Interaktivní ladění s využitím Visual Studio Code

  • Článek

PLATÍ PRO:Sada Python SDK azureml v1

Zjistěte, jak interaktivně ladit experimenty, kanály a nasazení služby Azure Machine Learning pomocí editoru Visual Studio Code (VS Code) a debugpy.

Místní spouštění a ladění experimentů

Pomocí rozšíření Azure Machine Learning můžete ověřovat, spouštět a ladit experimenty strojového učení před jejich odesláním do cloudu.

Požadavky

Místní ladění experimentu

Důležité

Před místním spuštěním experimentu se ujistěte, že:

  • Docker je spuštěný.
  • Nastavení azureML.CLI Compatibility Mode v editoru Visual Studio Code je nastavené na 1.0 hodnotu , jak je uvedeno v požadavcích.

  1. Ve VS Code otevřete zobrazení rozšíření Azure Machine Learning.

  2. Rozbalte uzel předplatného obsahující váš pracovní prostor. Pokud ho ještě nemáte, můžete pomocí rozšíření vytvořit pracovní prostor Azure Machine Learning .

  3. Rozbalte uzel pracovního prostoru.

  4. Klikněte pravým tlačítkem na uzel Experimenty a vyberte Vytvořit experiment. Po zobrazení výzvy zadejte název experimentu.

  5. Rozbalte uzel Experimenty , klikněte pravým tlačítkem myši na experiment, který chcete spustit, a vyberte Spustit experiment.

  6. V seznamu možností vyberte Místně.

  7. První použití pouze ve Windows. Po zobrazení výzvy k povolení sdílené složky vyberte Ano. Když povolíte sdílenou složku, umožní to Dockeru připojit ke kontejneru adresář obsahující váš skript. Kromě toho také dockeru umožňuje ukládat protokoly a výstupy z vašeho spuštění do dočasného adresáře ve vašem systému.

  8. Pokud chcete experiment ladit, vyberte Ano . Jinak vyberte No (Ne). Výběrem možnosti Ne spustíte experiment místně bez připojení k ladicím programu.

  9. Výběrem možnosti Create new Run Configuration (Vytvořit novou konfiguraci spuštění ) vytvořte konfiguraci spuštění. Konfigurace spuštění definuje skript, který chcete spustit, závislosti a použité datové sady. Pokud už ho máte, můžete ho také vybrat z rozevíracího seznamu.

    1. Zvolte své prostředí. Můžete si vybrat z libovolného kurátora služby Azure Machine Learning nebo si vytvořit vlastní.
    2. Zadejte název skriptu, který chcete spustit. Cesta je relativní k adresáři otevřenému v editoru VS Code.
    3. Zvolte, jestli chcete použít datovou sadu Azure Machine Learning, nebo ne. Pomocí rozšíření můžete vytvářet datové sady Azure Machine Learning .
    4. Nástroj Debugpy se vyžaduje k připojení ladicího programu ke kontejneru, který spouští váš experiment. Pokud chcete přidat debugpy jako závislost, vyberte Přidat debugpy. V opačném případě vyberte Přeskočit. Nepřidání debugpy jako závislosti spustí experiment bez připojení k ladicím programu.
    5. V editoru se otevře konfigurační soubor obsahující nastavení konfigurace spuštění. Pokud jste s nastavením spokojení, vyberte Odeslat experiment. Případně můžete otevřít paletu příkazů (Zobrazit > paletu příkazů) z řádku nabídek a zadat AzureML: Submit experiment příkaz do textového pole.

  10. Po odeslání experimentu se vytvoří image Dockeru obsahující váš skript a konfigurace zadané v konfiguraci spuštění.

    Po zahájení procesu sestavení image Dockeru 60_control_log.txt se obsah souboru streamuje do výstupní konzoly v editoru VS Code.

    Poznámka

    První vytvoření image Dockeru může trvat několik minut.

  11. Po sestavení image se zobrazí výzva ke spuštění ladicího programu. Nastavte zarážky ve skriptu a až budete připraveni spustit ladění, vyberte Spustit ladicí program . Tím se ladicí program VS Code připojí ke kontejneru, ve kterém experiment běží. Případně v rozšíření Azure Machine Learning najeďte myší na uzel aktuálního spuštění a výběrem ikony přehrávání spusťte ladicí program.

    Důležité

    Pro jeden experiment nelze mít více ladicích relací. Můžete však ladit dva nebo více experimentů pomocí více instancí VS Code.

V tuto chvíli byste měli být schopni krokovat a ladit kód pomocí nástroje VS Code.

Pokud chcete v určitém okamžiku spuštění zrušit, klikněte pravým tlačítkem na uzel spuštění a vyberte Zrušit spuštění.

