Vertex AI Predictions: Kosten senken mit Cloud Run

Viele Unternehmen wollen die Vorteile von Vertex AI nutzen – wegen des umfangreichen Funktionsumfangs und der nahtlosen Einbindung in das Google-Cloud-Ökosystem – statt einfach nur einen Endpoint auf einer VM aufzusetzen und das Modell dort für Predictions auszuliefern. Doch die Kostenseite ist eine erhebliche Hürde und macht eine effizientere, kostengünstigere Lösung notwendig.

Der Knackpunkt: Die Kosten für das Deployment von Modellen in Vertex AI sind zeitabhängig – unabhängig davon, ob die Ressourcen tatsächlich genutzt werden. So beschreibt es auch die Preisdokumentation:

AI Platform Prediction liefert Predictions Ihres Modells aus, indem eine bestimmte Anzahl virtueller Maschinen ("Nodes") betrieben wird.

Berechnet wird die Laufzeit jedes Nodes für Ihr Modell, einschließlich:

1. wenn der Node eine Online-Prediction-Anfrage verarbeitet.

2. wenn der Node sich im Bereitschaftszustand befindet, um Online-Predictions auszuliefern.

Die Kosten für eine Stunde Laufzeit eines Nodes entsprechen einer Node-Stunde. Eine Node-Stunde steht für die Zeit, in der eine virtuelle Maschine Ihren Prediction-Job ausführt oder im aktiven Zustand wartet (ein Endpoint mit einem oder mehreren bereitgestellten Modellen), um Prediction- oder Erklärungsanfragen zu bearbeiten.

Wenn Online-Predictions nur zu bestimmten Zeiten am Tag oder in der Woche anfallen, wird die fehlende Möglichkeit zum Skalieren auf null in den Leerlaufphasen zum echten Kostentreiber. Bei GPU-basierten Modellen verschärft sich das Problem zusätzlich, denn hier steigen die Kosten besonders schnell.

In unserem Szenario möchte ein Kunde den Vertex-AI-Service für Online-Predictions des Foundation-Modells Stable Diffusion (mit GPU-Bedarf) während der regulären Arbeitszeiten einsetzen – konkret an fünf Tagen pro Woche von 7 bis 19 Uhr.

Statt 720 Node-Stunden möchte der Kunde nur die tatsächliche Nutzung bezahlen, also lediglich 240 Node-Stunden (30 %).

Um das Problem zu lösen, setzen wir auf Cloud Run Jobs:

Mit Cloud Run Jobs lassen sich lange, bis zum Ende durchlaufende Skripte ausführen – komplett serverlos.

Wenn Ihr Code eine Aufgabe erledigt und sich anschließend beendet (ein Skript ist ein gutes Beispiel), können Sie ihn als Cloud Run Job ausführen. Sie können einen Job über die Kommandozeile mit der gcloud CLI starten oder einen wiederkehrenden Job einplanen.

Unser pragmatischer Ansatz besteht aus drei Hauptschritten:

1. Das Modell auf einem Vertex-AI-Online-Prediction-Endpoint bereitstellen
2. Cloud Run Jobs erzeugen, um das Modell auf den Vertex-AI-Prediction-Endpoints sowohl bereitzustellen als auch wieder zu entfernen
3. Eine Zeitplanung für diese Jobs einrichten

Im Vertex AI Model Garden habe ich ein vortrainiertes Modell ausgewählt, das zu den Anforderungen des Kunden passt. Das Modell stable-diffusion-2–1 erfüllt die Vorgaben. Über die Schaltfläche "Deploy" in der Konsole wird das Modell-Artefakt in die Vertex AI Model Registry hochgeladen und anschließend auf einem Online-Prediction-Endpoint bereitgestellt.

Danach habe ich das Modell erfolgreich getestet und manuell wieder vom Endpoint entfernt.

Details zur Modellversion im Model Garden

Das Modell wurde in die Model Registry importiert

Der Modell-Container ist auf dem Online-Prediction-Endpoint bereitgestellt

Um das Deployment und Un-Deployment unseres Machine-Learning-Modells auf Vertex-AI-Endpoints fein zu steuern, setzen wir auf Cloud Run Jobs.

Aufgabe des Jobs ist es, das Modell entweder bereitzustellen oder wieder zu entfernen. Dazu greift er auf ein Shell-Skript mit den passenden gcloud-Befehlen für Deployment und Un-Deployment auf dem Prediction-Endpoint zurück.

Cloud Run Jobs anlegen

Zum Anlegen der Cloud Run Jobs gehen wir wie folgt vor:

1. Wir setzen die Modellparameter so, dass sie mit den Werten aus dem ersten Deployment des Modells auf dem Endpoint übereinstimmen: MODEL_NAME,MACHINE_TYPE,ACCELERATOR_TYPE,ENDPOINT_NAME

Diese Parameter passen Sie an Ihren Anwendungsfall an. 2. Anschließend legen wir die Cloud Run Jobs für Deployment und Un-Deployment des Modells auf den Vertex-AI-Endpoints an. Die Joberstellung erfolgt über gcloud run jobs mit der Option zum Deployment aus dem Quellcode (-source): Dabei wird der Container gebaut, in die Artifact Registry hochgeladen und der Job auf Cloud Run ausgerollt. 3. Zum Schluss richten wir mit gcloud für die Job-Zeitplanung einen Scheduler-Trigger ein, der die Jobs gemäß Konfiguration ausführt. So lassen sich präzise Zeitpläne definieren, sodass die Ressourcennutzung exakt zu den Zeitfenstern für Online-Predictions am Tag oder in der Woche passt.

Über das GitHub-Repository vertex-ai-mng-deploy lassen sich die Jobs DEPLOY und UNDEPLOY für das Modell auf dem Vertex-AI-Endpoint generieren. Das Repository enthält:

1. CreateCloudRunJobs.sh für das Anlegen der Cloud Run Jobs

2. MngModelDeploy.sh für Deployment/Un-Deployment des Modells auf dem Vertex-AI-Endpoint

3. eine Docker-Datei zum Erstellen eines Containers, der das Skript MngModelDeploy.sh enthält.

Das Skript CreateCloudRunJobs.sh sieht so aus:

#!/bin/bash -xv

#A number that will be used for the id of the model deployment
ENDPOINT_NAME="stabilityai_stable-diffusion-endpoint"
MODEL_NAME="stable-diffusion-2-1"
MACHINE_TYPE="g2-standard-8"
ACCELERATOR_TYPE="nvidia-l4"

PROJECT=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects describe "$PROJECT" --format="value(projectNumber)")
REGION=us-central1
DEPLOY_JOB_NAME=deploy-model-$MODEL_NAME
UNDEPLOY_JOB_NAME=undeploy-model-$MODEL_NAME
TIME_ZONE='UTC'
DEPLOY_SCHEDULE="0 7 * * *"
UN_DEPLOY_SCHEDULE="0 19 * * *"

#create a job for model deploy
gcloud run jobs deploy $DEPLOY_JOB_NAME --region=$REGION --source vertex-ai-mng-deploy \
      --task-timeout=1800 --command "./MngModelDeploy.sh" \
      --args DEPLOY,$ENDPOINT_NAME,$MODEL_NAME,$MACHINE_TYPE,$ACCELERATOR_TYPE \
      --set-env-vars RUN_DEBUG=true,REGION=$REGION

#describe the job created
gcloud run jobs --region=$REGION describe $DEPLOY_JOB_NAME

#create a job for model undeploy
gcloud run jobs deploy $UNDEPLOY_JOB_NAME --region=$REGION --source vertex-ai-mng-deploy \
      --task-timeout=180 --command "./MngModelDeploy.sh" \
      --args UNDEPLOY,$ENDPOINT_NAME,$MODEL_NAME --set-env-vars RUN_DEBUG=true,REGION=$REGION

#describe the job created
gcloud run jobs --region=$REGION describe $UNDEPLOY_JOB_NAME

Job-Zeitplanung:

Der Scheduler-Trigger der Cloud Run Jobs ist entscheidend, um Deployment- und Un-Deployment-Prozesse auf dem Vertex-AI-Endpoint zeitlich zu steuern. Damit lassen sich präzise Zeitpläne festlegen, sodass die Ressourcennutzung genau zu den Zeitfenstern für Online-Predictions am Tag oder in der Woche passt.

Im letzten Abschnitt des Skripts CreateCloudRunJobs.sh werden die geplanten Jobs angelegt (über Cloud Scheduler):

#create a schedule for deploy
gcloud scheduler jobs create http scheduler-$DEPLOY_JOB_NAME \
  --location $REGION \
  --schedule="$DEPLOY_SCHEDULE" --time-zone=$TIME_ZONE \
  --uri="https://$REGION-run.googleapis.com/apis/run.googleapis.com/v1/namespaces/$PROJECT/jobs/$DEPLOY_JOB_NAME:run" \
  --http-method POST \
  --oauth-service-account-email "$PROJECT_NUMBER"[email protected]

#create a schedule for undeploy
gcloud scheduler jobs create http scheduler-$DEPLOY_JOB_NAME \
  --location $REGION \
  --schedule="$UN_DEPLOY_SCHEDULE" --time-zone=$TIME_ZONE \
  --uri="https://$REGION-run.googleapis.com/apis/run.googleapis.com/v1/namespaces/$PROJECT/jobs/$DEPLOY_JOB_NAME:run" \
  --http-method POST \
  --oauth-service-account-email "$PROJECT_NUMBER"[email protected]

Modell-Deployment und Un-Deployment

Das Skript MngModelDeploy.sh wird vom Job ausgeführt und entscheidet anhand des Eingabearguments ACTION, was der Job tun soll – also, ob das Modell bereitgestellt oder entfernt wird:

Modell-Deployment-Job und Befehl:

nadav@cloudshell:~$ gcloud run jobs describe deploy-model-stable-diffusion-2-1 --region=us-central1
✔ Job deploy-model-stable-diffusion-2-1 in region us-central1
Executed 6 times
Last executed 2024-01-30T08:06:22.875396Z with execution deploy-model-stable-diffusion-2-1-sr7kk
Image:           us-central1-docker.pkg.dev/nadav/cloud-run-source-deploy/deploy-model-stable-diffusion-2-1@sha256:328c1117422af347be0906b0e4d27211ca764559e2405e8832d30d2f55158974
Tasks:           1
Command:         ./MngModelDeploy.sh
Args:            DEPLOY stabilityai_stable-diffusion-endpoint stable-diffusion-2-1 g2-standard-8 nvidia-l4
Memory:          512Mi
CPU:             1000m
Task Timeout:    30m
Max Retries:     3
Parallelism:     No limit
Service account: [email protected]
Env vars:
  REGION         us-central1
  RUN_DEBUG      true

if [ "$ACTION" == "DEPLOY" ]; then
 # Model deploy (takes time)
 MODEL_ID=$(gcloud ai models list --region=$REGION \
 --filter="DISPLAY_NAME:$MODEL_NAME" --format="value(MODEL_ID)")

  echo "Deploying model..."
  gcloud ai endpoints deploy-model "$ENDPOINT_ID" --region=$REGION \
  --model="$MODEL_ID" --display-name="$MODEL_NAME"\
  --machine-type="$MACHINE_TYPE" --accelerator=count=1,type="$ACCELERATOR_TYPE"
fi

Modell-Un-Deployment-Job und Befehl:

nadav@cloudshell$ gcloud run jobs describe undeploy-model-stable-diffusion-2-1 --region=us-central1
✔ Job undeploy-model-stable-diffusion-2-1 in region us-central1
Executed 6 times
Last executed 2024-01-30T08:04:57.205233Z with execution undeploy-model-stable-diffusion-2-1-kgrrc
Image:           us-central1-docker.pkg.dev/nadav/cloud-run-source-deploy/undeploy-model-stable-diffusion-2-1@sha256:b1a8de6919205191feab7e4bed5d98fba9b40ecc9cb6cdae5a5fda550a54f612
Tasks:           1
Command:         ./MngModelDeploy.sh
Args:            UNDEPLOY stabilityai_stable-diffusion-endpoint stable-diffusion-2-1
Memory:          512Mi
CPU:             1000m
Task Timeout:    3m
Max Retries:     3
Parallelism:     No limit
Service account: [email protected]
Env vars:
  REGION         us-central1
  RUN_DEBUG      true

if [ "$ACTION" == "UNDEPLOY" ]; then
  echo "Un-deploying model..."
  DEPLOY_MODEL_ID=$(gcloud ai endpoints describe "$ENDPOINT_ID" --region=$REGION \
   --format=json | \
  jq --arg ml_name "$MODEL_NAME" \
  -r '.deployedModels[] | select(.displayName == $ml_name).id')

  gcloud ai endpoints undeploy-model "$ENDPOINT_ID" --region=$REGION \
  --deployed-model-id="$DEPLOY_MODEL_ID"
fi

Unterm Strich bietet der vorgestellte Ansatz – Vertex AI in Kombination mit Cloud Run für Deployment und Zeitsteuerung – einen praxistauglichen und wirkungsvollen Weg, um unnötigen Ressourcenverbrauch in Leerlaufzeiten zu vermeiden und so spürbar Kosten zu sparen.

Wer die spezifischen Herausforderungen zeitabhängiger Kostenmodelle gezielt angeht, schöpft das volle Potenzial von Vertex AI aus – ohne die Wirtschaftlichkeit aus dem Blick zu verlieren.