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 une tâche cron GKE pour sauvegarder automatiquement les données selon une planification. Ce guide explique également comment récupérer les données d'une instance Parallelstore.
Avant de commencer
Suivez la procédure 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 une tâche cron GKE pour sauvegarder en continu vos données 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 Google Cloud projet.
- CLUSTER_LOCATION : zone Compute Engine contenant le cluster. Votre cluster doit se trouver dans une zone compatible pour le pilote CSI Parallelstore.
Provisionner les autorisations requises
Votre tâche cron 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 Google Cloud compte de service
gcloud iam service-accounts create parallelstore-sa \
--project=PROJECT_ID
Attribuer les Google Cloud rôles du compte de service
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 Google Cloud compte de service. Procédez comme suit pour autoriser le compte de service GKE à se lier à le Google Cloud compte de service.
Créez le manifeste de compte de service
parallelstore-sa.yamlsuivant :# GKE service account used by workload and will have access to Parallelstore and GCS apiVersion: v1 kind: ServiceAccount metadata: name: parallelstore-sa namespace: defaultEnsuite, déployez-le sur votre cluster GKE à l'aide de la commande suivante :
kubectl apply -f parallelstore-sa.yamlAutorisez le compte de service GKE à emprunter l'identité du Google Cloud compte de service.
# 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 Google Cloud projet.
Démarrer la tâche cron
Configurez et démarrez une tâche cron 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 la tâche cron :
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 à
volumeMountdéfini pour ce conteneur. - PSTORE_PV_NAME : nom du GKE
PersistentVolumequi pointe vers votre instance Parallelstore. Il doit avoir été configuré dans votre cluster GKE dans le cadre des prérequis. - PSTORE_PVC_NAME : nom du GKE
PersistentVolumeClaimqui demande l'utilisation du ParallelstorePersistentVolume. Il doit avoir été 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 de l'instance
Parallelstore sans le chemin d'installation du volume. Il 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
trueoufalse.
Déployez la tâche cron 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 la section CronJob.
Détecter une perte de données
Lorsque l'état d'une instance Parallelstore est FAILED, les données de l'instance ne sont peut-être 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 soit utiliser GKE VolumePopulator pour précharger automatiquement les données de Cloud Storage dans une instance Parallelstore gérée par GKE, soit créer manuellement une nouvelle instance Parallelstore et importer des 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.
GKE Volume Populator
GKE Volume Populator peut être utilisé pour précharger des données à partir d'un chemin d'accès de bucket Cloud Storage dans une instance Parallelstore nouvellement créée. Pour obtenir des instructions, consultez la section Précharger Parallelstore.
Récupération manuelle
Vous pouvez également créer manuellement une instance Parallelstore et importer des données à partir d'un bucket Cloud Storage en procédant comme suit.
Créez une instance Parallelstore :
gcloud beta parallelstore instances create PARALLELSTORE_NAME \ --capacity-gib=CAPACITY_GIB \ --location=PARALLELSTORE_LOCATION \ --network=NETWORK_NAME \ --project=PROJECT_IDImportez 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
12000et100000, par multiples de4000. - PARALLELSTORE_LOCATION : emplacement de l'instance Parallelstore à sauvegarder. Il doit se trouver dans la zone compatible.
- NETWORK_NAME : nom du réseau VPC
que vous avez créé lors de la configuration d'un réseau VPC. Il doit s'agir du
même réseau que celui utilisé par votre cluster GKE et l'
Private Services Accessdoit être activé. - SOURCE_GCS_URI : URI du bucket Cloud Storage vers un bucket Cloud Storage ou un 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 de l'instance Parallelstore dans 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 la section Transférer des données vers ou depuis Cloud Storage.