Cómo escalar nodos de inferencia con el ajuste de escala automático

Cuando implementas un modelo para la inferencia en línea como DeployedModel, puedes configurar nodos de inferencia para que se escalen automáticamente. Para ello, configura dedicatedResources.maxReplicaCount con un valor mayor que dedicatedResources.minReplicaCount.

Cuando configuras un DeployedModel, debes configurar dedicatedResources.minReplicaCount en, como mínimo, 1. En otras palabras, no puedes configurar DeployedModel para escalar a 0 nodos de inferencia cuando no se usa.

Como alternativa, si aceptas usar la función Scale To Zero (versión preliminar), el campo dedicatedResources.minReplicaCount se puede establecer en 0 y la carga de trabajo se puede escalar a cero réplicas cuando no hay tráfico en el extremo. Para obtener más detalles, consulta Scale To Zero.

De forma predeterminada, la operación de implementación solo se considera exitosa si la cantidad de nodos de inferencia alcanza dedicatedResources.minReplicaCount antes del valor de tiempo de espera de la solicitud de implementación. De lo contrario, la implementación se marca como fallida y se liberan los recursos subyacentes.

Implementación y mutación parcialmente correctas

Puedes modificar el comportamiento predeterminado de la implementación configurando dedicatedResources.requiredReplicaCount en un valor inferior a dedicatedResources.minReplicaCount. En este caso, cuando la cantidad de nodos de inferencia alcanza dedicatedResources.requiredReplicaCount, la operación de implementación se marca como exitosa, aunque aún no se haya completado. Deployment continúa hasta que se alcanza dedicatedResources.minReplicaCount. Si no se alcanza dedicatedResources.minReplicaCount antes de la hora de la solicitud de implementación, la operación se realiza correctamente, pero se muestra un mensaje de error para las réplicas con errores en DeployedModel.status.message.

La cuota para la entrega de modelos personalizados se calcula en función del uso en tiempo real de los recursos de procesamiento del modelo implementado. Si la suma de maxReplicaCount para todas las implementaciones de tu proyecto supera la cuota de tu proyecto, es posible que algunas implementaciones no hagan un ajuste de escala automático debido a que se agota la cuota.

Los extremos se escalan vertical y horizontalmente por máquina, pero la cuota se calcula por CPU o GPU. Por ejemplo, si tu modelo se implementa en el tipo de máquina a2-highgpu-2g, cada réplica activa se contará como 24 CPU y 2 GPU en la cuota de tu proyecto. Para obtener más información, consulta Cuotas y límites.

Los nodos de inferencia para la inferencia por lotes no se escalan automáticamente. Vertex AI usa BatchDedicatedResources.startingReplicaCount e ignora BatchDedicatedResources.maxReplicaCount.

Uso y configuración de destino

De forma predeterminada, si implementas un modelo sin recursos de GPU dedicados, Vertex AI aumentará o disminuirá la escala de la cantidad de réplicas de forma automática para que el uso de CPU coincida con el valor objetivo predeterminado del 60%.

De forma predeterminada, si implementas un modelo con recursos de GPU dedicados (si machineSpec.accelerator_count es superior a 0), Vertex AI escalará vertical y horizontalmente la cantidad de réplicas automáticamente para que el uso de CPU o GPU, el que sea más alto, coincida con el valor objetivo predeterminado del 60%. Por lo tanto, si la capacidad de procesamiento de tu inferencia causa un uso elevado de GPU, pero no un uso elevado de CPU, Vertex AI escalará verticalmente y el uso de CPU será muy bajo, lo que será visible en la supervisión. Por el contrario, si tu contenedor personalizado tiene poco uso de la GPU, pero tiene un proceso no relacionado que aumenta el uso de CPU por encima del 60%, Vertex AI escalará verticalmente, incluso si esto no fue necesario para lograr los objetivos de QPS y latencia.

Puedes anular la métrica y el objetivo de límite predeterminados si especificas autoscalingMetricSpecs. Ten en cuenta que, si tu implementación está configurada para escalar solo según el uso de CPU, no se escalará de forma vertical, incluso si el uso de GPU es alto.

Se admiten las siguientes métricas de ajuste de escala automático:

  • Uso de CPU (aiplatform.googleapis.com/prediction/online/cpu/utilization): Se ajusta según el uso de CPU. Su unidad es el uso de CPU por réplica. El valor objetivo es un porcentaje (0-100). El valor objetivo predeterminado es del 60%.
  • Uso de GPU (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle): Se ajusta según el uso de la GPU. Su unidad es el uso de la GPU por réplica. El valor objetivo es un porcentaje (0-100). El valor objetivo predeterminado es del 60%.
  • Recuento de solicitudes (aiplatform.googleapis.com/prediction/online/request_count): Se ajusta según la cantidad de solicitudes. Su unidad son las solicitudes por minuto por réplica. El valor objetivo es un número entero. Esta métrica está inhabilitada de forma predeterminada.
  • Tamaño de la cola de Pub/Sub (Versión preliminar, sin compatibilidad con Google Cloud CLI) (pubsub.googleapis.com/subscription/num_undelivered_messages): Se ajusta según la cantidad de mensajes no entregados de una suscripción a Pub/Sub. Su unidad son los mensajes no entregados por réplica. El valor objetivo es un número entero. Esta métrica está inhabilitada de forma predeterminada.

Cuando configures el ajuste de escala automático, usa METRIC_NAME para el identificador de la métrica y TARGET_THRESHOLD para el valor objetivo.

Configura el ajuste de escala automático durante la implementación

Para configurar el ajuste de escala automático cuando implementas un modelo, usa una de las siguientes interfaces:

gcloud

Para configurar el ajuste de escala automático cuando implementas un modelo con gcloud CLI, usa el comando gcloud ai endpoints deploy-model.

Ten en cuenta que, para Google Cloud CLI, la palabra clave de la métrica es ligeramente diferente. Usa lo siguiente:

  • cpu-usage
  • gpu-duty-cycle
  • request-counts-per-minute

Antes de usar cualquiera de los datos de comando, realiza los siguientes reemplazos:

  • ENDPOINT_ID: Es el ID de tu extremo.
  • PROJECT_ID: Es el ID de tu proyecto.
  • LOCATION: Es la región de tu extremo.
  • MODEL_ID: Es el ID del modelo que se implementará.
  • MACHINE_TYPE: Es el tipo de máquina del modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Opcional. Tipo de acelerador de GPU que se adjuntará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Opcional. Es la cantidad de aceleradores que se conectarán a cada máquina.
  • MIN_REPLICA_COUNT: Es la cantidad mínima de réplicas para el ajuste de escala automático.
  • MAX_REPLICA_COUNT: Es la cantidad máxima de réplicas para el ajuste de escala automático.
  • METRIC_NAME_GCLOUD: Es el identificador de la métrica del ajuste de escala automático.
  • TARGET_THRESHOLD: Es el valor objetivo de la métrica especificada.
gcloud ai endpoints deploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION \
    --model=MODEL_ID \
    --display-name=DEPLOYED_MODEL_DISPLAY_NAME \
    --machine-type=MACHINE_TYPE \
    --accelerator-type=ACCELERATOR_TYPE \
    --accelerator-count=ACCELERATOR_COUNT \
    --min-replica-count=MIN_REPLICA_COUNT \
    --max-replica-count=MAX_REPLICA_COUNT \
    --autoscaling-metric-specs=METRIC_NAME_GCLOUD=TARGET_THRESHOLD

REST

Para configurar el ajuste de escala automático cuando implementas un modelo con la API de REST, usa el método projects.locations.endpoints.deployModel.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • ENDPOINT_ID: Es el ID de tu extremo.
  • PROJECT_ID: Es el ID de tu proyecto.
  • LOCATION: Es la región de tu extremo.
  • MODEL_ID: Es el ID del modelo que se implementará.
  • DEPLOYED_MODEL_DISPLAY_NAME: Es un nombre visible para el modelo implementado.
  • MACHINE_TYPE: Es el tipo de máquina del modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Opcional. Tipo de acelerador de GPU que se adjuntará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Opcional. Es la cantidad de aceleradores que se conectarán a cada máquina.
  • MIN_REPLICA_COUNT: Es la cantidad mínima de réplicas para el ajuste de escala automático.
  • MAX_REPLICA_COUNT: Es la cantidad máxima de réplicas para el ajuste de escala automático.
  • METRIC_NAME: Es el identificador de la métrica del ajuste de escala automático.
  • TARGET_THRESHOLD: Es el valor objetivo de la métrica especificada.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel

Cuerpo JSON de la solicitud:

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_DISPLAY_NAME",
    "dedicatedResources": {
      "machineSpec": {
        "machineType": "MACHINE_TYPE",
        "acceleratorType": "ACCELERATOR_TYPE",
        "acceleratorCount": ACCELERATOR_COUNT
      },
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD
        }
      ]
    }
  }
}

Para el ajuste de escala automático basado en las métricas de tamaño de la cola de Pub/Sub (versión preliminar), se necesita información adicional sobre la suscripción a Pub/Sub:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: Es el ID del proyecto de la suscripción a Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID: Es el ID de la suscripción a Pub/Sub.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Python

El ajuste de escala automático del SDK de Python se configura a través de nombres de parámetros en la llamada a la función deploy(). El comando de muestra usa el ajuste de escala automático basado en la simultaneidad como ejemplo. Los parámetros de ajuste de escala automático que se pueden configurar son los siguientes:

  • autoscaling_target_cpu_utilization
  • autoscaling_target_accelerator_duty_cycle
  • autoscaling_target_request_count_per_minute

Para configurar el ajuste de escala automático cuando implementes un modelo con el SDK de Vertex AI para Python, haz lo siguiente:

Antes de ejecutar el código, realiza los siguientes reemplazos:

  • PROJECT_ID: Es el ID de tu proyecto.
  • LOCATION: Es la región de tu extremo.
  • ENDPOINT_ID: Es el ID de tu extremo.
  • MODEL_ID: Es el ID del modelo que se implementará.
  • DEPLOYED_MODEL_DISPLAY_NAME: Es un nombre visible para el modelo implementado.
  • MACHINE_TYPE: Es el tipo de máquina del modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Opcional. Tipo de acelerador de GPU que se adjuntará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Opcional. Es la cantidad de aceleradores que se conectarán a cada máquina.
  • MIN_REPLICA_COUNT: Es la cantidad mínima de réplicas para el ajuste de escala automático.
  • MAX_REPLICA_COUNT: Es la cantidad máxima de réplicas para el ajuste de escala automático.
  • METRIC_NAME: Es el identificador de la métrica del ajuste de escala automático.
  • TARGET_THRESHOLD: Es el valor objetivo de la métrica especificada.
from google.cloud import aiplatform

# Initialize Vertex AI
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT,
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_request_count_per_minute=TARGET_THRESHOLD,
)

Para el ajuste de escala automático basado en las métricas de tamaño de la cola de Pub/Sub (versión preliminar, solo se admite aiplatform_v1beta1), se necesita información adicional sobre la suscripción a Pub/Sub:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: Es el ID del proyecto de la suscripción a Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID: Es el ID de la suscripción a Pub/Sub.
from google.cloud import aiplatform_v1beta1 as aiplatform

# Initialize Vertex AI
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT,
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_pubsub_num_undelivered_messages=TARGET_THRESHOLD,
  autoscaling_pubsub_subscription_labels={
      "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
      "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
  },
)

Actualiza la configuración del ajuste de escala automático

Para actualizar una configuración de ajuste de escala automático existente, usa una de las siguientes interfaces:

REST

Para actualizar la configuración del ajuste de escala automático de un modelo implementado con la API de REST, usa el método projects.locations.endpoints.mutateDeployedModel.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • ENDPOINT_ID: Es el ID de tu extremo.
  • PROJECT_ID: Es el ID de tu proyecto.
  • LOCATION: Es la región de tu extremo.
  • DEPLOYED_MODEL_ID: Es el ID del modelo implementado que se actualizará.
  • MIN_REPLICA_COUNT: Es la nueva cantidad mínima de réplicas para el ajuste de escala automático.
  • MAX_REPLICA_COUNT: Es la nueva cantidad máxima de réplicas para el ajuste de escala automático.
  • METRIC_NAME: Es el identificador de la métrica del ajuste de escala automático.
  • TARGET_THRESHOLD: Es el valor objetivo de la métrica especificada.

Método HTTP y URL:

PATCH https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:mutateDeployedModel

Cuerpo JSON de la solicitud:

{
  "deployedModel": {
    "id": "DEPLOYED_MODEL_ID",
    "dedicatedResources": {
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD
        }
      ]
    }
  },
  "updateMask": {
    "paths": [
      "dedicated_resources.min_replica_count",
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs"
    ]
  }
}

Para el ajuste de escala automático basado en las métricas de tamaño de la cola de Pub/Sub (versión preliminar), se necesita información adicional sobre la suscripción a Pub/Sub:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: Es el ID del proyecto de la suscripción a Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID: Es el ID de la suscripción a Pub/Sub.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Reducción de escala a cero (vista previa)

La función Scale To Zero te permite reducir automáticamente la escala de tus implementaciones de servidores de modelos a cero réplicas cuando no hay tráfico, lo que significa que no se generarán cargos durante este tiempo.

Cuando el tráfico llega al extremo reducido de destino, se recibe una respuesta 429 - Model is not yet ready for inference. Wait and then try your request again, se descarta la solicitud y se envía un indicador de aumento al servidor del modelo de destino.

Esto hace que el servidor del modelo se escale de cero al valor que se especifica en el campo DedicatedResources.initial_replica_count. El valor predeterminado es 1.

Esta función está diseñada para los siguientes casos de uso:

  • Implementaciones con largos períodos sin tráfico de forma regular.
  • Son los extremos que suelen recibir tráfico durante el horario de atención y están inactivos en otros momentos.

Habilitación y uso

La función Scale To Zero no se puede habilitar en extremos públicos compartidos. Todos los demás tipos de extremos son compatibles.

Para habilitar la función Scale To Zero, especifica min_replica_count=0 en la sección DedicatedResources de tu solicitud de deploy-model (dirigida a la versión v1beta1 de la API de Vertex Prediction).

Parámetros opcionales

En DedicatedResources, puedes especificar un valor de initial_replica_count entre 1 y max_replica_count (inclusive).

También se agregó una nueva sección ScaleToZeroSpec a DedicatedResources que permite la configuración de dos parámetros relacionados con Scale to Zero:

  • min_scaleup_period: Es la duración (en segundos) antes de que se inscriba un servidor de modelos en la evaluación de Scale to Zero. La implementación no intentará reducir la cantidad de réplicas a cero hasta que transcurra este período, incluso si no hay tráfico. Esto permite un valor de búfer durante la implementación inicial y los eventos de aumento posteriores antes de que se verifique el tráfico en el extremo de destino (lo que puede provocar la reducción de la implementación).
    • Valor predeterminado: 1 hora (3,600 s)
    • Valor mínimo: 5 minutos (300 s)
    • El valor máximo es de 8 horas (28,800 s).
  • idle_scaledown_period: Es la duración (en segundos) sin tráfico antes de reducir la cantidad de réplicas del servidor del modelo de destino a cero.
    • Valor predeterminado: 1 hora (3,600 s)
    • Valor mínimo: 5 minutos (300 s)
    • El valor máximo es de 8 horas (28,800 s).

Comportamientos esperados

Una solicitud enviada a un modelo reducido devolverá una respuesta 429 con Model is not yet ready for inference. Please wait and then try your request again.

Espera y vuelve a enviar la solicitud. Ten en cuenta que se descartará cualquier solicitud que se envíe en esta fase.

Limitaciones

  • La función Scale To Zero solo es compatible con las implementaciones de un solo modelo y un modelo por extremo.
  • Scale To Zero no se puede habilitar en extremos públicos compartidos, pero es compatible con todos los demás tipos de extremos.
  • Sin reservas, es posible que se agote el stock cuando se vuelve a aumentar la escala desde un estado reducido (según el tipo de máquina).

  • Los modelos implementados que se ajustan a cero durante más de 30 días (debido a que no reciben tráfico) están sujetos a la desimplementación automática.

gcloud

Para configurar el ajuste a cero cuando implementas un modelo con gcloud CLI, usa el comando gcloud beta ai endpoints deploy-model.

Antes de usar cualquiera de los datos de comando, realiza los siguientes reemplazos:

  • ENDPOINT_ID: Es el ID de tu extremo.
  • PROJECT_ID: Es el ID de tu proyecto.
  • LOCATION: Es la región de tu extremo.
  • MODEL_ID: Es el ID del modelo que se implementará.
  • MACHINE_TYPE: Es el tipo de máquina del modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Opcional. Tipo de acelerador de GPU que se adjuntará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Opcional. Es la cantidad de aceleradores que se conectarán a cada máquina.
  • MIN_REPLICA_COUNT: Es la cantidad mínima de réplicas para el ajuste de escala automático.
  • MAX_REPLICA_COUNT: Es la cantidad máxima de réplicas para el ajuste de escala automático.
gcloud beta ai endpoints deploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION \
    --model=MODEL_ID \
    --display-name=DEPLOYED_MODEL_DISPLAY_NAME \
    --machine-type=MACHINE_TYPE \
    --accelerator-type=ACCELERATOR_TYPE \
    --accelerator-count=ACCELERATOR_COUNT \
    --min-replica-count=MIN_REPLICA_COUNT \
    --max-replica-count=MAX_REPLICA_COUNT \
    --min-scaleup-period=300s \
    --idle-scaledown-period=300s

REST

Para configurar el ajuste a cero cuando implementes un modelo con la API de REST, usa el método projects.locations.endpoints.deployModel.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • ENDPOINT_ID: Es el ID de tu extremo.
  • PROJECT_ID: Es el ID de tu proyecto.
  • LOCATION: Es la región de tu extremo.
  • MODEL_ID: Es el ID del modelo que se implementará.
  • DEPLOYED_MODEL_DISPLAY_NAME: Es un nombre visible para el modelo implementado.
  • MACHINE_TYPE: Es el tipo de máquina del modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Opcional. Tipo de acelerador de GPU que se adjuntará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Opcional. Es la cantidad de aceleradores que se conectarán a cada máquina.
  • MIN_REPLICA_COUNT: Es la cantidad mínima de réplicas para el ajuste de escala automático.
  • MAX_REPLICA_COUNT: Es la cantidad máxima de réplicas para el ajuste de escala automático.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel

Cuerpo JSON de la solicitud:

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_DISPLAY_NAME",
    "dedicatedResources": {
      "machineSpec": {
        "machineType": "MACHINE_TYPE",
        "acceleratorType": "ACCELERATOR_TYPE",
        "acceleratorCount": ACCELERATOR_COUNT
      },
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "scale_to_zero_spec": {
          "min_scaleup_period": "300s",
          "idle_scaledown_period": "300s",
      },
    }
  }
}

Python

El SDK de Python para escalar a cero se configura a través del cliente de la API de v1beta1.

Antes de ejecutar el código, realiza los siguientes reemplazos:

  • PROJECT_ID: Es el ID de tu proyecto.
  • LOCATION: Es la región de tu extremo.
  • ENDPOINT_ID: Es el ID de tu extremo.
  • MODEL_ID: Es el ID del modelo que se implementará.
  • DEPLOYED_MODEL_DISPLAY_NAME: Es un nombre visible para el modelo implementado.
  • MACHINE_TYPE: Es el tipo de máquina del modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Opcional. Tipo de acelerador de GPU que se adjuntará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Opcional. Es la cantidad de aceleradores que se conectarán a cada máquina.
  • MIN_REPLICA_COUNT: Es la cantidad mínima de réplicas para el ajuste de escala automático.
  • MAX_REPLICA_COUNT: Es la cantidad máxima de réplicas para el ajuste de escala automático.
  • METRIC_NAME: Es el identificador de la métrica del ajuste de escala automático.
  • TARGET_THRESHOLD: Es el valor objetivo de la métrica especificada.
from google.cloud import aiplatform

# Initialize Vertex AI
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_request_count_per_minute=TARGET_THRESHOLD,
)

import google.auth.transport.requests
import urllib3

# pip install google-cloud-aiplatform for this dependency
from google.cloud import aiplatform
from google.cloud.aiplatform_v1beta1.services import endpoint_service # For EndpointServiceClient
from google.cloud.aiplatform_v1beta1 import types as aiplatform_v1beta1_types # For message types

PROJECT_NUMBER = "PROJECT_ID"
LOCATION = "LOCATION"
ENDPOINT_DISPLAY_NAME = "stz-sdk-test"
MODEL_ID="MODEL_ID"

# Full resource name of your existing model in Vertex AI Model Registry
# e.g., "projects/your-gcp-project-id/locations/us-central1/models/your-model-id"
MODEL_RESOURCE_NAME = f"projects/{PROJECT_NUMBER}/locations/{LOCATION}/models/{MODEL_ID}"

# Deployment settings
MACHINE_TYPE = "MACHINE_TYPE"
ACCELERATOR_TYPE ="ACCELERATOR_TYPE",
ACCELERATOR_COUNT =ACCELERATOR_COUNT

# Disable InsecureRequestWarning for the requests part as in your snippet
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# The AI Platform services require regional API endpoints.
client_options = {"api_endpoint": f"{LOCATION}-aiplatform.googleapis.com"}
endpoint_service_client = endpoint_service.EndpointServiceClient(client_options=client_options)

def main():
    aiplatform.init(project=PROJECT_NUMBER, location=LOCATION)
    model_to_deploy = aiplatform.Model(model_name=MODEL_RESOURCE_NAME) # Initialize model object

    try:
        # # --- 1. Create an Endpoint ---
        print(f"\nCreating endpoint '{ENDPOINT_DISPLAY_NAME}'...")
        endpoint = aiplatform.Endpoint.create(
            display_name=ENDPOINT_DISPLAY_NAME,
            project=PROJECT_NUMBER,
            location=LOCATION,
            sync=True, # Wait for creation to complete
            dedicated_endpoint_enabled=True,
        )
        print(f"Endpoint created: {endpoint.resource_name}")
        endpoint_numeric_id = endpoint.name # This is the numeric ID
        print(f"Numeric Endpoint ID for URL: {endpoint_numeric_id}")

        print(f"\nFetching model details for: {MODEL_RESOURCE_NAME}")
        model_to_deploy = aiplatform.Model(model_name=MODEL_RESOURCE_NAME)

        # --- 2. Deploy the Model ---
        print(f"\nDeploying model '{model_to_deploy.resource_name}' to endpoint '{endpoint.display_name}'...")
        deployed_model_config = aiplatform_v1beta1_types.DeployedModel(
            model=model_to_deploy.resource_name,
            dedicated_resources=aiplatform_v1beta1_types.DedicatedResources(
                machine_spec=aiplatform_v1beta1_types.MachineSpec(
                    machine_type=MACHINE_TYPE,
                    accelerator_type=ACCELERATOR_TYPE,
                    accelerator_count=ACCELERATOR_COUNT,
                ),
                initial_replica_count=1,
                min_replica_count=0,
                max_replica_count=1,
                scale_to_zero_spec=aiplatform_v1beta1_types.DedicatedResources.ScaleToZeroSpec(
                    min_scaleup_period=300,
                    idle_scaledown_period=300,
                )
            ),
        )

        deploy_model_request = aiplatform_v1beta1_types.DeployModelRequest(
            endpoint=endpoint.resource_name,
            deployed_model=deployed_model_config,
        )

        # Alternatively, if you've got an existing endpoint, use:
        # endpoint_path = endpoint_service_client.endpoint_path(
        #     project=PROJECT_NUMBER, location=LOCATION, endpoint={ENDPOINT_ID}
        # )

        # deploy_model_request = aiplatform_v1beta1_types.DeployModelRequest(
        #     endpoint=endpoint_path,
        #     deployed_model=deployed_model_config,
        # )

        print("\nSending v1beta1 DeployModelRequest...")
        operation = endpoint_service_client.deploy_model(request=deploy_model_request)

        print("Waiting for v1beta1 update deploy model operation to complete (this can take several minutes)...")
        operation.result()
        print("Model deployed successfully.")

    except Exception as e:
        print(f"\nAn error occurred: {e}")

if __name__ == "__main__":
    main()

Administra el uso de recursos

Puedes supervisar tu extremo para hacer un seguimiento de las métricas, como el uso de CPU y acelerador, la cantidad de solicitudes, la latencia y la cantidad actual y objetivo de réplicas. Esta información puede ayudarte a comprender el uso de los recursos de tu extremo y el comportamiento del escalamiento.

Ten en cuenta que cada réplica ejecuta solo un contenedor. Esto significa que si un contenedor de inferencia no puede usar por completo el recurso de procesamiento seleccionado, como un solo código de subproceso para una máquina de varios núcleos o un modelo personalizado que llame a otro servicio como parte de la inferencia, es posible que tus nodos no se escalen verticalmente.

Por ejemplo, si usas FastAPI o cualquier servidor de modelos que tenga una cantidad configurable de trabajadores o subprocesos, existen muchos casos en los que tener más de un trabajador puede aumentar el uso de recursos, lo que mejora la capacidad del servicio para escalar de forma automática la cantidad de réplicas.

Por lo general, recomendamos empezar con un trabajador o subproceso por núcleo. Si notas que el uso de CPU es bajo, en especial con una carga alta o tu modelo no escala de forma vertical porque el uso de CPU es bajo, aumenta la cantidad de trabajadores. Por otro lado, si notas que el uso es demasiado alto y las latencias aumentan más de lo esperado con la carga, intenta usar menos trabajadores. Si ya usas un solo trabajador, intenta usar un tipo de máquina más pequeño.

Comportamiento y retraso del escalamiento

Vertex AI ajusta la cantidad de réplicas cada 15 segundos con los datos de la ventana de 5 minutos anteriores. Para cada ciclo de 15 segundos, el sistema mide el uso del servidor y genera una cantidad objetivo de réplicas según la siguiente fórmula:

target # of replicas = Ceil(current # of replicas * (current utilization / target utilization))

Por ejemplo, si tienes dos réplicas que se usan al 100%, el objetivo es 4:

4 = Ceil(3.33) = Ceil(2 * (100% / 60%))

Otro ejemplo, si tienes 10 réplicas y el uso disminuye al 1%, el objetivo es 1:

1 = Ceil(.167) = Ceil(10 * (1% / 60%))

Al final de cada ciclo de 15 segundos, el sistema ajusta la cantidad de réplicas para que coincida con el valor objetivo más alto de la ventana anterior de 5 minutos. Ten en cuenta que, como se elige el valor objetivo más alto, tu extremo no reducirá la escala verticalmente si hay un aumento repentino en el uso durante ese período de 5 minutos, incluso si el uso general es muy bajo. Por otro lado, si el sistema necesita escalar de forma vertical, lo hará en un plazo de 15 segundos, ya que se elige el valor objetivo más alto en lugar del promedio.

Ten en cuenta que, incluso después de que Vertex AI ajuste la cantidad de réplicas, el inicio o el apagado de las réplicas lleva tiempo. Por lo tanto, hay un retraso adicional antes de que el extremo pueda ajustarse al tráfico. Los factores principales que contribuyen a este momento incluyen los siguientes:

  • El tiempo para aprovisionar y, luego, iniciar las VMs de Compute Engine
  • El tiempo para descargar el contenedor desde el registro
  • El tiempo para cargar el modelo desde el almacenamiento

La mejor manera de comprender el comportamiento de escalamiento del modelo real es ejecutar una prueba de carga y optimizar las características importantes para el modelo y tu caso de uso. Si el escalador automático no escala de forma vertical lo suficientemente rápido para la aplicación, aprovisiona min_replicas suficientes para controlar el tráfico del modelo de referencia esperado.

Actualiza la configuración de escalamiento

Si especificaste DedicatedResources o AutomaticResources cuando implementaste el modelo, puedes actualizar la configuración de escalamiento sin volver a implementar el modelo mediante una llamada a mutateDeployedModel.

Por ejemplo, la siguiente solicitud actualiza max_replica y autoscaling_metric_specs y luego, inhabilita el registro de contenedores.

{
  "deployedModel": {
    "id": "2464520679043629056",
    "dedicatedResources": {
      "maxReplicaCount": 9,
      "autoscalingMetricSpecs": [
        {
          "metricName": "aiplatform.googleapis.com/prediction/online/cpu/utilization",
          "target": 50
        }
      ]
    },
    "disableContainerLogging": true
  },
  "update_mask": {
    "paths": [
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs",
      "disable_container_logging"
    ]
  }
}

Notas de uso:

  • No puedes cambiar el tipo de máquina ni cambiar de DedicatedResources a AutomaticResources o viceversa. Los únicos campos de configuración de escalamiento que puedes cambiar son min_replica, max_replica, required_replica y AutoscalingMetricSpec (solo DedicatedResources).
  • Debes enumerar todos los campos que necesites actualizar en updateMask. Los campos no enumerados se ignoran.
  • El DeployedModel debe tener un estado DEPLOYED. Puede haber, como máximo, una operación de mutación activa por modelo implementado.
  • mutateDeployedModel también te permite habilitar o inhabilitar el registro de contenedores. Para obtener más información, consulta Registro de inferencias en línea.