Escalonar nós de inferência usando o escalonamento automático

Ao implantar um modelo para inferência on-line como um DeployedModel, é possível configurar os nós de inferência para escalonamento automático. Para isso, defina dedicatedResources.maxReplicaCount com um valor maior que dedicatedResources.minReplicaCount.

Ao configurar um DeployedModel, você precisa definir dedicatedResources.minReplicaCount como pelo menos 1. Em outras palavras, não é possível configurar o DeployedModel para escalonar para 0 nós de inferência quando ele não é usado.

Como alternativa, se você aceitar o uso do recurso de redução da escala a zero (pré-lançamento), o campo dedicatedResources.minReplicaCount poderá ser definido como 0, e a carga de trabalho será reduzida a zero réplicas quando não houver tráfego no endpoint. Para mais detalhes, consulte Redução da escala a zero.

Por padrão, a operação de implantação só é considerada bem-sucedida se o número de nós de inferência atingir dedicatedResources.minReplicaCount antes do valor de tempo limite da solicitação de implantação. Caso contrário, a implantação será marcada como com falha, e os recursos subjacentes serão liberados.

Implantação e mutação parcialmente bem-sucedidas

É possível modificar o comportamento de implantação padrão definindo dedicatedResources.requiredReplicaCount como um valor menor que dedicatedResources.minReplicaCount. Nesse caso, quando o número de nós de inferência chega a dedicatedResources.requiredReplicaCount, a operação de implantação é marcada como bem-sucedida, mesmo que ainda não esteja concluída. A implantação continua até que dedicatedResources.minReplicaCount seja atingido. Se dedicatedResources.minReplicaCount não for alcançado antes do tempo de solicitação de implantação, a operação ainda será bem-sucedida, mas uma mensagem de erro para as réplicas com falha será retornada em DeployedModel.status.message.

A cota para disponibilização de modelo personalizado é reservada com base no valor dedicatedResources.maxReplicaCount de cada modelo implantado no projeto e na região, em vez do número de réplicas ativas. O faturamento é baseado nas réplicas ativas que estão em execução. Se a soma de maxReplicaCount em todas as implantações no projeto e na região exceder a cota de exibição do projeto, a implantação de um novo modelo ou o aumento de maxReplicaCount vai falhar com um erro de cota.

Os endpoints são escalonados verticalmente por máquina, e a cota de exibição é calculada por CPU e GPU. Por exemplo, se você implantar um modelo usando o tipo de máquina a2-highgpu-2g (24 vCPUs e 2 GPUs por réplica) com maxReplicaCount definido como 5, a implantação reservará 120 CPUs e 10 GPUs na cota do projeto, mesmo quando menos réplicas estiverem ativas. Para liberar a cota reservada sem cancelar a implantação do modelo, reduza maxReplicaCount chamando mutateDeployedModel. Para mais informações, consulte Cotas e limites.

Os nós de inferência em lote não são escalonados automaticamente. A Agent Platform usa BatchDedicatedResources.startingReplicaCount e ignora BatchDedicatedResources.maxReplicaCount.

Utilização e configuração de valor desejado

Por padrão, se você implantar um modelo sem recursos de GPU dedicados, a Gemini Enterprise Agent Platform fará o escalonamento automático do número de réplicas para que o uso da CPU corresponda ao valor desejado padrão de 60%.

Por padrão, se você implantar um modelo com recursos de GPU dedicados (se machineSpec.accelerator_count for maior que 0), a Gemini Enterprise Agent Platform vai escalonar vertical ou horizontalmente o número de réplicas de modo automático para que o uso da CPU ou GPU, o que for maior, corresponda ao valor desejado padrão de 60%. Portanto, se a capacidade de processamento de inferência estiver causando alto uso da GPU, mas não alto uso da CPU, a plataforma de agentes será escalonar verticalmente, e a utilização da CPU será muito baixa, o que vai ficar visível no monitoramento. Por outro lado, se o contêiner personalizado estiver subutilizando a GPU, mas tiver um processo não relacionado que aumente a utilização da CPU para mais de 60%, a plataforma de agente será escalonar verticalmente, mesmo que isso não seja necessário para atingir as metas de QPS e latência.

É possível substituir o valor desejado e a métrica de limite padrão especificando autoscalingMetricSpecs. Se a implantação for configurada para escalonar com base apenas no uso da CPU, ela não será escalonar verticalmente mesmo que o uso da GPU seja alto.

