Déploiement avec vLLM
Pe această pagină
vLLM : le moteur d’inférence recommandé
vLLM est le moteur d’inférence Python le plus populaire pour les LLM. Mistral AI le recommande pour l’auto-hébergement car il est simple d’utilisation, offre d’excellentes performances et propose une API compatible avec celle d’OpenAI. Nous allons parcourir ensemble les étapes d’installation et de configuration, puis aborder ses deux modes d’utilisation : le mode par lots (hors ligne) et le mode serveur. Ces modes ne s’excluent pas mutuellement ; de nombreuses équipes utilisent le premier pour préparer les données et le second pour servir les applications.
Ce dont vous avez besoin
Le téléchargement des modèles s’effectue via Hugging Face, ce qui nécessite un jeton disposant de l’autorisation READ :
export HF_TOKEN="hf_your_token_here"
Avant votre premier téléchargement, vous devez accepter les conditions d’utilisation sur la page Hugging Face du modèle (par exemple : huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Il s’agit d’une étape manuelle unique par compte. L’oublier entraîne des échecs de téléchargement dont le diagnostic peut prendre une heure, car ils ressemblent à des problèmes d’authentification.
Pour l’environnement Python, utilisez un virtualenv dédié afin d’éviter les conflits de versions avec vos autres projets :
# Créer un environnement virtuel
python -m venv vllm-env
source vllm-env/bin/activate
# Installer vLLM (version >= 0.6.1.post1)
pip install vllm
Ensuite, il y a le matériel, qui détermine ce que vous pouvez réellement servir. Mistral 7B et Nemo tiennent sur un seul GPU de 24 Go, typiquement un A10G, un RTX 4090 ou un L4. Mixtral 8x7B nécessite deux GPU de 80 Go, en pratique des cartes A100-80GB. Mistral Large 2, dans sa version à poids ouverts avec ses 123 milliards de paramètres, requiert au moins quatre GPU A100-80GB. Dans tous les cas, installez les pilotes NVIDIA et CUDA 12.x avant vLLM.
Mode hors ligne : traitement par lots
Le mode hors ligne gère des lots de requêtes sans serveur HTTP. Vous chargez le modèle en mémoire, traitez vos requêtes et récupérez les résultats. Notez les trois arguments tokenizer_mode, load_format et config_format : nous y reviendrons, car ils ne sont pas optionnels.
from vllm import LLM
from vllm.sampling_params import SamplingParams
# Charger le modèle avec les indicateurs Mistral
llm = LLM(
model="mistralai/Mistral-Nemo-Instruct-2407",
tokenizer_mode="mistral",
load_format="mistral",
config_format="mistral"
)
# Paramètres de génération
sampling = SamplingParams(
max_tokens=8192,
temperature=0.3
)
# Traiter un lot de requêtes
messages_batch = [
[{"role": "user", "content": "What is PagedAttention?"}],
[{"role": "user", "content": "Explain tensor parallelism."}],
[{"role": "user", "content": "How does the KV cache work?"}],
]
results = llm.chat(messages=messages_batch[0], sampling_params=sampling)
for output in results:
print(output.outputs[0].text)
Ce mode excelle pour le traitement de documents par lots (résumé, classification), l’évaluation de modèles sur des benchmarks, la génération de données synthétiques, ainsi que pour les scripts de test ou de prototypage. Dès lors que personne n’attend une réponse immédiate, vous bénéficiez de la suppression de la couche HTTP.
Mode serveur : exposition d’une API
Le mode serveur lance un point de terminaison HTTP compatible avec l’API OpenAI :
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--host 0.0.0.0 \
--port 8000
Le serveur expose l’API sur le port 8000. La conséquence pratique est significative : une application écrite pour l’API OpenAI bascule vers votre modèle auto-hébergé en modifiant seulement deux lignes, base_url et api_key. Vos bibliothèques, frameworks d’agents et outils de test continuent de fonctionner.
from openai import OpenAI
# Se connecter au serveur vLLM local
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="not-needed" # Pas d'authentification par défaut
)
response = client.chat.completions.create(
model="mistralai/Mistral-Nemo-Instruct-2407",
messages=[
{"role": "system", "content": "You are a DevOps expert."},
{"role": "user", "content": "How do I monitor a vLLM server in production?"}
],
temperature=0.3,
max_tokens=1024
)
print(response.choices[0].message.content)
Le commentaire # Pas d'authentification par défaut mérite attention : un serveur vLLM lancé de cette façon n’authentifie personne. Sur une machine de développement, c’est pratique. Sur une machine accessible via le réseau, c’est une porte ouverte. Un test rapide en ligne de commande confirme que tout répond avant de passer à la suite :
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "mistralai/Mistral-Nemo-Instruct-2407",
"messages": [{"role": "user", "content": "Hello, is this working?"}],
"temperature": 0.3
}'
Déploiement avec Docker
Pour un déploiement reproductible, l’image officielle évite de réinstaller les dépendances sur chaque machine :
docker run --runtime nvidia --gpus all \
-v ~/.cache/huggingface:/root/.cache/huggingface \
--env "HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}" \
-p 8000:8000 \
--ipc=host \
vllm/vllm-openai:latest \
--model mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--load_format mistral \
--config_format mistral
Trois options de cette commande méritent une explication. --runtime nvidia --gpus all donne au conteneur accès aux GPU NVIDIA ; sans cela, le modèle tenterait de s’exécuter sur le CPU. Le montage -v ~/.cache/huggingface:... partage le cache des modèles avec l’hôte, vous évitant de retélécharger des dizaines de gigaoctets à chaque redémarrage du conteneur. --ipc=host accorde la mémoire partagée nécessaire à la communication inter-processus entre les GPU ; l’omettre provoque des plantages difficiles à diagnostiquer dès que vous passez à plusieurs cartes.
Les trois indicateurs Mistral essentiels
| Indicateur | Objectif |
|---|---|
--tokenizer_mode mistral | Utilise le tokenizer natif Mistral (et non celui de HF) |
--config_format mistral | Charge la configuration au format Mistral |
--load_format mistral | Charge les poids au format natif Mistral |
Sans ces indicateurs, le modèle peut s’exécuter, mais avec des performances dégradées ou des résultats incorrects. C’est le piège le plus courant lors de l’auto-hébergement de Mistral : rien ne plante, le serveur démarre, les réponses arrivent, mais elles sont simplement moins bonnes qu’elles ne devraient l’être, et vous risquez de conclure à tort que le modèle est décevant.
Ajustement des performances
Lorsqu’un modèle ne tient pas sur une seule carte, le parallélisme tensoriel distribue ses couches sur plusieurs GPU. La valeur passée correspond au nombre de cartes utilisées :
vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--tensor-parallel-size 2
Le second levier concerne la proportion de mémoire GPU que vLLM réserve :
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--gpu-memory-utilization 0.9
La valeur par défaut (0,9) fonctionne dans la plupart des cas. Réduisez-la si d’autres processus utilisent le GPU (un service de vision, un notebook oublié), sinon le premier processus prend toute la mémoire et le second échoue au démarrage.
Enfin, deux appels suffisent pour vérifier qu’un serveur est actif, ce qui en fait de bonnes sondes pour votre orchestrateur :
# Lister les modèles disponibles
curl http://localhost:8000/v1/models
# Vérifier l'état de santé du serveur
curl http://localhost:8000/health
Puncte cheie
- vLLM expose une API compatible OpenAI : vous pouvez utiliser le SDK
openaipour communiquer - Les trois indicateurs
--tokenizer_mode mistral,--config_format mistral,--load_format mistralsont obligatoires - Le mode hors ligne convient au traitement par lots ; le mode serveur convient aux applications en temps réel
- Docker simplifie le déploiement et assure la reproductibilité
- Le parallélisme tensoriel vous permet de distribuer les grands modèles sur plusieurs GPU