Inferenzen des Gemma 4-Modells auf Cloud Run mit RTX 6000 Pro-GPU mit vLLM ausführen

1. Einführung

Übersicht

Lerninhalte

Gemma 4-Modell auf einer Cloud Run RTX 6000 Pro-GPU bereitstellen
vLLM und Run:ai Model Streamer für schnellere Inferenz und kürzere Instanzstarts verwenden.

2. Einrichtung und Anforderungen

Legen Sie Umgebungsvariablen fest, die in diesem Codelab verwendet werden:

# Model name on HuggingFace Hub
export MODEL_NAME="google/gemma-4-31B-it"

# Cloud Run Service name
export SERVICE_NAME=gemma-rtx-vllm-codelab

# Cloud Project and Region for Cloud Run
export GOOGLE_CLOUD_PROJECT=<YOUR_PROJECT_ID> # Change to your Project Id
export GOOGLE_CLOUD_REGION=us-central1 # or europe-west4

# Optional HuggingFace User Access Token for accessing model weights 
# (https://huggingface.co/docs/hub/en/security-tokens),
# if you are loading a private model.
export HF_TOKEN=""

# Service account for Cloud Run service
export SERVICE_ACCOUNT="vllm-service-sa"
export SERVICE_ACCOUNT_EMAIL="${SERVICE_ACCOUNT}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com"

# GCS Bucket for the model cache.
export MODEL_CACHE_BUCKET="${GOOGLE_CLOUD_PROJECT}-${GOOGLE_CLOUD_REGION}-hf-model-cache"
# Model cache location in GSC bucket
export GCS_MODEL_LOCATION="gs://${MODEL_CACHE_BUCKET}/model-cache/${MODEL_NAME}"

# VPC Network for Direct VPC Egress
export VPC_NETWORK="vllm-${GOOGLE_CLOUD_REGION}-net"
export VPC_SUBNET="vllm-${GOOGLE_CLOUD_REGION}-subnet"
export SUBNET_RANGE="10.8.0.0/26"

# set the project
gcloud config set project $GOOGLE_CLOUD_PROJECT
gcloud config set run/region $GOOGLE_CLOUD_REGION

Für dieses Codelab erforderliche APIs aktivieren

gcloud services enable --project "${GOOGLE_CLOUD_PROJECT}" \
    run.googleapis.com \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    iam.googleapis.com \
    compute.googleapis.com \
    vpcaccess.googleapis.com \
    storage.googleapis.com

3. Dienstkonto erstellen

Wenn Sie kein Dienstkonto angeben, wenn der Cloud Run-Dienst oder -Job erstellt wird, verwendet Cloud Run das Compute Engine-Standarddienstkonto. Es wird empfohlen, ein separates Dienstkonto für den Cloud Run-Dienst zu verwenden, um zu vermeiden, dass der Dienst mit übermäßigen Berechtigungen ausgeführt wird.

Dienstkonto für Cloud Run-Dienst erstellen

gcloud iam service-accounts create ${SERVICE_ACCOUNT} \
  --project "${GOOGLE_CLOUD_PROJECT}" \
  --display-name "vLLM Service Account"

4. Cloud Storage einrichten

Erstellen Sie einen Cloud Storage-Bucket zum Speichern der Modellgewichte. So können Sie ausgehenden Direct VPC-Traffic verwenden, um Modellgewichte schneller herunterzuladen, wenn Cloud Run eine Dienstinstanz startet.

In Kombination mit der Run:ai Model Streamer-Funktion in vLLM wird die Ladezeit des Modells erheblich reduziert.

Bucket erstellen

Achten Sie darauf, dass es sich um einen Bucket mit einer einzelnen Region handelt, der sich am selben Standort wie der Cloud Run-Dienst befindet.

gcloud storage buckets create "gs://${MODEL_CACHE_BUCKET}" \
    --uniform-bucket-level-access --public-access-prevention \
    --project "${GOOGLE_CLOUD_PROJECT}" --location "${GOOGLE_CLOUD_REGION}"

5. Modellgewichtungen abrufen und im Cache speichern

Laden Sie als Nächstes das Gemma 4-Modell in Ihren Cloud Storage-Bucket herunter.

Die Gewichte von Modellen sind Dutzende von Gigabyte groß. Das Herunterladen auf Ihren lokalen Computer oder in Cloud Shell ist möglicherweise nicht möglich.

Stattdessen verwenden wir Cloud Build mit ausreichend Speicherplatz für die Modellgewichte.

gcloud builds submit --project="${GOOGLE_CLOUD_PROJECT}" --region="${GOOGLE_CLOUD_REGION}" --no-source \
    --substitutions="_MODEL_NAME=${MODEL_NAME},_HF_TOKEN=${HF_TOKEN},_GCS_MODEL_LOCATION=${GCS_MODEL_LOCATION}" \
    --config=/dev/stdin <<'EOF'
steps:
- name: 'gcr.io/google.com/cloudsdktool/google-cloud-cli:slim'
  entrypoint: 'bash'
  args:
  - '-c'
  - |
    set -e
    pip3 install --root-user-action=ignore --break-system-packages huggingface_hub[cli]
    echo "Downloading the model..."
    if [[ "$_HF_TOKEN" != "" ]]; then
      hf download "$_MODEL_NAME" --token $_HF_TOKEN --local-dir "./model-cache/$_MODEL_NAME"
    else
      hf download "$_MODEL_NAME" --local-dir "./model-cache/$_MODEL_NAME"
    fi
    echo "Uploading the model..."
    gcloud storage cp -r "./model-cache/$_MODEL_NAME" "$_GCS_MODEL_LOCATION"
options:
  machineType: 'E2_HIGHCPU_32'
  diskSizeGb: 500
EOF

6. Netzwerk für ausgehenden Direct VPC-Traffic konfigurieren

Für die Konfiguration von Direct VPC Egress muss ein Netzwerk und ein Subnetz mit aktiviertem privaten Google-Zugriff erstellt werden.

So können Cloud Run-Dienste eine Verbindung zu den externen IP-Adressen herstellen, die von Google APIs und Diensten, einschließlich Cloud Storage, verwendet werden.

Netzwerk erstellen

gcloud compute networks create "$VPC_NETWORK" \
        --subnet-mode=custom \
        --bgp-routing-mode=regional \
        --project "$GOOGLE_CLOUD_PROJECT"

Subnetz erstellen

gcloud compute networks subnets create "$VPC_SUBNET" \
        --network="$VPC_NETWORK" \
        --region="$GOOGLE_CLOUD_REGION" \
        --range="$SUBNET_RANGE" \
        --enable-private-ip-google-access \
        --project "$GOOGLE_CLOUD_PROJECT"

7. Zugriffsrichtlinie für Dienstkonten konfigurieren

Das Cloud Run-Dienstkonto benötigt Berechtigungen für den Zugriff auf Modellgewichte in dem von Ihnen erstellten Storage-Bucket.

gcloud storage buckets add-iam-policy-binding "gs://${MODEL_CACHE_BUCKET}" \
    --member "serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --role "roles/storage.admin" \
    --project "${GOOGLE_CLOUD_PROJECT}"

8. Konfigurationsvariablen initialisieren

Definieren Sie die Variablen für die vLLM-Inferenz-Engine und den Cloud Run-Dienst.

# vLLM variables
export MAX_MODEL_LEN=32767      # 32767 to improve concurrency. Keep it empty to use model's maximim context length (256K)
export QUANTIZATION_TYPE="fp8"  # Model quantization for faster performance and lower memory usage.
export KV_CACHE_DTYPE="fp8"     # KV-cache quantization to save GPU memory.
export GPU_MEM_UTIL="0.95"      # Fraction of GPU memory to be used by the vLLM engine.
export TENSOR_PARALLEL_SIZE="1" # Partitioning model across GPUs (1 here as we have only 1 GPU).
export MAX_NUM_SEQS=8           # Max concurrent requests vLLM processes in one batch.

# Cloud Run variables
export CLOUD_RUN_CPU_NUM=20
export CLOUD_RUN_MEMORY_GB=80
export CLOUD_RUN_MAX_INSTANCES=3
export CLOUD_RUN_CONCURRENCY=16

Hinweis zur Leistungsoptimierung:Beim Optimieren dieser Variablen muss ein Gleichgewicht zwischen Durchsatz und Latenz gefunden werden:

MAX_NUM_SEQS im Vergleich zu CLOUD_RUN_CONCURRENCY: CLOUD_RUN_CONCURRENCY sollte mindestens so groß wie MAX_NUM_SEQS sein. Für eine optimale Auslastung bei Trafficspitzen sollten Sie den Wert etwas höher ansetzen (z.B. das Doppelte).
Speicherbelastung: MAX_MODEL_LEN und MAX_NUM_SEQS belegen beide GPU-Arbeitsspeicher für den KV-Cache. Wenn bei großen Kontextlängen OOM-Fehler (Out-of-Memory) auftreten, sollten Sie MAX_NUM_SEQS verringern.
Latenz: Eine höhere Gleichzeitigkeit (MAX_NUM_SEQS) erhöht den Gesamtdurchsatz, kann aber die Latenz einzelner Anfragen erhöhen.
Skalierung: Mit CLOUD_RUN_MAX_INSTANCES können Sie horizontal skalieren. Wenn die Latenz der einzelnen Instanzen akzeptabel ist, Sie aber mehr Gesamtkapazität benötigen, erhöhen Sie diesen Wert.

9. In Cloud Run bereitstellen

vLLM-Container-Befehlszeile vorbereiten

vLLM benötigt viele Parameter, um große Modelle schnell und effizient auszuführen.