As seguintes métricas de escalonamento automático são compatíveis:

  • Utilização da CPU (aiplatform.googleapis.com/prediction/online/cpu/utilization): escalona com base no uso da CPU. A unidade é o uso da CPU por réplica. O valor de destino é uma porcentagem (0-100). O valor de destino padrão é 60%.
  • Uso de GPU (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle): escalonamento com base no uso da GPU. A unidade é o uso de GPU por réplica. O valor de destino é uma porcentagem (0-100). O valor padrão é 60%.
  • Uso da GPU do DCGM (pré-lançamento)(prometheus.googleapis.com/vertex_dcgm_fi_dev_gpu_util): escalona com base nas métricas do DCGM para uso da GPU. A unidade é o uso de GPU por réplica. O valor de destino é uma porcentagem (0-100). Essa métrica fica desativada por padrão.
  • Porcentagem de uso do cache de KV da GPU do vLLM (pré-lançamento)(prometheus.googleapis.com/vertex_vllm_gpu_cache_usage_perc): escalona com base nas métricas do vLLM para a porcentagem de uso do cache de KV da GPU. A unidade é a porcentagem de uso do cache de KV da GPU por réplica. O valor de destino é uma porcentagem (0-100). Essa métrica fica desativada por padrão.
  • Número de solicitações em espera do vLLM (pré-lançamento)(prometheus.googleapis.com/vertex_vllm_num_requests_waiting): escalona com base nas métricas do vLLM para o número de solicitações em espera. A unidade é o número de solicitações em espera por réplica. O valor desejado é um número inteiro. Essa métrica fica desativada por padrão.
  • Contagem de solicitações (aiplatform.googleapis.com/prediction/online/request_count): escalonamento com base no número de solicitações. A unidade é solicitações por minuto por réplica. O valor desejado é um número inteiro. Essa métrica fica desativada por padrão.
  • Tamanho da fila do Pub/Sub (pré-lançamento, somente API v1beta1; sem suporte à Google Cloud CLI) (pubsub.googleapis.com/subscription/num_undelivered_messages): escalona com base no número de mensagens não entregues de uma assinatura do Pub/Sub. A unidade é de mensagens não entregues por réplica. O valor desejado é um número inteiro. Essa métrica fica desativada por padrão.

Ao configurar o escalonamento automático, use METRIC_NAME para o identificador de métrica e TARGET_THRESHOLD para o valor de destino. Especifique o identificador exato da métrica mostrado na lista anterior. Outras métricas exportadas para o Cloud Monitoring não são compatíveis como destinos de escalonamento automático. Para métricas prometheus.googleapis.com/*, omita o sufixo de tipo de métrica /gauge que aparece no Monitoring (por exemplo, especifique prometheus.googleapis.com/vertex_vllm_num_requests_waiting, não prometheus.googleapis.com/vertex_vllm_num_requests_waiting/gauge).

Configurar o escalonamento automático durante a implantação

Para configurar o escalonamento automático ao implantar um modelo, use uma das seguintes interfaces:

gcloud

Para configurar o escalonamento automático ao implantar um modelo usando a CLI gcloud, use o comando gcloud ai endpoints deploy-model.

Para a Google Cloud CLI, a palavra-chave da métrica é um pouco diferente. Use o seguinte:

  • 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 os dados do comando, faça estas substituições:

  • ENDPOINT_ID: o ID do endpoint.
  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região do endpoint.
  • MODEL_ID: o ID do modelo a ser implantado.
  • MACHINE_TYPE: o tipo de máquina do modelo implantado (por exemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. O tipo de acelerador de GPU a ser anexado (por exemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. O número de aceleradores a serem anexados a cada máquina.
  • MIN_REPLICA_COUNT: o número mínimo de réplicas para o escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para o escalonamento automático.
  • METRIC_NAME: o identificador da métrica de escalonamento automático.
  • TARGET_THRESHOLD: o valor de destino da 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 o escalonamento automático ao implantar um modelo usando a API REST, use o método projects.locations.endpoints.deployModel.

Antes de usar os dados da solicitação, faça as substituições a seguir:

  • ENDPOINT_ID: o ID do endpoint.
  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região do endpoint.
  • MODEL_ID: o ID do modelo a ser implantado.
  • DEPLOYED_MODEL_DISPLAY_NAME: um nome de exibição para o modelo implantado.
  • MACHINE_TYPE: o tipo de máquina do modelo implantado (por exemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. O tipo de acelerador de GPU a ser anexado (por exemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. O número de aceleradores a serem anexados a cada máquina.
  • MIN_REPLICA_COUNT: o número mínimo de réplicas para o escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para o escalonamento automático.
  • METRIC_NAME: o identificador da métrica de escalonamento automático.
  • TARGET_THRESHOLD: o valor de destino da métrica especificada.

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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 o escalonamento automático do tamanho da fila do Pub/Sub (pré-lançamento), use o método v1beta1 projects.locations.endpoints.deployModel, porque monitoredResourceLabels só é compatível com a API v1beta1. Faça as seguintes substituições adicionais:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: o ID do projeto da assinatura do Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID: o ID da assinatura do Pub/Sub. Esse campo pode ter no máximo 63 caracteres.

Método HTTP e URL:

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

No corpo JSON da solicitação, configure autoscalingMetricSpecs da seguinte maneira:

      "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

O escalonamento automático do SDK do Python é configurado usando nomes de parâmetros na chamada de função deploy(). O comando de amostra usa o escalonamento automático baseado em simultaneidade como exemplo. Os parâmetros de escalonamento automático configuráveis são:

  • 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 o escalonamento automático ao implantar um modelo usando o SDK da Agent Platform para Python:

Antes de executar o código, faça as seguintes substituições:

  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região do endpoint.
  • ENDPOINT_ID: o ID do endpoint.
  • MODEL_ID: o ID do modelo a ser implantado.
  • DEPLOYED_MODEL_DISPLAY_NAME: um nome de exibição para o modelo implantado.
  • MACHINE_TYPE: o tipo de máquina do modelo implantado (por exemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. O tipo de acelerador de GPU a ser anexado (por exemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. O número de aceleradores a serem anexados a cada máquina.
  • MIN_REPLICA_COUNT: o número mínimo de réplicas para o escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para o escalonamento automático.
  • METRIC_NAME: o identificador da métrica de escalonamento automático.
  • TARGET_THRESHOLD: o valor de destino da 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 o escalonamento automático com base em métricas de tamanho da fila do Pub/Sub (pré-lançamento, apenas aiplatform_v1beta1 é compatível), são necessárias mais informações de assinatura do Pub/Sub:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: o ID do projeto da assinatura do Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID: o ID da assinatura do 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.")

Atualizar configuração de escalonamento automático

Para atualizar uma configuração de escalonamento automático, use uma das seguintes interfaces:

REST

Para atualizar a configuração de escalonamento automático de um modelo implantado usando a API REST, use o método projects.locations.endpoints.mutateDeployedModel.

Antes de usar os dados da solicitação, faça as substituições a seguir:

  • ENDPOINT_ID: o ID do endpoint.
  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região do endpoint.
  • DEPLOYED_MODEL_ID: o ID do modelo implantado a ser atualizado.
  • MIN_REPLICA_COUNT: o novo número mínimo de réplicas para o escalonamento automático.
  • MAX_REPLICA_COUNT: o novo número máximo de réplicas para o escalonamento automático.
  • METRIC_NAME: o identificador da métrica de escalonamento automático.
  • TARGET_THRESHOLD: o valor de destino da métrica especificada.

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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 o escalonamento automático do tamanho da fila do Pub/Sub (pré-lançamento), use o método v1beta1 projects.locations.endpoints.mutateDeployedModel, porque monitoredResourceLabels só é compatível com a API v1beta1. Faça as seguintes substituições adicionais:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: o ID do projeto da assinatura do Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID: o ID da assinatura do Pub/Sub. Esse campo pode ter no máximo 63 caracteres.

Método HTTP e URL:

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

No corpo JSON da solicitação, configure autoscalingMetricSpecs da seguinte maneira:

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

Redução da escala a zero (pré-lançamento)

O recurso de redução da escala a zero permite escalonar automaticamente as implantações do servidor de modelos para zero réplicas quando não há tráfego, o que resulta em nenhuma cobrança durante esse período.

Quando o tráfego chega ao endpoint de destino com escala reduzida, uma resposta 429 - Model is not yet ready for inference. Please wait while model completes scale-up from zero, then try your request again é recebida, a solicitação é descartada e um sinal de aumento de escala é enviado ao servidor de modelos de destino.

Isso faz com que o servidor de modelos seja escalonado de zero para o valor especificado no campo DedicatedResources.initial_replica_count. O valor padrão é 1.

Esse recurso foi criado para os seguintes casos de uso:

  • Implantações com longos períodos sem tráfego regularmente.
  • Endpoints que normalmente recebem tráfego durante o horário de funcionamento e ficam inativos em outros momentos.

Ativação e uso

O recurso de redução da escala a zero não pode ser ativado em endpoints públicos compartilhados. Todos os outros tipos de endpoint são compatíveis.

Para ativar a redução da escala a zero, especifique min_replica_count=0 na seção DedicatedResources da solicitação de implantação do modelo (visando a versão v1beta1 da API Vertex Prediction).

Parâmetros opcionais

Em DedicatedResources, é possível especificar um valor de initial_replica_count entre 1 e max_replica_count (incluso).

Também há uma nova seção ScaleToZeroSpec adicionada a DedicatedResources, que permite a configuração de dois parâmetros relacionados à redução da escala a zero:

  • min_scaleup_period: duração (em segundos) antes que um servidor de modelos seja inscrito na avaliação de redução da escala a zero. A implantação não tentará reduzir para zero réplicas até que esse período tenha passado, mesmo que não haja tráfego. Isso permite um valor de buffer durante a implantação inicial e os eventos de escalonamento vertical subsequentes antes que o tráfego seja verificado em relação ao endpoint de destino (o que pode resultar na redução da escala vertical da implantação).
    • Valor padrão: 1 hora (3.600s)
    • Valor mínimo: 5 minutos (300s)
    • Valor máximo: 8 horas (28.800s).
  • idle_scaledown_period: duração (em segundos) sem tráfego antes de reduzir o servidor de modelos de destino para zero réplicas.
    • Valor padrão: 1 hora (3.600s)
    • Valor mínimo: 5 minutos (300s)
    • Valor máximo: 8 horas (28.800s).

Comportamentos esperados

Uma solicitação enviada a um modelo reduzido vai retornar uma resposta 429 com Model is not yet ready for inference. Please wait and then try your request again.

Aguarde e tente fazer a solicitação de novo. Todas as solicitações enviadas nessa fase serão descartadas.

Limitações

  • A redução da escala a zero só é compatível com implantações de modelo único e um modelo por endpoint.
  • A redução da escala a zero não é compatível com implantações de GPU ou TPU de vários hosts. No entanto, as implantações de GPU ou TPU de host único são compatíveis.
  • A redução da escala a zero não pode ser ativada em endpoints públicos compartilhados. Todos os outros tipos de endpoint são compatíveis.
  • Sem reservas, é possível que ocorram faltas de estoque ao escalonar verticalmente de um estado reduzido (dependendo do tipo de máquina).
  • Os DeployedModels que são reduzidos da escala a zero por mais de 30 dias (por não receberem tráfego) são removidos automaticamente.

gcloud

Para configurar a redução da escala a zero ao implantar um modelo usando a CLI gcloud, use o comando gcloud beta ai endpoints deploy-model.

Antes de usar os dados do comando, faça estas substituições:

  • ENDPOINT_ID: o ID do endpoint.
  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região do endpoint.
  • MODEL_ID: o ID do modelo a ser implantado.
  • MACHINE_TYPE: o tipo de máquina do modelo implantado (por exemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. O tipo de acelerador de GPU a ser anexado (por exemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. O número de aceleradores a serem anexados a cada máquina.
  • MIN_REPLICA_COUNT: o número mínimo de réplicas para o escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para o escalonamento 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 a redução da escala a zero ao implantar um modelo usando a API REST, use o método projects.locations.endpoints.deployModel.

Antes de usar os dados da solicitação, faça as substituições a seguir:

  • ENDPOINT_ID: o ID do endpoint.
  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região do endpoint.
  • MODEL_ID: o ID do modelo a ser implantado.
  • DEPLOYED_MODEL_DISPLAY_NAME: um nome de exibição para o modelo implantado.
  • MACHINE_TYPE: o tipo de máquina do modelo implantado (por exemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. O tipo de acelerador de GPU a ser anexado (por exemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. O número de aceleradores a serem anexados a cada máquina.
  • MIN_REPLICA_COUNT: o número mínimo de réplicas para o escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para o escalonamento automático.

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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

A redução da escala a zero do SDK para Python é configurada pelo cliente da API v1beta1.

Antes de executar o código, faça as seguintes substituições:

  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região do endpoint.
  • ENDPOINT_ID: o ID do endpoint.
  • MODEL_ID: o ID do modelo a ser implantado.
  • DEPLOYED_MODEL_DISPLAY_NAME: um nome de exibição para o modelo implantado.
  • MACHINE_TYPE: o tipo de máquina do modelo implantado (por exemplo, n1-standard-4).
  • ACCELERATOR_TYPE: opcional. O tipo de acelerador de GPU a ser anexado (por exemplo, NVIDIA_L4).
  • ACCELERATOR_COUNT: opcional. O número de aceleradores a serem anexados a cada máquina.
  • MIN_REPLICA_COUNT: o número mínimo de réplicas para o escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para o escalonamento automático.
  • METRIC_NAME: o identificador da métrica de escalonamento automático.
  • TARGET_THRESHOLD: o valor de destino da 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()

Gerenciar o uso de recursos

É possível monitorar seu endpoint para rastrear métricas como o uso da CPU e do acelerador, o número de solicitações, a latência e o número atual e pretendido de réplicas. Essas informações podem ajudar você a entender o uso de recursos e o comportamento de escalonamento do endpoint.

Lembre-se de que cada réplica executa apenas um contêiner. Isso significa que, se um contêiner de inferência não puder usar totalmente o recurso de computação selecionado, como um código de linha de execução única para uma máquina de vários núcleos ou um modelo personalizado que chamará outro serviço como parte da inferência, talvez seus nós não sejam escalonar verticalmente verticalmente.

Por exemplo, se você estiver usando o FastAPI ou qualquer servidor de modelos com um número configurável de workers ou linhas de execução, poderá haver muitos casos em que ter mais de um worker aumentará a utilização de recursos, o que melhora a capacidade do serviço de escalonamento automático o número de réplicas.

Geralmente, recomendamos começar com um só worker ou linha de execução por núcleo. Se você perceber que a utilização da CPU está baixa, especialmente sob carga alta, ou se o modelo não estiver escalonando verticalmente porque a utilização da CPU está baixa, aumente o número de workers. Por outro lado, se você perceber que a utilização está muito alta e suas latências aumentam mais do que o esperado sob carga, tente usar menos workers. Se você já estiver usando apenas um worker, tente usar um tipo de máquina menor.

Comportamento de escalonamento e atraso

A Gemini Enterprise Agent Platform ajusta o número de réplicas a cada 15 segundos usando dados da janela anterior de 5 minutos. Para cada ciclo de 15 segundos, o sistema mede a utilização do servidor e gera um número pretendido de réplicas com base na seguinte fórmula:

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

Por exemplo, se você tem duas réplicas que estão sendo usadas em 100%, o valor desejado é 4:

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

Outro exemplo: se você tem 10 réplicas e a utilização cai para 1%, o valor desejado é 1:

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

No final de cada ciclo de 15 segundos, o sistema ajusta o número de réplicas para corresponder ao maior valor desejado da janela de cinco minutos anterior. Como o maior valor desejado é escolhido, seu endpoint não reduzir escala vertical vertical se houver um aumento repentino de utilização durante essa janela de cinco minutos, mesmo que a utilização geral seja muito baixa. Por outro lado, se o sistema precisar ser escalonado verticalmente, ele fará isso em até 15 segundos, já que o valor de destino mais alto é escolhido em vez da média.

Mesmo depois que a Gemini Enterprise Agent Platform ajusta o número de réplicas, leva tempo para iniciar ou desativar as réplicas. Portanto, haverá um atraso maior até o endpoint se ajustar ao tráfego. Os principais fatores que contribuem para esse tempo incluem:

  • O tempo para provisionar e iniciar as VMs do Compute Engine
  • O tempo para fazer o download do contêiner do registro
  • O tempo para carregar o modelo do armazenamento

A melhor maneira de entender o comportamento de escalonamento real do seu modelo é executar um teste de carga e otimizar as características importantes para o modelo e o caso de uso. Se o escalonador automático não estiver sendo rápido o suficiente para escalonar verticalmente o aplicativo, provisione min_replicas suficientes para lidar com o tráfego de referência esperado.

Atualizar a configuração de escalonamento

Se você tiver especificado DedicatedResources ou AutomaticResources ao implantar o modelo, poderá atualizar a configuração de escalonamento sem reimplantar o modelo chamando mutateDeployedModel.

Por exemplo, a solicitação a seguir atualiza max_replica, autoscaling_metric_specs e desativa o registro de contêiner.

{
  "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"
    ]
  }
}

Observações sobre o uso:

  • Não é possível alterar o tipo de máquina ou alternar de DedicatedResources para AutomaticResources ou vice-versa. Os únicos campos de configuração de escalonamento que podem ser alterados são: min_replica, max_replica, required_replica e AutoscalingMetricSpec (somente DedicatedResources).
  • É necessário listar todos os campos que você quer atualizar em updateMask. Os campos não listados são ignorados.
  • O DeployedModel precisa estar no estado DEPLOYED. Pode haver no máximo uma operação mutate ativa por modelo implantado.
  • O mutateDeployedModel também permite ativar ou desativar a geração de registros de contêineres. Para mais informações, consulte Geração de registros de inferência on-line.