Container Compute Service:Deploy a DeepSeek-R1 model inference service with ACS GPU

ACS fournit des ressources de calcul GPU serverless facturées au paiement à l'utilisation, ce qui élimine la gestion des nœuds GPU. Ce guide explique comment déployer sur ACS un service d'inférence prêt pour la production, basé sur le modèle complet DeepSeek-R1, en utilisant vLLM et l'accélération RDMA.

Contexte

Modèle DeepSeek-R1

DeepSeek-R1 est le modèle de raisonnement de première génération de DeepSeek, entraîné par apprentissage par renforcement à grande échelle. Il surpasse non seulement les autres modèles propriétaires, mais égale ou dépasse également OpenAI-O1 dans les benchmarks de raisonnement mathématique et de programmation. DeepSeek-R1 obtient aussi d'excellents résultats dans les tâches fondées sur les connaissances ainsi que dans d'autres domaines, tels que la rédaction créative et les questions-réponses générales. Consultez le référentiel GitHub DeepSeek AI pour plus de détails.

vLLM

vLLM est un framework d'inférence LLM performant et simple d'utilisation, compatible avec les modèles populaires tels que Qwen. Il accélère l'inférence grâce à PagedAttention, au traitement par lots continu et à la quantification des modèles. Reportez-vous au référentiel GitHub vLLM pour en savoir plus.

ACS

ACS est un service de conteneurs serverless basé sur Kubernetes qui fournit des capacités de calcul généralistes et GPU sans nécessiter la gestion des nœuds ni des clusters. L'intégration native de l'ordonnancement, du runtime de conteneurs, du stockage et du réseau réduit la complexité opérationnelle, tandis que la facturation au paiement à l'utilisation et la mise à l'échelle élastique permettent de maîtriser les coûts. Pour l'inférence LLM, les fonctionnalités d'accélération des données et des images d'ACS optimisent davantage le temps de démarrage des modèles et l'utilisation des ressources.

Prérequis

Avant de commencer, assurez-vous d'avoir réalisé les étapes suivantes :

1. Créez un cluster ACS avec le rôle de service par défaut attribué. Voir Créer un cluster ACS.

2. Configurez kubectl pour vous connecter à votre cluster ACS. Voir Se connecter à un cluster avec kubectl.

Spécifications des instances GPU et estimation des coûts

Le déploiement du modèle complet DeepSeek-R1 sur ACS nécessite 16 heures GPU sans accélération. Configuration recommandée pour une instance unique :

Pour choisir les spécifications d'instance appropriées, consultez GPU. Concernant la tarification, reportez-vous à Vue d'ensemble de la facturation.

Étape 1 : Préparer les fichiers du modèle DeepSeek-R1-GPTQ-INT8

Les LLM requièrent un espace disque important. Utilisez des volumes de stockage NAS ou OSS pour conserver les modèles de manière persistante. Les étapes ci-dessous prennent OSS comme exemple.

Remarque : Ouvrez un ticket pour obtenir les fichiers du modèle ainsi que la configuration de déploiement YAML, comprenant :

• Fichiers du modèle : DeepSeek-R1-GPTQ-INT8

• Modèle GPU : Remplacez le libellé alibabacloud.com/gpu-model-series par le modèle GPU effectivement pris en charge par ACS

• Image de base : Remplacez l'image de conteneur par l'adresse réelle de l'image

• Secret d'extraction d'image : Créez un Secret et remplacez le nom imagePullSecrets par le nom réel du Secret

(Facultatif) Charger le modèle vers OSS

Si vous avez téléchargé les fichiers du modèle localement, créez un répertoire dans OSS et chargez-y le modèle :

ossutil mkdir oss://<your-bucket-name>/models/DeepSeek-R1-GPTQ-INT8
ossutil cp -r /mnt/models/DeepSeek-R1-GPTQ-INT8 oss://<your-bucket-name>/models/DeepSeek-R1-GPTQ-INT8

Installer ossutil.

Étape 2 : Déployer le modèle avec ACS GPU

Déployez le service d'inférence DeepSeek-R1-GPTQ-INT8 via vLLM avec accélération RDMA. Ce service expose une API compatible OpenAI.

Remarque :

• Le paramètre max-model-len définit la longueur maximale des tokens. Des valeurs élevées améliorent la qualité des conversations, mais consomment davantage de mémoire GPU. Pour DeepSeek-R1-GPTQ-INT8, le maximum recommandé avoisine 128 000 tokens.

• RDMA (Remote Direct Memory Access) offre un réseau sans copie et sans passage par le noyau, garantissant une latence réduite, un débit supérieur et une consommation CPU moindre par rapport à TCP/IP. Ajoutez le libellé alibabacloud.com/hpn-type: rdma pour activer cette fonctionnalité. Ouvrez un ticket afin de confirmer la prise en charge de RDMA pour votre modèle GPU.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deepseek-r1
  namespace: default
  labels:
    app: deepseek-r1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: deepseek-r1
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
  template:
    metadata:
      labels:
        app: deepseek-r1
        alibabacloud.com/compute-class: gpu
        alibabacloud.com/gpu-model-series: <example-model>
        alibabacloud.com/hpn-type: "rdma"
    spec:
      imagePullSecrets:
        - name: <your-secret-name>
      containers:
        - name: llm-ds-r1
          image: <your-image-address>
          imagePullPolicy: IfNotPresent
          command:
            - sh
            - -c
            - "vllm serve /data/DeepSeek-R1-GPTQ-INT8 --port 8000 --trust-remote-code --served-model-name ds --max-model-len 128000 --quantization moe_wna16 --gpu-memory-utilization 0.98 --tensor-parallel-size 16"
          resources:
            limits:
              alibabacloud.com/gpu: "16"
              cpu: "64"
              memory: 512Gi
            requests:
              alibabacloud.com/gpu: "16"
              cpu: "64"
              memory: 512Gi
          volumeMounts:
            - name: llm-model
              mountPath: /data/DeepSeek-R1-GPTQ-INT8
            - name: shm
              mountPath: /dev/shm
      restartPolicy: Always
      terminationGracePeriodSeconds: 30
      volumes:
        - name: llm-model
          persistentVolumeClaim:
            claimName: llm-model
        - name: shm
          emptyDir:
            medium: Memory
            sizeLimit: 32Gi
---
apiVersion: v1
kind: Service
metadata:
  name: deepseek-r1
spec:
  type: ClusterIP
  selector:
    app: deepseek-r1
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Appliquez la configuration :

kubectl apply -f deepseek-r1-deployment.yaml

Étape 3 : Vérifier le service d'inférence

1. Configurez la redirection de port vers le service d'inférence :

   kubectl port-forward svc/deepseek-r1 8000:8000

   Sortie attendue :

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

   Important : La redirection de port kubectl convient uniquement au développement et au débogage. Elle n'offre pas la fiabilité, la sécurité ni l'évolutivité requises en production. Pour les environnements de production, consultez Premiers pas avec ALB Ingress.

2. Envoyez une requête d'inférence de test :

   curl http://localhost:8000/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{
       "model": "ds",
       "messages": [
         {
           "role": "user",
           "content": "Explain the concept of reinforcement learning in simple terms."
         }
       ],
       "max_tokens": 1024,
       "temperature": 0.7,
       "top_p": 0.9,
       "seed": 10
     }'

   Une réponse réussie confirme que le service fonctionne correctement.

Résultat

Vous avez déployé un service d'inférence basé sur le modèle complet DeepSeek-R1 sur ACS avec accélération GPU. Le service expose une API compatible OpenAI, prête à être intégrée à vos applications.