Pencadangan dan pemulihan data untuk Parallelstore di Google Kubernetes Engine

Parallelstore hanya tersedia berdasarkan undangan. Jika Anda ingin meminta akses ke Parallelstore di project Anda Google Cloud , hubungi sales representative Anda.

Panduan ini menjelaskan cara mencadangkan data di instance Parallelstore yang terhubung (GKE) ke bucket Cloud Storage dan mencegah potensi kehilangan data dengan mengonfigurasi GKE CronJob untuk mencadangkan data secara otomatis sesuai jadwal. Panduan ini juga menjelaskan cara memulihkan data untuk instance Parallelstore.

Sebelum memulai

Ikuti langkah-langkah di Membuat dan menghubungkan ke instance Parallelstore dari GKE untuk menyiapkan cluster GKE dan instance Parallelstore.

Pencadangan data

Bagian berikut menjelaskan cara menyiapkan GKE CronJob untuk terus mencadangkan data dari instance Parallelstore di cluster GKE guna mencegah kehilangan data.

Menghubungkan ke cluster GKE

Dapatkan kredensial untuk cluster GKE Anda:

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

Ganti kode berikut:

  • CLUSTER_NAME: nama cluster GKE.
  • PROJECT_ID: Project ID. Google Cloud
  • CLUSTER_LOCATION: zona Compute Engine yang berisi cluster. Cluster Anda harus berada di zona yang didukung untuk driver CSI Parallelstore.

Menyediakan izin yang diperlukan

GKE CronJob Anda memerlukan peran roles/parallelstore.admin dan roles/storage.admin untuk mengimpor dan mengekspor data antara Cloud Storage dan Parallelstore.

Membuat akun layanan Google Cloud 

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

Memberikan peran akun layanan Google Cloud

Berikan peran Admin Parallelstore dan Admin Cloud Storage ke akun layanan.

    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

Menyiapkan akun layanan GKE

Anda harus menyiapkan akun layanan GKE dan mengizinkannya untuk meniru identitas Google Cloud akun layanan. Gunakan langkah-langkah berikut untuk mengizinkan akun layanan GKE terikat ke akun Google Cloud layanan.

  1. Buat manifes akun layanan parallelstore-sa.yaml berikut:

      # GKE service account used by workload and will have access to Parallelstore and GCS
  apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: parallelstore-sa
    namespace: default

    Selanjutnya, deploy ke cluster GKE Anda menggunakan perintah ini:

      kubectl apply -f parallelstore-sa.yaml

  2. Izinkan akun layanan GKE meniru identitas Google Cloud akun layanan.

      # 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

Memberikan izin ke akun layanan Agen 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

Ganti kode berikut:

  • GCS_BUCKET: URI bucket Cloud Storage dalam format gs://<bucket_name>.
  • PROJECT_NUMBER: Nomor Google Cloud project.

Memulai CronJob

Konfigurasikan dan mulai GKE CronJob untuk mengekspor data secara berkala dari Parallelstore ke Cloud Storage.

Buat file konfigurasi ps-to-gcs-backup.yaml untuk 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

Ganti variabel berikut:

  • PSTORE_MOUNT_PATH: Jalur pemasangan instance Parallelstore, yang harus cocok dengan volumeMount yang ditentukan untuk container ini.
  • PSTORE_PV_NAME: Nama GKE PersistentVolume yang mengarah ke instance Parallelstore Anda. Hal ini seharusnya telah disiapkan di cluster GKE Anda sebagai bagian dari prasyarat.
  • PSTORE_PVC_NAME: Nama GKE PersistentVolumeClaim yang meminta penggunaan Parallelstore PersistentVolume. Hal ini seharusnya telah disiapkan di cluster GKE Anda sebagai bagian dari prasyarat.
  • PSTORE_NAME: Nama instance Parallelstore yang memerlukan pencadangan.
  • PSTORE_LOCATION: Lokasi instance Parallelstore yang memerlukan pencadangan.
  • SOURCE_PARALLELSTORE_PATH: Jalur absolut dari instance Parallelstore tanpa jalur pemasangan volume dan harus dimulai dengan /.
  • DESTINATION_GCS_URI: URI bucket Cloud Storage ke bucket Cloud Storage, atau jalur dalam bucket, menggunakan format gs://<bucket_name>/<optional_path_inside_bucket>.
  • DELETE_AFTER_BACKUP: Konfigurasi untuk memutuskan apakah akan menghapus data lama dari Parallelstore setelah pencadangan dan mengosongkan ruang, nilai yang didukung: true atau false.

