Solución de problemas con la implementación de Azure Machine Learning, Azure Kubernetes Service y Azure Container InstancesTroubleshooting Azure Machine Learning Azure Kubernetes Service and Azure Container Instances deployment

Obtenga información sobre cómo abordar, solucionar y resolver los errores comunes de implementación de Docker con Azure Container Instances (ACI) y Azure Kubernetes Service (AKS) mediante Azure Machine Learning.Learn how to work around or solve common Docker deployment errors with Azure Container Instances (ACI) and Azure Kubernetes Service (AKS) using Azure Machine Learning.

Al implementar un modelo en Azure Machine Learning, el sistema realiza una serie de tareas.When deploying a model in Azure Machine Learning, the system performs a number of tasks. Las tareas de implementación son:The deployment tasks are:

  1. Registrar el modelo en el registro de modelos del área de trabajo.Register the model in the workspace model registry.

  2. Compilar una imagen de Docker, incluido:Build a Docker image, including:

    1. Descargue el modelo registrado desde el registro.Download the registered model from the registry.
    2. Cree un archivo dockerfile, con un entorno de Python basado en las dependencias que especifique en el archivo yaml del entorno.Create a dockerfile, with a Python environment based on the dependencies you specify in the environment yaml file.
    3. Agregue los archivos del modelo y el script de puntuación que proporciona en el archivo dockerfile.Add your model files and the scoring script you supply in the dockerfile.
    4. Cree una nueva imagen de Docker con el archivo dockerfile.Build a new Docker image using the dockerfile.
    5. Registre la imagen de Docker en la instancia de Azure Container Registry asociada con el área de trabajo.Register the Docker image with the Azure Container Registry associated with the workspace.

    Importante

    En función del código, la creación de imágenes se realiza automáticamente sin que sea necesaria la entrada.Depending on your code, image creation happen automatically without your input.

  3. Implementar la imagen de Docker en el servicio de instancia de contenedor de Azure (ACI) o Azure Kubernetes Service (AKS).Deploy the Docker image to Azure Container Instance (ACI) service or to Azure Kubernetes Service (AKS).

  4. Iniciar un nuevo contenedor (o contenedores) en ACI o AKS.Start up a new container (or containers) in ACI or AKS.

Más información sobre este proceso en la introducción a la administración de modelos.Learn more about this process in the Model Management introduction.

Requisitos previosPrerequisites

Antes de empezarBefore you begin

Si tiene algún problema, lo primero es dividir la tarea de implementación (descrita anteriormente) en pasos individuales para aislar el problema.If you run into any issue, the first thing to do is to break down the deployment task (previous described) into individual steps to isolate the problem.

Dividir la implementación en tareas es útil si se utilizan las API Webservice.deploy() o Webservice.deploy_from_model(), ya que ambas funciones realizan los pasos mencionados anteriormente como una acción única.Breaking the deployment into tasks is helpful if you are using the Webservice.deploy() API, or Webservice.deploy_from_model() API, as both of these functions perform the aforementioned steps as a single action. Normalmente estas API son prácticas, pero resulta útil dividir los pasos para solucionar problemas al reemplazarlas por las siguientes llamadas API.Typically those APIs are convenient, but it helps to break up the steps when troubleshooting by replacing them with the below API calls.

  1. Registre el modelo.Register the model. Este es un código de ejemplo:Here's some sample code:

    # register a model out of a run record
    model = best_run.register_model(model_name='my_best_model', model_path='outputs/my_model.pkl')
    
    # or, you can register a file or a folder of files as a model
    model = Model.register(model_path='my_model.pkl', model_name='my_best_model', workspace=ws)
    
  2. Compile la imagen.Build the image. Este es un código de ejemplo:Here's some sample code:

    # configure the image
    image_config = ContainerImage.image_configuration(runtime="python",
                                                      entry_script="score.py",
                                                      conda_file="myenv.yml")
    
    # create the image
    image = Image.create(name='myimg', models=[model], image_config=image_config, workspace=ws)
    
    # wait for image creation to finish
    image.wait_for_creation(show_output=True)
    
  3. Implemente la imagen como servicio.Deploy the image as service. Este es un código de ejemplo:Here's some sample code:

    # configure an ACI-based deployment
    aci_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)
    
    aci_service = Webservice.deploy_from_image(deployment_config=aci_config, 
                                               image=image, 
                                               name='mysvc', 
                                               workspace=ws)
    aci_service.wait_for_deployment(show_output=True)    
    

