lumikha

2 min de lecture

Node Affinity : attirer vos pods vers les bons nodes

requiredDuringScheduling vs preferredDuringScheduling, différence avec les Taints, et cas d'usage concrets de la Node Affinity Kubernetes sur AKS.

La Node Affinity permet de définir des règles d'attraction : un pod déclare ses préférences ou exigences concernant les nodes sur lesquels il accepte d'être schedulé. C'est le pendant des Taints — qui repoussent — appliqué côté pod.

Les deux modes#

requiredDuringSchedulingIgnoredDuringExecution#

Règle stricte : si aucun node ne satisfait la condition, le pod reste en Pending. Le scheduler ne le placera jamais sur un node qui ne matche pas.

spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: agentpool
                operator: In
                values:
                  - gpupool

preferredDuringSchedulingIgnoredDuringExecution#

Règle souple : le scheduler essaie de placer le pod sur un node qui satisfait la condition, mais si aucun n'est disponible, il le place ailleurs. Le weight (1-100) détermine la priorité relative quand plusieurs règles entrent en compétition.

spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
        - weight: 80
          preference:
            matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                  - francecentral-1
        - weight: 20
          preference:
            matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                  - francecentral-2

Ici, un node de la zone 1 reçoit un bonus de score de 80, un node de la zone 2 un bonus de 20 : à ressources équivalentes, le scheduler choisit la zone 1, puis la zone 2, et ailleurs si nécessaire. Le poids n'est pas un pourcentage de répartition : il s'ajoute aux autres critères de scoring du scheduler.

Opérateurs disponibles#

OpérateurSignification
InLa valeur du label est dans la liste
NotInLa valeur du label n'est pas dans la liste
ExistsLe label existe (quelle que soit la valeur)
DoesNotExistLe label n'existe pas
GtLa valeur est supérieure (comparaison numérique)
LtLa valeur est inférieure

Cas d'usage sur AKS#

Cibler un node pool spécifique#

AKS label automatiquement les nodes avec agentpool=<nom-du-pool>. Pour forcer des pods sur un pool dédié :

spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: agentpool
                operator: In
                values:
                  - infrapool

Répartition multi-zones#

Pour distribuer un Deployment sur plusieurs zones de disponibilité :

spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
        - weight: 1
          preference:
            matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                  - francecentral-1
                  - francecentral-2
                  - francecentral-3

Cette règle ne fait que favoriser les nodes de ces trois zones : elle ne répartit pas les pods entre elles. La répartition elle-même se fait avec topologySpreadConstraints (clé topology.kubernetes.io/zone).

Différence avec les Taints#

TaintNode Affinity
Posée surLe nodeLe pod
DirectionRepousse les pods sans TolerationAttire les pods vers certains nodes
Sans Toleration / sans matchPod ignoré par le nodeDépend du mode (required → Pending, preferred → placement ailleurs)

En pratique, les deux se combinent : une Taint sur un node GPU pour empêcher les pods ordinaires d'y atterrir, et une Node Affinity dans les pods GPU pour les attirer vers ce type de node.

Schéma taint et Node Affinity sur un pool GPU : le pod web, sans toleration ni affinity, va sur systempool / userpool et est repoussé par la taint gpu=true:NoSchedule du gpupool ; le pod GPU avec toleration et affinity agentpool=gpupool (required) est attiré et toléré sur le gpupool ; un pod GPU avec seulement la toleration peut atterrir sur n'importe quel pool. La taint repousse, l'affinity attire : il faut les deux

nodeSelector vs Node Affinity#

nodeSelector est l'ancienne API, plus simple mais limitée à une correspondance exacte :

spec:
  nodeSelector:
    agentpool: gpupool

Node Affinity est plus expressive (opérateurs, poids, plusieurs conditions) et est à privilégier dès que la règle dépasse une simple égalité. nodeSelector n'est pas déprécié : la documentation Kubernetes le présente toujours comme la forme la plus simple de contrainte, adaptée aux cas simples.

← Tous les articles