Cómo implementar canalizaciones con puntos de conexión por lotes

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

Puedes implementar componentes de canalización en un punto de conexión por lotes, lo que proporciona una manera conveniente de ponerlos en funcionamiento en Azure Machine Learning. En este artículo, aprenderás a crear una implementación por lotes que contenga una canalización sencilla. Aprenderá lo siguiente:

Crear y registrar un componente de canalización
Crear un endpoint de procesamiento por lotes y desplegar un componente de la canalización
Prueba de la implementación

Acerca de este ejemplo

En este ejemplo, implementará un componente de canalización que consta de un trabajo de comando simple que imprime "¡hola mundo!". Este componente no requiere entradas ni salidas y es el escenario de implementación de canalización más sencillo.

El ejemplo de este artículo se basa en ejemplos de código contenidos en el repositorio azureml-examples. Para ejecutar los comandos localmente sin tener que copiar o pegar YAML y otros archivos, use los siguientes comandos para clonar el repositorio e ir a la carpeta del lenguaje de codificación:

CLI de Azure
Pitón

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/sdk/python

Los archivos de este ejemplo están en:

cd endpoints/batch/deploy-pipelines/hello-batch

Sigue estos pasos en los cuadernos de Jupyter Notebooks

Puedes seguir la versión SDK de Python de este ejemplo abriendo el cuaderno sdk-deploy-and-test.ipynb en el repositorio clonado.

Requisitos previos

Suscripción a Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita.
Un área de trabajo de Azure Machine Learning. Para crear un área de trabajo, vea Administración de áreas de trabajo de Azure Machine Learning.
Los siguientes permisos en el área de trabajo de Azure Machine Learning:
- Para crear o administrar puntos de conexión e implementaciones por lotes: use un rol de propietario, colaborador o personalizado que tenga los Microsoft.MachineLearningServices/workspaces/batchEndpoints/* permisos.
- Para crear implementaciones de Azure Resource Manager en el grupo de recursos del área de trabajo: use un rol propietario, colaborador o personalizado que tenga el Microsoft.Resources/deployments/write permiso en el grupo de recursos donde se implementa el área de trabajo.
La CLI de Azure Machine Learning o el SDK de Azure Machine Learning para Python:
- CLI de Azure
- Pitón
Ejecute el siguiente comando para instalar la CLI de Azure y la extensión ml para Azure Machine Learning:
```
az extension add -n ml
```
Las implementaciones de componentes de canalización para puntos de conexión por lotes requieren la versión 2.7 o posterior de la extensión para la ml CLI de Azure (versión actual: 2.37.0). Use el comando az extension update --name ml para obtener la versión más reciente.
Ejecute el siguiente comando para instalar el SDK de Azure Machine Learning para Python:
```
pip install azure-ai-ml
```
Las ModelBatchDeployment clases y PipelineComponentBatchDeployment requieren la versión 1.7.0 o posterior del SDK (versión actual: 1.32.0). Use el comando pip install -U azure-ai-ml para obtener la versión más reciente.

Conexión con su área de trabajo

El área de trabajo es el recurso de nivel superior de Azure Machine Learning. Proporciona un lugar centralizado para trabajar con todos los artefactos que cree al usar Azure Machine Learning. En esta sección, se conectará al área de trabajo donde realizará las tareas de implementación.

CLI de Azure
Pitón

En el siguiente comando, escriba el id. de suscripción, el nombre del área de trabajo, el nombre de grupo de recursos y la ubicación:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Importe las bibliotecas necesarias:

from azure.ai.ml import MLClient, Input, load_component
from azure.ai.ml.entities import BatchEndpoint, ModelBatchDeployment, ModelBatchDeploymentSettings, PipelineComponentBatchDeployment, Model, AmlCompute, Data, BatchRetrySettings, CodeConfiguration, Environment, Data
from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
from azure.ai.ml.dsl import pipeline
from azure.identity import DefaultAzureCredential

Configura los detalles del área de trabajo y obtén acceso al área de trabajo:

En el siguiente comando, escriba el id. de suscripción, el nombre del grupo de recursos y el nombre del área de trabajo:
```
subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
```

Crear el componente de canalización

Los puntos de conexión de Batch pueden implementar modelos o componentes de canalización. Los componentes de canalización son reutilizables y puedes optimizar tu práctica de MLOps mediante el uso de registros compartidos para mover estos componentes de un área de trabajo a otro.

El componente de canalización en este ejemplo contiene un solo paso que solo imprime un mensaje de "hola mundo" en los registros. No requiere entradas ni salidas.

El archivo hello-component/hello.yml contiene la configuración del componente de canalización:

hello-component/hello.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
name: hello_batch
display_name: Hello Batch component
version: 1
type: pipeline
jobs:
  main_job:
    type: command
    component:
      code: src
      environment: azureml://registries/azureml/environments/sklearn-1.5/labels/latest
      command: >-
        python hello.py

Registra el componente:

CLI de Azure
Pitón

az ml component create -f hello-component/hello.yml

hello_batch = load_component(source="hello-component/hello.yml")
hello_batch_registered = ml_client.components.create_or_update(hello_batch)

Creación de un punto de conexión por lotes

Proporcione un nombre para el punto de conexión. El nombre de un punto de conexión por lotes debe ser único en cada región, ya que el nombre se usa para construir el URI de invocación. Para garantizar la unicidad, anexa los caracteres finales al nombre especificado en el código siguiente.
- CLI de Azure
- Pitón
```
ENDPOINT_NAME="hello-batch"
```
```
endpoint_name = "hello-batch"
```

Configuración del punto de conexión:

CLI de Azure
Pitón

El archivo endpoint.yml contiene la configuración del punto de conexión.

endpoint.yml

$schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: hello-batch
description: A hello world endpoint for component deployments.
auth_mode: aad_token

endpoint = BatchEndpoint(
    name=endpoint_name,
    description="A hello world endpoint for component deployments",
)

Creación del punto de conexión:

CLI de Azure
Pitón

az ml batch-endpoint create --name $ENDPOINT_NAME  -f endpoint.yml

ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

Consulta del URI del punto de conexión:

CLI de Azure
Pitón

az ml batch-endpoint show --name $ENDPOINT_NAME

endpoint = ml_client.batch_endpoints.get(name=endpoint_name)
print(endpoint)

Implementar el componente de canalización

Para implementar el componente de canalización, debe crear una implementación por lotes. Una implementación es un conjunto de recursos necesarios para hospedar el recurso que realiza el trabajo real.

Crear un clúster de computación. Las implementaciones y puntos de conexión por lotes se ejecutan en clústeres de computación. Pueden ejecutarse en cualquier clúster de proceso de Azure Machine Learning que ya exista en el área de trabajo. Por lo tanto, varias implementaciones por lotes pueden compartir la misma infraestructura de proceso. En este ejemplo, usará un clúster de proceso de Azure Machine Learning denominado batch-cluster. Verifique que la instancia de cálculo exista en el espacio de trabajo o créela si no es así.
- CLI de Azure
- Pitón
```
az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5
```
```
compute_name = "batch-cluster"
if not any(filter(lambda m: m.name == compute_name, ml_client.compute.list())):
    compute_cluster = AmlCompute(
        name=compute_name,
        description="Batch endpoints compute cluster",
        min_instances=0,
        max_instances=5,
    )
    ml_client.begin_create_or_update(compute_cluster).result()
```

Configurar la implementación:

CLI de Azure
Pitón

El archivo deployment.yml contiene la configuración de la implementación. Puede comprobar el esquema YAML completo del punto de conexión por lotes para obtener más propiedades.

deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
name: hello-batch-dpl
endpoint_name: hello-pipeline-batch
type: pipeline
component: azureml:hello_batch@latest
settings:
    default_compute: batch-cluster

deployment = PipelineComponentBatchDeployment(
    name="hello-batch-dpl",
    description="A hello world deployment with a single step.",
    endpoint_name=endpoint.name,
    component=hello_batch,
    settings={"continue_on_step_failure": False, "default_compute": compute_name},
)

Crea el despliegue:
- CLI de Azure
- Pitón
Ejecute el código siguiente para crear una implementación por lotes en el punto de conexión por lotes y establézcala como la implementación predeterminada.
```
az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment.yml --set-default
```
Sugerencia

Observa el uso de la marca --set-default para indicar que esta nueva implementación es ahora el valor predeterminado.
Este comando iniciará la creación de la implementación y devolverá una respuesta de confirmación mientras continúa la creación de la implementación.
```
ml_client.batch_deployments.begin_create_or_update(deployment).result()
```
Una vez creada, configure esta nueva implementación como la predeterminada:
```
endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()
```
La implementación está lista para su uso.

Prueba de la implementación

Una vez creada la implementación, está lista para recibir trabajos. Puedes invocar la implementación determinada de la siguiente manera:

CLI de Azure
Pitón

JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --query name -o tsv)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
)

Sugerencia

En este ejemplo, la canalización no tiene entradas ni salidas. Sin embargo, si el componente de canalización requiere algunos, se pueden indicar en el momento de la invocación. Para obtener información sobre cómo indicar entradas y salidas, consulte Creación de trabajos y datos de entrada para puntos de conexión por lotes o consulte el tutorial Implementación de una canalización para realizar la puntuación por lotes con preprocesamiento.

Puedes supervisar el progreso de la presentación y transmitir los registros mediante:

CLI de Azure
Pitón

az ml job stream -n $JOB_NAME

ml_client.jobs.get(job.name)

Para esperar a que finalice el trabajo, ejecuta el código siguiente:

ml_client.jobs.stream(name=job.name)

Limpieza de recursos

Una vez que hayas terminado, elimina los recursos asociados del área de trabajo:

CLI de Azure
Pitón

Ejecuta el código siguiente para eliminar el punto de conexión por lotes y la implementación subyacente. --yes se usa para confirmar la eliminación.

az ml batch-endpoint delete -n $ENDPOINT_NAME --yes

Eliminación del punto de conexión:

ml_client.batch_endpoints.begin_delete(endpoint_name).result()

(Opcional) Eliminar el cómputo, a menos que pienses reutilizar tu clúster de cómputo con implementaciones posteriores.

CLI de Azure
Pitón

az ml compute delete -n batch-cluster

ml_client.compute.begin_delete(name="batch-cluster")

Pasos siguientes

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-03-13