Inferenzknoten mit Autoscaling skalieren

Wenn Sie ein Modell für die Onlineinferenz als DeployedModel bereitstellen, können Sie Inferenzknoten so konfigurieren, dass sie automatisch skaliert werden. Setzen Sie dazu dedicatedResources.maxReplicaCount auf einen höheren Wert als dedicatedResources.minReplicaCount.

Wenn Sie ein DeployedModel konfigurieren, müssen Sie dedicatedResources.minReplicaCount auf mindestens 1 festlegen. Mit anderen Worten können Sie das DeployedModel nicht so konfigurieren, dass es auf 0 Inferenzknoten skaliert wird, wenn es nicht verwendet wird.

Wenn Sie die Funktion „Auf null skalieren“ (Vorschau) verwenden möchten, kann das Feld dedicatedResources.minReplicaCount auf 0 gesetzt werden. Die Arbeitslast wird dann auf null Replikate skaliert, wenn kein Traffic am Endpunkt vorhanden ist. Weitere Informationen finden Sie unter Auf null skalieren.

Standardmäßig gilt der Bereitstellungsvorgang nur dann als erfolgreich, wenn die Anzahl der Inferenzknoten vor dem Timeout-Wert der Bereitstellungsanfrage dedicatedResources.minReplicaCount erreicht. Andernfalls wird das Deployment als fehlgeschlagen markiert und die zugrunde liegenden Ressourcen werden freigegeben.

Teilweise erfolgreiche Bereitstellung und Mutation

Sie können das Standardbereitstellungsverhalten ändern, indem Sie dedicatedResources.requiredReplicaCount auf einen Wert festlegen, der kleiner als dedicatedResources.minReplicaCount ist. Wenn die Anzahl der Inferenzknoten dedicatedResources.requiredReplicaCount erreicht, wird der Bereitstellungsvorgang als erfolgreich markiert, obwohl er noch nicht abgeschlossen ist. Die Bereitstellung wird fortgesetzt, bis dedicatedResources.minReplicaCount erreicht ist. Wenn dedicatedResources.minReplicaCount vor der Zeit der Bereitstellungsanfrage nicht erreicht wird, ist der Vorgang trotzdem erfolgreich, aber eine Fehlermeldung für die fehlgeschlagenen Replikate wird in DeployedModel.status.message zurückgegeben.

Das Kontingent für die Bereitstellung benutzerdefinierter Modelle wird anhand der Echtzeitnutzung von Rechenressourcen durch das bereitgestellte Modell berechnet. Wenn die Summe von maxReplicaCount für alle Bereitstellungen in Ihrem Projekt das Kontingent Ihres Projekts überschreitet, werden einige Bereitstellungen möglicherweise nicht automatisch skaliert, da das Kontingent erschöpft ist.

Endpunkte werden pro Maschine vertikal und horizontal skaliert, aber das Kontingent wird pro CPU oder GPU berechnet. Wenn Ihr Modell beispielsweise für den Maschinentyp a2-highgpu-2g bereitgestellt wird, wird jedes aktive Replikat als 24 CPUs und 2 GPUs auf das Projektkontingent angerechnet. Weitere Informationen finden Sie unter Kontingente und Limits.

Die Inferenzknoten für Batchinferenz werden nicht automatisch skaliert. Vertex AI verwendet BatchDedicatedResources.startingReplicaCount und ignoriert BatchDedicatedResources.maxReplicaCount.

Zielauslastung und -konfiguration

Wenn Sie ein Modell ohne dedizierte GPU-Ressourcen bereitstellen, skaliert Vertex AI automatisch die Anzahl der Replikate nach oben oder unten, sodass die CPU-Nutzung mit dem Standardwert von 60 % übereinstimmt.

Wenn Sie ein Modell mit dedizierten GPU-Ressourcen bereitstellen (wenn machineSpec.accelerator_count über 0 liegt), skaliert Vertex AI standardmäßig die Anzahl der Replikate nach oben oder unten, sodass die CPU- oder GPU-Nutzung, je nachdem, welcher Wert höher ist, mit dem Standardwert von 60 % übereinstimmt. Wenn Ihr Inferenzdurchsatz also eine hohe GPU-Nutzung, aber keine hohe CPU-Auslastung verursacht, wird Vertex AI hochskaliert und die CPU-Auslastung ist sehr niedrig, was im Monitoring sichtbar ist. Wenn Ihr benutzerdefinierter Container dagegen die GPU nicht ausreichend nutzt, aber einen anderen Prozess hat, der die CPU-Auslastung auf über 60 % erhöht, wird Vertex AI hochskaliert, auch wenn dies möglicherweise nicht erforderlich ist, um Ziele für die Abfragen pro Sekunde und die Latenz zu erreichen.

