Stocker des données applicatives avec des PersistentVolumes

Introduction

Dans ce lab, vous apprendrez à stocker des données applicatives à l'aide de PersistentVolumes (volumes persistants) dans Kubernetes.

Les PersistentVolumes (PV) sont des ressources Kubernetes qui représentent un espace de stockage réseau dans un cluster. Ils permettent de stocker des données applicatives indépendamment du cycle de vie des conteneurs. Cela signifie que les données sont préservées même si le conteneur est arrêté ou déplacé vers un autre nœud.

Dans ce lab, vous allez créer un PersistentVolume et l'utiliser pour stocker les données d'une application web simple. Ensuite, vous modifierez l'application pour utiliser un PersistentVolumeClaim (PVC) afin d'accéder au PersistentVolume. Enfin, vous modifierez le PVC pour demander des ressources de stockage 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 bien en cours d'exécution :

Vérifiez l'état du cluster Minikube :
```
minikube status
```
- Recherchez les composants tels que kubelet et apiserver qui doivent être indiqués comme Running.
- Si le cluster ne fonctionne pas, 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.

Créer un PersistentVolume

Dans cette étape, vous allez créer un PersistentVolume qui pourra être utilisé pour stocker des données. Créez un fichier YAML nommé pv.yaml avec le contenu suivant :

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  hostPath:
    path: /mnt/data

Ce fichier crée un PersistentVolume d'une capacité de 1Go avec un mode d'accès ReadWriteOnce. Le champ hostPath indique que les données seront stockées sur la machine hôte au chemin /mnt/data. Le champ persistentVolumeReclaimPolicy est défini sur Retain, ce qui signifie que les données seront préservées même si le PersistentVolume est supprimé.

Appliquez le PersistentVolume à votre cluster à l'aide de la commande suivante :

kubectl apply -f pv.yaml

Déployer une application web simple

Dans cette étape, vous allez déployer une application web simple qui stockera ses données sur le PersistentVolume que vous avez créé à l'étape précédente. Créez un fichier YAML nommé web-app.yaml avec le contenu suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
        - name: web-app
          image: nginx
          volumeMounts:
            - name: data
              mountPath: /usr/share/nginx/html/data
      volumes:
        - name: data
          persistentVolumeClaim:
            claimName: my-pvc

Ce fichier crée un déploiement (Deployment) avec un réplica et un conteneur exécutant l'image nginx. Le champ volumeMounts indique que le conteneur doit monter le PersistentVolume sur le chemin /usr/share/nginx/html/data. Le champ volumes spécifie que le conteneur doit utiliser un PersistentVolumeClaim nommé my-pvc.

Appliquez le déploiement à votre cluster à l'aide de la commande suivante :

kubectl apply -f web-app.yaml

Créer un PersistentVolumeClaim

Dans cette étape, vous allez créer un PersistentVolumeClaim (PVC) qui servira à demander du stockage auprès du PersistentVolume créé à l'étape 2. Créez un fichier YAML nommé pvc.yaml avec le contenu suivant :

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi

Ce fichier crée un PersistentVolumeClaim avec un mode d'accès ReadWriteOnce et une demande de 500Mo de stockage provenant du PersistentVolume.

Appliquez le PersistentVolumeClaim à votre cluster avec la commande suivante :

kubectl apply -f pvc.yaml

Vérifier la persistance des données

Dans cette étape, vous allez vérifier que les données sont bien persistées sur le PersistentVolume. Vous accéderez à l'application web exécutée dans le conteneur et écrirez des données sur le PersistentVolume.

Tout d'abord, recherchez le nom du pod exécutant votre application en exécutant la commande suivante :

kubectl get pods -l app=web-app

Vous devriez voir un seul pod exécuter votre application. Notez le nom de ce pod.

Ensuite, exécutez la commande suivante pour ouvrir une session de terminal (shell) à l'intérieur du conteneur de votre application :

kubectl exec -it pod-name -- /bin/sh

Remplacez pod-name par le nom du pod que vous avez noté précédemment.

Une fois dans la session du terminal, exécutez la commande suivante pour ajouter un fichier test.txt :

echo "This is a test file." > /usr/share/nginx/html/data/test.txt

Cette commande crée un fichier nommé test.txt contenant le texte "This is a test file." dans le répertoire de données du PersistentVolume.

Supprimez l'application web avec la commande suivante :

kubectl delete deployment web-app

Recréez l'application web avec la commande suivante :

kubectl apply -f web-app.yaml

Vérifiez que le fichier que vous avez créé dans le répertoire de données existe toujours à l'aide des commandes suivantes :

kubectl get pods -l app=web-app
kubectl exec pod-name -- cat /usr/share/nginx/html/data/test.txt

Remplacez pod-name par le nom du pod actuel de votre application.

Modifier les ressources de stockage du PVC

Dans cette étape, vous allez modifier le PVC pour demander des ressources de stockage spécifiques au PersistentVolume. Modifiez le fichier pvc.yaml pour demander 1Go de stockage au lieu de 500Mo.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Ajoutez le champ allowVolumeExpansion: true à la storageclass sur la dernière ligne.

kubectl edit storageclass standard

Exemple de modification du stockage PVC

Appliquez les modifications du PersistentVolumeClaim à votre cluster en exécutant les commandes suivantes :

kubectl delete deployment web-app
kubectl delete pvc my-pvc
kubectl apply -f web-app.yaml
kubectl apply -f pvc.yaml

Résumé

Dans ce lab, vous avez appris à stocker des données d'application avec des PersistentVolumes dans Kubernetes. Vous avez créé un PersistentVolume, déployé une application web simple utilisant ce volume, créé un PersistentVolumeClaim pour demander du stockage, et modifié ce PVC pour ajuster les ressources de stockage. Vous avez également vérifié que les données persistaient sur le PersistentVolume même après la suppression ou le déplacement du conteneur vers un autre nœud.