Tirer parti des GPU fractionnaires sur Kubernetes

Pourquoi des GPU fractionnés ?

Les GPU fractionnés nous permettent d'allouer plusieurs charges de travail à un seul GPU, ce qui peut être utile dans les scénarios suivants :

1. Les charges de travail occupent environ 2 à 3 Go de VRAM. Vous pouvez donc allouer plusieurs répliques de cette charge de travail sur un seul GPU doté d'environ 16 Go de VRAM ou plus.
2. Chaque charge de travail a un trafic limité et n'est pas en mesure de maximiser l'utilisation du GPU.

Comment utiliser les GPU fractionnés ?

1. Tranchage temporel: Dans cette approche, vous pouvez découper un GPU en un nombre fixe de parties fractionnées, puis choisir une fraction de GPU pour cette charge de travail. Par exemple, nous pouvons décider de diviser un GPU en 10 tranches, puis de demander 3 tranches pour une charge de travail, 5 tranches pour la charge de travail2 et 2 tranches pour la charge de travail3. Cela signifie que workload1 utilisera 0,3 GPU (calcul + 30 % de VRAM), workload2 utilisera 0,5 GPU et workload3 utilisera 0,2 GPU. Cependant, le découpage temporel n'est utilisé que pour planifier les charges de travail sur la même machine. Cela ne signifie pas une véritable isolation de la machine. Par exemple, si la machine GPU possède 16 Go de VRAM, c'est à l'utilisateur de s'assurer que workload1 utilise moins de 4,8 Go de VRAM, workload2 utilise moins de 8 Go de VRAM et workload3 utilise moins de 3,2 Go de VRAM. Si une charge de travail commence soudainement à prendre plus de mémoire, cela peut entraîner le blocage des autres processus. Le calcul est également partagé, mais une charge de travail peut aller jusqu'à utiliser la totalité du GPU si les autres charges de travail sont inactives. Il s'agit essentiellement d'un changement de contexte entre les trois charges de travail. Vous pouvez en savoir plus à ce sujet ici.
2. MIG (GPU multi-instances): Il s'agit d'une fonctionnalité fournie par Nvidia uniquement sur les GPU A100 et H100. Elle ne fonctionne pas sur les autres GPU. Nous pouvons diviser les GPU en un nombre fixe de composants configurables, comme indiqué dans le tableau ci-dessous. Les charges de travail peuvent choisir l'une des tranches et bénéficier d'une isolation de calcul et de mémoire. Les instances ne sont pas exactement les fractions complètes du GPU, mais des unités plus discrètes, comme indiqué dans le tableau ci-dessous. Par exemple, supposons que nous divisons un GPU A100 de 40 Go en 7 parties. Ensuite, nous pouvons placer 7 charges de travail utilisant chacune environ 1/7 de GPU et 5 Go de VRAM. Veuillez noter que nous ne pouvons pas simplement fournir 2 tranches à une charge de travail dans ce cas et nous attendre à ce qu'elle obtienne 2/7 GPU et 10 Go de VRAM. Dans ce cas, chaque charge de travail ne peut obtenir qu'une seule tranche.

Prérequis pour le GPU fractionné

Ajouter une intégration au cloud

Pour activer les GPU fractionnaires, nous devrons créer un pool de nœuds distinct des GPU et il ne fonctionnera pas via le provisionnement dynamique de nœuds standard dans AWS/GCP. Pour que Truefoundry puisse lire ces pools de nœuds, nous devons nous assurer que l'intégration cloud avec Truefoundry est déjà effectuée.

Si ce n'est pas encore activé, veuillez suivez ce guide pour activer l'intégration au cloud.

Une fois l'intégration cloud ajoutée, vous devez « créer des pools de nœuds » pour les GPU compatibles MIG ou TimeSlicing. Cette configuration est différente selon les fournisseurs de cloud. Veuillez suivre le guide ci-dessous pour activer les GPU fractionnaires sur votre cluster.

Installez la dernière version de tfy-gpu-operator

• Accédez à Déploiements -> Helm -> tfy-gpu-operator.
• Cliquez sur Modifier (trois points à droite)
• Choisissez la dernière version du graphique (en haut de la page) dans la liste déroulante et cliquez sur Soumettre.

Activer MIG

Azure

1. Créez un Nodepool avec MIG activé à l'aide de l'argument --gpu-instance-profile d'Azure CLI. Voici un exemple de commande permettant de faire de même :

az aks nodepool add \
<your cluster name>--nom-cluster \
<your resource group>--groupe-ressources \
--sans attendre \
--enable-cluster-autoscaler \
--eviction-policy Supprimer \
--nombre de nœuds 0 \
--compte maximum 20 \
--compte minimum 1 \
--node-osdisk-size 200 \
--scale-down-mode Supprimer \
--os-type Linux \
--node-taints « nvidia.com/GPU=present:NoSchedule » \
--name a100mig7 \
--node-vm-size standard_NC24ADS_A100_V4 \
--Emplacement prioritaire \
--os-sku Ubuntu \
--gpu-instance-profile MiG1G


2. Actualisez les pools de nœuds du cluster Truefoundry.

3. Déployez votre charge de travail en sélectionnant le GPU (avec le nombre 1) et en sélectionnant le pool de nœuds approprié.

GCP

Créez un pool de nœuds et transmettez le mig_profile dans accélérateur en passant gpu_partition_size=1G,5 Go[OU l'une des valeurs autorisées pour le profil MIG que vous trouverez en haut de cette page]

Les pools de nœuds de conteneurs gcloud créent un 100-40-mig-1g5gb \ INT ✘
<enter your project name>--projet= \
<enter your region>--région= \
<enter your cluster name here>--cluster= \
--machine-type=a2-high gpu-1g \
--accelerator type=nvidia-tesla-a100, compte=1, taille de la partition GPU=1g.5 Go \
--activer-la mise à l'échelle automatique \
--nombre total de nœuds minimum 0 \
--total-max-nodes 4 \
--min-provision-nodes 0 \
--num-nodes 0


AWS

Il n'est pas anodin de prendre actuellement en charge les GPU MIG sur AWS de manière gérée, mais si vous souhaitez essayer cette fonctionnalité -> Veuillez vous y référer médecins

Activer Timeslicing

Azure

1. Assurez-vous que plug-in pour appareil NVIDIA la configuration est correctement définie dans opérateur tfy-gpugraphique.
   Accédez à Casque -> tfy-gpu-operator, cliquez sur Modifier et assurez-vous que les lignes suivantes sont présentes dans le valeurs

opérateur azure-AKS-GPU :
Plug-in de l'appareil :
configuration :
données :
tous : « »
tranche dans le temps : |-
version : v1
partage :
Découpage temporel :
RenameByDefault : true
ressources :
- nom : nvidia.com/gpu
répliques : 10
nom : time-slicing-config
créer : vrai
par défaut : tous


2. Créez un Nodepool avec plugin-appareil.config pointant vers la configuration de découpage temporel correcte avec Azure CLI. Voici un exemple de commande pour faire de même.

az aks nodepool add \
<your cluster name>--nom-cluster \
<your resource group>--groupe-ressources \
--sans attendre \
--enable-cluster-autoscaler \
--eviction-policy Supprimer \
--nombre de nœuds 0 \
--compte maximum 20 \
--compte minimum 0 \
--node-osdisk-size 200 \
--scale-down-mode Supprimer \
--os-type Linux \
--node-taints « nvidia.com/GPU=present:NoSchedule » \
--name a100mig7 \
--node-vm-size standard_NC24ADS_A100_V4 \
--Emplacement prioritaire \
--os-sku Ubuntu \
--labels nvidia.com/device-plugin.config=time-sliced-10


2. Actualisez les pools de nœuds sur le cluster Truefoundry.
3. Déployez votre charge de travail en sélectionnant le GPU (avec le nombre 1) et en sélectionnant le pool de nœuds approprié.

GCP

Les pools de nœuds de conteneurs gcloud créent un 100-40-frac-10 \ ✔
--project=tfy-devtest \
--region=us-central1 \
--cluster=tfy-gtl-b-us-central-1 \
--machine-type=a2-high gpu-1g \
--accelerator type=nvidia-tesla-a100, count=1, gpu-sharing-strategy=temps partagé, max-shared-clients-per-gpu=10 \
--activer-la mise à l'échelle automatique \
--nombre total de nœuds minimum 0 \
--total-max-nodes 4 \
--min-provision-nodes 0 \
--num-nodes 0


AWS

1. Assurez-vous que plug-in pour appareil NVIDIA la configuration est correctement définie dans opérateur tfy-gpugraphique.
Accédez à Casque -> tfy-gpu-operator, cliquez sur Modifier et assurez-vous que les lignes suivantes sont présentes dans le valeurs

Opérateur aws-eks-GPU :
Plug-in de l'appareil :
configuration :
données :
tous : « »
tranche dans le temps : |-
version : v1
partage :
Découpage temporel :
RenameByDefault : true
ressources :
- nom : nvidia.com/gpu
répliques : 10
nom : time-slicing-config
créer : vrai
par défaut : tous


2. Créez un groupe de nœuds sur AWS EKS avec l'étiquette suivante :

étiquettes :
« nvidia.com/device-plugin.config » : « time-sliced-10 »


Utilisation de GPU fractionnaires dans votre service

Pour utiliser des GPU fractionnaires dans votre service :

1. Assurez-vous d'avoir ajouté les pools de nœuds souhaités.

2. Synchronisez les pools de nœuds de cluster depuis votre compte cloud en accédant à Intégrations -> Clusters -> Synchroniser comme indiqué ci-dessous :

3. Vous pouvez déployer à l'aide de l'interface utilisateur de Truefoundry ou du SDK Python.
Remarque : La mise à l'échelle automatique des Nodepools ne fonctionnera que dans GCP clusters. Vous devrez augmenter ou réduire manuellement les pools de nœuds dans Azure/AWS.

Déploiement avec interface utilisateur

1. Pour déployer une charge de travail utilisant un GPU fractionné, commencez à déployer votre service/job sur Truefoundry et dans la section « Ressources », sélectionnez le sélecteur de pool de nœuds

2. Une fois que vous avez sélectionné le sélecteur de pool de nœuds en haut à droite de la section Ressources, vous pouvez maintenant voir les GPU fractionnés sur l'interface utilisateur que vous pouvez sélectionner (comme indiqué ci-dessous)

Déploiement avec le SDK Python

Vous pouvez utiliser des GPU fractionnaires à l'aide du SDK python avec les modifications suivantes en termes de ressources :

1. Utilisation de GPU MIG

depuis Servicefoundry import (
...
Un service,
Processeur graphique NVIDIA Mig,
Sélecteur de pool de nœuds,
)

service = Service (
...

Resources=Ressources (
...
Node=NodePoolSelector (
<add your nodepool name>pools de nœuds = [» «],
),
appareils = [
GPU NVIDIA Mig (profil = « 1 g, 5 Go »)
],
),
)


2. Utilisation du GPU Timeslicing

depuis Servicefoundry import (
Un service,
GPU NVIDIA Time Slicing,
Sélecteur de pool de nœuds,
)

service = Service (
...

Resources=Ressources (
...
Node=NodePoolSelector (
<add your nodepool name>pools de nœuds = [» «],
),
appareils = [
GPU Nvidia Timeslicing (gpu_memory = 4000),
],
),
)

Nous mangeons True Foundry prend en charge les GPU fractionnaires de manière extrêmement rationalisée.