Points clés
- Headless = pas d'UI de chat, juste une API. Ollama, vLLM et LM Studio supportent tous le mode headless.
- Ollama headless : `ollama serve` démarre l'API sur localhost:11434. Pas d'UI.
- vLLM headless : `vllm serve` démarre l'API sur le port 8000. Meilleur débit qu'Ollama.
- Production : utilisez vLLM pour le haut débit, Ollama pour la simplicité, nginx pour l'équilibrage de charge et la sécurité.
- Depuis avril 2026, vLLM est le standard de production pour les services à haut débit.
Qu'est-ce que Headless signifie?
Headless signifie que le logiciel s'exécute en tant que service sans interface graphique. Vous interagissez via des appels API (REST, gRPC) au lieu de cliquer sur des boutons.
Avantages : utilisation plus légère des ressources (pas de surcharge UI), automatisation plus facile, approprié pour les serveurs, évolutivité plus simple.
Inconvénients : pas de retour visuel, nécessite des connaissances en API, plus difficile à déboguer sans journaux.
Comment exécuter Ollama en mode Headless?
Ollama peut s'exécuter en tant que service API pur :
# Run Ollama headless
ollama serve
# This starts the API at http://localhost:11434/v1
# No chat UI, just a background service
# Use the API from Python
from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
response = client.chat.completions.create(
model="llama3.2:3b",
messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)
# Or from curl
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{{"model": "llama3.2:3b", "messages": [{{"role": "user", "content": "Hello"}}]}}'Comment exécuter vLLM en mode Headless?
vLLM est optimisé pour les déploiements headless à haut débit :
# Install vLLM
pip install vllm
# Run headless with API
vllm serve llama-3.1-8b-instruct \
--host 0.0.0.0 \
--port 8000 \
--gpu-memory-utilization 0.9
# Access at http://localhost:8000/v1
# Supports 50+ concurrent requests
# Use from Python (same as Ollama)
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="anything")
response = client.chat.completions.create(
model="meta-llama/Llama-2-7b-chat-hf",
messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)Comment déployer pour la production?
1. Utilisez vLLM pour un haut débit (50+ utilisateurs simultanés).
2. Utilisez Ollama pour la simplicité (utilisateur unique ou petites équipes).
3. Ajoutez un proxy inverse nginx pour l'équilibrage de charge et l'authentification.
4. Surveillez la mémoire GPU -- les modèles ne devraient pas dépasser 80 % de VRAM.
5. Configurez la journalisation -- suivez les erreurs et les performances.
6. Utilisez systemd ou Docker pour la gestion des services (redémarrage automatique en cas de panne).
7. Considérez la conformité CNIL -- pour les applications traitant des données sensibles (données financières, médicales, juridiques), la CNIL recommande les LLMs locaux pour minimiser les risques de transfert de données.
# Example: Deploy vLLM on a server via Docker
docker run --gpus all -p 8000:8000 \
--env VLLM_API_KEY="your-secret-key" \
vllm/vllm-openai:latest \
--model meta-llama/Llama-2-13b-chat-hf \
--tensor-parallel-size 2 # Use 2 GPUs
# Nginx reverse proxy config (optional)
# server {
# listen 80;
# location / {
# proxy_pass http://localhost:8000;
# proxy_set_header Authorization "Bearer $http_authorization";
# }
# }Comment surveiller les déploiements Headless?
Surveillez la mémoire GPU, la latence des requêtes et les taux d'erreur :
# Monitor GPU usage (nvidia-smi)
watch nvidia-smi # Updates every 2 seconds
# Monitor request latency
# Add logging to your client code
import time
start = time.time()
response = client.chat.completions.create(...)
latency = time.time() - start
print(f"Request took {latency:.2f} seconds")
# Monitor vLLM logs
docker logs -f <container_id>
# Check error rates
# Parse logs for errors or use a monitoring tool (Prometheus + Grafana)Erreurs courantes avec les déploiements Headless
- Ne pas surveiller la VRAM. Les modèles peuvent silencieusement manquer de mémoire. Surveillez le GPU avant le déploiement en production.
- Exposer l'API sans authentification. Les services headless sont souvent exposés aux réseaux. Ajoutez toujours l'authentification (clé API, pare-feu).
- Ne pas définir les limites de ressources. Un modèle peut consommer 100 % du GPU, bloquant les autres tâches. Utilisez `--gpu-memory-utilization` dans vLLM.
- S'attendre à ce qu'Ollama se mette à l'échelle à 100+ utilisateurs. Utilisez vLLM pour la haute concurrence. Ollama peut gérer 1-3 utilisateurs simultanés.
- Ne pas tester le basculement. Si votre serveur de modèles plante, les requêtes se bloquent. Utilisez un équilibreur de charge et des contrôles de santé.
Questions fréquemment posées sur les déploiements Headless
Ollama et vLLM peuvent-ils s'exécuter sur le même GPU?
Non, pas simultanément. Ils concourront pour la VRAM. Exécutez l'un ou l'autre, ou utilisez plusieurs GPU.
Est-il sûr d'exposer l'API à Internet?
Non, pas sans authentification. Placez toujours une clé API, un pare-feu ou un proxy inverse en avant. Ne jamais exposer localhost:11434 directement.
Combien d'utilisateurs simultanés Ollama peut-il gérer?
Généralement 1-3 sans mise en file d'attente. Pour plus, utilisez vLLM ou ajoutez une mise en file d'attente des requêtes.
Quelle est la différence de performance entre Ollama et vLLM?
Requête unique : vitesse similaire. Requêtes simultanées multiples : vLLM est 5-10× mieux car il regroupe les requêtes.
Sources
- Ollama GitHub -- github.com/ollama/ollama
- vLLM GitHub -- github.com/vllm-project/vllm
- vLLM Deployment Guide -- docs.vllm.ai/en/serving/deploying_with_docker.html
- Ollama API Docs -- github.com/ollama/ollama/blob/main/docs/api.md