Aller au contenu

Lab 03 : Gestion des volumes dans OKS

À l’issue de ce lab, vous serez capable de :

  • identifier les StorageClasses fournies par OKS et leur politique de rétention (Retain ou Delete) ;
  • créer un PersistentVolumeClaim (PVC) qui provisionne dynamiquement un volume BSU (Block Storage Unit) ;
  • monter ce volume dans un Pod et vérifier la persistance des données ;
  • créer un VolumeSnapshot, qui crée un snapshot OUTSCALE du volume ;
  • restaurer les données dans un nouveau volume à partir du snapshot.

Dans ce lab, vous travaillez dans le cluster oks-lab01-cluster créé au Lab 01, dans le namespace oks-lab03.

Le cluster OKS intègre le pilote CSI (Container Storage Interface) d’OUTSCALE, bsu.csi.outscale.com. Quand un Pod utilise un PVC, ce pilote crée un volume BSU, dans la Sous-région du nœud, puis l’attache au nœud qui exécute le Pod. Dans Kubernetes, ce volume est représenté par un PersistentVolume (PV).

Vous créez ensuite un VolumeSnapshot du PVC : le pilote CSI crée un snapshot OUTSCALE du volume BSU. Vous supprimez le Pod et le PVC d’origine, puis vous créez un nouveau PVC à partir du snapshot : un nouveau volume BSU est créé avec les données sauvegardées.

Avant de commencer, vous devez disposer :

  • du cluster oks-lab01-cluster à l’état ready, avec ses NodePools, créé dans le Lab 01 ;
  • du fichier oks-lab01-kubeconfig.yaml récupéré dans le Lab 01 ;
  • de kubectl et octl installés et configurés (Lab 01) ;
  • de connaissances de base sur les objets Kubernetes Pod et namespace.

Le lab utilise la région eu-west-2.

  1. Placez-vous dans le répertoire qui contient le fichier oks-lab01-kubeconfig.yaml, puis indiquez à kubectl de l’utiliser :

    Terminal window
    export KUBECONFIG=$PWD/oks-lab01-kubeconfig.yaml

    Remarque : si vous avez supprimé ce fichier, récupérez-le de nouveau :

    Terminal window
    (umask 077; octl kube cluster kubeconfig oks-lab01-cluster --project oks-lab01-project > oks-lab01-kubeconfig.yaml)
  2. Vérifiez l’accès au cluster :

    Terminal window
    kubectl get nodes
Terminal window
kubectl create namespace oks-lab03

Une StorageClass décrit un type de stockage que Kubernetes peut provisionner à la demande : le pilote utilisé, le type de volume BSU et le comportement à la suppression.

  1. Listez les StorageClasses du cluster :

    Terminal window
    kubectl get storageclass

    Exemple de sortie :

    NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ALLOWVOLUMEEXPANSION AGE
    bsu-gp2 (default) bsu.csi.outscale.com Retain WaitForFirstConsumer true 30d
    bsu-gp2-del bsu.csi.outscale.com Delete WaitForFirstConsumer true 30d
    bsu-io1-50 bsu.csi.outscale.com Retain WaitForFirstConsumer true 30d
    bsu-io1-50-del bsu.csi.outscale.com Delete WaitForFirstConsumer true 30d
    bsu-standard bsu.csi.outscale.com Retain WaitForFirstConsumer true 30d
    bsu-standard-del bsu.csi.outscale.com Delete WaitForFirstConsumer true 30d
  2. Analysez les colonnes :

    • Le nom reprend le type de volume BSU : standard (magnétique), gp2 (SSD usage général) ou io1 (SSD à IOPS provisionnées, ici 50 IOPS par Gio).
    • (default) : la StorageClass bsu-gp2 est utilisée par tout PVC qui n’indique pas de StorageClass.
    • RECLAIMPOLICY : avec Retain, le volume BSU est conservé quand le PVC est supprimé ; avec Delete (suffixe -del), il est supprimé.
    • VOLUMEBINDINGMODE : avec WaitForFirstConsumer, le volume BSU n’est créé qu’au démarrage du premier Pod qui utilise le PVC, dans la Sous-région de son nœud.

Attention : un volume BSU conservé par la politique Retain n’est pas supprimé avec le PVC : il reste lié à un PV à l’état Released, et continue de consommer du stockage. Dans ce lab, vous utilisez la StorageClass bsu-standard-del pour que les volumes soient supprimés avec leur PVC.

  1. Créez un fichier oks-lab03-pvc.yaml avec le contenu suivant :

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
    name: oks-lab03-pvc
    namespace: oks-lab03
    spec:
    accessModes:
    - ReadWriteOnce
    storageClassName: bsu-standard-del
    resources:
    requests:
    storage: 5Gi
    • ReadWriteOnce (RWO) : le volume ne peut être monté en lecture-écriture que par un seul nœud à la fois. C’est le cas de tout volume BSU, qui ne peut être attaché qu’à une seule VM.
    • storage: 5Gi : taille du volume BSU demandé.
  2. Appliquez le manifeste :

    Terminal window
    kubectl apply -f oks-lab03-pvc.yaml
  3. Affichez le PVC :

    Terminal window
    kubectl get pvc -n oks-lab03

    Exemple de sortie :

    NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS VOLUMEATTRIBUTESCLASS AGE
    oks-lab03-pvc Pending bsu-standard-del <unset> 10s

    Le PVC est à l’état Pending : c’est normal. Avec le mode WaitForFirstConsumer, le volume BSU n’est créé que lorsqu’un Pod utilise le PVC.

  1. Créez un fichier oks-lab03-app.yaml avec le contenu suivant :

    apiVersion: v1
    kind: Pod
    metadata:
    name: oks-lab03-app
    namespace: oks-lab03
    spec:
    containers:
    - name: app
    image: busybox:1.36
    command: ["/bin/sh", "-c"]
    args: ["while true; do date -u >> /data/out.txt; sleep 5; done"]
    volumeMounts:
    - name: data
    mountPath: /data
    volumes:
    - name: data
    persistentVolumeClaim:
    claimName: oks-lab03-pvc

    Le Pod ajoute la date et l’heure toutes les 5 secondes dans le fichier /data/out.txt, stocké sur le volume BSU.

  2. Appliquez le manifeste, puis attendez que le PVC soit lié à un volume :

    Terminal window
    kubectl apply -f oks-lab03-app.yaml
    kubectl wait pvc/oks-lab03-pvc -n oks-lab03 \
    --for=jsonpath='{.status.phase}'=Bound --timeout=3m
  3. Affichez le PVC et le PV créé :

    Terminal window
    kubectl get pvc -n oks-lab03
    kubectl get pv

    Exemple de sortie :

    NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE
    oks-lab03-pvc Bound pvc-3f1c9a52-6b1e-4d7f-9c2a-1e8d4b7a6c10 5Gi RWO bsu-standard-del 1m

    Le PVC est à l’état Bound : il est lié au PV pvc-3f1c..., qui représente le volume BSU créé par le pilote CSI.

  4. Affichez l’identifiant du volume BSU qui correspond au PV :

    Terminal window
    kubectl get pv -o custom-columns=PV:.metadata.name,VOLUME_BSU:.spec.csi.volumeHandle,CLAIM:.spec.claimRef.name

    La colonne VOLUME_BSU affiche l’identifiant du volume BSU créé par le pilote CSI (il commence par vol-).

    Remarque : les volumes BSU des clusters OKS sont gérés par OKS : ils n’apparaissent pas dans la liste des volumes de votre compte (octl iaas volume list).

  1. Vérifiez que le Pod est à l’état Running :

    Terminal window
    kubectl get pods -n oks-lab03
  2. Affichez le contenu du fichier écrit sur le volume :

    Terminal window
    kubectl exec -n oks-lab03 oks-lab03-app -- cat /data/out.txt

    Exemple de sortie :

    Tue Oct 27 14:37:04 UTC 2026
    Tue Oct 27 14:37:09 UTC 2026
    Tue Oct 27 14:37:14 UTC 2026

    Une nouvelle ligne est ajoutée toutes les 5 secondes. Notez l’heure de la première ligne : vous la comparerez après la restauration.

Les snapshots de volumes reposent sur trois CRDs (VolumeSnapshotClass, VolumeSnapshot, VolumeSnapshotContent) et sur un contrôleur de snapshots. OKS installe les CRDs dans le cluster et exécute le contrôleur de snapshots avec le control plane : il n’apparaît pas parmi les Pods du cluster.

  1. Vérifiez la présence des CRDs :

    Terminal window
    kubectl api-resources --api-group=snapshot.storage.k8s.io

    Les trois ressources volumesnapshotclasses, volumesnapshotcontents et volumesnapshots s’affichent.

Attention : n’installez pas vous-même le contrôleur de snapshots du projet external-snapshotter : il entrerait en concurrence avec celui géré par OKS.

