Stockage des données d'application avec des PersistentVolumes

Introduction

Dans ce laboratoire, vous apprendrez à stocker les données d'une application à l'aide de PersistentVolumes dans Kubernetes.

Les PersistentVolumes (PV) sont des ressources Kubernetes qui représentent un espace de stockage réseau au sein d'un cluster. Ils permettent de stocker les données d'une application indépendamment du cycle de vie du conteneur. 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 laboratoire, vous allez créer un PersistentVolume et l'utiliser pour stocker les données d'une application web simple. Vous modifierez ensuite l'application pour utiliser un PersistentVolumeClaim (PVC) afin d'accéder au PersistentVolume. Enfin, vous ajusterez 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 opérationnel. 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.

Créer un PersistentVolume

Dans cette étape, vous allez créer un PersistentVolume destiné au stockage de 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 1Gi avec un mode d'accès ReadWriteOnce. Le champ hostPath spécifie que les données seront stockées sur la machine hôte dans le chemin /mnt/data. Le champ persistentVolumeReclaimPolicy est défini sur Retain, ce qui signifie que les données seront conservées même si le PersistentVolume est supprimé.

Appliquez le PersistentVolume à votre cluster avec 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 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 avec une réplique et un conteneur exécutant l'image nginx. Le champ volumeMounts indique au conteneur de 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 avec la commande suivante :

kubectl apply -f web-app.yaml

Créer un PersistentVolumeClaim

Dans cette étape, vous allez créer un PersistentVolumeClaim pour demander du stockage au 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 500Mi de stockage auprès 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 en cours d'exécution dans le conteneur pour y écrire des données.

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

kubectl get pods -l app=web-app

Vous devriez voir un seul pod exécutant votre application. Notez son nom.

Ensuite, exécutez la commande suivante pour ouvrir une session shell dans le conteneur :

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 shell, exécutez la commande suivante pour créer 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 créé dans le répertoire de données existe toujours avec la commande suivante :

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 que vous avez noté précédemment.

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 1Gi de stockage au lieu de 500Mi.

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 le PersistentVolumeClaim mis à jour à votre cluster avec la commande suivante :

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 laboratoire, vous avez appris à stocker les données d'une 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 dernier pour ajuster les ressources. Vous avez également vérifié que les données étaient conservées sur le PersistentVolume, même après la suppression et la recréation du conteneur.