vLLM — servir des modèles à haut débit sur GPU

Page informative, sans valeur de conseil. Téléchargez depuis la source officielle, vérifiez la licence du logiciel et de chaque modèle, et gardez en tête qu'un modèle de langage peut se tromper : croisez les informations importantes.

À quoi ça sert

vLLM est un serveur d'inférence open source né à l'Université de Berkeley. Son apport décisif, le PagedAttention, gère la mémoire du cache d'attention (le « KV cache ») par pages, comme un système d'exploitation gère la mémoire virtuelle. Résultat : très peu de gaspillage mémoire, et un débit élevé quand beaucoup de requêtes arrivent en même temps. À cela s'ajoute le continuous batching, qui agrège les requêtes à la volée plutôt que d'attendre un lot complet.

Concrètement : vLLM n'est pas fait pour discuter seul sur un portable, mais pour servir un modèle à une équipe, une application ou plusieurs services via une API compatible OpenAI.

Ce qui fait sa force

• Le débit, vraiment. PagedAttention + continuous batching permettent de servir des dizaines de requêtes simultanées avec un débit (tokens/seconde cumulés) que les moteurs mono-usage n'atteignent pas. C'est la raison de choisir vLLM.
• Efficacité mémoire GPU. Le KV cache paginé réduit la fragmentation : à VRAM égale, vous tenez plus de requêtes concurrentes ou un contexte plus long.
• API compatible OpenAI, prête à l'emploi. Le serveur expose /v1/completions, /v1/chat/completions et /v1/embeddings : vos outils prévus pour OpenAI fonctionnent en changeant l'URL de base.
• Conçu pour passer à l'échelle. Parallélisme tensoriel multi-GPU (--tensor-parallel-size), quantifications (AWQ, GPTQ, FP8), large couverture d'architectures Hugging Face. C'est l'outil quand un seul GPU ne suffit plus.
• Adopté en production. vLLM est devenu une brique standard du service de modèles open source, avec une communauté et un rythme de releases soutenus.

Pour qui

Pour qui dispose d'un GPU NVIDIA et doit servir un modèle à plusieurs utilisateurs ou applications, avec un bon niveau en Python, CUDA et déploiement serveur. Pour un usage individuel ou une très petite équipe, Ollama et llama.cpp sont plus appropriés et bien plus rapides à mettre en place.

Installation

Prérequis

GPU NVIDIA avec pilotes récents et CUDA, Python 3.9 à 3.12, et de la VRAM en quantité suffisante (voir Points de vigilance). vLLM cible avant tout Linux + CUDA ; d'autres backends (AMD ROCm, CPU, TPU) existent mais sont plus avancés à mettre en œuvre.

Installation via pip

# Environnement isolé (recommandé)
python -m venv .venv
source .venv/bin/activate          # Linux/macOS

pip install vllm

uv est également bien pris en charge et souvent plus rapide : uv pip install vllm.

Lancer un serveur d'inférence

La commande moderne est vllm serve (elle remplace l'ancien python -m vllm.entrypoints.openai.api_server, toujours valide) :

vllm serve mistralai/Mistral-7B-Instruct-v0.3

Le serveur écoute par défaut sur http://localhost:8000 et le modèle est téléchargé depuis Hugging Face au premier lancement. Vérifiez la licence du modèle avant de l'utiliser.

Via Docker (GPU NVIDIA)

docker run --gpus all -p 8000:8000 --ipc=host \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3

Tester l'API

# Lister les modèles servis
curl http://localhost:8000/v1/models

# Une requête de chat
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "messages": [{"role": "user", "content": "Bonjour !"}]
  }'

Points de vigilance

vLLM est un outil sérieux et sain : en local, rien ne sort de la machine. Ses vrais points d'attention sont liés à sa nature de serveur exposé sur le réseau et aux exigences matérielles — pas à des défauts cachés.

Point d'attention	Niveau	Ce qu'il faut savoir
API exposée sur le réseau	🔴 réel si publiée sans protection	Une option --api-key existe (jeton statique unique en en-tête Authorization: Bearer) mais reste basique : pas de gestion multi-utilisateurs ni de TLS intégré. Pour un accès au-delà de localhost, placez vLLM derrière un reverse-proxy (Nginx, Caddy) avec HTTPS et authentification.
Exigences VRAM	🟡 à dimensionner	vLLM préalloue de la mémoire GPU pour le KV cache. Un modèle 7B en demi-précision occupe environ 14–16 Go de VRAM ; les modèles plus grands imposent la quantification ou plusieurs GPU. Dimensionnez avant de lancer.
Licence du modèle (≠ celle de vLLM)	🟡 selon le modèle	vLLM est sous licence Apache 2.0 (permissive), mais chaque modèle chargé a la sienne : Llama et Gemma imposent des conditions, Mistral et Qwen (Apache 2.0) sont plus souples. À vérifier sur Hugging Face avant un usage commercial.
Confiance dans le modèle chargé	🟡 selon la source	Charger un modèle, c'est exécuter le code de chargement associé. Restez sur des dépôts Hugging Face réputés ; soyez prudent avec --trust-remote-code, qui exécute du code fourni par le dépôt du modèle.

Sécurité

• Restreignez l'écoute à localhost par défaut (--host 127.0.0.1) si vous n'avez pas besoin d'accès réseau.
• Pour l'accès multi-utilisateurs, un reverse-proxy. Nginx ou Caddy avec HTTPS et authentification ; --api-key seul ne suffit pas pour une exposition Internet.
• Maîtrisez --trust-remote-code. Ne l'activez que pour des modèles dont vous connaissez la provenance.
• Tenez vLLM à jour. Le projet évolue vite : correctifs, nouvelles architectures et gains de performance arrivent régulièrement.

Aller plus loin

• llama.cpp — l'autre moteur de référence, plus polyvalent côté matériel (CPU/GPU).
• Ollama — pour un usage individuel ou une petite équipe.
• Open WebUI — une interface web à brancher sur l'API de vLLM.
• OSIALab — comparer vLLM avec les autres moteurs d'inférence.

Sources

• Code source : github.com/vllm-project/vllm — licence Apache 2.0
• Documentation : docs.vllm.ai
• Article PagedAttention : arxiv.org/abs/2309.06180