Entrega modelos de Llama con GPUs en GKE con vLLM

En este instructivo, se muestra cómo implementar y entregar el modelo de lenguaje grande (LLM) Llama 4 con GPUs en Google Kubernetes Engine (GKE) con el framework de entrega vLLM. Esto proporciona una base para comprender y explorar la implementación práctica de LLM para la inferencia en un entorno de Kubernetes administrado. Implementas en GKE un contenedor compilado previamente que ejecuta vLLM. También configurarás GKE para cargar Llama desde Hugging Face.

Sugerencia: Para las implementaciones de producción en GKE, recomendamos usar Inference Quickstart para obtener prácticas recomendadas y configuraciones personalizadas para la inferencia de tu modelo.

Este instructivo está dirigido a ingenieros de aprendizaje automático (AA), administradores y operadores de plataformas, y especialistas en datos y en IA que estén interesados en usar las capacidades de organización de contenedores de Kubernetes para entregar cargas de trabajo de IA/AA en hardware de GPU H200, H100, A100 y L4. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles de usuario y tareas comunes de GKE.

Si necesitas una plataforma de IA administrada unificada diseñada para compilar y entregar modelos de AA con rapidez de forma rentable, te recomendamos que pruebes nuestra solución de implementación de Vertex AI.

Antes de leer esta página, asegúrate de estar familiarizado con lo siguiente:

• Modo Autopilot y modo Standard
• Disponibilidad actual de la versión de GPU
• GPUs en GKE

Fondo

En esta sección, se describen las tecnologías clave que se usan en este instructivo.

Llama

Llama es un modelo de lenguaje grande de Meta diseñado para una variedad de tareas de procesamiento de lenguaje natural, como la generación de texto, la traducción y la respuesta de preguntas. GKE ofrece la infraestructura necesaria para admitir las necesidades de entrenamiento y entrega distribuidos de modelos de esta escala. Para obtener más información, consulta la documentación de Llama.

GPU

Las GPUs te permiten acelerar cargas de trabajo específicas que se ejecutan en tus nodos, como el aprendizaje automático y el procesamiento de datos. GKE proporciona una variedad de opciones de tipos de máquinas para la configuración de nodos, incluidos los tipos de máquinas con GPUs NVIDIA H200, H100, L4 y A100.

vLLM

vLLM es un framework de entrega de LLM de código abierto altamente optimizado que puede aumentar la capacidad de procesamiento de entrega en GPUs, con funciones como las siguientes:

• Implementación optimizada de transformadores con PagedAttention
• Agrupación en lotes continua para mejorar la capacidad de procesamiento general de la entrega
• Paralelismo de tensor y entrega distribuida en varias GPUs

Para obtener más información, consulta la documentación de vLLM.

Obtén acceso al modelo

Nota: Debes firmar el acuerdo de consentimiento para usar Llama en el repositorio de Hugging Face.

Para acceder al modelo a través de Hugging Face, necesitas un token de Hugging Face.

Sigue estos pasos para generar un token nuevo si aún no tienes uno:

1. Haz clic en Tu perfil > Configuración > Tokens de acceso.
2. Selecciona Token nuevo.
3. Especifica el nombre que desees y un rol de al menos Read.
4. Selecciona Genera un token.
5. Copia el token generado al portapapeles.

Prepara el entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados enGoogle Cloud. Cloud Shell tiene preinstalado el software que necesitas para este instructivo, incluidos kubectl y la CLI de gcloud.

Para configurar tu entorno con Cloud Shell, sigue estos pasos:

1. En la Google Cloud consola, haz clic en Activar Cloud Shell en la Google Cloud consola para iniciar una sesión de Cloud Shell. Esto inicia una sesión en el panel inferior de la consola de Google Cloud .

