Esta página se ha traducido con Cloud Translation API.

Servir modelos Llama mediante GPUs en GKE con vLLM

Autopilot Standard

En este tutorial se muestra cómo desplegar y servir el modelo de lenguaje extenso (LLM) Llama 4 con GPUs en Google Kubernetes Engine (GKE) mediante el framework de servicio vLLM. Esto proporciona una base para comprender y explorar la implementación práctica de LLMs para la inferencia en un entorno de Kubernetes gestionado. Despliega en GKE un contenedor prediseñado que ejecuta vLLM. También debes configurar GKE para que cargue Llama desde Hugging Face.

Este tutorial está dirigido a ingenieros de aprendizaje automático, administradores y operadores de plataformas, y especialistas en datos e IA que estén interesados en usar las funciones de orquestación de contenedores de Kubernetes para servir cargas de trabajo de IA y aprendizaje automático en hardware de GPU H200, H100, A100 y L4. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el contenido, consulta Roles y tareas habituales de los usuarios de GKE. Google Cloud

Si necesitas una plataforma de IA gestionada y unificada diseñada para crear y ofrecer modelos de aprendizaje automático rápidamente y de forma rentable, te recomendamos que pruebes nuestra solución de despliegue Vertex AI.

Antes de leer esta página, asegúrese de que conoce los siguientes conceptos:

Fondo

En esta sección se describen las tecnologías clave que se usan en esta guía.

Llama

Llama es un modelo de lenguaje extenso de Meta diseñado para llevar a cabo diversas tareas de procesamiento del lenguaje natural, como la generación de texto, la traducción y la respuesta a preguntas. GKE ofrece la infraestructura necesaria para satisfacer las necesidades de entrenamiento y servicio distribuidos de modelos de esta escala. Para obtener más información, consulta la documentación de Llama.

GPUs

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 ofrece una amplia gama 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 servicio de LLMs de código abierto muy optimizado que puede aumentar el rendimiento del servicio en GPUs. Incluye funciones como las siguientes:

Implementación optimizada de Transformer con PagedAttention
Agrupación continua para mejorar el rendimiento general del servicio
Paralelismo de tensores y servicio distribuido en varias GPUs

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

Objetivos

Prepara tu entorno con un clúster de GKE en modo Autopilot o Estándar.
Despliega un contenedor vLLM en tu clúster.
Usa vLLM para servir modelos de Llama 4 a través de curl y una interfaz de chat web.

Antes de empezar

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.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

Check for the roles

In the Google Cloud console, go to the IAM page.
Go to IAM
Select the project.
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.
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

In the Google Cloud console, go to the IAM page.
Ir a IAM
Selecciona el proyecto.
Haz clic en Conceder acceso.
En el campo Nuevos principales, introduce tu identificador de usuario. Normalmente, se trata de la dirección de correo de una cuenta de Google.
En la lista Selecciona un rol, elige un rol.
Para conceder más roles, haz clic en Añadir otro rol y añade cada rol adicional.
Haz clic en Guardar.

Crea una cuenta de Hugging Face si aún no tienes una.
Asegúrate de que tu proyecto tenga suficiente cuota para GPUs H100 y H200. Para obtener más información, consulta Planificar la cuota de GPU y Cuota de GPU.

Acceder al modelo

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

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

Haz clic en Tu perfil > Configuración > Tokens de acceso.
Selecciona New Token (Nuevo token).
Especifica el nombre que quieras y un rol de al menos Read.
Selecciona Generar un token.
Copia el token generado en el portapapeles.

Prepara tu entorno

En este tutorial, usarás Cloud Shell para gestionar los recursos alojados enGoogle Cloud. Cloud Shell tiene preinstalado el software que necesitas para este tutorial, como kubectl y la CLI de gcloud.

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

