Container Service for Kubernetes:Deploying a Qwen3.5-2B large model inference service in ACK Auto Mode

1. Télécharger le modèle Qwen3,5-2B

Effectuez les étapes suivantes sur l'instance ECS temporaire pour télécharger les fichiers du modèle depuis ModelScope.

1. Installez Git.

   # You can run yum install git or apt install git to install it.
   sudo yum install git

2. Installez l'extension Git Large File Storage (LFS).

   # You can run yum install git-lfs or apt install git-lfs to install it.
   sudo yum install git-lfs

3. Initialisez Git LFS et clonez le dépôt Qwen3,5-2B depuis ModelScope. Cette commande ignore les fichiers volumineux LFS pour éviter les téléchargements en double.

   git lfs install
   GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/Qwen/Qwen3.5-2B.git

4. Accédez au répertoire du dépôt et récupérez les fichiers du grand modèle gérés par LFS.

   cd Qwen3.5-2B/
   git lfs pull

2. Téléverser les fichiers du modèle vers OSS

1. Créez un répertoire dans le bucket OSS pour stocker le modèle.

   Remplacez <Your-Bucket-Name> par le nom réel de votre bucket.

   ossutil mkdir oss://<Your-Bucket-Name>/models/Qwen3.5-2B

2. Téléversez les fichiers locaux du modèle vers OSS.

   ossutil cp -r ./Qwen3.5-2B oss://<Your-Bucket-Name>/models/Qwen3.5-2B

3. Configurer un volume OSS

Créez un PV et un PVC pour permettre aux pods de monter le répertoire du modèle dans OSS en tant que volume en lecture seule. Pour plus d'informations, consultez Utiliser un volume statique avec ossfs 2,0.

1. Sélectionnez une méthode d'authentification (RRSA ou AccessKey) et préparez les identifiants d'accès afin de garantir que le cluster puisse accéder de manière sécurisée aux ressources du bucket OSS.

   Cet exemple utilise l'authentification par AccessKey. Les deux méthodes diffèrent légèrement. Pour plus d'informations, consultez Utiliser un volume statique avec ossfs 2,0 .

2. Stockez votre AccessKey en tant que Secret pour le PV.

   Remplacez <yourAccessKeyID> et <yourAccessKeySecret> par vos identifiants réels. Le namespace du Secret doit correspondre au namespace de l'application.

   kubectl create -n default secret generic oss-secret --from-literal='akId=<yourAccessKeyID>' --from-literal='akSecret=<yourAccessKeySecret>'

3. Créez un PV et un PVC pour monter le répertoire du modèle dans OSS en tant que volume en lecture seule. L'exemple suivant utilise un volume statique avec ossfs 2,0.

   Exemple de code

   apiVersion: v1
   kind: PersistentVolume
   metadata:
     # PV name.
     name: llm-model  
   spec:
     capacity:
       # Volume capacity. This value is used only to match the PVC.
       storage: 30Gi  
     # Access mode.
     accessModes:  
       - ReadOnlyMany
     persistentVolumeReclaimPolicy: Retain
     csi:
       driver: ossplugin.csi.alibabacloud.com
       # Must match the PV name (metadata.name).
       volumeHandle: llm-model   
       # Use the Secret created earlier.
       nodePublishSecretRef:
         # Name of the Secret storing the AccessKey.
         name: oss-secret  
         # Namespace of the Secret.
         namespace: default  
       volumeAttributes:
         fuseType: ossfs2
         # Your bucket name.
         bucket: knative-llm  
         # Subdirectory to mount. Leave empty for the root directory.
         path: /models/Qwen3.5-2B
         # Endpoint for the region where the OSS bucket is located.
         url: "http://oss-cn-hangzhou-internal.aliyuncs.com"  
         otherOpts: "-o close_to_open=false"
   ---
   kind: PersistentVolumeClaim
   apiVersion: v1
   metadata:
     # PVC name.
     name: llm-model 
     namespace: default
   spec:
     # Must be consistent with the PV.
     accessModes:
       - ReadOnlyMany
     resources:
       requests:
         storage: 30Gi
     storageClassName: ""
     # The PV to bind.
     volumeName: llm-model

1. Créer le Deployment et le Service

Utilisez le framework vLLM pour déployer le modèle Qwen3,5-2B en tant que Deployment et l'exposer via un Service LoadBalancer.

1. Sur la page Clusters ACK, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Deployments.

2. Cliquez sur Create from YAML et soumettez le contenu YAML suivant.

   Après avoir soumis le YAML, si le cluster ne dispose pas de suffisamment de ressources GPU, le pod passera à l'état Pending . Le mode automatique ACK déclenche automatiquement la mise à l'échelle des nœuds GPU, crée de nouveaux nœuds et planifie le pod sur un nouveau nœud une fois celui-ci initialisé. Aucune intervention manuelle n'est requise. Lorsque le pod passe à l'état Running , le service de modèle est déployé.

   Exemple de code

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: qwen-2b
     labels:
       app: qwen
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: qwen
     template:
       metadata:
         labels:
           app: qwen
       spec:
         containers:
         - command:
           - vllm
           - serve
           - /models/Qwen3.5-2B       
           - --served-model-name
           - Qwen3.5-2B
           - --port
           - "8000"                 
           - --enforce-eager
           image: ac2-mirror-registry.cn-hangzhou.cr.aliyuncs.com/evaluate/vllm-openai:nightly-d00df624f313a6a5a7a6245b71448b068b080cd7
           imagePullPolicy: IfNotPresent
           name: vllm-container
           ports:
           - containerPort: 8000
             name: http1
             protocol: TCP
           readinessProbe:
             tcpSocket:
               port: 8000
             initialDelaySeconds: 5
             periodSeconds: 5
           resources:
             limits:
               cpu: "32"
               memory: 64Gi
               # Maximum number of GPUs.
               nvidia.com/gpu: "1"
             requests:
               cpu: "8"
               memory: 32Gi
               # Each pod requests 1 GPU, consistent with limits.
               nvidia.com/gpu: "1"
           volumeMounts:
           # Must match the model path in the command.
           - mountPath: /models/Qwen3.5-2B
             name: llm-model
         volumes:
         - name: llm-model
           persistentVolumeClaim:
             claimName: llm-model
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: qwen-2b
   spec:
     type: LoadBalancer
     ports:
       # The exposed port. Must match containerPort.
       - port: 8000
         protocol: TCP
         targetPort: 8000
     selector:
       app: qwen

   Une fois le déploiement terminé, vous pouvez consulter l'état de l'application sur la page Deployments.

2. Vérifier le service d'inférence

1. Récupérez l'adresse IP publique exposée par le Service.

   export EXTERNAL_IP=$(kubectl get svc qwen-2b -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo ${EXTERNAL_IP}

2. Envoyez une requête d'inférence pour vérifier que le service est disponible.

   Remplacez 8.XX.XX.89 par votre adresse IP publique.

   curl http://8.XX.XX.89:8000/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{
       "model": "Qwen3.5-2B",
       "messages": [
         {
           "role": "user",
           "content": [
             {
               "type": "text",
               "text": "Kubernetes"
             }
           ]
         }
       ],
       "max_tokens": 200
     }'

   Sortie attendue :

   {"id":"chatcmpl-98f158cdbbb38087","object":"chat.completion","created":1775043962,"model":"Qwen3.5-2B","choices":[{"index":0,"message":{"role":"assistant","content":"**Kubernetes** is an open-source container orchestration platform that automates deployment, scaling, management, and repair of containerized applications..."},"finish_reason":"length"}],"usage":{"prompt_tokens":14,"total_tokens":214,"completion_tokens":200}}