Best practices for deploying the DeepSeek full version across multiple nodes in ACK - Container Service for Kubernetes

Cette rubrique décrit les bonnes pratiques pour déployer le modèle DeepSeek version complète sur plusieurs nœuds dans Alibaba Cloud Container Service for Kubernetes (ACK) afin d'obtenir des performances, une évolutivité et une fiabilité optimales.

Contexte

Présentation de DeepSeek

DeepSeek est une série de grands modèles de langage développés par DeepSeek. Les modèles de la version complète de DeepSeek prennent en charge à la fois les modes de réflexion hybride et de réflexion exclusive, offrant des capacités de raisonnement avancées pour les tâches complexes. Ces modèles sont particulièrement adaptés aux scénarios nécessitant une analyse approfondie et une résolution de problèmes complexe.

Les modèles DeepSeek pris en charge incluent :

Modèles à réflexion hybride (désactivés par défaut) : deepseek-v3.2, deepseek-v3.2-exp, deepseek-v3.1
Modèles à réflexion exclusive : deepseek-r1, deepseek-r1-0528, modèles distillés deepseek-r1

Remarque : Les modèles DeepSeek sont actuellement disponibles uniquement dans la région de Pékin.

Avantages du déploiement distribué avec ACK

Le déploiement des modèles DeepSeek sur plusieurs nœuds dans ACK offre plusieurs avantages :

Évolutivité : Ajustez dynamiquement les ressources de calcul en fonction de la charge de travail.
Haute disponibilité : Répartissez les charges de travail sur plusieurs nœuds pour éliminer les points de défaillance uniques.
Optimisation des ressources : Utilisez efficacement les ressources GPU à travers le cluster.
Performances : Réduisez la latence grâce à l'équilibrage de charge intelligent et à la planification de proximité.

Prérequis

Créez un cluster géré ACK (édition Pro) avec des nœuds GPU. La version Kubernetes du cluster doit être 1,22 ou ultérieure.

Assurez-vous que votre cluster contient des nœuds équipés de GPU NVIDIA compatibles (recommandé : A10, V100 ou A100). Utilisez la version 525 du pilote NVIDIA pour des performances optimales.
Vérifiez que vous disposez des autorisations suffisantes pour créer et gérer les ressources Kubernetes, y compris les déploiements, les services et les volumes persistants.
Configurez Object Storage Service (OSS) pour le stockage et la mise en cache des modèles. Créez un compartiment (bucket) pour stocker les poids du modèle et les fichiers de configuration.
Définissez des politiques réseau et des groupes de sécurité appropriés pour autoriser la communication entre les nœuds et l'accès externe au service d'inférence.

Principes de conception de l'architecture

Stratégie de déploiement multi-nœuds

Lors du déploiement des modèles DeepSeek sur plusieurs nœuds, prenez en compte les approches architecturales suivantes :

Approche Horizontal Pod Autoscaler (HPA)

Déployez plusieurs réplicas du service d'inférence DeepSeek sur différents nœuds, permettant à Kubernetes de mettre automatiquement à l'échelle les ressources en fonction du CPU, de la mémoire ou de métriques personnalisées.

Affinité et anti-affinité des nœuds

Utilisez des règles d'affinité de nœud pour assurer une distribution optimale des pods DeepSeek sur différents nœuds et zones de disponibilité :

affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: NotIn
          values:
          - node-1
          - node-2
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
    - weight: 100
      podAffinityTerm:
        labelSelector:
          matchLabels:
            app: deepseek-inference
        topologyKey: kubernetes.io/hostname

Gestion des ressources

Configurez les demandes et limites de ressources appropriées pour les pods DeepSeek :

resources:
  requests:
    cpu: "4"
    memory: "16Gi"
    nvidia.com/gpu: "1"
  limits:
    cpu: "8"
    memory: "32Gi"
    nvidia.com/gpu: "1"

Étapes de déploiement

Étape 1 : Préparer le modèle DeepSeek

Téléchargez les fichiers du modèle DeepSeek vers votre compartiment OSS :

#!/bin/bash
# Download DeepSeek model from ModelScope
git lfs install
git clone https://www.modelscope.cn/deepseek-ai/DeepSeek-V3.2.git /tmp/deepseek-v3.2
# Upload to OSS
ossutil cp -r /tmp/deepseek-v3.2 oss://your-bucket/models/deepseek-v3.2/

Optimisez le modèle pour l'inférence à l'aide de TensorRT-LLM (optionnel mais recommandé pour de meilleures performances) :

cd /workspace/tensorrt_llm/examples/deepseek
python convert_checkpoint.py \
  --model_dir /models/deepseek-v3.2 \
  --output_dir /models/deepseek-v3.2-trtllm \
  --dtype float16

Étape 2 : Configurer le stockage et la mise en cache

Créez un Dataset Fluid pour un chargement efficace du modèle :

apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: deepseek-models
spec:
  mounts:
  - mountPoint: oss://your-bucket/models/
    name: models
    path: /
    options:
      fs.oss.endpoint: oss-cn-beijing.aliyuncs.com
    encryptOptions:
      - name: fs.oss.accessKeyId
        valueFrom:
          secretKeyRef:
            name: oss-secret
            key: accessKeyId
      - name: fs.oss.accessKeySecret
        valueFrom:
          secretKeyRef:
            name: oss-secret
            key: accessKeySecret

Configurez JindoRuntime pour la mise en cache :

apiVersion: data.fluid.io/v1alpha1
kind: JindoRuntime
metadata:
  name: deepseek-models
spec:
  replicas: 3
  tieredstore:
    levels:
      - mediumtype: MEM
        volumeType: emptyDir
        path: /dev/shm
        quota: 50Gi
        high: "0.95"
        low: "0.7"

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

Créez un déploiement Kubernetes avec plusieurs réplicas :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deepseek-inference
spec:
  replicas: 3
  selector:
    matchLabels:
      app: deepseek-inference
  template:
    metadata:
      labels:
        app: deepseek-inference
    spec:
      containers:
      - name: deepseek-server
        image: registry.cn-beijing.aliyuncs.com/your-registry/deepseek-inference:latest
        ports:
        - containerPort: 8000
        env:
        - name: MODEL_PATH
          value: "/models/deepseek-v3.2"
        - name: ENABLE_THINKING
          value: "true"
        resources:
          requests:
            cpu: "4"
            memory: "16Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "8"
            memory: "32Gi"
            nvidia.com/gpu: "1"
        volumeMounts:
        - name: model-storage
          mountPath: /models
      volumes:
      - name: model-storage
        persistentVolumeClaim:
          claimName: deepseek-models
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchLabels:
                  app: deepseek-inference
              topologyKey: kubernetes.io/hostname

Créez un service d'équilibrage de charge :

apiVersion: v1
kind: Service
metadata:
  name: deepseek-inference-service
spec:
  selector:
    app: deepseek-inference
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000
  type: LoadBalancer

Étape 4 : Configurer la mise à l'échelle automatique

Configurez Horizontal Pod Autoscaler :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: deepseek-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: deepseek-inference
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Définissez des métriques personnalisées pour l'utilisation du GPU (optionnel) :

# Custom metric for GPU utilization
- type: Pods
  pods:
    metric:
      name: gpu_utilization
    target:
      type: AverageValue
      averageValue: "75"

Surveillance et optimisation

Configuration de la surveillance

Mettez en œuvre une surveillance complète pour votre déploiement DeepSeek :

Métriques Prometheus pour l'utilisation du CPU, de la mémoire et du GPU.
Tableaux de bord Grafana pour la visualisation en temps réel.
Journalisation centralisée avec Fluentd ou Logstash.
Traçage distribué avec Jaeger pour l'analyse du flux de requêtes.

Techniques d'optimisation des performances

Appliquez ces stratégies d'optimisation pour améliorer les performances :

Regroupement des requêtes (Batching)

Configurez le regroupement par lots pour améliorer le débit :

env:
- name: MAX_BATCH_SIZE
  value: "8"
- name: BATCH_TIMEOUT_MS
  value: "100"

Stratégies de mise en cache des modèles

Utilisez la mise en cache à plusieurs niveaux pour réduire le temps de chargement du modèle :

Mise en cache basée sur la RAM pour les parties du modèle fréquemment consultées.
Mise en cache sur SSD NVMe pour les composants de modèle plus volumineux.
Redis ou Memcached pour le partage entre nœuds.

Pool de connexions

Implémentez un pool de connexions pour réduire la surcharge :

env:
- name: CONNECTION_POOL_SIZE
  value: "50"
- name: KEEP_ALIVE_TIMEOUT
  value: "300"

Bonnes pratiques

Planification des ressources

Allocation GPU : Allouez des GPU dédiés par instance DeepSeek pour éviter la contention des ressources.
Dimensionnement de la mémoire : Réservez au moins 2 fois la taille du modèle en RAM pour des performances optimales.
Cœurs CPU : Allouez 4 à 8 cœurs CPU par instance GPU pour les tâches de prétraitement.

Stratégies de mise à l'échelle

Mise à l'échelle progressive : Augmentez l'échelle progressivement en fonction des modèles de charge réels plutôt que des estimations de pic.
Distribution par zone : Répartissez les réplicas sur plusieurs zones de disponibilité pour la tolérance aux pannes.
Périodes de chauffe : Implémentez une augmentation progressive du trafic lors des événements de mise à l'échelle.

Optimisation des coûts

Instances Spot : Utilisez des instances spot pour les charges de travail d'inférence non critiques.
Limites de mise à l'échelle automatique : Définissez des limites minimales/maximales appropriées pour équilibrer les performances et les coûts.
Arrêt en cas d'inactivité : Implémentez un arrêt automatique pendant les périodes de faible utilisation.

Considérations de sécurité

Politiques réseau : Restreignez la communication pod-à-pod à l'aide des politiques réseau Kubernetes.
Chiffrement TLS : Activez TLS pour toutes les communications externes.
RBAC : Implémentez le contrôle d'accès basé sur les rôles pour les ressources du cluster.
Gestion des secrets : Utilisez les Secrets Kubernetes ou des coffres-forts externes pour la gestion des identifiants.

Dépannage

Problèmes courants et solutions

Erreurs de mémoire GPU insuffisante

Symptômes : Erreurs CUDA « out of memory » pendant l'inférence.

Solutions :

Réduisez la taille du lot.
Augmentez l'allocation de mémoire GPU.
Activez la quantification du modèle.
Utilisez le parallélisme de modèle sur plusieurs GPU.

Performances d'inférence lentes

Symptômes : Latence élevée et temps de réponse lents.

Solutions :

Vérifiez les métriques d'utilisation du GPU.
Optimisez le modèle avec TensorRT-LLM.
Implémentez le regroupement des requêtes.
Examinez la connectivité réseau entre les nœuds.

Problèmes de mise à l'échelle automatique

Symptômes : Échec du démarrage ou de la mise à l'échelle des pods.

Solutions :

Vérifiez les quotas et les limites de ressources.
Contrôlez la disponibilité des ressources des nœuds.
Examinez les règles d'affinité et d'anti-affinité.
Surveillez les journaux du Cluster Autoscaler.

Commandes de diagnostic

Commandes utiles pour le dépannage :

# Check pod status and resource usage
kubectl top pods -l app=deepseek-inference

# View detailed pod information
kubectl describe pod -l app=deepseek-inference

# Check GPU utilization
kubectl exec -it <pod-name> -- nvidia-smi

# Monitor logs
kubectl logs -f -l app=deepseek-inference --tail=100

# Check HPA status
kubectl get hpa deepseek-hpa

# Verify service endpoints
kubectl get endpoints deepseek-inference-service

Contexte

Présentation de DeepSeek

Avantages du déploiement distribué avec ACK

Prérequis

Principes de conception de l'architecture

Stratégie de déploiement multi-nœuds

Approche Horizontal Pod Autoscaler (HPA)

Affinité et anti-affinité des nœuds

Gestion des ressources

Étapes de déploiement

Étape 1 : Préparer le modèle DeepSeek

Étape 2 : Configurer le stockage et la mise en cache

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

Étape 4 : Configurer la mise à l'échelle automatique

Surveillance et optimisation

Configuration de la surveillance

Techniques d'optimisation des performances

Regroupement des requêtes (Batching)

Stratégies de mise en cache des modèles

Pool de connexions

Bonnes pratiques

Planification des ressources

Stratégies de mise à l'échelle

Optimisation des coûts

Considérations de sécurité

Dépannage

Problèmes courants et solutions

Erreurs de mémoire GPU insuffisante

Performances d'inférence lentes

Problèmes de mise à l'échelle automatique

Commandes de diagnostic

Rubriques connexes