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 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 usar o recurso "Escalonar para zero" (Prévia), o campo dedicatedResources.minReplicaCount poderá ser definido como 0 e a carga de trabalho será escalonada para zero réplicas quando não houver tráfego no endpoint. Para mais detalhes, consulte Escalonar para 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 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 com um valor menor que dedicatedResources.minReplicaCount. Nesse caso, quando o número de nós de inferência atinge 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 horário da 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 é calculada com base no tempo real do modelo implantado dos recursos de computação. Se a soma de maxReplicaCount para todas as implantações no projeto for maior do que a cota, algumas implantações podem não ser escalonadas automaticamente devido ao esgotamento da cota.

Os endpoints são escalonados verticalmente por máquina, mas a cota é calculada por CPU ou GPU. Por exemplo, se o modelo for implantado no tipo de máquina a2-highgpu-2g, cada réplica ativa contará como 24 CPUs e 2 GPUs na cota do projeto. Para mais informações, consulte Cotas e limites.

Os nós de inferência para inferência em lote não são escalonados automaticamente. A Vertex AI 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 Vertex AI fará o escalonamento vertical ou horizontal 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 Vertex AI fará o escalonamento vertical ou horizontal automático do número de réplicas 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 inferência estiver causando alto uso da GPU, mas não alto uso da CPU, a Vertex AI 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 Vertex AI fará escalonar verticalmente, mesmo que isso não seja necessário para atingir os valores desejados 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:

  • Uso da CPU (aiplatform.googleapis.com/prediction/online/cpu/utilization): escalona com base no uso da CPU. A unidade é a utilização da CPU por réplica. O valor da meta é uma porcentagem (0 a 100). O valor padrão da meta é 60%.
  • Uso da GPU (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle): dimensiona com base no uso da GPU. A unidade é o uso de GPU por réplica. O valor da meta é uma porcentagem (0 a 100). O valor padrão da meta é 60%.
  • Contagem de solicitações (aiplatform.googleapis.com/prediction/online/request_count): escalona com base no número de solicitações. A unidade é solicitações por minuto por réplica. O valor de destino é um número inteiro. Essa métrica fica desativada por padrão.
  • Tamanho da fila do Pub/Sub (prévia, sem suporte da Google Cloud CLI) (pubsub.googleapis.com/subscription/num_undelivered_messages): dimensiona com base no número de mensagens não entregues de uma assinatura do Pub/Sub. A unidade é mensagens não entregues por réplica. O valor de destino é 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 da meta.

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.

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

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

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

  • ENDPOINT_ID: o ID do seu 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 escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para escalonamento automático.
  • METRIC_NAME_GCLOUD: 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_GCLOUD=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 seu 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 escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para 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 com base nas métricas de tamanho da fila do Pub/Sub (prévia), 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.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Python

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

  • autoscaling_target_cpu_utilization
  • autoscaling_target_accelerator_duty_cycle
  • autoscaling_target_request_count_per_minute

Para configurar o escalonamento automático ao implantar um modelo usando o SDK da Vertex AI 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 seu 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 escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para 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 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 o escalonamento automático com base em métricas de tamanho da fila do Pub/Sub (prévia, somente 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

# 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"
  },
)

Atualizar a 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 seu 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 escalonamento automático.
  • MAX_REPLICA_COUNT: o novo número máximo de réplicas para 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:

PATCH 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 com base nas métricas de tamanho da fila do Pub/Sub (prévia), 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.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Redução da escala a zero (Prévia)

Com o recurso "Reduzir escala vertical para zero", é possível reduzir automaticamente as implantações do servidor de modelo 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 atinge o endpoint de destino reduzido, uma resposta 429 - Model is not yet ready for inference. Wait and then try your request again é recebida, a solicitação é descartada e um sinal de escalonamento é enviado ao servidor do modelo de destino.

Isso faz com que o servidor de modelo aumente de zero para qualquer 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 comercial e ficam ociosos em outros momentos.

Ativação e uso

O recurso "Reduzir para zero" não pode ser ativado em endpoints públicos compartilhados. Todos os outros tipos de endpoint são compatíveis.

Para ativar o escalonamento até zero, especifique min_replica_count=0 na seção DedicatedResources da solicitação de implantação do modelo (direcionada à 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 (inclusive).

Também há uma nova seção ScaleToZeroSpec adicionada a DedicatedResources, que permite a configuração de dois parâmetros relacionados ao escalonamento até zero:

  • min_scaleup_period: duração (em segundos) antes de um servidor de modelo ser registrado na avaliação de escalonamento até zero. A implantação não tentará reduzir para zero réplicas até que esse período termine, 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 no endpoint de destino, o que pode resultar na redução da implantação.
    • Valor padrão: 1 hora (3.600 segundos)
    • Valor mínimo: 5 minutos (300 segundos)
    • Valor máximo: 8 horas (28.800 segundos).
  • idle_scaledown_period: duração (em segundos) sem tráfego antes de reduzir o número de réplicas do servidor do modelo de destino para zero.
    • Valor padrão: 1 hora (3.600 segundos)
    • Valor mínimo: 5 minutos (300 segundos)
    • Valor máximo: 8 horas (28.800 segundos).

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

  • O escalonamento até zero é compatível apenas com implantações de modelo único e um modelo por endpoint.
  • Não é possível ativar o recurso "Reduzir para zero" em endpoints públicos compartilhados. Todos os outros tipos de endpoint são compatíveis.
  • Sem reservas, é possível ter falta de estoque ao aumentar novamente a escala de um estado reduzido (dependendo do tipo de máquina).

  • Os DeployedModels que são escalonados para zero por mais de 30 dias (por não receberem tráfego) estão sujeitos a remoção automática.

gcloud

Para configurar o escalonamento automático para 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 as seguintes substituições:

  • ENDPOINT_ID: o ID do seu 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 escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para 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 o escalonamento até 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 seu 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 escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para 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

O escalonamento automático para zero do SDK Python é configurado 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 seu 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 escalonamento automático.
  • MAX_REPLICA_COUNT: o número máximo de réplicas para 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 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()

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 chame 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 modelo com um número configurável de workers ou linhas de execução, poderá haver muitos casos em que ter um só worker aumentará a utilização de recursos, o melhorando a capacidade do serviço de escalonar automaticamente 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 Vertex AI 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.

Lembre-se de que, mesmo depois que a Vertex AI 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 mudar 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.