Sauvegarder le stockage sur disque persistant à l'aide d'instantanés de volume

Autopilot Standard

---

Cette page vous explique comment sauvegarder et restaurer le stockage sur disque persistant à l'aide d'instantanés de volume.

Pour en savoir plus, consultez la page À propos des instantanés de volume Kubernetes.

Conditions requises

Pour utiliser des instantanés de volume sur GKE, vous devez répondre aux exigences suivantes :

• Utiliser un pilote CSI compatible avec les instantanés. Le pilote de disque persistant "in-tree" n'est pas compatible avec les instantanés. Pour créer et gérer des instantanés, vous devez utiliser le même pilote CSI que le PersistentVolumeClaim (PVC) sous-jacent.

  • Pour les instantanés de volume de disque persistant, utilisez le pilote CSI de disque persistant Compute Engine. Le pilote CSI de disque persistant Compute Engine est installé par défaut sur les nouveaux clusters Linux exécutant la version 1.18.10-gke.2100 ou ultérieure de GKE, ou la version 1.19.3-gke.2100 ou ultérieure. Vous pouvez également activer le pilote CSI de disque persistant Compute Engine sur un cluster existant.

  • Pour obtenir la liste de tous les pilotes CSI compatibles avec les instantanés, consultez la colonne Autres fonctionnalités dans la page Pilotes de la documentation Kubernetes.

• Utilisez les versions 1.17 ou ultérieures du plan de contrôle. Pour exploiter le pilote CSI de disque persistant Compute Engine dans un VolumeSnapshot, vous devez utiliser GKE version 1.17.6-gke.4 ou ultérieure.

• Vous devez disposer d'un objet PersistentVolumeClaim pour utiliser un instantané. Le PersistentVolume que vous utilisez pour une source d'instantané doit être géré par un pilote CSI. Vous pouvez contrôler que vous utilisez un pilote CSI en vérifiant que la spécification PersistentVolume présente une section csi avec driver: pd.csi.storage.gke.io ou filestore.csi.storage.gke.io. Si le PersistentVolume est provisionné de manière dynamique par le pilote CSI, comme décrit dans les sections suivantes, il est géré par le pilote CSI.

Limites

Toutes les restrictions concernant la création d'un instantané de disque sur Compute Engine s'appliquent également à GKE.

Bonnes pratiques

Assurez-vous de suivre les bonnes pratiques relatives aux instantanés de disque Compute Engine lorsque vous utilisez des instantanés Volume de disque persistant sur GKE.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Google Kubernetes Engine.
Activer l'API Google Kubernetes Engine
• Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
  Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Créer et utiliser un instantané de volume

Les exemples de ce document vous montrent comment effectuer les opérations suivantes :

1. Créer un PersistentVolumeClaim et un Deployment
2. Ajouter un fichier au PersistentVolume utilisé par Deployment
3. Créer un objet VolumeSnapshotClass pour configurer l'instantané
4. Créer un instantané de volume du PersistentVolume.
5. Supprimer le fichier de test
6. Restaurer le fichier PersistentVolume dans l'instantané que vous avez créé
7. Vérifiez que la restauration a fonctionné

Pour utiliser un instantané de volume, procédez comme suit :

1. Créez un objet VolumeSnapshotClass pour spécifier le pilote CSI et la règle de suppression de votre instantané.
2. Créez un objet VolumeSnapshot pour demander un instantané d'un PersistentVolumeClaim existant.
3. Référencez le VolumeSnapshot dans un PersistentVolumeClaim pour restaurer un volume sur cet instantané, ou créez un volume à l'aide de l'instantané.

Créer un PersistentVolumeClaim et un Deployment

1. Pour créer l'objet PersistentVolumeClaim, enregistrez le manifeste suivant sous le nom my-pvc.yaml :

   Persistent Disk

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

   Cet exemple utilise la classe de stockage standard-rwo installée par défaut avec le pilote CSI de disque persistant Compute Engine. Pour en savoir plus, consultez la page Utiliser le pilote CSI de disque persistant Compute Engine.

   Pour spec.storageClassName, vous pouvez spécifier n'importe quelle classe de stockage utilisant un pilote CSI compatible.

2. Appliquez le fichier manifeste :

   kubectl apply -f my-pvc.yaml
   

3. Pour créer un Deployment, enregistrez le fichier manifeste suivant sous le nom my-deployment.yaml :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-app
   spec:
     selector:
       matchLabels:
         app: hello-app
     template:
       metadata:
         labels:
           app: hello-app
       spec:
         containers:
         - name: hello-app
           image: google/cloud-sdk:slim
           args: [ "sleep", "3600" ]
           volumeMounts:
           - name: sdk-volume
             mountPath: /usr/share/hello/
         volumes:
         - name: sdk-volume
           persistentVolumeClaim:
             claimName: my-pvc
   

4. Appliquez le fichier manifeste :

   kubectl apply -f my-deployment.yaml
   

