Aller au contenu principal

Lab 6.4 - StatefulSet avec Stockage Persistant

Objectifs du Lab​

À la fin de ce lab, vous serez capable de:

  • Créer un StatefulSet avec des volumes persistants.
  • Comprendre le provisionnement de volumes pour chaque Pod.
  • Vérifier l'identité stable des Pods et volumes.
  • Tester la persistance des données lors des redémarrages.
  • Comprendre les différences entre StatefulSet et Deployment pour le stockage.

Durée Estimée​

60-75 minutes

Prérequis​

  • kubectl installé et configuré.
  • Cluster Kubernetes local fonctionnel (minikube ou kind).
  • Connaissances sur les StatefulSets et le stockage persistant (Chapitres 6.4 et 7.1).

Partie 1: Préparation de la StorageClass​

Pour un StatefulSet, chaque Pod a besoin de son propre volume persistant. Nous allons utiliser une StorageClass pour le provisionnement dynamique.

Étape 1.1: Créer une StorageClass​

Créez un fichier storageclass-statefulset.yaml:

# storageclass-statefulset.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: statefulset-storage
provisioner: k8s.io/minikube-hostpath # Pour minikube, ou kubernetes.io/no-provisioner pour kind
volumeBindingMode: WaitForFirstConsumer
reclaimPolicy: Delete
allowVolumeExpansion: false

Note: Si vous utilisez kind ou un cluster sans provisionneur, vous devrez créer les PVs manuellement. Pour ce lab, nous supposons minikube.

Appliquez la StorageClass:

kubectl apply -f storageclass-statefulset.yaml

Partie 2: Création d'un StatefulSet avec Stockage​

Nous allons créer un StatefulSet simple qui stocke des données dans des volumes persistants.

Étape 2.1: Créer le StatefulSet​

Créez un fichier statefulset-with-storage.yaml:

# statefulset-with-storage.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web-app
spec:
  serviceName: web-app-service # Nom du Service headless (requis pour StatefulSet)
  replicas: 3 # Créer 3 Pods
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: nginx
        image: nginx:1.20
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html # Montage du volume persistant
        command: ["/bin/sh", "-c"]
        args:
        - |
          echo "Pod $(hostname) - $(date)" > /usr/share/nginx/html/index.html
          echo "Données persistantes du Pod $(hostname)" >> /usr/share/nginx/html/data.txt
          nginx -g "daemon off;"
  volumeClaimTemplates: # Template pour créer un PVC pour chaque Pod
  - metadata:
      name: www # Nom du volume (sera utilisé dans volumeMounts)
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: statefulset-storage # Utilise notre StorageClass
      resources:
        requests:
          storage: 100Mi # Taille du volume pour chaque Pod

Explication:

  • serviceName: web-app-service: Un StatefulSet nécessite un Service headless pour la découverte DNS.
  • volumeClaimTemplates: Crée automatiquement un PVC pour chaque Pod du StatefulSet. Chaque Pod aura son propre volume persistant.
  • Les Pods seront nommés web-app-0, web-app-1, web-app-2 de manière ordonnée.

Étape 2.2: Créer le Service Headless​

Un StatefulSet nécessite un Service headless (ClusterIP avec clusterIP: None) pour la découverte DNS:

# service-headless.yaml
apiVersion: v1
kind: Service
metadata:
  name: web-app-service
spec:
  clusterIP: None # Service headless
  selector:
    app: web-app
  ports:
  - port: 80
    name: web

Appliquez le Service:

kubectl apply -f service-headless.yaml

Appliquez le StatefulSet:

kubectl apply -f statefulset-with-storage.yaml

Partie 3: Observation du Provisionnement​

Étape 3.1: Vérifier la Création des Pods​

Les Pods d'un StatefulSet sont créés de manière séquentielle (un par un):

kubectl get pods -l app=web-app -w

Vous devriez voir les Pods être créés dans l'ordre: web-app-0, puis web-app-1, puis web-app-2.

Étape 3.2: Vérifier les PVCs Créés​

Chaque Pod a son propre PVC:

kubectl get pvc