Una vez que haya dividido el proceso de implementación en tareas individuales, se pueden observar algunos de los errores más comunes.Once you have broken down the deployment process into individual tasks, we can look at some of the most common errors.

Error de compilación de la imagenImage building fails

Si no se puede compilar la imagen de Docker, no se podrá realizar la llamada a image.wait_for_creation() o service.wait_for_deployment() con algunos mensajes de error que pueden dar algunas pistas.If the Docker image cannot be built, the image.wait_for_creation() or service.wait_for_deployment() call fails with some error messages that can offer some clues. También puede encontrar más detalles acerca de los errores en el registro de compilación de la imagen.You can also find out more details about the errors from the image build log. A continuación encontrará algunos ejemplos de código que muestra cómo detectar el URI del registro de compilación de la imagen.Below is some sample code showing how to discover the image build log uri.

# if you already have the image object handy
print(image.image_build_log_uri)

# if you only know the name of the image (note there might be multiple images with the same name but different version number)
print(ws.images['myimg'].image_build_log_uri)

# list logs for all images in the workspace
for name, img in ws.images.items():
    print(img.name, img.version, img.image_build_log_uri)

El URI del registro de la imagen es una dirección URL de SAS que apunta a un archivo de registro almacenado en Azure Blob Storage.The image log uri is a SAS URL pointing to a log file stored in your Azure blob storage. Simplemente copie el URI y péguelo en una ventana del explorador, y podrá descargar y ver el archivo de registro.Simply copy and paste the uri into a browser window and you can download and view the log file.

Directiva de acceso de Azure Key Vault y plantillas de Azure Resource ManagerAzure Key Vault access policy and Azure Resource Manager templates

La compilación de la imagen también puede producir un error debido a un problema con la directiva de acceso en Azure Key Vault.The image build can also fail due to a problem with the access policy on Azure Key Vault. Esta situación puede suceder cuando se usa una plantilla de Azure Resource Manager para crear el área de trabajo y los recursos asociados (incluido Azure Key Vault) varias veces.This situation can occur when you use an Azure Resource Manager template to create the workspace and associated resources (including Azure Key Vault), multiple times. Por ejemplo, con el uso de la plantilla varias veces con los mismos parámetros como parte de una canalización de implementación e integración continuas.For example, using the template multiple times with the same parameters as part of a continuous integration and deployment pipeline.

La mayoría de las operaciones de creación de recursos mediante plantillas son idempotentes, pero Key Vault borra las directivas de acceso cada vez que se usa la plantilla.Most resource creation operations through templates are idempotent, but Key Vault clears the access policies each time the template is used. Al borrar las directivas de acceso se interrumpe el acceso al almacén de claves en el área de trabajo existente que lo esté usando.Clearing the access policies breaks access to the Key Vault for any existing workspace that is using it. Esta condición produce errores cuando intenta crear nuevas imágenes.This condition results in errors when you try to create new images. Los siguientes son ejemplos de errores que puede recibir:The following are examples of the errors that you can receive:

Portal:Portal:

Create image "myimage": An internal server error occurred. Please try again. If the problem persists, contact support.

SDK:SDK:

image = ContainerImage.create(name = "myimage", models = [model], image_config = image_config, workspace = ws)
Creating image
Traceback (most recent call last):
  File "C:\Python37\lib\site-packages\azureml\core\image\image.py", line 341, in create
    resp.raise_for_status()
  File "C:\Python37\lib\site-packages\requests\models.py", line 940, in raise_for_status
    raise HTTPError(http_error_msg, response=self)
requests.exceptions.HTTPError: 500 Server Error: Internal Server Error for url: https://eastus.modelmanagement.azureml.net/api/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace-name>/images?api-version=2018-11-19

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python37\lib\site-packages\azureml\core\image\image.py", line 346, in create
    'Content: {}'.format(resp.status_code, resp.headers, resp.content))
azureml.exceptions._azureml_exception.WebserviceException: Received bad response from Model Management Service:
Response Code: 500
Headers: {'Date': 'Tue, 26 Feb 2019 17:47:53 GMT', 'Content-Type': 'application/json', 'Transfer-Encoding': 'chunked', 'Connection': 'keep-alive', 'api-supported-versions': '2018-03-01-preview, 2018-11-19', 'x-ms-client-request-id': '3cdcf791f1214b9cbac93076ebfb5167', 'x-ms-client-session-id': '', 'Strict-Transport-Security': 'max-age=15724800; includeSubDomains; preload'}
Content: b'{"code":"InternalServerError","statusCode":500,"message":"An internal server error occurred. Please try again. If the problem persists, contact support"}'

