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

Článek
10/16/2024

Naučte se interaktivně ladit experimenty, kanály a nasazení služby Azure Machine Learning pomocí editoru Visual Studio Code (VS Code) a ladění.

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

Rozšíření Azure Machine Learning slouží k ověření, spuštění a ladění experimentů strojového učení před jejich odesláním do cloudu.

Požadavky

Rozšíření Azure Machine Learning VS Code (Preview) Další informace najdete v tématu Nastavení rozšíření Azure Machine Learning VS Code.

Důležité

Rozšíření Azure Machine Learning VS Code používá ve výchozím nastavení rozhraní příkazového řádku (v2). Pokyny v této příručce používají rozhraní příkazového řádku 1.0. Pokud chcete přepnout na rozhraní příkazového řádku 1.0, nastavte azureML.CLI Compatibility Mode nastavení v editoru Visual Studio Code na 1.0hodnotu . Další informace o úpravě nastavení v editoru Visual Studio Code najdete v dokumentaci k nastavení uživatele a pracovního prostoru.

Důležité

Tato funkce je v současné době ve verzi Public Preview. Tato verze Preview je poskytována bez smlouvy o úrovni služeb a nedoporučujeme ji pro produkční úlohy. Některé funkce se nemusí podporovat nebo mohou mít omezené možnosti.

Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.
Docker
- Docker Desktop pro Mac a Windows
- Docker Engine pro Linux.
  
  Poznámka:
  
  Ve Windows nezapomeňte Docker nakonfigurovat tak, aby používal kontejnery Linuxu.
  
  Tip
  
  Pro Windows se sice nedoporučuje používat Docker s Subsystém Windows pro Linux (WSL) 2.
Python 3

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 nastaveno tak 1.0 , jak je uvedeno v požadavcích.

Ve VS Code otevřete zobrazení rozšíření Azure Machine Learning.
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 Služby Azure Machine Learning.
Rozbalte uzel pracovního prostoru.
Klikněte pravým tlačítkem myši na uzel Experimenty a vyberte Vytvořit experiment. Po zobrazení výzvy zadejte název experimentu.
Rozbalte uzel Experimenty, klikněte pravým tlačítkem myši na experiment, který chcete spustit, a vyberte Spustit experiment.
V seznamu možností vyberte Místně.
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í Dockeru připojit adresář obsahující váš skript do kontejneru. Kromě toho umožňuje Dockeru ukládat protokoly a výstupy z vašeho spuštění do dočasného adresáře ve vašem systému.
Vyberte Ano , chcete-li experiment ladit. Jinak vyberte Ne. Výběrem nespustíte experiment místně bez připojení k ladicím programu.
Vyberte Vytvořit novou konfiguraci spuštění a vytvořte konfiguraci spuštění. Konfigurace spuštění definuje skript, který chcete spustit, závislosti a použité datové sady. Pokud ho už máte, můžete ho také vybrat z rozevíracího seznamu.
1. Zvolte své prostředí. Můžete si vybrat některou z kurátorovaných služeb Azure Machine Learning nebo si vytvořit vlastní.
2. Zadejte název skriptu, který chcete spustit. Cesta je relativní vzhledem k adresáři otevřenému ve VS Code.
3. Zvolte, jestli chcete použít datovou sadu Azure Machine Learning, nebo ne. Datové sady Azure Machine Learning můžete vytvořit pomocí rozšíření.
4. K připojení ladicího programu ke kontejneru spuštěného experimentu se vyžaduje ladění. Pokud chcete přidat ladicí program jako závislost, vyberte Přidat ladicí program. V opačném případě vyberte Přeskočit. Nepřidávejte ladicí program jako závislost 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ě otevřete paletu příkazů (Zobrazit paletu příkazů) z řádku nabídek a do textového pole zadejte AzureML: Submit experiment > příkaz.
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 se obsah streamu 60_control_log.txt souboru do výstupní konzoly v editoru VS Code.

Poznámka:

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

Důležité

Pro jeden experiment nemůžete mít více ladicích relací. Pomocí několika instancí VS Code však můžete ladit dva nebo více experimentů.

V tomto okamžiku byste měli být schopni krokovat a ladit kód pomocí VS Code.

Pokud chcete spuštění kdykoli zrušit, klikněte pravým tlačítkem myši na uzel spuštění a vyberte Zrušit spuštění.

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

Tip

Mezi spuštěními se znovu používají image Dockeru, které používají stejné závislosti definované ve vašem prostředí. Pokud však spustíte experiment pomocí nového nebo jiného 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í z vašeho systému použijte rozhraní příkazového řádku Dockeru nebo rozšíření VS Code Docker.

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 ladění můžete k kódu připojit, jak běží v trénovacím prostředí.

Požadavky

Pracovní prostor Azure Machine Learning, který je nakonfigurovaný tak, aby používal službu Azure Virtual Network.
Kanál Služby Azure Machine Learning, který v rámci 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 používá ho kanál pro 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 virtuálního počítače poznámkového bloku ve virtuální síti
- Klientský počítač, který má privátní síťové připojení k virtuální síti, a to buď prostřednictvím sítě VPN, nebo přes ExpressRoute.

Další informace o používání služby 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čujeme použít virtuální síť.

Jak to funguje

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

Protokolujte IP adresu hostitele, na kterém běží. Ip adresu použijete k připojení ladicího programu ke skriptu.
Spusťte ladicí komponentu ladění a počkejte, až se ladicí program připojí.
Ve vývojovém prostředí monitorujete protokoly vytvořené procesem trénování a vyhledáte IP adresu, ve které je skript spuštěný.
VS Code sdělíte IP adrese, aby ladicí program připojil pomocí launch.json souboru.
Ladicí program připojíte a interaktivně projdete 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:

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

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

Přidejte následující argumenty. Tyto argumenty umožňují podle potřeby povolit ladicí program 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')

Přidejte následující příkazy . Tyto příkazy načtou kontext aktuálního spuštění, abyste mohli protokolovat IP adresu uzlu, na kterém kód běží:
```
global run
run = Run.get_context()
```

Přidejte příkaz if , 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 normálně. Nezapomeňte nahradit HOST a PORT hodnoty je listen funkce vlastní.

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 verzi sady SDK, 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 byly do skriptů používaných kroky kanálu ML přidány nové argumenty. Následující fragment kódu ukazuje, jak tyto argumenty použít k povolení ladění komponenty a nastavení časového limitu. Ukazuje také, jak použít 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)

Když se kanál spustí, každý krok vytvoří podřízené spuštění. Pokud je povoleno ladění, upravený skript protokoluje informace podobné následujícímu textu v podřízené 70_driver_log.txt spuštění:

Timeout for debug connection: 300
ip_address: 10.3.0.5

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

Tip

IP adresu najdete také v protokolech spuštění pro podřízené 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í

Pokud chcete do vývojového prostředí VS Code nainstalovat ladění, použijte následující příkaz:
```
python -m pip install --upgrade debugpy
```
Další informace o použití ladění s VS Code naleznete v tématu Vzdálené ladění.
Pokud chcete nakonfigurovat VS Code pro komunikaci s výpočetním prostředím služby Azure Machine Learning, který spouští ladicí program, vytvořte novou konfiguraci ladění:
1. V editoru VS Code vyberte nabídku Ladění a pak vyberte 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 už v oddílu 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 zachovat prostředky pro skripty v samostatných adresářích, aby byl kód relevantní pouze pro každý z kroků. V tomto příkladu odkazuje na /code/step1ukázkové localRoot hodnoty .
  
  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

Otevřete VS Code a otevřete místní kopii skriptu.
Nastavte zarážky, u kterých chcete, aby se skript po připojení zastavil.
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 výpočetní prostředí Azure Machine Learning: konfigurace vzdáleného ladění . Můžete také vybrat ikonu ladění na bočním panelu, Azure Machine Learning: položka vzdáleného ladění z rozevírací nabídky Ladění a pak pomocí zelené šipky připojit ladicí program.

V tuto chvíli se VS Code připojí k ladění na výpočetním uzlu a zastaví se na zarážce, kterou jste nastavili dříve. Kód teď můžete procházet při spuštění, zobrazit proměnné atd.

Poznámka:

Pokud protokol zobrazí záznam, který hlásí Debugger attached = False, vypršel časový limit a skript pokračoval bez ladicího programu. Odešlete kanál znovu a připojte ladicí program po Timeout for debug connection zprávě a před vypršením časového limitu.

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

V některých případech možná budete muset interaktivně ladit kód Pythonu obsažený v nasazení modelu. Pokud například selhává vstupní skript a důvod není možné určit dodatečným protokolováním. Pomocí VS Code a ladicího programu se můžete připojit k kódu spuštěného uvnitř kontejneru Dockeru.

Tip

Pokud používáte spravované online koncové body a nasazení místně, podívejte se na téma Místní ladění spravovaných online koncových bodů v editoru Visual Studio Code (Preview).

Důležité

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

Nasazení místní webové služby vyžadují funkční instalaci Dockeru v místním systému. 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í

Pokud chcete nainstalovat ladění 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í ladění s VS Code naleznete v tématu Vzdálené ladění.

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

V editoru VS Code vyberte v rozsahu spuštění nabídku Ladění a pak vyberte Otevřít konfigurace. Otevře se soubor s názvem launch.json .

V souboru launch.json vyhledejte položku "konfigurace" (řádek, který obsahuje"configurations": [) a vložte za něj 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 už v oddílu konfigurace existují další položky, přidejte za vložený kód čárku ( , ).

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

Uložte soubor launch.json.

Vytvoření image, která obsahuje ladicí program

Upravte prostředí Conda pro vaše nasazení tak, aby zahrnovalo ladění. Následující příklad ukazuje 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())

Pokud chcete spustit ladění a počkat na připojení při spuštění služby, přidejte do horní části 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...")

Vytvořte image založenou na definici prostředí a stáhněte image do místního registru.

Poznámka:

Tento příklad předpokládá, že ws odkazuje na váš pracovní prostor 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 více než 10 minut), cesta k imagi (včetně úložiště, názvu a značky, což je v tomto případě také jeho hodnota hash) se nakonec zobrazí ve zprávě podobné následující:

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

Pokud chcete usnadnit práci s image místně, můžete k přidání značky pro tuto image použít následující příkaz. Nahraďte myimagepath v následujícím příkazu hodnotou umístění z předchozího kroku.
```
docker tag myimagepath debug:1
```
Ve zbývajících krocích můžete odkazovat na místní image jako debug:1 místo hodnoty cesty k úplnému obrázku.

Ladění služby

Tip

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

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

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řipojení k tomuto příkazu v kontejneru. Všechny změny provedené v editoru se proto automaticky projeví v kontejneru.
Pro lepší prostředí můžete přejít do kontejneru pomocí nového rozhraní VS Code. Vyberte rozsah na bočním Docker panelu VS Code a v této dokumentaci debug:1vyhledejte vytvořený místní kontejner. Klikněte pravým tlačítkem myši 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.
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:
Pokud chcete VS Code připojit k ladění uvnitř kontejneru, otevřete VS Code a použijte klávesu F5 nebo vyberte Ladit. Po zobrazení výzvy vyberte nasazení služby Azure Machine Learning: Konfigurace ladění Dockeru. Můžete také vybrat ikonu rozšíření spuštění na bočním panelu, nasazení služby Azure Machine Learning: Položka ladění Dockeru z rozevírací nabídky Ladění a pak pomocí zelené šipky připojit ladicí program.

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

Také v hlavním rozhraní VS Code vidíte následující:

A teď se místní, score.py který je připojený ke kontejneru, už zastavil na zarážkách, kde jste nastavili. V tuto chvíli se VS Code připojí k ladění uvnitř kontejneru Dockeru a zastaví kontejner Dockeru na zarážce, kterou jste nastavili dříve. Kód teď můžete procházet při 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

Pokud chcete kontejner zastavit, použijte následující příkaz:

docker stop debug

Další kroky

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

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

Sdílet prostřednictvím

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

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

Požadavky

Místní ladění experimentu

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

Požadavky

Jak to funguje

Konfigurace skriptů Pythonu

Konfigurace kanálu ML

Konfigurace vývojového prostředí

Připojení ladicího programu

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

Konfigurace vývojového prostředí

Vytvoření image, která obsahuje ladicí program

Ladění služby

Zastavení kontejneru

Další kroky

Váš názor

Další materiály