Escalar nodos de inferencia mediante el autoescalado

Cuando despliegues un modelo para la inferencia online como un DeployedModel, puedes configurar los nodos de inferencia para que se escalen automáticamente. Para ello, asigna a dedicatedResources.maxReplicaCount un valor superior a dedicatedResources.minReplicaCount.

Cuando configures un DeployedModel, debes asignar el valor 1 o superior a dedicatedResources.minReplicaCount. Es decir, no puedes configurar DeployedModel para que se escale a 0 nodos de inferencia cuando no se utilice.

También puede aceptar usar la función Escalar a cero (vista previa). En ese caso, el campo dedicatedResources.minReplicaCount se puede definir como 0 y la carga de trabajo se puede escalar a cero réplicas cuando no haya tráfico en el endpoint. Para obtener más información, consulta Escalar a cero.

De forma predeterminada, la operación de implementación solo se considera correcta si el número de nodos de inferencia alcanza dedicatedResources.minReplicaCount antes de que se agote el tiempo de espera de la solicitud de implementación. De lo contrario, el despliegue se marca como fallido y se liberan los recursos subyacentes.

Despliegue y mutación parcialmente correctos

Puedes modificar el comportamiento de implementación predeterminado asignando a dedicatedResources.requiredReplicaCount un valor inferior a dedicatedResources.minReplicaCount. En este caso, cuando el número de nodos de inferencia alcanza dedicatedResources.requiredReplicaCount, la operación de implementación se marca como correcta, aunque aún no se haya completado. La implementación continúa hasta que se alcanza el dedicatedResources.minReplicaCount. Si no se alcanza dedicatedResources.minReplicaCount antes de la hora de la solicitud de implementación, la operación se realizará correctamente, pero se devolverá un mensaje de error de las réplicas fallidas en DeployedModel.status.message.

La cuota de servicio de modelos personalizados se calcula en función del uso en tiempo real de los recursos de computación de tu modelo implementado. Si la suma de maxReplicaCount de todas las implementaciones de tu proyecto es superior a la cuota del proyecto, es posible que algunas implementaciones no puedan escalar automáticamente porque se haya agotado la cuota.

Los endpoints se escalan verticalmente 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 contabiliza como 24 CPUs y 2 GPUs en la cuota de tu proyecto. Para obtener más información, consulta Cuotas y límites.

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

Uso y configuración previstos

De forma predeterminada, si despliegas un modelo sin recursos de GPU dedicados, Vertex AI aumenta o reduce automáticamente el número de réplicas para que el uso de la CPU coincida con el valor objetivo predeterminado del 60 %.

De forma predeterminada, si despliegas un modelo con recursos de GPU dedicados (si machineSpec.accelerator_count es mayor que 0), Vertex AI aumentará o reducirá automáticamente el número de réplicas para que el uso de la CPU o la GPU, el que sea mayor, coincida con el valor objetivo predeterminado del 60 %. Por lo tanto, si el rendimiento de la inferencia provoca un uso elevado de la GPU, pero no de la CPU, Vertex AI aumentará la escala y la utilización de la CPU será muy baja, lo que se podrá ver en la monitorización. Por el contrario, si tu contenedor personalizado no está utilizando la GPU lo suficiente, pero tiene un proceso no relacionado que eleva la utilización de la CPU por encima del 60%, Vertex AI aumentará la escala, aunque no sea necesario para alcanzar los objetivos de QPS y latencia.

Para anular la métrica y el objetivo predeterminados, especifica autoscalingMetricSpecs. Ten en cuenta que, si tu despliegue está configurado para escalarse solo en función del uso de la CPU, no se escalará aunque el uso de la GPU sea alto.

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

  • Uso de CPU (aiplatform.googleapis.com/prediction/online/cpu/utilization): se escala en función del uso de CPU. Su unidad es el uso de CPU por réplica. El valor objetivo es un porcentaje (de 0 a 100). El valor objetivo predeterminado es del 60%.
  • Uso de la GPU (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle): se escala en función del uso de la GPU. Su unidad es el uso de la GPU por réplica. El valor objetivo es un porcentaje (de 0 a 100). El valor objetivo predeterminado es del 60%.
  • Número de solicitudes (aiplatform.googleapis.com/prediction/online/request_count): se basa en el número de solicitudes. Su unidad es 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 (vista previa, no compatible con la CLI de Google Cloud) (pubsub.googleapis.com/subscription/num_undelivered_messages): se ajusta en función del número de mensajes no entregados de una suscripción de 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 configure el ajuste automático de escala, use METRIC_NAME para el identificador de métrica y TARGET_THRESHOLD para el valor objetivo.

Configurar el autoescalado durante el despliegue

Para configurar el escalado automático al desplegar un modelo, utilice una de las siguientes interfaces:

gcloud

Para configurar el escalado automático al desplegar un modelo mediante la CLI de gcloud, usa el comando gcloud ai endpoints deploy-model.

Ten en cuenta que, en el caso de la CLI de Google Cloud, 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 los datos de los comandos, haz las siguientes sustituciones:

  • ENDPOINT_ID: el ID de tu endpoint.
  • PROJECT_ID: tu ID de proyecto.
  • LOCATION: la región de tu endpoint.
  • MODEL_ID: ID del modelo que se va a implementar.
  • MACHINE_TYPE: el tipo de máquina del modelo implementado (por ejemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. El tipo de acelerador de GPU que se va a conectar (por ejemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. Número de aceleradores que se van a asociar a cada máquina.
  • MIN_REPLICA_COUNT: número mínimo de réplicas para el escalado automático.
  • MAX_REPLICA_COUNT: número máximo de réplicas para el escalado automático.
  • METRIC_NAME_GCLOUD: identificador de la métrica de autoescalado.
  • TARGET_THRESHOLD: 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 escalado automático al desplegar un modelo con la API REST, usa el método projects.locations.endpoints.deployModel.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • ENDPOINT_ID: el ID de tu endpoint.
  • PROJECT_ID: tu ID de proyecto.
  • LOCATION: la región de tu endpoint.
  • MODEL_ID: ID del modelo que se va a implementar.
  • DEPLOYED_MODEL_DISPLAY_NAME: nombre visible del modelo implementado.
  • MACHINE_TYPE: el tipo de máquina del modelo implementado (por ejemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. El tipo de acelerador de GPU que se va a conectar (por ejemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. Número de aceleradores que se van a asociar a cada máquina.
  • MIN_REPLICA_COUNT: número mínimo de réplicas para el escalado automático.
  • MAX_REPLICA_COUNT: número máximo de réplicas para el escalado automático.
  • METRIC_NAME: identificador de la métrica de autoescalado.
  • TARGET_THRESHOLD: 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 métricas de tamaño de la cola de Pub/Sub (vista previa), se necesita información adicional sobre la suscripción a Pub/Sub:

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

Python

El autoescalado del SDK de Python se configura mediante nombres de parámetros en la llamada de función deploy(). El comando de ejemplo usa el autoescalado basado en la simultaneidad como ejemplo. Los parámetros de autoescalado configurables son los siguientes:

  • autoscaling_target_cpu_utilization
  • autoscaling_target_accelerator_duty_cycle
  • autoscaling_target_request_count_per_minute

Para configurar el autoescalado al desplegar un modelo con el SDK de Vertex AI para Python, sigue estos pasos:

Antes de ejecutar el código, haz las siguientes sustituciones:

  • PROJECT_ID: tu ID de proyecto.
  • LOCATION: la región de tu endpoint.
  • ENDPOINT_ID: el ID de tu endpoint.
  • MODEL_ID: ID del modelo que se va a implementar.
  • DEPLOYED_MODEL_DISPLAY_NAME: nombre visible del modelo implementado.
  • MACHINE_TYPE: el tipo de máquina del modelo implementado (por ejemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. El tipo de acelerador de GPU que se va a conectar (por ejemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. Número de aceleradores que se van a asociar a cada máquina.
  • MIN_REPLICA_COUNT: número mínimo de réplicas para el escalado automático.
  • MAX_REPLICA_COUNT: número máximo de réplicas para el escalado automático.
  • METRIC_NAME: identificador de la métrica de autoescalado.
  • TARGET_THRESHOLD: 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 autoescalado basado en métricas de tamaño de cola de Pub/Sub (vista previa, solo se admite aiplatform_v1beta1), se necesita información adicional sobre la suscripción a Pub/Sub:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: el ID de proyecto de la suscripción de Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID: el ID de la suscripción de 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"
  },
)

Actualizar la configuración de autoescalado

Para actualizar una configuración de escalado automático, utiliza una de las siguientes interfaces:

REST

Para actualizar la configuración de escalado automático de un modelo desplegado mediante la API REST, usa el método projects.locations.endpoints.mutateDeployedModel.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • ENDPOINT_ID: el ID de tu endpoint.
  • PROJECT_ID: tu ID de proyecto.
  • LOCATION: la región de tu endpoint.
  • DEPLOYED_MODEL_ID: ID del modelo implementado que se va a actualizar.
  • MIN_REPLICA_COUNT: el nuevo número mínimo de réplicas para el escalado automático.
  • MAX_REPLICA_COUNT: el nuevo número máximo de réplicas para el escalado automático.
  • METRIC_NAME: identificador de la métrica de autoescalado.
  • TARGET_THRESHOLD: 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 métricas de tamaño de la cola de Pub/Sub (vista previa), se necesita información adicional sobre la suscripción a Pub/Sub:

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

Escalado a cero (vista previa)

La función Escalar a cero te permite escalar automáticamente tus implementaciones del servidor de modelos a cero réplicas cuando no haya tráfico, lo que significa que no se te cobrará durante ese tiempo.

Cuando el tráfico llega al endpoint de destino reducido, se recibe una respuesta 429 - Model is not yet ready for inference. Wait and then try your request again, se rechaza la solicitud y se envía una señal de ampliación al servidor del modelo de destino.

De este modo, el servidor del modelo se ampliará de cero al valor que se especifique en el campo DedicatedResources.initial_replica_count. El valor predeterminado es 1.

Esta función se ha diseñado para los siguientes casos prácticos:

  • Despliegues con largos periodos sin tráfico de forma periódica.
  • Endpoints que suelen recibir tráfico durante el horario de apertura y que están inactivos en otros momentos.

Habilitación y uso

La función Escalar a cero no se puede habilitar en endpoints públicos compartidos. Todos los demás tipos de endpoint son compatibles.

Para habilitar la función Escalar a cero, especifica min_replica_count=0 en la sección DedicatedResources de tu solicitud de despliegue de modelo (dirigida a la versión v1beta1 de la API Vertex Prediction).

Parámetros opcionales

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

También se ha añadido una nueva sección ScaleToZeroSpec a DedicatedResources que permite configurar dos parámetros relacionados con la función Escalar a cero:

  • min_scaleup_period: duración (en segundos) antes de que se registre un servidor de modelos en la evaluación de Escalado a cero. La implementación no intentará reducirse a cero réplicas hasta que haya transcurrido este periodo, aunque no haya tráfico. Esto permite un valor de búfer durante la implementación inicial y los eventos de escalado posteriores antes de que se compruebe el tráfico con el endpoint de destino (lo que puede provocar que se reduzca la escala de la implementación).
    • Valor predeterminado: 1 hora (3600 s)
    • Valor mínimo: 5 minutos (300 s)
    • Valor máximo: 8 horas (28.800 s).
  • idle_scaledown_period: duración (en segundos) sin tráfico antes de reducir verticalmente el servidor del modelo de destino a cero réplicas.
    • Valor predeterminado: 1 hora (3600 s)
    • Valor mínimo: 5 minutos (300 s)
    • Valor máximo: 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 intentarlo. Ten en cuenta que se descartarán todas las solicitudes que se envíen en esta fase.

Limitaciones

  • La función Escalar a cero solo es compatible con las implementaciones de un solo modelo y con un modelo por endpoint.
  • Scale To Zero no se puede habilitar en endpoints públicos compartidos, pero sí en todos los demás tipos de endpoints.
  • Si no se hacen reservas, es posible que se agoten las existencias al volver a aumentar la escala desde un estado reducido (en función del tipo de máquina).

  • Los modelos implementados que se escalan a cero durante más de 30 días (porque no reciben tráfico) se desimplementan automáticamente.

gcloud

Para configurar la opción de escalar a cero al desplegar un modelo con la CLI de gcloud, usa el comando gcloud beta ai endpoints deploy-model.

Antes de usar los datos de los comandos, haz las siguientes sustituciones:

  • ENDPOINT_ID: el ID de tu endpoint.
  • PROJECT_ID: tu ID de proyecto.
  • LOCATION: la región de tu endpoint.
  • MODEL_ID: ID del modelo que se va a implementar.
  • MACHINE_TYPE: el tipo de máquina del modelo implementado (por ejemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. El tipo de acelerador de GPU que se va a conectar (por ejemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. Número de aceleradores que se van a asociar a cada máquina.
  • MIN_REPLICA_COUNT: número mínimo de réplicas para el escalado automático.
  • MAX_REPLICA_COUNT: número máximo de réplicas para el escalado 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 la opción de reducir a cero al desplegar un modelo con la API REST, usa el método projects.locations.endpoints.deployModel.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • ENDPOINT_ID: el ID de tu endpoint.
  • PROJECT_ID: tu ID de proyecto.
  • LOCATION: la región de tu endpoint.
  • MODEL_ID: ID del modelo que se va a implementar.
  • DEPLOYED_MODEL_DISPLAY_NAME: nombre visible del modelo implementado.
  • MACHINE_TYPE: el tipo de máquina del modelo implementado (por ejemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. El tipo de acelerador de GPU que se va a conectar (por ejemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. Número de aceleradores que se van a asociar a cada máquina.
  • MIN_REPLICA_COUNT: número mínimo de réplicas para el escalado automático.
  • MAX_REPLICA_COUNT: número máximo de réplicas para el escalado 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

La función de escalado a cero del SDK de Python se configura a través del cliente de la API v1beta1.

Antes de ejecutar el código, haz las siguientes sustituciones:

  • PROJECT_ID: tu ID de proyecto.
  • LOCATION: la región de tu endpoint.
  • ENDPOINT_ID: el ID de tu endpoint.
  • MODEL_ID: ID del modelo que se va a implementar.
  • DEPLOYED_MODEL_DISPLAY_NAME: nombre visible del modelo implementado.
  • MACHINE_TYPE: el tipo de máquina del modelo implementado (por ejemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. El tipo de acelerador de GPU que se va a conectar (por ejemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. Número de aceleradores que se van a asociar a cada máquina.
  • MIN_REPLICA_COUNT: número mínimo de réplicas para el escalado automático.
  • MAX_REPLICA_COUNT: número máximo de réplicas para el escalado automático.
  • METRIC_NAME: identificador de la métrica de autoescalado.
  • TARGET_THRESHOLD: 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()

Gestionar el uso de recursos

Puedes monitorizar tu endpoint para hacer un seguimiento de métricas como el uso de CPU y aceleradores, el número de solicitudes, la latencia y el número actual y objetivo de réplicas. Esta información puede ayudarte a comprender el uso de recursos y el comportamiento de escalado de tu endpoint.

Ten en cuenta que cada réplica ejecuta un solo contenedor. Esto significa que, si un contenedor de inferencia no puede usar por completo el recurso de computación seleccionado (por ejemplo, código de un solo hilo para una máquina de varios núcleos o un modelo personalizado que llama 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 un número configurable de trabajadores o de hilos, hay muchos casos en los que tener más de un trabajador puede aumentar la utilización de recursos, lo que mejora la capacidad del servicio para escalar automáticamente el número de réplicas.

Por lo general, recomendamos empezar con un trabajador o un hilo por núcleo. Si observas que el uso de la CPU es bajo, sobre todo cuando la carga es alta, o que tu modelo no se está escalando porque el uso de la CPU es bajo, aumenta el número de trabajadores. Por otro lado, si observas que el uso es demasiado alto y que las latencias aumentan más de lo esperado cuando hay carga, prueba a usar menos workers. Si ya solo usas un trabajador, prueba a usar un tipo de máquina más pequeño.

Comportamiento de escalado y latencia

Vertex AI ajusta el número de réplicas cada 15 segundos con los datos de los últimos 5 minutos. En cada ciclo de 15 segundos, el sistema mide la utilización del servidor y genera un número 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 están utilizando al 100%, el objetivo es 4:

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

Otro ejemplo: si tienes 10 réplicas y la utilización se reduce al 1%, el objetivo es 1:

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

Al final de cada ciclo de 15 segundos, el sistema ajusta el número de réplicas para que coincida con el valor de destino más alto de la ventana de 5 minutos anterior. Ten en cuenta que, como se elige el valor de destino más alto, tu endpoint no se reducirá si hay un aumento repentino de la utilización durante ese periodo de 5 minutos, aunque la utilización general sea muy baja. Por otro lado, si el sistema necesita aumentar la escala, lo hará en 15 segundos, ya que se elige el valor objetivo más alto en lugar del promedio.

Ten en cuenta que, aunque Vertex AI ajuste el número de réplicas, se tarda un tiempo en iniciar o reducir las réplicas. Por lo tanto, hay un retraso adicional antes de que el endpoint pueda adaptarse al tráfico. Estos son los principales factores que influyen en este tiempo:

  • El tiempo necesario para aprovisionar e iniciar las máquinas virtuales de Compute Engine
  • El tiempo que se tarda en descargar el contenedor del registro
  • Tiempo necesario para cargar el modelo desde el almacenamiento.

La mejor forma de entender el comportamiento de escalado de tu modelo en el mundo real es hacer una prueba de carga y optimizar las características que son importantes para tu modelo y tu caso práctico. Si el escalador automático no aumenta la escala lo suficientemente rápido para tu aplicación, aprovisiona suficientes min_replicas para gestionar el tráfico base previsto.

Actualizar la configuración de escalado

Si has especificado DedicatedResources o AutomaticResources al desplegar el modelo, puedes actualizar la configuración de escalado sin volver a desplegarlo llamando a mutateDeployedModel.

Por ejemplo, la siguiente solicitud actualiza max_replica, autoscaling_metric_specs e 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 sobre el uso:

  • No puedes cambiar el tipo de máquina ni pasar de DedicatedResources a AutomaticResources o viceversa. Los únicos campos de configuración de escalado que puedes cambiar son min_replica, max_replica, required_replica y AutoscalingMetricSpec (solo DedicatedResources).
  • Debes indicar todos los campos que quieras actualizar en updateMask. Los campos no incluidos en la lista se ignoran.
  • El DeployedModel debe tener el estado DEPLOYED. Solo puede haber 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 online.