Gestisci modelli aperti Gemma utilizzando GPU su GKE con vLLM

Autopilot Standard

Per pubblicare modelli linguistici di grandi dimensioni (LLM) Gemma 4 su Google Kubernetes Engine (GKE) con il framework vLLM utilizzando le GPU, devi eseguire il provisioning di un cluster GKE con acceleratori supportati, come le GPU NVIDIA B200, H100, RTX Pro 6000 o L4.

Per ottenere i pesi del modello Gemma 4, puoi configurare il container vLLM predefinito in modo che li scarichi dal repository Hugging Face. In alternativa, il container può caricare i pesi del modello da uno spazio di archiviazione permanente esistente, ad esempio memorizzando nella cache i bucket del modello Cloud Storage in un'istanza Google Cloud Managed Lustre.

Una volta caricati i pesi, il contenitore vLLM espone un endpoint API compatibile con OpenAI per l'inferenza ad alto throughput.

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:

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questa guida.

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 di 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

Questo tutorial fornisce le basi per comprendere ed esplorare l'implementazione pratica di LLM per l'inferenza in un ambiente Kubernetes gestito.

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

Prima di iniziare

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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.

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.

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

Assicurati di disporre dei seguenti ruoli nel progetto: roles/container.admin, roles/iam.serviceAccountAdmin
Controlla i ruoli
1. Nella console Google Cloud vai alla pagina IAM.
  Vai a IAM
2. Seleziona il progetto.
3. Nella colonna Entità, trova tutte le righe che identificano te o un gruppo di cui fai parte. Per scoprire a quali gruppi appartieni, contatta il tuo amministratore.
4. Per tutte le righe che ti specificano o ti includono, controlla la colonna Ruolo per verificare se l'elenco dei ruoli include i ruoli richiesti.
Concedi i ruoli
1. Nella console Google Cloud vai alla pagina IAM.
  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. Fai clic su Seleziona un ruolo, quindi cerca il ruolo.
6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo successivo.
7. Fai clic su Salva.

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.

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:

Nella console Google Cloud , avvia una sessione di Cloud Shell facendo clic su Attiva Cloud Shell nella Google Cloud console. Viene avviata una sessione nel riquadro inferiore della console Google Cloud .
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 ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME
```
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. Puoi scoprire quali GPU sono disponibili in ogni regione.
- ZONE: una zona che supporta il tipo di acceleratore che vuoi utilizzare, ad esempio us-central1-b e us-central1-f per la GPU RTX PRO 6000. Puoi scoprire quali GPU sono disponibili in quale zona.
- CLUSTER_NAME: il nome del tuo cluster.

Creare e configurare risorse Google Cloud

Segui queste istruzioni per creare le risorse richieste.

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

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.

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

  gcloud container node-pools create gpupool \
      --accelerator type=nvidia-rtx-pro-6000,count=1,gpu-driver-version=latest \
      --project=PROJECT_ID \
      --location=REGION \
      --node-locations=ZONE \
      --cluster=CLUSTER_NAME \
      --machine-type=g4-standard-48 \
      --num-nodes=1

GKE crea un singolo pool di nodi contenente una RTX PRO. 6000 GPU per ogni nodo.

Esegui il deployment dei modelli Gemma 4 su vLLM utilizzando i pesi di Hugging Face

Per eseguire il deployment dei modelli Gemma 4 utilizzando i pesi di Hugging Face, applica un manifest di deployment Kubernetes per le dimensioni del modello selezionate. Un deployment è un oggetto API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.

Procedura

L'applicazione di questo manifest estrae l'immagine container vLLM, richiede una GPU NVIDIA e scarica automaticamente i pesi da Hugging Face per avviare il motore di inferenza vLLM.

Gemma 4 E2B-it

Segui queste istruzioni per eseguire il deployment del modello Gemma 4 E2B ottimizzato per le istruzioni (input solo di testo).

Crea il seguente manifest vllm-4-e2b-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-4-e2b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        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.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E2B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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

Applica il manifest:
```
kubectl apply -f vllm-4-e2b-it.yaml
```

Gemma 4 E4B-it

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

Crea il seguente manifest vllm-4-e4b-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-4-e4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E4b-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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

Applica il manifest:
```
kubectl apply -f vllm-4-E4b-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 4 26B-A4B-it

Segui queste istruzioni per eseguire il deployment del modello ottimizzato per le istruzioni Gemma 4 26B-A4B.

Crea il seguente manifest vllm-4-26b-a4b-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-4-26b-a4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-26B-A4B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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

Applica il manifest:
```
kubectl apply -f vllm-4-26b-a4b-it.yaml
```
Nel nostro esempio, limitiamo le dimensioni 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 4 31B-it

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

Crea il seguente manifest vllm-4-31b-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-4-31b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-31B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        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

