Use vLLM to deploy a Qwen model as an inference service - Container Service for Kubernetes

Prérequis

Assurez-vous de disposer des éléments suivants :

Un cluster ACK Pro avec des nœuds accélérés par GPU exécutant Kubernetes 1.22 ou une version ultérieure, chacun disposant d'au moins 16 Go de mémoire GPU. Consultez la rubrique Créer un cluster ACK managé.
La dernière version du client Arena. Consultez la rubrique Configurer le client Arena.

Remarque

Utilisez la version 525 du pilote GPU. Ajoutez le libellé ack.aliyun.com/nvidia-driver-version:525.105.17 à vos nœuds accélérés par GPU. Consultez la rubrique Spécifier une version de pilote NVIDIA pour les nœuds en ajoutant un libellé.

Contexte

Qwen1,5-4B-Chat

Qwen1,5-4B-Chat est un LLM basé sur l'architecture Transformer, comptant 4 milliards de paramètres et développé par Alibaba Cloud. Il a été entraîné sur du texte web, des livres spécialisés et du code. Consultez le référentiel GitHub Qwen.

vLLM

vLLM est un framework d'inférence LLM open source optimisé pour un débit élevé et une faible latence. Il prend en charge la plupart des LLM couramment utilisés, y compris Qwen, et utilise PagedAttention, le traitement par lots continu et la quantification pour améliorer l'efficacité. Consultez le référentiel GitHub vLLM.

Étape 1 : Préparer les données du modèle

Téléchargez Qwen1.5-4B-Chat, importez-le dans Object Storage Service (OSS), puis créez un volume persistant (PV) et une revendication de volume persistant (PVC) dans votre cluster ACK.

Remarque

Vous pouvez également stocker le modèle dans File Storage NAS au lieu d'OSS. Consultez la rubrique Monter un volume NAS provisionné statiquement.

Télécharger le modèle

Installez Git :

   # Run yum install git or apt install git.
   yum install git

Installez Git Large File Storage (Git LFS) :

   # Run yum install git-lfs or apt install git-lfs.
   yum install git-lfs

Clonez Qwen1,5-4B-Chat depuis ModelScope :

   GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/qwen/Qwen1.5-4B-Chat.git

Accédez au répertoire Qwen1,5-4B-Chat et récupérez les fichiers Git LFS :
```
   cd Qwen1.5-4B-Chat
   git lfs pull
```

Importer le modèle dans OSS

Connectez-vous à la console OSS et notez le nom de votre bucket. Pour en créer un, consultez la rubrique Créer un bucket.
Installez et configurez ossutil. Consultez la rubrique Installer ossutil.

Créez un répertoire Qwen1.5-4B-Chat dans votre bucket OSS :

   ossutil mkdir oss://<Your-Bucket-Name>/Qwen1.5-4B-Chat

Importez les fichiers du modèle dans OSS :

   ossutil cp -r ./Qwen1.5-4B-Chat oss://<Your-Bucket-Name>/Qwen1.5-4B-Chat

Créer un PV et un PVC

Créez un PV et un PVC dans votre cluster ACK pour monter le modèle depuis OSS. Consultez la rubrique Monter un volume OSS provisionné statiquement.

Paramètres du PV :

Paramètre	Description
PV Type	OSS
Volume Name	llm-model
Access Certificate	AccessKey ID et AccessKey secret pour le bucket OSS
Bucket ID	Nom de votre bucket OSS
OSS Path	Chemin d'accès au modèle, par exemple /models/Qwen1,5-4B-Chat

Paramètres du PVC :

Paramètre	Description
PVC Type	OSS
Volume Name	llm-model
Allocation Mode	Sélectionnez Existing Volumes
Existing Volumes	Cliquez sur Existing Volumes et sélectionnez votre PV

Étape 2 : Déployer le service d'inférence

Arena traite les fichiers de modèle comme un ensemble de données. Utilisez --data pour monter le modèle dans le conteneur. Dans cet exemple, le chemin de montage est /model/Qwen1.5-4B-Chat.

Le paramètre --max-model-len définit la longueur maximale de jetons que le modèle peut traiter. Des valeurs plus élevées améliorent la qualité des interactions mais consomment davantage de mémoire GPU. Consultez le référentiel de code vLLM sur GitHub pour obtenir la liste complète des paramètres disponibles.

Choisir un type de GPU

GPU	Cas d'utilisation	max-model-len	Paramètres supplémentaires
NVIDIA A10	Production (hautes performances)	16384	Aucun
NVIDIA T4	Tests (coût réduit)	8192	`--dtype half`

Déployer le service

Choisissez une commande en fonction de votre type de GPU.

NVIDIA A10 (recommandé pour la production)

arena serve custom \
    --name=vllm-qwen-4b-chat \
    --version=v1 \
    --gpus=1 \
    --replicas=1 \
    --restful-port=8000 \
    --readiness-probe-action="tcpSocket" \
    --readiness-probe-action-option="port: 8000" \
    --readiness-probe-option="initialDelaySeconds: 30" \
    --readiness-probe-option="periodSeconds: 30" \
    --image=ac2-registry.cn-hangzhou.cr.aliyuncs.com/ac2/vllm:0.4.1-ubuntu22.04 \
    --data=llm-model:/model/Qwen1.5-4B-Chat \
    "python3 -m vllm.entrypoints.openai.api_server --trust-remote-code --model /model/Qwen1.5-4B-Chat/ --gpu-memory-utilization 0.95 --max-model-len 16384"