5. Vérifiez l'état du Deployment.

   kubectl get deployment hello-app
   

   La préparation du Deployment peut prendre un certain temps. Vous pouvez exécuter la commande ci-dessus jusqu'à obtenir un résultat semblable à celui-ci :

   NAME        READY   UP-TO-DATE   AVAILABLE   AGE
   hello-app   1/1     1            1           2m55s
   

Ajouter un fichier de test au volume

1. Référencez les Pods dans le Deployment :

   kubectl get pods -l app=hello-app
   

   Le résultat ressemble à ce qui suit :

   NAME                         READY   STATUS    RESTARTS   AGE
   hello-app-6d7b457c7d-vl4jr   1/1     Running   0          2m56s
   

2. Créez un fichier de test dans un Pod :

   kubectl exec POD_NAME \
       -- sh -c 'echo "Hello World!" > /usr/share/hello/hello.txt'
   

   Remplacez POD_NAME par le nom du Pod.

3. Vérifiez la présence du fichier.

   kubectl exec POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'
   

   Le résultat ressemble à ce qui suit :

   Hello World!
   

Créer un objet VolumeSnapshotClass.

Créez un objet VolumeSnapshotClass pour spécifier le pilote CSI et deletionPolicy pour votre instantané de volume. Vous pouvez référencer des objets VolumeSnapshotClass lorsque vous créez des objets VolumeSnapshot.

1. Enregistrez le fichier manifeste suivant sous le nom volumesnapshotclass.yaml.

   Persistent Disk

   Utilisez la version de l'API v1 pour les clusters exécutant les versions 1.21 ou une version ultérieure.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: my-snapshotclass
   driver: pd.csi.storage.gke.io
   deletionPolicy: Delete
   

   Dans cet exemple :

   • Le champ driver est utilisé par le pilote CSI pour provisionner l'instantané. Dans cet exemple, pd.csi.storage.gke.io utilise le pilote CSI de disque persistant Compute Engine.

   • Le champ deletionPolicy indique à GKE ce qu'il faut faire avec l'objet VolumeSnapshotContent et l'instantané sous-jacent lorsque l'objet VolumeSnapshot lié est supprimé. Spécifiez la valeur Delete pour supprimer l'objet VolumeSnapshotContent et l'instantané sous-jacent. Spécifiez la valeur Retain si vous souhaitez conserver l'objet VolumeSnapshotContent et l'instantané sous-jacent.

     Pour utiliser un emplacement de stockage personnalisé, ajoutez un paramètre storage-locations à la classe d'instantané. Pour utiliser ce paramètre, vos clusters doivent utiliser la version 1.21 ou ultérieure.

     apiVersion: snapshot.storage.k8s.io/v1
     kind: VolumeSnapshotClass
     metadata:
       name: my-snapshotclass
     parameters:
       storage-locations: us-east2
     driver: pd.csi.storage.gke.io
     deletionPolicy: Delete
     

   • Pour créer une image disque, ajoutez le code suivant dans le champ parameters :

     parameters:
       snapshot-type: images
       image-family: IMAGE_FAMILY
     

     Remplacez IMAGE_FAMILY par le nom de la famille d'images souhaitée (par exemple, preloaded-data).

2. Appliquez le fichier manifeste :

   kubectl apply -f volumesnapshotclass.yaml
   

Créer un objet VolumeSnapshot

Un objet VolumeSnapshot est une requête d'instantané d'un objet PersistentVolumeClaim existant. Lorsque vous créez un objet VolumeSnapshot, GKE le crée et le lie automatiquement avec un objet VolumeSnapshotContent, qui est une ressource de votre cluster comme un objet PersistentVolume.

1. Enregistrez le fichier manifeste suivant sous le nom volumesnapshot.yaml.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshot
   metadata:
     name: my-snapshot
   spec:
     volumeSnapshotClassName: my-snapshotclass
     source:
       persistentVolumeClaimName: my-pvc
   

2. Appliquez le fichier manifeste :

   kubectl apply -f volumesnapshot.yaml
   

   Après avoir créé un instantané Volume, GKE crée un objet VolumeSnapshotContent correspondant dans le cluster. Cet objet stocke l'instantané et les liaisons avec les objets VolumeSnapshot. Il n'est pas possible d'interagir directement avec les objets VolumeSnapshotContents.

3. Vérifiez que GKE a créé l'objet VolumeSnapshotContents :

   kubectl get volumesnapshotcontents
   

   Le résultat ressemble à ce qui suit :

   NAME                                               AGE
   snapcontent-cee5fb1f-5427-11ea-a53c-42010a1000da   55s
   

Une fois le contenu de l'instantané Volume créé, le pilote CSI que vous avez spécifié dans le VolumeSnapshotClass crée un instantané sur le système de stockage correspondant. Dès que GKE a créé l'instantané sur le système de stockage et l'a lié à un objet VolumeSnapshot du cluster, l'instantané devient utilisable. Vous pouvez vérifier son état à l'aide de la commande suivante :

