Déploiement avec vLLM

vLLM : le moteur d’inférence recommandé

vLLM est le moteur d’inférence Python le plus populaire pour les LLM. Il est recommandé par Mistral AI pour le self-hosting grâce à sa facilité d’utilisation, ses performances et son API compatible OpenAI. Cette leçon couvre l’installation, la configuration et les deux modes d’utilisation : batch (offline) et serveur.

Prérequis

Token Hugging Face

Vous avez besoin d’un token Hugging Face avec permission READ pour télécharger les modèles :

export HF_TOKEN="hf_votre_token_ici"

Avant le premier téléchargement, acceptez les conditions d’utilisation sur la page du modèle sur Hugging Face (par exemple : huggingface.co/mistralai/Mistral-Nemo-Instruct-2407).

Environnement Python

# 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

GPU requis

• Mistral 7B / Nemo — 1x GPU 24 Go (A10G, RTX 4090, L4)
• Mixtral 8x7B — 2x GPU 80 Go (A100-80GB)
• Mistral Large — 4x GPU 80 Go (A100-80GB) minimum
• Drivers NVIDIA et CUDA 12.x installés

Mode Offline (Batch)

Le mode offline est adapté au traitement de 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 :

from vllm import LLM
from vllm.sampling_params import SamplingParams

# Charger le modèle avec les flags 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": "Qu'est-ce que PagedAttention ?"}],
    [{"role": "user", "content": "Explique le tensor parallelism."}],
    [{"role": "user", "content": "Comment fonctionne le KV cache ?"}],
]

results = llm.chat(messages=messages_batch[0], sampling_params=sampling)
for output in results:
    print(output.outputs[0].text)

Cas d’usage du mode offline

• Traitement batch de documents (résumé, classification)
• Évaluation de modèles sur des benchmarks
• Génération de données synthétiques
• Scripts de test et prototypage

Mode Serveur

Le mode serveur lance un endpoint 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. Vous pouvez interagir avec lui exactement comme avec l’API OpenAI :

from openai import OpenAI

# Se connecter au serveur vLLM local
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # Pas d'auth par défaut
)

response = client.chat.completions.create(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    messages=[
        {"role": "system", "content": "Vous êtes un expert DevOps."},
        {"role": "user", "content": "Comment monitorer un serveur vLLM en production ?"}
    ],
    temperature=0.3,
    max_tokens=1024
)
print(response.choices[0].message.content)

Tester avec curl

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-Nemo-Instruct-2407",
        "messages": [{"role": "user", "content": "Bonjour, ça fonctionne ?"}],
        "temperature": 0.3
    }'

Déploiement Docker

Pour un déploiement reproductible, utilisez l’image Docker officielle :

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

Détail des flags :

• --runtime nvidia --gpus all — accès aux GPU NVIDIA
• -v ~/.cache/huggingface:... — cache des modèles (évite le re-téléchargement)
• --ipc=host — mémoire partagée pour la communication inter-processus GPU

Les trois flags Mistral essentiels

Lorsque vous servez un modèle Mistral avec vLLM, trois flags sont obligatoires :

Sans ces flags, le modèle peut fonctionner mais avec des performances dégradées ou des résultats incorrects.

Paramètres de performance

Tensor Parallelism

Pour distribuer un modèle sur plusieurs GPU :

vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --tensor-parallel-size 2

GPU Memory Utilization

Contrôlez le pourcentage de mémoire GPU alloué :

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) convient dans la plupart des cas. Réduisez-la si d’autres processus utilisent le GPU.

Vérifier que le serveur fonctionne

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

# Vérifier la santé du serveur
curl http://localhost:8000/health

Points clés à retenir

• vLLM expose une API compatible OpenAI — vous pouvez utiliser le SDK openai pour communiquer
• Les trois flags --tokenizer_mode mistral, --config_format mistral, --load_format mistral sont obligatoires
• Le mode offline est adapté au batch processing, le mode serveur aux applications temps réel
• Docker simplifie le déploiement et garantit la reproductibilité
• Le tensor parallelism permet de distribuer les gros modèles sur plusieurs GPU