Udostępnij za pośrednictwem

Debugowanie interakcyjne za pomocą programu Visual Studio Code

  • Artykuł

DOTYCZY: Zestaw SDK języka Python w wersji 1

Dowiedz się, jak interaktywnie debugować eksperymenty, potoki i wdrożenia usługi Azure Machine Learning przy użyciu programu Visual Studio Code (VS Code) i debugpy.

Lokalne uruchamianie i debugowanie eksperymentów

Użyj rozszerzenia Azure Machine Learning, aby zweryfikować, uruchomić i debugować eksperymenty uczenia maszynowego przed przesłaniem ich do chmury.

Wymagania wstępne

  • Rozszerzenie programu VS Code usługi Azure Machine Learning (wersja zapoznawcza). Aby uzyskać więcej informacji, zobacz Konfigurowanie rozszerzenia programu VS Code usługi Azure Machine Learning.

    Ważne

    Rozszerzenie programu VS Code usługi Azure Machine Learning domyślnie używa interfejsu wiersza polecenia (wersja 2). Instrukcje w tym przewodniku korzystają z interfejsu wiersza polecenia w wersji 1.0. Aby przełączyć się do interfejsu wiersza polecenia w wersji 1.0, ustaw azureML.CLI Compatibility Mode ustawienie w programie Visual Studio Code na 1.0wartość . Aby uzyskać więcej informacji na temat modyfikowania ustawień w programie Visual Studio Code, zobacz dokumentację ustawień użytkownika i obszaru roboczego.

    Ważne

    Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone.

    Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

  • Docker

  • Python 3

Lokalne debugowanie eksperymentu

Ważne

Przed uruchomieniem eksperymentu lokalnie upewnij się, że:

  • Platforma Docker jest uruchomiona.
  • Ustawienie azureML.CLI Compatibility Mode w programie Visual Studio Code jest ustawione na 1.0 określone w wymaganiach wstępnych

  1. W programie VS Code otwórz widok rozszerzenia usługi Azure Machine Learning.

  2. Rozwiń węzeł subskrypcji zawierający obszar roboczy. Jeśli jeszcze go nie masz, możesz utworzyć obszar roboczy usługi Azure Machine Learning przy użyciu rozszerzenia .

  3. Rozwiń węzeł obszaru roboczego.

  4. Kliknij prawym przyciskiem myszy węzeł Eksperymenty i wybierz polecenie Utwórz eksperyment. Po wyświetleniu monitu podaj nazwę eksperymentu.

  5. Rozwiń węzeł Eksperymenty, kliknij prawym przyciskiem myszy eksperyment, który chcesz uruchomić, a następnie wybierz polecenie Uruchom eksperyment.

  6. Z listy opcji wybierz pozycję Lokalnie.

  7. Używanie tylko po raz pierwszy w systemie Windows. Po wyświetleniu monitu o zezwolenie na udział plików wybierz pozycję Tak. Po włączeniu udziału plików umożliwia platformie Docker instalowanie katalogu zawierającego skrypt w kontenerze. Ponadto umożliwia platformie Docker przechowywanie dzienników i danych wyjściowych z przebiegu w katalogu tymczasowym w systemie.

  8. Wybierz pozycję Tak , aby debugować eksperyment. W przeciwnym razie wybierz Nie. Wybranie pozycji Nie spowoduje lokalnego uruchomienia eksperymentu bez dołączania do debugera.

  9. Wybierz pozycję Utwórz nową konfigurację uruchamiania, aby utworzyć konfigurację przebiegu. Konfiguracja przebiegu definiuje skrypt, który ma być uruchamiany, zależności i używane zestawy danych. Alternatywnie, jeśli masz go już, wybierz go z listy rozwijanej.

    1. Wybierz swoje środowisko. Możesz wybrać jedną z wyselekcjonowanych lub utworzonych przez usługę Azure Machine Learning.
    2. Podaj nazwę skryptu, który chcesz uruchomić. Ścieżka jest względna względem katalogu otwartego w programie VS Code.
    3. Wybierz, czy chcesz użyć zestawu danych usługi Azure Machine Learning, czy nie. Zestawy danych usługi Azure Machine Learning można utworzyć przy użyciu rozszerzenia .
    4. Debugpy jest wymagany w celu dołączenia debugera do kontenera uruchamiającego eksperyment. Aby dodać debugpy jako zależność, wybierz pozycję Dodaj debugowanie. W przeciwnym razie wybierz pozycję Pomiń. Nie można dodać debugpy jako zależność uruchamia eksperyment bez dołączania do debugera.
    5. W edytorze zostanie otwarty plik konfiguracji zawierający ustawienia konfiguracji uruchamiania. Jeśli ustawienia są zadowalające, wybierz pozycję Prześlij eksperyment. Alternatywnie możesz otworzyć paletę poleceń (Widok palety poleceń) na pasku menu i wprowadzić AzureML: Submit experiment polecenie w > polu tekstowym.

  10. Po przesłaniu eksperymentu zostanie utworzony obraz platformy Docker zawierający skrypt i konfiguracje określone w konfiguracji przebiegu.

    Po rozpoczęciu procesu kompilacji obrazu platformy Docker zawartość strumienia 60_control_log.txt plików do konsoli wyjściowej w programie VS Code.

    Uwaga

    Utworzenie obrazu platformy Docker po raz pierwszy może potrwać kilka minut.

  11. Po utworzeniu obrazu zostanie wyświetlony monit o uruchomienie debugera. Ustaw punkty przerwania w skrycie i wybierz pozycję Uruchom debuger , gdy wszystko będzie gotowe do rozpoczęcia debugowania. Spowoduje to dołączenie debugera programu VS Code do kontenera uruchamiającego eksperyment. Alternatywnie w rozszerzeniu Azure Machine Learning umieść wskaźnik myszy na węźle bieżącego przebiegu i wybierz ikonę odtwarzania, aby uruchomić debuger.

    Ważne

    Nie można mieć wielu sesji debugowania dla jednego eksperymentu. Można jednak debugować co najmniej dwa eksperymenty przy użyciu wielu wystąpień programu VS Code.