En la Google Cloud consola, inicia una sesión de Cloud Shell haciendo clic en Activar Cloud Shell en la Google Cloud consola. Se iniciará una sesión en el panel inferior de la consola Google Cloud .
Define 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
```
Sustituye los siguientes valores:
- PROJECT_ID: tu Google Cloud ID de proyecto.
- REGION: una región que admita el tipo de acelerador que quieras 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 has generado antes.

Crear y configurar Google Cloud recursos

Sigue estas instrucciones para crear los recursos necesarios.

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

Puedes servir modelos Llama 4 en GPUs de un clúster Autopilot o Standard de GKE. Te recomendamos que uses un clúster de Autopilot para disfrutar de una experiencia de Kubernetes totalmente gestionada. Para elegir el modo de funcionamiento de GKE que mejor se adapte a tus cargas de trabajo, consulta Elegir un modo de funcionamiento de GKE.

Autopilot

En Cloud Shell, ejecuta el siguiente comando:

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

Sustituye los siguientes valores:

PROJECT_ID: tu Google Cloud ID de 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 quieras 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 soliciten las cargas de trabajo desplegadas.

Estándar

En Cloud Shell, ejecuta el siguiente comando para crear un clúster 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
```
Sustituye los siguientes valores:
- PROJECT_ID: tu Google Cloud ID de 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 quieras usar. Por ejemplo, us-central1 para la GPU H100.
- CLUSTER_NAME: el nombre de tu clúster.
La creación del clúster puede tardar varios minutos.

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 único grupo de nodos que contiene ocho GPUs H100 de 80 GB.

Crear un secreto de Kubernetes para las credenciales de Hugging Face

En Cloud Shell, haz lo siguiente:

Configura kubectl para que pueda comunicarse con tu clúster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=REGION
```
Sustituye los siguientes valores:
- REGION: una región que admita el tipo de acelerador que quieras usar. Por ejemplo, us-central1 para la GPU L4.
- CLUSTER_NAME: el nombre de tu clúster.

Crea un secreto 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 -

Sustituye HF_TOKEN por el token de Hugging Face que has generado anteriormente.

Desplegar vLLM

En esta sección, desplegarás el contenedor vLLM para publicar los modelos de Llama 4 que quieras usar:

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

Para desplegar el modelo, en este tutorial se usan los desplegues de Kubernetes. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de pods distribuidas entre los nodos de un clúster.

Llama 4 Maverick 17B-128e

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

Crea el siguiente archivo de 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}}

Aplica el archivo de manifiesto:
```
kubectl apply -f vllm-llama4-maverick-17b-128e.yaml
```
En nuestro ejemplo, limitamos la ventana de contexto a 128 K mediante la opción --max-model-len=131072 vLLM.

Llama 4 Maverick 17B-128e-it

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

Crea el siguiente archivo de 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}}

Aplica el archivo de manifiesto:
```
kubectl apply -f vllm-llama4-maverick-17b-128e-instruct.yaml
```
En nuestro ejemplo, limitamos la ventana de contexto a 128 K mediante la opción --max-model-len=131072 vLLM.

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

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

Crea el siguiente archivo de 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}}

Aplica el archivo de manifiesto:
```
kubectl apply -f vllm-llama4-maverick-17b-128e-instruct-fp8.yaml
```
En nuestro ejemplo, limitamos la ventana de contexto a 512 K mediante la opción --max-model-len=524288 vLLM.

Llama 4 Scout 17B-16e

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

Crea el siguiente archivo de 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}}

Aplica el archivo de manifiesto:
```
kubectl apply -f vllm-llama4-scout-17b-16e.yaml
```
En nuestro ejemplo, limitamos la ventana de contexto a 256 K usando la opción --max-model-len=262144 vLLM.

Llama 4 Scout 17B-16e-it

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

Crea el siguiente archivo de 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}}

Aplica el archivo de manifiesto:
```
kubectl apply -f vllm-llama4-scout-17b-16e-instruct.yaml
```
En nuestro ejemplo, limitamos la ventana de contexto a 1280 K usando la opción --max-model-len=1310720 vLLM.

Espera a que la implementación esté disponible:

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

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

kubectl logs -f -l app=llama-server

El recurso Deployment descarga los datos del modelo. Este proceso puede tardar unos minutos. El resultado debería ser similar al siguiente:

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 pasar a la siguiente sección.

Aplicar el modelo

En esta sección, interactúas con el modelo.

Configurar la redirección de puertos

Para configurar el reenvío de puertos al modelo, ejecuta el siguiente comando:

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

El resultado debería ser similar al siguiente:

Forwarding from 127.0.0.1:8080 -> 7080

Interactuar con el modelo mediante curl

En esta sección se muestra cómo realizar una prueba de humo básica para verificar el modelo Llama ajustado con instrucciones que has implementado. En el caso de otros modelos, sustituye meta-llama/Llama-4-Scout-17B-16E por el nombre del modelo correspondiente.

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

En una nueva sesión de terminal, 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 debería ser similar al siguiente:

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

Solucionar problemas

Si aparece el mensaje Empty reply from server, es posible que el contenedor no haya terminado de descargar los datos del modelo. Vuelve a consultar los registros del pod para ver el mensaje Connected, que indica que el modelo está listo para usarse.
Si ves el mensaje Connection refused, comprueba que el reenvío de puertos esté activo.

Observar el rendimiento del modelo

Para observar el rendimiento del modelo, puedes usar la integración del panel de control de vLLM en Cloud Monitoring. Con este panel de control, puede ver métricas de rendimiento críticas, como el rendimiento de tokens, la latencia de las solicitudes y las tasas de error.

Para usar el panel de control de vLLM, debes habilitar Google Cloud Managed Service para Prometheus, que recoge las métricas de vLLM, en tu clúster de GKE. vLLM expone las métricas en formato Prometheus de forma predeterminada, por lo que no es necesario instalar ningún exportador adicional.

Después, puede ver las métricas en el panel de control de vLLM. Para obtener información sobre cómo usar Google Cloud Managed Service para Prometheus y recoger métricas de tu modelo, consulta la guía de observabilidad de vLLM en la documentación de Cloud Monitoring.

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

Eliminar los recursos desplegados

Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos que has creado en esta guía, ejecuta el siguiente comando:

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

Sustituye los siguientes valores:

CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster.
CLUSTER_NAME: el nombre de tu clúster.

Siguientes pasos

Consulta más información sobre las GPUs en GKE.
Consulta cómo usar Llama con vLLM en otros aceleradores, incluidas las GPUs A100 y H100, en el código de ejemplo de GitHub.
Consulta cómo desplegar cargas de trabajo de GPUs en Autopilot.
Consulta cómo desplegar cargas de trabajo de GPU en Estándar.
Consulta el repositorio de GitHub y la documentación de vLLM.
Consulta Vertex AI Model Garden.
Descubre cómo ejecutar cargas de trabajo de IA y aprendizaje automático optimizadas con las funciones de orquestación de la plataforma GKE.

Servir modelos Llama mediante GPUs en GKE con vLLM Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Fondo

Llama

GPUs

vLLM

Objetivos

Antes de empezar

Check for the roles

Grant the roles

Acceder al modelo

Prepara tu entorno

Crear y configurar Google Cloud recursos

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

Autopilot

Estándar

Crear un secreto de Kubernetes para las credenciales de Hugging Face

Desplegar vLLM

Llama 4 Maverick 17B-128e

Llama 4 Maverick 17B-128e-it

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

Llama 4 Scout 17B-16e

Llama 4 Scout 17B-16e-it

Aplicar el modelo

Configurar la redirección de puertos

Interactuar con el modelo mediante curl

Solucionar problemas

Observar el rendimiento del modelo

Limpieza

Eliminar los recursos desplegados

Siguientes pasos

Servir modelos Llama mediante GPUs en GKE con vLLM