En esta guía se describe cómo puedes crear una copia de seguridad de los datos de tu instancia de Parallelstore conectada a GKE en un segmento de Cloud Storage y evitar la posible pérdida de datos configurando un CronJob de GKE para que cree automáticamente copias de seguridad de los datos según una programación. En esta guía también se describe cómo puedes recuperar datos de una instancia de ParallelStore.
Antes de empezar
Sigue los pasos de Crear una instancia de Parallelstore y conectarse a ella desde GKE para configurar tu clúster de GKE y tu instancia de Parallelstore.
Copia de seguridad de datos
En la siguiente sección se describe cómo configurar un CronJob de GKE para crear copias de seguridad continuas de los datos de una instancia de Parallelstore en el clúster de GKE y evitar así la pérdida de datos.
Conectarse a un clúster de GKE
Obtén las credenciales de tu clúster de GKE:
gcloud container clusters get-credentials CLUSTER_NAME \
--project=PROJECT_ID \
--location=CLUSTER_LOCATION
Haz los cambios siguientes:
- CLUSTER_NAME: el nombre del clúster de GKE.
- PROJECT_ID: el ID del proyecto. Google Cloud
- CLUSTER_LOCATION: la zona de Compute Engine que contiene el clúster. Tu clúster debe estar en una zona admitida para el controlador CSI de Parallelstore.
Proporcionar los permisos necesarios
Tu CronJob de GKE necesita los roles roles/parallelstore.admin y roles/storage.admin para importar y exportar datos entre Cloud Storage y Parallelstore.
Crea una Google Cloud cuenta de servicio
gcloud iam service-accounts create parallelstore-sa \
--project=PROJECT_ID
Concede los Google Cloud roles de cuenta de servicio
Asigna los roles Administrador de Parallelstore y Administrador de Cloud Storage a la cuenta de servicio.
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
Configurar una cuenta de servicio de GKE
Debes configurar una cuenta de servicio de GKE y permitirle suplantar la cuenta de servicio de Google Cloud . Sigue estos pasos para permitir que la cuenta de servicio de GKE se vincule a la cuenta de servicio Google Cloud .
Crea el siguiente manifiesto de cuenta de servicio
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: defaultA continuación, despliégalo en tu clúster de GKE con este comando:
kubectl apply -f parallelstore-sa.yamlPermite que la cuenta de servicio de GKE suplante la identidad de la Google Cloud cuenta de servicio.
# 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
Conceder permisos a la cuenta de servicio del agente de 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
Haz los cambios siguientes:
- GCS_BUCKET: el URI del segmento de Cloud Storage en el formato
gs://<bucket_name>. - PROJECT_NUMBER: el Google Cloud número de proyecto.
Iniciar la tarea cron
Configura e inicia un CronJob de GKE para exportar periódicamente datos de Parallelstore a Cloud Storage.
Crea el archivo de configuración ps-to-gcs-backup.yaml para 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
Sustituye las siguientes variables:
- PSTORE_MOUNT_PATH: es la ruta de montaje de la instancia de ParallelStore. Debe coincidir con el
volumeMountdefinido para este contenedor. - PSTORE_PV_NAME: nombre del GKE
PersistentVolumeque apunta a tu instancia de ParallelStore. Debería haber configurado esto en su clúster de GKE como parte de los requisitos previos. - PSTORE_PVC_NAME: nombre del GKE
PersistentVolumeClaimque solicita el uso de ParallelstorePersistentVolume. Debería haber configurado este paso en su clúster de GKE como parte de los requisitos previos. - PSTORE_NAME: el nombre de la instancia de Parallelstore de la que se debe crear una copia de seguridad.
- PSTORE_LOCATION: la ubicación de la instancia de Parallelstore de la que se debe crear una copia de seguridad.
- SOURCE_PARALLELSTORE_PATH: la ruta absoluta de la instancia de ParallelStore sin la ruta de montaje del volumen, que debe empezar por
/. - DESTINATION_GCS_URI: el URI del segmento de Cloud Storage
de un segmento de Cloud Storage o una ruta de acceso dentro de un segmento, con el formato de
gs://<bucket_name>/<optional_path_inside_bucket>. - DELETE_AFTER_BACKUP: configuración para decidir si se deben eliminar los datos antiguos de Parallelstore después de crear una copia de seguridad y liberar espacio. Los valores admitidos son
trueofalse.
Despliega el CronJob en tu clúster de GKE con el siguiente comando:
kubectl apply -f ps-to-gcs-backup.yaml
Consulta CronJob para obtener más información sobre cómo configurar un CronJob.
Detectar la pérdida de datos
Cuando el estado de una instancia de Parallelstore es FAILED, es posible que ya no se pueda acceder a los datos de la instancia. Puedes usar el siguiente comando de la CLI de Google Cloud para comprobar el estado de la instancia de Parallelstore:
gcloud beta parallelstore instances describe PARALLELSTORE_NAME \
--location=PARALLELSTORE_LOCATION \
--format="value(state)"
Recuperación de datos
Si se produce un desastre o la instancia de Parallelstore falla por cualquier motivo, puedes usar VolumePopulator de GKE para precargar automáticamente los datos de Cloud Storage en una instancia de Parallelstore gestionada por GKE o crear manualmente una instancia de Parallelstore e importar los datos de una copia de seguridad de Cloud Storage.
Si vas a restaurar una carga de trabajo a partir de un punto de control, debes decidir qué punto de control quieres restaurar. Para ello, proporciona la ruta del segmento de Cloud Storage.
GKE Volume Populator
GKE Volume Populator se puede usar para precargar datos de una ruta de segmento de Cloud Storage en una instancia de Parallelstore recién creada. Puedes consultar las instrucciones en Precarga de ParallelStore.
Recuperación manual
También puedes crear una instancia de Parallelstore manualmente e importar datos de un segmento de Cloud Storage siguiendo estos pasos.
Crea una instancia de ParallelStore:
gcloud beta parallelstore instances create PARALLELSTORE_NAME \ --capacity-gib=CAPACITY_GIB \ --location=PARALLELSTORE_LOCATION \ --network=NETWORK_NAME \ --project=PROJECT_IDImportar datos desde 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
Haz los cambios siguientes:
- PARALLELSTORE_NAME: el nombre de esta instancia de Parallelstore.
- CAPACITY_GIB: capacidad de almacenamiento de la instancia de Parallelstore en GB, valor de
12000a100000, en múltiplos de4000. - PARALLELSTORE_LOCATION: la ubicación de la instancia de Parallelstore de la que se debe crear una copia de seguridad. Debe estar en la zona admitida.
- NETWORK_NAME: el nombre de la red VPC que has creado en Configurar una red VPC. Debe ser la misma red que usa tu clúster de GKE y tener
Private Services Accesshabilitado. - SOURCE_GCS_URI: el URI del segmento de Cloud Storage o la ruta de acceso dentro de un segmento en el que se encuentran los datos que quieres importar, con el formato
gs://<bucket_name>/<optional_path_inside_bucket>. - DESTINATION_PARALLELSTORE_PATH: la ruta absoluta de la instancia de ParallelStore a la que quiere importar los datos debe empezar por
/.
Para obtener más información sobre cómo importar datos a una instancia de Parallelstore, consulta Transferir datos a o desde Cloud Storage.