Comment déployer Gemma 4 en production (vLLM + Docker)

Exécuter Gemma 4 sur votre laptop avec Ollama est génial pour le développement. Mais quand vous devez servir des centaines d'utilisateurs concurrents, gérer des milliers de requêtes par minute et maintenir la latence sous une seconde — vous avez besoin d'un moteur d'inférence de qualité production.

C'est là que vLLM entre en jeu. C'est la référence pour servir de grands modèles de langage en production, et il fonctionne magnifiquement avec Gemma 4.

Pourquoi vLLM ?

vLLM utilise PagedAttention, qui gère la mémoire GPU comme un système d'exploitation gère la RAM — allouant et libérant dynamiquement la mémoire au fur et à mesure que les requêtes vont et viennent. Le résultat :

Débit 2-4x plus élevé vs inférence naïve
API compatible OpenAI — remplacez Gemma 4 sans changer votre code client
Batching continu — pas de cycles GPU gaspillés entre les requêtes
Parallélisme de tenseurs — répartissez les grands modèles sur plusieurs GPU

Installer vLLM

# Créer un environnement propre
python -m venv vllm-env
source vllm-env/bin/activate

# Installer vLLM avec support GPU
pip install vllm

Assurez-vous d'avoir les bons pilotes CUDA. vLLM nécessite CUDA 12.1+ et un GPU avec au moins 16 Go de VRAM pour les modèles Gemma 4 plus petits.

Servir Gemma 4 avec l'API compatible OpenAI

La façon la plus simple de commencer — une commande et vous avez 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

Maintenant vous pouvez l'appeler avec n'importe quel client SDK OpenAI :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed",  # vLLM ne nécessite pas de clé par défaut
)

response = client.chat.completions.create(
    model="google/gemma-4-26b",
    messages=[
        {"role": "user", "content": "Explique l'informatique quantique en un paragraphe."}
    ],
    temperature=0.7,
    max_tokens=256,
)

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

La beauté de ceci : si votre application utilise déjà l'API OpenAI, vous changez littéralement juste la base_url et le nom du model. Tout le reste reste pareil.

Planification de la mémoire GPU

C'est la partie que la plupart des gens ratent. Voici ce dont vous avez vraiment besoin :

Modèle	Précision	VRAM min	VRAM recommandée	Contexte max
Gemma 4 E4B	FP16	10 Go	16 Go	32K
Gemma 4 E4B	INT8	6 Go	10 Go	16K
Gemma 4 26B	BF16	52 Go	80 Go (A100)	32K
Gemma 4 26B	INT8	28 Go	40 Go (A100)	32K
Gemma 4 31B	BF16	62 Go	80 Go (A100)	32K

Conseil pro : Le flag --gpu-memory-utilization (défaut 0.9) contrôle combien de VRAM vLLM préalloue. Baissez-le à 0.8 si vous exécutez d'autres processus sur le même GPU. Besoin d'aide pour déterminer votre matériel ? Consultez notre guide matériel.

Pour les configurations multi-GPU :

# Répartir Gemma 4 26B sur 2 GPU
vllm serve google/gemma-4-26b \
  --tensor-parallel-size 2 \
  --host 0.0.0.0 \
  --port 8000

Configuration Docker

Docker est la bonne façon de déployer en production. Voici un docker-compose.yml complet :

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:

Lancez-le :

# Définir votre token HuggingFace
export HF_TOKEN=your_token_here

# Démarrer le service
docker compose up -d

# Vérifier les logs
docker compose logs -f vllm

# Vérifier qu'il tourne
curl http://localhost:8000/v1/models

Pour une plongée plus profonde dans la configuration spécifique à Docker, voir notre guide Docker.

Inférence par batch

Quand vous avez besoin de traiter un grand jeu de données — disons, classifier 10 000 documents — l'inférence par batch est bien plus efficace que d'envoyer une requête à la fois :

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)

# Traiter 1000 items avec jusqu'à 50 requêtes concurrentes
items = ["Classify this text: " + text for text in your_texts]
results = asyncio.run(process_batch(items))

vLLM gère le batching en interne via le batching continu — il groupe automatiquement les requêtes pour une utilisation GPU maximale.

Équilibrage de charge

Pour la haute disponibilité, exécutez plusieurs instances vLLM derrière un équilibreur de charge :

# 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 : l'option managée

Si vous ne voulez pas du tout gérer l'infrastructure, Vertex AI de Google offre un déploiement Gemma 4 managé :

# Déployer 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 gère la mise à l'échelle, la surveillance et l'allocation GPU. Vous payez par prédiction. C'est plus cher par requête mais bien moins de surcharge opérationnelle.

Pour une comparaison avec Google AI Studio (niveau gratuit), consultez notre guide Google AI Studio.

Surveillance

Vous devriez surveiller ces métriques en production :

import requests

# vLLM expose des métriques Prometheus
metrics = requests.get("http://localhost:8000/metrics").text

# Métriques clés à surveiller :
# vllm:num_requests_running    — requêtes concurrentes actuelles
# vllm:num_requests_waiting    — profondeur de la file
# vllm:avg_generation_throughput — tokens par seconde
# vllm:gpu_cache_usage_perc   — utilisation du cache KV

Configurez des alertes pour :

Profondeur de file > 100 : Vous avez besoin de plus d'instances ou d'un GPU plus grand
Cache GPU > 95% : Réduisez max-model-len ou ajoutez de la mémoire
Latence p99 > 5s : Temps de mise à l'échelle horizontale
Taux d'erreur > 1% : Vérifiez les erreurs OOM et la santé du modèle

Un tableau de bord Grafana rapide avec ces quatre métriques détectera la plupart des problèmes de production avant que vos utilisateurs ne les remarquent.

Prochaines étapes

Configurez des conteneurs Docker pour des déploiements reproductibles
Activez la sortie JSON structurée pour les consommateurs d'API
Comparez les architectures Gemma 4 pour choisir le bon modèle pour votre charge de travail
Apprenez sur le fine-tuning pour personnaliser le modèle pour votre cas d'utilisation

gemma4 — interact