Publique modelos Llama com GPUs no GKE com o vLLM

Este tutorial mostra como implementar e publicar o modelo de linguagem (conteúdo extenso) (MDI/CE) Llama 4 usando GPUs no Google Kubernetes Engine (GKE) com a framework de publicação vLLM. Isto fornece uma base para compreender e explorar a implementação prática de MDIs/CEs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado que executa o vLLM no GKE. Também configura o GKE para carregar o Llama do Hugging Face.

Sugestão: para implementações de produção no GKE, recomendamos vivamente que use o Inference Quickstart para receber práticas recomendadas personalizadas e configurações para a inferência do seu modelo.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, e especialistas em dados e IA que tenham interesse em usar capacidades de orquestração de contentores do Kubernetes para publicar cargas de trabalho de IA/AA em hardware de GPU H200, H100, A100 e L4. Para saber mais acerca das funções comuns e das tarefas de exemplo que referimos no Google Cloud conteúdo, consulte Funções e tarefas comuns do utilizador do GKE.

Se precisar de uma plataforma de IA gerida unificada concebida para criar e apresentar rapidamente modelos de ML de forma económica, recomendamos que experimente a nossa solução de implementação do Vertex AI.

Antes de ler esta página, certifique-se de que conhece o seguinte:

• Modo automático e modo padrão
• Disponibilidade da versão atual da GPU
• GPUs no GKE

Contexto

Esta secção descreve as principais tecnologias usadas neste guia.

Llama

O Llama é um modelo de linguagem (conteúdo extenso) da Meta concebido para uma variedade de tarefas de processamento de linguagem natural, incluindo geração de texto, tradução e resposta a perguntas. O GKE oferece a infraestrutura necessária para suportar as necessidades de preparação e publicação distribuídas de modelos desta escala. Para mais informações, consulte a documentação do Llama.

GPUs

As GPUs permitem-lhe acelerar cargas de trabalho específicas executadas nos seus nós, como a aprendizagem automática e o processamento de dados. O GKE oferece uma variedade de opções de tipos de máquinas para a configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H200, H100, L4 e A100.

vLLM

O vLLM é uma framework de publicação de LLMs de código aberto altamente otimizada que pode aumentar a taxa de transferência de publicação em GPUs, com funcionalidades como as seguintes:

• Implementação do transformador otimizada com PagedAttention
• Processamento em lote contínuo para melhorar o débito geral da publicação
• Paralelismo de tensores e publicação distribuída em várias GPUs

Para mais informações, consulte a documentação do vLLM.

Aceda ao modelo

Nota: tem de assinar o contrato de consentimento para usar o Llama no repositório do Hugging Face.

Para aceder ao modelo através do Hugging Face, precisa de um token do Hugging Face.

Siga estes passos para gerar um novo token se ainda não tiver um:

1. Clique em O seu perfil > Definições > Tokens de acesso.
2. Selecione Novo token.
3. Especifique um nome à sua escolha e uma função de, pelo menos, Read.
4. Selecione Gerar um token.
5. Copie o token gerado para a área de transferência.

Prepare o seu ambiente

Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Google Cloud. O Cloud Shell é pré-instalado com o software necessário para este tutorial, incluindo kubectl e CLI gcloud.

Para configurar o seu ambiente com o Cloud Shell, siga estes passos:

1. Na Google Cloud consola, inicie uma sessão do Cloud Shell clicando em Ativar Cloud Shell na Google Cloud consola. Esta ação inicia uma sessão no painel inferior da consola. Google Cloud

2. Defina as variáveis de ambiente predefinidas:

   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
   

   Substitua os seguintes valores:

   • PROJECT_ID: o seu Google Cloud ID do projeto.
   • REGION: uma região que suporta o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
   • CLUSTER_NAME: o nome do cluster.
   • HF_TOKEN: o token do Hugging Face que gerou anteriormente.

Crie e configure Google Cloud recursos

Siga estas instruções para criar os recursos necessários.

Nota: pode ter de criar uma reserva de capacidade para usar alguns aceleradores. Para saber como reservar e consumir recursos reservados, consulte o artigo Consumir recursos zonais reservados.

Crie um cluster e um node pool do GKE

Pode publicar modelos Llama 4 em GPUs num cluster padrão ou do GKE Autopilot. Recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.

Piloto automático

No Cloud Shell, execute o seguinte comando:

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

Substitua os seguintes valores:

• PROJECT_ID: o seu Google Cloud ID do projeto.
• CONTROL_PLANE_LOCATION: a região do Compute Engine do painel de controlo do seu cluster. Indique uma região que suporte o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
• CLUSTER_NAME: o nome do cluster.

O GKE cria um cluster do Autopilot com nós de CPU e GPU, conforme solicitado pelas cargas de trabalho implementadas.

Standard

1. No Cloud Shell, execute o seguinte comando para criar um 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
   

   Substitua os seguintes valores:

   • PROJECT_ID: o seu Google Cloud ID do projeto.
   • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Indique uma região que suporte o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU H100.
   • CLUSTER_NAME: o nome do cluster.

   A criação do cluster pode demorar vários minutos.

2. Para criar um conjunto de nós para o seu cluster com o tamanho do disco adequado, execute o seguinte 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
   

   O GKE cria um único node pool que contém oito GPUs H100 de 80 GB.

Crie um segredo do Kubernetes para as credenciais do Hugging Face

No Cloud Shell, faça o seguinte:

1. Configure o kubectl para que possa comunicar com o seu cluster:

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

   Substitua os seguintes valores:

   • REGION: uma região que suporta o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
   • CLUSTER_NAME: o nome do cluster.

