Comment afficher les taints d'un nœud Kubernetes

Introduction

Kubernetes, la plateforme d'orchestration de conteneurs populaire, offre une fonctionnalité puissante appelée "taints" (souillures) pour contrôler l'ordonnancement des pods sur les nœuds. Dans ce tutoriel, nous allons explorer comment visualiser les taints appliqués aux nœuds Kubernetes, une compétence essentielle pour gérer efficacement votre cluster Kubernetes.

Les taints vous permettent de marquer les nœuds avec des attributs spécifiques qui peuvent repousser certains pods, garantissant que les charges de travail sont ordonnancées de manière appropriée en fonction des capacités et des ressources des nœuds. Comprendre comment visualiser et travailler avec les taints vous aide à maintenir une allocation optimale des ressources dans votre environnement Kubernetes.

Configuration d'un environnement Kubernetes pour les tests

Avant de pouvoir visualiser les taints sur les nœuds Kubernetes, nous avons besoin d'un environnement Kubernetes fonctionnel. Pour ce tutoriel, nous utiliserons Minikube, qui fournit un cluster Kubernetes local et léger à des fins de développement et de test.

Commençons par installer Minikube :

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
rm minikube-linux-amd64

Maintenant que Minikube est installé, démarrons un cluster Kubernetes :

minikube start --driver=docker

Vous devriez voir une sortie similaire à celle-ci :

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Using the docker driver based on user configuration
📌  Using Docker driver with root privileges
👍  Starting control plane node minikube in cluster minikube
🚜  Pulling base image ...
🔥  Creating docker container (CPUs=2, Memory=2200MB) ...
🐳  Preparing Kubernetes v1.26.1 on Docker 23.0.1 ...
    ▪ Generating certificates and keys ...
    ▪ Booting up control plane ...
    ▪ Configuring RBAC rules ...
🔎  Verifying Kubernetes components...
    ▪ Using image gcr.io/k8s-minikube/storage-provisioner:v5
🌟  Enabled addons: default-storageclass, storage-provisioner
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Vérifions que le cluster est en cours d'exécution en vérifiant l'état des nœuds :

kubectl get nodes

Vous devriez voir une sortie similaire à celle-ci :

NAME       STATUS   ROLES           AGE    VERSION
minikube   Ready    control-plane   1m     v1.26.1

Génial ! Nous avons maintenant un environnement Kubernetes fonctionnel pour explorer les taints. La commande kubectl est déjà configurée pour fonctionner avec notre cluster Minikube.

Comprendre les Taints Kubernetes

Avant de commencer à visualiser les taints, comprenons ce qu'ils sont et comment ils fonctionnent dans Kubernetes.

Que sont les Taints ?

Les taints sont des propriétés appliquées aux nœuds Kubernetes qui permettent à un nœud de repousser certains pods. Considérez les taints comme des étiquettes qui marquent les nœuds comme inappropriés pour des types spécifiques de charges de travail.

Les taints fonctionnent en collaboration avec un concept appelé "tolerations" (tolérances). Alors que les taints sont appliqués aux nœuds, les tolérances sont appliquées aux pods. Un pod avec une tolérance correspondant au taint d'un nœud peut être ordonnancé sur ce nœud tainté.

Structure des Taints

Les taints se composent de trois éléments :

Key (Clé) : Une chaîne de caractères qui identifie le taint (par exemple, gpu, disk, network)
Value (Valeur) : Une chaîne de caractères optionnelle assignée à la clé (par exemple, true, high-performance)
Effect (Effet) : Définit comment les pods sans tolérances correspondantes sont traités

Les effets de taint les plus courants sont :

NoSchedule : Les nouveaux pods sans tolérances correspondantes ne seront pas ordonnancés sur le nœud
PreferNoSchedule : Le système essaiera d'éviter de placer des pods sans tolérances correspondantes sur le nœud, mais ce n'est pas garanti
NoExecute : Les nouveaux pods sans tolérances correspondantes ne seront pas ordonnancés sur le nœud, et les pods existants sans tolérances correspondantes seront évincés

Voici la syntaxe d'un taint :

Avec une valeur : key=value:effect
Sans valeur : key:effect

Certains nœuds dans un cluster Kubernetes ont des taints par défaut. Par exemple, les nœuds du plan de contrôle sont souvent taintés avec node-role.kubernetes.io/control-plane:NoSchedule pour empêcher les charges de travail régulières d'être ordonnancées dessus, préservant ainsi les ressources pour les composants système.

Examinons notre nœud Minikube pour voir s'il a des taints par défaut :

kubectl describe node minikube | grep -A3 Taints

Vous verrez probablement une sortie similaire à :

Taints:             node-role.kubernetes.io/control-plane:NoSchedule
Unschedulable:      false
Lease:
  HolderIdentity:  minikube

Cette sortie montre que notre nœud Minikube a un taint qui empêche les pods réguliers d'être ordonnancés dessus, car il s'agit d'un nœud du plan de contrôle.

Visualisation des Taints sur les Nœuds Kubernetes

Maintenant que nous comprenons ce que sont les taints, explorons les différentes méthodes pour visualiser les taints appliqués aux nœuds Kubernetes.

Méthode 1 : Utilisation de kubectl describe

La méthode la plus détaillée pour visualiser les taints sur un nœud est d'utiliser la commande kubectl describe node :

kubectl describe node minikube

Cette commande affiche des informations complètes sur le nœud. Pour vous concentrer uniquement sur les taints, vous pouvez utiliser grep :

kubectl describe node minikube | grep -A1 Taints

Exemple de sortie :

Taints:             node-role.kubernetes.io/control-plane:NoSchedule
Unschedulable:      false

Méthode 2 : Utilisation de kubectl get avec des colonnes personnalisées

Vous pouvez utiliser la commande kubectl get nodes avec des colonnes de sortie personnalisées pour afficher uniquement les taints :

kubectl get nodes -o custom-columns=NAME:.metadata.name,TAINTS:.spec.taints

Exemple de sortie :

NAME       TAINTS
minikube   [map[effect:NoSchedule key:node-role.kubernetes.io/control-plane]]

Méthode 3 : Utilisation de kubectl get avec JSONPath

Une autre approche consiste à utiliser JSONPath pour extraire les informations de taint :

kubectl get nodes minikube -o jsonpath='{.spec.taints}'

Exemple de sortie :

[{"effect":"NoSchedule","key":"node-role.kubernetes.io/control-plane"}]

Pour une meilleure lisibilité, vous pouvez formater la sortie en JSON :

kubectl get nodes minikube -o jsonpath='{.spec.taints}' | jq .

Si vous n'avez pas jq installé, vous pouvez l'installer avec :

sudo apt-get update && sudo apt-get install -y jq

Exemple de sortie formatée :

[
  {
    "effect": "NoSchedule",
    "key": "node-role.kubernetes.io/control-plane"
  }
]

Méthode 4 : Utilisation de kubectl get avec une sortie YAML

Vous pouvez également visualiser la spécification complète du nœud au format YAML et rechercher les taints :

kubectl get node minikube -o yaml | grep -A5 taints:

Exemple de sortie :

  taints:
  - effect: NoSchedule
    key: node-role.kubernetes.io/control-plane
  unschedulable: false
status:
  addresses:

Chacune de ces méthodes fournit les mêmes informations dans différents formats. Choisissez celle qui convient le mieux à vos besoins en fonction de la lisibilité et de la façon dont vous prévoyez d'utiliser les informations.

Ajout et Suppression de Taints

Maintenant que nous savons comment visualiser les taints, apprenons à les ajouter et à les supprimer. Il s'agit d'une opération courante lorsque vous devez contrôler l'ordonnancement des pods ou préparer les nœuds pour la maintenance.

Ajout de Taints aux Nœuds

La syntaxe pour ajouter un taint à un nœud est la suivante :

kubectl taint nodes <node-name> <key>=<value>:<effect>

Ajoutons un taint à notre nœud Minikube pour le marquer comme ayant un GPU :

kubectl taint nodes minikube gpu=true:NoSchedule

Vous devriez voir une sortie comme :

node/minikube tainted

Maintenant, vérifions que le taint a été ajouté :

kubectl describe node minikube | grep -A3 Taints

Exemple de sortie :

Taints:             gpu=true:NoSchedule
                    node-role.kubernetes.io/control-plane:NoSchedule
Unschedulable:      false
Lease:

Comme vous pouvez le constater, notre nœud a maintenant deux taints : le taint original du plan de contrôle et notre nouveau taint GPU.

Suppression de Taints des Nœuds

Pour supprimer un taint, vous ajoutez un signe moins (-) à la même définition de taint :

kubectl taint nodes <node-name> <key>=<value>:<effect>-

Supprimons le taint GPU que nous venons d'ajouter :

kubectl taint nodes minikube gpu=true:NoSchedule-

Vous devriez voir une sortie comme :

node/minikube untainted

Vérifions que le taint a été supprimé :

kubectl describe node minikube | grep -A3 Taints

Exemple de sortie :

Taints:             node-role.kubernetes.io/control-plane:NoSchedule
Unschedulable:      false
Lease:
  HolderIdentity:  minikube

Maintenant, notre nœud est revenu à n'avoir que le taint du plan de contrôle.

Quand utiliser les Taints

Les taints sont particulièrement utiles dans plusieurs scénarios :

Matériel spécialisé (Specialized hardware) : Tainter les nœuds avec du matériel spécial (comme les GPU) pour s'assurer que seules les charges de travail nécessitant ce matériel y sont ordonnancées.
Maintenance des nœuds (Node maintenance) : Ajouter un taint avant d'effectuer la maintenance pour empêcher l'ordonnancement de nouveaux pods.
Isolation de la sécurité (Security isolation) : Maintenir certaines charges de travail séparées des autres pour des raisons de sécurité.
Optimisation des ressources (Resource optimization) : Dédiant des nœuds à des types de charges de travail spécifiques pour une utilisation optimale des ressources.

En comprenant comment visualiser, ajouter et supprimer des taints, vous avez acquis des connaissances fondamentales pour gérer l'ordonnancement des pods dans votre cluster Kubernetes.

Travailler avec les Tolérances

Maintenant que nous comprenons comment fonctionnent les taints, explorons les tolérances - le mécanisme qui permet aux pods d'être ordonnancés sur des nœuds avec des taints correspondants.

Comprendre les Tolérances

Les tolérances sont spécifiées dans les spécifications des pods et permettent aux pods d'être ordonnancés sur des nœuds avec des taints correspondants. Une tolérance se compose de :

key : Correspond à la clé du taint
operator : Soit Equal (correspond à la clé et à la valeur) soit Exists (correspond uniquement à la clé)
value : La valeur à faire correspondre (lors de l'utilisation de l'opérateur Equal)
effect : L'effet à faire correspondre, ou vide pour correspondre à tous les effets
tolerationSeconds : Durée optionnelle pendant laquelle le pod peut rester sur un nœud avec un taint NoExecute correspondant

Création d'un Pod avec des Tolérances

Créons un pod qui tolère notre taint de plan de contrôle. Tout d'abord, créons un fichier YAML pour notre pod :

nano ~/project/toleration-pod.yaml

Maintenant, ajoutez le contenu suivant au fichier :

apiVersion: v1
kind: Pod
metadata:
  name: toleration-pod
spec:
  containers:
    - name: nginx
      image: nginx:latest
  tolerations:
    - key: "node-role.kubernetes.io/control-plane"
      operator: "Exists"
      effect: "NoSchedule"

Cette spécification de pod inclut une tolérance qui correspond au taint du plan de contrôle sur notre nœud. Enregistrez et quittez le fichier (dans nano, appuyez sur Ctrl+O, Entrée, puis Ctrl+X).

Maintenant, créons le pod :

kubectl apply -f ~/project/toleration-pod.yaml

Vous devriez voir une sortie comme :

pod/toleration-pod created

Vérifions si le pod a été ordonnancé sur notre nœud :

kubectl get pods -o wide

Exemple de sortie :

NAME             READY   STATUS    RESTARTS   AGE   IP           NODE       NOMINATED NODE   READINESS GATES
toleration-pod   1/1     Running   0          12s   10.244.0.5   minikube   <none>           <none>

Le pod est en cours d'exécution sur notre nœud minikube car il a une tolérance correspondant au taint du plan de contrôle.

Test avec un Pod sans Tolérances

À titre de comparaison, créons un pod sans tolérances :

nano ~/project/no-toleration-pod.yaml

Ajoutez le contenu suivant :

apiVersion: v1
kind: Pod
metadata:
  name: no-toleration-pod
spec:
  containers:
    - name: nginx
      image: nginx:latest

Enregistrez et quittez le fichier, puis créez le pod :

kubectl apply -f ~/project/no-toleration-pod.yaml

Maintenant, vérifions l'état du pod :

kubectl get pods -o wide

Vous remarquerez peut-être que le pod reste à l'état Pending :

NAME               READY   STATUS    RESTARTS   AGE   IP           NODE       NOMINATED NODE   READINESS GATES
no-toleration-pod  0/1     Pending   0          12s   <none>       <none>     <none>           <none>
toleration-pod     1/1     Running   0          2m    10.244.0.5   minikube   <none>           <none>

Vérifions pourquoi le pod est en attente :

kubectl describe pod no-toleration-pod

Dans la section des événements, vous devriez voir quelque chose comme :

Events:
  Type     Reason            Age   From               Message
  ----     ------            ----  ----               -------
  Warning  FailedScheduling  45s   default-scheduler  0/1 nodes are available: 1 node(s) had untolerated taint {node-role.kubernetes.io/control-plane: }. preemption: 0/1 nodes are available: 1 Preemption is not helpful for scheduling.

Cela confirme que le pod n'a pas pu être ordonnancé car il ne tolère pas le taint du plan de contrôle.

Nettoyage

Nettoyons les pods que nous avons créés :

kubectl delete pod toleration-pod no-toleration-pod

Vous devriez voir :

pod "toleration-pod" deleted
pod "no-toleration-pod" deleted

Félicitations ! Vous comprenez maintenant comment les taints et les tolérances fonctionnent ensemble pour contrôler l'ordonnancement des pods dans Kubernetes.

Résumé

Dans ce laboratoire pratique, vous avez appris à travailler avec les taints et les tolérances Kubernetes, des fonctionnalités clés pour contrôler l'ordonnancement des pods dans votre cluster. Voici ce que vous avez accompli :

Configuration d'un environnement Kubernetes à l'aide de Minikube
Compréhension du concept de taints et de leurs effets sur l'ordonnancement des pods
Exploration de différentes méthodes pour visualiser les taints sur les nœuds Kubernetes
Ajout et suppression de taints des nœuds à l'aide des commandes kubectl
Création de pods avec et sans tolérances pour voir comment ils interagissent avec les nœuds taintés

Ces compétences sont essentielles pour gérer le placement des charges de travail et l'allocation des ressources dans les clusters Kubernetes. En utilisant correctement les taints et les tolérances, vous pouvez vous assurer que les pods sont ordonnancés sur les nœuds appropriés en fonction des exigences matérielles, des caractéristiques de la charge de travail et des contraintes de ressources.

Au fur et à mesure que vous poursuivez votre parcours Kubernetes, vous pouvez vous appuyer sur ces connaissances pour mettre en œuvre des stratégies d'ordonnancement plus sophistiquées, telles que l'affinité et l'anti-affinité des nœuds, afin d'optimiser davantage les ressources de votre cluster.

Comment visualiser les taints appliqués à un nœud Kubernetes

Introduction

Configuration d'un environnement Kubernetes pour les tests

Comprendre les Taints Kubernetes

Que sont les Taints ?

Structure des Taints

Visualisation des Taints sur les Nœuds Kubernetes

Méthode 1 : Utilisation de kubectl describe

Méthode 2 : Utilisation de kubectl get avec des colonnes personnalisées

Méthode 3 : Utilisation de kubectl get avec JSONPath

Méthode 4 : Utilisation de kubectl get avec une sortie YAML

Ajout et Suppression de Taints

Ajout de Taints aux Nœuds

Suppression de Taints des Nœuds

Quand utiliser les Taints

Travailler avec les Tolérances

Comprendre les Tolérances

Création d'un Pod avec des Tolérances

Test avec un Pod sans Tolérances

Nettoyage

Résumé