2. Configura las variables de entorno predeterminadas:

   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
   

   Reemplaza los siguientes valores:

   • PROJECT_ID: Tu Google Cloud ID del proyecto.
   • REGION: una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para la GPU L4.
   • CLUSTER_NAME: El nombre de tu clúster.
   • HF_TOKEN: El token de Hugging Face que generaste antes.

Crea y configura recursos de Google Cloud

Sigue estas instrucciones para crear los recursos necesarios.

Nota: Es posible que debas crear una reserva de capacidad para usar algunos aceleradores. Para obtener información sobre cómo reservar y consumir recursos reservados, consulta Consume recursos zonales reservados.

Crea un clúster de GKE y un grupo de nodos

Puedes entregar modelos de Llama 4 en GPUs en un clúster de GKE Autopilot o Standard. Te recomendamos que uses un clúster de Autopilot para una experiencia de Kubernetes completamente administrada. Para elegir el modo de operación de GKE que se adapte mejor a tus cargas de trabajo, consulta Elige un modo de operación de GKE.

Autopilot

En Cloud Shell, ejecute el siguiente comando:

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

Reemplaza los siguientes valores:

• PROJECT_ID: Tu Google Cloud ID del proyecto.
• CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Proporciona una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para la GPU L4.
• CLUSTER_NAME: El nombre de tu clúster.

GKE crea un clúster de Autopilot con nodos de CPU y GPU según lo solicitan las cargas de trabajo implementadas.

Estándar

1. En Cloud Shell, ejecuta el siguiente comando para crear un clúster estándar:

   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
   

   Reemplaza los siguientes valores:

   • PROJECT_ID: Tu Google Cloud ID del proyecto.
   • CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Proporciona una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para la GPU H100.
   • CLUSTER_NAME: El nombre de tu clúster.

   La creación del clúster puede tomar varios minutos.

2. Para crear un grupo de nodos para tu clúster con el tamaño de disco adecuado, ejecuta el siguiente 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 grupo de nodos único que contiene ocho GPUs H100 de 80 GB.

Crea un secreto de Kubernetes para las credenciales de Hugging Face

En Cloud Shell, haz lo siguiente:

1. Configura kubectl para que pueda comunicarse con tu clúster:

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

   Reemplaza los siguientes valores:

   • REGION: una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para la GPU L4.
   • CLUSTER_NAME: El nombre de tu clúster.

2. Crea un Secret de Kubernetes que contenga el token de Hugging Face:

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

   Reemplaza HF_TOKEN por el token de Hugging Face que generaste antes.

Implementa vLLM

En esta sección, implementarás el contenedor de vLLM para entregar los modelos de Llama 2 que deseas usar:

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

Nota: No recomendamos usar modelos básicos, como Llama 3 8B, para chatbots de producción debido a problemas de seguridad. Para obtener más información sobre las prácticas recomendadas, consulta Instrucciones del sistema para la seguridad.

Para implementar el modelo, en este instructivo, se usan implementaciones de Kubernetes. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de Pods que se distribuyen entre los nodos de un clúster.

Llama 4 Maverick 17B-128e

Para implementar el modelo Llama 4 Maverick 17B-128E, sigue estas instrucciones:

1. Crea el siguiente manifiesto 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. Aplica el manifiesto

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

   En nuestro ejemplo, limitamos la ventana de contexto a 128 K con la opción --max-model-len=131072 de vLLM.

Llama 4 Maverick 17B-128e-it

Para implementar el modelo ajustado por instrucciones Llama 4 Maverick 17B-128e, sigue estas instrucciones:

1. Crea el siguiente manifiesto 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. Aplica el manifiesto

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

   En nuestro ejemplo, limitamos la ventana de contexto a 128 K con la opción --max-model-len=131072 de vLLM.

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

Para implementar el modelo Llama 4 Maverick 17B-128e-Instruct-FP8, sigue estas instrucciones:

1. Crea el siguiente manifiesto 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. Aplica el manifiesto

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

   En nuestro ejemplo, limitamos la ventana de contexto a 512 K con la opción --max-model-len=524288 de vLLM.

