Lancer un serveur vLLM sur les jobs HF en une seule commande

Lancer un serveur vLLM sur HF Jobs en une seule commande

Déployer des grands modèles de langage (LLM) pour l'inférence est une étape cruciale pour passer de l'expérimentation à la production. Le moteur d'inférence vLLM s'est imposé comme un outil puissant pour servir les modèles efficacement, en exploitant des techniques avancées de traitement par lots et de gestion de la mémoire. Hugging Face Jobs (HF Jobs) offre un environnement cloud-native et scalable pour exécuter ces charges de travail d'inférence. Cet article vous montre comment combiner ces deux technologies et lancer un serveur vLLM avec une seule commande, simplifiant ainsi votre pipeline de déploiement.

Ce que vous allez apprendre

À la fin de cet article, vous comprendrez :

• Comment vLLM accélère l'inférence des LLM.
• Les prérequis pour utiliser HF Jobs.
• L'installation et la configuration pas à pas d'un serveur vLLM.
• Les commandes pratiques pour lancer le serveur en une seule commande.
• Des exemples d'utilisation concrets et les bonnes pratiques.

Contexte : vLLM et HF Jobs

**vLLM** est un moteur d'inférence open-source conçu pour un débit élevé et une faible latence. Il utilise des techniques comme PagedAttention pour gérer efficacement la mémoire cache des paires clé-valeur, vous permettant de servir des modèles comme Llama, Mistral et autres avec un minimum de surcharge.

**Hugging Face Jobs** est un service géré qui exécute votre code sur une infrastructure cloud scalable. Il s'intègre parfaitement avec le Hub Hugging Face, vous permettant de télécharger des modèles directement et d'exécuter des commandes sans gérer vous-même les serveurs. La plateforme prend en charge les instances GPU, ce qui la rend idéale pour l'inférence des LLM.

Combiner vLLM avec HF Jobs vous offre une expérience de type serverless : vous spécifiez un modèle, une commande et les ressources nécessaires, et la plateforme s'occupe du reste.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

1. **Un compte Hugging Face** – Inscrivez-vous sur [huggingface.co](https://huggingface.co). Vous aurez besoin d'un jeton d'accès avec des droits d'écriture pour créer des jobs. 2. **HF CLI installé** – Installez la CLI Hugging Face localement pour interagir avec le Hub et l'API Jobs. Utilisez `pip install huggingface-hub`. 3. **Un modèle compatible GPU** – vLLM fonctionne mieux avec des modèles comme Mistral 7B, Llama 2/3, ou tout modèle supporté par Hugging Face Transformers. Assurez-vous que le modèle est accessible publiquement ou que vous y avez accès. 4. **Une familiarité de base avec Docker et la CLI** – HF Jobs utilise des conteneurs Docker, et vous exécuterez des commandes depuis votre terminal.

Installation et configuration pas à pas

1. Configurer votre environnement

Commencez par installer la CLI Hugging Face et vous authentifier :

pip install huggingface-hub
huggingface-cli login

Saisissez votre jeton d'accès lorsque vous y êtes invité. Ce jeton est stocké localement et utilisé pour tous les appels API ultérieurs.

2. Comprendre la structure des HF Jobs

Les HF Jobs nécessitent une définition de job. La façon la plus simple est d'utiliser le SDK Python `huggingface_hub` ou la CLI. Pour un lancement en une seule commande, nous utiliserons directement la CLI.

Un job comprend généralement :

• `--name` : Un nom de job.
• `--type` : Le type de job (par exemple, `inference`).
• `--image` : Une image Docker avec vLLM installé.
• `--command` : La commande à exécuter dans le conteneur.
• `--resources` : Les besoins en GPU (par exemple, `gpu=1`, `memory=16Gi`).

3. Choisir ou construire une image Docker

Vous pouvez utiliser l'image Docker officielle de vLLM depuis Docker Hub ou construire la vôtre. Pour simplifier, nous utiliserons `vllm/vllm-openai:latest` qui inclut le serveur API compatible OpenAI.

Vérifiez la dernière version sur le [GitHub de vLLM](https://github.com/vllm-project/vllm) ou utilisez un tag spécifique comme `v0.4.0`.

4. Écrire un point d'entrée Python simple (optionnel)

Si vous avez besoin d'une logique personnalisée, vous pouvez écrire un script Python. Mais pour un lancement en une seule commande, le serveur vLLM lui-même est le point d'entrée. La commande sera :

python -m vllm.entrypoints.openai.api_server --model <nom-du-modèle> --port 8000

5. Lancer le job avec une seule commande

Maintenant, combinez tout cela en une seule commande HF Jobs. Remplacez `<votre-modèle>` par l'ID du modèle (par exemple, `mistralai/Mistral-7B-Instruct-v0.2`).

huggingface-cli jobs create \
  --name vllm-server \
  --type inference \
  --image vllm/vllm-openai:latest \
  --command "python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-Instruct-v0.2 --port 8000" \
  --resources gpu=1,memory=16Gi

**Explication :**

• `--name` : Le nom d'affichage de votre job.
• `--type` : `inference` indique un job d'inférence GPU.
• `--image` : L'image Docker contenant vLLM et ses dépendances.
• `--command` : La commande exacte à exécuter. Le serveur API de vLLM démarre sur le port 8000.
• `--resources` : Demande un GPU et 16 Go de mémoire (ajustez selon la taille du modèle).

Après avoir exécuté cette commande, HF Jobs va : 1. Télécharger l'image Docker. 2. Allouer une instance GPU. 3. Exécuter la commande dans le conteneur. 4. Exposer un point d'accès (vous verrez l'URL dans les logs du job).

6. Surveiller le job

Vérifiez l'état du job et les logs :

huggingface-cli jobs logs --name vllm-server

Une fois le serveur prêt, vous verrez une sortie comme `Uvicorn running on http://0.0.0.0:8000`. L'URL publique réelle sera fournie dans les détails du job.

Exemples d'utilisation

Exemple 1 : Génération de texte basique

Une fois le serveur en cours d'exécution, vous pouvez envoyer des requêtes au point d'accès compatible OpenAI. Utilisez `curl` ou tout client HTTP :

curl http://<url-du-job>:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Quelle est la capitale de la France ?",
    "max_tokens": 50
  }'

**Réponse :**

{
  "id": "cmpl-...",
  "object": "text_completion",
  "choices": [{"text": " La capitale de la France est Paris."}]
}

Exemple 2 : Completions de chat

Pour les modèles basés sur le chat, utilisez le point d'accès `/v1/chat/completions` :

curl http://<url-du-job>:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [
      {"role": "user", "content": "Explique l'informatique quantique en termes simples."}
    ],
    "temperature": 0.7
  }'

Exemple 3 : Passage à l'échelle avec plusieurs GPU

Pour des modèles plus grands comme Llama 3 70B, vous pourriez avoir besoin de plusieurs GPU. Utilisez le parallélisme tensoriel :

huggingface-cli jobs create \
  --name vllm-llama3 \
  --type inference \
  --image vllm/vllm-openai:latest \
  --command "python -m vllm.entrypoints.openai.api_server --model meta-llama/Meta-Llama-3-70B-Instruct --tensor-parallel-size 4 --port 8000" \
  --resources gpu=4,memory=64Gi

Ici, `--tensor-parallel-size 4` répartit le modèle sur 4 GPU.

Exemple 4 : Utilisation de variables d'environnement

Vous pouvez passer des variables d'environnement pour la configuration, comme des clés API ou des paramètres personnalisés :

huggingface-cli jobs create \
  --name vllm-custom \
  --type inference \
  --image vllm/vllm-openai:latest \
  --command "python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-Instruct-v0.2 --port 8000" \
  --resources gpu=1,memory=16Gi \
  --env HF_TOKEN=votre_jeton_ici

**Remarque :** Utilisez ceci avec précaution ; les jetons sont visibles dans les logs du job.

Bonnes pratiques et dépannage

Choisir le bon modèle

• **Taille du modèle vs mémoire GPU :** Un modèle 7B tient sur un seul GPU de 16 Go (par exemple, T4, V100). Les modèles 13B nécessitent environ 24 Go. Les modèles 70B nécessitent plusieurs GPU.
• **Quantification :** Utilisez `--dtype half` ou `--quantization awq` de vLLM pour réduire la mémoire. Par exemple :

--command "python -m vllm.entrypoints.openai.api_server --model TheBloke/Mistral-7B-Instruct-v0.2-AWQ --quantization awq --port 8000"

Gérer les timeouts

La première exécution peut prendre plusieurs minutes pour télécharger le modèle. Définissez un timeout plus long dans votre client si nécessaire.

Sécurité

• N'exposez pas votre jeton HF dans la commande du job. Utilisez des variables d'environnement ou un gestionnaire de secrets.
• Le point d'accès du serveur est public par défaut. Pour la production, ajoutez une authentification (par exemple, via un proxy inverse).

Logs et débogage

Si le job échoue, vérifiez les logs :

huggingface-cli jobs logs --name vllm-server --tail 50

Erreurs courantes :

• **Mémoire insuffisante :** Augmentez la mémoire GPU ou utilisez un modèle plus petit.
• **Modèle introuvable :** Assurez-vous que l'ID du modèle est correct et accessible.
• **Conflit de port :** Changez le port avec `--port <nouveau-port>`.

Conclusion

Lancer un serveur vLLM sur HF Jobs avec une seule commande simplifie le déploiement des charges de travail d'inférence des LLM. En exploitant le moteur efficace de vLLM et l'infrastructure gérée de HF Jobs, vous pouvez servir des modèles comme Mistral et Llama en quelques minutes sans gérer de serveurs. Les étapes clés sont :

1. S'authentifier avec la CLI Hugging Face. 2. Utiliser une image Docker pré-construite de vLLM. 3. Écrire une commande concise qui démarre le serveur API. 4. Lancer le job avec des ressources GPU.

Cette approche est idéale pour le prototypage, les tests, et même l'inférence à l'échelle de la production, surtout lorsqu'elle est combinée avec des fonctionnalités de passage à l'échelle comme le parallélisme tensoriel. À mesure que l'écosystème évolue — avec les mises à jour de Mistral AI, Meta AI et la communauté Ollama — vLLM et HF Jobs resteront centraux pour un service de modèles efficace.

Essayez-le dès aujourd'hui : choisissez un modèle, exécutez la commande, et commencez à générer du texte en quelques minutes.