Sie können den Standardschwellenmesswert und das Ziel durch Angabe von autoscalingMetricSpecs überschreiben. Wenn Ihre Bereitstellung so konfiguriert ist, dass sie nur anhand der CPU-Nutzung skaliert, wird sie auch bei hoher GPU-Nutzung nicht hochskaliert.

Die folgenden Autoscaling-Messwerte werden unterstützt:

  • CPU-Auslastung (aiplatform.googleapis.com/prediction/online/cpu/utilization): Wird basierend auf der CPU-Nutzung skaliert. Die Einheit ist die CPU-Auslastung pro Replikat. Der Zielwert ist ein Prozentsatz (0–100). Der Standardzielwert ist 60%.
  • GPU-Auslastung (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle): Skaliert basierend auf der GPU-Nutzung. Die Einheit ist die GPU-Auslastung pro Replikat. Der Zielwert ist ein Prozentsatz (0–100). Der Standardzielwert ist 60%.
  • Anzahl der Anfragen (aiplatform.googleapis.com/prediction/online/request_count): Wird basierend auf der Anzahl der Anfragen skaliert. Die Einheit ist „Anfragen pro Minute und Replikat“. Der Zielwert ist eine Ganzzahl. Dieser Messwert ist standardmäßig deaktiviert.
  • Pub/Sub-Warteschlangengröße (Vorabversion, keine Google Cloud CLI-Unterstützung) (pubsub.googleapis.com/subscription/num_undelivered_messages): Die Skalierung erfolgt basierend auf der Anzahl der nicht zugestellten Nachrichten eines Pub/Sub-Abos. Die Einheit ist „nicht zugestellte Nachrichten pro Replikat“. Der Zielwert ist eine Ganzzahl. Dieser Messwert ist standardmäßig deaktiviert.

Verwenden Sie bei der Konfiguration des Autoscalings METRIC_NAME für die Messwert-ID und TARGET_THRESHOLD für den Zielwert.

Autoscaling während der Bereitstellung konfigurieren

Verwenden Sie eine der folgenden Schnittstellen, um das Autoscaling beim Bereitstellen eines Modells zu konfigurieren:

gcloud

Verwenden Sie den Befehl gcloud ai endpoints deploy-model, um das Autoscaling beim Bereitstellen eines Modells mit der gcloud CLI zu konfigurieren.

Beachten Sie, dass sich das Messwert-Keyword für die Google Cloud CLI geringfügig unterscheidet. Verwenden Sie Folgendes:

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

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • ENDPOINT_ID: Die ID Ihres Endpunkts.
  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region Ihres Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • MACHINE_TYPE: Der Maschinentyp für das bereitgestellte Modell (z.B. n1-standard-4) verwenden.
  • ACCELERATOR_TYPE: Optional. Der Typ des anzuhängenden GPU-Beschleunigers (z.B. NVIDIA_L4) verwenden.
  • ACCELERATOR_COUNT: Optional. Die Anzahl der Beschleuniger, die an jede Maschine angehängt werden sollen.
  • MIN_REPLICA_COUNT: Die Mindestanzahl von Replikaten für das Autoscaling.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Replikaten für das Autoscaling.
  • METRIC_NAME_GCLOUD: Die Kennzeichnung des Autoscaling-Messwerts.
  • TARGET_THRESHOLD: Der Zielwert für den angegebenen Messwert.
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

