Mettre à l'échelle les nœuds d'inférence à l'aide de l'autoscaling

Lorsque vous déployez un modèle pour l'inférence en ligne en tant que DeployedModel, vous pouvez configurer les nœuds d'inférence pour qu'ils assurent le scaling automatique. Pour ce faire, définissez dedicatedResources.maxReplicaCount sur une valeur supérieure à dedicatedResources.minReplicaCount.

Lorsque vous configurez un DeployedModel, vous devez définir dedicatedResources.minReplicaCount sur une valeur d'au moins 1. En d'autres termes, vous ne pouvez pas configurer le modèle DeployedModel pour qu'il soit réduit à 0 nœud d'inférence lorsqu'il n'est pas utilisé.

Si vous acceptez d'utiliser la fonctionnalité Scale to Zero (Preview), le champ dedicatedResources.minReplicaCount peut être défini sur 0 et la charge de travail est réduite à zéro réplica lorsqu'il n'y a pas de trafic sur le point de terminaison. Pour en savoir plus, consultez Scale to Zero.

Par défaut, l'opération de déploiement n'est considérée comme réussie que si le nombre de nœuds d'inférence atteint dedicatedResources.minReplicaCount avant la valeur du délai d'expiration de la demande de déploiement. Sinon, le déploiement est marqué comme ayant échoué et les ressources sous-jacentes sont libérées.

Déploiement et mutation partiellement réussis

Vous pouvez modifier le comportement de déploiement par défaut en définissant dedicatedResources.requiredReplicaCount sur une valeur inférieure à dedicatedResources.minReplicaCount. Dans ce cas, lorsque le nombre de nœuds d'inférence atteint dedicatedResources.requiredReplicaCount, l'opération de déploiement est marquée comme réussie, même si elle n'est pas encore terminée. Le déploiement se poursuit jusqu'à ce que dedicatedResources.minReplicaCount soit atteint. Si dedicatedResources.minReplicaCount n'est pas atteint avant l'heure de la demande de déploiement, l'opération réussit quand même, mais un message d'erreur pour les répliques ayant échoué est renvoyé dans DeployedModel.status.message.

Le quota pour servir des modèles personnalisés est calculé en fonction de l'utilisation en temps réel des ressources de calcul du modèle déployé. Si la somme de maxReplicaCount pour tous les déploiements de votre projet est supérieure au quota de votre projet, l'autoscaling de certains déploiements peut échouer en raison de l'épuisement du quota.

Les points de terminaison font l'objet d'un scaling à la hausse et à la baisse en fonction de la machine, mais le quota est calculé par processeur ou GPU. Par exemple, si votre modèle est déployé sur le type de machine a2-highgpu-2g, chaque instance répliquée active compte comme 24 processeurs et deux GPU dans le quota de votre projet. Pour en savoir plus, consultez Quotas et limites.

Les nœuds d'inférence par lot n'effectuent pas de scaling automatique. Vertex AI utilise BatchDedicatedResources.startingReplicaCount et ignore BatchDedicatedResources.maxReplicaCount.

Utilisation cible et configuration

Par défaut, si vous déployez un modèle sans ressources GPU dédiées, Vertex AI ajuste automatiquement le nombre d'instances dupliquées afin que l'utilisation du processeur corresponde à la valeur par défaut de 60 %.

Par défaut, si vous déployez un modèle avec des ressources GPU dédiées (si machineSpec.accelerator_count est supérieur à 0), Vertex AI effectuera automatiquement un scaling à la hausse ou à la baisse du nombre d'instances répliquées jusqu'à ce que l'utilisation du CPU ou du GPU (selon la valeur la plus élevée) corresponde à la valeur cible par défaut de 60 %. Par conséquent, si votre débit d'inférence entraîne une utilisation élevée des GPU, mais pas une utilisation élevée du processeur, Vertex AI effectue un scaling à la hausse, et l'utilisation du processeur sera très faible, ce qui est visible dans la surveillance. Si votre conteneur personnalisé sous-utilise les GPU, mais dispose d'un processus sans lien qui entraîne une utilisation du CPU supérieure à 60 %, Vertex AI effectue un scaling à la hausse, même si cela n'était peut-être pas nécessaire pour atteindre les objectifs de RPS et de latence.

Vous pouvez remplacer la métrique de seuil et la cible par défaut en spécifiant autoscalingMetricSpecs. Notez que si votre déploiement est configuré pour évoluer uniquement en fonction de l'utilisation du processeur, il ne peut pas évoluer à la hausse, même si l'utilisation du GPU est élevée.

Les métriques d'autoscaling suivantes sont acceptées :

  • Utilisation du processeur (aiplatform.googleapis.com/prediction/online/cpu/utilization) : effectue un scaling en fonction de l'utilisation du processeur. Son unité est l'utilisation du processeur par réplica. La valeur cible est un pourcentage (0 à 100). La valeur cible par défaut est de 60 %.
  • Utilisation du GPU (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle) : évolue en fonction de l'utilisation du GPU. Son unité est l'utilisation du GPU par réplica. La valeur cible est un pourcentage (0 à 100). La valeur cible par défaut est de 60 %.
  • Nombre de requêtes (aiplatform.googleapis.com/prediction/online/request_count) : évolue en fonction du nombre de requêtes. Son unité est "requêtes par minute et par réplica". La valeur cible est un nombre entier. Cette métrique est désactivée par défaut.
  • Taille de la file d'attente Pub/Sub (aperçu, non compatible avec la Google Cloud CLI) (pubsub.googleapis.com/subscription/num_undelivered_messages) : évolue en fonction du nombre de messages non distribués d'un abonnement Pub/Sub. Son unité est le nombre de messages non remis par réplica. La valeur cible est un nombre entier. Cette métrique est désactivée par défaut.

Lorsque vous configurez l'autoscaling, utilisez METRIC_NAME pour l'identifiant de métrique et TARGET_THRESHOLD pour la valeur cible.

Configurer l'autoscaling lors du déploiement

Pour configurer l'autoscaling lors du déploiement d'un modèle, utilisez l'une des interfaces suivantes :

gcloud

Pour configurer l'autoscaling lors du déploiement d'un modèle à l'aide de gcloud CLI, utilisez la commande gcloud ai endpoints deploy-model.

Notez que pour Google Cloud CLI, le mot clé de la métrique est légèrement différent. Utilisez les ressources suivantes :

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

Avant d'utiliser les données de la commande, effectuez les remplacements suivants :

  • ENDPOINT_ID : ID de votre point de terminaison.
  • PROJECT_ID : ID de votre projet.
  • LOCATION : région de votre point de terminaison.
  • MODEL_ID : ID du modèle à déployer.
  • MACHINE_TYPE : type de machine pour le modèle déployé (par exemple, n1-standard-4).
  • ACCELERATOR_TYPE : facultatif. Type d'accélérateur GPU à associer (par exemple, NVIDIA_L4).
  • ACCELERATOR_COUNT : facultatif. Nombre d'accélérateurs à associer à chaque machine.
  • MIN_REPLICA_COUNT : nombre minimal d'instances répliquées pour l'autoscaling.
  • MAX_REPLICA_COUNT : nombre maximal de répliques pour l'autoscaling.
  • METRIC_NAME_GCLOUD : identifiant de la métrique d'autoscaling.
  • TARGET_THRESHOLD : valeur cible pour la métrique spécifiée.
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

