Utiliser des teintes de nœud dans un cluster AKS activé par le cluster Azure Arc

Article
06/06/2024

S’applique à : Azure Local, version 23H2

Cet article explique comment utiliser des teintes de nœud dans un cluster AKS.

Vue d’ensemble

Le mécanisme de planification AKS est chargé de placer des pods sur des nœuds et est basé sur le planificateur Kubernetes en amont, kube-scheduler. Vous pouvez limiter l’exécution d’un pod sur des nœuds particuliers en demandant au nœud de rejeter un ensemble de pods à l’aide de teintes de nœud, qui interagissent avec le planificateur AKS.

Les répulsions de nœud fonctionnent en marquant un nœud afin que le planificateur évite de placer certains pods sur les nœuds marqués. Vous pouvez placer des tolérances sur un pod pour permettre au planificateur de planifier ce pod sur un nœud avec une répulsion correspondante. Les répulsions et les tolérances fonctionnent ensemble pour vous aider à contrôler la façon dont le planificateur place les pods sur des nœuds. Pour plus d’informations, consultez les exemple de cas d’usage des répulsions et des tolérances.

Les répulsions sont des paires clé-valeur avec un effet. Il existe trois valeurs pour le champ d’effet lors de l’utilisation de répulsions de nœud : NoExecute, NoSchedule et PreferNoSchedule.

NoExecute : les pods déjà en cours d’exécution sur le nœud sont immédiatement évincés s’ils n’ont pas une tolérance correspondante. Si un pod a une tolérance correspondante, il peut être évincé si des tolerationSeconds sont spécifiées.
NoSchedule : seuls des pods avec une tolérance correspondante sont placés sur ce nœud. Les pods existants ne sont pas évincés.
PreferNoSchedule : le planificateur évite de placer des pods qui n’ont pas une tolérance correspondante.

Avant de commencer

Cet article suppose que vous disposez d’un cluster AKS. Si vous avez besoin d’un cluster AKS, vous pouvez en créer un à l’aide d’Azure CLI, d’Azure PowerShell ou du Portail Azure.
Lorsque vous créez un pool de nœuds, vous pouvez y ajouter des teintes. Quand vous ajoutez une aversion, tous les nœuds du pool reçoivent cette aversion.

Important

Vous devez ajouter des teintes ou des étiquettes à des nœuds pour l’ensemble du pool de nœuds à l’aide az aksarc nodepoolde . Nous vous déconseillons d’appliquer kubectl des teintes ou des étiquettes à des nœuds individuels dans un pool de nœuds.

Définir des teintes d’un pool de nœuds

Créez un pool de nœuds avec une teinte à l’aide de la commande az aksarc nodepool add . Spécifiez le nom taintnp et utilisez le --node-taints paramètre pour spécifier sku=gpu:NoSchedule la teinte :

az aksarc nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name taintnp \
    --node-count 1 \
    --node-taints sku=gpu:NoSchedule \
    --no-wait

Vérifiez l’état du pool de nœuds à l’aide de la az aksarc nodepool list commande :

az aksarc nodepool list -g myResourceGroup --cluster-name myAKSCluster

L’exemple de sortie suivant montre que le taintnp pool de nœuds crée des nœuds avec les éléments spécifiés nodeTaints:

[
  {
    ...
    "count": 1,
    ...
    "name": "taintnp",
    ...
    "provisioningState": "Succeeded",
    ...
    "nodeTaints":  [
      "sku=gpu:NoSchedule"
    ],
    ...
  },
 ...
]

Les informations concernant la teinte sont visibles dans Kubernetes pour la gestion des règles de planification des nœuds. Le planificateur Kubernetes peut utiliser des teintes et des tolérances pour limiter les charges de travail qui peuvent s’exécuter sur des nœuds.

Quand une teinte est appliquée à un nœud, seuls des pods spécifiques peuvent être planifiés sur le nœud.
Une tolérance est ensuite appliquée à un pod qui leur permet de « tolérer » la teinte d’un nœud.

Définir des tolérances de pool de nœuds

À l’étape précédente, vous avez appliqué la sku=gpu:NoSchedule teinte lorsque vous avez créé le pool de nœuds. L’exemple de manifeste YAML suivant utilise une tolérance pour permettre au planificateur Kubernetes d’exécuter un pod NGINX sur un nœud dans ce pool de nœuds :

Créez un fichier nommé nginx-toleration.yaml et copiez/collez l’exemple YAML suivant :

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - image: mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine
    name: mypod
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 1
        memory: 2G
  tolerations:
  - key: "sku"
    operator: "Equal"
    value: "gpu"
    effect: "NoSchedule"

Planifiez le pod à l’aide de la commande kubectl apply :

kubectl apply -f nginx-toleration.yaml

Il faut quelques secondes pour planifier le pod et extraire l’image NGINX.

Vérifiez l’état à l’aide de la kubectl describe pod commande :

kubectl describe pod mypod

L’exemple de sortie condensé suivant montre que la sku=gpu:NoSchedule tolérance est appliquée. Dans la section Événements , le planificateur a affecté le pod au moc-lbeof1gn6x3 nœud :

[...]
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
                 sku=gpu:NoSchedule
Events:
  Type    Reason     Age    From                Message
  ----    ------     ----   ----                -------
  Normal  Scheduled  54s  default-scheduler   Successfully assigned default/mypod to moc-lbeof1gn6x3
  Normal  Pulling    53s  kubelet             Pulling image "mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine"
  Normal  Pulled     48s  kubelet             Successfully pulled image "mcr.microsoft.com/oss/nginx/nginx:1.15.9-alpine" in 3.025148695s (3.025157609s including waiting)
  Normal  Created    48s  kubelet             Created container
  Normal  Started    48s  kubelet             Started container

Seuls les pods auxquels cette tolérance est appliquée peuvent être planifiés sur les nœuds dans taintnp. Tous les autres pods seront planifiés dans le pool de nœuds nodepool1. Si vous créez des pools de nœuds supplémentaires, vous pouvez utiliser des teintes et des tolérances supplémentaires pour limiter les pods qui peuvent être planifiés sur ces ressources de nœud.

Mettre à jour un pool de nœuds de cluster pour ajouter une teinte de nœud

Mettez à jour un cluster pour ajouter une teinte de nœud à l’aide de la az aksarc update commande et du --node-taints paramètre à spécifier sku=gpu:NoSchedule pour la teinte. Toutes les teintes existantes sont remplacées par les nouvelles valeurs. Les anciennes teintes sont supprimées :

az aksarc update -g myResourceGroup --cluster-name myAKSCluster --name taintnp --node-taints "sku=gpu:NoSchedule"

Étapes suivantes

Utilisez des étiquettes dans un cluster AKS avec Azure Arc.

Partager via