Podobně jako u vzdálených spuštění experimentů můžete rozbalit uzel spuštění a zkontrolovat protokoly a výstupy.

Tip

Image Dockeru, které používají stejné závislosti definované ve vašem prostředí, se mezi spuštěními opakovaně používají. Pokud však spustíte experiment v novém nebo jiném prostředí, vytvoří se nová image. Vzhledem k tomu, že se tyto image ukládají do místního úložiště, doporučujeme odebrat staré nebo nepoužívané image Dockeru. K odebrání imagí ze systému použijte rozhraní příkazového řádku Dockeru nebo rozšíření Dockeru VS Code.

Ladění kanálů strojového učení a řešení souvisejících potíží

V některých případech možná budete muset interaktivně ladit kód Pythonu použitý v kanálu ML. Pomocí VS Code a debugpy se můžete připojit ke kódu, který běží v trénovacím prostředí.

Požadavky

  • Pracovní prostor Služby Azure Machine Learning, který je nakonfigurovaný tak, aby používal Virtual Network Azure.

  • Kanál služby Azure Machine Learning, který jako součást kroků kanálu používá skripty Pythonu. Například PythonScriptStep.

  • Výpočetní cluster Azure Machine Learning, který je ve virtuální síti a kanál ho používá k trénování.

  • Vývojové prostředí, které je ve virtuální síti. Vývojové prostředí může být jedno z následujících:

    • Virtuální počítač Azure ve virtuální síti
    • Výpočetní instance poznámkového bloku virtuálního počítače ve virtuální síti
    • Klientský počítač, který má k virtuální síti připojení privátní sítě, a to buď přes SÍŤ VPN, nebo přes ExpressRoute.

Další informace o používání azure Virtual Network se službou Azure Machine Learning najdete v tématu Přehled izolace virtuální sítě a ochrany osobních údajů.

Tip

I když můžete pracovat s prostředky služby Azure Machine Learning, které nejsou za virtuální sítí, doporučuje se použít virtuální síť.

Jak to funguje

Kroky kanálu ML spouštějí skripty Pythonu. Tyto skripty se upraví tak, aby prováděly následující akce:

  1. Protokolujte IP adresu hostitele, na kterém běží. Ip adresu použijete k připojení ladicího programu ke skriptu.

  2. Spusťte ladicí komponentu a počkejte, až se ladicí program připojí.

  3. Z vývojového prostředí monitorujete protokoly vytvořené procesem trénování, abyste našli IP adresu, na které je skript spuštěný.

  4. VS Code sdělíte IP adresu, ke které se má ladicí program připojit, pomocí launch.json souboru.

  5. Připojíte ladicí program a interaktivně procházíte skriptem.

Konfigurace skriptů Pythonu

Pokud chcete povolit ladění, proveďte následující změny skriptů Pythonu používaných kroky v kanálu ML:

  1. Přidejte následující příkazy importu:

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

  2. Přidejte následující argumenty. Tyto argumenty umožňují povolit ladicí program podle potřeby a nastavit časový limit pro připojení ladicího programu:

    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. Přidejte následující příkazy. Tyto příkazy načtou aktuální kontext spuštění, abyste mohli protokolovat IP adresu uzlu, na kterém je kód spuštěný:

    global run
run = Run.get_context()

  4. if Přidejte příkaz, který spustí ladění a čeká na připojení ladicího programu. Pokud se před vypršením časového limitu nepřipojí žádný ladicí program, skript bude pokračovat jako obvykle. Nezapomeňte nahradit HOST hodnoty a PORT funkce listen vlastními.

    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()}')

Následující příklad Pythonu ukazuje jednoduchý train.py soubor, který umožňuje ladění:

# 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)

Konfigurace kanálu ML

Pokud chcete poskytnout balíčky Pythonu potřebné ke spuštění ladění a získání kontextu spuštění, vytvořte prostředí a nastavte pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Změňte verzi sady SDK tak, aby odpovídala té, kterou používáte. Následující fragment kódu ukazuje, jak vytvořit prostředí:

# 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>'])

V části Konfigurace skriptů Pythonu se do skriptů používaných kroky kanálu ML přidaly nové argumenty. Následující fragment kódu ukazuje, jak pomocí těchto argumentů povolit ladění pro komponentu a nastavit časový limit. Také ukazuje, jak používat prostředí vytvořené dříve nastavením 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)

Při spuštění kanálu každý krok vytvoří podřízené spuštění. Pokud je ladění povolené, upravený skript zaznamená informace podobné následujícímu textu v 70_driver_log.txt podřízené spuštění:

Timeout for debug connection: 300
ip_address: 10.3.0.5

ip_address Uložte hodnotu. Použije se v další části.

Tip

Můžete také najít IP adresu z protokolů spuštění podřízeného spuštění pro tento krok kanálu. Další informace o zobrazení těchto informací najdete v tématu Monitorování spuštění a metrik experimentu Azure Machine Learning.

Konfigurace vývojového prostředí

  1. Pokud chcete nainstalovat debugpy do vývojového prostředí VS Code, použijte následující příkaz:

    python -m pip install --upgrade debugpy

    Další informace o použití debugpy s nástrojem VS Code najdete v tématu Vzdálené ladění.

  2. Pokud chcete nakonfigurovat VS Code pro komunikaci s výpočetním prostředím Azure Machine Learning, na kterém běží ladicí program, vytvořte novou konfiguraci ladění:

    1. V nástroji VS Code vyberte nabídku Debug (Ladit) a pak vyberte Open configurations (Otevřít konfigurace). Otevře se soubor s názvem launch.json .

    2. V souboru launch.json najděte řádek, který obsahuje "configurations": [, a vložte za něj následující text. "host": "<IP-ADDRESS>" Změňte položku na IP adresu vrácenou v protokolech z předchozí části. "localRoot": "${workspaceFolder}/code/step" Změňte položku na místní adresář, který obsahuje kopii laděného skriptu:

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

      Důležité

      Pokud již v části konfigurace existují další položky, přidejte za vložený kód čárku (,).

      Tip

      Osvědčeným postupem, zejména pro kanály, je uchovávat prostředky pro skripty v samostatných adresářích, aby byl kód relevantní pouze pro každý z kroků. V tomto příkladu ukázková localRoot hodnota odkazuje na /code/step1.

      Pokud ladíte více skriptů, vytvořte v různých adresářích samostatný oddíl konfigurace pro každý skript.

    3. Uložte soubor launch.json .

Připojení ladicího programu

  1. Otevřete VS Code a otevřete místní kopii skriptu.

  2. Nastavte zarážky tam, kde se má skript po připojení zastavit.

  3. Zatímco podřízený proces spouští skript a Timeout for debug connection zobrazí se v protokolech, použijte klávesu F5 nebo vyberte Ladit. Po zobrazení výzvy vyberte konfiguraci Azure Machine Learning Compute: vzdálené ladění . Můžete také vybrat ikonu ladění na bočním panelu, položku Azure Machine Learning: vzdálené ladění z rozevírací nabídky Ladění a pak pomocí zelené šipky připojit ladicí program.

    V tomto okamžiku se VS Code připojí k ladění na výpočetním uzlu a zastaví se u zarážky, kterou jste nastavili dříve. Teď můžete procházet kód při jeho spuštění, zobrazit proměnné atd.

    Poznámka

    Pokud se v protokolu zobrazí položka s informací Debugger attached = False, vypršel časový limit a skript pokračoval bez ladicího programu. Znovu odešlete kanál a připojte ladicí program po Timeout for debug connection zprávě a před vypršením časového limitu.

Ladění nasazení a řešení potíží

V některých případech může být potřeba interaktivně ladit kód Pythonu obsažený v nasazení modelu. Například pokud vstupní skript selhává a důvod nelze určit dodatečným protokolováním. Pomocí VS Code a debugpy se můžete připojit ke kódu spuštěného v kontejneru Dockeru.

Tip

Pokud používáte spravované online koncové body a nasazení místně, přečtěte si téma Ladění spravovaných online koncových bodů místně v editoru Visual Studio Code (Preview).

Důležité

Tato metoda ladění nefunguje při použití Model.deploy() a LocalWebservice.deploy_configuration k místnímu nasazení modelu. Místo toho musíte vytvořit image pomocí metody Model.package().

Nasazení místní webové služby vyžadují v místním systému funkční instalaci Dockeru. Další informace o používání Dockeru najdete v dokumentaci k Dockeru. Při práci s výpočetními instancemi je Docker už nainstalovaný.

Konfigurace vývojového prostředí

  1. Pokud chcete nainstalovat debugpy do místního vývojového prostředí VS Code, použijte následující příkaz:

    python -m pip install --upgrade debugpy

    Další informace o použití debugpy s nástrojem VS Code najdete v tématu Vzdálené ladění.

  2. Pokud chcete nakonfigurovat VS Code pro komunikaci s imagí Dockeru, vytvořte novou konfiguraci ladění:

    1. V nástroji VS Code vyberte nabídku Debug (Ladění ) v části Run extention ( Spustit rozšíření) a pak vyberte Open configurations (Otevřít konfigurace). Otevře se soubor s názvem launch.json .

    2. V souboru launch.json vyhledejte položku "configurations" (řádek, který obsahuje "configurations": [) a vložte za ni následující text.

      {
    "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 vložení by měl být soubor launch.json podobný následujícímu:

      {
// 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"
            }
        ]
    }
    ]
}

      Důležité

      Pokud již v části konfigurace existují další položky, přidejte za vložený kód čárku ( , ).

      Tato část se připojí ke kontejneru Dockeru pomocí portu 5678.

    3. Uložte soubor launch.json .

Vytvoření image, která obsahuje ladění

  1. Upravte prostředí Conda pro vaše nasazení tak, aby zahrnovalo ladění. Následující příklad ukazuje jeho přidání pomocí 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. Pokud chcete spustit ladění a čekat na připojení při spuštění služby, přidejte na začátek score.py souboru následující:

    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. Vytvořte image založenou na definici prostředí a natáhněte image do místního registru.

    Poznámka

    Tento příklad předpokládá, že ws odkazuje na váš pracovní prostor Služby Azure Machine Learning a to je model, který model se nasazuje. Soubor myenv.yml obsahuje závislosti conda vytvořené v 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 vytvoření a stažení image (tento proces může trvat déle než 10 minut) se cesta k obrázku (včetně úložiště, názvu a značky, která je v tomto případě také její hodnotou hash) nakonec zobrazí ve zprávě podobné následující:

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

  4. Pokud chcete usnadnit místní práci s imagí, můžete k přidání značky pro tuto image použít následující příkaz. V následujícím příkazu nahraďte myimagepath hodnotou umístění z předchozího kroku.

    docker tag myimagepath debug:1

    Ve zbývajících krocích můžete místo hodnoty úplné cesty k obrázku odkazovat na místní image debug:1 .

Ladění služby

Tip

Pokud v score.py souboru nastavíte časový limit pro připojení debugpy, musíte před vypršením časového limitu připojit nástroj VS Code k ladicí relaci. Spusťte VS Code, otevřete místní kopii nástroje score.py, nastavte zarážku a před použitím kroků v této části ji připravte k použití.

Další informace o ladění a nastavení zarážek najdete v tématu Ladění.

  1. Pokud chcete spustit kontejner Dockeru pomocí image, použijte následující příkaz:

    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

    Tento příkaz připojí místní score.py příkaz k příkazu v kontejneru. Proto se všechny změny provedené v editoru automaticky projeví v kontejneru.

  2. Pro lepší prostředí můžete do kontejneru přejít s novým rozhraním VS Code. Na bočním panelu Docker nástroje VS Code vyberte rozsah, vyhledejte vytvořený místní kontejner a v této dokumentaci najdete jeho debug:1. Klikněte pravým tlačítkem na tento kontejner a vyberte "Attach Visual Studio Code", pak se automaticky otevře nové rozhraní VS Code a toto rozhraní zobrazí uvnitř vytvořeného kontejneru.

    Rozhraní VS Code pro kontejner

  3. V kontejneru spusťte v prostředí následující příkaz.

    runsvdir /var/runit

    V prostředí uvnitř kontejneru pak uvidíte následující výstup:

    Výstup konzoly spuštění kontejneru

  4. Pokud chcete připojit VS Code k ladění uvnitř kontejneru, otevřete VS Code a použijte klávesu F5 nebo vyberte Ladit. Po zobrazení výzvy vyberte nasazení Azure Machine Learning: Konfigurace ladění Dockeru . Můžete také vybrat ikonu Rozsah spuštění na bočním panelu, položku Azure Machine Learning Deployment: Docker Debug (Nasazení Azure Machine Learning: Ladění Dockeru ) z rozevírací nabídky Debug (Ladění) a pak pomocí zelené šipky připojit ladicí program.

    Ikona ladění, tlačítko Spustit ladění a selektor konfigurace

    Po výběru zelené šipky a připojení ladicího programu se v rozhraní VS Code kontejneru zobrazí některé nové informace:

    Připojené informace o ladicím programu kontejneru

    V hlavním rozhraní editoru VS Code můžete také vidět následující:

    Zarážka VS Code v score.py

A teď se místní score.py prostředí, které je připojené ke kontejneru, už zastavilo na zarážce, kde jste nastavili. V tomto okamžiku se VS Code připojí k ladění uvnitř kontejneru Dockeru a zastaví kontejner Dockeru na zarážce, kterou jste nastavili dříve. Teď můžete procházet kód při jeho spuštění, zobrazit proměnné atd.

Další informace o použití nástroje VS Code k ladění Pythonu najdete v tématu Ladění kódu Pythonu.

Zastavení kontejneru

K zastavení kontejneru použijte následující příkaz:

docker stop debug

Další kroky

Teď, když jste nastavili VS Code Remote, můžete použít výpočetní instanci jako vzdálený výpočetní výkon z VS Code k interaktivnímu ladění kódu.

Další informace o řešení potíží: