Sauvegarder l'espace de stockage Filestore à l'aide d'instantanés de volume

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

La création d'un instantané de volume Kubernetes équivaut à créer une sauvegarde Filestore. Pour plus d'informations, 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 :

  • Vous devez déployer le pilote CSI Filestore. Seuls les niveaux de service Filestore suivants sont pris en charge :

    • HDD de base avec GKE version 1.21 ou ultérieure
    • HDD de base (100 Gio à 63,9 Tio) avec GKE version 1.33 ou ultérieure
    • SSD de base avec GKE version 1.21 ou ultérieure
    • Zonal (1 à 9,75 Tio) avec GKE version 1.31 ou ultérieure
    • Zonal (10 à 100 Tio) avec GKE version 1.27 ou ultérieure
    • Régional avec GKE version 1.33.4-gke.1172000 ou ultérieure
    • Entreprise avec GKE version 1.25 ou ultérieure

  • Utilisez les versions 1.17 ou ultérieures du plan de contrôle. Pour utiliser le pilote CSI Filestore dans un VolumeSnapshot, utilisez le numéro de version GKE applicable à votre niveau de service.

  • 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

  • Les volumes d'instantanés sont soumis aux mêmes restrictions de taille que les volumes standards. Par exemple, la taille des instantanés Filestore doit être supérieure ou égale à 1 Tio pour le niveau HDD de base.

  • Le pilote CSI Filestore n'est pas compatible avec les workflows de provisionnement ou de sauvegarde dynamiques pour le niveau de service Filestore régional :

    • Vous ne pouvez sauvegarder qu'un seul partage à la fois par instance. Cela signifie que vous ne pouvez pas créer de sauvegarde multisaisie ni restaurer de sauvegarde sur une instance comportant plusieurs partages. Toutefois, les requêtes de sauvegarde provenant de deux partages différents sur deux instances Filestore différentes s'exécutent simultanément.

    • Vous pouvez restaurer une sauvegarde d'une instance de base sur l'instance source du même niveau de service, sur une instance existante ou sur une nouvelle instance. Si vous choisissez une nouvelle instance, vous pouvez choisir entre une instance HDD de base et une instance SSD de base, quel que soit le niveau de l'instance source.

    • Vous ne pouvez pas restaurer des instances zonales, régionales et Enterprise sur une instance source ou existante, mais uniquement sur une nouvelle instance. Le niveau de la nouvelle instance ne doit pas nécessairement correspondre à celui de l'instance source. Par exemple, vous pouvez restaurer la sauvegarde d'une instance régionale sur une instance zonale. La capacité provisionnée de la nouvelle instance doit être égale ou supérieure à celle de l'instance source.

    Pour obtenir la liste complète des limites des fonctionnalités, consultez Limites des fonctionnalités de sauvegarde Filestore.

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é la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de gcloud CLI ne permettent pas d'exécuter les commandes de ce document.

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 :

    Filestore 

     apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: enterprise-rwx
   accessModes:
   - ReadWriteMany
   resources:
     requests:
       storage: 1Ti

    Cet exemple crée un PVC Filestore de niveau Enterprise. Pour en savoir plus, consultez la page Accéder aux instances Filestore avec le pilote CSI Filestore.

    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.

    Filestore 

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

    Dans cet exemple :

    • Le champ driver est utilisé par le pilote CSI pour provisionner l'instantané. Dans cet exemple, filestore.csi.storage.gke.io utilise le pilote CSI Filestore.
    • 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.

  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.

Pour référencer un VolumeSnapshot dans une PersistentVolumeClaim, ajoutez le champ dataSource à votre PersistentVolumeClaim.

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. Enregistrez le manifeste suivant sous le nom pvc-restore.yaml :

    Filestore 

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-restore
spec:
  dataSource:
    name: my-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  storageClassName: enterprise-rwx
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Ti

  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!

Importer un instantané préexistant

Vous pouvez utiliser un instantané de volume existant créé en dehors du cluster actuel pour provisionner manuellement l'objet VolumeSnapshotContents. Par exemple, vous pouvez remplir un volume dans GKE avec l'instantané d'une autre ressourceCloud de Confiance créée dans un autre cluster.

  1. Recherchez le nom de votre instantané.

    Console Cloud de Confiance

    Accéder à la page "Instantanés"

    Google Cloud CLI

    Exécutez la commande ci-dessous.

    gcloud compute snapshots list

    Le résultat ressemble à ce qui suit :

    NAME                                           DISK_SIZE_GB  SRC_DISK                                                     STATUS
snapshot-5e6af474-cbcc-49ed-b53f-32262959a0a0  1             us-central1-b/disks/pvc-69f80fca-bb06-4519-9e7d-b26f45c1f4aa READY

  2. Enregistrez le manifeste VolumeSnapshot suivant sous le nom restored-snapshot.yaml.

    apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: restored-snapshot
spec:
  volumeSnapshotClassName: my-snapshotclass
  source:
    volumeSnapshotContentName: restored-snapshot-content

  3. Appliquez le fichier manifeste :

    kubectl apply -f restored-snapshot.yaml

  4. Enregistrez le manifeste VolumeSnapshotContent suivant sous le nom restored-snapshot-content.yaml. Remplacez le champ snapshotHandle par l'ID de votre projet et le nom de l'instantané. volumeSnapshotRef.name et volumeSnapshotRef.namespace doivent pointer vers le VolumeSnapshot créé précédemment pour que la liaison bidirectionnelle soit valide.

    apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotContent
metadata:
  name: restored-snapshot-content
spec:
  deletionPolicy: Retain
  driver: filestore.csi.storage.gke.io
  source:
    snapshotHandle: projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
  volumeSnapshotRef:
    kind: VolumeSnapshot
    name: restored-snapshot
    namespace: default

  5. Appliquez le fichier manifeste :

    kubectl apply -f restored-snapshot-content.yaml

  6. Enregistrez le manifeste PersistentVolumeClaim suivant sous le nom restored-pvc.yaml. Le contrôleur de stockage Kubernetes va trouver un VolumeSnapshot nommé restored-snapshot, puis tenter de trouver ou créer de manière dynamique un PersistentVolume comme source de données. Vous pouvez ensuite utiliser ce PVC dans un pod pour accéder aux données restaurées.

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: restored-pvc
spec:
  dataSource:
    name: restored-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  storageClassName: enterprise-rwx
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

  7. Appliquez le fichier manifeste :

    kubectl apply -f restored-pvc.yaml

  8. Enregistrez le fichier manifeste Pod suivant en tant que restored-pod.yaml faisant référence au PersistentVolumeClaim. Le pilote CSI va provisionner un PersistentVolume et le remplir à partir de l'instantané.

    apiVersion: v1
kind: Pod
metadata:
  name: restored-pod
spec:
  containers:
  - name: busybox
    image: busybox
    args:
    - sleep
    - "3600"
    volumeMounts:
    - name: source-data
      mountPath: /demo/data
  volumes:
  - name: source-data
    persistentVolumeClaim:
      claimName: restored-pvc
      readOnly: false

  9. Appliquez le fichier manifeste :

    kubectl apply -f restored-pod.yaml

  10. Vérifiez que le fichier a été restauré :

    kubectl exec restored-pod -- sh -c 'cat /demo/data/hello.txt'

Effectuer un nettoyage

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

  1. Supprimez le sous-réseau VolumeSnapshot :

    kubectl delete volumesnapshot my-snapshot

  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