Como Ejecutar Gemma 4 en Docker (Guia Completa de Contenedores)

Docker te da despliegues de IA reproducibles y aislados. El mismo contenedor, los mismos resultados — ya sea tu laptop, un servidor de staging o produccion. No mas "funciona en mi maquina".

Configuremos Gemma 4 en Docker desde cero.

¿Por Que Docker Para IA?

Reproducible: Fija tu version de Ollama, archivos de modelo y configuracion
Aislado: No afecta al Python, CUDA o cualquier otra cosa de tu sistema host
Portatil: Construye una vez, despliega en cualquier lugar
Limpieza facil: docker compose down y desaparece

Si solo estas ejecutando Gemma 4 para uso personal, Ollama directamente es mas simple. Docker brilla cuando necesitas despliegues consistentes en diferentes entornos o quieres empaquetar Gemma 4 en un stack de aplicacion mas grande.

Inicio Rapido con Docker Run

La forma mas rapida de tener Gemma 4 ejecutandose en Docker:

# Ejecutar Ollama en Docker
docker run -d \
  --name gemma4 \
  -p 11434:11434 \
  -v ollama-data:/root/.ollama \
  ollama/ollama

# Descargar y ejecutar Gemma 4
docker exec gemma4 ollama pull gemma4:26b
docker exec -it gemma4 ollama run gemma4:26b

Eso es todo — tres comandos. El -v ollama-data:/root/.ollama asegura que tu modelo persiste cuando el contenedor se reinicia.

Dockerfile con Ollama

Para mas control, construye una imagen personalizada:

FROM ollama/ollama:latest

# Set environment
ENV OLLAMA_HOST=0.0.0.0
ENV OLLAMA_KEEP_ALIVE=24h

# Create a startup script that pulls the model on first run
COPY <<'EOF' /start.sh
#!/bin/bash
ollama serve &
sleep 5

# Pull model if not already present
if ! ollama list | grep -q "gemma4:26b"; then
    echo "Pulling Gemma 4 26B..."
    ollama pull gemma4:26b
fi

# Keep container running
wait
EOF

RUN chmod +x /start.sh

EXPOSE 11434

CMD ["/start.sh"]

Construir y ejecutar:

docker build -t gemma4-server .
docker run -d --name gemma4 -p 11434:11434 -v ollama-data:/root/.ollama gemma4-server

Docker Compose (Recomendado)

Para una configuracion adecuada, usa docker-compose.yml:

version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    container_name: gemma4-ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-models:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=24h
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 30s

  webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: gemma4-webui
    ports:
      - "3000:8080"
    volumes:
      - webui-data:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    depends_on:
      ollama:
        condition: service_healthy
    restart: unless-stopped

volumes:
  ollama-models:
    driver: local
  webui-data:
    driver: local

Esto te da Ollama + Open WebUI — una interfaz completa tipo ChatGPT para Gemma 4:

# Iniciar todo
docker compose up -d

# Descargar Gemma 4
docker exec gemma4-ollama ollama pull gemma4:26b

# Abrir la UI web
open http://localhost:3000

Passthrough de GPU (NVIDIA)

Para usar tu GPU dentro de Docker, necesitas el NVIDIA Container Toolkit:

# Instalar NVIDIA Container Toolkit (Ubuntu/Debian)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# Configurar Docker para usar el runtime NVIDIA
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Verificar
docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi

Actualiza tu docker-compose.yml para usar la GPU:

services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama-models:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

Nota: En Mac con Apple Silicon, Docker se ejecuta en una VM Linux y no puede acceder a la aceleracion Metal. Para Mac, ejecuta Ollama nativamente en su lugar — obtendras la aceleracion de GPU Metal automaticamente. Ve nuestra guia de rendimiento en Mac para detalles.

Almacenamiento Persistente de Modelos

Los modelos son archivos grandes. No quieres re-descargarlos cada vez que un contenedor se reinicia.

Volumen con nombre (recomendado — Docker gestiona el almacenamiento):

volumes:
  ollama-models:
    driver: local

Bind mount (tu eliges la ruta — bueno para gestionar espacio en disco):

volumes:
  - /data/ollama-models:/root/.ollama

Verificar el tamano del almacenamiento de modelos:

docker exec gemma4-ollama du -sh /root/.ollama/models

Modelo	Tamano Aproximado (Q4)
Gemma 4 E2B	~1.5 GB
Gemma 4 E4B	~2.5 GB
Gemma 4 26B	~15 GB
Gemma 4 31B	~18 GB

Configuracion Multi-Modelo

¿Quieres ejecutar multiples tamanos de Gemma 4 para diferentes casos de uso? Facil:

# Descargar multiples modelos
docker exec gemma4-ollama ollama pull gemma4:e4b   # Rapido, tareas simples
docker exec gemma4-ollama ollama pull gemma4:26b    # La mayoria de tareas
docker exec gemma4-ollama ollama pull gemma4:31b    # Maxima calidad

# Listar todos los modelos
docker exec gemma4-ollama ollama list

Ollama carga modelos bajo demanda y descarga los inactivos. Solo el modelo activo usa VRAM. Puedes configurar cuanto tiempo los modelos permanecen cargados:

environment:
  - OLLAMA_KEEP_ALIVE=5m     # Descargar despues de 5 minutos inactivo
  - OLLAMA_MAX_LOADED_MODELS=2  # Mantener hasta 2 modelos cargados

Exponiendo la API

La API de Ollama se ejecuta en el puerto 11434 por defecto. Una vez que tu contenedor esta ejecutandose:

# Listar modelos disponibles
curl http://localhost:11434/api/tags

# Generar una respuesta
curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:26b",
  "messages": [{"role": "user", "content": "Hello!"}]
}'

# La API tambien es compatible con OpenAI
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:26b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Para uso detallado de la API, ve nuestro tutorial de API. Para servicio de nivel de produccion con mayor rendimiento, considera vLLM en Docker.

Comandos Docker Utiles

# Ver logs
docker compose logs -f ollama

# Verificar uso de recursos
docker stats gemma4-ollama

# Entrar al contenedor
docker exec -it gemma4-ollama bash

# Detener todo
docker compose down

# Detener y eliminar datos del modelo
docker compose down -v

# Actualizar imagen de Ollama
docker compose pull && docker compose up -d