Depuração interativa com Visual Studio CodeInteractive debugging with Visual Studio Code

Saiba como depurar interativamente Azure Machine Learning testes, pipelines e implantações usando Visual Studio Code (VS Code) e debugpy.Learn how to interactively debug Azure Machine Learning experiments, pipelines, and deployments using Visual Studio Code (VS Code) and debugpy.

Executar e depurar experimentos localmenteRun and debug experiments locally

Use a extensão Azure Machine Learning para validar, executar e depurar seus experimentos de aprendizado de máquina antes de enviá-los para a nuvem.Use the Azure Machine Learning extension to validate, run, and debug your machine learning experiments before submitting them to the cloud.

Pré-requisitosPrerequisites

Observação

No Windows, certifique-se de Configurar o Docker para usar contêineres do Linux.On Windows, make sure to configure Docker to use Linux containers.

Dica

Para o Windows, embora não seja necessário, é altamente recomendável usar o Docker com o subsistema do Windows para Linux (WSL) 2.For Windows, although not required, it's highly recommended to use Docker with Windows Subsystem for Linux (WSL) 2.

Importante

Antes de executar o experimento localmente, verifique se o Docker está em execução.Before running your experiment locally, make sure that Docker is running.

Depurar experimento localmenteDebug experiment locally

  1. Em VS Code, abra a exibição de extensão de Azure Machine Learning.In VS Code, open the Azure Machine Learning extension view.

  2. Expanda o nó de assinatura que contém seu espaço de trabalho.Expand the subscription node containing your workspace. Se você ainda não tiver uma, poderá criar um Azure Machine Learning espaço de trabalho usando a extensão.If you don't already have one, you can create an Azure Machine Learning workspace using the extension.

  3. Expanda o nó do espaço de trabalho.Expand your workspace node.

  4. Clique com o botão direito do mouse no nó experimentos e selecione criar experimento.Right-click the Experiments node and select Create experiment. Quando o prompt for exibido, forneça um nome para o experimento.When the prompt appears, provide a name for your experiment.

  5. Expanda o nó experimentos , clique com o botão direito do mouse no experimento que você deseja executar e selecione executar experimento.Expand the Experiments node, right-click the experiment you want to run and select Run Experiment.

  6. Na lista de opções para executar seu experimento, selecione localmente.From the list of options to run your experiment, select Locally.

  7. Primeira vez, use somente no Windows.First time use on Windows only. Quando for solicitado a permitir o compartilhamento de arquivos, selecione Sim.When prompted to allow File Share, select Yes. Quando você habilita o compartilhamento de arquivos, ele permite que o Docker monte o diretório que contém o script no contêiner.When you enable file share it allows Docker to mount the directory containing your script to the container. Além disso, ele também permite que o Docker armazene os logs e as saídas de sua execução em um diretório temporário em seu sistema.Additionally, it also allows Docker to store the logs and outputs from your run in a temporary directory on your system.

  8. Selecione Sim para depurar seu experimento.Select Yes to debug your experiment. Caso contrário, selecione Não.Otherwise, select No. Selecionar não executará seu experimento localmente sem anexar ao depurador.Selecting no will run your experiment locally without attaching to the debugger.

  9. Selecione criar nova configuração de execução para criar sua configuração de execução.Select Create new Run Configuration to create your run configuration. A configuração de execução define o script que você deseja executar, as dependências e os conjuntos de valores usados.The run configuration defines the script you want to run, dependencies, and datasets used. Como alternativa, se você já tiver um, selecione-o na lista suspensa.Alternatively, if you already have one, select it from the dropdown.

    1. Escolha seu ambiente.Choose your environment. Você pode escolher entre qualquer uma das Azure Machine Learning organizadas ou criar suas próprias.You can choose from any of the Azure Machine Learning curated or create your own.
    2. Forneça o nome do script que você deseja executar.Provide the name of the script you want to run. O caminho é relativo ao diretório aberto em VS Code.The path is relative to the directory opened in VS Code.
    3. Escolha se deseja usar um conjunto de Azure Machine Learning ou não.Choose whether you want to use an Azure Machine Learning dataset or not. Você pode criar Azure Machine Learning conjuntos de valores usando a extensão.You can create Azure Machine Learning datasets using the extension.
    4. Debugpy é necessário para anexar o depurador ao contêiner que está executando o experimento.Debugpy is required in order to attach the debugger to the container running your experiment. Para adicionar debugpy como uma dependência, selecione Adicionar debugpy.To add debugpy as a dependency,select Add Debugpy. Caso contrário, selecione ignorar.Otherwise, select Skip. Não adicionar debugpy como uma dependência executa seu experimento sem anexar ao depurador.Not adding debugpy as a dependency runs your experiment without attaching to the debugger.
    5. Um arquivo de configuração que contém as definições de configuração de execução é aberto no editor.A configuration file containing your run configuration settings opens in the editor. Se você estiver satisfeito com as configurações, selecione Enviar experimento.If you're satisfied with the settings, select Submit experiment. Como alternativa, abra a paleta de comandos (exibir > paleta de comandos) na barra de menus e insira o Azure ML: Submit experiment comando na caixa de texto.Alternatively, you open the command palette (View > Command Palette) from the menu bar and enter the Azure ML: Submit experiment command into the text box.
  10. Depois que o teste for enviado, uma imagem do Docker que contém o script e as configurações especificadas na sua configuração de execução serão criadas.Once your experiment is submitted, a Docker image containing your script and the configurations specified in your run configuration is created.

    Quando o processo de criação de imagem do Docker é iniciado, o conteúdo do 60_control_log.txt fluxo de arquivos para o console de saída no vs Code.When the Docker image build process begins, the contents of the 60_control_log.txt file stream to the output console in VS Code.

    Observação

    A primeira vez que a imagem do Docker é criada pode levar vários minutos.The first time your Docker image is created can take several minutes.

  11. Depois que a imagem for criada, um prompt será exibido para iniciar o depurador.Once your image is built, a prompt appears to start the debugger. Defina seus pontos de interrupção em seu script e selecione Iniciar depurador quando você estiver pronto para iniciar a depuração.Set your breakpoints in your script and select Start debugger when you're ready to start debugging. Isso anexa o depurador de VS Code ao contêiner que executa o experimento.Doing so attaches the VS Code debugger to the container running your experiment. Como alternativa, na extensão Azure Machine Learning, passe o mouse sobre o nó da sua execução atual e selecione o ícone de reprodução para iniciar o depurador.Alternatively, in the Azure Machine Learning extension, hover over the node for your current run and select the play icon to start the debugger.

    Importante

    Você não pode ter várias sessões de depuração para um único experimento.You cannot have multiple debug sessions for a single experiment. No entanto, você pode depurar dois ou mais experimentos usando várias instâncias de VS Code.You can however debug two or more experiments using multiple VS Code instances.

Neste ponto, você deve ser capaz de percorrer e depurar seu código usando VS Code.At this point, you should be able to step-through and debug your code using VS Code.

Se a qualquer momento você quiser cancelar a execução, clique com o botão direito do mouse no nó de execução e selecione Cancelar execução.If at any point you want to cancel your run, right-click your run node and select Cancel run.

Assim como as execuções de experimento remoto, você pode expandir o nó de execução para inspecionar os logs e as saídas.Similar to remote experiment runs, you can expand your run node to inspect the logs and outputs.

Dica

As imagens do Docker que usam as mesmas dependências definidas em seu ambiente são reutilizadas entre as execuções.Docker images that use the same dependencies defined in your environment are reused between runs. No entanto, se você executar um experimento usando um ambiente novo ou diferente, uma nova imagem será criada.However, if you run an experiment using a new or different environment, a new image is created. Como essas imagens são salvas no armazenamento local, é recomendável remover imagens antigas ou não utilizadas do Docker.Since these images are saved to your local storage, it's recommended to remove old or unused Docker images. Para remover imagens do sistema, use a CLI do Docker ou a extensão vs Code Docker.To remove images from your system, use the Docker CLI or the VS Code Docker extension.

Depurar e solucionar problemas de pipelines do aprendizado de máquinaDebug and troubleshoot machine learning pipelines

Em alguns casos, talvez seja necessário depurar interativamente o código Python usado em seu pipeline de ML.In some cases, you may need to interactively debug the Python code used in your ML pipeline. Usando VS Code e debugpy, você pode anexar ao código conforme ele é executado no ambiente de treinamento.By using VS Code and debugpy, you can attach to the code as it runs in the training environment.

Pré-requisitosPrerequisites

  • Um espaço de trabalho Azure Machine Learning configurado para usar uma rede virtual do Azure.An Azure Machine Learning workspace that is configured to use an Azure Virtual Network.

  • Um pipeline Azure Machine Learning que usa scripts Python como parte das etapas do pipeline.An Azure Machine Learning pipeline that uses Python scripts as part of the pipeline steps. Por exemplo, um PythonScriptStep.For example, a PythonScriptStep.

  • Um cluster de computação Azure Machine Learning, que está na rede virtual e é usado pelo pipeline para treinamento.An Azure Machine Learning Compute cluster, which is in the virtual network and is used by the pipeline for training.

  • Um ambiente de desenvolvimento que está na rede virtual.A development environment that is in the virtual network. O ambiente de desenvolvimento pode ser um dos seguintes:The development environment might be one of the following:

    • Uma máquina virtual do Azure na rede virtualAn Azure Virtual Machine in the virtual network
    • Uma instância de computação da VM do notebook na rede virtualA Compute instance of Notebook VM in the virtual network
    • Um computador cliente que tem conectividade de rede privada com a rede virtual, seja por VPN ou via ExpressRoute.A client machine that has private network connectivity to the virtual network, either by VPN or via ExpressRoute.

Para obter mais informações sobre como usar uma rede virtual do Azure com Azure Machine Learning, consulte visão geral de isolamento de rede virtual e privacidade.For more information on using an Azure Virtual Network with Azure Machine Learning, see Virtual network isolation and privacy overview.

Dica

Embora você possa trabalhar com Azure Machine Learning recursos que não estão atrás de uma rede virtual, é recomendável usar uma rede virtual.Although you can work with Azure Machine Learning resources that are not behind a virtual network, using a virtual network is recommended.

Como ele funcionaHow it works

Suas etapas de pipeline ML executam scripts Python.Your ML pipeline steps run Python scripts. Esses scripts são modificados para executar as seguintes ações:These scripts are modified to perform the following actions:

  1. Registre o endereço IP do host no qual eles estão sendo executados.Log the IP address of the host that they are running on. Você usa o endereço IP para conectar o depurador ao script.You use the IP address to connect the debugger to the script.

  2. Inicie o componente de depuração debugpy e aguarde até que um depurador se conecte.Start the debugpy debug component, and wait for a debugger to connect.

  3. Em seu ambiente de desenvolvimento, você monitora os logs criados pelo processo de treinamento para localizar o endereço IP em que o script está sendo executado.From your development environment, you monitor the logs created by the training process to find the IP address where the script is running.

  4. Você informa VS Code o endereço IP para conectar o depurador usando um launch.json arquivo.You tell VS Code the IP address to connect the debugger to by using a launch.json file.

  5. Anexe o depurador e percorra o script interativamente.You attach the debugger and interactively step through the script.

Configurar scripts do PythonConfigure Python scripts

Para habilitar a depuração, faça as seguintes alterações no (s) script (es) do Python usados por etapas em seu pipeline de ML:To enable debugging, make the following changes to the Python script(s) used by steps in your ML pipeline:

  1. Adicione as seguintes instruções de importação:Add the following import statements:

    import argparse
    import os
    import debugpy
    import socket
    from azureml.core import Run
    
  2. Adicione os argumentos a seguir.Add the following arguments. Esses argumentos permitem que você habilite o depurador conforme necessário e defina o tempo limite para anexar o depurador:These arguments allow you to enable the debugger as needed, and set the timeout for attaching the debugger:

    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 AML 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. Adicione as instruções a seguir.Add the following statements. Essas instruções carregam o contexto de execução atual para que você possa registrar em log o endereço IP do nó em que o código está sendo executado:These statements load the current run context so that you can log the IP address of the node that the code is running on:

    global run
    run = Run.get_context()
    
  4. Adicione uma if instrução que inicia debugpy e aguarda a anexação de um depurador.Add an if statement that starts debugpy and waits for a debugger to attach. Se nenhum depurador for anexado antes do tempo limite, o script continuará normalmente.If no debugger attaches before the timeout, the script continues as normal. Certifique-se de substituir HOST os PORT valores e é a listen função com o seu próprio.Make sure to replace the HOST and PORT values is the listen function with your own.

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

O exemplo de Python a seguir mostra um train.py arquivo simples que habilita a depuração:The following Python example shows a simple train.py file that enables debugging:

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

Configurar pipeline MLConfigure ML pipeline

Para fornecer os pacotes do python necessários para iniciar o debugpy e obter o contexto de execução, crie um ambiente e defina pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>'] .To provide the Python packages needed to start debugpy and get the run context, create an environment and set pip_packages=['debugpy', 'azureml-sdk==<SDK-VERSION>']. Altere a versão do SDK para corresponder à que você está usando.Change the SDK version to match the one you are using. O trecho de código a seguir demonstra como criar um ambiente:The following code snippet demonstrates how to create an environment:

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

Na seção Configurar scripts Python , novos argumentos foram adicionados aos scripts usados pelas etapas de pipeline do ml.In the Configure Python scripts section, new arguments were added to the scripts used by your ML pipeline steps. O trecho de código a seguir demonstra como usar esses argumentos para habilitar a depuração para o componente e definir um tempo limite.The following code snippet demonstrates how to use these arguments to enable debugging for the component and set a timeout. Ele também demonstra como usar o ambiente criado anteriormente por meio da configuração runconfig=run_config :It also demonstrates how to use the environment created earlier by setting 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)

Quando o pipeline é executado, cada etapa cria uma execução filho.When the pipeline runs, each step creates a child run. Se a depuração estiver habilitada, o script modificado registrará informações semelhantes ao seguinte texto no 70_driver_log.txt para a execução do filho:If debugging is enabled, the modified script logs information similar to the following text in the 70_driver_log.txt for the child run:

Timeout for debug connection: 300
ip_address: 10.3.0.5

Salve o ip_address valor.Save the ip_address value. Ele é usado na próxima seção.It is used in the next section.

Dica

Você também pode encontrar o endereço IP na etapa executar logs para a execução do filho para este pipeline.You can also find the IP address from the run logs for the child run for this pipeline step. Para obter mais informações sobre como exibir essas informações, consulte monitorar execuções e métricas de experimento do Azure ml.For more information on viewing this information, see Monitor Azure ML experiment runs and metrics.

Configurar o ambiente de desenvolvimentoConfigure development environment

  1. Para instalar o debugpy em seu ambiente de desenvolvimento VS Code, use o seguinte comando:To install debugpy on your VS Code development environment, use the following command:

    python -m pip install --upgrade debugpy
    

    Para obter mais informações sobre como usar o debugpy com VS Code, consulte depuração remota.For more information on using debugpy with VS Code, see Remote Debugging.

  2. Para configurar VS Code para se comunicar com a computação Azure Machine Learning que está executando o depurador, crie uma nova configuração de depuração:To configure VS Code to communicate with the Azure Machine Learning compute that is running the debugger, create a new debug configuration:

    1. No VS Code, selecione o menu Depurar e depois selecione Configurações abertas.From VS Code, select the Debug menu and then select Open configurations. Um arquivo chamado launch.json será aberto.A file named launch.json opens.

    2. Na launch.jsno arquivo, localize a linha que contém "configurations": [ e insira o texto a seguir depois dela.In the launch.json file, find the line that contains "configurations": [, and insert the following text after it. Altere a "host": "<IP-ADDRESS>" entrada para o endereço IP retornado nos logs da seção anterior.Change the "host": "<IP-ADDRESS>" entry to the IP address returned in your logs from the previous section. Altere a "localRoot": "${workspaceFolder}/code/step" entrada para um diretório local que contenha uma cópia do script que está sendo depurado:Change the "localRoot": "${workspaceFolder}/code/step" entry to a local directory that contains a copy of the script being debugged:

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

      Importante

      Se já houver outras entradas na seção Configurações, adicione uma vírgula (,) após o código inserido.If there are already other entries in the configurations section, add a comma (,) after the code that you inserted.

      Dica

      A prática recomendada, especialmente para pipelines, é manter os recursos de scripts em diretórios separados para que o código seja relevante apenas para cada uma das etapas.The best practice, especially for pipelines is to keep the resources for scripts in separate directories so that code is relevant only for each of the steps. Neste exemplo, o localRoot valor de exemplo faz referência a /code/step1 .In this example the localRoot example value references /code/step1.

      Se você estiver Depurando vários scripts, em diretórios diferentes, crie uma seção de configuração separada para cada script.If you are debugging multiple scripts, in different directories, create a separate configuration section for each script.

    3. Salve o arquivo launch.json.Save the launch.json file.

Conectar o depuradorConnect the debugger

  1. Abra VS Code e abra uma cópia local do script.Open VS Code and open a local copy of the script.

  2. Defina os pontos de interrupção onde você deseja que o script Pare depois de anexado.Set breakpoints where you want the script to stop once you've attached.

  3. Enquanto o processo filho estiver executando o script e o Timeout for debug connection for exibido nos logs, use a tecla F5 ou selecione depurar.While the child process is running the script, and the Timeout for debug connection is displayed in the logs, use the F5 key or select Debug. Quando solicitado, selecione o Azure Machine Learning computação: configuração de depuração remota .When prompted, select the Azure Machine Learning Compute: remote debug configuration. Você também pode selecionar o ícone de depuração na barra lateral, a Azure Machine Learning: entrada de depuração remota no menu suspenso de depuração e, em seguida, usar a seta verde para anexar o depurador.You can also select the debug icon from the side bar, the Azure Machine Learning: remote debug entry from the Debug dropdown menu, and then use the green arrow to attach the debugger.

    Neste ponto, VS Code se conecta ao debugpy no nó de computação e pára no ponto de interrupção definido anteriormente.At this point, VS Code connects to debugpy on the compute node and stops at the breakpoint you set previously. Agora você pode percorrer o código enquanto ele é executado, exibir variáveis, ​​etc.You can now step through the code as it runs, view variables, etc.

    Observação

    Se o log exibir uma entrada informando Debugger attached = False , o tempo limite expirou e o script continuou sem o depurador.If the log displays an entry stating Debugger attached = False, then the timeout has expired and the script continued without the debugger. Envie o pipeline novamente e conecte o depurador após a Timeout for debug connection mensagem e antes do tempo limite expirar.Submit the pipeline again and connect the debugger after the Timeout for debug connection message, and before the timeout expires.

Depurar e solucionar problemas de implantaçõesDebug and troubleshoot deployments

Em alguns casos, talvez seja necessário depurar interativamente o código Python contido na implantação de modelo.In some cases, you may need to interactively debug the Python code contained in your model deployment. Por exemplo, se o script de entrada estiver falhando e não for possível determinar o motivo por meio de um registro adicional.For example, if the entry script is failing and the reason cannot be determined by additional logging. Usando VS Code e debugpy, você pode anexar ao código em execução dentro do contêiner do Docker.By using VS Code and the debugpy, you can attach to the code running inside the Docker container.

Importante

Esse método de depuração não funciona ao usar Model.deploy() e LocalWebservice.deploy_configuration para implantar um modelo localmente.This method of debugging does not work when using Model.deploy() and LocalWebservice.deploy_configuration to deploy a model locally. Em vez disso, você deve criar uma imagem usando o método Model.package().Instead, you must create an image using the Model.package() method.

As implantações de serviço Web local exigem uma instalação do Docker em funcionamento no sistema local.Local web service deployments require a working Docker installation on your local system. Para obter mais informações, confira a Documentação do Docker.For more information on using Docker, see the Docker Documentation. Observe que, ao trabalhar com instâncias de computação, o Docker já está instalado.Note that when working with compute instances, Docker is already installed.

Configurar o ambiente de desenvolvimentoConfigure development environment

  1. Para instalar o debugpy em seu ambiente de desenvolvimento de VS Code local, use o seguinte comando:To install debugpy on your local VS Code development environment, use the following command:

    python -m pip install --upgrade debugpy
    

    Para obter mais informações sobre como usar o debugpy com VS Code, consulte depuração remota.For more information on using debugpy with VS Code, see Remote Debugging.

  2. Para configurar o VS Code para se comunicar com a imagem do Docker, crie uma nova configuração de depuração:To configure VS Code to communicate with the Docker image, create a new debug configuration:

    1. Em VS Code, selecione o menu depurar na extensão de execução e, em seguida, selecione abrir configurações.From VS Code, select the Debug menu in the Run extention and then select Open configurations. Um arquivo chamado launch.json será aberto.A file named launch.json opens.

    2. Na launch.jsno arquivo, localize o item "configurações" (a linha que contém "configurations": [ ) e insira o texto a seguir após ele.In the launch.json file, find the "configurations" item (the line that contains "configurations": [), and insert the following text after it.

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

      Após a inserção, o launch.jsno arquivo deve ser semelhante ao seguinte:After insertion, the launch.json file should be similar to the following:

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

      Importante

      Se já houver outras entradas na seção Configurações, adicione uma vírgula ( , ) após o código que você inseriu.If there are already other entries in the configurations section, add a comma ( , ) after the code that you inserted.

      Esta seção anexa o contêiner do Docker usando a porta 5678.This section attaches to the Docker container using port 5678.

    3. Salve o arquivo launch.json.Save the launch.json file.

Criar uma imagem que inclui debugpyCreate an image that includes debugpy

  1. Modifique o ambiente Conda para sua implantação para que ele inclua o debugpy.Modify the conda environment for your deployment so that it includes debugpy. O seguinte exemplo demonstra como adicioná-lo usando o parâmetro pip_packages:The following example demonstrates adding it using the pip_packages parameter:

    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. Para iniciar o debugpy e aguardar uma conexão quando o serviço for iniciado, adicione o seguinte à parte superior do score.py arquivo:To start debugpy and wait for a connection when the service starts, add the following to the top of your score.py file:

    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. Crie uma imagem com base na definição de ambiente e extraia a imagem para o registro local.Create an image based on the environment definition and pull the image to the local registry.

    Observação

    Este exemplo pressupõe que ws aponta para o workspace do Azure Machine Learning e que model é o modelo implantado.This example assumes that ws points to your Azure Machine Learning workspace, and that model is the model being deployed. O arquivo myenv.yml contém as dependências do Conda criadas na etapa 1.The myenv.yml file contains the conda dependencies created in step 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/base:intelmpi2018.3-ubuntu16.04"
    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()
    

    Depois que a imagem tiver sido criada e baixada (esse processo pode levar mais de 10 minutos, aguarde o paciente), o caminho da imagem (inclui repositório, nome e marca, que nesse caso também é seu resumo), finalmente exibido em uma mensagem semelhante à seguinte:Once the image has been created and downloaded (this process may take more than 10 minutes, so please wait patiently), the image path (includes repository, name, and tag, which in this case is also its digest) is finally displayed in a message similar to the following:

    Status: Downloaded newer image for myregistry.azurecr.io/package@sha256:<image-digest>
    
  4. Para facilitar o trabalho com a imagem localmente, você pode usar o comando a seguir para adicionar uma marca para essa imagem.To make it easier to work with the image locally, you can use the following command to add a tag for this image. Substitua myimagepath no comando a seguir pelo valor de local da etapa anterior.Replace myimagepath in the following command with the location value from the previous step.

    docker tag myimagepath debug:1
    

    Para o restante das etapas, você pode ver a imagem local como debug:1, em vez do valor do caminho da imagem completa.For the rest of the steps, you can refer to the local image as debug:1 instead of the full image path value.

Depurar o serviçoDebug the service

Dica

Se você definir um tempo limite para a conexão debugpy no score.py arquivo, deverá se conectar vs Code à sessão de depuração antes que o tempo limite expire.If you set a timeout for the debugpy connection in the score.py file, you must connect VS Code to the debug session before the timeout expires. Inicie o VS Code, abra a cópia local de score.py, defina um ponto de interrupção e prepare-o antes de usar as etapas nesta seção.Start VS Code, open the local copy of score.py, set a breakpoint, and have it ready to go before using the steps in this section.

Para obter mais informações sobre depuração e definição de pontos de interrupção, confira Depuração.For more information on debugging and setting breakpoints, see Debugging.

  1. Para iniciar um contêiner do Docker usando a imagem, use o seguinte comando:To start a Docker container using the image, use the following command:

    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
    

    Isso anexa o score.py local a um no contêiner.This attaches your score.py locally to the one in the container. Portanto, todas as alterações feitas no editor são refletidas automaticamente no contêinerTherefore, any changes made in the editor are automatically reflected in the container

  2. Para uma melhor experiência, você pode entrar no contêiner com uma nova interface do VS Code.For a better experience, you can go into the container with a new VS code interface. Selecione a Docker extensão na barra lateral vs Code, localize seu contêiner local criado, nesta documentação debug:1 .Select the Docker extention from the VS Code side bar, find your local container created, in this documentation it's debug:1. Clique com o botão direito do mouse nesse contêiner e selecione "Attach Visual Studio Code" , uma nova interface de vs Code será aberta automaticamente e essa interface mostrará o interior do seu contêiner criado.Right-click this container and select "Attach Visual Studio Code", then a new VS Code interface will be opened automatically, and this interface shows the inside of your created container.

    A interface VS Code do contêiner

  3. Dentro do contêiner, execute o seguinte comando no ShellInside the container, run the following command in the shell

    runsvdir /var/runit
    

    Em seguida, você pode ver a seguinte saída no Shell dentro do seu contêiner:Then you can see the following output in the shell inside your container:

    A saída do console de execução do contêiner

  4. Para anexar VS Code ao debugpy dentro do contêiner, abra VS Code e use a tecla F5 ou selecione depurar.To attach VS Code to debugpy inside the container, open VS Code and use the F5 key or select Debug. Quando solicitado, selecione o Azure Machine Learning implantação: configuração de depuração do Docker .When prompted, select the Azure Machine Learning Deployment: Docker Debug configuration. Você também pode selecionar o ícone de extensão de execução na barra lateral, a Azure Machine Learning implantação: entrada de depuração do Docker no menu suspenso depurar e, em seguida, usar a seta verde para anexar o depurador.You can also select the Run extention icon from the side bar, the Azure Machine Learning Deployment: Docker Debug entry from the Debug dropdown menu, and then use the green arrow to attach the debugger.

    O ícone de depuração, o botão Iniciar depuração e o seletor de configuração

    Depois de clicar na seta verde e anexar o depurador, na interface VS Code de contêiner, você poderá ver algumas informações novas:After clicking the green arrow and attaching the debugger, in the container VS Code interface you can see some new information:

    As informações anexadas do depurador de contêiner

    Além disso, na sua interface de VS Code principal, o que você pode ver é o seguinte:Also, in your main VS Code interface, what you can see is following:

    O ponto de interrupção VS Code em score.py

E agora, o local score.py que está anexado ao contêiner já parou nos pontos de interrupção onde você definiu.And now, the local score.py which is attached to the container has already stopped at the breakpoints where you set. Neste ponto, VS Code se conecta ao debugpy dentro do contêiner do Docker e interrompe o contêiner do Docker no ponto de interrupção definido anteriormente.At this point, VS Code connects to debugpy inside the Docker container and stops the Docker container at the breakpoint you set previously. Agora você pode percorrer o código enquanto ele é executado, exibir variáveis, ​​etc.You can now step through the code as it runs, view variables, etc.

Para obter mais informações sobre como usar o VS Code para depurar o Python, confira Depurar o código Python.For more information on using VS Code to debug Python, see Debug your Python code.

Parar o contêinerStop the container

Para parar o contêiner, use o seguinte comando:To stop the container, use the following command:

docker stop debug

Próximas etapasNext steps

Agora que você configurou o VS Code remoto, é possível usar uma instância de computação como computação remota do VS Code para depurar interativamente seu código.Now that you've set up VS Code Remote, you can use a compute instance as remote compute from VS Code to interactively debug your code.

Saiba mais sobre solução de problemas:Learn more about troubleshooting: