Wnioskowanie modelu Gemma 4 w Cloud Run z użyciem procesora graficznego RTX 6000 Pro i vLLM

1. Wprowadzenie

Uwaga: ta funkcja podlega „Warunkom oferty przed GA” z sekcji Ogólne warunki korzystania z usługi w Szczegółowych warunkach korzystania z usługi. Funkcje w wersji przed GA są dostępne w stanie „takim, jaki jest” i mogą mieć ograniczone wsparcie. Więcej informacji znajdziesz w opisach etapu uruchamiania.

Przegląd

Czego się nauczysz

• Jak wdrożyć model Gemma 4 na GPU RTX 6000 Pro w Cloud Run
• Jak używać vLLM i Run:ai Model Streamer, aby przyspieszyć wnioskowanie i skrócić czas uruchamiania instancji.

Uwaga: w tym ćwiczeniu z programowania używamy modelu Gemma 4 31B dostosowanego do instrukcji. W tym ćwiczeniu pokazujemy, jak używać Run:ai Model Streamer i bezpośredniego ruchu wychodzącego VPC, aby skrócić czas ładowania modelu z Cloud Storage podczas uruchamiania kontenera. Więcej informacji znajdziesz w przewodniku ze sprawdzonymi metodami dotyczącymi procesorów graficznych.

2. Konfiguracja i wymagania

Ustaw zmienne środowiskowe, które będą używane w tym module:

# 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

Włączanie interfejsów API potrzebnych w tym ćwiczeniu z programowania

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. Utwórz konto usługi

Jeśli podczas tworzenia usługi lub zadania Cloud Run nie określisz konta usługi, Cloud Run użyje domyślnego konta usługi Compute Engine. Zalecamy używanie osobnego konta usługi dla usługi Cloud Run, aby uniknąć uruchamiania usługi z nadmiernymi uprawnieniami.

Tworzenie konta usługi dla usługi Cloud Run

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

4. Konfigurowanie Cloud Storage

Utwórz zasobnik Cloud Storage, w którym będą przechowywane wagi modelu. Dzięki temu będzie można używać bezpośredniego ruchu wychodzącego VPC do szybszego pobierania wag modelu za każdym razem, gdy Cloud Run uruchamia instancję usługi.

W połączeniu z funkcją Run:ai Model Streamer w vLLM znacznie skraca czas wczytywania modelu.

Utwórz zasobnik

Upewnij się, że jest to zasobnik w jednym regionie, który znajduje się w tym samym miejscu co usługa Cloud Run.

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

5. Pobieranie i buforowanie wag modelu

Następnie pobierz model Gemma 4 do zasobnika Cloud Storage.

Wagi modeli mają dziesiątki gigabajtów, więc pobranie ich na maszynę lokalną lub do Cloud Shell może być niemożliwe.

Zamiast tego używamy Cloud Build z wystarczającą ilością miejsca na przechowywanie wag modelu.

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. Konfigurowanie sieci na potrzeby bezpośredniego ruchu wychodzącego VPC

Konfiguracja bezpośredniego ruchu wychodzącego z sieci VPC wymaga utworzenia sieci i podsieci z włączonym prywatnym dostępem do Google.

Dzięki temu usługi Cloud Run mogą łączyć się z zestawem zewnętrznych adresów IP używanych przez interfejsy API Google i usługi, w tym Cloud Storage.

Tworzenie sieci

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

Tworzenie podsieci

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. Konfigurowanie zasad dostępu do konta usługi

Konto usługi Cloud Run musi mieć uprawnienia dostępu do wag modelu w utworzonym przez Ciebie zasobniku Storage.

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. Inicjowanie zmiennych konfiguracji

Zdefiniuj zmienne dla silnika wnioskowania vLLM i usługi Cloud Run.

# 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

Uwaga dotycząca dostrajania pod kątem wydajności: dostrajanie tych zmiennych to kompromis między przepustowością a opóźnieniem:

• MAX_NUM_SEQS w porównaniu z CLOUD_RUN_CONCURRENCY: wartość CLOUD_RUN_CONCURRENCY powinna być co najmniej tak duża jak MAX_NUM_SEQS. Aby uzyskać optymalne wykorzystanie w przypadku nagłych wzrostów ruchu, ustaw nieco wyższą wartość (np. 2x).
• Obciążenie pamięci: zarówno MAX_MODEL_LEN, jak i MAX_NUM_SEQS zużywają pamięć GPU na potrzeby pamięci podręcznej KV. Jeśli przy dużych długościach kontekstu występują błędy braku pamięci, rozważ zmniejszenie wartości MAX_NUM_SEQS.
• Opóźnienie: większa równoczesność (MAX_NUM_SEQS) zwiększa całkowitą przepustowość, ale może zwiększyć opóźnienie poszczególnych żądań.
• Skalowanie: CLOUD_RUN_MAX_INSTANCES umożliwia skalowanie w poziomie. Jeśli opóźnienie pojedynczej instancji jest akceptowalne, ale potrzebujesz większej łącznej pojemności, zwiększ tę wartość.

9. Wdrożenie w Cloud Run

Przygotowywanie wiersza poleceń kontenera vLLM

vLLM wymaga wielu parametrów, aby szybko i wydajnie uruchamiać duże modele.

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[*]}"

Wdrażanie usługi Cloud Run

Aby wdrożyć usługę Cloud Run, uruchom to polecenie.

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. Testowanie usługi

Po wdrożeniu możesz korzystać z modelu Gemma 4 za pomocą interfejsu vLLM zgodnego z OpenAI.

Pobieranie adresu URL usługi

Pobierz adres URL wdrożonej usługi Cloud Run.

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"

Uruchom wnioskowanie

Wyślij prompt do modelu za pomocą curl.

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. Gratulacje!

Gratulujemy ukończenia ćwiczenia!

Zalecamy zapoznanie się z dokumentacją Cloud Run.

Omówione zagadnienia

• Jak wdrożyć model Gemma 4 na GPU RTX 6000 Pro w Cloud Run
• Jak skonfigurować bezpośredni ruch wychodzący VPC i strumieniowanie modelu vLLM za pomocą Cloud Storage, aby przyspieszyć uruchamianie usługi.

12. Czyszczenie danych

Aby uniknąć obciążenia konta Google Cloud opłatami za zasoby zużyte w tym samouczku, możesz usunąć projekt lub poszczególne zasoby.

Opcja 1. Usuwanie zasobów

Usuwanie usługi Cloud Run

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

Usuwanie konta usługi

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

Usuwanie zasobnika Cloud Storage

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

Usuwanie sieci VPC i podsieci

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

Opcja 2. Usuwanie projektu

Aby usunąć cały projekt, otwórz stronę Zarządzaj zasobami, wybierz projekt utworzony w kroku 2 i kliknij Usuń. Jeśli usuniesz projekt, musisz zmienić projekty w Cloud SDK. Listę wszystkich dostępnych projektów możesz wyświetlić, uruchamiając polecenie gcloud projects list.