Container Service for Kubernetes:Work with GPU sharing

Étape 1 : Ajouter un libellé au nœud

1. Vérifiez que le nœud est bien un nœud Lingjun en contrôlant l'existence du fichier /etc/lingjun_metadata sur le nœud. Si le fichier existe, exécutez la commande nvidia-smi pour vérifier l'accessibilité du GPU. Si le fichier n'existe pas, le nœud n'est pas un nœud Lingjun et vous ne pouvez pas y activer le partage de GPU. Créez d'abord un pool de nœuds Lingjun. Consultez la rubrique Présentation des pools de nœuds Lingjun.

2. Ajoutez le libellé de partage de GPU au nœud :

   kubectl label node <NODE_NAME> ack.node.gpu.schedule=share

Étape 2 : Soumettre une tâche de partage de GPU

1. Créez un fichier nommé tensorflow.yaml contenant les informations suivantes :

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: tensorflow-mnist-share
   spec:
     parallelism: 1
     template:
       metadata:
         labels:
           app: tensorflow-mnist-share
       spec:
         containers:
         - name: tensorflow-mnist-share
           image: registry.cn-beijing.aliyuncs.com/ai-samples/gpushare-sample:tensorflow-1.5
           command:
           - python
           - tensorflow-sample-code/tfjob/docker/mnist/main.py
           - --max_steps=100000
           - --data_dir=tensorflow-sample-code/data
           resources:
             limits:
               aliyun.com/gpu-mem: 4  # Request 4 GiB of GPU memory
           workingDir: /root
         restartPolicy: Never

   Le champ clé est aliyun.com/gpu-mem: 4 sous resources.limits, qui demande 4 Go de mémoire GPU pour le pod.

2. Soumettez la tâche :

   kubectl apply -f tensorflow.yaml

Étape 3 : Vérifier le partage de GPU sans isolation

1. Récupérez le nom du pod :

   kubectl get pod | grep tensorflow

2. Exécutez la commande nvidia-smi à l'intérieur du pod :

   kubectl exec -ti tensorflow-mnist-share-xxxxx -- nvidia-smi

   Résultat attendu :

   Wed Jun 14 06:45:56 2023
   +-----------------------------------------------------------------------------+
   | NVIDIA-SMI 515.105.01   Driver Version: 515.105.01   CUDA Version: 11.7     |
   |-------------------------------+----------------------+----------------------+
   | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
   | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
   |                               |                      |               MIG M. |
   |===============================+======================+======================|
   |   0  Tesla V100-SXM2...  On   | 00000000:00:09.0 Off |                    0 |
   | N/A   35C    P0    59W / 300W |    334MiB / 16384MiB |      0%      Default |
   |                               |                      |                  N/A |
   +-------------------------------+----------------------+----------------------+
   
   +-----------------------------------------------------------------------------+
   | Processes:                                                                  |
   |  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
   |        ID   ID                                                   Usage      |
   |=============================================================================|
   +-----------------------------------------------------------------------------+

   Points clés à vérifier :

   • Le champ Memory-Usage affiche 334MiB / 16384MiB : le pod voit la totalité des 16 384 MiB de mémoire GPU, et non pas seulement les 4 Go qu'il a demandés. Cela confirme que l'isolation n'est pas active.

   • Si le module d'isolation GPU était installé, le champ de mémoire n'afficherait que les 4 Go demandés.

Dans ce mode, le pod n'applique pas de limites de mémoire au niveau du pilote GPU. Le planificateur suit les allocations de mémoire à l'aide de deux variables d'environnement injectées dans le conteneur. Les applications qui doivent respecter l'allocation peuvent calculer la fraction autorisée : 4 / 16 = 0.25 (25 % de la mémoire totale du GPU).

ALIYUN_COM_GPU_MEM_CONTAINER=4   # GPU memory allocated to this pod (GiB)
ALIYUN_COM_GPU_MEM_DEV=16        # Total GPU memory per card (GiB)

Étape 1 : Ajouter un libellé au nœud

1. Vérifiez que le nœud est bien un nœud Lingjun en contrôlant l'existence du fichier /etc/lingjun_metadata sur le nœud. Si le fichier existe, exécutez la commande nvidia-smi pour vérifier l'accessibilité du GPU. Si le fichier n'existe pas, le nœud n'est pas un nœud Lingjun et vous ne pouvez pas y activer le partage de GPU. Créez d'abord un pool de nœuds Lingjun. Consultez la rubrique Présentation des pools de nœuds Lingjun.

2. Ajoutez le libellé de partage de GPU au nœud. Choisissez la valeur du libellé en fonction du type d'isolation requis :

   Valeur du libellé	Ce qu'elle active
   egpu_mem	Isolation de la mémoire GPU uniquement
   egpu_core_mem	Isolation de la mémoire GPU et isolation de la puissance de calcul

   Pour activer l'isolation de la mémoire :

   kubectl label node <NODE_NAME> ack.node.gpu.schedule=egpu_mem

   La puissance de calcul GPU doit toujours être demandée conjointement avec la mémoire GPU. La demande de puissance de calcul seule n'est pas prise en charge.

Étape 2 : Vérifier que les ressources du nœud sont prêtes

Après avoir ajouté le libellé au nœud, attendez que celui-ci signale ses ressources GPU, puis effectuez la vérification suivante :

kubectl get node <NODE_NAME> -oyaml

Recherchez les champs aliyun.com/gpu-mem et aliyun.com/gpu-count dans les sections allocatable et capacity :

allocatable:
  aliyun.com/gpu-count: "1"
  aliyun.com/gpu-mem: "80"
  ...
  nvidia.com/gpu: "0"
  ...
capacity:
  aliyun.com/gpu-count: "1"
  aliyun.com/gpu-mem: "80"
  ...
  nvidia.com/gpu: "0"
  ...

Points clés à vérifier :

• aliyun.com/gpu-count: "1" : le nœud dispose d'une carte GPU.

• aliyun.com/gpu-mem: "80" : le nœud dispose de 80 Go de mémoire GPU totale.

• nvidia.com/gpu: "0" : le GPU entier n'est pas exposé en tant que ressource planifiable indépendante ; la mémoire est allouée via aliyun.com/gpu-mem.

Pour planifier un pod sur un périphérique GPU entier, ajoutez le libellé ack.gpushare.placement=require-whole-device au pod et spécifiez la quantité de mémoire GPU à l'aide de aliyun.com/gpu-mem .

Étape 3 : Exécuter une tâche de référence pour vérifier l'isolation

1. Créez un fichier nommé benchmark.yaml contenant les informations suivantes :

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: benchmark-job
   spec:
     parallelism: 1
     template:
       spec:
         containers:
         - name: benchmark-job
           image: registry.cn-beijing.aliyuncs.com/ai-samples/gpushare-sample:benchmark-tensorflow-2.2.3
           command:
           - bash
           - run.sh
           - --num_batches=500000000
           - --batch_size=8
           resources:
             limits:
               aliyun.com/gpu-mem: 10  # Request 10 GB of GPU memory
           workingDir: /root
         restartPolicy: Never
         hostNetwork: true
         tolerations:
           - operator: Exists

2. Soumettez la tâche :

   kubectl apply -f benchmark.yaml

3. Une fois le pod démarré, ouvrez un shell dans le pod :

   kubectl exec -ti benchmark-job-xxxx bash

4. Exécutez la commande vgpu-smi pour vérifier l'état de l'isolation GPU :

   • Le champ Memory-Usage affiche 8307MiB / 10782MiB : le pod est limité à environ 10 Go, ce qui confirme que l'isolation de la mémoire GPU est active.

   • Contrairement à la commande nvidia-smi utilisée en mode non isolé, la commande vgpu-smi n'affiche que la mémoire allouée à ce pod, et non la mémoire totale du GPU.

   vgpu-smi

   Résultat attendu :

   +------------------------------------------------------------------------------+
   |    VGPU_SMI 460.91.03     DRIVER_VERSION: 460.91.03     CUDA Version: 11.2   |
   +-------------------------------------------+----------------------------------+
   | GPU  Name                Bus-Id           |        Memory-Usage     GPU-Util |
   |===========================================+==================================|
   |   0  xxxxxxxx            00000000:00:07.0 |  8307MiB / 10782MiB   100% /  100% |
   +-------------------------------------------+----------------------------------+

   Points clés à vérifier :

Comment vérifier si le composant de partage de GPU est installé ?

Exécutez la commande suivante :

kubectl get ds -nkube-system | grep gpushare

Si le composant est installé, la sortie liste les DaemonSets suivants :

NAME                                 DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR                    AGE
gpushare-egpu-device-plugin-ds       0         0         0       0            0           <none>
gpushare-egpucore-device-plugin-ds   0         0         0       0            0           <none>