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 Cloud Run RTX 6000 Pro.
• Jak używać vLLM i Run:ai Model Streamer do szybszego wnioskowania i krótszego uruchamiania instancji.

Gemma 4 to rodzina modeli o otwartych wagach na licencji Apache 2 od Google DeepMind. Modele są multimodalne, wielojęzyczne, oferują rozumowanie i wydajną architekturę. Cloud Run to bezserwerowe środowisko dla kontenerów z obsługą GPU.

Uwaga: w tym ćwiczeniu używamy modelu Gemma 4 31B Instruction-Tuned. Ćwiczenie pokazuje, jak używać Run:ai Model Streamer i bezpośredniego ruchu wychodzącego VPC, aby zminimalizować czas wczytywania modelu z Cloud Storage podczas uruchamiania kontenera. Więcej informacji znajdziesz w przewodniku po sprawdzonych metodach korzystania z GPU.

2. Konfiguracja i wymagania

Całe ćwiczenie można wykonać w wierszu poleceń. Aby uruchomić środowisko, możesz użyć Cloud Shell (kliknij ikonę prompta w prawym górnym rogu konsoli).

Oto zmienne środowiskowe, których będziemy używać w tym ćwiczeniu. Możesz je zapisać w pliku środowiska i „źródle”. Upewnij się, że prawidłowo ustawisz wartość identyfikatora projektu i opcjonalnie regionu.

# 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

Włączanie interfejsów API potrzebnych do tego ćwiczenia

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 utworzenie 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. Umożliwi to korzystanie z 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, a pobieranie 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 wagi 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

Pamiętaj, że używa to dość dużej maszyny wirtualnej. Zamiast tego możesz też uruchomić maszynę wirtualną za pomocą E2_HIGHCPU_8 lub nawet całkowicie usunąć wiersz machineType. Kompilacja prawdopodobnie potrwa dłużej, ale pozwoli też na uruchomienie w ramach niższych ograniczeń limitu.

6. Konfigurowanie sieci na potrzeby bezpośredniego ruchu wychodzącego VPC

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

Umożliwia to usługom Cloud Run łączenie się z zestawem zewnętrznych adresów IP używanych przez interfejsy API Google i usługi, w tym Cloud Storage.

Utwórz sieć

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

Utwórz podsieć

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 zasobniku.

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 zarówno dla silnika wnioskowania vLLM, jak 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 vs CLOUD_RUN_CONCURRENCY: 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 ją nieco wyżej (np. 2 razy).
• Obciążenie pamięci: MAX_MODEL_LEN i MAX_NUM_SEQS zużywają pamięć GPU na potrzeby pamięci podręcznej KV. Jeśli występują błędy braku pamięci (OOM) przy dużych długościach kontekstu, rozważ zmniejszenie MAX_NUM_SEQS.
• Opóźnienie: większa współbieżność (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. Te parametry zostaną przekazane jako argumenty do kontenera wdrożonego w Cloud Run.

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[*]}"
echo "Deployment string: ${CONTAINER_ARGS_STR}"

Wdrażanie usługi Cloud Run

Aby wdrożyć usługę Cloud Run, uruchom to polecenie. Zwróć uwagę na typ GPU (RTX 6000 Pro), obraz podstawowy (pytorch-vllm-serve:gemma4) oraz konieczność uwierzytelnienia, aby wywołać usługę (--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}"

Wdrożenie potrwa kilka minut. Po zakończeniu będziesz mieć środowisko z obsługą GPU, które będzie udostępniać Gemma 4 przy użyciu bezserwerowej infrastruktury z autoskalowaniem, w tym skalowaniem do zera (brak ruchu, brak kosztów).

10. Testowanie usługi

Po wdrożeniu możesz korzystać z modelu Gemma 4 za pomocą interfejsu API 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"

Uruchamianie wnioskowania

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 Cloud Run RTX 6000 Pro.
• Jak skonfigurować bezpośredni ruch wychodzący VPC i przesyłanie strumieniowe modelu vLLM za pomocą Cloud Storage, aby przyspieszyć uruchamianie usługi.

12. Zwalnianie miejsca

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 Zarządzanie 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. Jeśli chcesz pozostać w wierszu poleceń, możesz też użyć tego polecenia:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}