Partage de GPU contrôlé par la mémoire dans Kubernetes avec NVIDIA CUDA 13.4

Partage de GPU contrôlé par la mémoire dans Kubernetes avec NVIDIA CUDA 13.4

À mesure que les charges de travail liées à l’IA deviennent plus diverses, la demande en gestion flexible des ressources GPU dans les environnements Kubernetes augmente. De nombreuses applications n’ont besoin que d’une fraction de la capacité d’un GPU, mais les méthodes d’allocation traditionnelles attribuent souvent des dispositifs entiers, laissant une grande partie de la capacité inutilisée. NVIDIA répond à ce défi avec CUDA 13.4, en introduisant un mécanisme de contrôle des limites de mémoire transparent pour les applications. Cette mise à jour permet d’indiquer des quantités de mémoire précises, des minimums garantis avec des maximums pouvant varier, ainsi que le choix entre des modes de calcul basés sur le découpage temporel et le partage de ressources.

Afin de mettre ces fonctionnalités en œuvre à grande échelle, NVIDIA a publié l’opérateur open source GPU Fractioning Operator. Hébergé sous l’organisation KAI Scheduler sur GitHub, cet opérateur fonctionne en parallèle de l’NVIDIA GPU Operator. Sa fonction principale est d’installer et de superviser le Multi-Process Service (MPS) sur chaque nœud GPU, d’appliquer des limites de mémoire et des modes de calcul spécifiques à chaque charge de travail, ainsi que de mesurer l’utilisation de la mémoire et du calcul par fraction de GPU plutôt que pour l’ensemble du GPU.

L’architecture du contrôle

CUDA 13.4 fournit la capacité de contrôle de la mémoire de base, mais un cluster Kubernetes ne peut pas l’utiliser de manière indépendante. Sur chaque nœud GPU, un mécanisme est nécessaire pour appliquer les limites de mémoire et le mode de calcul de chaque conteneur Pod avant le démarrage du processus, ainsi que pour communiquer l’utilisation réelle par fraction. Cette tâche doit être effectuée au niveau du nœud, indépendamment du scheduler qui a assigné la charge de travail.

L’opérateur GPU Fractioning Operator remplit cette fonction. Il lit les annotations relatives aux ressources et aux modes écrites dans le fichier YAML du Pod par le scheduler. Une fois que le scheduler a sélectionné les GPUs pour une charge de travail et en a enregistré l’allocation de mémoire ainsi que le mode de partage de calcul dans les annotations par conteneur du Pod, l’opérateur GPU Fractioning Operator configure les GPUs assignés afin d’appliquer ces limites.

KAI Scheduler v0.18.0 est le premier planificateur intégré à l’opérateur de fractionnement GPU. À partir de cette version, KAI Scheduler inclut un mode de partage GPU appelé NvFractions. Ce mode choisit quelle partie de quel GPU chaque charge de travail reçoit et écrit les annotations nécessaires. Les administrateurs peuvent activer NvFractions lors de l’installation de KAI Scheduler à l’aide d’une flag Helm, ce qui installe également l’opérateur de fractionnement GPU en tant que dépendance.

Configuration des demandes et limites de mémoire

Les charges de travail peuvent déclarer des besoins en GPU fractionnés à l’aide d’annotations spécifiques. Il existe quatre annotations essentielles qui répondent à quatre questions fondamentales : quelle quantité de mémoire est nécessaire, jusqu’où la charge de travail peut croître, comment le calcul est partagé, et combien de GPUs elle utilise.

Les administrateurs peuvent spécifier les besoins en mémoire sous forme de taille absolue en utilisant des unités Kubernetes standard. Le nom du conteneur fait partie de la clé afin de s’assurer que l’annotation cible le bon conteneur. Alternativement, les charges de travail peuvent déclarer une partie d’un GPU. Cette capacité permet à une charge de travail de définir un minimum garanti (la demande) ainsi qu’un maximum qu’elle peut atteindre en cas de disponibilité de mémoire.

Si une annotation de limite est omise, la limite équivaut à la demande, et la charge de travail est plafonnée à exactement ce qu’elle a demandé. Une limite de portion doit être supérieure à gpu-fraction et inférieure à 1.

Modes de calcul : Time-Slicing vs. SM-Sharing

CUDA 13.4 introduit deux modes de calcul distincts pour le partage des GPUs, chacun présentant des caractéristiques différentes en termes de performance et d’isolation.

Time-Slicing est le mode par défaut. Il est séquentiel, ce qui signifie que les charges de travail s’alternent sur l’ensemble du GPU. Lorsque chaque charge de travail utilise toute sa partie, chacune reçoit approximativement 1/n du temps. Tout temps inutilisé par une charge de travail est partagé équitablement entre les autres. Il est crucial de noter que chaque charge de travail s’exécute dans son propre domaine d’erreurs, assurant ainsi une isolation complète des erreurs. Si un job plante, cela n’affecte pas ses voisins.