Na tym etapie powinno być możliwe przechodzenie i debugowanie kodu przy użyciu programu VS Code.

Jeśli w dowolnym momencie chcesz anulować przebieg, kliknij prawym przyciskiem myszy węzeł przebiegu i wybierz polecenie Anuluj uruchomienie.

Podobnie jak w przypadku przebiegów eksperymentów zdalnych, możesz rozwinąć węzeł uruchamiania, aby sprawdzić dzienniki i dane wyjściowe.

Napiwek

Obrazy platformy Docker korzystające z tych samych zależności zdefiniowanych w środowisku są ponownie używane między przebiegami. Jeśli jednak uruchomisz eksperyment przy użyciu nowego lub innego środowiska, zostanie utworzony nowy obraz. Ponieważ te obrazy są zapisywane w magazynie lokalnym, zaleca się usunięcie starych lub nieużywanych obrazów platformy Docker. Aby usunąć obrazy z systemu, użyj interfejsu wiersza polecenia platformy Docker lub rozszerzenia platformy Docker programu VS Code.

Debugowanie i rozwiązywanie problemów z potokami uczenia maszynowego

W niektórych przypadkach może być konieczne interaktywne debugowanie kodu języka Python używanego w potoku uczenia maszynowego. Za pomocą programu VS Code i debugpy można dołączyć go do kodu, gdy jest uruchamiany w środowisku trenowania.

Wymagania wstępne

  • Obszar roboczy usługi Azure Machine Learning skonfigurowany do korzystania z usługi Azure Virtual Network.

  • Potok usługi Azure Machine Learning, który używa skryptów języka Python w ramach kroków potoku. Na przykład pythonScriptStep.

  • Klaster obliczeniowy usługi Azure Machine Learning, który znajduje się w sieci wirtualnej i jest używany przez potok do trenowania.

  • Środowisko programistyczne, które znajduje się w sieci wirtualnej. Środowisko programistyczne może być jednym z następujących elementów:

    • Maszyna wirtualna platformy Azure w sieci wirtualnej
    • Wystąpienie obliczeniowe maszyny wirtualnej notesu w sieci wirtualnej
    • Maszyna kliencka z prywatną łącznością sieciową z siecią wirtualną przez sieć VPN lub za pośrednictwem usługi ExpressRoute.

