Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Déploiement avec vLLM

Ceacht 11 as 14 Nuashonraithe 29 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. vLLM : le moteur d’inférence recommandé
  2. Ce dont tu as besoin
  3. Mode hors ligne : traitement par lots
  4. Mode serveur : exposition d’une API
  5. Déploiement Docker
  6. Les trois indicateurs Mistral essentiels
  7. Ajustement des performances
  8. Príomhphointí

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 facile à utiliser, offre d’excellentes performances et propose une API compatible avec celle d’OpenAI. Nous allons parcourir ensemble l’installation et la 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 tu as 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 ton premier téléchargement, accepte 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 provoque 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, utilise un virtualenv dédié afin d’éviter les conflits de versions avec tes 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 tu peux 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, a besoin d’au moins quatre GPU A100-80GB. Dans tous les cas, installe 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. Tu charges le modèle en mémoire, traites tes requêtes et récupères les résultats. Note 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 par rapport à des benchmarks, la génération de données synthétiques, ainsi que pour les scripts de test ou de prototypage. Dès que personne n’attend une réponse immédiate, tu profites de l’absence 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 ton modèle auto-hébergé en changeant seulement deux lignes, base_url et api_key. Tes 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é ainsi n’authentifie personne. Sur une machine de développement, c’est pratique. Sur une machine accessible au 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 Docker

Pour un déploiement reproductible, l’image officielle évite de réinstaller 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 dans cette commande méritent une explication. --runtime nvidia --gpus all donne au conteneur l’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, t’é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 tu passes à plusieurs cartes.

Les trois indicateurs Mistral essentiels

IndicateurObjectif
--tokenizer_mode mistralUtilise le tokeniseur natif Mistral (et non celui de HF)
--config_format mistralCharge la configuration au format Mistral
--load_format mistralCharge 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 tu risques 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éduis-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 ton 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

Príomhphointí

  • vLLM expose une API compatible OpenAI : tu peux utiliser le SDK openai pour communiquer
  • Les trois indicateurs --tokenizer_mode mistral, --config_format mistral, --load_format mistral sont 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 te permet de distribuer les grands modèles sur plusieurs GPU