Planification avec les Sélecteurs de nœuds (Node Selectors)

Introduction

Dans ce laboratoire, nous commencerons par créer un déploiement simple, puis nous lui assignerons des Sélecteurs de nœuds (Node Selectors). Ensuite, nous passerons à des scénarios plus complexes où nous utiliserons différents sélecteurs 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 :

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 déploiement simple

Dans cette étape, nous allons créer un déploiement simple avec un seul pod.

Créez un fichier nommé simple-deployment.yaml avec le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: simple-app
  template:
    metadata:
      labels:
        app: simple-app
    spec:
      containers:
        - name: simple-container
          image: nginx:latest

Utilisez kubectl pour créer le déploiement :

kubectl apply -f simple-deployment.yaml

Vérifiez que le déploiement a été créé :

kubectl get deployments

Assignation de Sélecteurs de nœuds (Node Selectors) à un déploiement

Dans cette étape, nous allons attribuer un Sélecteur de nœud (Node Selector) au déploiement que nous avons créé à l'Étape 1.

Créez les nœuds avec une étiquette (label) :

kubectl label nodes minikube disk=ssd

Modifiez le fichier node-selector-deployment.yaml et ajoutez le champ nodeSelector dans la section spec.template.spec :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: selector-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: selector-app
  template:
    metadata:
      labels:
        app: selector-app
    spec:
      nodeSelector:
        disk: ssd
      containers:
        - name: selector-container
          image: nginx:latest

Utilisez kubectl pour appliquer les modifications :

kubectl apply -f node-selector-deployment.yaml

Vérifiez que le pod a été planifié sur un nœud avec l'étiquette disk=ssd :

kubectl get pods -o wide | grep selector-deployment

Utilisation de différents Sélecteurs de nœuds (Node Selectors)

Dans cette étape, nous allons utiliser différents Sélecteurs de nœuds (Node Selectors) pour planifier des pods sur des nœuds spécifiques en fonction des étiquettes (labels) attribuées à ces nœuds.

Créez trois nœuds avec des étiquettes différentes :

kubectl label nodes minikube resigon=labex
kubectl label nodes minikube gpu=true

Créez un fichier nommé multi-selector-deployment.yaml avec le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multi-selector-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: multi-selector-app
  template:
    metadata:
      labels:
        app: multi-selector-app
    spec:
      containers:
        - name: multi-selector-container
          image: nginx:latest
      nodeSelector:
        resigon: labex
        gpu: "true"

Appliquez les modifications :

kubectl apply -f multi-selector-deployment.yaml

Vérifiez que les pods ont été planifiés sur des nœuds avec les étiquettes appropriées :

kubectl get pods -o wide | grep multi-selector-deployment

Résumé

Dans ce laboratoire, nous avons appris à planifier des pods sur des nœuds spécifiques en utilisant les Sélecteurs de nœuds (Node Selectors) et l'Affinité de nœud (Node Affinity). Nous avons commencé par un déploiement simple, puis nous sommes passés à des scénarios plus complexes où nous avons utilisé différents sélecteurs et règles d'affinité pour planifier des pods sur des nœuds spécifiques en fonction des étiquettes (labels) attribuées à ces nœuds.

Félicitations! Vous avez terminé avec succès ce laboratoire.