How to configure the GPU selection policy for GPU sharing - Container Service for Kubernetes

Par défaut, l'ordonnanceur alloue les ressources GPU en saturant un GPU sur un nœud avant de passer au suivant. Cette approche évite la fragmentation de la mémoire GPU. Toutefois, dans certains scénarios, il peut être préférable de répartir les Pods sur plusieurs GPU afin de minimiser l'impact d'une défaillance matérielle sur vos charges de travail. Cette rubrique explique comment configurer la stratégie de sélection des GPU pour le partage de GPU.

Prérequis

Fonctionnement

Lorsque vous utilisez le partage de GPU sur un nœud doté de plusieurs GPU, deux stratégies d'allocation s'offrent à vous :

Binpack : (par défaut) L'ordonnanceur sature un GPU sur un nœud avant d'allouer des ressources sur un autre. Cette approche évite la fragmentation de la mémoire GPU.
Spread : L'ordonnanceur répartit les Pods aussi uniformément que possible sur tous les GPU disponibles d'un nœud. Cette approche minimise le nombre de charges de travail affectées en cas de défaillance d'un seul GPU.

L'exemple suivant présente un nœud équipé de deux GPU, chacun disposant de 15 Go de mémoire GPU. Pod1 demande 2 Go de mémoire GPU et Pod2 en demande 3.

Procédure

Par défaut, la stratégie de sélection des GPU pour un nœud est Binpack. Pour utiliser la stratégie Spread pour le partage de GPU, suivez les étapes ci-dessous.

Étape 1 : Créer un pool de nœuds

Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
Sur la page Clusters, cliquez sur le nom du cluster cible. Dans le volet de navigation de gauche, choisissez Nodes > Node Pools.

Sur la page Node Pools, cliquez sur Create Node Pool dans le coin supérieur droit.

Sur la page Create Node Pool, définissez les paramètres et cliquez sur Confirm. Le tableau suivant décrit les principaux paramètres. Pour plus d'informations sur les autres paramètres, consultez la rubrique Créer et gérer un pool de nœuds.

Paramètre	Description
Type d'instance	Pour Architecture, sélectionnez Instance accélérée par GPU et choisissez un type d'instance. La stratégie `Spread` n'est effective que sur les nœuds dotés de plusieurs GPU. Sélectionnez un type d'instance avec plusieurs GPU.
Nombre de nœuds souhaité	Spécifiez le nombre initial de nœuds dans le pool de nœuds. Définissez cette valeur sur 0 si vous ne souhaitez pas créer de nœuds immédiatement.
Libellé de nœud	Cliquez sur pour ajouter les deux libellés suivants : Définissez la Key sur `ack.node.gpu.schedule` et la Value sur `cgpu`. Cela active le partage de GPU et l'isolation de la mémoire GPU. Définissez la Key sur `ack.node.gpu.placement` et la Value sur `spread`. Cela active la stratégie `Spread` pour le nœud.

Étape 2 : Soumettre une tâche

Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Jobs.

Dans le coin supérieur droit de la page, cliquez sur Create from YAML. Copiez le contenu YAML suivant dans l'éditeur Template, modifiez-le comme indiqué dans les commentaires, puis cliquez sur Create.

Détails YAML

apiVersion: batch/v1
kind: Job
metadata:
  name: tensorflow-mnist-spread
spec:
  parallelism: 3
  template:
    metadata:
      labels:
        app: tensorflow-mnist-spread
    spec:
      nodeSelector:
         kubernetes.io/hostname: <NODE_NAME> # Replace <NODE_NAME> with the name of a GPU node in your cluster to better observe the effect, for example, cn-shanghai.192.0.2.109.
      containers:
      - name: tensorflow-mnist-spread
        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 # Requests 4 GiB of gpu memory.
        workingDir: /root
      restartPolicy: Never

Description du fichier YAML :

Ce fichier YAML définit une tâche qui utilise l'exemple TensorFlow MNIST. La tâche crée trois Pods, et chaque Pod demande 4 Go de mémoire GPU.
Un Pod demande 4 Go de mémoire GPU en définissant aliyun.com/gpu-mem: 4 dans la section resources.limits de la spécification du Pod.
Pour observer l'effet sur un seul nœud, le fichier YAML ajoute un nodeSelector, kubernetes.io/hostname: <NODE_NAME>, afin de planifier les Pods sur un nœud spécifique.

Étape 3 : Vérifier la stratégie Spread

Utilisez l'outil d'inspection GPU pour interroger l'allocation des ressources GPU sur le nœud :

kubectl inspect cgpu

NAME                   IPADDRESS      GPU0(Allocated/Total)  GPU1(Allocated/Total)  GPU2(Allocated/Total)  GPU3(Allocated/Total)  GPU Memory(GiB)
cn-shanghai.192.0.2.109  192.0.2.109  4/15                   4/15                   0/15                   4/15                   12/60
--------------------------------------------------------------------------------------
Allocated/Total GPU Memory In Cluster:
12/60 (20%)

La sortie indique que les trois Pods sont planifiés sur différents GPU du nœud. Cela confirme que la stratégie Spread est effective.