2. Crie um segredo do Kubernetes que contenha o token do Hugging Face:

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

   Substitua HF_TOKEN pelo token do Hugging Face que gerou anteriormente.

Implemente o vLLM

Nesta secção, implementa o contentor vLLM para publicar os modelos Llama 4 que quer usar:

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

Nota: não recomendamos a utilização de modelos base, como o Llama 3 8B, para chatbots de produção devido a preocupações de segurança. Para mais informações sobre as práticas recomendadas, consulte o artigo Instruções do sistema para segurança.

Para implementar o modelo, este tutorial usa implementações do Kubernetes. Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídas entre os nós num cluster.

Llama 4 Maverick 17B-128e

Para implementar o modelo Llama 4 Maverick 17B-128E, siga estas instruções:

1. Crie o seguinte manifesto 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. Aplique o manifesto:

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

   No nosso exemplo, limitamos a capacidade de resposta a 128 mil tokens usando a opção --max-model-len=131072vLLM.

Llama 4 Maverick 17B-128e-it

Para implementar o modelo otimizado com instruções Llama 4 Maverick 17B-128e, siga estas instruções:

1. Crie o seguinte manifesto 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. Aplique o manifesto:

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

   No nosso exemplo, limitamos a capacidade de resposta a 128 mil tokens usando a opção --max-model-len=131072vLLM.

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

Para implementar o modelo Llama 4 Maverick 17B-128e-Instruct-FP8, siga estas instruções:

1. Crie o seguinte manifesto 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. Aplique o manifesto:

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

   No nosso exemplo, limitamos a capacidade de resposta em 512 K usando a opção --max-model-len=524288vLLM.

Llama 4 Scout 17B-16e

Para implementar o modelo Llama 4 Scout 17B-16E, siga estas instruções:

1. Crie o seguinte manifesto 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. Aplique o manifesto:

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

   No nosso exemplo, limitamos a capacidade de resposta em 256 mil tokens usando a opção --max-model-len=262144vLLM.

Llama 4 Scout 17B-16e-it

Para implementar o modelo otimizado para instruções Llama 4 Scout 17B-16e Instruct, siga estas instruções:

1. Crie o seguinte manifesto 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. Aplique o manifesto:

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

   No nosso exemplo, limitamos a capacidade de resposta em 1280 K usando a opção --max-model-len=1310720vLLM.

Aguarde até que a implementação esteja disponível:

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

Veja os registos da implementação em execução:

kubectl logs -f -l app=llama-server

O recurso de implementação transfere os dados do modelo. Este processo pode demorar alguns minutos. O resultado é semelhante ao seguinte:

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

Certifique-se de que o modelo é totalmente transferido antes de avançar para a secção seguinte.

Publique o modelo

Nesta secção, interage com o modelo.

Configure o encaminhamento de portas

Para configurar o encaminhamento de portas para o modelo, execute o seguinte comando:

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

O resultado é semelhante ao seguinte:

Forwarding from 127.0.0.1:8080 -> 7080

Interaja com o modelo através do curl

Esta secção mostra como pode realizar um teste rápido básico para validar o modelo Llama ajustado com instruções implementado. Para outros modelos, substitua meta-llama/Llama-4-Scout-17B-16E pelo nome do modelo respetivo.

Este exemplo mostra como testar o modelo Llama 4 Scout 17B-16E com entrada apenas de texto.

Numa nova sessão de terminal, use curl para conversar com o seu modelo:

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
  }'

O resultado é semelhante ao seguinte:

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

Êxito: publicou o Llama com GPUs no GKE com o vLLM. Agora, pode interagir com o modelo.

Resolver problemas

• Se receber a mensagem Empty reply from server, o contentor pode não ter terminado de transferir os dados do modelo. Verifique novamente os registos do Pod para ver a mensagem Connected, que indica que o modelo está pronto para publicação.
• Se vir a mensagem Connection refused, verifique se o encaminhamento de portas está ativo.

Observe o desempenho do modelo

Para ver os painéis de controlo das métricas de observabilidade de um modelo, siga estes passos:

1. Na Google Cloud consola, aceda à página Modelos implementados.

   Aceda a Modelos implementados

2. Para ver detalhes sobre a implementação específica, incluindo as respetivas métricas, registos e painéis de controlo, clique no nome do modelo na lista.

3. Na página de detalhes do modelo, clique no separador Observabilidade para ver os seguintes painéis de controlo. Se lhe for pedido, clique em Ativar para ativar a recolha de métricas para o cluster.

   • O painel de controlo Utilização da infraestrutura apresenta métricas de utilização.
   • O painel de controlo do DCGM apresenta métricas do DCGM.
   • Se estiver a usar o vLLM, o painel de controlo Desempenho do modelo está disponível e apresenta métricas para o desempenho do modelo vLLM.

Também pode ver métricas na integração do painel de controlo do vLLM no Cloud Monitoring. Estas métricas são agregadas para todas as implementações de vLLM sem filtros predefinidos

Para usar o painel de controlo no Cloud Monitoring, tem de ativar o Google Cloud Managed Service for Prometheus, que recolhe as métricas do vLLM, no seu cluster do GKE. Por predefinição, o vLLM expõe métricas no formato Prometheus; não precisa de instalar um exportador adicional. Para obter informações sobre a utilização do serviço gerido do Google Cloud para Prometheus para recolher métricas do seu modelo, consulte as orientações de observabilidade da vLLM na documentação do Cloud Monitoring.