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

1. Einführung

Übersicht

Lerninhalte

  • Bereitstellung eines Gemma 4-Modells auf einer Cloud Run RTX 6000 Pro-GPU
  • Verwendung von vLLM und Run:ai Model Streamer für schnellere Inferenz und kürzere Instanzstartzeiten

Gemma 4 ist eine Familie von Apache 2-lizenzierten Modellen mit offenen Gewichtungen von Google DeepMind. Die Modelle sind multimodal, mehrsprachig, bieten Argumentationsfähigkeiten und eine effiziente Architektur. Cloud Run ist eine serverlose Umgebung für Container mit Unterstützung für GPUs.

2. Einrichtung und Anforderungen

Hier sind Umgebungsvariablen, die in diesem Codelab verwendet werden. Sie können diese in einer Umgebungsdatei speichern und „sourcen“. Achten Sie darauf, den Wert Ihrer Projekt-ID und optional die Region richtig festzulegen.

# 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=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 beim Erstellen des Cloud Run-Dienstes oder -Jobs kein Dienstkonto angeben, 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 zu vielen Berechtigungen ausgeführt wird.

Dienstkonto für den 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 Modellgewichtungen. So können Sie Direct VPC Egress verwenden, um Modellgewichtungen 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.

Option 1: Modellgewichtungen aus einem freigegebenen Cloud Storage-Bucket kopieren

Google Cloud hostet einen öffentlich zugänglichen Cloud Storage-Bucket mit Gemma 4-Modellgewichtungen.

Führen Sie den folgenden Befehl aus, um sie in Ihren Storage-Bucket zu kopieren:

SHORT_NAME="${MODEL_NAME#*/}"
gcloud storage cp --recursive \
    "gs://vertex-model-garden-public-us/gemma4/${SHORT_NAME}" \
    "${GCS_MODEL_LOCATION}"

Option 2: Modellgewichtungen aus dem Hugging Face-Hub herunterladen

Alternativ können Modellgewichtungen direkt aus dem Hugging Face-Hub abgerufen werden. Modellgewichtungen sind Dutzende von Gigabyte groß und es ist möglicherweise nicht möglich, sie zuerst auf Ihren lokalen Computer oder in Cloud Shell herunterzuladen. Verwenden Sie stattdessen Cloud Build mit genügend Speicherplatz für Modellgewichtungen.

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 Direct VPC Egress konfigurieren

Direct VPC Egress-Konfiguration erfordert die Erstellung eines Netzwerks und Subnetzes mit aktiviertem privaten Google-Zugriff.

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

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 Dienstkonto konfigurieren

Das Cloud Run-Dienstkonto benötigt Berechtigungen für den Zugriff auf Modellgewichtungen im 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

9. In Cloud Run bereitstellen

vLLM-Container-Befehlszeile vorbereiten

vLLM benötigt viele Parameter, um große Modelle schnell und effizient auszuführen. Diese Parameter werden als Argumente an den in Cloud Run bereitgestellten Container übergeben.

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}"
    "--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. Beachten Sie den GPU-Typ (RTX 6000 Pro), das Basis-Image (pytorch-vllm-serve:gemma4) und die Notwendigkeit, sich zu authentifizieren, um den Dienst aufzurufen (--no-allow-unauthenticated).

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}" \
    --port=8080 \
    --timeout=3600 \
    --cpu-boost \
    --startup-probe tcpSocket.port=8080,initialDelaySeconds=240,failureThreshold=40,timeoutSeconds=10,periodSeconds=15 \
    --command "bash" \
    --args="^;^-c;${CONTAINER_ARGS_STR}"

Die Bereitstellung dauert einige Minuten. Danach haben Sie eine GPU-basierte Umgebung, in der Gemma 4 über eine serverlose Infrastruktur mit automatischer Skalierung bereitgestellt wird, einschließlich der Skalierung auf null (kein Traffic, keine Kosten).

10. Dienst testen

Nach der Bereitstellung können Sie mit dem Gemma 4-Modell über die vLLM-API interagieren, die mit OpenAI kompatibel ist.

Dienst-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!

Sie haben das Codelab abgeschlossen.

Wir empfehlen, die Cloud Run-Dokumentation zu lesen.

Behandelte Themen

  • Bereitstellung eines Gemma 4-Modells auf einer Cloud Run RTX 6000 Pro-GPU
  • Konfiguration von Direct VPC Egress 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 in Schritt 2 erstellte Projekt aus und klicken Sie auf „Löschen“. Wenn Sie das Projekt löschen, müssen Sie die Projekte in Ihrem Cloud SDK ändern. Sie können die Liste aller verfügbaren Projekte mit gcloud projects list aufrufen. Wenn Sie die Befehlszeile verwenden möchten, können Sie auch diesen Befehl verwenden:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}