CONTAINER_ARGS=(
    "vllm"
    "serve"
    "${GCS_MODEL_LOCATION}"
    "--served-model-name" "${MODEL_NAME}"
    "--enable-log-requests"
    "--enable-chunked-prefill"
    "--enable-prefix-caching"
    "--generation-config" "auto"
    "--enable-auto-tool-choice"
    "--tool-call-parser" "gemma4"
    "--reasoning-parser" "gemma4"
    "--dtype" "bfloat16"
    "--quantization" "${QUANTIZATION_TYPE}"
    "--kv-cache-dtype" "${KV_CACHE_DTYPE}"
    "--max-num-seqs" "${MAX_NUM_SEQS}"
    "--limit-mm-per-prompt" '{"image":4,"video":2}'
    "--gpu-memory-utilization" "${GPU_MEM_UTIL}"
    "--tensor-parallel-size" "${TENSOR_PARALLEL_SIZE}"
    "--load-format" "runai_streamer"
    "--port" "8080"
    "--host" "0.0.0.0"
)

if [[ "${MAX_MODEL_LEN}" != "" ]]; then
    CONTAINER_ARGS+=("--max-model-len" "${MAX_MODEL_LEN}")
fi

export CONTAINER_ARGS_STR="${CONTAINER_ARGS[*]}"

Cloud Run-Dienst bereitstellen

Führen Sie den folgenden Befehl aus, um den Cloud Run-Dienst bereitzustellen.

gcloud beta run deploy "${SERVICE_NAME}" \
    --image="us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4" \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --region "${GOOGLE_CLOUD_REGION}" \
    --service-account "${SERVICE_ACCOUNT_EMAIL}" \
    --execution-environment gen2 \
    --no-allow-unauthenticated \
    --cpu="${CLOUD_RUN_CPU_NUM}" \
    --memory="${CLOUD_RUN_MEMORY_GB}Gi" \
    --gpu=1 \
    --gpu-type=nvidia-rtx-pro-6000 \
    --no-gpu-zonal-redundancy \
    --no-cpu-throttling \
    --max-instances ${CLOUD_RUN_MAX_INSTANCES} \
    --concurrency ${CLOUD_RUN_CONCURRENCY} \
    --network ${VPC_NETWORK} \
    --subnet ${VPC_SUBNET} \
    --vpc-egress all-traffic \
    --set-env-vars "MODEL_NAME=${MODEL_NAME}" \
    --set-env-vars "GOOGLE_CLOUD_PROJECT=${GOOGLE_CLOUD_PROJECT}" \
    --set-env-vars "GOOGLE_CLOUD_REGION=${GOOGLE_CLOUD_REGION}" \
    --startup-probe tcpSocket.port=8080,initialDelaySeconds=240,failureThreshold=1,timeoutSeconds=240,periodSeconds=240 \
    --command "bash" \
    --args="^;^-c;${CONTAINER_ARGS_STR}"

10. Dienst testen

Nach der Bereitstellung können Sie über die OpenAI-kompatible vLLM-API mit Ihrem Gemma 4-Modell interagieren.

Service-URL abrufen

Rufen Sie die URL Ihres bereitgestellten Cloud Run-Dienstes ab.

SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --project "${GOOGLE_CLOUD_PROJECT}" --region "${GOOGLE_CLOUD_REGION}" --format 'value(status.url)')
echo "Service URL: $SERVICE_URL"

Inferenz ausführen

Senden Sie mit curl einen Prompt an das Modell.

curl -s "$SERVICE_URL/v1/chat/completions" \
  -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "'"${MODEL_NAME}"'",
  "messages": [
    {"role": "user", "content": "Why is the sky blue?"}
  ],
  "chat_template_kwargs": {
    "enable_thinking": true
  },
  "skip_special_tokens": false
}' | jq -r '.choices[0].message.content'

11. Glückwunsch!

Herzlichen Glückwunsch zum Abschluss des Codelabs!

Wir empfehlen, die Cloud Run-Dokumentation zu lesen.

Behandelte Themen

Gemma 4-Modell auf einer Cloud Run RTX 6000 Pro-GPU bereitstellen
Konfiguration von ausgehendem Direct VPC-Traffic und vLLM-Modellstreaming mit Cloud Storage für einen schnelleren Dienststart.

12. Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder das Projekt löschen oder die einzelnen Ressourcen entfernen.

Option 1: Ressourcen löschen

Cloud Run-Dienst löschen

gcloud run services delete $SERVICE_NAME \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --region "${GOOGLE_CLOUD_REGION}"
      --quiet

Dienstkonto löschen

gcloud iam service-accounts delete \
      ${SERVICE_ACCOUNT_EMAIL} \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --quiet

Cloud Storage-Bucket löschen

gcloud storage rm --recursive gs://$MODEL_CACHE_BUCKET

VPC-Netzwerk und Subnetz löschen

gcloud compute networks subnets delete $VPC_SUBNET \
    --region "${GOOGLE_CLOUD_REGION}" \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --quiet

gcloud compute networks delete $VPC_NETWORK \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --quiet

Option 2: Projekt löschen

Wenn Sie das gesamte Projekt löschen möchten, rufen Sie Ressourcen verwalten auf, wählen Sie das Projekt aus, das Sie in Schritt 2 erstellt haben, und klicken Sie auf „Löschen“. Wenn Sie das Projekt löschen, müssen Sie das Projekt in Ihrem Cloud SDK ändern. Sie können die Liste aller verfügbaren Projekte mit gcloud projects list aufrufen.