Aby uzyskać więcej informacji na temat korzystania z usługi Azure Virtual Network z usługą Azure Machine Learning, zobacz Omówienie izolacji sieci wirtualnej i prywatności.

Napiwek

Chociaż możesz pracować z zasobami usługi Azure Machine Learning, które nie znajdują się za siecią wirtualną, zaleca się korzystanie z sieci wirtualnej.

Jak to działa

Kroki potoku uczenia maszynowego uruchamiają skrypty języka Python. Te skrypty są modyfikowane w celu wykonania następujących akcji:

  1. Zarejestruj adres IP hosta, na którym są uruchomione. Adres IP służy do łączenia debugera ze skryptem.

  2. Uruchom składnik debugowania debugowania i poczekaj na nawiązanie połączenia z debugerem.

  3. W środowisku projektowym można monitorować dzienniki utworzone przez proces trenowania, aby znaleźć adres IP, pod którym jest uruchomiony skrypt.

  4. Program VS Code informuje program VS Code o połączeniu debugera z plikiem launch.json .

  5. Dołączasz debuger i interakcyjnie przechodzisz przez skrypt.

Konfigurowanie skryptów języka Python

Aby włączyć debugowanie, wprowadź następujące zmiany w skryptach języka Python używanych przez kroki w potoku uczenia maszynowego:

  1. Dodaj następujące instrukcje importowania:

    import argparse
import os
import debugpy
import socket
from azureml.core import Run

  2. Dodaj następujące argumenty. Te argumenty umożliwiają włączenie debugera zgodnie z potrzebami i ustawienie limitu czasu dołączania debugera:

    parser.add_argument('--remote_debug', action='store_true')
parser.add_argument('--remote_debug_connection_timeout', type=int,
                    default=300,
                    help=f'Defines how much time the Azure Machine Learning compute target '
                    f'will await a connection from a debugger client (VSCODE).')
parser.add_argument('--remote_debug_client_ip', type=str,
                    help=f'Defines IP Address of VS Code client')
parser.add_argument('--remote_debug_port', type=int,
                    default=5678,
                    help=f'Defines Port of VS Code client')

  3. Dodaj następujące instrukcje . Te instrukcje ładują bieżący kontekst uruchamiania, aby można było zarejestrować adres IP węzła, na którym działa kod:

    global run
run = Run.get_context()

  4. Dodaj instrukcję if , która uruchamia debugpy i czeka na dołączenie debugera. Jeśli żaden debuger nie dołączy się przed przekroczeniem limitu czasu, skrypt będzie kontynuowany w normalny sposób. Pamiętaj, aby zastąpić HOST wartości i PORT jest funkcją listen własną.

    if args.remote_debug:
    print(f'Timeout for debug connection: {args.remote_debug_connection_timeout}')
    # Log the IP and port
    try:
        ip = args.remote_debug_client_ip
    except:
        print("Need to supply IP address for VS Code client")
    print(f'ip_address: {ip}')
    debugpy.listen(address=(ip, args.remote_debug_port))
    # Wait for the timeout for debugger to attach
    debugpy.wait_for_client()
    print(f'Debugger attached = {debugpy.is_client_connected()}')

Poniższy przykład w języku Python przedstawia prosty train.py plik, który umożliwia debugowanie:

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.

import argparse
import os
import debugpy
import socket
from azureml.core import Run

print("In train.py")
print("As a data scientist, this is where I use my training code.")

parser = argparse.ArgumentParser("train")

parser.add_argument("--input_data", type=str, help="input data")
parser.add_argument("--output_train", type=str, help="output_train directory")

# Argument check for remote debugging
parser.add_argument('--remote_debug', action='store_true')
parser.add_argument('--remote_debug_connection_timeout', type=int,
                    default=300,
                    help=f'Defines how much time the Azure Machine Learning compute target '
                    f'will await a connection from a debugger client (VSCODE).')
parser.add_argument('--remote_debug_client_ip', type=str,
                    help=f'Defines IP Address of VS Code client')
