In diesem Leitfaden wird beschrieben, wie Sie die Daten in Ihrer verbundenen Parallelstore-Instanz (GKE) in einem Cloud Storage-Bucket sichern und potenziellen Datenverlust verhindern können, indem Sie einen GKE-CronJob konfigurieren, um die Daten automatisch nach Zeitplan zu sichern. Außerdem wird beschrieben, wie Sie Daten für eine Parallelstore-Instanz wiederherstellen können.
Hinweis
Folgen Sie der Anleitung unter Parallelstore-Instanz erstellen und mit GKE verbinden , um Ihren GKE-Cluster und Ihre Parallelstore-Instanz einzurichten.
Datensicherung
Im folgenden Abschnitt wird beschrieben, wie Sie einen GKE-CronJob einrichten können, um Ihre Daten kontinuierlich aus einer Parallelstore-Instanz im GKE-Cluster zu sichern und so Datenverlust zu verhindern.
Verbindung zu Ihrem GKE-Cluster herstellen
Rufen Sie die Anmeldedaten für Ihren GKE-Cluster ab:
gcloud container clusters get-credentials CLUSTER_NAME \
--project=PROJECT_ID \
--location=CLUSTER_LOCATION
Ersetzen Sie Folgendes:
- CLUSTER_NAME: der Name des GKE-Cluster.
- PROJECT_ID: die Google Cloud Projekt-ID.
- CLUSTER_LOCATION: die Compute Engine-Zone, die den Cluster enthält. Ihr Cluster muss sich in einer unterstützten Zone für den Parallelstore-CSI-Treiber befinden.
Erforderliche Berechtigungen bereitstellen
Für Ihren GKE-CronJob sind die Rollen roles/parallelstore.admin und roles/storage.admin erforderlich, um Daten zwischen Cloud Storage und Parallelstore zu importieren und zu exportieren.
Dienstkonto erstellen Google Cloud
gcloud iam service-accounts create parallelstore-sa \
--project=PROJECT_ID
Dienstkontorollen gewähren Google Cloud
Gewähren Sie dem Dienstkonto die Rollen „Parallelstore-Administrator“ und „Cloud Storage-Administrator“.
gcloud projects add-iam-policy-binding PROJECT_ID \
--member=serviceAccount:parallelstore-sa@PROJECT_ID. \
--role=roles/parallelstore.admin
gcloud projects add-iam-policy-binding PROJECT_ID \
--member serviceAccount:parallelstore-sa@PROJECT_ID. \
--role=roles/storage.admin
GKE-Dienstkonto einrichten
Sie müssen ein GKE-Dienstkonto einrichten und ihm erlauben, das Google Cloud Dienstkonto zu vertreten. Führen Sie die folgenden Schritte aus, um dem GKE-Dienstkonto zu erlauben, sich an das Google Cloud Dienstkonto zu binden.
Erstellen Sie das folgende Dienstkonto-Manifest
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: defaultStellen Sie es dann mit diesem Befehl in Ihrem GKE-Cluster bereit:
kubectl apply -f parallelstore-sa.yamlErlauben Sie dem GKE-Dienstkonto, das Google Cloud Dienstkonto zu vertreten.
# Bind the GCP SA and GKE SA gcloud iam service-accounts add-iam-policy-binding parallelstore-sa@PROJECT_ID. \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:PROJECT_ID.[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.
Berechtigungen für das Parallelstore-Agent-Dienstkonto gewähren
gcloud storage buckets add-iam-policy-binding GCS_BUCKET \
--member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-parallelstore. \
--role=roles/storage.admin
Ersetzen Sie Folgendes:
- GCS_BUCKET: Der Cloud Storage-Bucket-URI im
Format
gs://<bucket_name>. - PROJECT_NUMBER: Die Google Cloud Projektnummer.
CronJob starten
Konfigurieren und starten Sie einen GKE-CronJob, um Daten regelmäßig aus Parallelstore nach Cloud Storage zu exportieren.
Erstellen Sie die Konfigurationsdatei ps-to-gcs-backup.yaml für den 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
Ersetzen Sie die folgenden Variablen:
- PSTORE_MOUNT_PATH: Der Bereitstellungspfad der Parallelstore
-Instanz. Er muss mit der für diesen Container definierten
volumeMountübereinstimmen. - PSTORE_PV_NAME: Der Name des GKE
PersistentVolume, der auf Ihre Parallelstore-Instanz verweist. Dieser muss im Rahmen der Voraussetzungen in Ihrem GKE-Cluster eingerichtet worden sein. - PSTORE_PVC_NAME: Der Name des GKE
PersistentVolumeClaim, der die Verwendung des ParallelstorePersistentVolumeanfordert. Dieser muss im Rahmen der Voraussetzungen in Ihrem GKE-Cluster eingerichtet worden sein. - PSTORE_NAME: Der Name der Parallelstore-Instanz die gesichert werden muss.
- PSTORE_LOCATION: Der Standort der Parallelstore -Instanz, die gesichert werden muss.
- SOURCE_PARALLELSTORE_PATH: Der absolute Pfad von der
Parallelstore-Instanz ohne den Bereitstellungspfad des Volumes. Er muss mit
/beginnen. - DESTINATION_GCS_URI: Der Cloud Storage-Bucket
URI zu einem Cloud Storage-Bucket oder ein Pfad in einem Bucket im Format
gs://<bucket_name>/<optional_path_inside_bucket>. - DELETE_AFTER_BACKUP: Die Konfiguration, um zu entscheiden, ob
alte Daten nach der Sicherung aus Parallelstore gelöscht und Speicherplatz freigegeben werden soll. Unterstützte
Werte:
trueoderfalse.
Stellen Sie den CronJob mit dem folgenden Befehl in Ihrem GKE-Cluster bereit:
kubectl apply -f ps-to-gcs-backup.yaml
Weitere Informationen zum Einrichten eines CronJobs finden Sie unter CronJob.
Datenverlust erkennen
Wenn der Status einer Parallelstore-Instanz FAILED ist, sind die Daten in der Instanz möglicherweise nicht mehr zugänglich. Mit dem folgenden Google Cloud CLI-Befehl können Sie den Status der Parallelstore-Instanz prüfen:
gcloud beta parallelstore instances describe PARALLELSTORE_NAME \
--location=PARALLELSTORE_LOCATION \
--format="value(state)"
Datenwiederherstellung
Wenn ein Notfall eintritt oder die Parallelstore-Instanz aus irgendeinem Grund ausfällt, können Sie entweder den GKE VolumePopulator verwenden, um Daten automatisch aus Cloud Storage in eine von GKE verwaltete Parallelstore-Instanz vorab zu laden, oder manuell eine neue Parallelstore-Instanz erstellen und Daten aus einer Cloud Storage-Sicherung importieren.
Wenn Sie eine Wiederherstellung von einem Prüfpunkt Ihrer Arbeitslast durchführen, müssen Sie angeben, von welchem Prüfpunkt die Wiederherstellung erfolgen soll. Geben Sie dazu den Pfad im Cloud Storage-Bucket an.
GKE Volume Populator
Mit dem GKE Volume Populator können Daten aus einem Cloud Storage-Bucket-Pfad in eine neu erstellte Parallelstore-Instanz vorab geladen werden. Eine Anleitung dazu finden Sie unter Parallelstore vorab laden.
Manuelle Wiederherstellung
Sie können auch manuell eine Parallelstore-Instanz erstellen und Daten aus einem Cloud Storage-Bucket importieren. Gehen Sie dazu so vor:
Erstellen Sie eine neue Parallelstore-Instanz:
gcloud beta parallelstore instances create PARALLELSTORE_NAME \ --capacity-gib=CAPACITY_GIB \ --location=PARALLELSTORE_LOCATION \ --network=NETWORK_NAME \ --project=PROJECT_IDDaten aus Cloud Storage importieren:
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
Ersetzen Sie Folgendes:
- PARALLELSTORE_NAME: Der Name dieser Parallelstore-Instanz.
- CAPACITY_GIB: Die Speicherkapazität der Parallelstore
Instanz in GB. Der Wert muss zwischen
12000und100000liegen und ein Vielfaches von4000sein. - PARALLELSTORE_LOCATION: Der Standort der Parallelstore -Instanz, die gesichert werden muss. Er muss sich in der unterstützten Zone befinden.
- NETWORK_NAME: Der Name des VPC-Netzwerks
, das Sie unter VPC-Netzwerk konfigurieren erstellt haben. Es muss dasselbe Netzwerk sein, das Ihr GKE-Cluster verwendet, und
Private Services Accessmuss aktiviert sein. - SOURCE_GCS_URI: Der Cloud Storage-Bucket
URI zu einem Cloud Storage-Bucket oder ein Pfad in einem Bucket, in dem sich die
Daten befinden, die Sie importieren möchten, im Format
gs://<bucket_name>/<optional_path_inside_bucket>. - DESTINATION_PARALLELSTORE_PATH: Der absolute Pfad von der
Parallelstore-Instanz, in die Sie die Daten importieren möchten. Er muss mit
/beginnen.
Weitere Informationen zum Importieren von Daten in eine Parallelstore-Instanz finden Sie unter Daten in oder aus Cloud Storage übertragen.