Applica il manifest:
```
kubectl apply -f vllm-4-31b-it.yaml
```
Nel nostro esempio, limitiamo le dimensioni 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.000), modifica il manifest e la configurazione del pool di nodi con una maggiore capacità della GPU.

Verifica

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 Gemma. Questo processo può richiedere alcuni minuti. L'output è simile al seguente:

  ...
  ...
  (APIServer pid=1) INFO:     Started server process [1]
  (APIServer pid=1) INFO:     Waiting for application startup.
  (APIServer pid=1) INFO:     Application startup complete.

Una volta disponibile il deployment di Hugging Face, configura l'inoltro delle porte per interagire con il modello.

Esegui il deployment di Gemma ottimizzato da Managed Lustre

Per erogare un modello Gemma sottoposto a fine tuning (come Gemma 3 27B) già archiviato in un'istanza Google Cloud Managed Lustre, devi montare il PersistentVolumeClaim (PVC) corrispondente nel container vLLM.

Prerequisiti

Assicurati di avere un PVC esistente nel tuo cluster GKE che si connette alla tua istanza Lustre. In questo esempio, la PVC si chiama gemma-lustre-pvc.

Per scoprire come creare un PVC e un PersistentVolume (PV) per un'istanza esistente, consulta Accedere a un'istanza Managed Lustre esistente.

Procedura

Salva il seguente manifest YAML come vllm-lustre-gemma.yaml. In questo esempio, il deployment monta il PVC Lustre su /data e indica a vLLM di caricare i pesi del modello da questo percorso locale.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-lustre
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/data/gemma-3-27b
        - --tensor-parallel-size=1
        resources:
          limits:
            nvidia.com/gpu: "1"
        volumeMounts:
        - name: model-weights
          mountPath: /data
      volumes:
      - name: model-weights
        persistentVolumeClaim:
          claimName: gemma-lustre-pvc
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest

Applica il manifest al cluster GKE:

kubectl apply -f vllm-lustre-gemma.yaml

Verifica

Per verificare che il modello sia stato caricato correttamente dal volume Lustre, controlla i log del pod per la sequenza di avvio di vLLM:

kubectl logs -l app=gemma-server

Eroga il modello

In questa sezione, interagisci con il modello. Assicurati che il modello sia stato scaricato completamente prima di procedere.

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 base per verificare i modelli Gemma 4 ottimizzati per le istruzioni che hai implementato. Per gli altri modelli, sostituisci gemma-4-e4b-it con il nome del modello corrispondente.

Questo esempio mostra come testare il modello ottimizzato per l'istruzione Gemma 4 E4B con input solo di 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-4-26B-A4B-it",
    "messages": [
        {
          "role": "user",
          "content": "Why is the sky blue?"
        }
    ],
    "chat_template_kwargs": {
         "enable_thinking": true
    },
    "skip_special_tokens": false
}'

L'output è simile al seguente:

