Gestisci modelli aperti Gemma utilizzando GPU su GKE con vLLM

Autopilot Standard

Questo tutorial mostra come eseguire il deployment e pubblicare un modello linguistico di grandi dimensioni (LLM) Gemma 3 utilizzando le GPU su Google Kubernetes Engine (GKE) con il framework di pubblicazione vLLM. Questo fornisce una base per comprendere ed esplorare il deployment pratico di LLM per l'inferenza in un ambiente Kubernetes gestito. Esegui il deployment di un container predefinito che esegue vLLM in GKE. Configura anche GKE per caricare i pesi di Gemma 1B, 4B, 12B e 27B da Hugging Face.

Suggerimento: per i deployment di produzione su GKE, ti consigliamo vivamente di utilizzare Inference Quickstart per ottenere best practice e configurazioni personalizzate per l'inferenza del modello.

Questo tutorial è destinato a ingegneri di machine learning (ML), amministratori e operatori di piattaforme e specialisti di dati e AI interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per la gestione dei carichi di lavoro AI/ML su hardware GPU H200, H100, A100 e L4. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti, consulta Ruoli utente e attività comuni di GKE. Google Cloud

Se hai bisogno di una piattaforma di AI gestita unificata progettata per creare e pubblicare rapidamente modelli ML in modo economicamente vantaggioso, ti consigliamo di provare la nostra soluzione di deployment Vertex AI.

Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:

• Modalità Autopilot e Standard
• Disponibilità della versione attuale della GPU
• GPU in GKE

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questa guida.

Gemma

Gemma è un insieme di modelli multimodali di intelligenza artificiale (AI) generativa, leggeri e disponibili pubblicamente, rilasciati con una licenza aperta. Questi modelli di AI sono disponibili per l'esecuzione nelle tue applicazioni, hardware, dispositivi mobili o servizi ospitati. Gemma 3 introduce la multimodalità e supporta l'input di linguaggio visivo e gli output di testo. Gestisce finestre contestuali fino a 128.000 token e supporta oltre 140 lingue. Gemma 3 offre anche funzionalità migliorate per la matematica, il ragionamento e la chat, tra cui output strutturati e chiamate di funzioni.

Puoi utilizzare i modelli Gemma per la generazione di testo oppure puoi anche ottimizzarli per attività specializzate.

Per saperne di più, consulta la documentazione di Gemma.

GPU

Le GPU ti consentono di accelerare carichi di lavoro specifici in esecuzione sui tuoi nodi, come machine learning ed elaborazione di dati. GKE offre una gamma di opzioni di tipo di macchina per la configurazione dei nodi, inclusi i tipi di macchine con GPU NVIDIA H200, H100, L4 e A100.

vLLM

vLLM è un framework di erogazione degli LLM open source altamente ottimizzato che può aumentare la velocità effettiva di erogazione sulle GPU, con funzionalità come le seguenti:

• Implementazione ottimizzata di Transformer con PagedAttention
• Batch continuo per migliorare la velocità effettiva complessiva della pubblicazione
• Parallelismo dei tensori e pubblicazione distribuita su più GPU

Per saperne di più, consulta la documentazione di vLLM.

Obiettivi

1. Prepara l'ambiente con un cluster GKE in modalità Autopilot o Standard.
2. Esegui il deployment di un container vLLM nel cluster.
3. Utilizza vLLM per distribuire il modello Gemma 3 tramite curl e un'interfaccia di chat web.

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

• Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

  Check for the roles

  1. In the Google Cloud console, go to the IAM page.

     Go to IAM
  2. Select the project.

  3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

  4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

  Grant the roles

  1. In the Google Cloud console, go to the IAM page.

     Vai a IAM
  2. Seleziona il progetto.
  3. Fai clic su Concedi l'accesso.

  4. Nel campo Nuove entità, inserisci il tuo identificatore dell'utente. In genere si tratta dell'indirizzo email di un Account Google.

  5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
  6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo successivo.
  7. Fai clic su Salva.
  • Crea un account Hugging Face, se non ne hai già uno.
  • Assicurati che il tuo progetto disponga di una quota sufficiente per le GPU L4. Per saperne di più, consulta Informazioni sulle GPU e Quote di allocazione.

  Ottenere l'accesso al modello

  Nota: devi firmare il contratto di consenso per utilizzare Gemma nel repository Hugging Face .

  Per accedere al modello tramite Hugging Face, è necessario un token Hugging Face.

  Segui questi passaggi per generare un nuovo token se non ne hai già uno:

  1. Fai clic su Il tuo profilo > Impostazioni > Token di accesso.
  2. Seleziona Nuovo token.
  3. Specifica un nome a tua scelta e un ruolo di almeno Read.
  4. Seleziona Genera un token.
  5. Copia il token generato negli appunti.

  prepara l'ambiente

  In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell include il software necessario per questo tutorial, tra cui kubectl e gcloud CLI.

  Per configurare l'ambiente con Cloud Shell:

  1. Nella console Google Cloud , avvia una sessione di Cloud Shell facendo clic su Attiva Cloud Shell nella consoleGoogle Cloud . Viene avviata una sessione nel riquadro inferiore della console Google Cloud .

  2. Imposta le variabili di ambiente predefinite:

     gcloud config set project PROJECT_ID
     gcloud config set billing/quota_project PROJECT_ID
     export PROJECT_ID=$(gcloud config get project)
     export REGION=REGION
     export CLUSTER_NAME=CLUSTER_NAME
     export HF_TOKEN=HF_TOKEN
     

     Sostituisci i seguenti valori:

     • PROJECT_ID: il tuo Google Cloud ID progetto.
     • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
     • CLUSTER_NAME: il nome del tuo cluster.
     • HF_TOKEN: il token Hugging Face che hai generato in precedenza.

  Creare e configurare risorse Google Cloud

  Segui queste istruzioni per creare le risorse richieste.

  Nota: per utilizzare alcuni acceleratori, potrebbe essere necessario creare una prenotazione di capacità. Per scoprire come prenotare e utilizzare le risorse prenotate, consulta Utilizzo delle risorse di zona prenotate.

  Crea un cluster GKE e un pool di nodi

  Puoi gestire Gemma su GPU in un cluster GKE Autopilot o Standard. Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta ai tuoi workload, consulta Scegliere una modalità operativa GKE.

  Autopilot

  In Cloud Shell, esegui questo comando:

  gcloud container clusters create-auto CLUSTER_NAME \
      --project=PROJECT_ID \
      --location=CONTROL_PLANE_LOCATION \
      --release-channel=rapid
  

  Sostituisci i seguenti valori:

  • PROJECT_ID: il tuo Google Cloud ID progetto.
  • CONTROL_PLANE_LOCATION: la regione di Compute Engine del control plane del tuo cluster. Fornisci una regione che supporti il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
  • CLUSTER_NAME: il nome del tuo cluster.

  GKE crea un cluster Autopilot con nodi CPU e GPU come richiesto dai carichi di lavoro di cui è stato eseguito il deployment.

  Standard

  1. In Cloud Shell, esegui questo comando per creare un cluster Standard:

     gcloud container clusters create CLUSTER_NAME \
         --project=PROJECT_ID \
         --location=CONTROL_PLANE_LOCATION \
         --workload-pool=PROJECT_ID.svc.id.goog \
         --release-channel=rapid \
         --num-nodes=1
     

     Sostituisci i seguenti valori:

     • PROJECT_ID: il tuo Google Cloud ID progetto.
     • CONTROL_PLANE_LOCATION: la regione di Compute Engine del control plane del tuo cluster. Fornisci una regione che supporti il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
     • CLUSTER_NAME: il nome del tuo cluster.

     La creazione del cluster potrebbe richiedere diversi minuti.

  2. Per creare un node pool per il tuo cluster con le dimensioni del disco appropriate, esegui questo comando:

     Gemma 3 1B

     gcloud container node-pools create gpupool \
         --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
         --project=PROJECT_ID \
         --location=REGION \
         --node-locations=REGION-a \
         --cluster=CLUSTER_NAME \
         --machine-type=g2-standard-8 \
         --num-nodes=1
     

     GKE crea un singolo pool di nodi contenente una GPU L4 per ogni nodo.

     Gemma 3 4B

     gcloud container node-pools create gpupool \
         --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
         --project=PROJECT_ID \
         --location=REGION \
         --node-locations=REGION-a \
         --cluster=CLUSTER_NAME \
         --machine-type=g2-standard-8 \
         --num-nodes=1
     

     GKE crea un singolo pool di nodi contenente una GPU L4 per ogni nodo.

     Gemma 3 12B

     gcloud container node-pools create gpupool \
         --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \
         --project=PROJECT_ID \
         --location=REGION \
         --node-locations=REGION-a \
         --cluster=CLUSTER_NAME \
         --machine-type=g2-standard-48 \
         --num-nodes=1
     

     GKE crea un singolo pool di nodi contenente quattro GPU L4 per ogni nodo.

     Gemma 3 27B

     gcloud container node-pools create gpupool \
         --accelerator type=nvidia-a100-80gb,count=1,gpu-driver-version=latest \
         --project=PROJECT_ID \
         --location=REGION \
         --node-locations=REGION-a \
         --cluster=CLUSTER_NAME \
         --machine-type=a2-ultragpu-1g \
         --disk-type=pd-ssd \
         --num-nodes=1 \
         --disk-size=256
     

     GKE crea un singolo pool di nodi contenente una GPU A100 da 80 GB.

  Crea un secret Kubernetes per le credenziali di Hugging Face

  In Cloud Shell:

  1. Configura kubectl in modo che possa comunicare con il tuo cluster:

     gcloud container clusters get-credentials CLUSTER_NAME \
         --location=REGION
     

     Sostituisci i seguenti valori:

     • REGION: una regione che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1 per la GPU L4.
     • CLUSTER_NAME: il nome del tuo cluster.

  2. Crea un secret di Kubernetes che contenga il token Hugging Face:

     kubectl create secret generic hf-secret \
         --from-literal=hf_api_token=${HF_TOKEN} \
         --dry-run=client -o yaml | kubectl apply -f -
     

     Sostituisci HF_TOKEN con il token Hugging Face che hai generato in precedenza.

  Esegui il deployment di vLLM

  In questa sezione, esegui il deployment del container vLLM per pubblicare il modello Gemma che vuoi utilizzare. Per il deployment del modello, questo tutorial utilizza i deployment Kubernetes. Un deployment è un oggetto API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.

  Gemma 3 1B-it

  Segui queste istruzioni per eseguire il deployment del modello Gemma 3 1B ottimizzato per le istruzioni (input solo di testo).

  1. Crea il seguente manifest vllm-3-1b-it.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: vllm-gemma-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gemma-server
       template:
         metadata:
           labels:
             app: gemma-server
             ai.gke.io/model: gemma-3-1b-it
             ai.gke.io/inference-server: vllm
             examples.ai.gke.io/source: user-guide
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: "2"
                 memory: "10Gi"
                 ephemeral-storage: "10Gi"
                 nvidia.com/gpu: "1"
               limits:
                 cpu: "2"
                 memory: "10Gi"
                 ephemeral-storage: "10Gi"
                 nvidia.com/gpu: "1"
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --model=$(MODEL_ID)
             - --tensor-parallel-size=1
             - --host=0.0.0.0
             - --port=8000
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: google/gemma-3-1b-it
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-l4
             cloud.google.com/gke-gpu-driver-version: latest
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llm-service
     spec:
       selector:
         app: gemma-server
       type: ClusterIP
       ports:
         - protocol: TCP
           port: 8000
           targetPort: 8000

  2. Applica il manifest:

     kubectl apply -f vllm-3-1b-it.yaml
     

  Gemma 3 4B-it

  Segui queste istruzioni per eseguire il deployment del modello Gemma 3 4B ottimizzato per le istruzioni.

  1. Crea il seguente manifest vllm-3-4b-it.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: vllm-gemma-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gemma-server
       template:
         metadata:
           labels:
             app: gemma-server
             ai.gke.io/model: gemma-3-4b-it
             ai.gke.io/inference-server: vllm
             examples.ai.gke.io/source: user-guide
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: "2"
                 memory: "20Gi"
                 ephemeral-storage: "20Gi"
                 nvidia.com/gpu: "1"
               limits:
                 cpu: "2"
                 memory: "20Gi"
                 ephemeral-storage: "20Gi"
                 nvidia.com/gpu: "1"
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --model=$(MODEL_ID)
             - --tensor-parallel-size=1
             - --host=0.0.0.0
             - --port=8000
             - --max-model-len=32768
             - --max-num-seqs=4
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: google/gemma-3-4b-it
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-l4
             cloud.google.com/gke-gpu-driver-version: latest
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llm-service
     spec:
       selector:
         app: gemma-server
       type: ClusterIP
       ports:
         - protocol: TCP
           port: 8000
           targetPort: 8000

  2. Applica il manifest:

     kubectl apply -f vllm-3-4b-it.yaml
     

     Nel nostro esempio, limitiamo la finestra contestuale a 32 K utilizzando l'opzione vLLM --max-model-len=32768. Se vuoi una dimensione della finestra contestuale più grande (fino a 128 K), modifica il manifest e la configurazione del pool di nodi con una maggiore capacità della GPU.

  Gemma 3 12B-it

  Segui queste istruzioni per eseguire il deployment del modello Gemma 3 12B ottimizzato per le istruzioni.

  1. Crea il seguente manifest vllm-3-12b-it.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: vllm-gemma-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gemma-server
       template:
         metadata:
           labels:
             app: gemma-server
             ai.gke.io/model: gemma-3-12b-it
             ai.gke.io/inference-server: vllm
             examples.ai.gke.io/source: user-guide
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: "4"
                 memory: "32Gi"
                 ephemeral-storage: "32Gi"
                 nvidia.com/gpu: "2"
               limits:
                 cpu: "4"
                 memory: "32Gi"
                 ephemeral-storage: "32Gi"
                 nvidia.com/gpu: "2"
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --model=$(MODEL_ID)
             - --tensor-parallel-size=2
             - --host=0.0.0.0
             - --port=8000
             - --max-model-len=16384
             - --max-num-seqs=4
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: google/gemma-3-12b-it
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-l4
             cloud.google.com/gke-gpu-driver-version: latest
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llm-service
     spec:
       selector:
         app: gemma-server
       type: ClusterIP
       ports:
         - protocol: TCP
           port: 8000
           targetPort: 8000

  2. Applica il manifest:

     kubectl apply -f vllm-3-12b-it.yaml
     

     Nel nostro esempio, limitiamo la dimensione della finestra contestuale a 16 K utilizzando l'opzione vLLM --max-model-len=16384. Se vuoi una dimensione della finestra contestuale più grande (fino a 128 K), modifica la configurazione del manifest e del pool di nodi con una maggiore capacità della GPU.

  Gemma 3 27B-it

  Segui queste istruzioni per eseguire il deployment del modello Gemma 3 27B ottimizzato per le istruzioni.

  1. Crea il seguente manifest vllm-3-27b-it.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: vllm-gemma-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gemma-server
       template:
         metadata:
           labels:
             app: gemma-server
             ai.gke.io/model: gemma-3-27b-it
             ai.gke.io/inference-server: vllm
             examples.ai.gke.io/source: user-guide
         spec:
           containers:
           - name: inference-server
             image: docker.io/vllm/vllm-openai:v0.10.0
             resources:
               requests:
                 cpu: "10"
                 memory: "128Gi"
                 ephemeral-storage: "120Gi"
                 nvidia.com/gpu : "1"
               limits:
                 cpu: "10"
                 memory: "128Gi"
                 ephemeral-storage: "120Gi"
                 nvidia.com/gpu : "1"
             command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
             args:
             - --model=$(MODEL_ID)
             - --tensor-parallel-size=1
             - --host=0.0.0.0
             - --port=8000
             - --swap-space=16
             - --gpu-memory-utilization=0.95
             - --max-model-len=32768
             - --max-num-seqs=4
             env:
             - name: LD_LIBRARY_PATH
               value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
             - name: MODEL_ID
               value: google/gemma-3-27b-it
             - name: HUGGING_FACE_HUB_TOKEN
               valueFrom:
                 secretKeyRef:
                   name: hf-secret
                   key: hf_api_token
             volumeMounts:
             - mountPath: /dev/shm
               name: dshm
           volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-a100-80gb
             cloud.google.com/gke-gpu-driver-version: latest
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: llm-service
     spec:
       selector:
         app: gemma-server
       type: ClusterIP
       ports:
         - protocol: TCP
           port: 8000
           targetPort: 8000

  2. Applica il manifest:

     kubectl apply -f vllm-3-27b-it.yaml
     

     Nel nostro esempio, limitiamo le dimensioni della finestra contestuale a 32 K utilizzando l'opzione vLLM --max-model-len=32768. Se vuoi una dimensione della finestra contestuale più grande (fino a 128.000), modifica il manifest e la configurazione del pool di nodi con una maggiore capacità della GPU.

  Un pod nel cluster scarica i pesi del modello da Hugging Face e avvia il motore di pubblicazione.

  Attendi che il deployment sia disponibile:

  kubectl wait --for=condition=Available --timeout=1800s deployment/vllm-gemma-deployment
  

  Visualizza i log del deployment in esecuzione:

  kubectl logs -f -l app=gemma-server
  

  La risorsa Deployment scarica i dati del modello. Questo processo può richiedere alcuni minuti. L'output è simile al seguente:

  INFO:     Automatically detected platform cuda.
  ...
  INFO      [launcher.py:34] Route: /v1/chat/completions, Methods: POST
  ...
  INFO:     Started server process [13]
  INFO:     Waiting for application startup.
  INFO:     Application startup complete.
  Default STARTUP TCP probe succeeded after 1 attempt for container "vllm--google--gemma-3-4b-it-1" on port 8080.
  

  Assicurati che il modello sia stato scaricato completamente prima di procedere alla sezione successiva.

  Pubblica il modello

  In questa sezione, interagisci con il modello.

  Configurare il port forwarding

  Esegui questo comando per configurare il port forwarding al modello:

  kubectl port-forward service/llm-service 8000:8000
  

  L'output è simile al seguente:

  Forwarding from 127.0.0.1:8000 -> 8000
  

  Interagisci con il modello utilizzando curl

  Questa sezione mostra come eseguire un test di fumo di base per verificare i modelli Gemma 3 ottimizzati per le istruzioni di cui è stato eseguito il deployment. Per gli altri modelli, sostituisci gemma-3-4b-it con il nome del modello corrispondente.

  Questo esempio mostra come testare il modello Gemma 3 4B ottimizzato per le istruzioni con input di solo testo.

  In una nuova sessione del terminale, utilizza curl per chattare con il tuo modello:

  curl http://127.0.0.1:8000/v1/chat/completions \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
      "model": "google/gemma-3-4b-it",
      "messages": [
          {
            "role": "user",
            "content": "Why is the sky blue?"
          }
      ]
  }'
  

  L'output è simile al seguente:

  {
      "id": "chatcmpl-e4a2e624bea849d9b09f838a571c4d9e",
      "object": "chat.completion",
      "created": 1741763029,
      "model": "google/gemma-3-4b-it",
      "choices": [
          {
              "index": 0,
              "message": {
                  "role": "assistant",
                  "reasoning_content": null,
                  "content": "Okay, let's break down why the sky appears blue! It's a fascinating phenomenon rooted in physics, specifically something called **Rayleigh scattering**. Here's the explanation: ...",
                  "tool_calls": []
              },
              "logprobs": null,
              "finish_reason": "stop",
              "stop_reason": 106
          }
      ],
      "usage": {
          "prompt_tokens": 15,
          "total_tokens": 668,
          "completion_tokens": 653,
          "prompt_tokens_details": null
      },
      "prompt_logprobs": null
  }
  

  Operazione riuscita: hai gestito Gemma utilizzando le GPU su GKE con vLLM. Ora puoi interagire con il modello.

  (Facoltativo) Interagisci con il modello tramite un'interfaccia di chat Gradio

  In questa sezione, creerai un'applicazione di chat web che ti consente di interagire con il modello ottimizzato per le istruzioni. Per semplicità, questa sezione descrive solo l'approccio di test utilizzando il modello 4B-it.

  Gradio è una libreria Python che ha un wrapper ChatInterface che crea interfacce utente per chatbot.

  Implementare l'interfaccia di chat

  1. In Cloud Shell, salva il seguente manifest come gradio.yaml. Modifica google/gemma-2-9b-it in google/gemma-3-4b-it o in un altro nome del modello Gemma 3 che hai utilizzato nel deployment.

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: gradio
       labels:
         app: gradio
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gradio
       template:
         metadata:
           labels:
             app: gradio
         spec:
           containers:
           - name: gradio
             image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.4
             resources:
               requests:
                 cpu: "250m"
                 memory: "512Mi"
               limits:
                 cpu: "500m"
                 memory: "512Mi"
             env:
             - name: CONTEXT_PATH
               value: "/v1/chat/completions"
             - name: HOST
               value: "http://llm-service:8000"
             - name: LLM_ENGINE
               value: "openai-chat"
             - name: MODEL_ID
               value: "google/gemma-2-9b-it"
             - name: DISABLE_SYSTEM_MESSAGE
               value: "true"
             ports:
             - containerPort: 7860
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: gradio
     spec:
       selector:
         app: gradio
       ports:
       - protocol: TCP
         port: 8080
         targetPort: 7860
       type: ClusterIP
     

  2. Applica il manifest:

     kubectl apply -f gradio.yaml
     

  3. Attendi che il deployment sia disponibile:

     kubectl wait --for=condition=Available --timeout=900s deployment/gradio
     

  Utilizzare l'interfaccia di chat

  1. In Cloud Shell, esegui questo comando:

     kubectl port-forward service/gradio 8080:8080
     

     In questo modo viene creato un port forwarding da Cloud Shell al servizio Gradio.

  2. Fai clic sul pulsante Anteprima web, che si trova in alto a destra nella barra delle app di Cloud Shell. Fai clic su Anteprima sulla porta 8080. Nel browser si apre una nuova scheda.

  3. Interagisci con Gemma utilizzando l'interfaccia di chat di Gradio. Aggiungi un prompt e fai clic su Invia.

  Risoluzione dei problemi

  • Se visualizzi il messaggio Empty reply from server, è possibile che il container non abbia completato il download dei dati del modello. Controlla di nuovo i log del pod per il messaggio Connected che indica che il modello è pronto per la pubblicazione.
  • Se visualizzi Connection refused, verifica che l'inoltro delle porte sia attivo.

  Osserva le prestazioni del modello

  Per visualizzare le dashboard per le metriche di osservabilità di un modello, segui questi passaggi:

  1. Nella console Google Cloud , vai alla pagina Modelli di cui è stato eseguito il deployment.

     Vai a Modelli di cui è stato eseguito il deployment

  2. Per visualizzare i dettagli del deployment specifico, incluse metriche, log e dashboard, fai clic sul nome del modello nell'elenco.

  3. Nella pagina dei dettagli del modello, fai clic sulla scheda Osservabilità per visualizzare le seguenti dashboard. Se richiesto, fai clic su Abilita per abilitare la raccolta delle metriche per il cluster.

     • La dashboard Utilizzo dell'infrastruttura mostra le metriche di utilizzo.
     • La dashboard DCGM mostra le metriche DCGM.
     • Se utilizzi vLLM, la dashboard Prestazioni del modello è disponibile e mostra le metriche per le prestazioni del modello vLLM.

  Puoi anche visualizzare le metriche nell'integrazione della dashboard vLLM in Cloud Monitoring. Queste metriche vengono aggregate per tutti i deployment di vLLM senza filtri preimpostati

  Per utilizzare la dashboard in Cloud Monitoring, devi abilitare Google Cloud Managed Service per Prometheus, che raccoglie le metriche da vLLM, nel tuo cluster GKE. vLLM espone le metriche nel formato Prometheus per impostazione predefinita; non è necessario installare un esportatore aggiuntivo. Per informazioni sull'utilizzo di Google Cloud Managed Service per Prometheus per raccogliere le metriche del modello, consulta le indicazioni sull'osservabilità di vLLM nella documentazione di Cloud Monitoring.

  Esegui la pulizia

  Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

  Elimina le risorse di cui è stato eseguito il deployment

  Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse che hai creato in questa guida, esegui questo comando:

  gcloud container clusters delete CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION
  

  Sostituisci i seguenti valori:

  • CONTROL_PLANE_LOCATION: la regione di Compute Engine del control plane del tuo cluster.
  • CLUSTER_NAME: il nome del tuo cluster.

  Passaggi successivi

  • Scopri di più sulle GPU in GKE.
  • Scopri come utilizzare Gemma con vLLM su altri acceleratori, tra cui le GPU A100 e H100, visualizzando il codice campione in GitHub.
  • Scopri come eseguire il deployment dei carichi di lavoro GPU in Autopilot.
  • Scopri come eseguire il deployment dei carichi di lavoro GPU in Standard.
  • Esplora il repository GitHub e la documentazione di vLLM.
  • Esplora Vertex AI Model Garden.
  • Scopri come eseguire workload di AI/ML ottimizzati con le funzionalità di orchestrazione della piattaforma GKE.