Gestisci modelli Llama utilizzando GPU su GKE con vLLM

Questo tutorial mostra come eseguire il deployment e il servizio di un modello linguistico di grandi dimensioni (LLM) Llama 4 utilizzando 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 Llama da Hugging Face.

Questo tutorial è rivolto a ingegneri del machine learning (ML), amministratori e operatori della piattaforma e a specialisti di dati e IA interessati a utilizzare le funzionalità di orchestrazione dei container Kubernetes per l'erogazione di carichi di lavoro di AI/ML su hardware GPU H200, H100, A100 e L4. Per scoprire di più su ruoli comuni e attività di esempio a cui facciamo riferimento nei contenuti, consulta Ruoli e attività comuni degli utenti di GKE Enterprise. Google Cloud

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

Prima di leggere questa pagina, assicurati di conoscere quanto segue:

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questa guida.

Llama

Llama è un modello linguistico di grandi dimensioni di Meta progettato per una serie di attività di elaborazione del linguaggio naturale, tra cui generazione di testo, traduzione e risposta a domande. GKE offre l'infrastruttura necessaria per supportare le esigenze di addestramento e pubblicazione distribuiti dei modelli di questa scala. Per ulteriori informazioni, consulta la documentazione di Llama.

GPU

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

vLLM

vLLM è un framework di pubblicazione di modelli LLM open source altamente ottimizzato che può aumentare il throughput di pubblicazione sulle GPU, con funzionalità come le seguenti:

  • Implementazione ottimizzata del transformer con PagedAttention
  • Raggruppamento continuo per migliorare il throughput complessivo della pubblicazione
  • Parallelismo di tensori e pubblicazione distribuita su più GPU

Per ulteriori informazioni, 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 contenitore vLLM nel tuo cluster.
  3. Utilizza vLLM per pubblicare i modelli Llama 4 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.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

    •

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

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

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

    4. Nel campo Nuovi principali, inserisci il tuo identificatore 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 aggiuntivo.
    7. Fai clic su Salva.

Ottieni l'accesso al modello

Per accedere al modello tramite Hugging Face, devi disporre di un token Hugging Face.

Se non ne hai già uno, segui questi passaggi per generare un nuovo token:

  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 di cui hai bisogno per questo tutorial, tra cui kubectl e gcloud CLI.

Per configurare l'ambiente con Cloud Shell:

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

  2. Imposta le variabili di ambiente predefinite:

    gcloud config set 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.

Crea e configura le risorse Google Cloud

Segui queste istruzioni per creare le risorse necessarie.

Crea un cluster e un pool di nodi GKE

Puoi pubblicare modelli Llama 4 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 di GKE più adatta ai tuoi carichi di lavoro, consulta Scegliere una modalità operativa GKE.

Autopilot

In Cloud Shell, esegui questo comando:

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --region=REGION \
    --release-channel=rapid

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.

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 il comando seguente per creare un cluster standard:

    gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --region=REGION \
    --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.
    • REGION: una regione che supporta 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 pool di nodi per il cluster con la dimensione del disco appropriata, esegui il seguente 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 contenente il token di 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 contenitore vLLM per pubblicare i modelli Llama 4 che vuoi utilizzare:

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

Per eseguire il deployment del modello, questo tutorial utilizza i deployment Kubernetes. Un deployment è un oggetto dell'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: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        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
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --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: 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 di contesto 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: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        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
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --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: 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 di contesto 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: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        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
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --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: 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 di contesto 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: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        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
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --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: 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 di contesto a 256.000 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:

  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: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
        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
        args:
        - python3
        - -m
        - vllm.entrypoints.api_server
        - --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: 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 di contesto 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. Questa operazione 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 il seguente comando:

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

L'output è simile al seguente:

Forwarding from 127.0.0.1:8080 -> 7080

Interagire con il modello utilizzando curl

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

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

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":[]}

Risoluzione dei problemi

  • Se ricevi il messaggio Empty reply from server, il contenitore potrebbe non aver completato il download dei dati del modello. Controlla di nuovo i log del pod per verificare la presenza del messaggio Connected, che indica che il modello è pronto per essere pubblicato.
  • Se visualizzi il messaggio Connection refused, verifica che l'inoltro delle porte sia attivo.

Osserva le prestazioni del modello

Per osservare le prestazioni del modello, puoi utilizzare l'integrazione della dashboard vLLM in Cloud Monitoring. Con questa dashboard puoi visualizzare metriche sul rendimento critiche come throughput dei token, latenza delle richieste e tassi di errore.

Per utilizzare la dashboard di vLLM, devi attivare Google Cloud Managed Service per Prometheus, che raccoglie le metriche da vLLM, nel tuo cluster GKE. Per impostazione predefinita, vLLM espone le metriche in formato Prometheus. Non è necessario installare un'esportatrice aggiuntiva.

Puoi quindi visualizzare le metriche utilizzando la dashboard vLLM. Per informazioni sull'utilizzo di Google Cloud Managed Service per Prometheus per raccogliere le metriche dal 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 il seguente comando:

gcloud container clusters delete CLUSTER_NAME \
    --region=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.

Passaggi successivi