Une VolumeSnapshotClass est aux snapshots ce qu’une StorageClass est aux volumes : elle indique le pilote qui crée les snapshots et le comportement à la suppression.

  1. Créez un fichier oks-lab03-snapshotclass.yaml avec le contenu suivant :

    apiVersion: snapshot.storage.k8s.io/v1
    kind: VolumeSnapshotClass
    metadata:
    name: oks-lab03-vsc
    driver: bsu.csi.outscale.com
    deletionPolicy: Delete
    • driver : le même pilote CSI que les StorageClasses BSU.
    • deletionPolicy: Delete : le snapshot OUTSCALE est supprimé quand le VolumeSnapshot est supprimé.
  2. Appliquez le manifeste :

    Terminal window
    kubectl apply -f oks-lab03-snapshotclass.yaml
  1. Créez un fichier oks-lab03-snapshot.yaml avec le contenu suivant :

    apiVersion: snapshot.storage.k8s.io/v1
    kind: VolumeSnapshot
    metadata:
    name: oks-lab03-snapshot
    namespace: oks-lab03
    spec:
    volumeSnapshotClassName: oks-lab03-vsc
    source:
    persistentVolumeClaimName: oks-lab03-pvc
  2. Appliquez le manifeste, puis attendez que le snapshot soit prêt à l’emploi :

    Terminal window
    kubectl apply -f oks-lab03-snapshot.yaml
    kubectl wait volumesnapshot/oks-lab03-snapshot -n oks-lab03 \
    --for=jsonpath='{.status.readyToUse}'=true --timeout=5m
  3. Affichez le VolumeSnapshot :

    Terminal window
    kubectl get volumesnapshot -n oks-lab03

    La colonne READYTOUSE affiche true.

  4. Affichez l’identifiant du snapshot BSU créé par le pilote CSI :

    Terminal window
    kubectl get volumesnapshotcontent \
    -o custom-columns=CONTENT:.metadata.name,SNAPSHOT_BSU:.status.snapshotHandle,READY:.status.readyToUse

    La colonne SNAPSHOT_BSU affiche l’identifiant du snapshot (il commence par snap-). Le VolumeSnapshotContent est l’objet Kubernetes qui représente ce snapshot.

Pour démontrer que le snapshot est indépendant du volume d’origine, supprimez le Pod et le PVC :

Terminal window
kubectl delete pod oks-lab03-app -n oks-lab03
kubectl delete pvc oks-lab03-pvc -n oks-lab03

Avec la StorageClass bsu-standard-del, le volume BSU d’origine est supprimé. Lancez kubectl get pv : le PV passe d’abord à l’état Released, puis disparaît au bout de quelques secondes, une fois le volume BSU supprimé. Le snapshot, lui, est toujours présent dans kubectl get volumesnapshotcontent.

  1. Créez un fichier oks-lab03-restore.yaml avec le contenu suivant :

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
    name: oks-lab03-pvc-restored
    namespace: oks-lab03
    spec:
    accessModes:
    - ReadWriteOnce
    storageClassName: bsu-standard-del
    resources:
    requests:
    storage: 5Gi
    dataSource:
    name: oks-lab03-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
    ---
    apiVersion: v1
    kind: Pod
    metadata:
    name: oks-lab03-app-restored
    namespace: oks-lab03
    spec:
    containers:
    - name: app
    image: busybox:1.36
    command: ["/bin/sh", "-c"]
    args: ["while true; do date -u >> /data/out.txt; sleep 5; done"]
    volumeMounts:
    - name: data
    mountPath: /data
    volumes:
    - name: data
    persistentVolumeClaim:
    claimName: oks-lab03-pvc-restored

    Le champ dataSource indique que le nouveau volume BSU doit être créé à partir du snapshot oks-lab03-snapshot, et non vide. Sa taille doit être supérieure ou égale à celle du volume d’origine.

  2. Appliquez le manifeste, puis attendez que le Pod soit prêt :

    Terminal window
    kubectl apply -f oks-lab03-restore.yaml
    kubectl wait pod/oks-lab03-app-restored -n oks-lab03 \
    --for=condition=Ready --timeout=5m
  1. Affichez le début du fichier restauré :

    Terminal window
    kubectl exec -n oks-lab03 oks-lab03-app-restored -- head -n 3 /data/out.txt

    La première ligne est identique à celle relevée à l’étape 3.3 : les données écrites avant le snapshot ont été restaurées.

  2. Affichez la fin du fichier :

    Terminal window
    kubectl exec -n oks-lab03 oks-lab03-app-restored -- tail -n 3 /data/out.txt

    Les dernières lignes ont été ajoutées par le nouveau Pod, après la restauration. Entre les deux, il manque les lignes écrites entre la création du snapshot et la suppression du Pod d’origine : un snapshot fige les données à l’instant de sa création.

Pour valider votre lab, vérifiez les points suivants :

  • kubectl get storageclass affiche les StorageClasses BSU, dont bsu-standard-del avec la politique Delete.
  • kubectl get volumesnapshot -n oks-lab03 affiche oks-lab03-snapshot avec READYTOUSE à true.
  • kubectl get volumesnapshotcontent affiche un identifiant de snapshot BSU (snap-...).
  • kubectl get pvc -n oks-lab03 affiche oks-lab03-pvc-restored à l’état Bound.
  • La première ligne de /data/out.txt dans le Pod oks-lab03-app-restored est celle relevée à l’étape 3.3.
  1. Augmentez la taille du PVC oks-lab03-pvc-restored de 5 Gio à 8 Gio, sans recréer le Pod, puis vérifiez la nouvelle taille du système de fichiers dans le Pod.
  2. Faites de bsu-gp2-del la StorageClass par défaut du cluster, vérifiez le résultat, puis rétablissez bsu-gp2 comme StorageClass par défaut.

Question : Pourquoi un PVC en ReadWriteMany (RWX), monté par plusieurs nœuds à la fois, ne peut-il pas utiliser une StorageClass BSU ?

💡 Correction — Agrandissement du volume

Les StorageClasses BSU autorisent l’agrandissement (ALLOWVOLUMEEXPANSION à true).

Terminal window
kubectl patch pvc oks-lab03-pvc-restored -n oks-lab03 \
-p '{"spec":{"resources":{"requests":{"storage":"8Gi"}}}}'
kubectl get pvc oks-lab03-pvc-restored -n oks-lab03 -w

Quand la colonne CAPACITY affiche 8Gi, vérifiez la taille dans le Pod :

Terminal window
kubectl exec -n oks-lab03 oks-lab03-app-restored -- df -h /data

Le volume BSU a été agrandi, puis le système de fichiers étendu, sans arrêter le Pod. La taille d’un volume BSU ne peut qu’augmenter.

💡 Correction — Changement de StorageClass par défaut

Une seule StorageClass doit porter l’annotation is-default-class. Retirez-la d’abord de bsu-gp2, puis ajoutez-la à bsu-gp2-del :

Terminal window
kubectl patch storageclass bsu-gp2 \
-p '{"metadata":{"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'
kubectl patch storageclass bsu-gp2-del \
-p '{"metadata":{"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
kubectl get storageclass

Rétablissez ensuite la configuration d’origine, car le cluster est partagé par les labs suivants :

Terminal window
kubectl patch storageclass bsu-gp2-del \
-p '{"metadata":{"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'
kubectl patch storageclass bsu-gp2 \
-p '{"metadata":{"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
💡 Correction — Question du challenge

Un volume BSU est un volume en mode bloc qui ne peut être attaché qu’à une seule VM à la fois. Les StorageClasses BSU ne proposent donc que le mode ReadWriteOnce. Pour un stockage partagé en ReadWriteMany, il faut une solution de stockage distribué, comme Longhorn (Lab Avancé 02).

Attention : avant de supprimer une ressource, vérifiez qu’elle n’est pas utilisée par d’autres labs.

Si vous prévoyez de continuer avec le Lab 04, ne supprimez pas les ressources du Lab 01 :

  • le cluster OKS oks-lab01-cluster et ses NodePools ;
  • le fichier kubeconfig oks-lab01-kubeconfig.yaml.

Supprimez les ressources suivantes, qui ne seront pas réutilisées :

  1. Supprimer le VolumeSnapshot. Avec la politique Delete, le snapshot OUTSCALE est supprimé :

    Terminal window
    kubectl delete volumesnapshot oks-lab03-snapshot -n oks-lab03
  2. Supprimer le namespace, avec le Pod et le PVC restaurés. Avec la StorageClass bsu-standard-del, le volume BSU est supprimé :

    Terminal window
    kubectl delete namespace oks-lab03
  3. Supprimer la VolumeSnapshotClass :

    Terminal window
    kubectl delete volumesnapshotclass oks-lab03-vsc
  4. Vérifiez qu’il ne reste ni PV ni snapshot du lab :

    Terminal window
    kubectl get pv
    kubectl get volumesnapshotcontent

    Les deux commandes affichent No resources found.