Wenn Sie Autoscaling beim Bereitstellen eines Modells mit der REST API konfigurieren möchten, verwenden Sie die Methode projects.locations.endpoints.deployModel.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • ENDPOINT_ID: Die ID Ihres Endpunkts.
  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region Ihres Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_DISPLAY_NAME: Ein Anzeigename für das bereitgestellte Modell.
  • MACHINE_TYPE: Der Maschinentyp für das bereitgestellte Modell (z.B. n1-standard-4) verwenden.
  • ACCELERATOR_TYPE: Optional. Der Typ des anzuhängenden GPU-Beschleunigers (z.B. NVIDIA_L4) verwenden.
  • ACCELERATOR_COUNT: Optional. Die Anzahl der Beschleuniger, die an jede Maschine angehängt werden sollen.
  • MIN_REPLICA_COUNT: Die Mindestanzahl von Replikaten für das Autoscaling.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Replikaten für das Autoscaling.
  • METRIC_NAME: Die Kennzeichnung des Autoscaling-Messwerts.
  • TARGET_THRESHOLD: Der Zielwert für den angegebenen Messwert.

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Für das Autoscaling auf Grundlage von Messwerten für die Pub/Sub-Warteschlangengröße (Vorabversion) sind zusätzliche Informationen zum Pub/Sub-Abo erforderlich:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: Die Projekt-ID des Pub/Sub-Abos.
  • PUBSUB_SUBSCRIPTION_ID: Die ID des Pub/Sub-Abos.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Python

Die automatische Skalierung des Python SDK wird über Parameternamen im deploy()-Funktionsaufruf konfiguriert. Im Beispielbefehl wird die auf Parallelität basierende automatische Skalierung verwendet. Die konfigurierbaren Autoscaling-Parameter sind:

  • autoscaling_target_cpu_utilization
  • autoscaling_target_accelerator_duty_cycle
  • autoscaling_target_request_count_per_minute

So konfigurieren Sie die automatische Skalierung beim Bereitstellen eines Modells mit dem Vertex AI SDK für Python:

Ersetzen Sie vor dem Ausführen des Codes Folgendes:

  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region Ihres Endpunkts.
  • ENDPOINT_ID: Die ID Ihres Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_DISPLAY_NAME: Ein Anzeigename für das bereitgestellte Modell.
  • MACHINE_TYPE: Der Maschinentyp für das bereitgestellte Modell (z.B. n1-standard-4) verwenden.
  • ACCELERATOR_TYPE: Optional. Der Typ des anzuhängenden GPU-Beschleunigers (z.B. NVIDIA_L4) verwenden.
  • ACCELERATOR_COUNT: Optional. Die Anzahl der Beschleuniger, die an jede Maschine angehängt werden sollen.
  • MIN_REPLICA_COUNT: Die Mindestanzahl von Replikaten für das Autoscaling.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Replikaten für das Autoscaling.
  • METRIC_NAME: Die Kennzeichnung des Autoscaling-Messwerts.
  • TARGET_THRESHOLD: Der Zielwert für den angegebenen Messwert.
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,
)

Für das Autoscaling auf Grundlage von Messwerten für die Pub/Sub-Warteschlangengröße (Vorabversion, nur aiplatform_v1beta1 wird unterstützt) sind zusätzliche Informationen zum Pub/Sub-Abo erforderlich:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: Die Projekt-ID des Pub/Sub-Abos.
  • PUBSUB_SUBSCRIPTION_ID: Die ID des Pub/Sub-Abos.
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"
  },
)

Autoscaling-Konfiguration aktualisieren

Verwenden Sie eine der folgenden Schnittstellen, um eine vorhandene Autoscaling-Konfiguration zu aktualisieren:

REST

Verwenden Sie die Methode projects.locations.endpoints.mutateDeployedModel, um die Autoscaling-Konfiguration eines bereitgestellten Modells mit der REST API zu aktualisieren.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • ENDPOINT_ID: Die ID Ihres Endpunkts.
  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region Ihres Endpunkts.
  • DEPLOYED_MODEL_ID: Die ID des bereitzustellenden Modells, das aktualisiert werden soll.
  • MIN_REPLICA_COUNT: Die neue Mindestanzahl von Replikaten für das Autoscaling.
  • MAX_REPLICA_COUNT: Die neue maximale Anzahl von Replikaten für das Autoscaling.
  • METRIC_NAME: Die Kennzeichnung des Autoscaling-Messwerts.
  • TARGET_THRESHOLD: Der Zielwert für den angegebenen Messwert.

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Für das Autoscaling auf Grundlage von Messwerten für die Pub/Sub-Warteschlangengröße (Vorabversion) sind zusätzliche Informationen zum Pub/Sub-Abo erforderlich:

  • PUBSUB_SUBSCRIPTION_PROJECT_ID: Die Projekt-ID des Pub/Sub-Abos.
  • PUBSUB_SUBSCRIPTION_ID: Die ID des Pub/Sub-Abos.
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Skalierung auf null (Vorschau)

Mit der Funktion „Auf null skalieren“ können Sie Ihre Modellserverbereitstellungen automatisch auf null Replikate skalieren, wenn kein Traffic vorhanden ist. In diesem Zeitraum fallen keine Abrechnungskosten an.

Wenn Traffic den skalierten Zielendpunkt erreicht, wird eine 429 - Model is not yet ready for inference. Wait and then try your request again-Antwort empfangen, die Anfrage wird verworfen und ein Hochskalierungssignal wird an den Zielmodellserver gesendet.

Dadurch wird der Modellserver von null auf den im Feld DedicatedResources.initial_replica_count angegebenen Wert skaliert. Der Standardwert ist 1.

Diese Funktion ist für die folgenden Anwendungsfälle konzipiert:

  • Bereitstellungen mit regelmäßig langen Phasen ohne Traffic.
  • Endpunkte, die in der Regel während der Geschäftszeiten Traffic empfangen und zu anderen Zeiten inaktiv sind.

Aktivierung und Nutzung

Die Funktion „Auf null skalieren“ kann nicht für freigegebene öffentliche Endpunkte aktiviert werden. Alle anderen Endpunkttypen sind kompatibel.

Wenn Sie „Scale to Zero“ aktivieren möchten, geben Sie min_replica_count=0 im Abschnitt DedicatedResources Ihres deploy-model-Requests an (der auf die v1beta1-Version der Vertex Prediction API ausgerichtet ist).

Optionale Parameter

In DedicatedResources können Sie einen initial_replica_count-Wert zwischen 1 und max_replica_count (einschließlich) angeben.

Außerdem wurde DedicatedResources ein neuer ScaleToZeroSpec-Abschnitt hinzugefügt, in dem die Konfiguration über zwei Parameter im Zusammenhang mit „Auf null skalieren“ möglich ist:

  • min_scaleup_period: Dauer (in Sekunden), bevor ein Modellserver in die Scale-to-Zero-Bewertung aufgenommen wird. Die Bereitstellung versucht erst nach Ablauf dieses Zeitraums, wieder auf null Replikate herunterzuskalieren, auch wenn kein Traffic vorhanden ist. So wird bei der ersten Bereitstellung und den nachfolgenden Scale-up-Ereignissen ein Pufferwert berücksichtigt, bevor der Traffic mit dem Zielendpunkt abgeglichen wird. Dies kann dazu führen, dass die Bereitstellung skaliert wird.
    • Standardwert: 1 Stunde (3.600 Sekunden)
    • Mindestwert: 5 Minuten (300 Sekunden)
    • Höchstwert: 8 Stunden (28.800 Sekunden).
  • idle_scaledown_period: Dauer (in Sekunden), in der kein Traffic vorhanden ist, bevor der Zielmodellserver auf null Replikate herunterskaliert wird.
    • Standardwert: 1 Stunde (3.600 Sekunden)
    • Mindestwert: 5 Minuten (300 Sekunden)
    • Höchstwert: 8 Stunden (28.800 Sekunden).

Erwartetes Verhalten

Eine Anfrage, die an ein verkleinertes Modell gesendet wird, gibt eine 429-Antwort mit Model is not yet ready for inference. Please wait and then try your request again zurück.

Warten Sie und wiederholen Sie Ihre Anfrage. Anfragen, die in dieser Phase gesendet werden, werden verworfen.

Beschränkungen

  • „Scale To Zero“ ist nur mit Bereitstellungen einzelner Modelle und einem Modell pro Endpunkt kompatibel.
  • „Auf Null skalieren“ kann nicht für gemeinsam genutzte öffentliche Endpunkte aktiviert werden. Alle anderen Endpunkttypen sind kompatibel.
  • Ohne Reservierungen kann es beim Hochskalieren aus einem herunterskalierten Zustand zu Engpässen kommen (je nach Maschinentyp).

  • DeployedModels, die länger als 30 Tage auf null skaliert werden (weil sie keinen Traffic erhalten), unterliegen der automatischen Aufhebung der Bereitstellung.

gcloud

Wenn Sie beim Bereitstellen eines Modells mit der gcloud CLI die Funktion „Auf 0 skalieren“ konfigurieren möchten, verwenden Sie den Befehl gcloud beta ai endpoints deploy-model.

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • ENDPOINT_ID: Die ID Ihres Endpunkts.
  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region Ihres Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • MACHINE_TYPE: Der Maschinentyp für das bereitgestellte Modell (z.B. n1-standard-4) verwenden.
  • ACCELERATOR_TYPE: Optional. Der Typ des anzuhängenden GPU-Beschleunigers (z.B. NVIDIA_L4) verwenden.
  • ACCELERATOR_COUNT: Optional. Die Anzahl der Beschleuniger, die an jede Maschine angehängt werden sollen.
  • MIN_REPLICA_COUNT: Die Mindestanzahl von Replikaten für das Autoscaling.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Replikaten für das 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

Wenn Sie ein Modell mithilfe der REST API bereitstellen und dabei Scale-to-Zero konfigurieren möchten, verwenden Sie die Methode projects.locations.endpoints.deployModel.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • ENDPOINT_ID: Die ID Ihres Endpunkts.
  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region Ihres Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_DISPLAY_NAME: Ein Anzeigename für das bereitgestellte Modell.
  • MACHINE_TYPE: Der Maschinentyp für das bereitgestellte Modell (z.B. n1-standard-4) verwenden.
  • ACCELERATOR_TYPE: Optional. Der Typ des anzuhängenden GPU-Beschleunigers (z.B. NVIDIA_L4) verwenden.
  • ACCELERATOR_COUNT: Optional. Die Anzahl der Beschleuniger, die an jede Maschine angehängt werden sollen.
  • MIN_REPLICA_COUNT: Die Mindestanzahl von Replikaten für das Autoscaling.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Replikaten für das Autoscaling.

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Das Skalieren auf null des Python SDK wird über den v1beta1 API-Client konfiguriert.

Ersetzen Sie vor dem Ausführen des Codes Folgendes:

  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region Ihres Endpunkts.
  • ENDPOINT_ID: Die ID Ihres Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_DISPLAY_NAME: Ein Anzeigename für das bereitgestellte Modell.
  • MACHINE_TYPE: Der Maschinentyp für das bereitgestellte Modell (z.B. n1-standard-4) verwenden.
  • ACCELERATOR_TYPE: Optional. Der Typ des anzuhängenden GPU-Beschleunigers (z.B. NVIDIA_L4) verwenden.
  • ACCELERATOR_COUNT: Optional. Die Anzahl der Beschleuniger, die an jede Maschine angehängt werden sollen.
  • MIN_REPLICA_COUNT: Die Mindestanzahl von Replikaten für das Autoscaling.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Replikaten für das Autoscaling.
  • METRIC_NAME: Die Kennzeichnung des Autoscaling-Messwerts.
  • TARGET_THRESHOLD: Der Zielwert für den angegebenen Messwert.
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()

Ressourcennutzung verwalten

Sie können Ihren Endpunkt überwachen, um Messwerte wie CPU- und Beschleunigernutzung, die Anzahl der Anfragen, die Latenz sowie die aktuelle und die Zielanzahl der Replikate zu verfolgen. Diese Informationen können Ihnen helfen, die Ressourcennutzung und das Skalierungsverhalten Ihres Endpunkts zu verstehen.

Beachten Sie, dass jedes Replikat nur einen einzigen Container ausführt. Das bedeutet: Wenn ein Inferenzcontainer die ausgewählte Rechenressource nicht vollständig nutzen kann, z. B. Single-Threaded-Code für eine Mehrkern-Maschine oder ein benutzerdefiniertes Modell, das einen anderen Dienst als Teil der Erstellung der Inferenz aufruft, werden Ihre Knoten möglicherweise nicht hochskaliert.

Wenn Sie beispielsweise FastAPI oder einen Modellserver mit einer konfigurierbaren Anzahl von Workern oder Threads verwenden, kann es in vielen Fällen sein, dass bei Vorhandensein mehrerer Worker die Ressourcenauslastung erhöht wird, wodurch der Dienst die Anzahl der Replikate besser automatisch skalieren kann.

Wir empfehlen in der Regel, mit einem Worker oder Thread pro Kern zu beginnen. Wenn Sie feststellen, dass die CPU-Auslastung niedrig ist, insbesondere bei hoher Last, oder dass Ihr Modell aufgrund der niedrigen CPU-Auslastung nicht hochskaliert wird, erhöhen Sie die Anzahl der Worker. Wenn Sie andererseits feststellen, dass die Auslastung zu hoch ist und die Latenz unter Last höher als erwartet ist, verwenden Sie weniger Worker. Wenn Sie bereits nur einen einzigen Worker verwenden, versuchen Sie es mit einem kleineren Maschinentyp.

Skalierungsverhalten und Verzögerung

Vertex AI passt die Anzahl der Replikate alle 15 Sekunden mithilfe von Daten aus dem vorherigen 5‑Minuten-Fenster an. Für jeden 15-Sekunden-Zyklus misst das System die Serverauslastung und generiert anhand der folgenden Formel eine Zielanzahl von Replikaten:

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

Wenn Sie beispielsweise zwei Replikate haben, die zu 100 % ausgelastet sind, ist das Ziel 4:

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

Ein weiteres Beispiel: Wenn Sie derzeit 10 Replikate haben und die Auslastung auf 1 % sinkt, ist das Ziel 1:

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

Am Ende jedes 15-Sekunden-Zyklus passt das System die Anzahl der Replikate an den höchsten Zielwert aus dem vorherigen 5-Minuten-Fenster an. Beachten Sie, dass aufgrund der Auswahl des höchsten Zielwerts der Endpunkt nicht herunterskaliert wird, wenn in diesem 5-Minuten-Fenster ein plötzlicher Anstieg der Auslastung auftritt, selbst wenn die Gesamtauslastung sehr niedrig ist. Wenn das System hingegen hochskaliert werden muss, erfolgt dies innerhalb von 15 Sekunden, da der höchste Zielwert anstelle des Durchschnitts ausgewählt wird.

Auch wenn Vertex AI die Anzahl der Replikate anpasst, dauert es einige Zeit, bis die Replikate gestartet oder heruntergefahren werden. Daher gibt es eine zusätzliche Verzögerung, bevor der Endpunkt an den Traffic angepasst wird. Die wichtigsten Faktoren, die zu dieser Zeit beitragen, sind:

  • Die Zeit für die Bereitstellung und den Start der Compute Engine-VMs
  • Die Zeit, um den Container aus der Registry herunterzuladen
  • Die Zeit, um das Modell aus dem Speicher zu laden

Am besten verstehen Sie das reale Skalierungsverhalten Ihres Modells dadurch, dass Sie einen Lasttest ausführen und die für Ihr Modell und Ihren Anwendungsfall relevanten Eigenschaften optimieren. Wenn das Autoscaling für Ihre Anwendung nicht schnell genug hochskaliert wird, stellen Sie genügend min_replicas bereit, um den erwarteten Baseline-Traffic zu verarbeiten.

Skalierungskonfiguration aktualisieren

Wenn Sie beim Bereitstellen des Modells DedicatedResources oder AutomaticResources angegeben haben, können Sie die Skalierungskonfiguration aktualisieren, ohne das Modell noch einmal bereitzustellen. Rufen Sie dazu mutateDeployedModel auf.

Beispiel: Mit folgender Anfrage werden max_replica und autoscaling_metric_specs aktualisiert und das Container-Logging deaktiviert.

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

Verwendungshinweise:

  • Sie können nicht den Maschinentyp ändern oder von DedicatedResources zu AutomaticResources oder umgekehrt wechseln. Die einzigen Skalierungskonfigurationsfelder, die Sie ändern können, sind min_replica, max_replica, required_replica und AutoscalingMetricSpec (nur DedicatedResources).
  • Sie müssen jedes Feld, das Sie aktualisieren müssen, in updateMask auflisten. Nicht aufgeführte Felder werden ignoriert.
  • Das DeployedModel muss den Status DEPLOYED haben. Es kann höchstens einen aktiven Mutationsvorgang pro bereitgestelltem Modell geben.
  • Mit mutateDeployedModel können Sie auch das Container-Logging aktivieren oder deaktivieren. Weitere Informationen finden Sie unter Online-Inferenz-Logging.