Para entregar modelos de lenguaje grandes (LLM) de Gemma 3 en Google Kubernetes Engine (GKE) con el framework de vLLM, debes aprovisionar un clúster de GKE con aceleradores compatibles, como las GPUs NVIDIA B200, H100 o L4.
Para obtener los pesos del modelo de Gemma 3, puedes configurar el contenedor de vLLM compilado previamente para descargarlos del repositorio de Hugging Face. Como alternativa, el contenedor puede cargar pesos del modelo desde un almacenamiento persistente existente, por ejemplo, almacenando en caché tus buckets del modelo de Cloud Storage en una instancia de Google Cloud Managed Lustre.
Una vez que se cargan los pesos, el contenedor de vLLM expone un extremo de API compatible con OpenAI para la inferencia de alta capacidad de procesamiento.
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 y tareas comunes del usuario 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 los siguientes temas:
Fondo
En esta sección, se describen las tecnologías clave que se usan en este instructivo.
Gemma
Gemma es un conjunto de modelos multimodales de Inteligencia Artificial (IA) generativos básicos disponibles de forma abierta que se lanzaron con una licencia abierta. Estos modelos de IA están disponibles para ejecutarse en tus aplicaciones, hardware, dispositivos móviles o servicios alojados. Gemma 3 introduce la multimodalidad y admite entradas de lenguaje visual y salidas de texto. Maneja ventanas de contexto de hasta 128,000 tokens y admite más de 140 idiomas. Gemma 3 también ofrece capacidades mejoradas de matemáticas, razonamiento y chat, incluidas salidas estructuradas y llamadas a funciones.
Puedes usar los modelos de Gemma para la generación de texto, pero también puedes ajustar estos modelos en el caso de tareas especializadas.
Para obtener más información, consulta la documentación de Gemma.
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.
Objetivos
En este instructivo, se proporcionan los conceptos básicos para comprender y explorar la implementación práctica de LLM para la inferencia en un entorno de Kubernetes administrado.
- Preparar tu entorno con un clúster de GKE en modo Autopilot o Standard.
- Implementar un contenedor de vLLM en tu clúster.
- Usa vLLM para entregar el modelo de Gemma 3 a través de curl y una interfaz de chat web.
Antes de comenzar
- Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
-
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 role
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
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 theserviceusage.services.enablepermission. Learn how to grant roles.-
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 role
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
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 theserviceusage.services.enablepermission. Learn how to grant roles.-
Asegúrate de tener los siguientes roles en el proyecto: roles/container.admin, roles/iam.serviceAccountAdmin
Verifica los roles
-
En la consola de Google Cloud , dirígete a la página IAM.
Ir a IAM - Selecciona el proyecto.
-
En la columna Principal, busca todas las filas que te identifiquen a ti o a un grupo en el que se te incluya. Para saber en qué grupos estás incluido, comunícate con tu administrador.
- Para todas las filas en las que se te especifique o se te incluya, verifica la columna Rol para ver si la lista de roles incluye los roles necesarios.
Otorga los roles
-
En la consola de Google Cloud , dirígete a la página IAM.
Ir a IAM - Selecciona el proyecto.
- Haz clic en Otorgar acceso.
-
En el campo Principales nuevas, ingresa tu identificador de usuario. Esta suele ser la dirección de correo electrónico de una Cuenta de Google.
- Haz clic en Seleccionar un rol y, luego, busca el rol.
- Para otorgar roles adicionales, haz clic en Agregar otro rol y agrega uno más.
- Haz clic en Guardar.
-
- Asegúrate de que tu proyecto tenga la cuota suficiente para las GPU L4. Para obtener más información, consulta Acerca de las GPU y Cuotas de asignación.
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:
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 .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_NAMEReemplaza los siguientes valores:
PROJECT_ID: Es el Google Cloud ID del proyecto.REGION: una región que admita el tipo de acelerador que deseas usar, por ejemplo,us-central1para la GPU L4.CLUSTER_NAME: El nombre de tu clúster.
Crea y configura recursos de Google Cloud
Sigue estas instrucciones para crear los recursos necesarios.
Crea un clúster de GKE y un grupo de nodos
Puedes entregar Gemma en GPU 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: Es el 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-central1para 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
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=1Reemplaza los siguientes valores:
PROJECT_ID: Es el 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-central1para la GPU L4.CLUSTER_NAME: El nombre de tu clúster.
La creación del clúster puede tomar varios minutos.
Para crear un grupo de nodos para tu clúster con el tamaño de disco adecuado, ejecuta el siguiente comando:
Gemma 3 1B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=REGION \ --node-locations=REGION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-8 \ --num-nodes=1GKE crea un grupo de nodos único que contiene una GPU L4 para cada nodo.
Gemma 3 4B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=REGION \ --node-locations=REGION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-8 \ --num-nodes=1GKE crea un grupo de nodos único que contiene una GPU L4 para cada nodo.
Gemma 3 12B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=REGION \ --node-locations=REGION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-48 \ --num-nodes=1GKE crea un solo grupo de nodos que contiene cuatro GPU L4 para cada nodo.
Gemma 3 27B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-a100-80gb,count=1,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=REGION \ --node-locations=REGION-a \ --cluster=CLUSTER_NAME \ --machine-type=a2-ultragpu-1g \ --disk-type=pd-ssd \ --num-nodes=1 \ --disk-size=256GKE crea un grupo de nodos único que contiene una GPU A100 de 80 GB.
Implementa modelos de Gemma 3 en vLLM con pesos de Hugging Face
Para implementar los modelos de Gemma 3 con pesos de Hugging Face, autentica tu clúster de GKE con un token de API de Hugging Face y aplica un manifiesto de implementación de Kubernetes. Este manifiesto extrae la imagen del contenedor de vLLM, solicita una GPU de NVIDIA y activa tu token como un Secret para que el contenedor pueda descargar los pesos directamente del repositorio de Hugging Face durante el inicio.
Procedimiento
Para implementar el modelo, completa estos pasos:
- Obtén acceso al modelo de Gemma 3 y genera un token de Hugging Face.
- Crea un Secret de Kubernetes en GKE para almacenar el token.
- Implementa el manifiesto de vLLM para el modelo de Gemma 3 que seleccionaste.
Obtén acceso al modelo
Sigue estos pasos para generar un token nuevo si aún no tienes uno:
- Haz clic en Tu perfil > Configuración > Tokens de acceso.
- Selecciona Token nuevo.
- Especifica el nombre que desees y un rol de al menos
Read. - Selecciona Genera un token.
- Copia el token generado al portapapeles.
Ejecuta este comando para establecer el token como una variable de entorno.
export HF_TOKEN=HF_TOKEN
Crea un secreto de Kubernetes para las credenciales de Hugging Face
En Cloud Shell, haz lo siguiente:
Configura
kubectlpara que pueda comunicarse con tu clúster:gcloud container clusters get-credentials CLUSTER_NAME \ --location=REGIONReemplaza los siguientes valores:
REGION: una región que admita el tipo de acelerador que deseas usar, por ejemplo,us-central1para la GPU L4.CLUSTER_NAME: El nombre de tu clúster.
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_TOKENpor el token de Hugging Face que generaste antes.
Descarga los pesos del modelo de Gemma 3 de Hugging Face
Aplica el manifiesto de implementación para el tamaño del modelo seleccionado. 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.
Aplicar este manifiesto crea un Pod en el clúster que descarga los pesos del modelo Gemma 3 directamente desde Hugging Face y, luego, inicia el motor de entrega de vLLM.
Gemma 3 1B-it
Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 3 1B (entrada solo de texto).
Crea el siguiente manifiesto
vllm-3-1b-it.yaml:Aplica el manifiesto
kubectl apply -f vllm-3-1b-it.yaml
Gemma 3 4B-it
Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 3 4B.
Crea el siguiente manifiesto
vllm-3-4b-it.yaml:Aplica el manifiesto
kubectl apply -f vllm-3-4b-it.yamlEn nuestro ejemplo, limitamos la ventana de contexto a 32 K con la opción
--max-model-len=32768de vLLM. Si deseas un tamaño de ventana de contexto más grande (hasta 128 K), ajusta tu manifiesto y la configuración del grupo de nodos con más capacidad de GPU.
Gemma 3 12B-it
Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 3 12B.
Crea el siguiente manifiesto
vllm-3-12b-it.yaml:Aplica el manifiesto
kubectl apply -f vllm-3-12b-it.yamlEn nuestro ejemplo, limitamos el tamaño de la ventana de contexto a 16 K con la opción
--max-model-len=16384de vLLM. Si deseas un tamaño de ventana de contexto más grande (hasta 128 K), ajusta la configuración del manifiesto y del grupo de nodos con más capacidad de GPU.
Gemma 3 27B-it
Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 3 27B.
Crea el siguiente manifiesto
vllm-3-27b-it.yaml:Aplica el manifiesto
kubectl apply -f vllm-3-27b-it.yamlEn nuestro ejemplo, limitamos el tamaño de la ventana de contexto a 32 K con la opción
--max-model-len=32768de vLLM. Si deseas un tamaño de ventana de contexto más grande (hasta 128 000), ajusta tu manifiesto y la configuración del grupo de nodos con más capacidad de GPU.
Verificación
Espera a que la implementación esté disponible:
kubectl wait --for=condition=Available --timeout=1800s deployment/vllm-gemma-deploymentObserva los registros de la implementación en ejecución:
kubectl logs -f -l app=gemma-serverEl recurso de Deployment descarga los datos del modelo de Gemma. Este proceso puede demorar unos minutos. El resultado es similar a lo siguiente:
INFO: Automatically detected platform cuda. ... INFO [launcher.py:34] Route: /v1/chat/completions, Methods: POST ... INFO: Started server process [13] INFO: Waiting for application startup. INFO: Application startup complete. Default STARTUP TCP probe succeeded after 1 attempt for container "vllm--google--gemma-3-4b-it-1" on port 8080.
Una vez que la implementación de Hugging Face esté disponible, configura el reenvío de puertos para interactuar con el modelo.
Implementa Gemma ajustado desde Managed Lustre
Para entregar un modelo de Gemma ajustado (como Gemma 3 27B) que ya está almacenado en una instancia de Lustre administrada por Google Cloud, debes activar el PersistentVolumeClaim (PVC) correspondiente en el contenedor de vLLM.
Requisitos previos
Asegúrate de tener un PVC existente en tu clúster de GKE que se conecte a tu instancia de Lustre. En este ejemplo, el PVC se llama gemma-lustre-pvc.
Si quieres obtener información para crear un PVC y un PersistentVolume (PV) para una instancia existente, consulta Cómo acceder a una instancia existente de Lustre administrado.
Procedimiento
Guarda el siguiente manifiesto YAML como
vllm-lustre-gemma.yaml. En este ejemplo, la Deployment activa el PVC de Lustre en/datay le indica a vLLM que cargue los pesos del modelo desde esa ruta de acceso local.apiVersion: apps/v1 kind: Deployment metadata: name: vllm-gemma-lustre spec: replicas: 1 selector: matchLabels: app: gemma-server template: metadata: labels: app: gemma-server spec: containers: - name: vllm image: vllm/vllm-openai:latest command: ["python3", "-m", "vllm.entrypoints.openai.api_server"] args: - --model=/data/gemma-3-27b - --tensor-parallel-size=1 resources: limits: nvidia.com/gpu: "1" volumeMounts: - name: model-weights mountPath: /data volumes: - name: model-weights persistentVolumeClaim: claimName: gemma-lustre-pvc nodeSelector: cloud.google.com/gke-accelerator: nvidia-l4 cloud.google.com/gke-gpu-driver-version: latestAplica el manifiesto al clúster de GKE:
kubectl apply -f vllm-lustre-gemma.yaml
Verificación
Para confirmar que el modelo se cargó correctamente desde el volumen de Lustre, consulta los registros del Pod para la secuencia de inicio de vLLM:
kubectl logs -l app=gemma-server
Entrega el modelo
En esta sección, interactuarás con el modelo. Asegúrate de que el modelo se haya descargado por completo antes de continuar.
Configura la redirección de puertos
Ejecuta el siguiente comando para configurar la redirección de puertos al modelo:
kubectl port-forward service/llm-service 8000:8000
El resultado es similar al siguiente:
Forwarding from 127.0.0.1:8000 -> 8000
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 los modelos de Gemma 3 ajustados por instrucciones que implementaste.
Para otros modelos, reemplaza gemma-3-4b-it por el nombre del modelo respectivo.
En este ejemplo, se muestra cómo probar el modelo ajustado con instrucciones de Gemma 3 4B con entrada solo de texto.
En una sesión de terminal nueva, usa curl para chatear con tu modelo:
curl http://127.0.0.1:8000/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
"model": "google/gemma-3-4b-it",
"messages": [
{
"role": "user",
"content": "Why is the sky blue?"
}
]
}'
El resultado es similar al siguiente:
{
"id": "chatcmpl-e4a2e624bea849d9b09f838a571c4d9e",
"object": "chat.completion",
"created": 1741763029,
"model": "google/gemma-3-4b-it",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Okay, let's break down why the sky appears blue! It's a fascinating phenomenon rooted in physics, specifically something called **Rayleigh scattering**. Here's the explanation: ...",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": 106
}
],
"usage": {
"prompt_tokens": 15,
"total_tokens": 668,
"completion_tokens": 653,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
Interactúa con el modelo a través de una interfaz de chat de Gradio (opcional)
En esta sección, compilarás una aplicación de chat web que te permita interactuar con el modelo ajustado a instrucciones. Para simplificar, en esta sección solo se describe el enfoque de prueba con el modelo 4B-it.
Gradio es una biblioteca de Python que tiene un
wrapper ChatInterface de ChatInterface que crea interfaces de usuario para chatbots.
Implementa la interfaz de chat
En Cloud Shell, guarda el siguiente manifiesto como
gradio.yaml. Cambiagoogle/gemma-2-9b-itporgoogle/gemma-3-4b-ito por otro nombre de modelo de Gemma 3 que hayas usado en tu implementación.Aplica el manifiesto
kubectl apply -f gradio.yamlEspera a que la implementación esté disponible:
kubectl wait --for=condition=Available --timeout=900s deployment/gradio
Usa la interfaz de chat
En Cloud Shell, ejecuta el siguiente comando:
kubectl port-forward service/gradio 8080:8080Esto crea una redirección de puertos desde Cloud Shell al servicio de Gradio.
Haz clic en el botón
Vista previa en la Web, que se encuentra en la parte superior derecha de la barra de tareas de Cloud Shell. Haga clic en Vista previa en el puerto 8080. Se abrirá una pestaña nueva en el navegador.Interactúa con Gemma con la interfaz de chat de Gradio. Agrega un mensaje y haz clic en Enviar.
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 mensajeConnected, que indica que el modelo está listo para entregar. - Si ves
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:
En la consola de Google Cloud , ve a la página Modelos implementados.
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.
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 del 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.
Realiza una limpieza
Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.
Borra los recursos implementados
Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que creaste en esta guía, ejecuta el siguiente comando:
gcloud container clusters delete CLUSTER_NAME \
--location=CONTROL_PLANE_LOCATION
Reemplaza 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.
¿Qué sigue?
- Obtén más información sobre las GPUs en GKE.
- Para aprender a usar Gemma con vLLM en otros aceleradores, incluidas las GPU A100 y H100, visualiza el código de muestra en GitHub.
- Aprende a implementar cargas de trabajo de GPUs en Autopilot.
- Aprende a implementar cargas de trabajo de GPUs en Standard.
- Explora el repositorio de GitHub y la documentación de vLLM.
- Explora Vertex AI Model Garden.
- Descubre cómo ejecutar cargas de trabajo de IA/AA optimizadas con las capacidades de organización de la plataforma de GKE.