Marques (Taints) et Tolérances (Tolerations)

Introduction

Les taints (marques) et les tolerations (tolerances) sont utilisés dans Kubernetes pour spécifier quels nœuds sont appropriés pour planifier certains pods. Les taints sont appliqués aux nœuds pour repousser les pods, tandis que les tolerations sont appliqués aux pods pour les attirer vers des nœuds spécifiques. Dans ce labo (atelier), nous apprendrons à utiliser les taints et les tolerations pour planifier des pods sur des nœuds spécifiques.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 100%. Il a reçu un taux d'avis positifs de 100% de la part des apprenants.

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes en cours d'exécution. Minikube est un environnement Kubernetes léger qui s'exécute sur votre machine locale.

Accédez à votre répertoire de travail :

Ouvrez le terminal et accédez au dossier de projet par défaut :
```
cd /home/labex/project
```
Démarrez Minikube :

Démarrez Minikube pour initialiser un cluster Kubernetes :
```
minikube start
```
- Cette commande configure un cluster Kubernetes mono - nœud sur votre machine locale.
- Minikube peut prendre quelques minutes à démarrer en fonction des performances de votre système.
Vérifiez que Minikube est en cours d'exécution :

Vérifiez l'état du cluster Minikube :
```
minikube status
```
- Recherchez des composants tels que kubelet et apiserver listés comme Running (En cours d'exécution).
- Si le cluster n'est pas en cours d'exécution, relancez la commande minikube start.

Si vous rencontrez des problèmes lors du démarrage de Minikube, utilisez minikube delete pour réinitialiser l'environnement si nécessaire.

Création d'un nœud avec une marque (taint)

Dans cette étape, nous allons créer un nœud avec une marque (taint) qui repoussera certains pods.

Étiqueter un nœud avec une étiquette personnalisée :

kubectl label nodes minikube disk-type=ssd

Appliquer une marque (taint) au nœud avec la commande suivante :

kubectl taint nodes minikube disk-type=ssd:NoSchedule

L'effet NoSchedule empêchera les pods sans tolérances (tolerations) d'être planifiés sur ce nœud.

Création d'un pod sans tolérances (tolerations)

Dans cette étape, nous allons créer un pod sans tolérances (tolerations) et vérifier qu'il ne peut pas être planifié sur le nœud marqué (tainted).

Créez un fichier nommé pod-without-toleration.yaml avec le contenu suivant :

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

Appliquez les modifications :

kubectl apply -f pod-without-toleration.yaml

Vérifiez que le pod n'est pas planifié sur le nœud marqué (tainted) :

kubectl describe pod pod-without-toleration | grep -i taint

La sortie devrait montrer que le pod n'est pas planifié sur le nœud avec la marque (taint).

Création d'un pod avec des tolérances (tolerations)

Dans cette étape, nous allons créer un pod avec des tolérances (tolerations) qui lui permettront d'être planifié sur le nœud marqué (tainted).

Créez un fichier nommé pod-with-toleration.yaml avec le contenu suivant :

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-toleration
spec:
  containers:
    - name: nginx
      image: nginx:latest
  tolerations:
    - key: "disk-type"
      operator: "Equal"
      value: "ssd"
      effect: "NoSchedule"

Appliquez les modifications :

kubectl apply -f pod-with-toleration.yaml

Vérifiez que le pod est planifié sur le nœud marqué (tainted) :

kubectl get pod pod-with-toleration -o wide

Tolérer plusieurs marques (taints)

Dans cette étape, nous allons créer un pod avec plusieurs tolérances (tolerations) qui lui permettront d'être planifié sur des nœuds avec plusieurs marques (taints).

Créez un fichier nommé pod-with-multiple-tolerations.yaml avec le contenu suivant :

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-multiple-tolerations
spec:
  containers:
    - name: nginx
      image: nginx:latest
  tolerations:
    - key: "disk-type"
      operator: "Equal"
      value: "ssd"
      effect: "NoSchedule"
    - key: "gpu"
      operator: "Equal"
      value: "true"
      effect: "NoSchedule"

Appliquez les modifications :

kubectl apply -f pod-with-multiple-tolerations.yaml

Vérifiez que le pod est planifié sur un nœud avec les deux marques (taints) :

kubectl get pod pod-with-multiple-tolerations -o wide

Résumé

Dans ce laboratoire, nous avons appris à utiliser les marques (taints) et les tolérances (tolerations) pour planifier des pods sur des nœuds spécifiques. Nous avons commencé par créer un nœud marqué (tainted) et vérifié que les pods sans tolérances (tolerations) ne pouvaient pas être planifiés sur celui-ci. Nous avons ensuite créé un pod avec des tolérances (tolerations) et vérifié qu'il pouvait être planifié sur le nœud marqué (tainted). Enfin, nous avons créé un pod avec plusieurs tolérances (tolerations) et vérifié qu'il pouvait être planifié sur des nœuds avec plusieurs marques (taints).

Les marques (taints) et les tolérances (tolerations) sont une fonctionnalité puissante de Kubernetes qui peut être utilisée pour garantir que certains charges de travail ne sont planifiées que sur des nœuds spécifiques.