parser.add_argument('--remote_debug_port', type=int,
                    default=5678,
                    help=f'Defines Port of VS Code client')

# Get run object, so we can find and log the IP of the host instance
global run
run = Run.get_context()

args = parser.parse_args()

# Start debugger if remote_debug is enabled
if args.remote_debug:
    print(f'Timeout for debug connection: {args.remote_debug_connection_timeout}')
    # Log the IP and port
    ip = socket.gethostbyname(socket.gethostname())
    # try:
    #     ip = args.remote_debug_client_ip
    # except:
    #     print("Need to supply IP address for VS Code client")
    print(f'ip_address: {ip}')
    debugpy.listen(address=(ip, args.remote_debug_port))
    # Wait for the timeout for debugger to attach
    debugpy.wait_for_client()
    print(f'Debugger attached = {debugpy.is_client_connected()}')

print("Argument 1: %s" % args.input_data)
print("Argument 2: %s" % args.output_train)

if not (args.output_train is None):
    os.makedirs(args.output_train, exist_ok=True)
    print("%s created" % args.output_train)

Konfigurowanie potoku uczenia maszynowego

Aby udostępnić pakiety języka Python potrzebne do uruchomienia debugpy i pobrania kontekstu uruchamiania, utwórz środowisko i ustaw polecenie pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Zmień wersję zestawu SDK, aby odpowiadała używanej wersji. Poniższy fragment kodu pokazuje, jak utworzyć środowisko:

# Use a RunConfiguration to specify some additional requirements for this step.
from azureml.core.runconfig import RunConfiguration
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.runconfig import DEFAULT_CPU_IMAGE

# create a new runconfig object
run_config = RunConfiguration()

# enable Docker 
run_config.environment.docker.enabled = True

# set Docker base image to the default CPU-based image
run_config.environment.docker.base_image = DEFAULT_CPU_IMAGE

# use conda_dependencies.yml to create a conda environment in the Docker image for execution
run_config.environment.python.user_managed_dependencies = False

# specify CondaDependencies obj
run_config.environment.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'],
                                                                           pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>'])

W sekcji Konfigurowanie skryptów języka Python dodano nowe argumenty do skryptów używanych przez kroki potoku uczenia maszynowego. Poniższy fragment kodu pokazuje, jak używać tych argumentów do włączania debugowania dla składnika i ustawiania limitu czasu. Pokazano również, jak używać środowiska utworzonego wcześniej przez ustawienie :runconfig=run_config

# Use RunConfig from a pipeline step
step1 = PythonScriptStep(name="train_step",
                         script_name="train.py",
                         arguments=['--remote_debug', '--remote_debug_connection_timeout', 300,'--remote_debug_client_ip','<VS-CODE-CLIENT-IP>','--remote_debug_port',5678],
                         compute_target=aml_compute,
                         source_directory=source_directory,
                         runconfig=run_config,
                         allow_reuse=False)

Po uruchomieniu potoku każdy krok tworzy uruchomienie podrzędne. Jeśli debugowanie jest włączone, zmodyfikowane skrypty rejestruje informacje podobne do następującego tekstu w 70_driver_log.txt uruchomieniu podrzędnym:

Timeout for debug connection: 300
ip_address: 10.3.0.5

ip_address Zapisz wartość. Jest on używany w następnej sekcji.

Napiwek

Adres IP można również znaleźć w dziennikach uruchamiania dla podrzędnego przebiegu dla tego kroku potoku. Aby uzyskać więcej informacji na temat wyświetlania tych informacji, zobacz Monitorowanie przebiegów i metryk eksperymentu usługi Azure Machine Learning.

Konfigurowanie środowiska programowania

  1. Aby zainstalować debugpy w środowisku programistycznym programu VS Code, użyj następującego polecenia:

    python -m pip install --upgrade debugpy

    Aby uzyskać więcej informacji na temat używania debugpy z programem VS Code, zobacz Debugowanie zdalne.

  2. Aby skonfigurować program VS Code do komunikowania się z obliczeniami usługi Azure Machine Learning z uruchomionym debugerem, utwórz nową konfigurację debugowania:

    1. W programie VS Code wybierz menu Debuguj, a następnie wybierz pozycję Otwórz konfiguracje. Zostanie otwarty plik o nazwie launch.json .

    2. W pliku launch.json znajdź wiersz zawierający "configurations": [, a następnie wstaw następujący tekst. "host": "<IP-ADDRESS>" Zmień wpis na adres IP zwrócony w dziennikach z poprzedniej sekcji. Zmień wpis na "localRoot": "${workspaceFolder}/code/step" katalog lokalny zawierający kopię debugowanego skryptu:

      {
    "name": "Azure Machine Learning Compute: remote debug",
    "type": "python",
    "request": "attach",
    "port": 5678,
    "host": "<IP-ADDRESS>",
    "redirectOutput": true,
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}/code/step1",
            "remoteRoot": "."
        }
    ]
}

      Ważne

      Jeśli w sekcji konfiguracji znajdują się już inne wpisy, dodaj przecinek (,) po wstawionym kodzie.

      Napiwek

      Najlepszym rozwiązaniem, szczególnie w przypadku potoków, jest przechowywanie zasobów dla skryptów w oddzielnych katalogach, tak aby kod był odpowiedni tylko dla każdego z kroków. W tym przykładzie przykładowa localRoot wartość odwołuje się do /code/step1elementu .

      Jeśli debugujesz wiele skryptów, w różnych katalogach utwórz oddzielną sekcję konfiguracji dla każdego skryptu.

    3. Zapisz plik launch.json.

Łączenie debugera

  1. Otwórz program VS Code i otwórz lokalną kopię skryptu.

  2. Ustaw punkty przerwania, w których skrypt ma zostać zatrzymany po dołączeniu.

  3. Podczas uruchamiania skryptu przez proces podrzędny, który Timeout for debug connection jest wyświetlany w dziennikach, użyj klucza F5 lub wybierz pozycję Debuguj. Po wyświetleniu monitu wybierz usługę Azure Machine Learning Compute: konfiguracja zdalnego debugowania . Możesz również wybrać ikonę debugowania na pasku bocznym, wpis Azure Machine Learning: debugowanie zdalne z menu rozwijanego Debugowanie, a następnie użyć zielonej strzałki, aby dołączyć debuger.

    W tym momencie program VS Code łączy się z debugowaniem w węźle obliczeniowym i zatrzymuje się w ustawionym wcześniej punkcie przerwania. Teraz możesz przejść przez kod podczas jego uruchamiania, wyświetlać zmienne itp.

    Uwaga

    Jeśli w dzienniku zostanie wyświetlony wpis z informacją Debugger attached = False, upłynął limit czasu, a skrypt kontynuował bez debugera. Prześlij potok ponownie i połącz debuger po Timeout for debug connection komunikacie i przed upływem limitu czasu.

Debugowanie i rozwiązywanie problemów z wdrożeniami

W niektórych przypadkach może być konieczne interaktywne debugowanie kodu języka Python zawartego we wdrożeniu modelu. Na przykład jeśli skrypt wpisu kończy się niepowodzeniem i przyczyną nie można określić przez dodatkowe rejestrowanie. Za pomocą programu VS Code i debugpy można dołączyć go do kodu uruchomionego w kontenerze platformy Docker.

Napiwek

Jeśli używasz zarządzanych punktów końcowych i wdrożeń online lokalnie, zobacz Debugowanie zarządzanych punktów końcowych online lokalnie w programie Visual Studio Code (wersja zapoznawcza).

Ważne

Ta metoda debugowania nie działa w przypadku użycia Model.deploy() i LocalWebservice.deploy_configuration wdrożenia modelu lokalnie. Zamiast tego należy utworzyć obraz przy użyciu metody Model.package().

Lokalne wdrożenia usług internetowych wymagają działającej instalacji platformy Docker w systemie lokalnym. Aby uzyskać więcej informacji na temat korzystania z platformy Docker, zobacz dokumentację platformy Docker. Podczas pracy z wystąpieniami obliczeniowymi platforma Docker jest już zainstalowana.

Konfigurowanie środowiska programowania

  1. Aby zainstalować debugpy w lokalnym środowisku programistycznym programu VS Code, użyj następującego polecenia:

    python -m pip install --upgrade debugpy

    Aby uzyskać więcej informacji na temat używania debugpy z programem VS Code, zobacz Debugowanie zdalne.

  2. Aby skonfigurować program VS Code do komunikowania się z obrazem platformy Docker, utwórz nową konfigurację debugowania:

    1. W programie VS Code wybierz menu Debuguj w obszarze Zakres uruchamiania, a następnie wybierz pozycję Otwórz konfiguracje. Zostanie otwarty plik o nazwie launch.json .

    2. W pliku launch.json znajdź element "configurations" (wiersz zawierający "configurations": [) i wstaw następujący tekst po nim.

      {
    "name": "Azure Machine Learning Deployment: Docker Debug",
    "type": "python",
    "request": "attach",
    "connect": {
        "port": 5678,
        "host": "0.0.0.0",
    },
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}",
            "remoteRoot": "/var/azureml-app"
        }
    ]
}

      Po wstawieniu plik launch.json powinien być podobny do następującego:

      {
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/linkid=830387
"version": "0.2.0",
"configurations": [
    {
        "name": "Python: Current File",
        "type": "python",
        "request": "launch",
        "program": "${file}",
        "console": "integratedTerminal"
    },
    {
        "name": "Azure Machine Learning Deployment: Docker Debug",
        "type": "python",
        "request": "attach",
        "connect": {
            "port": 5678,
            "host": "0.0.0.0"
            },
        "pathMappings": [
            {
                "localRoot": "${workspaceFolder}",
                "remoteRoot": "/var/azureml-app"
            }
        ]
    }
    ]
}

      Ważne

      Jeśli w sekcji konfiguracji znajdują się już inne wpisy, dodaj przecinek ( , ) po wstawionym kodzie.

      Ta sekcja jest dołączana do kontenera platformy Docker przy użyciu portu 5678.

    3. Zapisz plik launch.json.

Tworzenie obrazu zawierającego debugpy

  1. Zmodyfikuj środowisko conda dla wdrożenia, aby obejmowało debugpy. W poniższym przykładzie pokazano, jak dodać go przy użyciu parametru pip_packages :

    from azureml.core.conda_dependencies import CondaDependencies 


# Usually a good idea to choose specific version numbers
# so training is made on same packages as scoring
myenv = CondaDependencies.create(conda_packages=['numpy==1.15.4',
                            'scikit-learn==0.19.1', 'pandas==0.23.4'],
                             pip_packages = ['azureml-defaults==1.0.83', 'debugpy'])

with open("myenv.yml","w") as f:
    f.write(myenv.serialize_to_string())

  2. Aby uruchomić debugpy i poczekać na połączenie po uruchomieniu score.py usługi, dodaj następujące polecenie na początku pliku:

    import debugpy
# Allows other computers to attach to debugpy on this IP address and port.
debugpy.listen(('0.0.0.0', 5678))
# Wait 30 seconds for a debugger to attach. If none attaches, the script continues as normal.
debugpy.wait_for_client()
print("Debugger attached...")

  3. Utwórz obraz na podstawie definicji środowiska i przeciągnij obraz do rejestru lokalnego.

    Uwaga

    W tym przykładzie przyjęto założenie, że ws wskazuje obszar roboczy usługi Azure Machine Learning i jest model to model, który jest wdrażany. Plik myenv.yml zawiera zależności conda utworzone w kroku 1.

    from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment


myenv = Environment.from_conda_specification(name="env", file_path="myenv.yml")
myenv.docker.base_image = None
myenv.docker.base_dockerfile = "FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest"
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)
package = Model.package(ws, [model], inference_config)
package.wait_for_creation(show_output=True)  # Or show_output=False to hide the Docker build logs.
package.pull()

    Po utworzeniu i pobraniu obrazu (proces ten może potrwać ponad 10 minut), ścieżka obrazu (w tym repozytorium, nazwa i tag, który w tym przypadku jest również jego skrótem) zostanie ostatecznie wyświetlona w komunikacie podobnym do następującego:

    Status: Downloaded newer image for myregistry.azurecr.io/package@sha256:<image-digest>

  4. Aby ułatwić pracę z obrazem lokalnie, możesz użyć następującego polecenia, aby dodać tag dla tego obrazu. Zastąp myimagepath ciąg w poniższym poleceniu wartością lokalizacji z poprzedniego kroku.

    docker tag myimagepath debug:1

    W pozostałych krokach możesz odwołać się do obrazu lokalnego jako debug:1 zamiast pełnej wartości ścieżki obrazu.

