Uso de un contenedor personalizado para implementar un modelo en un punto de conexión en línea

APLICA A:Extensión CLI de Azure ml v2 (actual)SDK de Python azure-ai-ml v2 (actual)

En Azure Machine Learning, puede usar un contenedor personalizado para implementar un modelo en un punto de conexión en línea. Las implementaciones de contenedores personalizadas pueden usar servidores web distintos del Python servidor de Flask predeterminado que Azure Machine Learning usa.

Al usar una implementación personalizada, puede hacer lo siguiente:

Use varias herramientas y tecnologías, como TensorFlow Serving (TF Serving), TorchServe, Triton Inference Server, el paquete Plumber R y la imagen mínima de inferencia Azure Machine Learning.
Sigue aprovechando la supervisión integrada, el escalado, las alertas y la autenticación que Azure Machine Learning ofrece.

En este artículo se muestra cómo usar una imagen de servicio de TF para servir un modelo de TensorFlow.

Prerequisites

Un área de trabajo de Azure Machine Learning. Para obtener instrucciones para crear un área de trabajo, consulte Creación del área de trabajo.
La CLI de Azure y la extensión ml o el SDK de Python de Azure Machine Learning v2:
- CLI de Azure
- SDK de Python
Para instalar el CLI de Azure y la extensión ml, consulte Install y configure la CLI (v2).

En los ejemplos de este artículo se supone que se usa un shell de Bash o un shell compatible. Por ejemplo, puede usar un shell en un sistema Linux o Subsistema de Windows para Linux.
- Python 3.10 o posterior.
Para instalar el SDK de Python v2, use el siguiente comando:
```
pip install azure-ai-ml azure-identity
```
Para actualizar una instalación existente del SDK a la versión más reciente, use el siguiente comando:
```
pip install --upgrade azure-ai-ml azure-identity
```
Para obtener más información, consulte biblioteca cliente de Azure Machine Learning Package para Python.

Un Azure grupo de recursos que contiene el área de trabajo y al que usted o la entidad de servicio tienen acceso colaborador. Si usa los pasos descritos en Creación del área de trabajo para configurar el área de trabajo, cumple este requisito.
Motor de Docker, instalado y ejecutándose localmente. Este requisito previo es muy recomendable. Necesita implementar un modelo localmente y resulta útil para la depuración.

Ejemplos de implementación

En la tabla siguiente se enumeran ejemplos de implementación que usan contenedores personalizados y aprovechan diversas herramientas y tecnologías.

Example	script de CLI de Azure	Description
minimal/multimodel	desplegar-contenedor-personalizado-minimodelo-multimodelo	Implementa varios modelos en una sola implementación mediante la extensión de la imagen mínima de inferencia de Azure Machine Learning.
minimal/single-model	desplegar-contenedor-personalizado-mínimo-modelo-único	Implementa un único modelo mediante la extensión de la imagen mínima de inferencia de Azure Machine Learning.
mlflow/multideployment-scikit	desplegar-contenedor-personalizado-mlflow-multidespliegue-scikit	Implementa dos modelos de MLFlow con requisitos de Python diferentes en dos implementaciones independientes detrás de un único punto de conexión. Usa la imagen mínima de inferencia de Azure Machine Learning.
r/multimodel-plumber	deploy-custom-container-r-multimodel-plumber	Implementa tres modelos de regresión en un punto de conexión. Usa el paquete Plumber R.
tfserving/half-plus-two	deploy-custom-container-tfserving-mitad-más-dos	Implementa un modelo Half Plus Two mediante un contenedor personalizado tf Serving. Usa el proceso de registro de modelos estándar.
tfserving/half-plus-two-integrated	deploy-custom-container-tfserving-half-plus-two-integrated	Implementa un modelo Half Plus Two mediante un contenedor personalizado tf Serving con el modelo integrado en la imagen.
torchserve/densenet	deploy-custom-container-torchserve-densenet	Implementa un único modelo mediante un contenedor personalizado de TorchServe.
triton/single-model	deploy-custom-container-triton-single-model	Implementa un modelo de Triton mediante un contenedor personalizado.

En este artículo se muestra cómo usar el ejemplo.

