Gestisci modelli Llama utilizzando le GPU su GKE con vLLM

Questo tutorial mostra come eseguire il deployment e l'erogazione del modello linguistico di grandi dimensioni (LLM) Llama 4 utilizzando le GPU su Google Kubernetes Engine (GKE) con il framework di gestione 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 su GKE. Configuri anche GKE per caricare Llama da Hugging Face.

Suggerimento: per le implementazioni 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 di 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 corrente della GPU
• GPU in GKE

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questa guida.

Llama

Llama è un modello linguistico di grandi dimensioni di Meta progettato per una gamma di attività di elaborazione del linguaggio naturale, tra cui generazione di testi, traduzione e risposta a domande. GKE offre l'infrastruttura necessaria per supportare le esigenze di addestramento e serving distribuiti di modelli di questa scala. Per saperne di più, consulta la documentazione di Llama.

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
• Batching 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.

Ottenere l'accesso al modello

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

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 i modelli Llama 4 sulle 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 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 H100.
   • CLUSTER_NAME: il nome del tuo cluster.

   La creazione del cluster potrebbe richiedere diversi minuti.

2. 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-h100-80gb,count=1,gpu-driver-version=latest \
       --project=PROJECT_ID \
       --location=REGION \
       --node-locations=REGION-a \
       --cluster=CLUSTER_NAME \
       --machine-type=a3-highgpu-8g \
       --disk-type=pd-ssd \
       --num-nodes=1 \
       --disk-size=256
   

   GKE crea un singolo pool di nodi contenente otto GPU H100 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 i modelli Llama 4 che vuoi utilizzare:

• Llama 4 Maverick 17B-128E
• Llama 4 Scout 17B-16E

Nota: non consigliamo di utilizzare modelli di base come Llama 3 8B per i chatbot di produzione per motivi di sicurezza. Per saperne di più sulle best practice, consulta le istruzioni di sistema per la sicurezza.

Per eseguire 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.

Llama 4 Maverick 17B-128e

Per eseguire il deployment del modello Llama 4 Maverick 17B-128E, segui queste istruzioni:

1. Crea il seguente manifest vllm-llama4-maverick-17b-128e.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llama-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llama-server
     template:
       metadata:
         labels:
           app: llama-server
           ai.gke.io/model: Llama-4-Maverick-17B-128E
           ai.gke.io/inference-server: vllm
       spec:
         containers:
         - name: inference-server
           image: docker.io/vllm/vllm-openai:v0.10.0
           resources:
             requests:
               cpu: 157
               memory: 2067Gi
               ephemeral-storage: 850Gi
               nvidia.com/gpu : 8
             limits:
               cpu: 157
               memory: 2067Gi
               ephemeral-storage: 850Gi
               nvidia.com/gpu : 8
           command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
           args:
           - --host=0.0.0.0
           - --port=7080
           - --swap-space=16
           - --max-model-len=131072
           - --gpu-memory-utilization=0.95
           - --disable-log-stats
           - --dtype=auto
           - --kv-cache-dtype=auto
           - --max-num-seqs=64
           - --model=meta-llama/Llama-4-Maverick-17B-128E
           - --tensor-parallel-size=8
           env:
           - name: LD_LIBRARY_PATH
             value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
           - name: MODEL_ID
             value: 'meta-llama/Llama-4-Maverick-17B-128E'
           - 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-h200-141gb
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llama-service
   spec:
     selector:
       app: llama-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 7080
   ---
   apiVersion: v1
   kind: Secret
   metadata:
     name: hf-secret
   type: Opaque
   stringData:
     hf_api_token: {{HF_TOKEN}}

2. Applica il manifest:

   kubectl apply -f vllm-llama4-maverick-17b-128e.yaml
   

   Nel nostro esempio, limitiamo la finestra contestuale a 128 K utilizzando l'opzione --max-model-len=131072 vLLM.

Llama 4 Maverick 17B-128e-it

Per eseguire il deployment del modello ottimizzato per le istruzioni Llama 4 Maverick 17B-128e, segui queste istruzioni:

1. Crea il seguente manifest vllm-llama4-maverick-17b-128e-instruct.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llama-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llama-server
     template:
       metadata:
         labels:
           app: llama-server
           ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct
           ai.gke.io/inference-server: vllm
       spec:
         containers:
         - name: inference-server
           image: docker.io/vllm/vllm-openai:v0.10.0
           resources:
             requests:
               cpu: 157
               memory: 2067Gi
               ephemeral-storage: 850Gi
               nvidia.com/gpu : 8
             limits:
               cpu: 157
               memory: 2067Gi
               ephemeral-storage: 850Gi
               nvidia.com/gpu : 8
           command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
           args:
           - --host=0.0.0.0
           - --port=7080
           - --swap-space=16
           - --max-model-len=131072
           - --gpu-memory-utilization=0.95
           - --disable-log-stats
           - --dtype=auto
           - --kv-cache-dtype=auto
           - --max-num-seqs=64
           - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct
           - --tensor-parallel-size=8
           env:
           - name: LD_LIBRARY_PATH
             value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
           - name: MODEL_ID
             value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct'
           - 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-h200-141gb
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llama-service
   spec:
     selector:
       app: llama-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 7080
   ---
   apiVersion: v1
   kind: Secret
   metadata:
     name: hf-secret
   type: Opaque
   stringData:
     hf_api_token: {{HF_TOKEN}}

2. Applica il manifest:

   kubectl apply -f vllm-llama4-maverick-17b-128e-instruct.yaml
   

   Nel nostro esempio, limitiamo la finestra contestuale a 128 K utilizzando l'opzione --max-model-len=131072 vLLM.

Llama 4 Maverick 17B-128e-it-fp8

Per eseguire il deployment del modello Llama 4 Maverick 17B-128e-Instruct-FP8, segui queste istruzioni:

1. Crea il seguente manifest vllm-llama4-maverick-17b-128e-instruct-fp8.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llama-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llama-server
     template:
       metadata:
         labels:
           app: llama-server
           ai.gke.io/model: Llama-4-Maverick-17B-128E-Instruct-FP8
           ai.gke.io/inference-server: vllm
       spec:
         containers:
         - name: inference-server
           image: docker.io/vllm/vllm-openai:v0.10.0
           resources:
             requests:
               cpu: 146
               memory: 1311Gi
               ephemeral-storage: 600Gi
               nvidia.com/gpu : 8
             limits:
               cpu: 146
               memory: 1311Gi
               ephemeral-storage: 600Gi
               nvidia.com/gpu : 8
           command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
           args:
           - --host=0.0.0.0
           - --port=7080
           - --swap-space=16
           - --max-model-len=524288
           - --gpu-memory-utilization=0.90
           - --disable-log-stats
           - --model=meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8
           - --tensor-parallel-size=8
           env:
           - name: LD_LIBRARY_PATH
             value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
           - name: MODEL_ID
             value: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8'
           - 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-h100-80gb
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llama-service
   spec:
     selector:
       app: llama-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 7080
   ---
   apiVersion: v1
   kind: Secret
   metadata:
     name: hf-secret
   type: Opaque
   stringData:
     hf_api_token: {{HF_TOKEN}}

2. Applica il manifest:

   kubectl apply -f vllm-llama4-maverick-17b-128e-instruct-fp8.yaml
   

   Nel nostro esempio, limitiamo la finestra contestuale a 512 K utilizzando l'opzione --max-model-len=524288 vLLM.

Llama 4 Scout 17B-16e

Per eseguire il deployment del modello Llama 4 Scout 17B-16E, segui queste istruzioni:

1. Crea il seguente manifest vllm-llama4-scout-17b-16e.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llama-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llama-server
     template:
       metadata:
         labels:
           app: llama-server
           ai.gke.io/model: Llama-4-Scout-17B-16E
           ai.gke.io/inference-server: vllm
       spec:
         containers:
         - name: inference-server
           image: docker.io/vllm/vllm-openai:v0.10.0
           resources:
             requests:
               cpu: 146
               memory: 1311Gi
               ephemeral-storage: 600Gi
               nvidia.com/gpu : 8
             limits:
               cpu: 146
               memory: 1311Gi
               ephemeral-storage: 600Gi
               nvidia.com/gpu : 8
           command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
           args:
           - --host=0.0.0.0
           - --port=7080
           - --swap-space=16
           - --max-model-len=262144
           - --limit_mm_per_prompt
           - '{"image": 5}'
           - --disable-log-stats
           - --model=meta-llama/Llama-4-Scout-17B-16E
           - --tensor-parallel-size=8
           env:
           - name: LD_LIBRARY_PATH
             value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64        
           - name: MODEL_ID
             value: 'meta-llama/Llama-4-Scout-17B-16E'
           - 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-h100-80gb
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llama-service
   spec:
     selector:
       app: llama-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 7080
   ---
   apiVersion: v1
   kind: Secret
   metadata:
     name: hf-secret
   type: Opaque
   stringData:
     hf_api_token: {{HF_TOKEN}}

