Questa guida descrive come eseguire il backup dei dati nell'istanza Parallelstore (GKE) connessa 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 Crea una istanza Parallelstore e connettiti a questa 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 Compute Engine contenente il cluster. Il cluster deve trovarsi in una zona supportata per il driver CSI Parallelstore.
Fornire le autorizzazioni richieste
Il tuo GKE CronJob richiede i ruoli roles/parallelstore.admin e roles/storage.admin
per importare ed esportare dati tra Cloud Storage e Parallelstore.
Crea un Google Cloud service account
gcloud iam service-accounts create parallelstore-sa \
--project=PROJECT_ID
Concedi i ruoli del service account Google Cloud
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 service account Google Cloud . Segui questi passaggi per consentire al account di servizio GKE di eseguire il binding al service account Google Cloud .
Crea il seguente manifest dell'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: defaultDopodiché, esegui il deployment nel cluster GKE utilizzando questo comando:
kubectl apply -f parallelstore-sa.yamlConsenti al account di servizio GKE di rappresentare il service account 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
Concedi 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 di progetto.
Avvia 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, deve corrispondere a
volumeMountdefinito per questo container. - PSTORE_PV_NAME: il nome di GKE
PersistentVolumeche punta all'istanza Parallelstore. Questa impostazione deve essere stata configurata nel cluster GKE nell'ambito dei prerequisiti. - PSTORE_PVC_NAME: Il nome del cluster GKE
PersistentVolumeClaimche richiede l'utilizzo di ParallelstorePersistentVolume. Questa operazione deve essere stata configurata nel cluster GKE nell'ambito dei prerequisiti. - PSTORE_NAME: il nome dell'istanza Parallelstore di cui è necessario eseguire il backup.
- PSTORE_LOCATION: La posizione 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
di un bucket Cloud Storage o un percorso all'interno di un bucket, utilizzando il formato
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:
trueofalse.
Esegui il deployment di CronJob nel cluster GKE utilizzando questo comando:
kubectl apply -f ps-to-gcs-backup.yaml
Per maggiori dettagli sulla configurazione di un CronJob, consulta CronJob.
Rilevamento della 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
Quando si verifica un disastro o l'istanza Parallelstore non funziona per qualsiasi motivo, puoi utilizzare VolumePopulator di GKE 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 esegui il ripristino da un checkpoint del tuo workload, 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 Precaricamento di Parallelstore.
Recupero manuale
Puoi anche creare manualmente un'istanza Parallelstore e importare i dati da un bucket Cloud Storage con i seguenti 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 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 da
12000a100000, in multipli di4000. - PARALLELSTORE_LOCATION: La posizione 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
a 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.