Sauvegarde et récupération des données pour Parallelstore sur Google Kubernetes Engine

Parallelstore n'est disponible que sur invitation. Si vous souhaitez demander l'accès à Parallelstore dans votre projet Google Cloud , contactez votre représentant commercial.

Ce guide explique comment sauvegarder les données de votre instance Parallelstore connectée (GKE) dans un bucket Cloud Storage et éviter toute perte de données potentielle en configurant un CronJob GKE pour sauvegarder automatiquement les données selon une programmation. Ce guide explique également comment récupérer les données d'une instance Parallelstore.

Avant de commencer

Suivez Créer une instance Parallelstore et s'y connecter depuis GKE pour configurer votre cluster GKE et votre instance Parallelstore.

Sauvegarde des données

La section suivante explique comment configurer un CronJob GKE pour sauvegarder en continu vos données à partir d'une instance Parallelstore dans le cluster GKE afin d'éviter toute perte de données.

Vous connecter à votre cluster GKE

Obtenez les identifiants de votre cluster GKE :

    gcloud container clusters get-credentials CLUSTER_NAME \
      --project=PROJECT_ID \
      --location=CLUSTER_LOCATION

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom du cluster GKE.
  • PROJECT_ID : ID du projet Google Cloud .
  • CLUSTER_LOCATION : zone Compute Engine contenant le cluster. Votre cluster doit se trouver dans une zone compatible pour le pilote CSI Parallelstore.

Accorder les autorisations requises

Votre CronJob GKE a besoin des rôles roles/parallelstore.admin et roles/storage.admin pour importer et exporter des données entre Cloud Storage et Parallelstore.

Créer un compte de service Google Cloud 

    gcloud iam service-accounts create parallelstore-sa \
      --project=PROJECT_ID

Attribuer les rôles de compte de service Google Cloud

Attribuez les rôles "Administrateur Parallelstore" et "Administrateur Cloud Storage" au compte de service.

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member=serviceAccount:parallelstore-sa@PROJECT_ID.iam.gserviceaccount.com \
      --role=roles/parallelstore.admin
    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member serviceAccount:parallelstore-sa@PROJECT_ID.iam.gserviceaccount.com \
      --role=roles/storage.admin

Configurer un compte de service GKE

Vous devez configurer un compte de service GKE et l'autoriser à emprunter l'identité du compte de service Google Cloud . Suivez les étapes ci-dessous pour autoriser le compte de service GKE à s'associer au compte de service Google Cloud .

  1. Créez le fichier manifeste de compte de service parallelstore-sa.yaml suivant :

      # GKE service account used by workload and will have access to Parallelstore and GCS
  apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: parallelstore-sa
    namespace: default

    Déployez-le ensuite sur votre cluster GKE à l'aide de la commande suivante :

      kubectl apply -f parallelstore-sa.yaml

  2. Autorisez le compte de service GKE à emprunter l'identité du compte de service Google Cloud .

      # Bind the GCP SA and GKE SA
  gcloud iam service-accounts add-iam-policy-binding parallelstore-sa@PROJECT_ID.iam.gserviceaccount.com \
      --role roles/iam.workloadIdentityUser \
      --member "serviceAccount:PROJECT_ID.svc.id.goog[default/parallelstore-sa]"

  # Annotate the GKE SA with GCP SA
  kubectl annotate serviceaccount parallelstore-sa \
      --namespace default \
  iam.gke.io/gcp-service-account=parallelstore-sa@PROJECT_ID.iam.gserviceaccount.com

Accorder des autorisations au compte de service de l'agent Parallelstore

    gcloud storage buckets add-iam-policy-binding GCS_BUCKET \
      --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-parallelstore.iam.gserviceaccount.com \
      --role=roles/storage.admin

Remplacez les éléments suivants :

  • GCS_BUCKET : URI du bucket Cloud Storage au format gs://<bucket_name>.
  • PROJECT_NUMBER : numéro du projet Google Cloud .

Démarrer le CronJob

Configurez et démarrez un CronJob GKE pour exporter régulièrement des données de Parallelstore vers Cloud Storage.

Créez le fichier de configuration ps-to-gcs-backup.yaml pour le CronJob :

  apiVersion: batch/v1
  kind: CronJob
  metadata:
    name: ps-to-gcs-backup
  spec:
    concurrencyPolicy: Forbid
    failedJobsHistoryLimit: 1
    schedule: "0 * * * *"
    successfulJobsHistoryLimit: 3
    suspend: false
    jobTemplate:
      spec:
        template:
          metadata:
            annotations:
              gke-parallelstore/cpu-limit: "0"
              gke-parallelstore/ephemeral-storage-limit: "0"
              gke-parallelstore/memory-limit: "0"
              gke-parallelstore/volumes: "true"
          spec:
            serviceAccountName: parallelstore-sa
            containers:
            - name: pstore-backup
              image: google/cloud-sdk:slim
              imagePullPolicy: IfNotPresent
              command:
              - /bin/bash
              - -c
              - |
                #!/bin/bash
                set -ex

                # Retrieve modification timestamp for the latest file up to the minute
                latest_folder_timestamp=$(find $PSTORE_MOUNT_PATH/$SOURCE_PARALLELSTORE_PATH -type d -printf  '%T@ %p\n'| sort -n | tail -1 | cut -d' ' -f2- | xargs -I{} stat -c %x {} | xargs -I {} date -d {} +"%Y-%m-%d %H:%M")

                # Start exporting from PStore to GCS
                operation=$(gcloud beta parallelstore instances export-data $PSTORE_NAME \
                  --location=$PSTORE_LOCATION \
                  --source-parallelstore-path=$SOURCE_PARALLELSTORE_PATH \
                  --destination-gcs-bucket-uri=$DESTINATION_GCS_URI \
                  --async \
                  --format="value(name)")

                # Wait until operation complete
                while true; do
                  status=$(gcloud beta parallelstore operations describe $operation \
                    --location=$PSTORE_LOCATION \
                    --format="value(done)")
                  if [ "$status" == "True" ]; then
                    break
                  fi
                  sleep 60
                done

                # Check if export succeeded
                error=$(gcloud beta parallelstore operations describe $operation \
                  --location=$PSTORE_LOCATION \
                  --format="value(error)")
                if [ "$error" != "" ]; then
                  echo "!!! ERROR while exporting data !!!"
                fi

                # Delete the old files from PStore if requested
                # This will not delete the folder with the latest modification timestamp
                if $DELETE_AFTER_BACKUP && [ "$error" == "" ]; then
                  find $PSTORE_MOUNT_PATH/$SOURCE_PARALLELSTORE_PATH -type d -mindepth 1 |
                    while read dir; do
                        # Only delete folders that is modified earlier than the latest modification timestamp
                        folder_timestamp=$(stat -c %y $dir)
                        if [ $(date -d "$folder_timestamp" +%s) -lt $(date -d "$latest_folder_timestamp" +%s) ]; then
                          echo "Deleting $dir"
                          rm -rf "$dir"
                        fi
                    done
                fi
              env:
              - name: PSTORE_MOUNT_PATH # mount path of the Parallelstore instance, should match the volumeMount defined for this container
                value: "PSTORE_MOUNT_PATH"
              - name: PSTORE_NAME # name of the Parallelstore instance that need backup
                value: "PSTORE_NAME"
              - name: PSTORE_LOCATION # location/zone of the Parallelstore instance that need backup
                value: "PSTORE_LOCATION"
              - name: SOURCE_PARALLELSTORE_PATH # absolute path from the PStore instance, without volume mount path
                value: "SOURCE_PARALLELSTORE_PATH"
              - name: DESTINATION_GCS_URI # GCS bucket uri used for storing backups, starting with "gs://"
                value: "DESTINATION_GCS_URI"
              - name: DELETE_AFTER_BACKUP # will delete old data from Parallelstore if true
                value: "DELETE_AFTER_BACKUP"
              volumeMounts:
              - mountPath: PSTORE_MOUNT_PATH # should match the value of env var PSTORE_MOUNT_PATH
                name: PSTORE_PV_NAME
            dnsPolicy: ClusterFirst
            restartPolicy: OnFailure
            terminationGracePeriodSeconds: 30
            volumes:
            - name: PSTORE_PV_NAME
              persistentVolumeClaim:
                claimName: PSTORE_PVC_NAME

