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 Visual Studio Code (VS Code) i debugpy.

Uruchamianie i debugowanie eksperymentów lokalnie

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

Wymagania wstępne

Lokalne debugowanie eksperymentu

Ważne

Przed uruchomieniem eksperymentu lokalnie upewnij się, że:

  • Platforma Docker jest uruchomiona.
  • Ustawienie azureML.CLI Compatibility Mode w Visual Studio Code jest ustawione zgodnie 1.0 z wymaganiami wstępnymi

  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 pozycję 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 pozycję Uruchom eksperyment.

  6. Z listy opcji wybierz pozycję Lokalnie.

  7. Użycie 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 również platformie Docker przechowywanie dzienników i danych wyjściowych z uruchomienia w katalogu tymczasowym w systemie.

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

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

    1. Wybierz środowisko. Możesz wybrać dowolną z wyselekcjonowanych lub utworzonych własnych 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 debugpy. W przeciwnym razie wybierz pozycję Pomiń. Nie dodaje debugpy jako zależności uruchamia eksperyment bez dołączania do debugera.
    5. Plik konfiguracji zawierający ustawienia konfiguracji uruchamiania zostanie otwarty w edytorze. Jeśli ustawienia są zadowalające, wybierz pozycję Prześlij eksperyment. Możesz też otworzyć paletę poleceń (Wyświetl > paletę poleceń) z paska 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ść 60_control_log.txt strumienia 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ę Rozpocznij 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 usługi Azure Machine Learning umieść wskaźnik myszy na węźle dla 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 wykonanie kroków i debugowanie kodu przy użyciu programu VS Code.

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

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

Porada

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żytego w potoku usługi ML. Za pomocą programu VS Code i debugpy można dołączyć go do kodu, gdy jest uruchamiany w środowisku szkoleniowym.

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, która ma prywatną łączność 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.

Porada

Chociaż możesz pracować z zasobami usługi Azure Machine Learning, które nie znajdują się za siecią wirtualną, zaleca się użycie 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 połączenie debugera.

  3. W środowisku deweloperów można monitorować dzienniki utworzone przez proces trenowania, aby znaleźć adres IP, na którym działa skrypt.

  4. Za pomocą pliku należy poinformować program VS Code o adresie IP umożliwiającym połączenie debugera z plikiem launch.json .

  5. Debuger jest dołączany i interaktywnie przechodzi 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 uruchomienia, 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 debuger nie dołączy przed przekroczeniem limitu czasu, skrypt będzie kontynuowany jako normalny. Pamiętaj, aby zastąpić HOST wartości i PORT jest listen funkcją 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 języka 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 pasować do 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 nowe argumenty zostały dodane 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 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, zmodyfikowany skrypt 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.

Porada

Adres IP można również znaleźć w dziennikach uruchamiania dla podrzędnego uruchomienia dla tego kroku potoku. Aby uzyskać więcej informacji na temat wyświetlania tych informacji, zobacz Monitorowanie przebiegów eksperymentów i metryk 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 korzystania z 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": [ciąg , a następnie wstaw następujący tekst. "host": "<IP-ADDRESS>" Zmień wpis na adres IP zwrócony w dziennikach z poprzedniej sekcji. "localRoot": "${workspaceFolder}/code/step" Zmień wpis na 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.

      Porada

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

      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. Gdy proces podrzędny uruchamia skrypt i Timeout for debug connection jest wyświetlany w dziennikach, użyj klucza F5 lub wybierz pozycję Debuguj. Po wyświetleniu monitu wybierz pozycję Azure Machine Learning Compute: konfiguracja debugowania zdalnego . 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 debugpy w węźle obliczeniowym i zatrzymuje się w ustawionym wcześniej punkcie przerwania. Teraz możesz przechodzić przez kod podczas 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 będzie kontynuowany bez debugera. Prześlij potok ponownie i połącz debuger po Timeout for debug connection komunikacie i przed wygaśnięciem 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. Jeśli na przykład 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ć do kodu uruchomionego w kontenerze platformy Docker.

Porada

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 Visual Studio Code (wersja zapoznawcza).

Ważne

Ta metoda debugowania nie działa podczas używania Model.deploy() i LocalWebservice.deploy_configuration wdrażania modelu lokalnie. Zamiast tego należy utworzyć obraz przy użyciu metody Model.package().

Lokalne wdrożenia usługi sieci Web 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 korzystania z 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 usługi, dodaj następujące polecenie do góry score.py 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 pobierz 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 model jest 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 (ten proces może potrwać więcej niż 10 minut), ścieżka obrazu (obejmuje repozytorium, nazwę 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żna odwoływać się do obrazu debug:1 lokalnego zamiast pełnej wartości ścieżki obrazu.

Debugowanie usługi

Porada

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ę programu score.py, ustaw punkt przerwania i przygotuj go do wykonania przed wykonaniem kroków opisanych 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 score.py dane lokalnie do kontenera. 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 za pomocą nowego interfejsu programu VS Code. Docker Wybierz zakres na pasku bocznym programu VS Code, znajdź utworzony kontener lokalny w tej dokumentacjidebug:1. Kliknij prawym przyciskiem myszy ten kontener i wybierz "Attach Visual Studio Code"polecenie , a następnie nowy interfejs programu VS Code zostanie otwarty automatycznie, a ten interfejs pokazuje wewnątrz utworzonego kontenera.

    Interfejs programu VS Code kontenera

  3. Wewnątrz kontenera uruchom następujące polecenie w powłoce

    runsvdir /var/runit

    Następnie możesz wyświetlić 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 debugpy 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 zakres 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łączeniu debugera w interfejsie programu VS Code kontenera można wyświetlić kilka nowych informacji:

    Dołączone informacje o debugerze 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 debugpy wewnątrz kontenera platformy Docker i zatrzymuje kontener platformy Docker w ustawionym wcześniej punkcie przerwania. Teraz możesz przechodzić przez kod podczas 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 języka Python.

Zatrzymywanie kontenera

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

docker stop debug

Następne kroki

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

Dowiedz się więcej o rozwiązywaniu problemów: