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 de reducción de escala a cero (versión preliminar), el campo dedicatedResources.minReplicaCount se puede establecer en 0 y la carga de trabajo se reduce a cero réplicas cuando no hay tráfico en el extremo. Para obtener más detalles, consulta Reducción de escala a cero.

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 exitosas

Puedes modificar el comportamiento de implementación predeterminado si configuras dedicatedResources.requiredReplicaCount en un valor menor que 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 esté completa. Deployment continúa hasta que se alcanza el valor de dedicatedResources.minReplicaCount. Si no se alcanza dedicatedResources.minReplicaCount antes del tiempo de solicitud de implementación, la operación se realiza correctamente, pero se devuelve un mensaje de error para las réplicas con errores en DeployedModel.status.message.

La cuota para la entrega de modelos personalizados se reserva en función del valor dedicatedResources.maxReplicaCount de cada modelo implementado en tu proyecto y región, en lugar de la cantidad de réplicas activas. La facturación se basa en las réplicas activas que se están ejecutando. Si la suma de maxReplicaCount en todas las implementaciones de tu proyecto y región supera la cuota de entrega de tu proyecto, la implementación de un modelo nuevo o el aumento de maxReplicaCount fallará con un error de cuota.

Los extremos escalan vertical y horizontalmente por máquina, y la cuota de entrega se calcula por CPU y GPU. Por ejemplo, si implementas un modelo con el tipo de máquina a2-highgpu-2g (24 CPUs virtuales y 2 GPUs por réplica) con maxReplicaCount establecido en 5, la implementación reserva 120 CPUs y 10 GPUs en la cuota de tu proyecto, incluso cuando hay menos réplicas activas. Para liberar la cuota reservada sin anular la implementación del modelo, disminuye maxReplicaCount llamando a mutateDeployedModel. 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. Agent Platform 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, Gemini Enterprise Agent Platform aplica escalado automático a la cantidad de réplicas 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), Gemini Enterprise Agent Platform escalará automáticamente la cantidad de réplicas vertical y horizontalmente 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, Agent Platform 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%, Agent Platform 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): Escala 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): Escala según el uso de GPU. Su unidad es el uso de GPU por réplica. El valor objetivo es un porcentaje (0-100). El valor objetivo predeterminado es del 60%.
  • Uso de GPU de DCGM (versión preliminar)(prometheus.googleapis.com/vertex_dcgm_fi_dev_gpu_util): Escala según las métricas de DCGM para el uso de GPU. Su unidad es el uso de GPU por réplica. El valor objetivo es un porcentaje (0-100). Esta métrica está inhabilitada de forma predeterminada.
  • Porcentaje de uso de la caché de KV de GPU de vLLM (versión preliminar)(prometheus.googleapis.com/vertex_vllm_gpu_cache_usage_perc): Escala según las métricas de vLLM para el porcentaje de uso de la caché de KV de GPU. Su unidad es el porcentaje de uso de la caché de KV de la GPU por réplica. El valor objetivo es un porcentaje (0-100). Esta métrica está inhabilitada de forma predeterminada.
  • Cantidad de solicitudes de vLLM en espera (versión preliminar)(prometheus.googleapis.com/vertex_vllm_num_requests_waiting): Escala según las métricas de vLLM para la cantidad de solicitudes en espera. Su unidad es la cantidad de solicitudes en espera por réplica. El valor objetivo es un número entero. Esta métrica está inhabilitada de forma predeterminada.
  • Recuento de solicitudes (aiplatform.googleapis.com/prediction/online/request_count): Escala según la cantidad de solicitudes. Su unidad es de 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, solo API de v1beta1; sin compatibilidad con Google Cloud CLI) (pubsub.googleapis.com/subscription/num_undelivered_messages): Escala 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. Especifica el identificador de métrica exacto que se muestra en la lista anterior. No se admiten otras métricas exportadas a Cloud Monitoring como objetivos de escalado automático. Para las métricas de prometheus.googleapis.com/*, omite el sufijo de tipo de métrica /gauge que aparece en Monitoring (por ejemplo, especifica prometheus.googleapis.com/vertex_vllm_num_requests_waiting, no prometheus.googleapis.com/vertex_vllm_num_requests_waiting/gauge).

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 un poco diferente. Usa lo siguiente:

  • cpu-usage
  • gpu-duty-cycle
  • dcgm-fi-dev-gpu-util
  • vllm-gpu-cache-usage-perc
  • vllm-num-requests-waiting
  • 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: ID del 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 para el modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Es opcional. Es el tipo de acelerador de GPU que se conectará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Es 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 de 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=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: ID del 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 para el modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Es opcional. Es el tipo de acelerador de GPU que se conectará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Es 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 de 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 del tamaño de la cola de Pub/Sub (versión preliminar), usa el método v1beta1 projects.locations.endpoints.deployModel, ya que monitoredResourceLabels solo se admite en la API de v1beta1. Realiza los siguientes reemplazos adicionales:

  • 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 de Pub/Sub. La longitud máxima de este campo es de 63 caracteres.

Método HTTP y URL:

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

En el cuerpo JSON de la solicitud, configura autoscalingMetricSpecs de la siguiente manera:

      "autoscalingMetricSpecs": [
        {
          "metricName": "pubsub.googleapis.com/subscription/num_undelivered_messages",
          "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 función deploy(). En el comando de ejemplo, se usa el ajuste de escala automático basado en la simultaneidad. Los parámetros de ajuste de escala automático configurables son los siguientes:

  • autoscaling_target_cpu_utilization
  • autoscaling_target_accelerator_duty_cycle
  • autoscaling_target_dcgm_fi_dev_gpu_util
  • autoscaling_target_vllm_gpu_cache_usage_perc
  • autoscaling_target_vllm_num_requests_waiting
  • autoscaling_target_request_count_per_minute

Para configurar el ajuste de escala automático cuando implementas un modelo con el SDK de Agent Platform para Python, haz lo siguiente:

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

  • PROJECT_ID: ID del 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 para el modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Es opcional. Es el tipo de acelerador de GPU que se conectará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Es 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 de ajuste de escala automático.
  • TARGET_THRESHOLD: Es el valor objetivo de la métrica especificada.
from google.cloud import aiplatform

# Initialize Agent Platform
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 de 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 de Pub/Sub.
from google.cloud import aiplatform_v1beta1 as aiplatform
from google.api_core.client_options import ClientOptions

# Initialize the EndpointServiceClient
client_options = ClientOptions(api_endpoint="LOCATION-aiplatform.googleapis.com")
client = aiplatform.EndpointServiceClient(client_options=client_options)

# Specify the location
location = "projects/PROJECT_NUMBER/locations/LOCATION"

model_name = "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID"
autoscaling_metric_specs = [
    {"metric_name": "pubsub.googleapis.com/subscription/num_undelivered_messages", "target": TARGET_THRESHOLD, "monitored_resource_labels":{"project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID","subscription_id": "PUBSUB_SUBSCRIPTION_ID"}}
]

deployed_model = aiplatform.DeployedModel(
    model=model_name,
    display_name="DEPLOYED_MODEL_DISPLAY_NAME",
    dedicated_resources=aiplatform.DedicatedResources(
        machine_spec=aiplatform.MachineSpec(
            machine_type="MACHINE_TYPE"
        ),
        min_replica_count=MIN_REPLICA_COUNT,
        max_replica_count=MAX_REPLICA_COUNT,
        autoscaling_metric_specs=autoscaling_metric_specs
    )
)

deploy_request = aiplatform.DeployModelRequest(
    deployed_model=deployed_model,
    endpoint="projects/PROJECT_NUMBER/locations/LOCATION/endpoints/ENDPOINT_ID",
    traffic_split={"0": 100}
)

deploy_operation = client.deploy_model(deploy_request)
print("Long-running operation initiated to deploy model.")
deploy_operation.result()

print("Model deployed to endpoint.")

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 de 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: ID del 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 de 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: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 del tamaño de la cola de Pub/Sub (versión preliminar), usa el método v1beta1 projects.locations.endpoints.mutateDeployedModel, ya que monitoredResourceLabels solo se admite en la API de v1beta1. Realiza los siguientes reemplazos adicionales:

  • 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 de Pub/Sub. La longitud máxima de este campo es de 63 caracteres.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:mutateDeployedModel

En el cuerpo JSON de la solicitud, configura autoscalingMetricSpecs de la siguiente manera:

      "autoscalingMetricSpecs": [
        {
          "metricName": "pubsub.googleapis.com/subscription/num_undelivered_messages",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          }
        }
      ]

Reducción de escala a cero (versión preliminar)

La función de reducción de escala a cero te permite escalar automáticamente las implementaciones de tu servidor de modelos a cero réplicas cuando no hay tráfico, lo que no genera facturación durante este tiempo.

Cuando el tráfico llega al extremo de destino con reducción de escala, se recibe una respuesta 429 - Model is not yet ready for inference. Please wait while model completes scale-up from zero, then try your request again, se descarta la solicitud y se envía una señal de aumento de escala al servidor del modelo de destino.

Esto hace que el servidor de modelos aumente 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 habitual.
  • Son extremos que, por lo general, reciben tráfico durante el horario de atención y están inactivos en otros momentos.

Habilitación y uso

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

Para habilitar la reducción de escala a cero, especifica min_replica_count=0 en la sección DedicatedResources de tu solicitud de implementación de modelo (orientada 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 configurar dos parámetros relacionados con la reducción de escala a cero:

  • min_scaleup_period: Es la duración (en segundos) antes de que se inscriba un servidor de modelos en la evaluación de reducción de escala a cero. La implementación no intentará reducir la escala a cero réplicas hasta que haya transcurrido este tiempo, incluso si no hay tráfico. Esto permite un valor de búfer durante la implementación inicial y los eventos de escalamiento vertical posteriores antes de que se verifique el tráfico con el extremo de destino (lo que puede dar como resultado la reducción de la escala de la implementación).
    • Valor predeterminado: 1 hora (3,600 s)
    • Valor mínimo: 5 minutos (300 s)
    • Valor máximo: 8 horas (28,800 s).
  • idle_scaledown_period: Es la duración (en segundos) sin tráfico antes de reducir la escala verticalmente del servidor del modelo de destino a cero réplicas.
    • Valor predeterminado: 1 hora (3,600 s)
    • Valor mínimo: 5 minutos (300 s)
    • Valor máximo: 8 horas (28,800 s).

Comportamientos previstos

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

Espera y, luego, vuelve a intentar realizar la solicitud. Ten en cuenta que se descartarán todas las solicitudes que se envíen en esta fase.

Limitaciones

  • La reducción de escala a cero solo es compatible con implementaciones de un solo modelo y un modelo por endpoint.
  • La reducción de escala a cero no admite implementaciones de GPU o TPU de varios hosts. Sin embargo, las implementaciones de GPU o TPU de host único son compatibles.
  • La reducción de escala a cero no se puede habilitar en los extremos públicos compartidos, pero todos los demás tipos de extremos son compatibles.
  • Sin reservas, es posible que se produzcan faltas de stock cuando se vuelva a aumentar la escala desde un estado de escala reducida (según el tipo de máquina).

  • Se anula automáticamente la implementación de los DeployedModels cuya escala se reduce a cero durante más de 30 días (por no recibir tráfico).

gcloud

Para configurar la reducción de escala 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: ID del 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 para el modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Es opcional. Es el tipo de acelerador de GPU que se conectará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Es 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 la reducción de escala a cero 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: ID del 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 para el modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Es opcional. Es el tipo de acelerador de GPU que se conectará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Es 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

La reducción de escala a cero del SDK de Python se configura a través del cliente de API v1beta1.

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

  • PROJECT_ID: ID del 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 para el modelo implementado (p.ej., n1-standard-4).
  • ACCELERATOR_TYPE: Es opcional. Es el tipo de acelerador de GPU que se conectará (p.ej., NVIDIA_L4).
  • ACCELERATOR_COUNT: Es 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 de ajuste de escala automático.
  • TARGET_THRESHOLD: Es el valor objetivo de la métrica especificada.
from google.cloud import aiplatform

# Initialize Agent Platform
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 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 elegido, 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 de forma vertical.

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

Gemini Enterprise Agent Platform ajusta la cantidad de réplicas cada 15 segundos con los datos de la ventana de 5 minutos anterior. 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 Gemini Enterprise Agent Platform 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.