Comment exécuter Gemma 4 dans Docker (Guide complet des conteneurs)

Docker vous offre des déploiements d'IA reproductibles et isolés. Même conteneur, mêmes résultats — que ce soit votre laptop, un serveur de staging ou la production. Plus de « ça marche sur ma machine ».

Configurons Gemma 4 dans Docker à partir de zéro.

Pourquoi Docker pour l'IA ?

Reproductible : Verrouillez votre version d'Ollama, vos fichiers de modèle et votre config
Isolé : Ne touchera pas à Python, CUDA ou quoi que ce soit d'autre sur votre système hôte
Portable : Construire une fois, déployer partout
Nettoyage facile : docker compose down et c'est parti

Si vous exécutez juste Gemma 4 pour un usage personnel, Ollama directement est plus simple. Docker brille quand vous avez besoin de déploiements cohérents entre environnements ou que vous voulez intégrer Gemma 4 dans une pile d'application plus large.

Démarrage rapide avec Docker Run

Le moyen le plus rapide de faire tourner Gemma 4 dans Docker :

# Exécuter Ollama dans Docker
docker run -d \
  --name gemma4 \
  -p 11434:11434 \
  -v ollama-data:/root/.ollama \
  ollama/ollama

# Télécharger et exécuter Gemma 4
docker exec gemma4 ollama pull gemma4:26b
docker exec -it gemma4 ollama run gemma4:26b

C'est tout — trois commandes. Le -v ollama-data:/root/.ollama assure que votre modèle persiste au redémarrage du conteneur.

Dockerfile avec Ollama

Pour plus de contrôle, construisez une image personnalisée :

FROM ollama/ollama:latest

# Définir l'environnement
ENV OLLAMA_HOST=0.0.0.0
ENV OLLAMA_KEEP_ALIVE=24h

# Créer un script de démarrage qui télécharge le modèle au premier lancement
COPY <<'EOF' /start.sh
#!/bin/bash
ollama serve &
sleep 5

# Télécharger le modèle s'il n'est pas déjà présent
if ! ollama list | grep -q "gemma4:26b"; then
    echo "Téléchargement de Gemma 4 26B..."
    ollama pull gemma4:26b
fi

# Garder le conteneur actif
wait
EOF

RUN chmod +x /start.sh

EXPOSE 11434

CMD ["/start.sh"]

Construire et exécuter :

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

Docker Compose (recommandé)

Pour une configuration correcte, utilisez 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

Cela vous donne Ollama + Open WebUI — une interface complète de type ChatGPT pour Gemma 4 :

# Tout démarrer
docker compose up -d

# Télécharger Gemma 4
docker exec gemma4-ollama ollama pull gemma4:26b

# Ouvrir l'interface web
open http://localhost:3000

Passthrough GPU (NVIDIA)

Pour utiliser votre GPU dans Docker, vous avez besoin du NVIDIA Container Toolkit :

# Installer 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

# Configurer Docker pour utiliser le runtime NVIDIA
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Vérifier
docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi

Mettez à jour votre docker-compose.yml pour utiliser le 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

Note : Sur Mac avec Apple Silicon, Docker tourne dans une VM Linux et ne peut pas accéder à l'accélération Metal. Pour Mac, exécutez Ollama nativement à la place — vous obtiendrez automatiquement l'accélération GPU Metal. Voir notre guide de performance Mac pour les détails.

Stockage persistant des modèles

Les modèles sont des fichiers volumineux. Vous ne voulez pas les re-télécharger à chaque redémarrage de conteneur.

Volume nommé (recommandé — Docker gère le stockage) :

volumes:
  ollama-models:
    driver: local

Bind mount (vous choisissez le chemin — bon pour gérer l'espace disque) :

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

Vérifier la taille de stockage des modèles :

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

Modèle	Taille approximative (Q4)
Gemma 4 E2B	~1,5 Go
Gemma 4 E4B	~2,5 Go
Gemma 4 26B	~15 Go
Gemma 4 31B	~18 Go

Configuration multi-modèles

Vous voulez exécuter plusieurs tailles de Gemma 4 pour différents cas d'utilisation ? Facile :

# Télécharger plusieurs modèles
docker exec gemma4-ollama ollama pull gemma4:e4b   # Tâches rapides et simples
docker exec gemma4-ollama ollama pull gemma4:26b    # La plupart des tâches
docker exec gemma4-ollama ollama pull gemma4:31b    # Qualité maximale

# Lister tous les modèles
docker exec gemma4-ollama ollama list

Ollama charge les modèles à la demande et décharge les inactifs. Seul le modèle actif utilise la VRAM. Vous pouvez configurer combien de temps les modèles restent chargés :

environment:
  - OLLAMA_KEEP_ALIVE=5m     # Décharger après 5 minutes d'inactivité
  - OLLAMA_MAX_LOADED_MODELS=2  # Garder jusqu'à 2 modèles chargés

Exposer l'API

L'API Ollama tourne sur le port 11434 par défaut. Une fois votre conteneur démarré :

# Lister les modèles disponibles
curl http://localhost:11434/api/tags

# Générer une réponse
curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:26b",
  "messages": [{"role": "user", "content": "Bonjour !"}]
}'

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

Pour l'utilisation détaillée de l'API, voir notre tutoriel API. Pour un service de production avec un débit plus élevé, envisagez vLLM dans Docker.

Commandes Docker utiles

# Voir les logs
docker compose logs -f ollama

# Vérifier l'utilisation des ressources
docker stats gemma4-ollama

# Entrer dans le conteneur
docker exec -it gemma4-ollama bash

# Tout arrêter
docker compose down

# Arrêter et supprimer les données des modèles
docker compose down -v

# Mettre à jour l'image Ollama
docker compose pull && docker compose up -d