Enable the scheduling feature - Container Service for Kubernetes

Lors du déploiement de charges de travail GPU dans un ACK managed Pro cluster, attribuez des libellés de planification GPU (exclusif, partagé, conscient de la topologie) et des libellés de modèle de carte GPU pour optimiser l'utilisation et cibler la planification. La planification partagée et consciente de la topologie nécessite une édition Pro ; la planification par modèle de carte est prise en charge sur tous les types de clusters.

Aperçu des libellés de planification

Les libellés de planification GPU identifient les modèles de GPU et les politiques d'allocation pour une gestion fine des ressources.

Mode de planification	Valeur du libellé	Cas d'utilisation
Planification exclusive (Par défaut)	`ack.node.gpu.schedule: default`	Pour les tâches critiques en termes de performances nécessitant un accès exclusif au GPU, telles que l'entraînement de modèles et le calcul haute performance (HPC).
Planification partagée	`ack.node.gpu.schedule: cgpu` `ack.node.gpu.schedule: core_mem` `ack.node.gpu.schedule: share` `ack.node.gpu.schedule: mps`	Idéal pour les tâches légères concurrentes, telles que les scénarios multi-locataires et d'inférence. `cgpu` : Puissance de calcul partagée avec mémoire GPU isolée, basée sur Alibaba Cloud cGPU. `core_mem` : Puissance de calcul et mémoire GPU isolées. `share` : Puissance de calcul et mémoire GPU partagées sans isolation. `mps` : Puissance de calcul partagée avec mémoire GPU isolée, basée sur NVIDIA Multi-Process Service (MPS) avec Alibaba Cloud cGPU.
Planification partagée	`ack.node.gpu.placement: binpack` `ack.node.gpu.placement: spread`	Optimise l'allocation des ressources sur les nœuds multi-GPU avec la planification partagée `cgpu`, `core_mem`, `share` ou `mps` activée. `binpack` : (Par défaut) Remplit un GPU avec des pods avant d'allouer le suivant, réduisant la fragmentation des ressources. Idéal pour maximiser l'utilisation ou économiser de l'énergie. `spread` : Répartit les pods sur les GPU pour réduire l'impact d'une défaillance sur une seule carte. Adapté aux charges de travail nécessitant une haute disponibilité.
Planification consciente de la topologie	`ack.node.gpu.schedule: topology`	Attribue la combinaison optimale de GPU à un pod en fonction de la topologie physique des GPU au sein d'un nœud. Idéal pour les tâches sensibles à la latence de communication entre GPU.
Planification par modèle de carte	`aliyun.accelerator/nvidia_name: <nom de la carte GPU>` Utilisez ces libellés pour définir la mémoire GPU et le nombre de cartes pour les travaux. `aliyun.accelerator/nvidia_mem: <mémoire GPU par carte>` `aliyun.accelerator/nvidia_count: <nombre total de cartes GPU>`	Planifie les travaux vers des nœuds disposant d'un modèle de GPU spécifique ou évite les nœuds avec un modèle spécifique.

Activer les fonctionnalités de planification

Un nœud ne prend en charge qu'un seul mode de planification GPU (exclusif, partagé ou conscient de la topologie) à la fois. L'activation d'un mode définit à 0 les ressources étendues signalées par les autres modes.

Planification exclusive

Sans libellés de planification GPU, la planification exclusive est le mode par défaut. Une seule carte GPU constitue la plus petite unité d'allocation pour les pods.

Si vous avez activé un autre mode de planification GPU, la simple suppression du libellé ne rétablit pas la planification exclusive. Définissez le libellé sur ack.node.gpu.schedule: default via le pool de nœuds pour le rétablir.

Planification partagée

La planification partagée est disponible uniquement pour les ACK managed cluster Pro. Consultez les Limitations.

Installer le composant ack-ai-installer**
1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Applications > Cloud-native AI Suite.
3. Sur la page Cloud-native AI Suite, cliquez sur Deploy. Sur la page Cloud-native AI Suite, sélectionnez Scheduling Policy Extension (Batch Task Scheduling, GPU Sharing, Topology-aware GPU Scheduling).
  
  Pour configurer la politique de planification cGPU, consultez Installer et utiliser le composant cGPU .
4. Sur la page Cloud-native AI Suite, cliquez sur Deploy Cloud-native AI Suite.
  
  Dans la liste des composants sur la page Cloud-native AI Suite, vérifiez que le composant ack-ai-installer est installé.
Activer la planification partagée
1. Sur la page Clusters, cliquez sur le nom de votre cluster cible. Dans le volet de navigation de gauche, choisissez Nodes > Node Pools.
2. Sur la page Node Pools, cliquez sur Create Node Pool, configurez les libellés de nœud, puis cliquez sur Confirm.
  
  Conservez les valeurs par défaut pour les autres paramètres. Consultez l'Aperçu des libellés de planification pour connaître les cas d'utilisation des libellés.
  - Configurer la planification partagée de base.
    
    Cliquez sur l'icône Ajouter pour Node Labels, définissez la Key sur ack.node.gpu.schedule, et sélectionnez l'une des valeurs de libellé suivantes : cgpu, core_mem, share ou mps (nécessite l'installation du composant MPS Control Daemon).
  - Configurer la planification partagée multi-cartes.
    
    Pour les nœuds disposant de plusieurs cartes GPU, configurez la planification multi-cartes pour optimiser l'allocation des ressources.
    
    Cliquez sur l'icône Ajouter pour Node Labels, définissez la Key sur ack.node.gpu.placement, et sélectionnez l'une des valeurs de libellé suivantes : binpack ou spread.

Vérifier la planification partagée

`cgpu`/`share`/`mps`

Vérifiez que la planification partagée cgpu, share ou mps est activée. Remplacez <NODE_NAME> par le nom de votre nœud.

kubectl get nodes <NODE_NAME> -o yaml | grep -q "aliyun.com/gpu-mem"

Sortie attendue :

aliyun.com/gpu-mem: "60"

Une valeur non nulle confirme que la planification partagée cgpu, share ou mps est activée.

`core_mem`

Vérifiez que la planification partagée core_mem est activée. Remplacez <NODE_NAME> par le nom de votre nœud.

kubectl get nodes <NODE_NAME> -o yaml | grep -E 'aliyun\.com/gpu-core\.percentage|aliyun\.com/gpu-mem'

Sortie attendue :

aliyun.com/gpu-core.percentage:"80"
aliyun.com/gpu-mem:"6"

Des valeurs non nulles pour aliyun.com/gpu-core.percentage et aliyun.com/gpu-mem confirment que la planification partagée core_mem est activée.

`binpack`

Utilisez l'outil de requête de ressources GPU pour vérifier l'allocation des ressources GPU sur le nœud :

kubectl inspect cgpu

Sortie attendue :

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  15/15                   9/15                   0/15                   0/15                   24/60
--------------------------------------------------------------------------------------
Allocated/Total GPU Memory In Cluster:
24/60 (40%)

GPU0 est entièrement alloué (15/15) avant GPU1 (9/15), ce qui confirme que la stratégie binpack est active.

`spread`

Utilisez l'outil de requête de ressources GPU pour vérifier l'allocation des ressources GPU sur le nœud :

kubectl inspect cgpu

Sortie attendue :

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%)

Les ressources sont réparties uniformément (4/15) sur GPU0, GPU1 et GPU3, ce qui confirme que la politique spread est active.

Planification consciente de la topologie

La planification consciente de la topologie est disponible uniquement pour les ACK managed cluster Pro. Consultez les Exigences de version des composants système.

Installer le composant ack-ai-installer.
Activer la planification consciente de la topologie

Ajoutez un libellé de planification consciente de la topologie via le pool de nœuds : dans les libellés de nœud du pool de nœuds cible, définissez la Key sur ack.node.gpu.schedule avec la valeur topology.

L'activation de la planification GPU consciente de la topologie sur un nœud désactive les charges de travail GPU non conscientes de la topologie. Pour rétablir la planification exclusive, modifiez la valeur du libellé en default via le pool de nœuds.
Vérifier la planification consciente de la topologie

Vérifiez que la planification consciente de la topologie topology est activée. Remplacez <NODE_NAME> par le nom de votre nœud.
```
kubectl get nodes <NODE_NAME> -o yaml | grep aliyun.com/gpu
```
Sortie attendue :
```
aliyun.com/gpu: "2"
```
Une valeur non nulle pour aliyun.com/gpu confirme que la planification consciente de la topologie topology est activée.

Planification par modèle de carte

Planifiez les travaux vers des nœuds avec un modèle GPU spécifié, ou évitez des modèles spécifiques.

Afficher le modèle de carte GPU

Interrogez le modèle de carte GPU des nœuds du cluster.

Le champ NVIDIA_NAME affiche le modèle de carte GPU.
```
kubectl get nodes -L aliyun.accelerator/nvidia_name
```
Sortie attendue :
```
NAME                        STATUS   ROLES    AGE   VERSION            NVIDIA_NAME
cn-shanghai.192.XX.XX.176   Ready    <none>   17d   v1.26.3-aliyun.1   Tesla-V100-SXM2-32GB
cn-shanghai.192.XX.XX.177   Ready    <none>   17d   v1.26.3-aliyun.1   Tesla-V100-SXM2-32GB
```
Méthodes de vérification alternatives
Sur la page Clusters, cliquez sur le nom du cluster cible. Dans le volet de navigation de gauche, choisissez Workloads > Pods. Pour un pod en cours d'exécution (par exemple, tensorflow-mnist-multigpu-***), cliquez sur Terminal dans la colonne Actions. Sélectionnez le conteneur cible dans la liste déroulante et exécutez les commandes suivantes.
- Interroger le modèle de carte : nvidia-smi --query-gpu=gpu_name --format=csv,noheader --id=0 | sed -e 's/ /-/g'
- Interroger la mémoire GPU de chaque carte : nvidia-smi --id=0 --query-gpu=memory.total --format=csv,noheader | sed -e 's/ //g'
- Interroger le nombre total de cartes GPU sur le nœud : nvidia-smi -L | wc -l

Activer la planification par modèle de carte

Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Jobs.

Sur la page Jobs, cliquez sur Create from YAML. Utilisez les exemples suivants pour créer une application et activer la planification par modèle de carte.

Spécifier le modèle de carte

Assurez-vous que votre application s'exécute sur des nœuds avec un modèle de carte GPU spécifique.

Dans aliyun.accelerator/nvidia_name: "Tesla-V100-SXM2-32GB", remplacez Tesla-V100-SXM2-32GB par le modèle de carte réel de votre nœud.

Détails YAML

apiVersion: batch/v1
kind: Job
metadata:
  name: tensorflow-mnist
spec:
  parallelism: 1
  template:
    metadata:
      labels:
        app: tensorflow-mnist
    spec:
      nodeSelector:
        aliyun.accelerator/nvidia_name: "Tesla-V100-SXM2-32GB" # Runs the application on a Tesla V100-SXM2-32GB GPU.
      containers:
      - name: tensorflow-mnist
        image: registry.cn-beijing.aliyuncs.com/acs/tensorflow-mnist-sample:v1.5
        command:
        - python
        - tensorflow-sample-code/tfjob/docker/mnist/main.py
        - --max_steps=1000
        - --data_dir=tensorflow-sample-code/data
        resources:
          limits:
            nvidia.com/gpu: 1
        workingDir: /root
      restartPolicy: Never

Après la création du travail, choisissez Workloads > Pods . La liste des pods confirme que le pod est planifié sur un nœud avec le modèle de carte GPU correspondant.

Exclure le modèle de carte

Utilisez les libellés de modèle de carte GPU avec l'affinité de nœud pour empêcher la planification sur certains modèles de carte.

Dans values: - "Tesla-V100-SXM2-32GB", remplacez Tesla-V100-SXM2-32GB par le modèle de carte réel de votre nœud.

Détails YAML

apiVersion: batch/v1
kind: Job
metadata:
  name: tensorflow-mnist
spec:
  parallelism: 1
  template:
    metadata:
      labels:
        app: tensorflow-mnist
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: aliyun.accelerator/nvidia_name  # Card model scheduling label
                operator: NotIn
                values:
                - "Tesla-V100-SXM2-32GB"            # Prevents the pod from being scheduled to a node with a Tesla-V100-SXM2-32GB card.
      containers:
      - name: tensorflow-mnist
        image: registry.cn-beijing.aliyuncs.com/acs/tensorflow-mnist-sample:v1.5
        command:
        - python
        - tensorflow-sample-code/tfjob/docker/mnist/main.py
        - --max_steps=1000
        - --data_dir=tensorflow-sample-code/data
        resources:
          limits:
            nvidia.com/gpu: 1
        workingDir: /root
      restartPolicy: Never

Après la création du travail, l'application n'est pas planifiée sur les nœuds où aliyun.accelerator/nvidia_name est Tesla-V100-SXM2-32GB, mais peut s'exécuter sur des nœuds GPU avec d'autres modèles de carte.

Bonnes pratiques : Utiliser des pools de nœuds distincts pour chaque mode de planification

Créez un pool de nœuds distinct pour chaque mode de planification GPU et gérez les attributs de planification via les libellés du pool de nœuds. Évitez de mélanger plusieurs modes de planification au sein du même pool de nœuds. Configuration recommandée :

Pool de nœuds de planification exclusive : Aucun libellé de planification GPU n'est requis ; les nœuds utilisent par défaut la planification exclusive. Adapté aux tâches nécessitant un accès exclusif au GPU, telles que l'entraînement de modèles et le HPC.
Pool de nœuds de planification partagée : Définissez ack.node.gpu.schedule: cgpu (ou une autre valeur de libellé partagé). Adapté aux scénarios nécessitant une utilisation plus élevée du GPU, tels que les services d'inférence et le multi-locataire.
Pool de nœuds de planification consciente de la topologie : Définissez ack.node.gpu.schedule: topology. Adapté aux tâches sensibles à la latence de communication entre GPU, telles que l'entraînement distribué.

Les libellés de planification par modèle de carte (aliyun.accelerator/nvidia_name) peuvent être combinés avec l'un des modes de planification ci-dessus pour restreindre davantage la planification des pods aux nœuds avec des modèles GPU spécifiques.

Modification des modes de planification

Pour modifier le mode de planification d'un nœud spécifique, retirez le nœud de son pool de nœuds actuel et ajoutez-le au pool de nœuds avec le mode de planification cible.
Pour modifier le mode de planification d'un pool de nœuds entier, modifiez les libellés via les opérations du pool de nœuds. Par défaut, les modifications de libellés d'un pool de nœuds s'appliquent uniquement aux nouveaux nœuds. Pour synchroniser les modifications avec les nœuds existants, sélectionnez Update Labels and Taints of Existing Nodes lors de la modification du pool de nœuds.

Important
L'utilisation directe de kubectl label pour modifier les libellés de planification des nœuds n'est pas recommandée et peut provoquer des problèmes.

L'exécution de kubectl label node <NODE_NAME> ack.node.gpu.schedule=<value> --overwrite pour changer les modes de planification peut entraîner des erreurs d'allocation de ressources pour les pods GPU en cours d'exécution, et peut même déclencher l'éviction des pods ou des erreurs de planification irrécupérables. Utilisez les libellés du pool de nœuds pour gérer les modes de planification et assurer la cohérence sur tous les nœuds du pool.

Aperçu des libellés de planification

Activer les fonctionnalités de planification

Planification exclusive

Planification partagée

cgpu/share/mps

core_mem

binpack

spread

Planification consciente de la topologie

Planification par modèle de carte

Spécifier le modèle de carte

Exclure le modèle de carte

Bonnes pratiques : Utiliser des pools de nœuds distincts pour chaque mode de planification

Modification des modes de planification

`cgpu`/`share`/`mps`

`core_mem`

`binpack`

`spread`