Debugowanie usługi

Napiwek

Jeśli ustawisz limit czasu dla połączenia debugpy w score.py pliku, musisz połączyć program VS Code z sesją debugowania przed wygaśnięciem limitu czasu. Uruchom program VS Code, otwórz lokalną kopię score.pyprogramu , ustaw punkt przerwania i przygotuj go do wykonania przed wykonaniem kroków w tej sekcji.

Aby uzyskać więcej informacji na temat debugowania i ustawiania punktów przerwania, zobacz Debugowanie.

  1. Aby uruchomić kontener platformy Docker przy użyciu obrazu, użyj następującego polecenia:

    docker run -it --name debug -p 8000:5001 -p 5678:5678 -v <my_local_path_to_score.py>:/var/azureml-app/score.py debug:1 /bin/bash

    To polecenie dołącza lokalnie score.py do niego w kontenerze. W związku z tym wszelkie zmiany wprowadzone w edytorze są automatycznie odzwierciedlane w kontenerze

  2. Aby uzyskać lepsze środowisko, możesz przejść do kontenera przy użyciu nowego interfejsu programu VS Code. Docker Wybierz zakres na pasku bocznym programu VS Code, znajdź utworzony lokalny kontener, w tej dokumentacji .debug:1 Kliknij prawym przyciskiem myszy ten kontener i wybierz pozycję "Attach Visual Studio Code", a następnie zostanie otwarty automatycznie nowy interfejs programu VS Code, a ten interfejs pokazuje wewnątrz utworzonego kontenera.

    Interfejs programu VS Code kontenera

  3. W kontenerze uruchom następujące polecenie w powłoce

    runsvdir /var/runit

    Następnie możesz zobaczyć następujące dane wyjściowe w powłoce wewnątrz kontenera:

    Dane wyjściowe konsoli uruchamiania kontenera

  4. Aby dołączyć program VS Code do debugowania wewnątrz kontenera, otwórz program VS Code i użyj klucza F5 lub wybierz pozycję Debuguj. Po wyświetleniu monitu wybierz pozycję Wdrożenie usługi Azure Machine Learning: Konfiguracja debugowania platformy Docker. Możesz również wybrać ikonę Uruchom rozszerzenie na pasku bocznym, wpis Wdrożenie usługi Azure Machine Learning: Debugowanie platformy Docker z menu rozwijanego Debugowanie , a następnie użyć zielonej strzałki, aby dołączyć debuger.

    Ikona debugowania, przycisk Rozpocznij debugowanie i selektor konfiguracji

    Po wybraniu zielonej strzałki i dołącz debugerze w interfejsie programu VS Code kontenera można zobaczyć kilka nowych informacji:

    Dołączone informacje debugera kontenera

    Ponadto w głównym interfejsie programu VS Code widoczne są następujące elementy:

    Punkt przerwania programu VS Code w score.py

A teraz lokalny score.py , który jest dołączony do kontenera, został już zatrzymany w punktach przerwania, w których ustawiono. W tym momencie program VS Code łączy się z debugowaniem wewnątrz kontenera platformy Docker i zatrzymuje kontener platformy Docker w ustawionym wcześniej punkcie przerwania. Teraz możesz przejść przez kod podczas jego uruchamiania, wyświetlać zmienne itp.

Aby uzyskać więcej informacji na temat debugowania języka Python przy użyciu programu VS Code, zobacz Debugowanie kodu w języku Python.

Zatrzymywanie kontenera

Aby zatrzymać kontener, użyj następującego polecenia:

docker stop debug

Następne kroki

Po skonfigurowaniu programu VS Code Remote możesz użyć wystąpienia obliczeniowego jako zdalnego przetwarzania z programu VS Code, aby interaktywnie debugować kod.

Dowiedz się więcej na temat rozwiązywania problemów: