Débogage interactif avec Visual Studio Code

S’APPLIQUE À : SDK Python azureml v1

Découvrez comment déboguer des expériences, des pipelines et des déploiements Azure Machine Learning de manière interactive à l’aide de Visual Studio Code (VS Code) et de debugpy.

Exécuter et déboguer des expériences localement

Utilisez l’extension Azure Machine Learning pour valider, exécuter et déboguer vos expériences d’apprentissage automatique avant de les envoyer au cloud.

Prérequis

• Extension VS Code Azure Machine Learning (préversion). Pour plus d’informations, consultez Configurer l’extension VS Code Azure Machine Learning.

  Important

  L’extension Azure Machine Learning pour VS Code utilise l’interface CLI (v2) par défaut. Les instructions de ce guide utilisent l’interface CLI 1.0. Pour passer à l’interface CLI 1.0, définissez le paramètre azureML.CLI Compatibility Mode dans Visual Studio Code sur 1.0. Pour plus d’informations sur la modification de vos paramètres dans Visual Studio Code, consultez la documentation sur les paramètres de l’utilisateur et de l’espace de travail.

  Important

  Cette fonctionnalité est actuellement disponible en préversion publique. Cette préversion est fournie sans contrat de niveau de service et n’est pas recommandée pour les charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge.

  Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.

• Docker

  • Docker Desktop pour Mac et Windows

  • Moteur Docker pour Linux.

    Notes

    Sur Windows, veillez à Configurer Docker pour utiliser des conteneurs Linux.

    Conseil

    Pour Windows, bien que cela ne soit pas obligatoire, il est vivement recommandé d’utiliser Docker avec le Sous-système Windows pour Linux (WSL) 2.

• Python 3

Déboguer une expérience localement

1. Dans VS Code, ouvrez l’affichage de l’extension Azure Machine Learning.

2. Développez le nœud d’abonnement contenant votre espace de travail. Si vous n’en avez pas encore, vous pouvez créer un espace de travail Azure Machine Learning à l’aide de l’extension.

3. Développez le nœud de votre espace de travail.

4. Cliquez avec le bouton droit sur le nœud Expériences, puis sélectionnez Créer une expérience. Quand vous y être invité, spécifiez un nom pour votre expérience.

5. Développez le nœud Expériences, cliquez avec le bouton droit sur l’expérience que vous souhaitez exécuter, puis sélectionnez Exécuter une expérience.

6. Dans la liste d'options, sélectionnez Localement.

7. Première utilisation sur Windows uniquement. Lorsque vous êtes invité à autoriser le Partage de fichiers, sélectionnez Oui. Lorsque vous activez le partage de fichiers, Docker peut monter le répertoire contenant votre script sur le conteneur. En outre, il permet à Docker de stocker les journaux et les sorties de votre exécution dans un répertoire temporaire sur votre système.

8. Sélectionnez Oui pour déboguer votre expérience. Sinon, sélectionnez Non. Si vous sélectionnez Non, votre expérience est exécutée localement sans être attachée au débogueur.

9. Sélectionnez Create new Run Configuration (Créer une configuration de série de tests) pour créer votre configuration de série de tests. La configuration de série de tests définit le script que vous souhaitez exécuter, les dépendances et les jeux de données utilisés. Autrement, si vous en avez déjà un, sélectionnez-le dans la liste déroulante.

   1. Choisissez votre environnement. Vous pouvez choisir n’importe que environnement organisé Azure Machine Learning ou créer le vôtre.
   2. Indiquez le nom du script que vous souhaitez exécuter. Le chemin d’accès est relatif au répertoire ouvert dans VS Code.
   3. Indiquez si vous souhaitez utiliser un jeu de données Azure Machine Learning ou non. Vous pouvez créer des jeux de données Azure Machine Learning à l’aide de l’extension.
   4. Debugpy est requis pour attacher le débogueur au conteneur exécutant votre expérience. Pour ajouter debugpy en tant que dépendance, sélectionnez Ajouter Debugpy. Autrement, sélectionnez Ignorer. Si vous n’ajoutez pas debugpy en tant que dépendance, votre expérience s’exécute sans être attachée au débogueur.
   5. Un fichier de configuration contenant vos paramètres de configuration de série de tests s’ouvre dans l’éditeur. Si vous êtes satisfait des paramètres, sélectionnez Soumettre l’expérience. Vous pouvez également ouvrir la palette de commandes (Afficher > Palette de commandes) à partir de la barre de menus, puis entrer la commande AzureML: Submit experiment dans la zone de texte.

10. Une fois votre expérience envoyée, une image Docker contenant votre script et les configurations spécifiées dans votre configuration de série de tests est créée.

    Lorsque le processus de génération d’image Docker commence, le contenu du fichier 60_control_log.txt est diffusé vers la console de sortie dans VS Code.

    Notes

    La première création de votre image Docker peut prendre plusieurs minutes.

11. Une fois votre image générée, une invite s’affiche pour démarrer le débogueur. Définissez vos points d’arrêt dans votre script, puis sélectionnez Démarrer le débogueur quand vous êtes prêt à démarrer le débogage. Cela a pour effet d’attacher le débogueur VS Code au conteneur exécutant votre expérience. Ou bien, dans l’extension Azure Machine Learning, vous pouvez pointer sur le nœud de votre exécution actuelle et sélectionner l’icône de lecture pour démarrer le débogueur.

    Important

    Vous ne pouvez pas avoir plusieurs sessions de débogage pour une seule expérience. Vous pouvez cependant déboguer au moins deux expériences à l’aide de plusieurs instances VS Code.

À ce stade, vous devriez être en mesure d’effectuer un pas à pas détaillé et de déboguer votre code à l’aide de VS Code.

Si, à un point quelconque, vous souhaitez annuler votre exécution, cliquez avec le bouton droit sur le nœud d’exécution, puis sélectionnez Annuler l’exécution.

Comme pour les exécutions d’expérience à distance, vous pouvez développer votre nœud d’exécution pour inspecter les journaux et les sorties.

Déboguer et résoudre les problèmes de pipelines de machine learning

Dans certains cas, vous devrez peut-être déboguer interactivement le code Python utilisé dans votre pipeline ML. À l’aide de VS Code et de debugpy, vous pouvez attacher le code au fur et à mesure de son exécution dans l’environnement d’apprentissage.

Prérequis

• Un espace de travail Azure Machine Learning configuré pour utiliser un réseau virtuel Azure.

• un pipeline Azure Machine Learning utilisant des scripts Python dans le cadre de ses étapes. Par exemple, PythonScriptStep.

• Un cluster de Capacité de calcul Machine Learning se trouvant dans le réseau virtuel, que le pipeline utilise pour effectuer l’apprentissage.

• Un environnement de développement se trouvant dans le réseau virtuel. L’environnement de développement peut être l’une des ressources suivantes :

  • une machine virtuelle Azure se trouvant dans le réseau virtuel ;
  • une instance de calcul de machine virtuelle Notebook se trouvant dans le réseau virtuel ;
  • une machine client disposant d’une connectivité réseau privée au réseau virtuel, par le biais d’un VPN ou via ExpressRoute.

Pour plus d’informations sur l’utilisation d’un réseau virtuel Azure avec Azure Machine Learning, consultez Vue d’ensemble de l’isolement et la confidentialité des réseaux virtuels.

Fonctionnement

Les étapes de votre pipeline ML exécutent des scripts Python. Ces scripts sont modifiés pour effectuer les actions suivantes :

1. journaliser l’adresse IP de l’hôte sur lequel ils s’exécutent. Vous utilisez l’adresse IP pour connecter le débogueur au script.

2. Démarrez le composant de débogage debugpy et attendez qu’un débogueur se connecte.

3. À partir de votre environnement de développement, vous surveillez les journaux créés par le processus d’apprentissage pour trouver l’adresse IP où le script est en cours d’exécution.

4. Vous indiquez à VS Code l’adresse IP à laquelle connecter le débogueur à l’aide d’un fichier launch.json.

5. Vous attachez le débogueur et parcourez le script de manière interactive.

Configurer des scripts Python

Pour activer le débogage, apportez les modifications suivantes au(x) script(s) Python utilisé(s) dans les étapes de votre pipeline ML :

1. Ajoutez les instructions d’importation suivantes :

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

2. Ajoutez les arguments suivants : Ces arguments vous permettent d’activer le débogueur en fonction des besoins, et de définir le délai d’attente pour l’attachement du débogueur :

   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. Ajoutez les instructions suivantes. Ces instructions chargent le contexte d’exécution actuel afin que vous puissiez journaliser l’adresse IP du nœud sur lequel le code s’exécute :

   global run
   run = Run.get_context()
   

4. Ajoutez une instruction if qui démarre debugpy et attend qu’un débogueur s’attache. Si aucun débogueur ne s’attache avant le délai d’expiration, le script continue à s’exécuter normalement. Veillez à remplacer les valeurs HOST et PORT dans la fonction listen par les vôtres.

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

L’exemple Python suivant montre un fichier train.py simple qui active le débogage :

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

Configurer un pipeline ML

Pour fournir les packages Python nécessaires pour démarrer debugpy et obtenir le contexte d’exécution, créez un environnement et définissez pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Modifiez la version du kit de développement logiciel (SDK) pour qu’elle corresponde à celle que vous utilisez. L’extrait de code suivant montre comment créer un environnement :

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

Dans la section Configurer des scripts Python, de nouveaux arguments ont été ajoutés aux scripts qu’utilisent les étapes de votre pipeline ML. L’extrait de code suivant montre comment utiliser ces arguments pour activer le débogage pour le composant et définir un délai d’expiration. Il montre également comment utiliser l’environnement créé précédemment en définissant 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)

Lorsque le pipeline s’exécute, chaque étape crée une exécution enfant. Si le débogage est activé, le script modifié journalise des informations similaires au texte suivant dans le fichier 70_driver_log.txt pour l’exécution enfant :

Timeout for debug connection: 300
ip_address: 10.3.0.5

Enregistrez la valeur ip_address. Elles seront utilisées dans la prochaine section.

Configurer l’environnement de développement

1. Pour installer debugpy sur votre environnement de développement VS Code, utilisez la commande suivante :

   python -m pip install --upgrade debugpy
   

   Pour plus d’informations sur l’utilisation de debugpy avec VS Code, consultez Débogage à distance.

2. Pour configurer VS Code afin de communiquer avec la Capacité de calcul Azure Machine Learning qui exécute le débogueur, créez une nouvelle configuration de débogage :

   1. Dans VS Code, sélectionnez le menu Déboguer, puis sélectionnez Ouvrir les configurations. Un fichier nommé launch.json s’ouvre.

   2. Dans le fichier launch.json, recherchez la ligne contenant "configurations": [ et insérez le texte suivant après celle-ci : Remplacez l’entrée "host": "<IP-ADDRESS>" par l’adresse IP renvoyée dans vos journaux de la section précédente. Remplacez l’entrée "localRoot": "${workspaceFolder}/code/step" par un répertoire local contenant une copie du script en cours de débogage :

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

      Important

      Si la section des configurations contient déjà d’autres entrées, ajoutez une virgule (,) après le code que vous avez inséré.

      Conseil

      La meilleure pratique, en particulier pour les pipelines, consiste à conserver les ressources des scripts dans des répertoires distincts, de sorte que le code s’applique uniquement à chacune des étapes. Dans cet exemple, l’exemple de valeur localRoot fait référence à /code/step1.

      Si vous déboguez plusieurs scripts, dans des répertoires différents, créez une section de configuration distincte pour chaque script.

   3. Enregistrez le fichier launch.json.

Connectez le débogueur.

1. Ouvrez VS Code et ouvrez une copie locale du script.

2. Définissez des points d’arrêt là où vous souhaitez que le script s’arrête une fois que vous l’avez attaché.

3. Pendant que le processus enfant exécute le script et que le Timeout for debug connection s’affiche dans les journaux, utilisez la touche F5 ou sélectionnez Déboguer. Lorsque vous y êtes invité, sélectionnez la configuration Capacité de calcul Azure Machine Learning : débogage à distance. Vous pouvez également sélectionner l’icône de débogage dans la barre latérale, l’entrée Azure Machine Learning : débogage à distance dans le menu déroulant Débogage, puis utiliser la flèche verte pour attacher le débogueur.

   À ce stade, VS Code se connecte à debugpy sur le nœud de calcul et s’arrête au point d’arrêt que vous avez préalablement défini. Vous pouvez maintenant parcourir le code au fur et à mesure de son exécution, afficher des variables etc.

   Notes

   Si le journal contient une entrée indiquant Debugger attached = False, cela signifie que le délai d’expiration a expiré et que l’exécution du script a continué sans le débogueur. Soumettez à nouveau le pipeline et connectez le débogueur après le message Timeout for debug connection, et avant la fin du délai d’expiration.

Déboguer et résoudre les problèmes de déploiement

Dans certains cas, vous devrez peut-être déboguer interactivement le code Python contenu dans votre modèle de déploiement. Par exemple, si le script d'entrée échoue et que la raison ne peut être déterminée par une journalisation supplémentaire. À l’aide de VS Code et de debugpy, vous pouvez attacher au code qui s’exécute dans le conteneur Docker.

Les déploiements de service web locaux nécessitent l’installation d’un Docker de travail sur votre système local. Pour plus d’informations sur l’utilisation de Docker, consultez la documentation Docker. Lorsque vous travaillez avec des instances de calcul, Docker est déjà installé.

Configurer l’environnement de développement

1. Pour installer debugpy sur votre environnement de développement VS Code local, utilisez la commande suivante :

   python -m pip install --upgrade debugpy
   

   Pour plus d’informations sur l’utilisation de debugpy avec VS Code, consultez Débogage à distance.

2. Pour configurer VS Code pour communiquer avec l’image Docker, créez une nouvelle configuration de débogage :

   1. Dans VS Code, sélectionnez le menu Déboguer dans l’extension Exécuter, puis sélectionnez Ouvrir les configurations. Un fichier nommé launch.json s’ouvre.

   2. Dans le fichier launch.json, recherchez l’élément « configurations » (la ligne contenant "configurations": [) et insérez le texte suivant après celui-ci.

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

      Après l’insertion, le fichier launch.json doit ressembler à ce qui suit :

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

      Important

      Si la section des configurations contient déjà d’autres entrées, ajoutez une virgule ( , ) après le code que vous avez inséré.

      Cette section est attachée au conteneur Docker à l’aide du port 5678.

   3. Enregistrez le fichier launch.json.

Créer une image qui inclut debugpy

1. Modifiez l’environnement Conda pour votre déploiement afin qu’il inclue debugpy. L’exemple suivant illustre son ajout à l’aide du paramètre 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. Pour démarrer debugpy et attendre une connexion au démarrage du service, ajoutez le code suivant au début de votre fichier score.py :

   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. Créez une image basée sur la définition de l’environnement et extrayez l’image dans le registre local.

   Notes

   Cet exemple suppose que ws pointe vers votre espace de travail Azure Machine Learning et que model est le modèle en cours de déploiement. Le fichier myenv.yml contient les dépendances Conda créées à l’étape 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()
   

   Une fois l’image créée et téléchargée (ce processus peut prendre plus de 10 minutes), le chemin de l’image (y compris le référentiel, le nom et l’étiquette, qui dans ce cas est également son code de hachage) est finalement affiché dans un message semblable au suivant :

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

4. Pour faciliter le travail local sur l’image, vous pouvez utiliser la commande suivante pour ajouter une étiquette pour cette image. Remplacez myimagepath dans la commande suivante par la valeur d’emplacement issue de l’étape précédente.

   docker tag myimagepath debug:1
   

   Pour le reste des étapes, vous pouvez faire référence à l’image locale en tant que debug:1 au lieu de la valeur du chemin complet de l’image.

Déboguer le service

1. Pour démarrer un conteneur Docker à l’aide de l’image, utilisez la commande suivante :

   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
   

   La commande permet de joindre votre score.py localement à celui du conteneur. Par conséquent, toute modification effectuée dans l’éditeur se reflète automatiquement dans le conteneur.

2. Pour une meilleure expérience, vous pouvez accéder au conteneur avec une nouvelle interface VS Code. Sélectionnez l’extension Docker dans la barre latérale VS Code et recherchez le conteneur local que vous avez créé. Dans cette documentation, il s’agit de debug:1. Cliquez avec le bouton droit sur ce conteneur et sélectionnez "Attach Visual Studio Code", puis une nouvelle interface VS Code s’ouvre automatiquement et cette interface affiche l’intérieur du conteneur que vous avez créé.

   

3. Dans le conteneur, exécutez la commande suivante dans l’interpréteur de commandes.

   runsvdir /var/runit
   

   Vous pouvez ensuite voir la sortie suivante dans l’interpréteur à l’intérieur de votre conteneur :

   

4. Pour attacher VS Code à debugpy à l’intérieur du conteneur, ouvrez VS Code et utilisez la touche F5 ou sélectionnez Déboguer. Lorsque vous y êtes invité, sélectionnez la configuration Déploiement Azure Machine Learning : Configuration du débogage Docker. Vous pouvez également sélectionner l’icône de l’extension Exécuter dans la barre latérale, l’entrée Déploiement Azure Machine Learning : entrée de débogage Docker dans le menu déroulant Déboguer, puis utiliser la flèche verte pour attacher le débogueur.

   

   Après avoir sélectionné la flèche verte et attaché le débogueur, dans l’interface VS Code du conteneur, vous pouvez voir de nouvelles informations :

   

   Dans votre interface VS Code principale, vous pouvez aussi voir ce qui suit :

   

Désormais, le score.py local qui est attaché au conteneur s’est déjà arrêté aux points d’arrêt que vous avez définis. À ce stade, VS Code se connecte à debugpy à l’intérieur du conteneur Docker et arrête le conteneur Docker au point d’arrêt que vous avez précédemment défini. Vous pouvez maintenant parcourir le code au fur et à mesure de son exécution, afficher des variables etc.

Pour plus d’informations sur l’utilisation de VS Code pour déboguer Python, consultez Déboguer votre code Python.

Arrêter le conteneur

Pour arrêter un conteneur, utilisez la commande suivante :

docker stop debug

Étapes suivantes

À présent que vous avez configuré VS Code Remote, vous pouvez utiliser une instance de calcul en tant que calcul à distance de VS Code pour déboguer votre code de manière interactive.

Apprenez-en davantage sur la résolution des problèmes :

• Déploiement de modèle local
• Déploiement de modèle distant
• Pipelines d’apprentissage automatique
• ParallelRunStep