2. Applica il manifest:

   kubectl apply -f vllm-llama4-scout-17b-16e.yaml
   

   Nel nostro esempio, limitiamo la finestra contestuale a 256 K utilizzando l'opzione --max-model-len=262144 vLLM.

Llama 4 Scout 17B-16e-it

Per eseguire il deployment del modello ottimizzato per le istruzioni Llama 4 Scout 17B-16e Instruct, segui queste istruzioni:

1. Crea il seguente manifest vllm-llama4-scout-17b-16e-instruct.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llama-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llama-server
     template:
       metadata:
         labels:
           app: llama-server
           ai.gke.io/model: Llama-4-Scout-17B-16E-Instruct
           ai.gke.io/inference-server: vllm
       spec:
         containers:
         - name: inference-server
           image: docker.io/vllm/vllm-openai:v0.10.0
           resources:
             requests:
               cpu: 146
               memory: 1311Gi
               ephemeral-storage: 600Gi
               nvidia.com/gpu : 8
             limits:
               cpu: 146
               memory: 1311Gi
               ephemeral-storage: 600Gi
               nvidia.com/gpu : 8
           command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
           args:
           - --host=0.0.0.0
           - --port=7080
           - --swap-space=16
           - --max-model-len=1310720
           - --limit_mm_per_prompt
           - '{"image": 5}'
           - --disable-log-stats
           - --model=meta-llama/Llama-4-Scout-17B-16E-Instruct
           - --tensor-parallel-size=8
           env:
           - name: LD_LIBRARY_PATH
             value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
           - name: MODEL_ID
             value: 'meta-llama/Llama-4-Scout-17B-16E-Instruct'
           - 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-h100-80gb
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llama-service
   spec:
     selector:
       app: llama-server
     type: ClusterIP
     ports:
     - protocol: TCP
       port: 8000
       targetPort: 7080
   ---
   apiVersion: v1
   kind: Secret
   metadata:
     name: hf-secret
   type: Opaque
   stringData:
     hf_api_token: {{HF_TOKEN}}

2. Applica il manifest:

   kubectl apply -f vllm-llama4-scout-17b-16e-instruct.yaml
   

   Nel nostro esempio, limitiamo la finestra contestuale a 1280 K utilizzando l'opzione --max-model-len=1310720 vLLM.

Attendi che il deployment sia disponibile:

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

Visualizza i log del deployment in esecuzione:

kubectl logs -f -l app=llama-server

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

INFO:     Started server process [145]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
...
INFO 04-07 13:36:29 [async_llm.py:228] Added request chatcmpl-4149ea4cf35e48559f9f819dcdbbb23e.
INFO:     127.0.0.1:44018 - "POST /v1/chat/completions HTTP/1.1" 200 OK

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

Per configurare il port forwarding al modello, esegui questo comando:

kubectl port-forward service/llama-service 8080:8000

L'output è simile al seguente:

Forwarding from 127.0.0.1:8080 -> 7080

Interagisci con il modello utilizzando curl

Questa sezione mostra come eseguire un test di fumo di base per verificare il modello Llama ottimizzato per le istruzioni di cui è stato eseguito il deployment. Per gli altri modelli, sostituisci meta-llama/Llama-4-Scout-17B-16E con il nome del modello corrispondente.

Questo esempio mostra come testare il modello Llama 4 Scout 17B-16E con input solo testuale.

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

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-4-Scout-17B-16E",
    "messages": [{"role": "user", "content": "San Francisco is a"}],
    "max_tokens": 7,
    "temperature": 0
  }'

L'output è simile al seguente:

"message":{"role":"assistant","reasoning_content":null,"content":"San Francisco is a city","tool_calls":[]}

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

Risoluzione dei problemi

• Se visualizzi il messaggio Empty reply from server, il contenitore potrebbe non aver terminato 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 il messaggio Connection refused, verifica che l'inoltro delle porte sia attivo.

Osserva le prestazioni del modello

Per visualizzare i 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, tra cui 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 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.