RTX 6000 Pro GPU और vLLM की मदद से, Cloud Run पर Gemma 4 मॉडल का अनुमान लगाएं

1. परिचय

ध्यान दें: इस सुविधा पर, "Pre-GA के तहत आने वाले प्रॉडक्ट और सुविधाओं से जुड़ी शर्तें" लागू होती हैं. ये शर्तें, सेवा की खास शर्तें पेज पर 'सेवा की सामान्य शर्तें' सेक्शन में दी गई हैं. Pre-GA के तहत आने वाली सुविधाएं, "जैसी हैं वैसी" ही उपलब्ध कराई जाती हैं. ऐसा हो सकता है कि इनके लिए आपको सीमित सहायता ही मिले. ज़्यादा जानकारी के लिए, लॉन्च के चरणों की जानकारी देखें

खास जानकारी

आपको क्या सीखने को मिलेगा

Cloud Run के RTX 6000 Pro जीपीयू पर, Gemma 4 मॉडल को डिप्लॉय करने का तरीका
तेज़ी से इन्फ़रेंस और कम समय में इंस्टेंस शुरू करने के लिए, vLLM और Run:ai Model Streamer का इस्तेमाल करने का तरीका.

Gemma 4, Google DeepMind के Apache 2 लाइसेंस वाले ओपन वेट मॉडल का एक परिवार है. ये मॉडल मल्टीमॉडल और कई भाषाओं में काम करते हैं. साथ ही, इनमें तर्क करने और बेहतर आर्किटेक्चर की सुविधा मिलती है. Cloud Run, कंटेनर के लिए एक सर्वरलेस एनवायरमेंट है. इसमें जीपीयू के लिए सहायता उपलब्ध है.

2. सेटअप और ज़रूरी शर्तें

इस कोडलैब में, इन एनवायरमेंट वैरिएबल का इस्तेमाल किया जाएगा. इन्हें एनवायरमेंट फ़ाइल में सेव किया जा सकता है और "सोर्स" किया जा सकता है. पक्का करें कि आपने अपने प्रोजेक्ट आईडी की वैल्यू सही तरीके से सेट की हो. साथ ही, ज़रूरत पड़ने पर इलाके की वैल्यू भी सेट करें.

# 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

इस कोडलैब के लिए ज़रूरी एपीआई चालू करें

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. सेवा खाता बनाएं

अगर Cloud Run सेवा या जॉब बनाते समय, सेवा खाता नहीं बताया जाता है, तो Cloud Run, Compute Engine के डिफ़ॉल्ट सेवा खाते का इस्तेमाल करता है. Cloud Run सेवा के लिए, अलग सेवा खाता इस्तेमाल करने का सुझाव दिया जाता है. इससे, सेवा को ज़्यादा अनुमतियों के साथ चलाने से बचा जा सकता है.

Cloud Run सेवा के लिए सेवा खाता बनाना

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

4. Cloud Storage सेट अप करना

मॉडल के वेट स्टोर करने के लिए, Cloud Storage बकेट बनाएं. इससे, Cloud Run के हर बार सेवा इंस्टेंस शुरू करने पर, मॉडल के वेट को तेज़ी से डाउनलोड करने के लिए, Direct VPC Egress का इस्तेमाल किया जा सकेगा.

vLLM में Run:ai Model Streamer सुविधा के साथ इसका इस्तेमाल करने पर, मॉडल लोड होने में लगने वाला समय काफ़ी कम हो जाता है.

बकेट बनाना

पक्का करें कि यह एक ही इलाके की बकेट हो और 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. मॉडल के वेट वापस पाना और उन्हें कैश मेमोरी में सेव करना

इसके बाद, Gemma 4 मॉडल को अपनी Cloud Storage बकेट में डाउनलोड करें.

मॉडल के वेट कई जीबी के होते हैं. इन्हें अपने लोकल मशीन या Cloud Shell में डाउनलोड करना मुमकिन नहीं हो सकता.

इसके बजाय, हम Cloud Build का इस्तेमाल करते हैं. इसमें मॉडल के वेट को सेव करने के लिए, ज़रूरत के हिसाब से स्टोरेज होता है.

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. Direct VPC Egress के लिए नेटवर्किंग कॉन्फ़िगर करना

Direct VPC Egress को कॉन्फ़िगर करने के लिए, Private Google Access की सुविधा चालू करके नेटवर्क और सबनेट बनाना ज़रूरी है.

इससे, Cloud Run की सेवाएं, Google के एपीआई और सेवाओं के लिए इस्तेमाल किए जाने वाले बाहरी आईपी पतों के सेट से कनेक्ट हो सकती हैं. इनमें Cloud Storage भी शामिल है.

नेटवर्क बनाना

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

सबनेट बनाना

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. सेवा खाते के ऐक्सेस की नीति कॉन्फ़िगर करना

Cloud Run सेवा खाते को, आपके बनाए गए स्टोरेज बकेट में मौजूद मॉडल के वेट को ऐक्सेस करने की अनुमतियां चाहिए.

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. कॉन्फ़िगरेशन वैरिएबल शुरू करना

vLLM इन्फ़रेंस इंजन और 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

परफ़ॉर्मेंस के लिए ट्यूनिंग के बारे में ध्यान दें: इन वैरिएबल को ट्यून करने से थ्रूपुट और इंतज़ार के समय के बीच बैलेंस बनता है:

MAX_NUM_SEQS बनाम CLOUD_RUN_CONCURRENCY: CLOUD_RUN_CONCURRENCY की वैल्यू, कम से कम MAX_NUM_SEQS जितनी होनी चाहिए. ट्रैफ़िक बढ़ने पर बेहतर इस्तेमाल के लिए, इसे थोड़ी ज़्यादा वैल्यू पर सेट करें. जैसे, 2x.
मेमोरी प्रेशर: MAX_MODEL_LEN और MAX_NUM_SEQS, दोनों के लिए केवी कैश के लिए जीपीयू मेमोरी का इस्तेमाल किया जाता है. अगर आपको बड़े कॉन्टेक्स्ट की लंबाई के साथ, मेमोरी से बाहर होने (ओओएम) से जुड़ी गड़बड़ियां मिलती हैं, तो MAX_NUM_SEQS की वैल्यू कम करने पर विचार करें.
इंतज़ार का समय: ज़्यादा कंकरेंसी (MAX_NUM_SEQS) से कुल थ्रूपुट बढ़ता है, लेकिन इससे हर अनुरोध के इंतज़ार का समय बढ़ सकता है.
स्केलिंग: CLOUD_RUN_MAX_INSTANCES की मदद से, हॉरिज़ॉन्टली स्केल किया जा सकता है. अगर सिंगल-इंस्टेंस का इंतज़ार का समय ठीक है, लेकिन आपको ज़्यादा कुल क्षमता चाहिए, तो इस वैल्यू को बढ़ाएं.

9. Cloud Run पर डिप्लॉय करें

vLLM कंटेनर की कमांड लाइन तैयार करना

बड़े मॉडल को तेज़ी से और बेहतर तरीके से चलाने के लिए, vLLM को कई पैरामीटर की ज़रूरत होती है. इन पैरामीटर को, 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}"

Cloud Run सेवा डिप्लॉय करना

Cloud Run सेवा डिप्लॉय करने के लिए, यह कमांड चलाएं. जीपीयू का टाइप (RTX 6000 Pro), बेस इमेज (pytorch-vllm-serve:gemma4), और सेवा को शुरू करने के लिए पुष्टि की ज़रूरत (--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}"

इसे डिप्लॉय होने में कुछ मिनट लगेंगे. इसके बाद, आपके पास जीपीयू से चलने वाला एक एनवायरमेंट होगा. इसमें Gemma 4 को सर्वरलेस इन्फ़्रास्ट्रक्चर का इस्तेमाल करके चलाया जा सकेगा. इसमें ऑटोस्केलिंग की सुविधा भी होगी. साथ ही, इसे ज़ीरो पर स्केल किया जा सकेगा. इसका मतलब है कि अगर कोई ट्रैफ़िक नहीं है, तो कोई शुल्क नहीं लगेगा.

10. सेवा की जांच करना

डिप्लॉय होने के बाद, vLLM के OpenAI-कम्पैटिबल एपीआई का इस्तेमाल करके, अपने Gemma 4 मॉडल से इंटरैक्ट किया जा सकता है.

सेवा का यूआरएल पाना

डिप्लॉय की गई 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"

इन्फ़रेंस चलाना

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. बधाई हो!

कोडलैब पूरा करने के लिए बधाई!

हमारा सुझाव है कि Cloud Run का दस्तावेज़ पढ़ें.

हमने क्या-क्या कवर किया है

Cloud Run के RTX 6000 Pro जीपीयू पर, Gemma 4 मॉडल को डिप्लॉय करने का तरीका
सेवा को तेज़ी से शुरू करने के लिए, Cloud Storage के साथ Direct VPC Egress और vLLM मॉडल स्ट्रीमिंग को कॉन्फ़िगर करने का तरीका.

12. व्यवस्थित करें

इस ट्यूटोरियल में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते से शुल्क लिए जाने से बचने के लिए, प्रोजेक्ट मिटाया जा सकता है या अलग-अलग संसाधन मिटाए जा सकते हैं.

पहला विकल्प: संसाधन मिटाना

Cloud Run सेवा मिटाना

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

सेवा खाता मिटाना

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

Cloud Storage बकेट मिटाना

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

वीपीसी नेटवर्क और सबनेट मिटाना

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

दूसरा विकल्प: प्रोजेक्ट मिटाना

पूरा प्रोजेक्ट मिटाने के लिए, संसाधन मैनेज करें पर जाएं. इसके बाद, चरण 2 में बनाया गया प्रोजेक्ट चुनें और मिटाएं को चुनें. प्रोजेक्ट मिटाने पर, आपको अपने Cloud SDK में प्रोजेक्ट बदलने होंगे. gcloud projects list चलाकर, सभी उपलब्ध प्रोजेक्ट की सूची देखी जा सकती है. अगर आपको कमांड लाइन का इस्तेमाल करना है, तो यह कमांड भी इस्तेमाल किया जा सकता है:

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}