Warning

Es posible que los equipos de soporte técnico de Microsoft no puedan ayudar a solucionar problemas causados por una imagen personalizada. Si tiene problemas, es posible que le pidan que use la imagen predeterminada o una de las imágenes que Proporciona Microsoft para ver si el problema es específico de la imagen.

Descarga del código fuente

Los pasos de este artículo usan ejemplos de código del repositorio azureml-examples. Use los comandos siguientes para clonar el repositorio:

CLI de Azure
SDK de Python

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

En el repositorio de ejemplos, puede encontrar la mayoría de los ejemplos de Python en la carpeta sdk/python. Para este artículo, vaya a la carpeta correspondiente. La estructura de carpetas de la carpeta es ligeramente diferente de la estructura. La mayoría de los pasos de este artículo requieren la estructura.

Para seguir los pasos de ejemplo, consulte un cuaderno Jupyter notebook en el repositorio de ejemplos. Sin embargo, las secciones siguientes de ese cuaderno se ejecutan desde la carpeta en lugar de la carpeta :

1. Probar localmente
1. Prueba del punto de conexión con datos de ejemplo

Inicialización de las variables de entorno

Para usar un modelo de TensorFlow, necesita varias variables de entorno. Ejecute los siguientes comandos para definir esas variables:

BASE_PATH=endpoints/online/custom-container/tfserving/half-plus-two
AML_MODEL_NAME=tfserving-mounted
MODEL_NAME=half_plus_two
MODEL_BASE_PATH=/var/azureml-app/azureml-models/$AML_MODEL_NAME/1

Descarga de un modelo de TensorFlow

Descargue y descomprima un modelo que divide un valor de entrada por dos y agrega dos al resultado:

wget https://aka.ms/half_plus_two-model -O $BASE_PATH/half_plus_two.tar.gz
tar -xvf $BASE_PATH/half_plus_two.tar.gz -C $BASE_PATH

Prueba una imagen de TF Serving localmente

Use Docker para ejecutar la imagen localmente para realizar pruebas:

docker run --rm -d -v $PWD/$BASE_PATH:$MODEL_BASE_PATH -p 8501:8501 \
 -e MODEL_BASE_PATH=$MODEL_BASE_PATH -e MODEL_NAME=$MODEL_NAME \
 --name="tfserving-test" docker.io/tensorflow/serving:latest
sleep 10

Envío de solicitudes de ejecución y puntuación a la imagen

Envíe una solicitud de ejecución para comprobar que el proceso dentro del contenedor se está ejecutando. Debería obtener un código de estado de respuesta de 200 OK.

curl -v http://localhost:8501/v1/models/$MODEL_NAME

Envíe una solicitud de puntuación para comprobar que puede obtener predicciones de datos sin etiquetar:

curl --header "Content-Type: application/json" \
  --request POST \
  --data @$BASE_PATH/sample_request.json \
  http://localhost:8501/v1/models/$MODEL_NAME:predict

Detención de la imagen

Cuando termine de probar localmente, detenga la imagen:

docker stop tfserving-test

Despliega tu extremo en línea en Azure

Para implementar el punto de conexión en línea en Azure, siga los pasos descritos en las secciones siguientes.

CLI de Azure
SDK de Python

Creación de archivos YAML para el punto de conexión y la implementación

Puede configurar la implementación en la nube mediante YAML. Por ejemplo, para configurar el punto de conexión, cree un archivo YAML denominado que contenga las siguientes líneas:

$schema: https://azuremlsdk2.blob.core.windows.net/latest/managedOnlineEndpoint.schema.json
name: tfserving-endpoint
auth_mode: aml_token

Para configurar la implementación, cree un archivo YAML denominado que contenga las siguientes líneas:

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: <model-version>
  path: ./half_plus_two
environment_variables:
  MODEL_BASE_PATH: /var/azureml-app/azureml-models/tfserving-mounted/<model-version>
  MODEL_NAME: half_plus_two
environment:
  #name: tfserving
  #version: 1
  image: docker.io/tensorflow/serving:latest
  inference_config:
    liveness_route:
      port: 8501
      path: /v1/models/half_plus_two
    readiness_route:
      port: 8501
      path: /v1/models/half_plus_two
    scoring_route:
      port: 8501
      path: /v1/models/half_plus_two:predict
instance_type: Standard_DS3_v2
instance_count: 1

Conexión al área de trabajo de Azure Machine Learning

Para configurar el área de trabajo de Azure Machine Learning, siga estos pasos:

Importe las bibliotecas necesarias:

# Import the required libraries.
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
   ManagedOnlineEndpoint,
   ManagedOnlineDeployment,
   Model,
   Environment,
)
from azure.identity import DefaultAzureCredential

Configure las opciones del área de trabajo y obtenga un identificador para el área de trabajo:

# Enter information about your Azure Machine Learning workspace.
subscription_id = "<subscription-ID>"
resource_group = "<resource-group-name>"
workspace = "<Azure-Machine-Learning-workspace-name>"

# Get a handle to the workspace.
ml_client = MLClient(
  DefaultAzureCredential(), subscription_id, resource_group, workspace
)

Para obtener más información, consulte Implementación y puntuación de un modelo de Machine Learning mediante un punto de conexión online.

Configuración de un punto de conexión en línea

Use el código siguiente para configurar un punto de conexión en línea. Tenga en cuenta los siguientes puntos:

El nombre del punto de conexión debe ser único en su región de Azure. Además, un nombre de punto de conexión debe comenzar con una letra y solo constar de caracteres alfanuméricos y guiones. Para obtener más información sobre las reglas de nomenclatura, consulte Azure Machine Learning puntos de conexión en línea y puntos de conexión por lotes.
Para el valor , use para la autenticación basada en claves. Use aml_token para la autenticación basada en tokens de Azure Machine Learning. Usar aad_token para la autenticación basada en tokens de Microsoft Entra. Una clave no expira, pero y expira. Para obtener más información sobre la autenticación, consulte Autenticación de clientes para puntos de conexión en línea.
La descripción y las etiquetas son opcionales.

# To create a unique endpoint name, use a time stamp of the current date and time.
import datetime

online_endpoint_name = "endpoint-" + datetime.datetime.now().strftime("%m%d%H%M%f")

# Configure an online endpoint.
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="A sample online endpoint",
    auth_mode="key",
    tags={"env": "dev"},
)

Configuración de una implementación en línea

Una implementación es un conjunto de recursos necesarios para hospedar el modelo que realiza la inferencia real. Use la clase para configurar una implementación para el punto de conexión. El constructor de esa clase usa los parámetros siguientes:

: nombre de la implementación.
: nombre del punto de conexión en el que se va a crear la implementación.
: modelo que se va a usar para la implementación. Este valor puede ser una referencia a un modelo con versiones existente en el área de trabajo o una especificación de modelo en línea.
: entorno que se va a usar para la implementación. Este valor puede ser una referencia a un entorno con versiones existente en el área de trabajo o una especificación de entorno en línea.
: variables de entorno que se establecen durante la implementación.
- : ruta de acceso a la carpeta primaria que contiene una carpeta para el modelo.
- : Nombre del modelo.
: el tamaño de la máquina virtual que se va a usar para la implementación. Para la lista de tamaños admitidos, consulte Lista de SKU de puntos de conexión en línea administrados.
: número de instancias que se van a usar para la implementación.

Use el código siguiente para configurar una implementación para el punto de conexión:

# create a blue deployment
model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

env = Environment(
    image="docker.io/tensorflow/serving:latest",
    inference_config={
        "liveness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "readiness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "scoring_route": {"port": 8501, "path": "/v1/models/half_plus_two:predict"},
    },
)

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    environment_variables={
        "MODEL_BASE_PATH": "/var/azureml-app/azureml-models/tfserving-mounted/1",
        "MODEL_NAME": "half_plus_two",
    },
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

En las secciones siguientes se describen conceptos importantes sobre los parámetros YAML y Python.

Imagen base

En la sección de YAML o el constructor /> de

Si inspecciona el contenedor, puede ver que este servidor usa comandos para iniciar un script de punto de entrada. Ese script toma variables de entorno como y , y expone puertos como . Estos detalles pertenecen a este servidor y puede usar esta información para determinar cómo definir la implementación. Por ejemplo, si establece las variables de entorno y en la definición de implementación, TF Serving usa esos valores para iniciar el servidor. Del mismo modo, si establece el puerto para cada ruta en en la definición de implementación, las solicitudes de usuario a esas rutas se enrutan correctamente al servidor TF Serving.

Este ejemplo se basa en el caso tf Serving. Sin embargo, puede usar cualquier contenedor que permanezca funcionando y responda a las solicitudes que van a las rutas de disponibilidad, preparación y puntuación. Para ver cómo formar un Dockerfile para crear un contenedor, consulte otros ejemplos. Algunos servidores usan instrucciones en lugar de instrucciones.

Sugerencia

En el caso de las implementaciones de producción, ancle a una versión de imagen específica (por ejemplo, ) en lugar de usar para garantizar implementaciones reproducibles.

Parámetro de configuración de inferencia

En la sección o la clase , es un parámetro . Especifica el puerto y la ruta de acceso para tres tipos de rutas: disponibilidad, preparación y puntuación. El parámetro es necesario si desea ejecutar su propio contenedor con un punto de conexión en línea administrado.

Rutas de preparación frente a rutas de ejecución

Algunos servidores de API proporcionan una manera de comprobar el estado del servidor. Hay dos tipos de rutas que puede especificar para comprobar el estado:

Rutas de ejecución : para comprobar si un servidor se está ejecutando, use una ruta de ejecución.
Rutas de preparación : para comprobar si un servidor está listo para funcionar, use una ruta de preparación.

En el contexto de la inferencia de aprendizaje automático, un servidor puede responder con un código de estado 200 Ok a una solicitud de ejecución antes de cargar un modelo. El servidor puede responder con un código de estado 200 OK a una solicitud de disponibilidad solo después de cargar el modelo en memoria.

Para obtener más información sobre los sondeos de estado activo y preparación, consulte Configurar sondeos de estado activo, preparación y inicio.

El servidor de API que elija determina las rutas de ejecución y preparación. Identifica ese servidor en un paso anterior al probar el contenedor localmente. En este artículo, la implementación de ejemplo usa la misma ruta de acceso para las rutas de ejecución y preparación, ya que TF Serving solo define una ruta de ejecución. Para ver otras formas de definir las rutas, consulte otros ejemplos.

Rutas de puntuación

El servidor de API que usa proporciona una manera de recibir la carga útil en la que trabajar. En el contexto de la inferencia de aprendizaje automático, un servidor recibe los datos de entrada a través de una ruta específica. Identifique esa ruta para el servidor de API al probar el contenedor localmente en un paso anterior. Especifique esa ruta como ruta de puntuación al definir la implementación que se va a crear.

La exitosa creación de la implementación también actualiza el parámetro del punto de conexión. Para comprobar este hecho, ejecute el siguiente comando: .

Buscar el modelo montado

Al implementar un modelo como punto de conexión en línea, Azure Machine Learning monta el modelo en el punto de conexión. Cuando se monta el modelo, puede implementar nuevas versiones del modelo sin tener que crear una nueva imagen de Docker. De forma predeterminada, un modelo registrado con el nombre my-model y la versión 1 se encuentra en la siguiente ruta de acceso dentro del contenedor implementado: /var/azureml-app/azureml-models/my-model/1.

Por ejemplo, considere la siguiente configuración:

Estructura de directorios en una máquina local
Nombre de modelo de

Captura de pantalla que muestra una vista de árbol de una estructura de directorios local. La ruta de acceso /azureml-examples/cli/endpoints/online/custom-container está visible.

CLI de Azure
SDK de Python

Supongamos que el archivo contiene las siguientes líneas en su sección. En esta sección, el valor name hace referencia al nombre que se usa para registrar el modelo en Azure Machine Learning.

model:
    name: tfserving-mounted
    version: 1
    path: ./half_plus_two

Supongamos que usa el código siguiente para crear una clase. En este código, el valor name hace referencia al nombre que se usa para registrar el modelo en Azure Machine Learning.