Llama 4 Scout 17B-16e

Para implementar el modelo Llama 4 Scout 17B-16E, sigue estas instrucciones:

1. Crea el siguiente manifiesto 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. Aplica el manifiesto

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

   En nuestro ejemplo, limitamos la ventana de contexto a 256 K con la opción --max-model-len=262144 de vLLM.

Llama 4 Scout 17B-16e-it

Para implementar el modelo ajustado por instrucciones Llama 4 Scout 17B-16e Instruct, sigue estas instrucciones:

1. Crea el siguiente manifiesto 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. Aplica el manifiesto

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

   En nuestro ejemplo, limitamos la ventana de contexto a 1280 K con la opción --max-model-len=1310720 de vLLM.

Espera a que la implementación esté disponible:

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

Observa los registros de la implementación en ejecución:

kubectl logs -f -l app=llama-server

El recurso de implementación descarga los datos del modelo. Este proceso puede demorar unos minutos. El resultado es similar a este:

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

Asegúrate de que el modelo se haya descargado por completo antes de continuar con la siguiente sección.

Entrega el modelo

En esta sección, interactuarás con el modelo.

Configura la redirección de puertos

Para configurar la redirección de puertos al modelo, ejecuta el siguiente comando:

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

El resultado es similar a este:

Forwarding from 127.0.0.1:8080 -> 7080

Interactúa con el modelo con curl

En esta sección, se muestra cómo puedes realizar una prueba de humo básica para verificar el modelo de Llama ajustado por instrucciones que implementaste. Para otros modelos, reemplaza meta-llama/Llama-4-Scout-17B-16E por el nombre del modelo respectivo.

En este ejemplo, se muestra cómo probar el modelo Llama 4 Scout 17B-16E con entrada solo de texto.

En una sesión de terminal nueva, usa curl para chatear con tu 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
  }'

El resultado es similar a este:

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

Listo: Entregaste Llama correctamente con GPU en GKE con vLLM. Ahora puedes interactuar con el modelo.

Soluciona problemas

• Si recibes el mensaje Empty reply from server, es posible que el contenedor no haya terminado de descargar los datos del modelo. Vuelve a verificar los registros del Pod en busca del mensaje Connected, que indica que el modelo está listo para entregar.
• Si ves el mensaje Connection refused, verifica que tu redirección de puertos esté activa.

Observa el rendimiento del modelo

Para ver los paneles de las métricas de observabilidad de un modelo, sigue estos pasos:

1. En la consola de Google Cloud , ve a la página Modelos implementados.

   Ir a Modelos implementados

2. Para ver detalles sobre la implementación específica, incluidas sus métricas, registros y paneles, haz clic en el nombre del modelo en la lista.

3. En la página de detalles del modelo, haz clic en la pestaña Observabilidad para ver los siguientes paneles. Si se te solicita, haz clic en Habilitar para habilitar la recopilación de métricas para el clúster.

   • En el panel Uso de la infraestructura, se muestran las métricas de utilización.
   • En el panel DCGM, se muestran las métricas de DCGM.
   • Si usas vLLM, el panel Rendimiento del modelo está disponible y muestra métricas sobre el rendimiento del modelo de vLLM.

También puedes ver las métricas en la integración del panel de vLLM en Cloud Monitoring. Estas métricas se agregan para todas las implementaciones de vLLM sin filtros preestablecidos.

Para usar el panel en Cloud Monitoring, debes habilitar Google Cloud Managed Service para Prometheus, que recopila las métricas de vLLM, en tu clúster de GKE. vLLM expone las métricas en formato Prometheus de forma predeterminada. No es necesario que instales un exportador adicional. Si deseas obtener información para usar Google Cloud Managed Service para Prometheus y recopilar métricas de tu modelo, consulta la guía de observabilidad de vLLM en la documentación de Cloud Monitoring.