CLI:CLI:

ERROR: {'Azure-cli-ml Version': None, 'Error': WebserviceException('Received bad response from Model Management Service:\nResponse Code: 500\nHeaders: {\'Date\': \'Tue, 26 Feb 2019 17:34:05
GMT\', \'Content-Type\': \'application/json\', \'Transfer-Encoding\': \'chunked\', \'Connection\': \'keep-alive\', \'api-supported-versions\': \'2018-03-01-preview, 2018-11-19\', \'x-ms-client-request-id\':
\'bc89430916164412abe3d82acb1d1109\', \'x-ms-client-session-id\': \'\', \'Strict-Transport-Security\': \'max-age=15724800; includeSubDomains; preload\'}\nContent:
b\'{"code":"InternalServerError","statusCode":500,"message":"An internal server error occurred. Please try again. If the problem persists, contact support"}\'',)}

Para evitar este problema, se recomienda uno de los siguientes enfoques:To avoid this problem, we recommend one of the following approaches:

  • No implemente la plantilla de más de una vez con los mismos parámetros.Do not deploy the template more than once for the same parameters. O bien, elimine los recursos existentes antes de usar la plantilla para volver a crearlos.Or delete the existing resources before using the template to recreate them.
  • Examine las directivas de acceso de Key Vault y, luego, use estas directivas para establecer la propiedad accessPolicies de la plantilla.Examine the Key Vault access policies and then use these policies to set the accessPolicies property of the template.
  • Compruebe si ya existe el recurso de Key Vault.Check if the Key Vault resource already exists. Si es así, no lo vuelva a crear con la plantilla.If it does, do not recreate it through the template. Por ejemplo, agregue un parámetro que permita deshabilitar la creación del recurso de Key Vault si ya existe.For example, add a parameter that allows you to disable the creation of the Key Vault resource if it already exists.

Depuración localDebug locally

Si tiene problemas al implementar un modelo en ACI o AKS, intente implementarlo como un servicio web local.If you encounter problems deploying a model to ACI or AKS, try deploying it as a local web service. El uso de un servicio web local facilita la solución de problemas.Using a local web service makes it easier to troubleshoot problems. Se descarga la imagen de Docker que contiene el modelo y se inicia en el sistema local.The Docker image containing the model is downloaded and started on your local system.

Advertencia

No se admiten las implementaciones de servicios web locales en escenarios de producción.Local web service deployments are not supported for production scenarios.

Para implementar de forma local, modifique el código para usar LocalWebservice.deploy_configuration() con el fin de crear una configuración de implementación.To deploy locally, modify your code to use LocalWebservice.deploy_configuration() to create a deployment configuration. Luego use Model.deploy() para implementar el servicio.Then use Model.deploy() to deploy the service. En el ejemplo siguiente se implementa un modelo (incluido en la variable model) como un servicio web local:The following example deploys a model (contained in the model variable) as a local web service:

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import LocalWebservice

# Create inference configuration. This creates a docker image that contains the model.
inference_config = InferenceConfig(runtime="python",
                                   entry_script="score.py",
                                   conda_file="myenv.yml")

# Create a local deployment, using port 8890 for the web service endpoint
deployment_config = LocalWebservice.deploy_configuration(port=8890)
# Deploy the service
service = Model.deploy(
    ws, "mymodel", [model], inference_config, deployment_config)
# Wait for the deployment to complete
service.wait_for_deployment(True)
# Display the port that the web service is available on
print(service.port)

En este punto, se puede trabajar con el servicio de forma habitual.At this point, you can work with the service as normal. Por ejemplo, en el código siguiente se muestra cómo enviar datos al servicio:For example, the following code demonstrates sending data to the service:

import json

test_sample = json.dumps({'data': [
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
]})

test_sample = bytes(test_sample, encoding='utf8')

prediction = service.run(input_data=test_sample)
print(prediction)

Actualizar el servicioUpdate the service

Durante las pruebas locales, es posible que deba actualizar el archivo score.py para agregar un registro o intentar resolver los problemas que haya descubierto.During local testing, you may need to update the score.py file to add logging or attempt to resolve any problems that you've discovered. Para recargar los cambios realizados en el archivo score.py, use reload().To reload changes to the score.py file, use reload(). Por ejemplo, el código siguiente recarga el script para el servicio y luego envía datos.For example, the following code reloads the script for the service, and then sends data to it. Los datos se puntúan con el archivo score.py actualizado:The data is scored using the updated score.py file:

Importante

El método reload solo está disponible para las implementaciones locales.The reload method is only available for local deployments. Para obtener información sobre cómo actualizar una implementación en otro destino de proceso, consulte la sección de actualización de Implementación de modelos.For information on updating a deployment to another compute target, see the update section of Deploy models.

service.reload()
print(service.run(input_data=test_sample))

Nota

El script se recarga desde la ubicación que especifica el objeto InferenceConfig que usa el servicio.The script is reloaded from the location specified by the InferenceConfig object used by the service.

Para cambiar el modelo, las dependencias de Conda o la configuración de implementación, use update().To change the model, Conda dependencies, or deployment configuration, use update(). En el siguiente ejemplo se actualiza el modelo que usa el servicio:The following example updates the model used by the service:

service.update([different_model], inference_config, deployment_config)

Eliminación del servicioDelete the service

Para eliminar el servicio, use delete().To delete the service, use delete().

Inspección del registro de DockerInspect the Docker log

Puede imprimir los mensajes detallados de registro del motor de Docker desde el objeto de servicio.You can print out detailed Docker engine log messages from the service object. Puede ver el registro para ACI, AKS y las implementaciones locales.You can view the log for ACI, AKS, and Local deployments. En el ejemplo siguiente se muestra cómo imprimir los registros.The following example demonstrates how to print the logs.

# if you already have the service object handy
print(service.get_logs())

# if you only know the name of the service (note there might be multiple services with the same name but different version number)
print(ws.webservices['mysvc'].get_logs())

Error en el inicio del servicioService launch fails

Después de que la imagen se haya compilado correctamente, el sistema intenta iniciar un contenedor con el uso de la configuración de implementación.After the image is successfully built, the system attempts to start a container using your deployment configuration. Como parte del proceso de puesta en marcha del contenedor, el sistema invoca la función init() en el script de puntuación.As part of container starting-up process, the init() function in your scoring script is invoked by the system. Si hay excepciones no detectadas en la función init(), es posible que vea el error CrashLoopBackOff en el mensaje de error.If there are uncaught exceptions in the init() function, you might see CrashLoopBackOff error in the error message.

Use la información que aparece en la sección Inspeccionar el registro de Docker para comprobar los registros.Use the info in the Inspect the Docker log section to check the logs.

Error en la función: get_model_path()Function fails: get_model_path()

A menudo, en la función init() en el script de puntuación, se llama a la función Model.get_model_path() para buscar un archivo de modelo o una carpeta de archivos de modelo en el contenedor.Often, in the init() function in the scoring script, Model.get_model_path() function is called to locate a model file or a folder of model files in the container. Si no se encuentra el archivo de modelo o la carpeta, se produce un error en la función.If the model file or folder cannot be found, the function fails. La manera más fácil de depurar este error es ejecutar el siguiente código de Python en el shell del contenedor:The easiest way to debug this error is to run the below Python code in the Container shell:

from azureml.core.model import Model
import logging
logging.basicConfig(level=logging.DEBUG)
print(Model.get_model_path(model_name='my-best-model'))

En este ejemplo se imprime la ruta de acceso local (relativa a /var/azureml-app) en el contenedor donde el script de puntuación espera encontrar el archivo de modelo o la carpeta.This example prints out the local path (relative to /var/azureml-app) in the container where your scoring script is expecting to find the model file or folder. A continuación, puede comprobar si el archivo o la carpeta están realmente donde se espera que estén.Then you can verify if the file or folder is indeed where it is expected to be.

Establecer el nivel de registro en DEBUG puede provocar el registro de información adicional, que puede resultar útil para identificar el error.Setting the logging level to DEBUG may cause additional information to be logged, which may be useful in identifying the failure.

Error en la función: run(input_data)Function fails: run(input_data)

Si el servicio se implementa correctamente, pero se bloquea al publicar datos en el punto de conexión de puntuación, puede agregar una instrucción de captura de errores en la función run(input_data) para que devuelva un mensaje de error detallado en su lugar.If the service is successfully deployed, but it crashes when you post data to the scoring endpoint, you can add error catching statement in your run(input_data) function so that it returns detailed error message instead. Por ejemplo:For example:

def run(input_data):
    try:
        data = json.loads(input_data)['data']
        data = np.array(data)
        result = model.predict(data)
        return json.dumps({"result": result.tolist()})
    except Exception as e:
        result = str(e)
        # return error message back to the client
        return json.dumps({"error": result})

Nota: La devolución de mensajes de error de la llamada run(input_data) se debe realizar solo con fines de depuración.Note: Returning error messages from the run(input_data) call should be done for debugging purpose only. Por motivos de seguridad, no debe devolver los mensajes de error de este modo en un entorno de producción.For security reasons, you should not return error messages this way in a production environment.

Código de estado HTTP 503HTTP status code 503

Las implementaciones de Azure Kubernetes Service admiten el escalado automático, que permite que las réplicas se agreguen para admitir una carga adicional.Azure Kubernetes Service deployments support autoscaling, which allows replicas to be added to support additional load. Sin embargo, el escalador automático está diseñado para controlar cambios graduales en la carga.However, the autoscaler is designed to handle gradual changes in load. Si recibe grandes picos en las solicitudes por segundo, los clientes pueden recibir un código de estado HTTP 503.If you receive large spikes in requests per second, clients may receive an HTTP status code 503.

Hay dos cosas que ayudan a impedir los códigos de estado 503:There are two things that can help prevent 503 status codes:

  • Cambiar el nivel de uso en el que el escalado automático crea nuevas réplicas.Change the utilization level at which autoscaling creates new replicas.

    De forma predeterminada, se establece el uso de destino de escalado automático en el 70 %, lo que significa que el servicio puede controlar los picos en las solicitudes por segundo (RPS) de hasta un 30 %.By default, autoscaling target utilization is set to 70%, which means that the service can handle spikes in requests per second (RPS) of up to 30%. Puede ajustar el objetivo de uso mediante el establecimiento de autoscale_target_utilization en un valor inferior.You can adjust the utilization target by setting the autoscale_target_utilization to a lower value.

    Importante

    Este cambio no hace que las réplicas se creen más rápidamente.This change does not cause replicas to be created faster. En lugar de eso, se crean con un umbral de uso más bajo.Instead, they are created at a lower utilization threshold. En lugar de esperar a que el servicio se use en un 70 %, si se cambia el valor a un 30 %, las réplicas se crearán cuando se produzca este 30 % de uso.Instead of waiting until the service is 70% utilized, changing the value to 30% causes replicas to be created when 30% utilization occurs.

    Si el servicio web ya usa el número máximo de réplicas actuales y siguen apareciendo los códigos de estado 503, aumente el valor de autoscale_max_replicas con el fin de aumentar el número máximo de réplicas.If the web service is already using the current max replicas and you are still seeing 503 status codes, increase the autoscale_max_replicas value to increase the maximum number of replicas.

  • Cambie el número mínimo de réplicas.Change the minimum number of replicas. El aumento en el número mínimo de réplicas proporciona un grupo más grande para controlar los picos entrantes.Increasing the minimum replicas provides a larger pool to handle the incoming spikes.

    Para aumentar el número mínimo de réplicas, establezca autoscale_min_replicas en un valor superior.To increase the minimum number of replicas, set autoscale_min_replicas to a higher value. Puede calcular las réplicas necesarias mediante el código siguiente, reemplazando los valores por valores específicos del proyecto:You can calculate the required replicas by using the following code, replacing values with values specific to your project:

    from math import ceil
    # target requests per second
    targetRps = 20
    # time to process the request (in seconds)
    reqTime = 10
    # Maximum requests per container
    maxReqPerContainer = 1
    # target_utilization. 70% in this example
    targetUtilization = .7
    
    concurrentRequests = targetRps * reqTime / targetUtilization
    
    # Number of container replicas
    replicas = ceil(concurrentRequests / maxReqPerContainer)
    

    Nota

    Si recibe picos de solicitudes más grandes que el número mínimo nuevo de réplicas que se puede controlar, es posible que reciba códigos de estado 503 otra vez.If you receive request spikes larger than the new minimum replicas can handle, you may receive 503s again. Por ejemplo, a medida que el tráfico al servicio aumente, es posible que deba aumentar el número mínimo de réplicas.For example, as traffic to your service increases, you may need to increase the minimum replicas.

Para obtener más información sobre cómo configurar autoscale_target_utilization, autoscale_max_replicas, y autoscale_min_replicas, vea la referencia de módulo AksWebservice.For more information on setting autoscale_target_utilization, autoscale_max_replicas, and autoscale_min_replicas for, see the AksWebservice module reference.

Depuración avanzadaAdvanced debugging

En algunos casos, es posible que tenga que depurar interactivamente el código de Python incluido en la implementación de modelo.In some cases, you may need to interactively debug the Python code contained in your model deployment. Por ejemplo, si el script de entrada presenta errores y no se puede determinar el motivo mediante un registro adicional.For example, if the entry script is failing and the reason cannot be determined by additional logging. Mediante el uso de Visual Studio Code y las Herramientas de Python para Visual Studio (PTVSD), se puede adjuntar al código que se ejecuta dentro del contenedor de Docker.By using Visual Studio Code and the Python Tools for Visual Studio (PTVSD), you can attach to the code running inside the Docker container.

Importante

Este método de depuración no funciona cuando se usa Model.deploy() y LocalWebservice.deploy_configuration para implementar un modelo de manera local.This method of debugging does not work when using Model.deploy() and LocalWebservice.deploy_configuration to deploy a model locally. En su lugar, debe crear una imagen con la clase ContainerImage.Instead, you must create an image using the ContainerImage class.

Las implementaciones de servicios web locales requieren una instalación de Docker en funcionamiento en el sistema local.Local web service deployments require a working Docker installation on your local system. Para obtener más información sobre el uso de Docker, consulte la Documentación de Docker.For more information on using Docker, see the Docker Documentation.

Configuración del entorno de desarrolloConfigure development environment

  1. Para instalar las Herramientas de Python para Visual Studio (PTVSD) en el entorno de desarrollo de VS Code local, use el comando siguiente:To install the Python Tools for Visual Studio (PTVSD) on your local VS Code development environment, use the following command:

    python -m pip install --upgrade ptvsd
    

    Para más información sobre cómo usar PTVSD con VS Code, consulte Depuración remota.For more information on using PTVSD with VS Code, see Remote Debugging.

  2. Para configurar VS Code para comunicarse con la imagen de Docker, cree una configuración de depuración nueva:To configure VS Code to communicate with the Docker image, create a new debug configuration:

    1. En VS Code, seleccione el menú Depurar y, luego, seleccione Abrir configuraciones.From VS Code, select the Debug menu and then select Open configurations. Se abre un archivo denominado launch.json.A file named launch.json opens.

    2. En el archivo launch.json, busque la línea que contiene "configurations": [ e inserte el texto siguiente después de ella:In the launch.json file, find the line that contains "configurations": [, and insert the following text after it:

      {
          "name": "Azure Machine Learning: Docker Debug",
          "type": "python",
          "request": "attach",
          "port": 5678,
          "host": "localhost",
          "pathMappings": [
              {
                  "localRoot": "${workspaceFolder}",
                  "remoteRoot": "/var/azureml-app"
              }
          ]
      }
      

      Importante

      Si ya hay otras entradas en la sección de configuraciones, agregue una coma (,) después del código que insertó.If there are already other entries in the configurations section, add a comma (,) after the code that you inserted.

      Esta sección se adjunta al contenedor de Docker mediante el puerto 5678.This section attaches to the Docker container using port 5678.

    3. Guarde el archivo launch.json.Save the launch.json file.

Creación de una imagen que incluye PTVSDCreate an image that includes PTVSD

  1. Modifique el entorno de conda para la implementación de manera que incluya PTVSD.Modify the conda environment for your deployment so that it includes PTVSD. En el ejemplo siguiente se muestra cómo se agrega con el 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.17', 'ptvsd'])
    
    with open("myenv.yml","w") as f:
        f.write(myenv.serialize_to_string())
    
  2. Para iniciar PTVSD y esperar una conexión cuando se inicia el servicio, agregue lo siguiente en la parte superior del archivo score.py:To start PTVSD and wait for a connection when the service starts, add the following to the top of your score.py file:

    import ptvsd
    # Allows other computers to attach to ptvsd on this IP address and port.
    ptvsd.enable_attach(address=('0.0.0.0', 5678), redirect_output = True)
    # Wait 30 seconds for a debugger to attach. If none attaches, the script continues as normal.
    ptvsd.wait_for_attach(timeout = 30)
    print("Debugger attached...")
    
  3. Durante la depuración, es posible que quiera hacer cambios en los archivos de la imagen sin tener que volver a crearla.During debugging, you may want to make changes to the files in the image without having to recreate it. Para instalar un editor de texto (vim) en la imagen de Docker, cree un archivo de texto denominado Dockerfile.steps y use lo siguiente como el contenido del archivo:To install a text editor (vim) in the Docker image, create a new text file named Dockerfile.steps and use the following as the contents of the file:

    RUN apt-get update && apt-get -y install vim
    

    Un editor de texto le permite modificar los archivos dentro de la imagen de Docker para probar los cambios sin tener que crear una imagen.A text editor allows you to modify the files inside the docker image to test changes without creating a new image.

  4. Para crear una imagen que use el archivo Dockerfile.steps, use el parámetro docker_file al crear una imagen.To create an image that uses the Dockerfile.steps file, use the docker_file parameter when creating an image. En el ejemplo siguiente se muestra cómo hacerlo:The following example demonstrates how to do this:

    Nota

    En este ejemplo se da por supuesto que ws apunta al área de trabajo de Azure Machine Learning y que model es el modelo que se está implementando.This example assumes that ws points to your Azure Machine Learning workspace, and that model is the model being deployed. El archivo myenv.yml contiene las dependencias de conda creadas en el paso 1.The myenv.yml file contains the conda dependencies created in step 1.

    from azureml.core.image import Image, ContainerImage
    image_config = ContainerImage.image_configuration(runtime= "python",
                                 execution_script="score.py",
                                 conda_file="myenv.yml",
                                 docker_file="Dockerfile.steps")
    
    image = Image.create(name = "myimage",
                     models = [model],
                     image_config = image_config, 
                     workspace = ws)
    # Print the location of the image in the repository
    print(image.image_location)
    

Una vez que se crea la imagen, se muestra la ubicación de la imagen en el registro.Once the image has been created, the image location in the registry is displayed. La ubicación será similar al texto siguiente:The location is similar to the following text:

myregistry.azurecr.io/myimage:1

En este ejemplo de texto, el nombre del registro es myregistry y la imagen se denomina myimage.In this text example, the registry name is myregistry and the image is named myimage. La versión de la imagen es 1.The image version is 1.

Descarga de la imagenDownload the image

  1. Abra un símbolo del sistema, terminal u otro Shell y use el comando de la CLI de Azure siguiente para autenticarse en la suscripción de Azure que incluye el área de trabajo de Azure Machine Learning:Open a command prompt, terminal, or other shell and use the following Azure CLI command to authenticate to the Azure subscription that contains your Azure Machine Learning workspace:

    az login
    
  2. Para autenticarse en la instancia de Azure Container Registry (ACR) que contiene la imagen, use el comando siguiente.To authenticate to the Azure Container Registry (ACR) that contains your image, use the following command. Reemplace myregistry por el registro devuelto cuando registró la imagen:Replace myregistry with the one returned when you registered the image:

    az acr login --name myregistry
    
  3. Para descargar la imagen a la instancia de Docker local, use el comando siguiente.To download the image to your local Docker, use the following command. Reemplace myimagepath por la ubicación devuelta cuando registró la imagen:Replace myimagepath with the location returned when you registered the image:

    docker pull myimagepath
    

    La ruta de acceso de imagen debe ser similar a myregistry.azurecr.io/myimage:1.The image path should be similar to myregistry.azurecr.io/myimage:1. Donde myregistry es el registro, myimage es la imagen y 1 es la versión de la imagen.Where myregistry is your registry, myimage is your image, and 1 is the image version.

    Sugerencia

    La autenticación del paso anterior no es permanente.The authentication from the previous step does not last forever. Si espera lo suficiente entre el comando de autenticación y el comando de incorporación de datos, recibirá un error de autenticación.If you wait long enough between the authentication command and the pull command, you will receive an authentication failure. Si esto ocurre, vuelva a autenticarse.If this happens, reauthenticate.

    El tiempo que tarda en completar la descarga depende de la velocidad de su conexión a Internet.The time it takes to complete the download depends on the speed of your internet connection. Durante el proceso se muestra un estado de la descarga.A download status is displayed during the process. Una vez que se complete la descarga, puede usar el comando docker images para comprobar que se descargó.Once the download is complete, you can use the docker images command to verify that it has downloaded.

  4. Para facilitar el trabajo con la imagen, use el comando siguiente para agregar una etiqueta.To make it easier to work with the image, use the following command to add a tag. Reemplace myimagepath por el valor de la ubicación del paso 2.Replace myimagepath with the location value from step 2.

    docker tag myimagepath debug:1
    

    Para el resto de los pasos, puede hacer referencia a la imagen local como debug:1 en lugar del valor de la ruta de acceso completa a la imagen.For the rest of the steps, you can refer to the local image as debug:1 instead of the full image path value.

Depuración del servicioDebug the service

Sugerencia

Si establece un tiempo de expiración para la conexión de PTVSD en el archivo score.py, debe conectar VS Code a la sesión de depuración antes de que se cumpla el tiempo de expiración.If you set a timeout for the PTVSD connection in the score.py file, you must connect VS Code to the debug session before the timeout expires. Inicie VS Code, abra la copia local de score.py, establezca un punto de interrupción y prepárelo antes de seguir los pasos de esta sección.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 más información sobre la depuración y el establecimiento de puntos de interrupción, consulte Depuración.For more information on debugging and setting breakpoints, see Debugging.

  1. Para iniciar un contenedor de Docker con la imagen, use el comando siguiente:To start a Docker container using the image, use the following command:

    docker run --rm --name debug -p 8000:5001 -p 5678:5678 debug:1
    
  2. Para adjuntar VS Code a PTVSD dentro del contenedor, abra VS Code y use la tecla F5 o seleccione Depurar.To attach VS Code to PTVSD inside the container, open VS Code and use the F5 key or select Debug. Cuando se le solicite, seleccione la configuración Azure Machine Learning: Docker Debug (Azure Machine Learning Service: depuración de Docker).When prompted, select the Azure Machine Learning: Docker Debug configuration. También puede seleccionar el icono de depuración en la barra lateral, la entrada Azure Machine Learning: Docker Debug (Azure Machine Learning Service: depuración de Docker) en el menú desplegable Depurar y, luego, use la flecha verde para adjuntar el depurador.You can also select the debug icon from the side bar, the Azure Machine Learning: Docker Debug entry from the Debug dropdown menu, and then use the green arrow to attach the debugger.

    El icono de depuración, el botón de inicio de la depuración y el selector de configuración

En este punto, VS Code se conecta a PTVSD dentro del contenedor de Docker y se detiene en el punto de interrupción que se estableció anteriormente.At this point, VS Code connects to PTVSD inside the Docker container and stops at the breakpoint you set previously. Ahora puede recorrer el código a medida que se ejecuta, ver variables, etc.You can now step through the code as it runs, view variables, etc.

Para más información sobre cómo usar VS Code para implementar Python, consulte Depurar el código de Python.For more information on using VS Code to debug Python, see Debug your Python code.

Modificación de los archivos de contenedorModify the container files

Para hacer cambios en los archivos de la imagen, puede adjuntar el contenedor en ejecución y ejecutar un shell de Bash.To make changes to files in the image, you can attach to the running container, and execute a bash shell. Desde ahí, puede usar vim para editar los archivos:From there, you can use vim to edit files:

  1. Para conectarse al contenedor en ejecución e iniciar un shell de Bash en el contenedor, use este comando:To connect to the running container and launch a bash shell in the container, use the following command:

    docker exec -it debug /bin/bash
    
  2. Para buscar los archivos que usa el servicio, use el comando siguiente desde el shell de Bash en el contenedor:To find the files used by the service, use the following command from the bash shell in the container:

    cd /var/azureml-app
    

    Desde aquí, puede usar vim para editar el archivo score.py.From here, you can use vim to edit the score.py file. Para más información sobre el uso de vim, consulte el artículo sobre cómo usar el editor Vim.For more information on using vim, see Using the Vim editor.

  3. Por lo general, los cambios realizados en un contenedor no se conservan.Changes to a container are not normally persisted. Para guardar los cambios que haga, use el comando siguiente antes de salir del shell que se inició en el paso anterior (es decir, en otro shell):To save any changes you make, use the following command, before you exit the shell started in the step above (that is, in another shell):

    docker commit debug debug:2
    

    Este comando crea una imagen denominada debug:2 que contiene las ediciones.This command creates a new image named debug:2 that contains your edits.

    Sugerencia

    Deberá detener el contenedor actual y empezar a usar la versión nueva antes de que los cambios surtan efecto.You will need to stop the current container and start using the new version before changes take effect.

  4. Asegúrese de mantener los cambios que haga en los archivos del contenedor sincronizados con los archivos locales que usa VS Code.Make sure to keep the changes you make to files in the container in sync with the local files that VS Code uses. De lo contrario, la experiencia del depurador no funcionará según lo esperado.Otherwise, the debugger experience will not work as expected.

Detención del contenedorStop the container

Para detener el contenedor, use el comando siguiente:To stop the container, use the following command:

docker stop debug

Pasos siguientesNext steps

Más información acerca de la implementación:Learn more about deployment: