In dieser Anleitung wird beschrieben, wie Sie die Daten in Ihrer mit GKE verbundenen Parallelstore-Instanz in einem Cloud Storage-Bucket sichern und potenziellen Datenverlust verhindern können, indem Sie einen GKE-CronJob konfigurieren, um die Daten automatisch nach einem Zeitplan zu sichern. In diesem Leitfaden wird auch beschrieben, wie Sie Daten für eine Parallelstore-Instanz wiederherstellen können.
Hinweise
Folgen Sie der Anleitung unter Parallelstore-Instanz über GKE erstellen und 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 aus einer Parallelstore-Instanz im GKE-Cluster kontinuierlich 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.
Google Cloud Dienstkonto erstellen
gcloud iam service-accounts create parallelstore-sa \
--project=PROJECT_ID
Weisen Sie dem Dienstkonto die Rolle Google Cloud zu.
Weisen Sie dem Dienstkonto die Rollen „Parallelstore-Administrator“ und „Cloud Storage-Administrator“ zu.
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
GKE-Dienstkonto einrichten
Sie müssen ein GKE-Dienstkonto einrichten und ihm erlauben, sich als das Google Cloud -Dienstkonto auszugeben. Führen Sie die folgenden Schritte aus, um dem GKE-Dienstkonto zu erlauben, an das Google Cloud Dienstkonto gebunden zu werden.
Erstellen Sie das folgende Manifest für das Dienstkonto
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, die Identität des Dienstkontos Google Cloud zu übernehmen.
# 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
Berechtigungen für das Dienstkonto des Parallelstore-Agents erteilen
gcloud storage buckets add-iam-policy-binding GCS_BUCKET \
--member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-parallelstore.iam.gserviceaccount.com \
--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
GKE-CronJob konfigurieren und starten, um Daten regelmäßig aus Parallelstore in 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 dem
volumeMountübereinstimmen, der für diesen Container definiert ist. - PSTORE_PV_NAME: Der Name des GKE-
PersistentVolume, der auf Ihre Parallelstore-Instanz verweist. Dies sollte in Ihrem GKE-Cluster im Rahmen der Voraussetzungen eingerichtet worden sein. - PSTORE_PVC_NAME: Der Name des GKE-
PersistentVolumeClaim, der die Verwendung des Parallelstore-PersistentVolumeanfordert. Dies sollte in Ihrem GKE-Cluster im Rahmen der Voraussetzungen eingerichtet worden sein. - PSTORE_NAME: Der Name der Parallelstore-Instanz, die gesichert werden muss.
- PSTORE_LOCATION: Der Speicherort 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 für einen Cloud Storage-Bucket oder einen Pfad in einem Bucket im Format
gs://<bucket_name>/<optional_path_inside_bucket>. - DELETE_AFTER_BACKUP: Die Konfiguration, mit der entschieden wird, 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 es zu einem Notfall kommt oder die Parallelstore-Instanz aus irgendeinem Grund ausfällt, können Sie entweder den GKE-VolumePopulator verwenden, um Daten aus Cloud Storage automatisch in eine von GKE verwaltete Parallelstore-Instanz vorab zu laden, oder manuell eine neue Parallelstore-Instanz erstellen und Daten aus einem Cloud Storage-Backup importieren.
Wenn Sie eine Arbeitslast aus einem Checkpoint wiederherstellen, müssen Sie den Pfad im Cloud Storage-Bucket angeben, um festzulegen, aus welchem Checkpoint die Wiederherstellung erfolgen soll.
GKE Volume Populator
Mit 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:
So 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 liegt zwischen
12000und100000und ist ein Vielfaches von4000. - PARALLELSTORE_LOCATION: Der Speicherort der Parallelstore-Instanz, die gesichert werden muss. Er muss sich in der unterstützten Zone befinden.
- NETWORK_NAME: Der Name des VPC-Netzwerk, das Sie während der Konfiguration eines VPC-Netzwerks 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 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.