Planification avec l'affinité de nœud (Node Affinity)

Introduction

Dans Kubernetes, l'affinité de nœud (node affinity) est utilisée pour planifier des pods sur des nœuds répondant à certaines conditions. Cela permet de garantir que les pods sont déployés sur des types de nœuds spécifiques ou d'équilibrer la charge de travail entre les nœuds. Dans ce laboratoire, nous apprendrons à utiliser l'affinité de nœud pour planifier des pods sur des nœuds spécifiques.

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 :

Lancez Minikube pour initialiser un cluster Kubernetes :
```
minikube start
```
- Cette commande configure un cluster Kubernetes à nœud unique sur votre machine locale.
- Le démarrage de Minikube peut prendre quelques minutes selon les 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 indiqués comme Running.
- Si le cluster n'est pas en cours d'exécution, relancez 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.

Exécutez les étapes restantes de ce laboratoire depuis /home/labex/project afin que les fichiers YAML restent dans le même répertoire de travail.

Création d'un nœud avec des étiquettes (labels)

Dans cette étape, nous allons créer un nœud avec une étiquette qui sera utilisée pour planifier les pods.

Créez un fichier nommé node-with-label.yaml avec le contenu suivant dans le répertoire /home/labex/project :

apiVersion: v1
kind: Node
metadata:
  name: minikube
  labels:
    type: web

Appliquez les modifications :

kubectl apply -f node-with-label.yaml

Vérifiez que le nœud a été créé et étiqueté :

kubectl get nodes --show-labels

Création d'un pod avec l'affinité de nœud

Dans cette étape, nous allons créer un pod avec une règle d'affinité de nœud qui garantira qu'il est planifié sur un nœud possédant une étiquette spécifique.

Créez un fichier nommé pod-with-node-affinity.yaml avec le contenu suivant dans le répertoire /home/labex/project :

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - web

Appliquez les modifications :

kubectl apply -f pod-with-node-affinity.yaml

Vérifiez que le pod est planifié sur le nœud avec l'étiquette type=web :

kubectl get pod pod-with-node-affinity -o wide

Création d'un pod avec l'anti-affinité de nœud

Dans cette étape, nous allons créer un pod avec une règle d'anti-affinité de nœud qui garantira qu'il n'est pas planifié sur un nœud possédant une étiquette spécifique.

Créez un fichier nommé pod-with-node-anti-affinity.yaml avec le contenu suivant dans le répertoire /home/labex/project :

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-anti-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: NotIn
                values:
                  - web

Appliquez les modifications :

kubectl apply -f pod-with-node-anti-affinity.yaml

Vérifiez que le pod n'est pas planifié sur le nœud avec l'étiquette type=db :

kubectl get pod pod-with-node-anti-affinity -o wide

Création d'un pod avec l'affinité de nœud et le sélecteur de nœud

Dans cette étape, nous allons créer un pod utilisant à la fois une règle d'affinité de nœud et un sélecteur de nœud (node selector) pour garantir qu'il est planifié sur un nœud avec une étiquette spécifique.

Créez un fichier nommé pod-with-node-affinity-and-selector.yaml avec le contenu suivant dans le répertoire /home/labex/project :

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-affinity-and-selector
spec:
  containers:
    - name: nginx
      image: nginx:latest
  nodeSelector:
    type: web
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - db

Appliquez les modifications :

kubectl apply -f pod-with-node-affinity-and-selector.yaml

Vérifiez que le pod n'est pas planifié sur le nœud avec l'étiquette type=web :

kubectl get pod pod-with-node-affinity-and-selector -o wide

Création d'un pod avec plusieurs règles d'affinité de nœud

Dans cette étape, nous allons créer un pod avec plusieurs règles d'affinité de nœud qui garantiront qu'il est planifié sur un nœud dont les étiquettes correspondent à toutes les règles.

Créez un fichier nommé pod-with-multiple-node-affinity.yaml avec le contenu suivant dans le répertoire /home/labex/project :

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-multiple-node-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - web
          - matchExpressions:
              - key: disktype
                operator: In
                values:
                  - ssd

Appliquez les modifications :

kubectl apply -f pod-with-multiple-node-affinity.yaml

Vérifiez que le pod est planifié sur le nœud avec les étiquettes type=web et disktype=ssd :

kubectl get pod pod-with-multiple-node-affinity -o wide

Résumé

Dans ce laboratoire, nous avons appris à utiliser l'affinité de nœud pour planifier des pods sur des nœuds spécifiques. Nous avons créé un nœud avec une étiquette, puis créé des pods avec des règles d'affinité de nœud garantissant leur planification sur des nœuds possédant des étiquettes spécifiques. Nous avons également créé un pod avec une règle d'anti-affinité de nœud pour éviter qu'il ne soit planifié sur un nœud spécifique. Enfin, nous avons créé un pod avec plusieurs règles d'affinité de nœud pour garantir qu'il soit planifié sur un nœud correspondant à l'ensemble des règles définies.