Deploy CronJob ke cluster GKE Anda menggunakan perintah berikut:

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

Lihat CronJob untuk mengetahui detail selengkapnya tentang cara menyiapkan CronJob.

Mendeteksi kehilangan data

Jika status instance Parallelstore adalah FAILED, data di instance tersebut mungkin tidak dapat diakses lagi. Anda dapat menggunakan perintah Google Cloud CLI berikut untuk memeriksa status instance Parallelstore:

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

Pemulihan data

Jika terjadi bencana atau instance Parallelstore gagal karena alasan apa pun, Anda dapat menggunakan GKE VolumePopulator untuk otomatis memuat data dari Cloud Storage ke instance Parallelstore yang dikelola GKE, atau membuat instance Parallelstore baru secara manual dan mengimpor data dari cadangan Cloud Storage.

Jika Anda memulihkan dari checkpoint workload, Anda harus memutuskan checkpoint mana yang akan dipulihkan dengan memberikan jalur di dalam bucket Cloud Storage.

Ekspor Parallelstore di Cloud Storage mungkin memiliki data parsial jika instance Parallelstore gagal di tengah operasi ekspor. Periksa kelengkapan data di lokasi Cloud Storage target sebelum mengimpor nya ke Parallelstore dan melanjutkan workload Anda.

GKE Volume Populator

GKE Volume Populator dapat digunakan untuk memuat data dari jalur bucket Cloud Storage ke instance Parallelstore yang baru dibuat. Petunjuk untuk hal ini dapat ditemukan di Memuat Parallelstore.

Pemulihan manual

Anda juga dapat membuat instance Parallelstore secara manual dan mengimpor data dari bucket Cloud Storage dengan langkah-langkah berikut.

  1. Buat instance Parallelstore baru:

      gcloud beta parallelstore instances create PARALLELSTORE_NAME \
    --capacity-gib=CAPACITY_GIB \
    --location=PARALLELSTORE_LOCATION \
    --network=NETWORK_NAME \
    --project=PROJECT_ID

  2. Impor data dari 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

Ganti kode berikut:

  • PARALLELSTORE_NAME: Nama instance Parallelstore ini.
  • CAPACITY_GIB: Kapasitas penyimpanan instance Parallelstore dalam GB, nilai dari 12000 hingga 100000, dalam kelipatan 4000.
  • PARALLELSTORE_LOCATION: Lokasi instance Parallelstore yang memerlukan pencadangan, harus berada di zona yang didukung.
  • NETWORK_NAME: Nama jaringan VPC yang Anda buat selama Mengonfigurasi jaringan VPC, harus merupakan jaringan yang sama dengan yang digunakan cluster GKE Anda dan mengaktifkan Private Services Access.
  • SOURCE_GCS_URI: URI bucket Cloud Storage ke bucket Cloud Storage, atau jalur dalam bucket tempat Anda memiliki data yang ingin diimpor, menggunakan format gs://<bucket_name>/<optional_path_inside_bucket>.
  • DESTINATION_PARALLELSTORE_PATH: Jalur absolut dari instance Parallelstore tempat Anda ingin mengimpor data, harus dimulai dengan /.

Detail selengkapnya tentang cara mengimpor data ke instance Parallelstore dapat ditemukan di Mentransfer data ke atau dari Cloud Storage.