Questa guida descrive come eseguire il backup dei dati nell'istanza Parallelstore connessa (GKE) in un bucket Cloud Storage e prevenire la potenziale perdita di dati configurando un CronJob GKE per eseguire automaticamente il backup dei dati in base a una pianificazione. Questa guida descrive anche come recuperare i dati per un'istanza Parallelstore.
Prima di iniziare
Segui la procedura descritta in Creare e connettersi a un'istanza Parallelstore da GKE per configurare il cluster GKE e l'istanza Parallelstore.
Backup dei dati
La sezione seguente descrive come configurare un CronJob GKE per eseguire continuamente il backup dei dati da un'istanza Parallelstore nel cluster GKE per evitare la perdita di dati.
Connettiti al cluster GKE
Recupera le credenziali per il tuo cluster GKE:
gcloud container clusters get-credentials CLUSTER_NAME \
--project=PROJECT_ID \
--location=CLUSTER_LOCATION
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del cluster GKE.
- PROJECT_ID: l' Google Cloud ID progetto.
- CLUSTER_LOCATION: la zona di Compute Engine contenente il cluster. Il cluster deve trovarsi in una zona supportata per il driver CSI Parallelstore.
Provisioning delle autorizzazioni richieste
Il CronJob GKE richiede i ruoli roles/parallelstore.admin e roles/storage.admin per importare ed esportare i dati tra Cloud Storage e Parallelstore.
Creare un Google Cloud service account
gcloud iam service-accounts create parallelstore-sa \
--project=PROJECT_ID
Concedere i ruoli del Google Cloud service account
Concedi i ruoli Amministratore Parallelstore e Amministratore Cloud Storage al account di servizio.
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
Configurare un account di servizio GKE
Devi configurare un account di servizio GKE e consentirgli di rappresentare il Google Cloud service account. Segui questi passaggi per consentire al account di servizio GKE di eseguire il binding a the Google Cloud service account.
Crea il seguente manifest del account di servizio
parallelstore-sa.yaml:# GKE service account used by workload and will have access to Parallelstore and GCS apiVersion: v1 kind: ServiceAccount metadata: name: parallelstore-sa namespace: defaultQuindi, esegui il deployment nel cluster GKE utilizzando questo comando:
kubectl apply -f parallelstore-sa.yamlConsenti al account di servizio GKE di rappresentare il Google Cloud service account.
# 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
Concedere le autorizzazioni al account di servizio dell'agente 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
Sostituisci quanto segue:
- GCS_BUCKET: l'URI del bucket Cloud Storage nel
formato
gs://<bucket_name>. - PROJECT_NUMBER: il Google Cloud numero del progetto.
Avviare il CronJob
Configura e avvia un CronJob GKE per esportare periodicamente i dati da Parallelstore a Cloud Storage.
Crea il file di configurazione ps-to-gcs-backup.yaml per il 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
Sostituisci le seguenti variabili:
- PSTORE_MOUNT_PATH: il percorso di montaggio dell'istanza Parallelstore, che deve corrispondere a
volumeMountdefinito per questo container. - PSTORE_PV_NAME: il nome di GKE
PersistentVolumeche rimanda all'istanza Parallelstore. Questa impostazione deve essere stata configurata nel cluster GKE come parte dei prerequisiti. - PSTORE_PVC_NAME: il nome di GKE
PersistentVolumeClaimche richiede l'utilizzo di ParallelstorePersistentVolume. Questa impostazione deve essere stata configurata nel cluster GKE come parte dei prerequisiti. - PSTORE_NAME: il nome dell'istanza Parallelstore di cui è necessario eseguire il backup.
- PSTORE_LOCATION: la località dell'istanza Parallelstore di cui è necessario eseguire il backup.
- SOURCE_PARALLELSTORE_PATH: il percorso assoluto dall'istanza
Parallelstore senza il percorso di montaggio del volume e deve iniziare con
/. - DESTINATION_GCS_URI: l'URI del bucket Cloud Storage in un bucket Cloud Storage o un percorso all'interno di un bucket, utilizzando il formato di
gs://<bucket_name>/<optional_path_inside_bucket>. - DELETE_AFTER_BACKUP: la configurazione per decidere se
eliminare i dati precedenti da Parallelstore dopo il backup e liberare spazio, valori supportati: o
false.true
Esegui il deployment del CronJob nel cluster GKE utilizzando il seguente comando:
kubectl apply -f ps-to-gcs-backup.yaml
Per maggiori dettagli sulla configurazione di un CronJob, consulta CronJob.
Rilevare la perdita di dati
Quando lo stato di un'istanza Parallelstore è FAILED, i dati sull'istanza potrebbero non essere più accessibili. Puoi utilizzare il seguente comando Google Cloud CLI per controllare lo stato dell'istanza Parallelstore:
gcloud beta parallelstore instances describe PARALLELSTORE_NAME \
--location=PARALLELSTORE_LOCATION \
--format="value(state)"
Recupero dati
In caso di emergenza o se l'istanza Parallelstore non funziona per qualsiasi motivo, puoi utilizzare GKE VolumePopulator per precaricare automaticamente i dati da Cloud Storage in un'istanza Parallelstore gestita da GKE oppure creare manualmente una nuova istanza Parallelstore e importare i dati da un backup di Cloud Storage.
Se stai eseguendo il ripristino da un checkpoint del carico di lavoro, devi decidere da quale checkpoint eseguire il ripristino fornendo il percorso all'interno del bucket Cloud Storage.
GKE Volume Populator
GKE Volume Populator può essere utilizzato per precaricare i dati da un percorso del bucket Cloud Storage in un'istanza Parallelstore appena creata. Le istruzioni sono disponibili in Precaricare Parallelstore.
Recupero manuale
Puoi anche creare manualmente un'istanza Parallelstore e importare i dati da un bucket Cloud Storage seguendo questi passaggi.
Crea una nuova istanza Parallelstore:
gcloud beta parallelstore instances create PARALLELSTORE_NAME \ --capacity-gib=CAPACITY_GIB \ --location=PARALLELSTORE_LOCATION \ --network=NETWORK_NAME \ --project=PROJECT_IDImporta i dati da 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
Sostituisci quanto segue:
- PARALLELSTORE_NAME: il nome di questa istanza Parallelstore.
- CAPACITY_GIB: la capacità di archiviazione dell'istanza Parallelstore
in GB, valore compreso tra
12000e100000, in multipli di4000. - PARALLELSTORE_LOCATION: la località dell'istanza Parallelstore di cui è necessario eseguire il backup, deve trovarsi nella zona supportata.
- NETWORK_NAME: il nome della rete VPC
che hai creato durante la configurazione di una rete VPC, deve essere la
stessa rete utilizzata dal cluster GKE e deve avere
Private Services Accessabilitato. - SOURCE_GCS_URI: l'URI del bucket Cloud Storage in un bucket Cloud Storage o un percorso all'interno di un bucket in cui sono presenti i dati da importare, utilizzando il formato
gs://<bucket_name>/<optional_path_inside_bucket>. - DESTINATION_PARALLELSTORE_PATH: il percorso assoluto dall'istanza
Parallelstore in cui vuoi importare i dati, deve iniziare con
/.
Per maggiori dettagli sull'importazione dei dati in un'istanza Parallelstore, consulta Trasferire dati da o verso Cloud Storage.