kubectl get volumesnapshot \
  -o custom-columns='NAME:.metadata.name,READY:.status.readyToUse'

Si l'instantané est prêt à être utilisé, le résultat ressemble à ce qui suit :

NAME               READY
my-snapshot        true

Supprimer le fichier de test

1. Supprimez le fichier de test que vous avez créé :

   kubectl exec POD_NAME \
       -- sh -c 'rm /usr/share/hello/hello.txt'
   

2. Vérifiez que le fichier n'existe plus :

   kubectl exec POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'
   

   Le résultat ressemble à ce qui suit :

   cat: /usr/share/hello/hello.txt: No such file or directory
   

Restaurer l'instantané de volume

Vous pouvez référencer un VolumeSnapshot dans un PersistentVolumeClaim pour provisionner un nouveau volume avec les données d'un volume existant ou restaurer un volume à un état capturé dans l'instantané.

Pour référencer un VolumeSnapshot dans une PersistentVolumeClaim, ajoutez le champ dataSource à votre PersistentVolumeClaim. Le même processus est utilisé, que VolumeSnapshotContents fasse référence à une image disque ou à un instantané.

Dans cet exemple, vous référencez le VolumeSnapshot que vous avez créé dans une nouvelle PersistentVolumeClaim et vous mettez à jour le Deployment pour qu'il utilise la nouvelle revendication.

1. Vérifiez si vous utilisez un instantané de disque ou d'image, qui diffèrent comme suit :

   • Instantanés de disque : prenez des instantanés fréquemment et restaurez-les rarement.
   • Instantanés d'images : prenez rarement des instantanés et restaurez-les fréquemment. La création d'instantanés d'images peut également être plus lente que celle des instantanés de disque.

   Pour en savoir plus, consultez la page Limites de fréquence des instantanés. L'identification du type d'instantané vous permettra de résoudre les problèmes que vous rencontrez.

   Inspectez le VolumeSnapshot :

   kubectl describe volumesnapshot SNAPSHOT_NAME
   

   Le champ volumeSnapshotClassName spécifie la classe de l'instantané.

   kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
   

   Le paramètre snapshot-type spécifie snapshots ou images. S'il n'est pas spécifié, la valeur par défaut est snapshots.

   S'il n'y a aucune classe d'instantané (par exemple, si l'instantané a été créé statiquement), inspectez VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME Le format d'un gestionnaire d'instantanés dans la sortie vous indique le type d'instantané, comme suit : * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME : instantané de disque

   • projects/PROJECT_NAME/global/images/IMAGE_NAME : instantané d'image

1. Enregistrez le manifeste suivant sous le nom pvc-restore.yaml :

   Persistent Disk

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: pvc-restore
   spec:
     dataSource:
       name: my-snapshot
       kind: VolumeSnapshot
       apiGroup: snapshot.storage.k8s.io
     storageClassName: standard-rwo
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: 1Gi
   

   Remarque : L'espace de noms de l'objet PersistentVolumeClaim doit être identique à celui du VolumeSnapshot.

2. Appliquez le fichier manifeste :

   kubectl apply -f pvc-restore.yaml
   

3. Mettez à jour le fichier my-deployment.yaml pour qu'il utilise le nouveau fichier PersistentVolumeClaim :

   ...
   volumes:
   - name: my-volume
     persistentVolumeClaim:
       claimName: pvc-restore
   

4. Appliquez le fichier manifeste mis à jour :

   kubectl apply -f my-deployment.yaml
   

Vérifier que l'instantané a bien été restauré

1. Obtenez le nom du nouveau Pod créé par GKE pour le Deployment mis à jour :

    kubectl get pods -l app=hello-app
   

Vérifiez que le fichier de test existe :

   kubectl exec NEW_POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'

Remplacez NEW_POD_NAME par le nom du nouveau Pod créé par GKE.

Le résultat ressemble à ce qui suit :

   Hello World!

Effectuer un nettoyage

Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte Google Cloud, procédez comme suit :

1. Supprimez le sous-réseau VolumeSnapshot :

   kubectl delete volumesnapshot my-snapshot
   

   Remarque : Si la VolumeSnapshotClass de l'instantané de volume spécifie deletionPolicy:Delete, le VolumeSnapshotContent correspondant et l'instantané physique sur le système de stockage sont également supprimés. Si deletionPolicy:Retain est spécifié, GKE conserve l'instantané sous-jacent.

2. Supprimez le sous-réseau VolumeSnapshotClass :

   kubectl delete volumesnapshotclass my-snapshotclass
   

3. Supprimez le sous-réseau Deployment :

   kubectl delete deployments hello-app
   

4. Supprimer les objets PersistentVolumeClaim :

   kubectl delete pvc my-pvc pvc-restore
   

Étape suivante

• Consultez la documentation Kubernetes sur les instantanés de volume.
• Apprenez-en davantage sur l'expansion de volume.
• Découvrez comment installer manuellement un pilote CSI.
• Découvrez le stockage de blocs (disque persistant) pour GKE.