Pour configurer l'autoscaling lorsque vous déployez un modèle à l'aide de l'API REST, utilisez la méthode projects.locations.endpoints.deployModel.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • ENDPOINT_ID : ID de votre point de terminaison.
  • PROJECT_ID : ID de votre projet.
  • LOCATION : région de votre point de terminaison.
  • MODEL_ID : ID du modèle à déployer.
  • DEPLOYED_MODEL_DISPLAY_NAME : nom à afficher du modèle déployé.
  • MACHINE_TYPE : type de machine pour le modèle déployé (par exemple, n1-standard-4).
  • ACCELERATOR_TYPE : facultatif. Type d'accélérateur GPU à associer (par exemple, NVIDIA_L4).
  • ACCELERATOR_COUNT : facultatif. Nombre d'accélérateurs à associer à chaque machine.
  • MIN_REPLICA_COUNT : nombre minimal d'instances répliquées pour l'autoscaling.
  • MAX_REPLICA_COUNT : nombre maximal de répliques pour l'autoscaling.
  • METRIC_NAME : identifiant de la métrique d'autoscaling.
  • TARGET_THRESHOLD : valeur cible pour la métrique spécifiée.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour l'autoscaling basé sur les métriques de taille de file d'attente Pub/Sub (aperçu), des informations supplémentaires sur l'abonnement Pub/Sub sont nécessaires :

  • PUBSUB_SUBSCRIPTION_PROJECT_ID : ID du projet de l'abonnement Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID : ID de l'abonnement Pub/Sub.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Python

L'autoscaling du SDK Python est configuré à l'aide des noms de paramètres dans l'appel de la fonction deploy(). L'exemple de commande utilise l'autoscaling basé sur la simultanéité comme exemple. Les paramètres d'autoscaling configurables sont les suivants :

  • autoscaling_target_cpu_utilization
  • autoscaling_target_accelerator_duty_cycle
  • autoscaling_target_request_count_per_minute

Pour configurer l'autoscaling lors du déploiement d'un modèle à l'aide du SDK Vertex AI pour Python :

Avant d'exécuter le code, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet.
  • LOCATION : région de votre point de terminaison.
  • ENDPOINT_ID : ID de votre point de terminaison.
  • MODEL_ID : ID du modèle à déployer.
  • DEPLOYED_MODEL_DISPLAY_NAME : nom à afficher du modèle déployé.
  • MACHINE_TYPE : type de machine pour le modèle déployé (par exemple, n1-standard-4).
  • ACCELERATOR_TYPE : facultatif. Type d'accélérateur GPU à associer (par exemple, NVIDIA_L4).
  • ACCELERATOR_COUNT : facultatif. Nombre d'accélérateurs à associer à chaque machine.
  • MIN_REPLICA_COUNT : nombre minimal d'instances répliquées pour l'autoscaling.
  • MAX_REPLICA_COUNT : nombre maximal de répliques pour l'autoscaling.
  • METRIC_NAME : identifiant de la métrique d'autoscaling.
  • TARGET_THRESHOLD : valeur cible pour la métrique spécifiée.
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,
)

Pour l'autoscaling basé sur les métriques de taille de file d'attente Pub/Sub (aperçu, seule aiplatform_v1beta1 est acceptée), des informations supplémentaires sur l'abonnement Pub/Sub sont nécessaires :

  • PUBSUB_SUBSCRIPTION_PROJECT_ID : ID du projet de l'abonnement Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID : ID de l'abonnement 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"
  },
)

Mettre à jour la configuration de l'autoscaling

Pour mettre à jour une configuration d'autoscaling existante, utilisez l'une des interfaces suivantes :

REST

Pour mettre à jour la configuration de l'autoscaling d'un modèle déployé à l'aide de l'API REST, utilisez la méthode projects.locations.endpoints.mutateDeployedModel.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • ENDPOINT_ID : ID de votre point de terminaison.
  • PROJECT_ID : ID de votre projet.
  • LOCATION : région de votre point de terminaison.
  • DEPLOYED_MODEL_ID : ID du modèle déployé à mettre à jour.
  • MIN_REPLICA_COUNT : nouveau nombre minimal d'instances répliquées pour l'autoscaling.
  • MAX_REPLICA_COUNT : nouveau nombre maximal d'instances répliquées pour l'autoscaling.
  • METRIC_NAME : identifiant de la métrique d'autoscaling.
  • TARGET_THRESHOLD : valeur cible pour la métrique spécifiée.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour l'autoscaling basé sur les métriques de taille de file d'attente Pub/Sub (aperçu), des informations supplémentaires sur l'abonnement Pub/Sub sont nécessaires :

  • PUBSUB_SUBSCRIPTION_PROJECT_ID : ID du projet de l'abonnement Pub/Sub.
  • PUBSUB_SUBSCRIPTION_ID : ID de l'abonnement Pub/Sub.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Scaling à zéro instance (preview)

