Tous les produits
Search
Centre de documentation

Container Service for Kubernetes:Deploy a DeepSeek distilled model inference service on ACK

Dernière mise à jour :Aug 11, 2026

Déployez un service d'inférence prêt pour la production basé sur un modèle distillé DeepSeek sur ACK avec KServe.

Contexte

Modèle DeepSeek-R1

DeepSeek-R1 est le premier modèle d'inférence de DeepSeek. Il améliore le raisonnement des grands modèles de langage (LLM) grâce à un apprentissage par renforcement à grande échelle. Il offre d'excellentes performances dans des tâches telles que le raisonnement mathématique et les compétitions de programmation, égalant ou surpassant la série OpenAI-O1 sur certains benchmarks. Il excelle également dans les tâches reposant sur des connaissances, ainsi que dans d'autres domaines comme l'écriture créative et les questions-réponses générales. DeepSeek distille ce raisonnement dans des modèles plus petits, tels que Qwen et Llama, via un fine-tuning. Le modèle distillé de 14 milliards de paramètres surpasse QwQ-32B, tandis que les modèles de 32 et 70 milliards établissent de nouveaux records. Consultez le dépôt GitHub de DeepSeek AI.

KServe

KServe est une plateforme open source et cloud native dédiée au déploiement et à l'exécution de modèles d'apprentissage automatique sur Kubernetes. Elle prend en charge plusieurs frameworks, propose la mise à l'échelle automatique et utilise une API YAML déclarative pour le déploiement des modèles. Consultez KServe.

Arena

Arena est une solution légère basée sur Kubernetes pour l'apprentissage automatique. Elle couvre l'intégralité du cycle de vie, incluant la préparation des données, le développement de modèles, l'entraînement et la prédiction. Arena s'intègre aux services Alibaba Cloud, prend en charge le partage de GPU et CPFS, et exécute des frameworks d'apprentissage profond optimisés pour Alibaba Cloud afin de maximiser les performances de calcul hétérogène et la rentabilité. Consultez le dépôt GitHub Arena.

Prérequis

Spécifications GPU et coûts

Les paramètres du modèle consomment la majeure partie de la mémoire GPU lors de l'inférence. Calculez la mémoire GPU requise :

显存 = 模型参数量 * 精度数据类型字节数

Pour un modèle de 7 milliards de paramètres avec une précision par défaut FP16 : 7 milliards de paramètres à 2 octets chacun (virgule flottante 16 bits / 8 bits par octet).

显存 = 7 * 10^9 * 2字节 \approx 13.04GiB

Outre le chargement du modèle, prenez en compte le KV Cache et l'utilisation du GPU. Avec une marge typique, utilisez une instance accélérée par GPU disposant de 24 GiB de mémoire GPU, telle que ecs.gn7i-c8g1.2xlarge ou ecs.gn7i-c16g1.4xlarge. Consultez la famille d'instances optimisées pour le calcul accéléré par GPU et la facturation des serveurs cloud accélérés par GPU.

Déployer le modèle

Étape 1 : Préparer les fichiers du modèle DeepSeek-R1-Distill-Qwen-7B

  1. Téléchargez le modèle DeepSeek-R1-Distill-Qwen-7B depuis ModelScope.

    Remarque

    Git Large File Storage (LFS) doit être installé. Exécutez yum install git-lfs ou apt-get install git-lfs. Consultez Install Git Large File Storage.

    git lfs install
    GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.git
    cd DeepSeek-R1-Distill-Qwen-7B/
    git lfs pull
  2. Créez un répertoire dans OSS et téléversez les fichiers du modèle.

    Remarque

    Consultez Installer ossutil.

    ossutil mkdir oss://<your-bucket-name>/models/DeepSeek-R1-Distill-Qwen-7B
    ossutil cp -r ./DeepSeek-R1-Distill-Qwen-7B oss://<your-bucket-name>/models/DeepSeek-R1-Distill-Qwen-7B
  3. Créez un volume persistant (PV) et une revendication de volume persistant (PVC) nommés llm-model pour le cluster cible. Consultez Utiliser des volumes ossfs 1.0 provisionnés statiquement.

    Console

    Exemple de configuration PV :

    Paramètre

    Description

    Type de PV

    OSS

    Nom

    llm-model

    Certificat d'accès

    L'AccessKey ID et l'AccessKey secret pour l'accès à OSS.

    ID du bucket

    Le bucket OSS de l'étape précédente.

    Chemin OSS

    Le chemin de stockage du modèle, par exemple /models/DeepSeek-R1-Distill-Qwen-7B.

    Exemple de configuration PVC :

    Paramètre

    Description

    Type de PVC

    OSS

    Nom

    llm-model

    Mode d'allocation

    Sélectionnez un PV existant

    Volumes existants

    Sélectionnez le PV créé ci-dessus.

    kubectl

    Exemple de fichier YAML :

    apiVersion: v1
    kind: Secret
    metadata:
      name: oss-secret
    stringData:
      akId: <your-oss-ak> # Your AccessKey ID for accessing OSS.
      akSecret: <your-oss-sk> # Your AccessKey secret for accessing OSS.
    ---
    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: llm-model
      labels:
        alicloud-pvname: llm-model
    spec:
      capacity:
        storage: 30Gi 
      accessModes:
        - ReadOnlyMany
      persistentVolumeReclaimPolicy: Retain
      csi:
        driver: ossplugin.csi.alibabacloud.com
        volumeHandle: llm-model
        nodePublishSecretRef:
          name: oss-secret
          namespace: default
        volumeAttributes:
          bucket: <your-bucket-name> # The name of your bucket.
          url: <your-bucket-endpoint> # The endpoint, such as oss-cn-hangzhou-internal.aliyuncs.com.
          otherOpts: "-o umask=022 -o max_stat_cache_size=0 -o allow_other"
          path: <your-model-path> # In this example, the path is /models/DeepSeek-R1-Distill-Qwen-7B/.
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: llm-model
    spec:
      accessModes:
        - ReadOnlyMany
      resources:
        requests:
          storage: 30Gi
      selector:
        matchLabels:
          alicloud-pvname: llm-model

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

  1. Démarrez le service d'inférence nommé deepseek.

    arena serve kserve \
        --name=deepseek \
        --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:v0.6.6 \
        --gpus=1 \
        --cpu=4 \
        --memory=12Gi \
        --data=llm-model:/models/DeepSeek-R1-Distill-Qwen-7B \
        "vllm serve /models/DeepSeek-R1-Distill-Qwen-7B --port 8080 --trust-remote-code --served-model-name deepseek-r1 --max-model-len 32768 --gpu-memory-utilization 0.95 --enforce-eager"

    Paramètres :

    Paramètre

    Obligatoire

    Description

    --name

    Oui

    Nom du service d'inférence. Doit être unique globalement.

    --image

    Oui

    Image du service d'inférence.

    --gpus

    Non

    Nombre de GPU. Valeur par défaut : 0.

    --cpu

    Non

    Nombre de CPU.

    --memory

    Non

    Taille de la mémoire.

    --data

    Non

    Chemin de l'artefact du modèle. Dans cet exemple, le PV llm-model de l'étape précédente, monté sur /models/ dans le conteneur.

    Sortie attendue :

    inferenceservice.serving.kserve.io/deepseek created
    INFO[0003] The Job deepseek has been submitted successfully
    INFO[0003] You can run `arena serve get deepseek --type kserve -n default` to check the job status

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

  1. Vérifiez l'état du déploiement du service d'inférence KServe.

    arena serve get deepseek

    Sortie attendue :

    Name:       deepseek
    Namespace:  default
    Type:       KServe
    Version:    1
    Desired:    1
    Available:  1
    Age:        3m
    Address:    http://deepseek-default.example.com
    Port:       :80
    GPU:        1
    Instances:
      NAME                                 STATUS   AGE  READY  RESTARTS  GPU  NODE
      ----                                 ------   ---  -----  --------  ---  ----
      deepseek-predictor-7cd4d568fd-fznfg  Running  3m   1/1    0         1    cn-beijing.172.16.1.77

    La sortie confirme que le service d'inférence est déployé.

  2. Envoyez une requête au service d'inférence via l'adresse IP de la passerelle NGINX Ingress.

    # Get the IP address of the NGINX Ingress.
    NGINX_INGRESS_IP=$(kubectl -n kube-system get svc nginx-ingress-lb -ojsonpath='{.status.loadBalancer.ingress[0].ip}')
    # Get the hostname of the inference service.
    SERVICE_HOSTNAME=$(kubectl get inferenceservice deepseek -o jsonpath='{.status.url}' | cut -d "/" -f 3)
    # Send a request to the inference service.
    curl -H "Host: $SERVICE_HOSTNAME" -H "Content-Type: application/json" http://$NGINX_INGRESS_IP:80/v1/chat/completions -d '{"model": "deepseek-r1", "messages": [{"role": "user", "content": "Say this is a test!"}], "max_tokens": 512, "temperature": 0.7, "top_p": 0.9, "seed": 10}'

    Sortie attendue :

    {"id":"chatcmpl-0fe3044126252c994d470e84807d4a0a","object":"chat.completion","created":1738828016,"model":"deepseek-r1","choices":[{"index":0,"message":{"role":"assistant","content":"<think>\n\n</think>\n\nIt seems like you're testing or sharing some information. How can I assist you further? If you have any questions or need help with something, feel free to ask!","tool_calls":[]},"logprobs":null,"finish_reason":"stop","stop_reason":null}],"usage":{"prompt_tokens":9,"total_tokens":48,"completion_tokens":39,"prompt_tokens_details":null},"prompt_logprobs":null}

Observabilité

En production, l'observabilité des services d'inférence LLM est essentielle pour détecter et localiser rapidement les pannes. vLLM fournit des métriques d'inférence. Consultez la documentation sur les métriques. KServe propose également des métriques de santé des services. Les deux sont intégrés à Arena : ajoutez --enable-prometheus=true lors de la soumission de l'application.

arena serve kserve \
    --name=deepseek \
    --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:v0.6.6 \
    --gpus=1 \
    --cpu=4 \
    --memory=12Gi \
    --enable-prometheus=true \
    --data=llm-model:/models/DeepSeek-R1-Distill-Qwen-7B \
    "vllm serve /models/DeepSeek-R1-Distill-Qwen-7B --port 8080 --trust-remote-code --served-model-name deepseek-r1 --max-model-len 32768 --gpu-memory-utilization 0.95 --enforce-eager"

Surveillez le service d'inférence déployé avec vLLM à l'aide d'un tableau de bord Grafana. Obtenez le JSON officiel du tableau de bord vLLM depuis le site web officiel de vLLM et importez-le dans Grafana. Pour plus d'informations, consultez Exporter et importer des tableaux de bord. Après configuration :

image

Importer un tableau de bord Grafana

Importer le tableau de bord

  1. Connectez-vous à la console ARMS.

  2. Dans le volet de navigation de gauche, cliquez sur Integration Management.

  3. Dans l'onglet integrated environments, sélectionnez container environment, recherchez par nom de cluster ACK et cliquez sur l'environnement cible.

  4. Dans l'onglet Component Management, copiez et enregistrez l'Cluster ID, puis cliquez sur Dashboard Directory.

    Le nom du répertoire du tableau de bord contient l'ID de cluster correspondant.

  5. À droite de l'onglet Dashboards , cliquez sur Import .

  6. Copiez le contenu de grafana.json, collez-le dans la zone de texte Import via panel json et cliquez sur Load.

    Remarque

    Vous pouvez également importer le tableau de bord en téléchargeant le fichier JSON.

  7. Conservez les paramètres par défaut et cliquez sur Import.

Vérifier les données du tableau de bord

  1. Recherchez la source de données par ID de cluster enregistré ou par ID d'instance Prometheus, puis sélectionnez-la.

    image

  2. Envoyez des requêtes pour accéder au service d'inférence afin de simuler le trafic. Vérifiez que des métriques telles que Token Throughput apparaissent sur le tableau de bord.

    image

Mise à l'échelle automatique

KServe gère les charges de travail fluctuantes via le Horizontal Pod Autoscaler (HPA) de Kubernetes et l'adaptateur ack-alibaba-cloud-metrics-adapter d'ACK, en mettant à l'échelle les pods de service de modèle en fonction du CPU, de la mémoire, de l'utilisation du GPU ou de métriques personnalisées. Consultez Configurer la mise à l'échelle automatique pour un service.

Accélération des modèles

Le téléchargement d'artefacts de modèles volumineux depuis des services de stockage tels qu'OSS et NAS peut entraîner de longs délais et des démarrages à froid. Utilisez Fluid pour accélérer le chargement des modèles et optimiser les performances d'inférence des services basés sur KServe. Consultez Utiliser Fluid pour l'accélération des modèles.

Déploiement canari

ACK prend en charge des stratégies de déploiement canari, telles que la répartition du trafic par pourcentage et le routage basé sur les en-têtes, afin de réduire les risques de déploiement. Consultez Implémenter des déploiements canaris pour les services d'inférence.

Inférence avec partage de GPU

Le modèle DeepSeek-R1-Distill-Qwen-7B ne nécessite que 14 Go de mémoire GPU. Sur des instances dotées de GPU plus puissants, l'inférence avec partage de GPU permet de partitionner un seul GPU pour plusieurs services d'inférence, améliorant ainsi l'utilisation. Consultez Déployer des services d'inférence avec partage de GPU.

Références