Backup e recuperação de dados do Parallelstore no Google Kubernetes Engine

O Parallelstore só está disponível por convite. Se você quiser solicitar acesso ao Parallelstore no seu projeto Google Cloud , entre em contato com seu representante de vendas.

Este guia descreve como fazer backup dos dados na sua instância conectada do Parallelstore (GKE) em um bucket do Cloud Storage e evitar possíveis perdas de dados configurando um CronJob do GKE para fazer backup automático dos dados em uma programação. Este guia também descreve como recuperar dados de uma instância do Parallelstore.

Antes de começar

Siga as instruções em Criar e se conectar a uma instância do Parallelstore no GKE para configurar o cluster do GKE e a instância do Parallelstore.

Backup de dados

Na seção a seguir, descrevemos como configurar um CronJob do GKE para fazer backup contínuo dos dados de uma instância do Parallelstore no cluster do GKE e evitar a perda de dados.

Conecte-se ao seu cluster do GKE

Receba as credenciais do cluster do GKE:

    gcloud container clusters get-credentials CLUSTER_NAME \
      --project=PROJECT_ID \
      --location=CLUSTER_LOCATION

Substitua:

  • CLUSTER_NAME: o nome do cluster do GKE.
  • PROJECT_ID: o ID do projeto Google Cloud .
  • CLUSTER_LOCATION: a zona do Compute Engine que contém o cluster. O cluster precisa estar em uma zona compatível com o driver CSI do Parallelstore.

Provisionar as permissões necessárias

Seu CronJob do GKE precisa das funções roles/parallelstore.admin e roles/storage.admin para importar e exportar dados entre o Cloud Storage e o Parallelstore.

Criar uma conta de serviço Google Cloud

    gcloud iam service-accounts create parallelstore-sa \
      --project=PROJECT_ID

Conceda os papéis da conta de serviço Google Cloud

Conceda os papéis de administrador do Parallelstore e do Cloud Storage à conta de serviço.

    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 uma conta de serviço do GKE

Você precisa configurar uma conta de serviço do GKE e permitir que ela represente a conta de serviço Google Cloud . Siga estas etapas para permitir que a conta de serviço do GKE se vincule à conta de serviço Google Cloud .

  1. Crie o seguinte manifesto de conta de serviço 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: default
    

    Em seguida, implante no cluster do GKE usando este comando:

      kubectl apply -f parallelstore-sa.yaml
    
  2. Permita que a conta de serviço do GKE represente a conta de serviço 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
    

Conceder permissões à conta de serviço do agente do 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

Substitua:

  • GCS_BUCKET: o URI do bucket do Cloud Storage no formato gs://<bucket_name>.
  • PROJECT_NUMBER: o número do projeto Google Cloud .

Iniciar o CronJob

Configure e inicie um CronJob do GKE para exportar periodicamente dados do Parallelstore para o Cloud Storage.

Crie o arquivo de configuração ps-to-gcs-backup.yaml para o 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

Substitua as seguintes variáveis:

  • PSTORE_MOUNT_PATH: o caminho de montagem da instância do Parallelstore. Ele precisa corresponder ao volumeMount definido para esse contêiner.
  • PSTORE_PV_NAME: o nome do PersistentVolume do GKE que aponta para sua instância do Parallelstore. Isso precisa ter sido configurado no cluster do GKE como parte dos pré-requisitos.
  • PSTORE_PVC_NAME: o nome do PersistentVolumeClaim do GKE que solicita o uso do PersistentVolume do Parallelstore. Isso precisa ter sido configurado no cluster do GKE como parte dos pré-requisitos.
  • PSTORE_NAME: o nome da instância do Parallelstore que precisa de backup.
  • PSTORE_LOCATION: o local da instância do Parallelstore que precisa de backup.
  • SOURCE_PARALLELSTORE_PATH: o caminho absoluto da instância Parallelstore sem o caminho de montagem do volume e precisa começar com /.
  • DESTINATION_GCS_URI: o URI de um bucket do Cloud Storage ou um caminho dentro de um bucket, usando o formato gs://<bucket_name>/<optional_path_inside_bucket>.
  • DELETE_AFTER_BACKUP: a configuração para decidir se é necessário excluir dados antigos do Parallelstore após o backup e liberar espaço. Valores aceitos: true ou false.

Implante o CronJob no cluster do GKE usando o seguinte comando:

  kubectl apply -f ps-to-gcs-backup.yaml

Consulte CronJob para mais detalhes sobre como configurar um CronJob.

Como detectar a perda de dados

Quando o estado de uma instância do Parallelstore é FAILED, os dados nela podem não estar mais acessíveis. Use o seguinte comando da Google Cloud CLI para verificar o estado da instância do Parallelstore:

    gcloud beta parallelstore instances describe PARALLELSTORE_NAME \
    --location=PARALLELSTORE_LOCATION \
    --format="value(state)"

Recuperação de dados

Quando ocorre um desastre ou a instância do Parallelstore falha por qualquer motivo, é possível usar o VolumePopulator do GKE para pré-carregar automaticamente dados do Cloud Storage em uma instância gerenciada do Parallelstore pelo GKE ou criar manualmente uma nova instância do Parallelstore e importar dados de um backup do Cloud Storage.

Se você estiver se recuperando de um checkpoint da sua carga de trabalho, decida qual checkpoint usar fornecendo o caminho dentro do bucket do Cloud Storage.

A exportação do Parallelstore no Cloud Storage pode ter dados parciais se a instância do Parallelstore falhar no meio da operação de exportação. Verifique se os dados estão completos no local de destino do Cloud Storage antes de importar para o Parallelstore e retomar a carga de trabalho.

GKE Volume Populator

O GKE Volume Populator pode ser usado para pré-carregar dados de um caminho de bucket do Cloud Storage em uma instância do Parallelstore recém-criada. As instruções estão em Pré-carregar o Parallelstore.

Recuperação manual

Também é possível criar uma instância do Parallelstore manualmente e importar dados de um bucket do Cloud Storage com as etapas a seguir.

  1. Crie uma instância do Parallelstore:

      gcloud beta parallelstore instances create PARALLELSTORE_NAME \
        --capacity-gib=CAPACITY_GIB \
        --location=PARALLELSTORE_LOCATION \
        --network=NETWORK_NAME \
        --project=PROJECT_ID
    
  2. Importe dados do 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
    

Substitua:

  • PARALLELSTORE_NAME: o nome desta instância do Parallelstore.
  • CAPACITY_GIB: a capacidade de armazenamento da instância do Parallelstore em GB, valor de 12000 a 100000, em múltiplos de 4000.
  • PARALLELSTORE_LOCATION: o local da instância do Parallelstore que precisa de backup. Ele precisa estar na zona compatível.
  • NETWORK_NAME: o nome da rede VPC que você criou em Configurar uma rede VPC. Ela precisa ser a mesma rede usada pelo cluster do GKE e ter Private Services Access ativado.
  • SOURCE_GCS_URI: o URI do bucket do Cloud Storage para um bucket do Cloud Storage ou um caminho em um bucket em que você tem os dados que quer importar, usando o formato gs://<bucket_name>/<optional_path_inside_bucket>.
  • DESTINATION_PARALLELSTORE_PATH: o caminho absoluto da instância do Parallelstore em que você quer importar os dados. Ele precisa começar com /.

Para mais detalhes sobre como importar dados para uma instância do Parallelstore, consulte Transferir dados para ou do Cloud Storage.