La fonctionnalité de scaling à zéro instance vous permet de réduire automatiquement le nombre de répliques de vos déploiements de serveurs de modèles à zéro en l'absence de trafic, ce qui évite toute facturation pendant cette période.

Lorsque le trafic atteint le point de terminaison cible réduit, une réponse 429 - Model is not yet ready for inference. Wait and then try your request again est reçue, la requête est abandonnée et un signal d'augmentation de la capacité est envoyé au serveur de modèle cible.

Le serveur de modèle est alors mis à l'échelle de zéro à la valeur spécifiée dans le champ DedicatedResources.initial_replica_count. La valeur par défaut est 1.

Cette fonctionnalité est conçue pour les cas d'utilisation suivants :

  • Déploiements avec de longues périodes sans trafic de manière régulière.
  • Points de terminaison qui reçoivent généralement du trafic pendant les heures ouvrables et qui sont inactifs à d'autres moments.

Activation et utilisation

La fonctionnalité Scale to Zero ne peut pas être activée sur les points de terminaison publics partagés. Tous les autres types de points de terminaison sont compatibles.

Pour activer la mise à l'échelle à zéro, spécifiez min_replica_count=0 dans la section DedicatedResources de votre requête deploy-model (ciblant la version v1beta1 de l'API Vertex Prediction).

Paramètres facultatifs

Dans DedicatedResources, vous pouvez spécifier une valeur initial_replica_count comprise entre 1 et max_replica_count (inclus).

Une nouvelle section ScaleToZeroSpec a également été ajoutée à DedicatedResources, ce qui permet de configurer deux paramètres liés à la mise à l'échelle à zéro :

  • min_scaleup_period : durée (en secondes) avant l'inscription d'un serveur de modèle à l'évaluation "Scale to Zero". Le déploiement ne tentera pas de réduire le nombre de réplicas à zéro tant que cette durée ne sera pas écoulée, même en l'absence de trafic. Cela permet d'avoir une valeur tampon lors du déploiement initial et des événements de scale-up ultérieurs avant que le trafic ne soit vérifié par rapport au point de terminaison cible (ce qui peut entraîner la réduction du déploiement).
    • Valeur par défaut : 1 heure (3 600 s)
    • Valeur minimale : 5 minutes (300 s)
    • Valeur maximale : 8 heures (28 800 secondes).
  • idle_scaledown_period : durée (en secondes) sans trafic avant de réduire le nombre de répliques du serveur de modèle cible à zéro.
    • Valeur par défaut : 1 heure (3 600 s)
    • Valeur minimale : 5 minutes (300 s)
    • Valeur maximale : 8 heures (28 800 secondes).

Comportements attendus

Une requête envoyée à un modèle réduit renvoie une réponse 429 avec Model is not yet ready for inference. Please wait and then try your request again.

Attendez, puis réessayez d'envoyer votre demande. Notez que toutes les requêtes envoyées pendant cette phase seront abandonnées.

Limites

  • La mise à l'échelle à zéro n'est compatible qu'avec les déploiements de modèle unique et un seul modèle par point de terminaison.
  • La fonctionnalité Scale to Zero ne peut pas être activée sur les points de terminaison publics partagés. Tous les autres types de points de terminaison sont compatibles.
  • Sans réservation, il est possible de rencontrer des ruptures de stock lors d'une remise à l'échelle depuis un état réduit (selon le type de machine).

  • Les DeployedModels mis à l'échelle zéro pendant plus de 30 jours (car ils ne reçoivent aucun trafic) sont soumis à une annulation de déploiement automatique.

gcloud

Pour configurer la mise à l'échelle à zéro lors du déploiement d'un modèle à l'aide de gcloud CLI, utilisez la commande gcloud beta ai endpoints deploy-model.