model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

En este caso, al crear una implementación, el modelo se encuentra en la carpeta siguiente: .

Captura de pantalla que muestra una vista de árbol de la estructura del directorio de implementación. La ruta de acceso var/azureml-app/azureml-models/tfserving-mounted/1 está visible.

Puede configurar opcionalmente el valor . Al ajustar esta configuración, puede cambiar la ruta de acceso donde se monta el modelo.

Important

El valor debe ser una ruta de acceso absoluta válida en Linux (en el sistema operativo invitado de la imagen de contenedor).

Important

Solo se puede usar en un escenario BYOC (trae tu propio contenedor). En un escenario BYOC, el entorno que usa la implementación en línea debe tener configurado el parámetro . Use la CLI de Azure Machine Learning o el SDK de Python para especificar el parámetro inference_config al crear el entorno. Actualmente, Studio no admite la especificación de este parámetro.

Al cambiar el valor de , también debe actualizar la variable de entorno . Ajuste al mismo valor que para evitar una implementación fallida debido a un error relacionado con la ruta de acceso base que no se ha encontrado.

CLI de Azure
SDK de Python

Por ejemplo, puede agregar el parámetro al archivo. También puede actualizar el valor en ese archivo.

name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: 1
  path: ./half_plus_two
model_mount_path: /var/tfserving-model-mount
environment_variables:
  MODEL_BASE_PATH: /var/tfserving-model-mount
...

Por ejemplo, puede agregar el parámetro a la clase . También puede actualizar el valor en ese código.

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    model_mount_path="/var/tfserving-model-mount",
    environment_variables={
        "MODEL_BASE_PATH": "/var/tfserving-model-mount",
    ...
)

En tu implementación, el modelo se encuentra en . Ya no está en , pero en la ruta de acceso de montaje que especifique:

Captura de pantalla que muestra una vista de árbol de la estructura del directorio de implementación. La ruta de acceso /var/tfserving-model-mount/tfserving-mounted/1 está visible.

Creación del punto de conexión y la implementación

CLI de Azure
SDK de Python

Después de construir el archivo YAML, use el siguiente comando para crear el punto de conexión:

az ml online-endpoint create --name tfserving-endpoint -f endpoints/online/custom-container/tfserving/half-plus-two/tfserving-endpoint.yml

Use el comando siguiente para crear la implementación. Este paso puede ejecutarse durante unos minutos.

az ml online-deployment create --name tfserving-deployment -f endpoints/online/custom-container/tfserving/half-plus-two/tfserving-deployment.yml --all-traffic

Use el código siguiente para crear el punto de conexión en el área de trabajo. Este código usa la instancia de que creó anteriormente. El método inicia la creación del punto de conexión. A continuación, devuelve una respuesta de confirmación mientras continúa la creación del punto de conexión.

ml_client.begin_create_or_update(endpoint)

Cree la implementación mediante la ejecución del código siguiente:

ml_client.begin_create_or_update(blue_deployment)

Invocación del punto de conexión

Una vez completada la implementación, realice una solicitud de puntuación al punto de conexión implementado.

CLI de Azure
SDK de Python

RESPONSE=$(az ml online-endpoint invoke -n $ENDPOINT_NAME --request-file $BASE_PATH/sample_request.json)

Usa la instancia de que creó anteriormente para obtener un identificador al punto de conexión. A continuación, use el método y los parámetros siguientes para invocar el punto de conexión:

: nombre del punto de conexión.
: el archivo que contiene los datos de solicitud.
: nombre de la implementación que se va a probar en el punto de conexión.

Para los datos de solicitud, puede usar un archivo JSON de ejemplo del repositorio example.

# Test the blue deployment by using some sample data.
response = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="sample_request.json",
)

Eliminación del punto de conexión

Si ya no necesita el punto de conexión, ejecute el siguiente comando para eliminarlo:

CLI de Azure
SDK de Python

az ml online-endpoint delete --name tfserving-endpoint

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Implementación segura de nuevas implementaciones para la inferencia en tiempo real
Solución de problemas de implementación y puntuación de puntos de conexión en línea
Ejemplo de Torch Serve

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-03-06