Mencadangkan penyimpanan Persistent Disk menggunakan snapshot volume

Autopilot Standard

Halaman ini menunjukkan cara mencadangkan dan memulihkan penyimpanan Persistent Disk menggunakan snapshot volume.

Untuk pengantar, lihat Tentang snapshot volume Kubernetes.

Persyaratan

Untuk menggunakan snapshot volume di GKE, Anda harus memenuhi persyaratan berikut:

• Menggunakan driver CSI yang mendukung snapshot. Driver Persistent Disk dalam hierarki tidak mendukung snapshot. Untuk membuat dan mengelola snapshot, Anda harus menggunakan driver CSI yang sama dengan PersistentVolumeClaim (PVC) dasar.

  • Untuk snapshot volume Persistent Disk (PD), gunakan driver CSI Persistent Disk Compute Engine. Driver CSI Persistent Disk Compute Engine diinstal secara default pada cluster Linux baru yang menjalankan GKE versi 1.18.10-gke.2100 atau yang lebih baru, atau versi 1.19.3-gke.2100 atau yang lebih baru. Anda juga dapat mengaktifkan driver CSI Persistent Disk Compute Engine pada cluster yang ada.

  • Untuk daftar semua driver CSI yang mendukung snapshot, lihat kolom Fitur lainnya di Driver dalam dokumentasi Kubernetes.

• Gunakan control plane versi 1.17 atau yang lebih baru. Untuk menggunakan driver CSI Persistent Disk Compute Engine di VolumeSnapshot, gunakan GKE versi 1.17.6-gke.4 atau yang lebih baru.

• Memiliki PersistentVolumeClaim yang ada untuk digunakan untuk snapshot. PersistentVolume yang Anda gunakan untuk sumber snapshot harus dikelola oleh driver CSI. Anda dapat memverifikasi bahwa Anda menggunakan driver CSI dengan memeriksa apakah spesifikasi PersistentVolume memiliki bagian csi dengan driver: pd.csi.storage.gke.io atau filestore.csi.storage.gke.io. Jika PersistentVolume disediakan secara dinamis oleh driver CSI seperti yang dijelaskan di bagian berikut, PersistentVolume akan dikelola oleh driver CSI.

Batasan

Semua batasan untuk membuat snapshot disk di Compute Engine juga berlaku untuk GKE.

Praktik terbaik

Pastikan untuk mengikuti praktik terbaik untuk snapshot disk Compute Engine saat menggunakan snapshot Volume Persistent Disk di GKE.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

• Aktifkan Google Kubernetes Engine API.
Aktifkan Google Kubernetes Engine API
• Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
  Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

Membuat dan menggunakan snapshot volume

Contoh dalam dokumen ini menunjukkan cara melakukan tugas berikut:

1. Buat PersistentVolumeClaim dan Deployment.
2. Tambahkan file ke PersistentVolume yang digunakan Deployment.
3. Buat VolumeSnapshotClass untuk mengonfigurasi snapshot.
4. Buat snapshot volume PersistentVolume.
5. Hapus file pengujian.
6. Pulihkan PersistentVolume ke snapshot yang Anda buat.
7. Verifikasi bahwa pemulihan berfungsi.

Untuk menggunakan snapshot volume, Anda harus menyelesaikan langkah-langkah berikut:

1. Buat objek VolumeSnapshotClass untuk menentukan driver CSI dan kebijakan penghapusan untuk snapshot Anda.
2. Buat objek VolumeSnapshot untuk meminta snapshot PersistentVolumeClaim yang ada.
3. Merujuk VolumeSnapshot dalam PersistentVolumeClaim untuk memulihkan volume ke snapshot tersebut atau membuat volume baru menggunakan snapshot tersebut.

Buat PersistentVolumeClaim dan Deployment

1. Untuk membuat objek PersistentVolumeClaim, simpan manifes berikut sebagai my-pvc.yaml:

   Persistent Disk

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: my-pvc
    spec:
      storageClassName: standard-rwo
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
   

   Contoh ini menggunakan class penyimpanan standard-rwo yang diinstal secara default dengan driver CSI Persistent Disk Compute Engine. Untuk mempelajari lebih lanjut, lihat Menggunakan driver CSI Persistent Disk Compute Engine.

   Untuk spec.storageClassName, Anda dapat menentukan class penyimpanan apa pun yang menggunakan driver CSI yang didukung.

2. Terapkan manifes:

   kubectl apply -f my-pvc.yaml
   

3. Untuk membuat Deployment, simpan manifes berikut sebagai my-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-app
   spec:
     selector:
       matchLabels:
         app: hello-app
     template:
       metadata:
         labels:
           app: hello-app
       spec:
         containers:
         - name: hello-app
           image: google/cloud-sdk:slim
           args: [ "sleep", "3600" ]
           volumeMounts:
           - name: sdk-volume
             mountPath: /usr/share/hello/
         volumes:
         - name: sdk-volume
           persistentVolumeClaim:
             claimName: my-pvc
   

4. Terapkan manifes:

   kubectl apply -f my-deployment.yaml
   

5. Periksa status Deployment:

   kubectl get deployment hello-app
   

   Mungkin perlu waktu beberapa saat hingga Deployment siap. Anda dapat menjalankan perintah sebelumnya hingga melihat output yang mirip dengan berikut ini:

   NAME        READY   UP-TO-DATE   AVAILABLE   AGE
   hello-app   1/1     1            1           2m55s
   

Menambahkan file pengujian ke volume

1. Cantumkan Pods di Deployment:

   kubectl get pods -l app=hello-app
   

   Outputnya mirip dengan hal berikut ini:

   NAME                         READY   STATUS    RESTARTS   AGE
   hello-app-6d7b457c7d-vl4jr   1/1     Running   0          2m56s
   

2. Buat file pengujian di Pod:

   kubectl exec POD_NAME \
       -- sh -c 'echo "Hello World!" > /usr/share/hello/hello.txt'
   

   Ganti POD_NAME dengan nama Pod.

3. Verifikasi bahwa file tersebut ada:

   kubectl exec POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'
   

   Outputnya mirip dengan hal berikut ini:

   Hello World!
   

Membuat objek VolumeSnapshotClass.

Buat objek VolumeSnapshotClass untuk menentukan driver CSI dan deletionPolicy untuk snapshot volume Anda. Anda dapat mereferensikan objek VolumeSnapshotClass saat membuat objek VolumeSnapshot.

1. Simpan manifes berikut sebagai volumesnapshotclass.yaml.

   Persistent Disk

   Gunakan versi v1 API untuk cluster yang menjalankan versi 1.21 atau yang lebih baru.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: my-snapshotclass
   driver: pd.csi.storage.gke.io
   deletionPolicy: Delete
   

   Dalam contoh ini:

   • Kolom driver digunakan oleh driver CSI untuk menyediakan snapshot. Dalam contoh ini, pd.csi.storage.gke.io menggunakan driver CSI Persistent Disk Compute Engine.

   • Kolom deletionPolicy memberi tahu GKE apa yang harus dilakukan dengan objek VolumeSnapshotContent dan snapshot yang mendasarinya saat objek VolumeSnapshot terikat dihapus. Tentukan Delete untuk menghapus objek VolumeSnapshotContent dan snapshot yang mendasarinya. Tentukan Retain jika Anda ingin mempertahankan VolumeSnapshotContent dan snapshot yang mendasarinya.

     Untuk menggunakan lokasi penyimpanan kustom, tambahkan parameter storage-locations ke class snapshot. Untuk menggunakan parameter ini, cluster Anda harus menggunakan versi 1.21 atau yang lebih baru.

     apiVersion: snapshot.storage.k8s.io/v1
     kind: VolumeSnapshotClass
     metadata:
       name: my-snapshotclass
     parameters:
       storage-locations: us-east2
     driver: pd.csi.storage.gke.io
     deletionPolicy: Delete
     

   • Untuk membuat disk image, tambahkan baris berikut ke kolom parameters:

     parameters:
       snapshot-type: images
       image-family: IMAGE_FAMILY
     

     Ganti IMAGE_FAMILY dengan nama kelompok image pilihan Anda, seperti preloaded-data.

2. Terapkan manifes:

   kubectl apply -f volumesnapshotclass.yaml
   

Membuat VolumeSnapshot

Objek VolumeSnapshot adalah permintaan untuk snapshot objek PersistentVolumeClaim yang sudah ada. Saat Anda membuat objek VolumeSnapshot, GKE secara otomatis membuat dan mengikatnya dengan objek VolumeSnapshotContent, yang merupakan resource dalam cluster Anda seperti objek PersistentVolume.

1. Simpan manifes berikut sebagai volumesnapshot.yaml.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshot
   metadata:
     name: my-snapshot
   spec:
     volumeSnapshotClassName: my-snapshotclass
     source:
       persistentVolumeClaimName: my-pvc
   

2. Terapkan manifes:

   kubectl apply -f volumesnapshot.yaml
   

   Setelah Anda membuat snapshot Volume, GKE akan membuat objek VolumeSnapshotContent yang sesuai di cluster. Objek ini menyimpan snapshot dan binding objek VolumeSnapshot. Anda tidak berinteraksi dengan objek VolumeSnapshotContents secara langsung.

3. Konfirmasi bahwa GKE membuat objek VolumeSnapshotContents:

   kubectl get volumesnapshotcontents
   

   Outputnya mirip dengan hal berikut ini:

   NAME                                               AGE
   snapcontent-cee5fb1f-5427-11ea-a53c-42010a1000da   55s
   

Setelah konten snapshot Volume dibuat, driver CSI yang Anda tentukan dalam VolumeSnapshotClass akan membuat snapshot pada sistem penyimpanan yang sesuai. Setelah GKE membuat snapshot pada sistem penyimpanan dan mengikatnya ke objek VolumeSnapshot di cluster, snapshot tersebut siap digunakan. Anda dapat memeriksa status dengan menjalankan perintah berikut:

kubectl get volumesnapshot \
  -o custom-columns='NAME:.metadata.name,READY:.status.readyToUse'

Jika snapshot siap digunakan, outputnya akan mirip dengan berikut ini:

NAME               READY
my-snapshot        true

Menghapus file pengujian

1. Hapus file pengujian yang Anda buat:

   kubectl exec POD_NAME \
       -- sh -c 'rm /usr/share/hello/hello.txt'
   

2. Verifikasi bahwa file sudah tidak ada:

   kubectl exec POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'
   

   Outputnya mirip dengan hal berikut ini:

   cat: /usr/share/hello/hello.txt: No such file or directory
   

Memulihkan snapshot volume

Anda dapat mereferensikan VolumeSnapshot di PersistentVolumeClaim untuk menyediakan volume baru dengan data dari volume yang ada atau memulihkan volume ke status yang Anda rekam dalam snapshot.

Untuk mereferensikan VolumeSnapshot dalam PersistentVolumeClaim, tambahkan kolom dataSource ke PersistentVolumeClaim Anda. Proses yang sama akan digunakan terlepas dari apakah VolumeSnapshotContents mengacu pada disk image atau snapshot.

Dalam contoh ini, Anda mereferensikan VolumeSnapshot yang Anda buat di PersistentVolumeClaim baru dan mengupdate Deployment untuk menggunakan klaim baru.

1. Pastikan apakah Anda menggunakan snapshot disk atau image, yang berbeda sebagai berikut:

   • Snapshot disk: Seringlah mengambil snapshot dan tidak sering memulihkan.
   • Snapshot image: Tidak sering mengambil snapshot dan sering memulihkan. Snapshot image juga mungkin lebih lambat dibuat daripada snapshot disk.

   Untuk mengetahui detailnya, lihat Batas frekuensi snapshot. Mengetahui jenis snapshot akan membantu jika Anda perlu memecahkan masalah apa pun.

   Periksa VolumeSnapshot:

   kubectl describe volumesnapshot SNAPSHOT_NAME
   

   Kolom volumeSnapshotClassName menentukan class snapshot.

   kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
   

   Parameter snapshot-type akan menentukan snapshots atau images. Jika tidak diberikan, defaultnya adalah snapshots.

   Jika tidak ada class snapshot (misalnya, jika snapshot dibuat secara statis), periksa VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME Format handle snapshot dalam output memberi tahu Anda jenis snapshot, sebagai berikut: * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME: snapshot disk

   • projects/PROJECT_NAME/global/images/IMAGE_NAME: snapshot image

1. Simpan manifes berikut sebagai pvc-restore.yaml:

   Persistent Disk

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: pvc-restore
   spec:
     dataSource:
       name: my-snapshot
       kind: VolumeSnapshot
       apiGroup: snapshot.storage.k8s.io
     storageClassName: standard-rwo
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: 1Gi
   

   Catatan: Namespace PersistentVolumeClaim harus sama dengan namespace VolumeSnapshot.

2. Terapkan manifes:

   kubectl apply -f pvc-restore.yaml
   

3. Perbarui file my-deployment.yaml untuk menggunakan PersistentVolumeClaim yang baru:

   ...
   volumes:
   - name: my-volume
     persistentVolumeClaim:
       claimName: pvc-restore
   

4. Terapkan manifes yang diupdate:

   kubectl apply -f my-deployment.yaml
   

Pastikan snapshot berhasil dipulihkan

1. Dapatkan nama Pod baru yang dibuat GKE untuk Deployment yang telah diupdate:

    kubectl get pods -l app=hello-app
   

Pastikan file pengujian ada:

   kubectl exec NEW_POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'

Ganti NEW_POD_NAME dengan nama Pod baru yang dibuat GKE.

Outputnya mirip dengan hal berikut ini:

   Hello World!

Mengimpor snapshot yang sudah ada