SM-Sharing (partage des multiprocesseurs de streaming) est un mode parallèle. Dans ce mode, les multiprocesseurs de streaming de la GPU sont répartis entre différentes tâches, et toutes s’exécutent en même temps de manière continue. Rien n’est alloué à l’avance ; le matériel de la GPU attribue et libère des SM selon les besoins des tâches. Lorsque toutes les tâches sont actives, la répartition se situe à environ 1/n. Cependant, si une tâche cesse d’être active, ses SM passent aux autres, permettant à une seule tâche active d’en utiliser tous. Dans ce mode, les tâches partagent un même domaine d’erreurs.

Comme une GPU partagée ne fonctionne qu’avec un seul mode de calcul à la fois, le planificateur KAI ne place jamais une tâche en temps tronqué et une tâche en SM-Sharing sur la même GPU. Le planificateur suit cette logique par GPU, et non par nœud, ce qui permet à un même nœud d’héberger les deux modes sur des GPUs différentes.

Exemples de mise en œuvre pratique

Les exemples suivants montrent comment configurer des Pods pour différents scénarios de partage à l’aide des annotations du planificateur KAI.

Serveur d’inférence avec SM-Sharing

Cet exemple représente un serveur d’inférence réparti sur quatre GPUs. Il nécessite une allocation garantie de 40Gi sur chaque GPU et peut utiliser jusqu’à 60Gi lorsque les GPUs voisines sont inactives. Il s’exécute en parallèle des autres tâches au lieu d’attendre son tour.

apiVersion: v1
kind: Pod
metadata:
  name: inference
  labels:
    kai.scheduler/queue: default-queue
  annotations:
    nvidia.com/container.app.gpu-memory.request: "40Gi"
    nvidia.com/container.app.gpu-memory.limit: "60Gi"
    nvidia.com/container.app.gpu-compute.mode: "sm-sharing"
    gpu-fraction-num-devices: "4"
spec:
  schedulerName: kai-scheduler
  containers:
    - name: app
      image: nvcr.io/nvidia/cuda:13.0.2-base-ubuntu24.04

Job de développement avec temps tronqué

Cet exemple convient à des jobs de développement ou en batch, tels que des notebooks ou de petites sessions de fine-tuning. Il nécessite une allocation garantie d’une moitié de chaque GPU, et peut augmenter jusqu’à 80% lorsque de la mémoire est disponible. Le temps tronqué assure l’isolement des erreurs entre les jobs.

metadata:
  annotations:
    gpu-fraction: "0.5"
    gpu-fraction.limit: "0.8"
    nvidia.com/container.app.gpu-compute.mode: "time-slicing"
    gpu-fraction-num-devices: "2"
spec:
  schedulerName: kai-scheduler
  containers:
    - name: app

Début d’utilisation et communauté

Pour utiliser ces fonctionnalités, les administrateurs doivent s’assurer que le planificateur KAI est installé avec le flag global.nvFractions.set=true. Cette configuration active le mode NvFractions et installe l’opérateur de fractionnement de GPU.

L’opérateur de fractionnement de GPU et le planificateur KAI sont tous deux disponibles sur GitHub au sein de l’organisation KAI Scheduler. Les instructions d’installation et de configuration pour les trois mécanismes de partage se trouvent dans les guides administratifs et utilisateurs. Les développeurs peuvent également rejoindre le canal Slack ou assister à des réunions communautaires bimensuelles pour poser des questions et contribuer au projet.

Pour en savoir plus sur CUDA 13.4, consultez l’annonce officielle. De plus, NVIDIA sera présente à KubeCon + CloudNativeCon NA 2026 à Salt Lake City, dans l’Utah, du 9 au 12..

Conclusion

Le partage de GPU contrôlé par la mémoire dans Kubernetes représente une avancée significative en termes d’efficacité des ressources pour les charges de travail d’IA. En combinant l’opérateur de fractionnement de GPU avec le planificateur KAI v0.18.0 et CUDA 13.4, les équipes de plateforme peuvent imposer des limites de mémoire par charge de travail et choisir entre les modes de calcul basés sur le découpage temporel et le partage de mémoire. Cette flexibilité permet aux organisations de gérer davantage de charges de travail avec l’infrastructure existante tout en maintenant un contrôle strict sur l’utilisation de la mémoire et l’affectation des ressources de calcul.

Source : https://developer.nvidia.com/blog/memory-enforced-gpu-sharing-in-kubernetes-with-nvidia-cuda-13-4