Avant d'utiliser les données de la commande, effectuez les remplacements suivants :

  • ENDPOINT_ID : ID de votre point de terminaison.
  • PROJECT_ID : ID de votre projet.
  • LOCATION : région de votre point de terminaison.
  • MODEL_ID : ID du modèle à déployer.
  • MACHINE_TYPE : type de machine pour le modèle déployé (par exemple, n1-standard-4).
  • ACCELERATOR_TYPE : facultatif. Type d'accélérateur GPU à associer (par exemple, NVIDIA_L4).
  • ACCELERATOR_COUNT : facultatif. Nombre d'accélérateurs à associer à chaque machine.
  • MIN_REPLICA_COUNT : nombre minimal d'instances répliquées pour l'autoscaling.
  • MAX_REPLICA_COUNT : nombre maximal de répliques pour l'autoscaling.
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

Pour configurer la mise à l'échelle à zéro lors du déploiement d'un modèle à l'aide de l'API REST, utilisez la méthode projects.locations.endpoints.deployModel.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • ENDPOINT_ID : ID de votre point de terminaison.
  • PROJECT_ID : ID de votre projet.
  • LOCATION : région de votre point de terminaison.
  • MODEL_ID : ID du modèle à déployer.
  • DEPLOYED_MODEL_DISPLAY_NAME : nom à afficher du modèle déployé.
  • MACHINE_TYPE : type de machine pour le modèle déployé (par exemple, n1-standard-4).
  • ACCELERATOR_TYPE : facultatif. Type d'accélérateur GPU à associer (par exemple, NVIDIA_L4).
  • ACCELERATOR_COUNT : facultatif. Nombre d'accélérateurs à associer à chaque machine.
  • MIN_REPLICA_COUNT : nombre minimal d'instances répliquées pour l'autoscaling.
  • MAX_REPLICA_COUNT : nombre maximal de répliques pour l'autoscaling.

Méthode HTTP et URL :

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

Corps JSON de la requête :