Vous devriez voir trois PVCs:

  • www-web-app-0
  • www-web-app-1
  • www-web-app-2

Chaque PVC est lié à son propre PV:

kubectl get pv

Étape 3.3: Vérifier les Données dans Chaque Pod​

Chaque Pod a ses propres données persistantes:

# Pod 0
kubectl exec web-app-0 -- cat /usr/share/nginx/html/index.html
kubectl exec web-app-0 -- cat /usr/share/nginx/html/data.txt

# Pod 1
kubectl exec web-app-1 -- cat /usr/share/nginx/html/index.html
kubectl exec web-app-1 -- cat /usr/share/nginx/html/data.txt

# Pod 2
kubectl exec web-app-2 -- cat /usr/share/nginx/html/index.html
kubectl exec web-app-2 -- cat /usr/share/nginx/html/data.txt

Chaque Pod devrait afficher son propre hostname et ses propres données.

Partie 4: Test de Persistance​

Étape 4.1: Ajouter des Données Uniques​

Ajoutez des données uniques à chaque Pod:

kubectl exec web-app-0 -- sh -c "echo 'Données uniques Pod 0 - $(date)' >> /usr/share/nginx/html/data.txt"
kubectl exec web-app-1 -- sh -c "echo 'Données uniques Pod 1 - $(date)' >> /usr/share/nginx/html/data.txt"
kubectl exec web-app-2 -- sh -c "echo 'Données uniques Pod 2 - $(date)' >> /usr/share/nginx/html/data.txt"

Vérifiez les données:

kubectl exec web-app-0 -- cat /usr/share/nginx/html/data.txt

Étape 4.2: Supprimer un Pod​

Supprimez un Pod pour tester la persistance:

kubectl delete pod web-app-0

Le StatefulSet recréera automatiquement le Pod avec le même nom (web-app-0).

Attendez que le nouveau Pod soit Running:

kubectl get pods -l app=web-app

Étape 4.3: Vérifier la Persistance​

Vérifiez que les données sont toujours présentes après le redémarrage:

kubectl exec web-app-0 -- cat /usr/share/nginx/html/data.txt

Vous devriez voir toutes les données précédentes, y compris les "Données uniques Pod 0", ce qui prouve que le volume persistant a été remonté avec les mêmes données.

Partie 5: Scaling du StatefulSet​

Étape 5.1: Augmenter le Nombre de Réplicas​

Augmentez le nombre de Pods:

kubectl scale statefulset web-app --replicas=5

Vérifiez que de nouveaux Pods et PVCs sont créés:

kubectl get pods -l app=web-app
kubectl get pvc

Vous devriez voir web-app-3 et web-app-4 avec leurs PVCs respectifs.

Étape 5.2: Réduire le Nombre de Réplicas​

Réduisez le nombre de Pods:

kubectl scale statefulset web-app --replicas=2

Vérifiez que les Pods sont supprimés dans l'ordre inverse (du plus grand au plus petit):

kubectl get pods -l app=web-app -w

Important: Les PVCs ne sont PAS supprimés automatiquement. Vérifiez:

kubectl get pvc

Les PVCs des Pods supprimés (www-web-app-2, www-web-app-3, www-web-app-4) sont toujours présents, préservant les données.

Partie 6: Nettoyage​

Supprimez les ressources créées:

kubectl delete statefulset web-app
kubectl delete service web-app-service
kubectl delete pvc -l app=web-app # Supprimer tous les PVCs du StatefulSet
# Les PVs seront supprimés automatiquement si reclaimPolicy: Delete
kubectl delete -f storageclass-statefulset.yaml

Résumé du Lab​

Dans ce lab, vous avez exploré l'utilisation des StatefulSets avec stockage persistant. Vous avez appris à créer un StatefulSet avec volumeClaimTemplates, à observer le provisionnement séquentiel des Pods et des volumes, à tester la persistance des données lors des redémarrages, et à comprendre le comportement du scaling avec les volumes persistants.

Prochaines Étapes​

Ce module sur le stockage est maintenant complet. Vous pouvez passer au Module 7 sur les Workloads Avancés.

Module 7: Workloads Avancés

Lab créé le: Décembre 2024