Bonnes pratiques GPU pour Azure Kubernetes Service (AKS)

L'exécution de charges de travail GPU sur un cluster AKS nécessite une configuration appropriée et une validation continue pour garantir que les ressources de calcul sont accessibles, sécurisées et utilisées de manière optimale. Cet article décrit les meilleures pratiques pour la gestion des nœuds compatibles GPU, la validation des configurations et la réduction des interruptions de charge de travail à l'aide de commandes de diagnostic spécifiques au fournisseur.

Les charges de travail GPU, telles que la formation de modèles d'IA, l'inférence en temps réel, les simulations et le traitement vidéo, dépendent souvent des configurations suivantes :

• Pilote GPU correct et compatibilité d'exécution.
• Planification précise des ressources GPU.
• Accès aux périphériques matériels GPU à l'intérieur des conteneurs.

Des erreurs de configuration peuvent entraîner des coûts élevés, des échecs de tâches inattendus ou une sous-utilisation du GPU.

Appliquer le placement de la charge de travail du GPU

Par défaut, le planificateur AKS place les pods sur n'importe quel nœud disponible avec suffisamment de CPU et de mémoire. Sans conseils, cela peut conduire à deux problèmes majeurs :

1. Les charges de travail GPU peuvent être planifiées sur des nœuds sans GPU et ne pas démarrer, ou
2. Les charges de travail à usage général peuvent occuper des nœuds GPU, gaspillant ainsi des ressources coûteuses.

Pour garantir un placement correct :

• Corromprez vos nœuds GPU à l’aide d’une clé telle que [gpu-vendor].com/gpu: NoSchedule (par exemple, nvidia.com/gpu : NoSchedule). Cela empêche les charges de travail non GPU d'y être planifiées.
• Ajoutez une tolérance correspondante dans la spécification de votre pod de charge de travail GPU afin qu'elle puisse être planifiée sur les nœuds GPU contaminés.
• Définissez les requêtes et les limites de ressources GPU dans votre pod, pour garantir que le planificateur réserve la capacité GPU, par exemple :

resources:
  limits:
    [gpu-vendor].com/gpu: 1

• Définissez les requêtes et les limites de ressources GPU dans votre pod, pour garantir que le respecter réserve la capacité GPU, par exemple.

Cette approche garantit que seules les charges de travail compatibles GPU atterrissent sur les nœuds GPU et ont accès aux ressources de calcul spécialisées dont elles ont besoin.

Avant de déployer des charges de travail GPU de production, vérifiez toujours que vos pools de nœuds GPU sont :

• Équipé de pilotes GPU compatibles.
• Hébergement d'un DaemonSet de plug-ins de périphérique Kubernetes sain.
• Exposer [gpu-vendor].com/gpu comme une ressource planifiable.

Vous pouvez confirmer la version actuelle du pilote exécutée sur vos pools de nœuds GPU avec l'interface de gestion système (SMI) associée au fournisseur de GPU.

La commande suivante s'exécute nvidia-smi à partir de l'intérieur du pod de déploiement du plug-in de votre périphérique GPU, pour vérifier l'installation du pilote et la préparation de l'exécution sur un pool de nœuds compatible GPU NVIDIA :

kubectl exec -it $"{GPU_DEVICE_PLUGIN_POD}" -n {GPU_NAMESPACE} -- nvidia-smi

Votre sortie doit ressembler à l’exemple suivant :

+-----------------------------------------------------------------------------+
|NVIDIA-SMI 570.xx.xx    Driver Version: 570.xx.xx    CUDA Version: 12.x|
...
...

Répétez l’étape ci-dessus pour chaque pool de nœuds GPU afin de confirmer la version du pilote installée sur vos nœuds.

Sur vos pools de nœuds compatibles GPU AMD, déployez également les composants GPU AMD et exécutez la commande amd-smi dans le pod du plug-in de périphérique ROCm pour confirmer la version du pilote installée.

Maintenez les nœuds compatibles GPU à jour avec la dernière image du système d'exploitation du nœud

Pour garantir les performances, la sécurité et la compatibilité de vos charges de travail GPU sur AKS, il est essentiel de maintenir vos pools de nœuds GPU à jour avec les dernières images de système d'exploitation de nœud recommandées. Ces mises à jour sont essentielles car elles :

• Incluent les derniers pilotes GPU de qualité production, remplaçant toutes les versions obsolètes ou en fin de vie (EOL).
• Sont entièrement testés pour la compatibilité avec votre version actuelle de Kubernetes.
• Corrigent les vulnérabilités connues identifiées par les fournisseurs de GPU.
• Intègrent les dernières améliorations du système d’exploitation et de l’exécution des conteneurs pour une stabilité et une efficacité accrues.

Mettent à niveau votre ou vos pools de nœuds GPU vers la dernière image de système d'exploitation de nœud recommandée publiée par AKS, soit en définissant le canal de mise à niveau automatique, soit via une mise à niveau manuelle. Vous pouvez surveiller et suivre les dernières versions d'images de nœuds à l'aide du suivi des versions AKS.

Séparer les charges de travail GPU lors de l'utilisation de clusters partagés

Si un seul cluster AKS avec des pools de nœuds GPU exécute plusieurs types de charges de travail GPU, telles que la formation de modèles, l'inférence en temps réel ou le traitement par lots, il est important de séparer ces charges de travail pour :

• Éviter les interférences accidentelles ou les conflits de ressources entre différents types de charges de travail.
• Améliorer la sécurité et maintenir les limites de conformité.
• Simplifier la gestion et la surveillance de l’utilisation des ressources GPU par catégorie de charge de travail.

Vous pouvez isoler les charges de travail GPU au sein d’un seul cluster AKS en utilisant des espaces de noms et des stratégies réseau. Cela permet une gouvernance plus claire grâce à des quotas, des limites et des configurations de journalisation spécifiques à la charge de travail.

Exemple de scénario

Considérez un cluster AKS hébergeant deux types de charges de travail GPU différents qui n’ont pas besoin de communiquer entre eux :

• Charges de travail de formation : tâches de formation de modèles d'IA gourmandes en ressources.
• Charges de travail d'inférence : services d'inférence en temps réel sensibles à la latence.

Vous pouvez utiliser les étapes suivantes pour séparer les deux charges de travail :

1. Créez des espaces de noms dédiés par type de charge de travail à l’aide de la commande kubectl create namespace.

   kubectl create namespace gpu-training
   kubectl create namespace gpu-inference
   

2. Étiquetez les pods de charge de travail GPU par type, comme indiqué dans l'exemple suivant :

   metadata:
     namespace: gpu-training
     labels:
       workload: training
   

3. Appliquez des stratégies réseau pour isoler le trafic entre les types de charges de travail. Le manifeste suivant bloque toutes les entrées et sorties de l'espace de noms gpu-training (sauf autorisation explicite) :

   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: deny-cross-namespace
     namespace: gpu-training
   spec:
     podSelector: {}
     policyTypes:
     - Ingress
     - Egress
     ingress: []
     egress: []
   

Cette stratégie :

• S'applique à tous les pods de l'espace de noms gpu-training.
• Refuse tout le trafic entrant et sortant par défaut, prenant en charge une isolation forte.

Ce modèle améliore la clarté, le contrôle et la sécurité dans les environnements GPU partagés, en particulier lorsque les types de charge de travail ont des profils d'exécution, des niveaux de risque ou des exigences opérationnelles différents.

Optimiser l'utilisation des ressources sur les nœuds GPU à l'aide du GPU multi-instance (MIG)

Les différentes charges de travail GPU varient en termes de besoins en mémoire, et les déploiements plus petits (par exemple, NVIDIA A100 40 Go) peuvent ne pas nécessiter un GPU complet. Cependant, une charge de travail unique monopolise par défaut la ressource GPU même lorsqu'elle est sous-utilisée.

AKS prend en charge l'optimisation des ressources sur les nœuds GPU en les divisant en tranches plus petites à l'aide d'un GPU multi-instance (MIG), afin que les équipes puissent planifier des tâches plus petites plus efficacement. En savoir plus sur les tailles de GPU prises en charge et comment démarrer avec les GPU multi-instances sur AKS.

Utiliser des disques de données NVMe éphémères comme cache hautes performances

Pour les charges de travail IA s’exécutant sur des machines virtuelles GPU dans AKS, un accès rapide et fiable au stockage temporaire est essentiel pour optimiser les performances d’apprentissage et d’inférence. Les disques de données NVMe éphémères fournissent un stockage à débit élevé et à faible latence directement attaché à l’hôte de machine virtuelle, ce qui les rend idéaux pour les scénarios tels que la mise en cache des jeux de données, le stockage de points de contrôle intermédiaires et les pondérations de modèle, ou la fourniture d’un espace de travail pour le prétraitement et l’analytique des données.

Lors du déploiement de pools de nœuds avec GPU pour les charges de travail IA, configurez des disques de données NVMe éphémères pour servir de cache hautes performances ou d’espace de travail. Cette approche permet d’éliminer les goulots d’étranglement des E/S, d’accélérer les opérations gourmandes en données et de s’assurer que vos ressources GPU ne sont pas en attente de données.

Les disques de données NVMe éphémères sont pris en charge dans un large éventail de familles de machines virtuelles GPU Azure. Selon la taille de la machine virtuelle GPU, elle dispose jusqu'à 8 disques de données NVMe éphémères avec une capacité combinée allant jusqu'à 28 Tio. Pour obtenir des configurations détaillées sur les tailles de machine virtuelle, reportez-vous à la documentation de la série ND H100 v5 ou à la documentation sur la taille de machine virtuelle pour votre famille GPU choisie.

Pour simplifier l’approvisionnement et la gestion, utilisez Stockage Conteneur Azure, qui peut détecter et orchestrer automatiquement des disques NVMe éphémères pour vos charges de travail Kubernetes.

Les scénarios recommandés sont les suivants :

• Mise en cache de jeux de données volumineux et de checkpoints de modèle pour l’apprentissage et l’inférence IA.
• Mise en cache des pondérations de modèle pour l’inférence IA. Par exemple, le modèle d'hébergement KAITO en tant qu'artefacts OCI sur NVMe local.
• Fournir un espace de stockage temporaire rapide pour les travaux par lots et les pipelines de données.

Pour plus d’informations sur les disques de données NVMe éphémères, consultez les meilleures pratiques pour les disques de données NVMe éphémères dans AKS.

Étapes suivantes

Pour en savoir plus sur le déploiement et la gestion de la charge de travail GPU sur AKS, consultez les articles suivants :

• Créez un pool de nœuds compatible GPU sur votre cluster AKS.

• Surveillez les charges de travail du GPU à l'aide de l'exportateur NVIDIA DCGM autogéré.

• Mettez automatiquement à l'échelle vos charges de travail GPU en fonction des métriques GPU courantes avec l'exportateur KEDA et DCGM.