{
  "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 mise à l'échelle à zéro du SDK Python est configurée via le client de l'API v1beta1.

Avant d'exécuter le code, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet.
  • LOCATION : région de votre point de terminaison.
  • ENDPOINT_ID : ID de votre point de terminaison.
  • MODEL_ID : ID du modèle à déployer.
  • DEPLOYED_MODEL_DISPLAY_NAME : nom à afficher du modèle déployé.
  • MACHINE_TYPE : type de machine pour le modèle déployé (par exemple, n1-standard-4).
  • ACCELERATOR_TYPE : facultatif. Type d'accélérateur GPU à associer (par exemple, NVIDIA_L4).
  • ACCELERATOR_COUNT : facultatif. Nombre d'accélérateurs à associer à chaque machine.
  • MIN_REPLICA_COUNT : nombre minimal d'instances répliquées pour l'autoscaling.
  • MAX_REPLICA_COUNT : nombre maximal de répliques pour l'autoscaling.
  • METRIC_NAME : identifiant de la métrique d'autoscaling.
  • TARGET_THRESHOLD : valeur cible pour la métrique spécifiée.
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()

Gérer l'utilisation des ressources

Vous pouvez surveiller votre point de terminaison pour effectuer le suivi de métriques telles que l'utilisation du processeur et de l'accélérateur, le nombre de requêtes, la latence, ainsi que le nombre actuel et cible d'instances dupliquées. Ces informations peuvent vous aider à comprendre le comportement des ressources et leur utilisation des points de terminaison.

N'oubliez pas que chaque instance dupliquée n'exécute qu'un seul conteneur. Cela signifie que si un conteneur d'inférence ne peut pas utiliser pleinement la ressource de calcul sélectionnée, telle que du code à thread unique pour une machine multicœur ou un modèle personnalisé qui appelle un autre service dans le cadre de l'inférence, il est possible que le scaling à la hausse de vos nœuds ne soit pas effectué.

Par exemple, si vous utilisez FastAPI ou tout serveur de modèles comportant un nombre configurable de nœuds de calcul ou de threads, il existe de nombreux cas où l'utilisation de plusieurs nœuds de calcul peut augmenter l'utilisation des ressources. Cela permet au service d'adapter automatiquement le nombre d'instances dupliquées.

Nous vous recommandons généralement de commencer par un nœud de calcul ou un thread par cœur. Si vous remarquez que l'utilisation du processeur est faible, en particulier en cas de charge élevée, ou que votre modèle n'effectue pas de scaling à la hausse, car l'utilisation du CPU est faible, augmentez le nombre de nœuds de calcul. En revanche, si vous remarquez que l'utilisation est trop élevée et que vos latences augmentent plus que prévu sous la charge, diminuez le nombre de nœuds de calcul. Si vous n'utilisez qu'un seul nœud de calcul, essayez d'utiliser un type de machine plus petit.

Comportement et délai du scaling

Vertex AI ajuste le nombre d'instances dupliquées toutes les 15 secondes à l'aide des données de la fenêtre des 5 minutes précédentes. Pour chaque cycle de 15 secondes, le système mesure l'utilisation du serveur et génère un nombre cible d'instances dupliquées selon la formule suivante :

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

Par exemple, si deux instances répliquées sont actuellement utilisées à 100 %, la cible est de 4 :

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

Autre exemple, si vous avez actuellement 10 instances répliquées et que l'utilisation chute à 1 %, la cible est de 1 :

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

À la fin de chaque cycle de 15 secondes, le système ajuste le nombre d'instances dupliquées afin qu'elles correspondent à la valeur cible la plus élevée de la fenêtre des cinq minutes précédentes. Notez que comme la valeur choisie est la valeur cible la plus élevée, votre point de terminaison n'effectue pas de scaling à la baisse en cas de pic d'utilisation pendant cet intervalle de 5 minutes, même si l'utilisation globale est très faible. En revanche, si le système doit faire l'objet d'un scaling à la hausse, il le fera dans les 15 secondes, car la valeur cible la plus élevée est choisie plutôt que la moyenne.

Gardez à l'esprit que même après que Vertex AI ajuste le nombre d'instances dupliquées, le démarrage ou la désactivation des instances dupliquées prend un certain temps. Ainsi, il existe un délai supplémentaire avant que le point de terminaison puisse s'adapter au trafic. Les principaux facteurs qui contribuent à ce délai sont les suivants :

  • Temps de provisionnement et de démarrage des VM Compute Engine
  • Heure du téléchargement du conteneur à partir du registre
  • Temps de chargement du modèle depuis l'espace de stockage

La meilleure façon de comprendre le comportement de scaling réel de votre modèle consiste à exécuter un test de charge et à optimiser les caractéristiques importantes pour votre modèle et votre cas d'utilisation. Si l'autoscaler n'effectue pas un scaling assez rapide pour votre application, provisionnez suffisamment de min_replicas pour gérer le trafic de référence attendu.

Mettre à jour la configuration du scaling

Si vous avez spécifié une valeur pour DedicatedResources ou AutomaticResources lorsque vous avez déployé le modèle, vous pouvez mettre à jour la configuration du scaling sans redéployer le modèle en appelant mutateDeployedModel.

Par exemple, la requête suivante met à jour max_replica et autoscaling_metric_specs, et désactive la journalisation des conteneurs.

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

Consignes d'utilisation :

  • Vous ne pouvez pas modifier le type de machine ni passer de DedicatedResources à AutomaticResources, ou inversement. Les seuls champs de configuration de scaling que vous pouvez modifier sont : min_replica, max_replica, required_replica et AutoscalingMetricSpec (DedicatedResources uniquement).
  • Vous devez répertorier tous les champs que vous souhaitez mettre à jour dans updateMask. Les champs non répertoriés sont ignorés.
  • L'état DeployedModel doit être à l'état DEPLOYED. Il peut y avoir au plus une opération de mutation active par modèle déployé.
  • mutateDeployedModel vous permet également d'activer ou de désactiver la journalisation des conteneurs. Pour en savoir plus, consultez la section Journalisation des inférences en ligne.