NVIDIA T4 (pour les tests)

arena serve custom \
    --name=vllm-qwen-4b-chat \
    --version=v1 \
    --gpus=1 \
    --replicas=1 \
    --restful-port=8000 \
    --readiness-probe-action="tcpSocket" \
    --readiness-probe-action-option="port: 8000" \
    --readiness-probe-option="initialDelaySeconds: 30" \
    --readiness-probe-option="periodSeconds: 30" \
    --image=ac2-registry.cn-hangzhou.cr.aliyuncs.com/ac2/vllm:0.4.1-ubuntu22.04 \
    --data=llm-model:/model/Qwen1.5-4B-Chat \
    "python3 -m vllm.entrypoints.openai.api_server --trust-remote-code --model /model/Qwen1.5-4B-Chat/ --gpu-memory-utilization 0.95 --max-model-len 8192 --dtype half"

Remarque

T4 utilise --max-model-len 8192 (contre 16384 pour A10) et ajoute --dtype half pour respecter les contraintes de mémoire de T4.

Paramètres Arena :

Paramètre	Description
`--name`	Nom du service d'inférence
`--version`	Version du service d'inférence
`--gpus`	Nombre de GPU par réplica
`--replicas`	Nombre de réplicas
`--restful-port`	Port du service d'inférence
`--readiness-probe-action`	Type de sonde de readiness. Valeurs valides : `HttpGet`, `Exec`, `gRPC` et `TCPSocket`
`--readiness-probe-action-option`	Méthode de connexion de la sonde de readiness
`--readiness-probe-option`	Configuration de la sonde de readiness
`--data`	Monte un PVC partagé. Format : `PVCName:MountPath`. Utilisez `arena data list` pour interroger les PVC disponibles
`--image`	Image de conteneur pour le service d'inférence

Sortie attendue :

service/vllm-qwen-4b-chat-v1 created
deployment.apps/vllm-qwen-4b-chat-v1-custom-serving created
INFO[0008] The Job vllm-qwen-4b-chat has been submitted successfully
INFO[0008] You can run `arena serve get vllm-qwen-4b-chat --type custom-serving -n default` to check the job status

Vérifier le déploiement

Vérifiez l'état du service d'inférence :

arena serve get vllm-qwen-4b-chat

Sortie attendue :

Name:       vllm-qwen-4b-chat
Namespace:  default
Type:       Custom
Version:    v1
Desired:    1
Available:  1
Age:        36m
Address:    172.16.XX.XX
Port:       RESTFUL:8000
GPU:        1

Instances:
  NAME                                                  STATUS   AGE  READY  RESTARTS  GPU  NODE
  ----                                                  ------   ---  -----  --------  ---  ----
  vllm-qwen-4b-chat-v1-custom-serving-6d7c786b9f-z6nfk  Running  36m  1/1    0         1    cn-beijing.192.168.XX.XX

Lorsque Available correspond à Desired et que l'état de l'instance est Running, le service est prêt.

Étape 3 : Tester le service d'inférence

Configurer la redirection de port

Important

La redirection de port avec kubectl port-forward est réservée au développement et au débogage. Pour la production, utilisez un Ingress.

Redirigez le port 8000 vers votre machine locale :

kubectl port-forward svc/vllm-qwen-4b-chat-v1 8000:8000

Sortie attendue :

Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000

Envoyer une requête de test

Ouvrez un nouveau terminal et envoyez une requête d'inférence :

curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json"  -d '{"model": "/model/Qwen1.5-4B-Chat/", "messages": [{"role": "user", "content": "Test"}], "max_tokens": 10, "temperature": 0.7, "top_p": 0.9, "seed": 10}'

Sortie attendue :

{"id":"cmpl-503270b21fa44db2b6b3c3e0abaa3c02","object":"chat.completion","created":1717141209,"model":"/model/Qwen1.5-4B-Chat/","choices":[{"index":0,"message":{"role":"assistant","content":"OK. What do you want to test?"},"logprobs":null,"finish_reason":"stop","stop_reason":null}],"usage":{"prompt_tokens":21,"total_tokens":30,"completion_tokens":9}}

vLLM expose une API compatible OpenAI au niveau du point de terminaison /v1/chat/completions.

(Facultatif) Nettoyer les ressources

Supprimez les ressources inutilisées pour éviter des coûts inutiles.

Supprimez le service d'inférence :

arena serve delete vllm-qwen-4b-chat

Supprimez le PVC et le PV :

kubectl delete pvc llm-model
kubectl delete pv llm-model

Étapes suivantes

Configurez un Ingress pour exposer le service d'inférence en production.
Pour déployer d'autres modèles Qwen, ajustez --max-model-len et --gpu-memory-utilization en fonction de la taille du modèle et de la mémoire GPU.
Consultez le référentiel GitHub vLLM pour connaître les options de configuration.