Remplacez les variables suivantes :

  • PSTORE_MOUNT_PATH : chemin d'installation de l'instance Parallelstore. Il doit correspondre à volumeMount défini pour ce conteneur.
  • PSTORE_PV_NAME : nom du PersistentVolume GKE qui pointe vers votre instance Parallelstore. Cette configuration devrait avoir été effectuée dans votre cluster GKE dans le cadre des conditions préalables.
  • PSTORE_PVC_NAME : nom du PersistentVolumeClaim GKE qui demande l'utilisation du PersistentVolume Parallelstore. Il aurait dû être configuré dans votre cluster GKE dans le cadre des prérequis.
  • PSTORE_NAME : nom de l'instance Parallelstore à sauvegarder.
  • PSTORE_LOCATION : emplacement de l'instance Parallelstore à sauvegarder.
  • SOURCE_PARALLELSTORE_PATH : chemin absolu à partir de l'instance Parallelstore sans le chemin d'installation du volume, qui doit commencer par /.
  • DESTINATION_GCS_URI : URI du bucket Cloud Storage vers un bucket Cloud Storage ou un chemin d'accès dans un bucket, au format gs://<bucket_name>/<optional_path_inside_bucket>.
  • DELETE_AFTER_BACKUP : configuration permettant de déterminer s'il faut supprimer les anciennes données de Parallelstore après la sauvegarde et libérer de l'espace. Les valeurs acceptées sont true ou false.

Déployez le CronJob sur votre cluster GKE à l'aide de la commande suivante :

  kubectl apply -f ps-to-gcs-backup.yaml

Pour en savoir plus sur la configuration d'une tâche cron, consultez CronJob.

Détecter une perte de données

Lorsque l'état d'une instance Parallelstore est FAILED, il est possible que les données de l'instance ne soient plus accessibles. Vous pouvez utiliser la commande Google Cloud CLI suivante pour vérifier l'état de l'instance Parallelstore :

    gcloud beta parallelstore instances describe PARALLELSTORE_NAME \
    --location=PARALLELSTORE_LOCATION \
    --format="value(state)"

Récupération de données

En cas de sinistre ou de défaillance de l'instance Parallelstore pour quelque raison que ce soit, vous pouvez utiliser VolumePopulator GKE pour précharger automatiquement les données de Cloud Storage dans une instance Parallelstore gérée par GKE, ou créer manuellement une instance Parallelstore et importer les données à partir d'une sauvegarde Cloud Storage.

Si vous effectuez une récupération à partir d'un point de contrôle de votre charge de travail, vous devez choisir le point de contrôle à partir duquel effectuer la récupération en fournissant le chemin d'accès dans le bucket Cloud Storage.

L'exportation Parallelstore dans Cloud Storage peut contenir des données partielles si l'instance Parallelstore a échoué au milieu de l'opération d'exportation. Vérifiez que les données sont complètes dans l'emplacement Cloud Storage cible avant de les importer dans Parallelstore et de reprendre votre charge de travail.

GKE Volume Populator

GKE Volume Populator peut être utilisé pour précharger des données à partir d'un chemin de bucket Cloud Storage dans une instance Parallelstore nouvellement créée. Pour obtenir des instructions, consultez Précharger Parallelstore.

Récupération manuelle

Vous pouvez également créer manuellement une instance Parallelstore et importer des données depuis un bucket Cloud Storage en procédant comme suit.

  1. Créez une instance Parallelstore :

      gcloud beta parallelstore instances create PARALLELSTORE_NAME \
    --capacity-gib=CAPACITY_GIB \
    --location=PARALLELSTORE_LOCATION \
    --network=NETWORK_NAME \
    --project=PROJECT_ID

  2. Importer des données depuis Cloud Storage :

      gcloud beta parallelstore instances import-data PARALLELSTORE_NAME \
    --location=PARALLELSTORE_LOCATION \
    --source-gcs-bucket-uri=SOURCE_GCS_URI \
    --destination-parallelstore-path=DESTINATION_PARALLELSTORE_PATH \
    --async

Remplacez les éléments suivants :

  • PARALLELSTORE_NAME : nom de cette instance Parallelstore.
  • CAPACITY_GIB : capacité de stockage de l'instance Parallelstore en Go, valeur comprise entre 12000 et 100000, par multiples de 4000.
  • PARALLELSTORE_LOCATION : emplacement de l'instance Parallelstore à sauvegarder. Elle doit se trouver dans une zone compatible.
  • NETWORK_NAME : nom du réseau VPC que vous avez créé lors de la section Configurer un réseau VPC. Il doit s'agir du même réseau que celui utilisé par votre cluster GKE et sur lequel Private Services Access est activé.
  • SOURCE_GCS_URI : URI du bucket Cloud Storage ou chemin d'accès dans un bucket où se trouvent les données que vous souhaitez importer, au format gs://<bucket_name>/<optional_path_inside_bucket>.
  • DESTINATION_PARALLELSTORE_PATH : chemin absolu à partir de l'instance Parallelstore vers laquelle vous souhaitez importer les données. Il doit commencer par /.

Pour en savoir plus sur l'importation de données dans une instance Parallelstore, consultez Transférer des données vers ou depuis Cloud Storage.