Como Desplegar Gemma 4 en Produccion (vLLM + Docker)

Ejecutar Gemma 4 en tu laptop con Ollama es genial para desarrollo. Pero cuando necesitas servir cientos de usuarios concurrentes, manejar miles de solicitudes por minuto y mantener la latencia por debajo de un segundo — necesitas un motor de inferencia de nivel de produccion.

Ahi es donde entra vLLM. Es el estandar de oro para servir grandes modelos de lenguaje en produccion, y funciona maravillosamente con Gemma 4.

¿Por Que vLLM?

vLLM usa PagedAttention, que gestiona la memoria de GPU de la forma en que un sistema operativo gestiona la RAM — asignando y liberando memoria dinamicamente a medida que las solicitudes van y vienen. El resultado:

2-4x mayor rendimiento vs. inferencia ingenua
API compatible con OpenAI — cambia a Gemma 4 sin cambiar el codigo de tu cliente
Batching continuo — sin ciclos de GPU desperdiciados entre solicitudes
Paralelismo de tensores — divide modelos grandes entre multiples GPUs

Instalando vLLM

# Crear un entorno limpio
python -m venv vllm-env
source vllm-env/bin/activate

# Instalar vLLM con soporte GPU
pip install vllm

Asegurate de tener los drivers CUDA correctos. vLLM necesita CUDA 12.1+ y una GPU con al menos 16GB VRAM para los modelos Gemma 4 mas pequenos.

Sirviendo Gemma 4 con la API Compatible con OpenAI

La forma mas simple de comenzar — un comando y tienes un endpoint API:

vllm serve google/gemma-4-26b \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90 \
  --dtype bfloat16

Ahora puedes golpearlo con cualquier cliente del SDK de OpenAI:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed",  # vLLM doesn't require a key by default
)

response = client.chat.completions.create(
    model="google/gemma-4-26b",
    messages=[
        {"role": "user", "content": "Explain quantum computing in one paragraph."}
    ],
    temperature=0.7,
    max_tokens=256,
)

print(response.choices[0].message.content)

La belleza de esto: si tu app ya usa la API de OpenAI, literalmente solo cambias el base_url y el nombre del model. Todo lo demas permanece igual.

Planificacion de Memoria GPU

Esta es la parte que la mayoria de la gente hace mal. Esto es lo que realmente necesitas:

Modelo	Precision	VRAM Min	VRAM Recomendada	Contexto Max
Gemma 4 E4B	FP16	10 GB	16 GB	32K
Gemma 4 E4B	INT8	6 GB	10 GB	16K
Gemma 4 26B	BF16	52 GB	80 GB (A100)	32K
Gemma 4 26B	INT8	28 GB	40 GB (A100)	32K
Gemma 4 31B	BF16	62 GB	80 GB (A100)	32K

Pro tip: La bandera --gpu-memory-utilization (por defecto 0.9) controla cuanta VRAM pre-asigna vLLM. Bajala a 0.8 si estas ejecutando otros procesos en la misma GPU. ¿Necesitas ayuda para averiguar tu hardware? Consulta nuestra guia de hardware.

Para configuraciones multi-GPU:

# Split Gemma 4 26B across 2 GPUs
vllm serve google/gemma-4-26b \
  --tensor-parallel-size 2 \
  --host 0.0.0.0 \
  --port 8000

Configuracion de Docker

Docker es la forma correcta de desplegar en produccion. Aqui tienes un docker-compose.yml completo:

version: "3.8"

services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - model-cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    command: >
      --model google/gemma-4-26b
      --host 0.0.0.0
      --port 8000
      --max-model-len 8192
      --gpu-memory-utilization 0.90
      --dtype bfloat16
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  model-cache:

Lanzalo:

# Set your HuggingFace token
export HF_TOKEN=your_token_here

# Start the service
docker compose up -d

# Check logs
docker compose logs -f vllm

# Verify it's running
curl http://localhost:8000/v1/models

Para una inmersion mas profunda en la configuracion especifica de Docker, ve nuestra guia de Docker.

Inferencia Por Lotes

Cuando necesitas procesar un gran conjunto de datos — digamos, clasificar 10,000 documentos — la inferencia por lotes es mucho mas eficiente que enviar una solicitud a la vez:

from openai import OpenAI
import asyncio
import aiohttp

client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

async def process_batch(items, max_concurrent=50):
    semaphore = asyncio.Semaphore(max_concurrent)
    
    async def process_one(item):
        async with semaphore:
            response = client.chat.completions.create(
                model="google/gemma-4-26b",
                messages=[{"role": "user", "content": item}],
                max_tokens=128,
            )
            return response.choices[0].message.content
    
    tasks = [process_one(item) for item in items]
    return await asyncio.gather(*tasks)

# Process 1000 items with up to 50 concurrent requests
items = ["Classify this text: " + text for text in your_texts]
results = asyncio.run(process_batch(items))

vLLM maneja el batching internamente a traves del batching continuo — agrupa solicitudes automaticamente para maxima utilizacion de GPU.

Balanceo de Carga

Para alta disponibilidad, ejecuta multiples instancias de vLLM detras de un balanceador de carga:

# nginx.conf
upstream vllm_backend {
    least_conn;
    server vllm-1:8000;
    server vllm-2:8000;
    server vllm-3:8000;
}

server {
    listen 80;

    location /v1/ {
        proxy_pass http://vllm_backend;
        proxy_set_header Host $host;
        proxy_read_timeout 120s;
    }
}

Vertex AI: La Opcion Gestionada

Si no quieres gestionar infraestructura en absoluto, Vertex AI de Google ofrece despliegue gestionado de Gemma 4:

# Deploy via gcloud CLI
gcloud ai endpoints create \
  --region=us-central1 \
  --display-name=gemma4-endpoint

gcloud ai models upload \
  --region=us-central1 \
  --display-name=gemma-4-26b \
  --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/vllm-serve:latest \
  --artifact-uri=gs://your-bucket/gemma-4-26b

Vertex AI maneja el escalado, monitoreo y asignacion de GPU. Pagas por prediccion. Es mas caro por consulta pero mucha menos sobrecarga operacional.

Para una comparacion con Google AI Studio (nivel gratuito), consulta nuestra guia de Google AI Studio.

Monitoreo

Deberias estar observando estas metricas en produccion:

import requests

# vLLM exposes Prometheus metrics
metrics = requests.get("http://localhost:8000/metrics").text

# Key metrics to track:
# vllm:num_requests_running    — current concurrent requests
# vllm:num_requests_waiting    — queue depth
# vllm:avg_generation_throughput — tokens per second
# vllm:gpu_cache_usage_perc   — KV cache utilization

Configura alertas para:

Profundidad de cola > 100: Necesitas mas instancias o una GPU mas grande
Cache GPU > 95%: Reduce max-model-len o agrega memoria
Latencia p99 > 5s: Hora de escalar horizontalmente
Tasa de error > 1%: Verifica errores OOM y salud del modelo

Un dashboard rapido de Grafana con estas cuatro metricas capturara la mayoria de los problemas de produccion antes de que tus usuarios los noten.

Siguientes Pasos

Configura contenedores Docker para despliegues reproducibles
Habilita salida JSON estructurada para consumidores de API
Compara arquitecturas de Gemma 4 para elegir el modelo correcto para tu carga de trabajo
Aprende sobre fine-tuning para personalizar el modelo para tu caso de uso

gemma4 — interact