Anda dapat menggunakan snapshot volume yang ada yang dibuat di luar cluster saat ini untuk menyediakan objek VolumeSnapshotContents secara manual. Misalnya, Anda dapat mengisi volume di GKE dengan snapshot resourceGoogle Cloud lain yang dibuat di cluster yang berbeda.

1. Temukan nama snapshot Anda.

   Google Cloud console

   Buka halaman Snapshots

   Google Cloud CLI

   Jalankan perintah berikut:

   gcloud compute snapshots list
   

   Outputnya mirip dengan hal berikut ini:

   NAME                                           DISK_SIZE_GB  SRC_DISK                                                     STATUS
   snapshot-5e6af474-cbcc-49ed-b53f-32262959a0a0  1             us-central1-b/disks/pvc-69f80fca-bb06-4519-9e7d-b26f45c1f4aa READY
   

2. Simpan manifes VolumeSnapshot berikut sebagai restored-snapshot.yaml.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshot
   metadata:
     name: restored-snapshot
   spec:
     volumeSnapshotClassName: my-snapshotclass
     source:
       volumeSnapshotContentName: restored-snapshot-content
   

3. Terapkan manifes:

   kubectl apply -f restored-snapshot.yaml
   

4. Simpan manifes VolumeSnapshotContent berikut sebagai restored-snapshot-content.yaml. Ganti kolom snapshotHandle dengan project ID dan nama snapshot Anda. volumeSnapshotRef.name dan volumeSnapshotRef.namespace harus mengarah ke VolumeSnapshot yang dibuat sebelumnya agar binding dua arah valid.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotContent
   metadata:
     name: restored-snapshot-content
   spec:
     deletionPolicy: Retain
     driver: pd.csi.storage.gke.io
     source:
       snapshotHandle: projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
     volumeSnapshotRef:
       kind: VolumeSnapshot
       name: restored-snapshot
       namespace: default
   

5. Terapkan manifes:

   kubectl apply -f restored-snapshot-content.yaml
   

6. Simpan manifes PersistentVolumeClaim berikut sebagai restored-pvc.yaml. Pengontrol penyimpanan Kubernetes akan menemukan VolumeSnapshot bernama restored-snapshot, lalu mencoba menemukan, atau membuat secara dinamis, PersistentVolume sebagai sumber data. Kemudian, Anda dapat menggunakan PVC ini di Pod untuk mengakses data yang dipulihkan.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: restored-pvc
   spec:
     dataSource:
       name: restored-snapshot
       kind: VolumeSnapshot
       apiGroup: snapshot.storage.k8s.io
     storageClassName: standard-rwo
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: 1Gi
   

7. Terapkan manifes:

   kubectl apply -f restored-pvc.yaml
   

8. Simpan manifes Pod berikut sebagai restored-pod.yaml yang merujuk ke PersistentVolumeClaim. Driver CSI akan menyediakan PersistentVolume dan mengisinya dari snapshot.

   apiVersion: v1
   kind: Pod
   metadata:
     name: restored-pod
   spec:
     containers:
     - name: busybox
       image: busybox
       args:
       - sleep
       - "3600"
       volumeMounts:
       - name: source-data
         mountPath: /demo/data
     volumes:
     - name: source-data
       persistentVolumeClaim:
         claimName: restored-pvc
         readOnly: false
   

9. Terapkan manifes:

   kubectl apply -f restored-pod.yaml
   

10. Verifikasi bahwa file telah dipulihkan:

    kubectl exec restored-pod -- sh -c 'cat /demo/data/hello.txt'
    

Pembersihan

Agar akun Google Cloud Anda tidak dikenai biaya untuk resource yang digunakan di halaman ini, ikuti langkah-langkah berikut.

1. Hapus VolumeSnapshot.

   kubectl delete volumesnapshot my-snapshot
   

   Catatan: Jika VolumeSnapshotClass snapshot volume memiliki deletionPolicy:Delete, VolumeSnapshotContent yang sesuai dan snapshot fisik pada sistem penyimpanan juga akan dihapus. Jika memiliki deletionPolicy:Retain, GKE akan mempertahankan snapshot yang mendasarinya.

2. Hapus VolumeSnapshotClass.

   kubectl delete volumesnapshotclass my-snapshotclass
   

3. Hapus Deployment.

   kubectl delete deployments hello-app
   

4. Hapus objek PersistentVolumeClaim:

   kubectl delete pvc my-pvc pvc-restore
   

Langkah selanjutnya

• Baca dokumentasi Snapshot Volume Kubernetes.
• Pelajari ekspansi volume.
• Pelajari cara menginstal driver CSI secara manual.
• Pelajari penyimpanan blok (Persistent Disk) untuk GKE.