{
  "id": "chatcmpl-be75ccfcbdf753d1",
  "object": "chat.completion",
  "created": 1775006187,
  "model": "google/gemma-4-26B-A4B-it",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The short answer is a phenomenon called **Rayleigh scattering**.\n\nTo understand how it works, you have to look at three things: sunlight, the Earth's atmosphere, and how light travels.\n\n### 1. Sunlight is a Rainbow\nAlthough sunlight looks white to us, it is actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet). Light travels as **waves**, and each color has a different wavelength:\n*   **Red light** travels in long, lazy, wide waves.\n*   **Blue and violet light** travel in short, choppy, tight waves.\n\n### 2. The Atmosphere is an Obstacle Course\nEarth's atmosphere is filled with gases (mostly nitrogen and oxygen). As sunlight travels through the atmosphere, it strikes the molecules of these gases. \n\nBecause the gas molecules are very small, they affect the colors differently based on their wavelength:\n*   The **long waves** (reds and yellows) pass through the atmosphere mostly straight, without hitting much. They are like large ocean waves that roll right over small pebbles.\n*   The **short waves** (blues and violets) strike the gas molecules and get scattered in every direction. They are like small ripples that hit a pebble and splash everywhere.\n\nBecause this blue light is being scattered in every direction by the air, when you look up, your eyes are catching that scattered blue light coming from every part of the sky.\n\n### 3. Why isn't the sky violet?\nIf violet light has an even shorter wavelength than blue light, you might wonder why the sky doesn't look purple. There are two main reasons:\n1.  **The Sun's output:** The Sun emits much more blue light than violet light.\n2.  **Human Biology:** Human eyes are much more sensitive to blue than to violet. Our eyes interpret the scatter of mixed blue and violet light simply as pale blue.\n\n---\n\n### Bonus: Why are sunsets red?\nWhen the sun is setting, it is much lower on the horizon. This means the sunlight has to travel through a much **thicker** layer of the atmosphere to reach your eyes. \n\nBy the time the light gets to you, the blue light has been scattered away completely로. Only the long-wavelength colors—the reds, oranges, and pinks—are able to make it through that thick layer of air without being scattered away, creating the beautiful colors of a sunset.",
        "refusal": null,
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": [],
        "reasoning": "\"Why is the sky blue?\"\nScience/Physics (Atmospheric scattering).\nExplain the phenomenon clearly, accurately, and engagingly.\n\n    *   Sunlight (white light) is made of a spectrum of colors (ROYGBIV).\n    *   Earth's atmosphere is filled with gases (nitrogen, oxygen) and particles.\n    *   Rayleigh Scattering: Shorter wavelengths (blue/violet) scatter more easily than longer wavelengths (red/yellow) when hitting small gas molecules.\n    *   The human eye's sensitivity: Why isn't it violet?\n\n    A good scientific explanation should follow a logical flow:\n    *   *Direct Answer:* The core mechanism (Rayleigh Scattering).\n    *   *The Components:* Sunlight and the Atmosphere.\n    *   *The Mechanism:* How light interacts with gas molecules.\n    *   *The Wavelength Factor:* Comparing colors.\n    *   *The \"Wait, why not violet?\" question:* Addressing human perception.\n    *   *Bonus/Related concept:* Why sunsets are red.\n\n        *   Use the term **Rayleigh Scattering**.\n        *   Summarize: Its how sunlight interacts with the Earth's atmosphere.\n\n        *   Sunlight looks white, but it's actually a mix of all colors (the rainbow).\n        *   Each color travels as a different wavelength. Red = long/lazy waves; Blue/Violet = short/choppy waves.\n\n        *   The atmosphere is mostly Nitrogen and Oxygen.\n        *   When sunlight hits these tiny gas molecules, the light gets scattered in all directions.\n\n        *   Blue light travels in shorter, smaller waves.\n        *   Because these waves are small, they strike the gas molecules more frequently and get scattered more easily than the longer red/yellow waves.\n        *   Result: When you look up, your eyes are catching this \"scattered\" blue light coming from every direction.\n\n        *   *Technically*, violet light has an even shorter wavelength than blue, so it scatters *even more*. Why isn't the sky violet?\n        *   Two reasons: 1. The Sun emits more blue light than violet light. 2. Human eyes are much more sensitive to blue than violet.\n\n        *   Briefly mention sunsets to provide a complete picture.\n        *   At sunset, light travels through *more* atmosphere. The blue is scattered away completely, leaving only the long red/orange waves to reach your eyes.\n\n    *   *Tone Check:* Is it too academic? Use analogies (like waves in water or skipping stones) if needed, but keep it concise.\n    *   *Clarity:* Ensure the distinction between wavelength and scattering is clear."
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": 106,
      "token_ids": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 21,
    "total_tokens": 1122,
    "completion_tokens": 1101,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null,
  "prompt_token_ids": null,
  "kv_transfer_params": null
}

(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

In Cloud Shell, salva il seguente manifest come gradio.yaml. Modifica google/gemma-4-E4B-it con il nome del modello Gemma 4 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.7
        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-4-E4B-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

Applica il manifest:
```
kubectl apply -f gradio.yaml
```

Attendi che il deployment sia disponibile:

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

Utilizzare l'interfaccia di chat

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.
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.
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 l'erogazione.
Se visualizzi Connection refused, verifica che il port forwarding sia attivo.

Osserva le prestazioni del modello

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

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

Vai a Modelli di cui è stato eseguito il deployment
Per visualizzare i dettagli del deployment specifico, incluse metriche, log e dashboard, fai clic sul nome del modello nell'elenco.
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 LLM video 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, incluse 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.

Gestisci modelli aperti Gemma utilizzando GPU su GKE con vLLM Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Sfondo

GPU

vLLM

Obiettivi

Prima di iniziare

Controlla i ruoli

Concedi i ruoli

prepara l'ambiente

Creare e configurare risorse Google Cloud

Crea un cluster GKE e un pool di nodi

Autopilot

Standard

Esegui il deployment dei modelli Gemma 4 su vLLM utilizzando i pesi di Hugging Face

Procedura

Gemma 4 E2B-it

Gemma 4 E4B-it

Gemma 4 26B-A4B-it

Gemma 4 31B-it

Verifica

Esegui il deployment di Gemma ottimizzato da Managed Lustre

Prerequisiti

Procedura

Verifica

Eroga il modello

Configurare il port forwarding

Interagisci con il modello utilizzando curl

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

Implementare l'interfaccia di chat

Utilizzare l'interfaccia di chat

Risoluzione dei problemi

Osserva le prestazioni del modello

Esegui la pulizia

Elimina le risorse di cui è stato eseguito il deployment

Passaggi successivi

Gestisci modelli aperti Gemma utilizzando GPU su GKE con vLLM