Dokumentasi ini ditujukan untuk versi GKE saat ini di AWS, yang dirilis pada November 2021. Lihat Catatan rilis untuk mengetahui informasi selengkapnya.

Mengambil snapshot PersistentVolume

Anda dapat menggunakan fitur snapshot volume Kubernetes untuk Volume persisten dan penyediaan dinamis di cluster GKE Anda.

Snapshot volume memungkinkan Anda membuat salinan volume pada waktu tertentu. Anda dapat menggunakan salinan ini untuk mengembalikan volume ke status sebelumnya atau untuk menyediakan volume pengganti.

Anda dapat menyediakan dan melampirkan snapshot volume dengan komponen berikut:

Persyaratan

Untuk menggunakan snapshot volume pada GKE di AWS, Anda harus memiliki hal berikut:

Volume menggunakan driver Antarmuka Penyimpanan Container (CSI) yang mendukung snapshot. Driver Elastic Block Store (EBS) yang digunakan GKE di AWS secara default pada snapshot dukungan.

Untuk mengetahui daftar semua driver CSI yang mendukung snapshot, lihat kolom "Fitur lainnya" di Driver dalam dokumentasi Kubernetes.
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: ebs.csi.aws.com . Jika cluster Anda menyediakan PersistentVolumes secara dinamis oleh driver CSI seperti yang dijelaskan di bagian berikut, cluster tersebut akan dikelola oleh driver CSI.

Sebelum memulai

Membuat dan menggunakan snapshot volume

Contoh dalam dokumen ini menunjukkan cara melakukan tugas berikut:

Buat contoh PersistentVolumeClaim dan Pod.
Membuat VolumeSnapshot.
Pulihkan ringkasan volume.
Verifikasi bahwa pemulihan berfungsi.

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

Buat objek VolumeSnapshot untuk meminta snapshot PersistentVolumeClaim yang ada.
Merujuk VolumeSnapshot dalam PersistentVolumeClaim untuk memulihkan volume ke snapshot tersebut atau membuat volume baru menggunakan snapshot tersebut.

Buat contoh `PersistentVolumeClaim` dan `Pod`

Untuk membuat objek PersistentVolumeClaim, simpan manifes berikut sebagai example-pvc.yaml:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: example-pvc
spec:
  storageClassName: standard-rwo
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```
Untuk spec.storageClassName, Anda dapat menentukan class penyimpanan apa pun yang menggunakan driver CSI yang didukung. Contoh ini menggunakan kelas penyimpanan standard-rwo default.
Terapkan manifes:
```
kubectl apply -f example-pvc.yaml
```

Membuat Pod yang menuliskan tanggal dan waktu saat ini ke volume. Untuk membuat Pod, simpan manifes berikut sebagai snapshot-shell.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: snapshot-shell
spec:
  terminationGracePeriodSeconds: 10
  containers:
  - name: linux
    image: ubuntu:bionic
    command: ["/bin/sh"]
    args: ["-c", "echo $(date -u) >> /data/out.txt"]
    volumeMounts:
    - name: snapshot-volume
      mountPath: /data
  restartPolicy: Never
  volumes:
  - name: snapshot-volume
    persistentVolumeClaim:
      claimName: example-pvc

Terapkan manifes:
```
kubectl apply -f snapshot-shell.yaml
```
Periksa status Pod:
```
kubectl get pod snapshot-shell
```
Perlu waktu beberapa saat sampai Pod berjalan dan selesai. Anda dapat menjalankan perintah sebelumnya hingga melihat output yang mirip dengan berikut ini:
```
NAME             READY   STATUS      RESTARTS   AGE
snapshot-shell   0/1     Completed   0          24s
```

Membuat VolumeSnapshot

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

Simpan manifes berikut sebagai volumesnapshot.yaml.

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

Terapkan manifes:
```
kubectl apply -f volumesnapshot.yaml
```
Setelah membuat snapshot volume, cluster Anda akan membuat objek VolumeSnapshotContent yang sesuai. Objek ini menyimpan snapshot dan binding objek VolumeSnapshot. Anda tidak berinteraksi dengan objek VolumeSnapshotContents secara langsung.

Konfirmasi bahwa cluster Anda membuat objek VolumeSnapshotContents:

kubectl get volumesnapshotcontents

Outputnya mirip dengan hal berikut ini:

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

Pastikan snapshot volume sudah siap

Setelah konten snapshot volume dibuat, driver CSI yang Anda tentukan dalam VolumeSnapshotClass akan membuat snapshot pada sistem penyimpanan yang sesuai. Setelah cluster Anda membuat snapshot di sistem penyimpanan dan mengikatnya ke objek VolumeSnapshot, snapshot siap digunakan. Anda dapat memeriksa statusnya 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
example-snapshot        true

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.

Dalam contoh ini, Anda mereferensikan VolumeSnapshot yang Anda buat di PersistentVolumeClaim baru dan membuat Pod yang memasang PersistentVolumeClaim.

Simpan manifes berikut sebagai pvc-restore.yaml:

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

Terapkan manifes:
```
kubectl apply -f pvc-restore.yaml
```

Luncurkan Pod sementara yang memasang PVC ke Pod dan mencetak konten out.txt ke log.

Simpan manifes berikut sebagai restore-log.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: restore-verify
spec:
  volumes:
    - name: restore-data
      persistentVolumeClaim:
        claimName: pvc-restore
  containers:
    - name: shell-container
      image: ubuntu:bionic
      volumeMounts:
        - mountPath: "/data"
          name: restore-data
      command: [ "/bin/sh" ]
      args: ["-c", "cat /data/out.txt", "exit", "1"]
  restartPolicy: Never

Terapkan manifes:
```
kubectl apply -f restore-log.yaml
```

Pastikan snapshot berhasil dipulihkan

Pod yang Anda buat pada langkah sebelumnya akan membaca dari snapshot. Untuk melihat data dari snapshot, gunakan perintah kubectl logs.

kubectl logs restore-verify

Output harus menyertakan stempel waktu dari snapshot.

Pembersihan

Agar tidak menimbulkan biaya untuk resource yang digunakan pada halaman ini, ikuti langkah-langkah berikut.

Hapus VolumeSnapshot.
```
kubectl delete volumesnapshot example-snapshot
```
Catatan: Jika VolumeSnapshotClass snapshot volume memiliki deletionPolicy:Delete, VolumeSnapshotContent dan snapshot fisik yang terkait di sistem penyimpanan juga akan dihapus. Jika memiliki deletionPolicy:Retain, snapshot yang mendasarinya akan dipertahankan.
Hapus Pod sementara:
```
kubectl delete -f restore-log.yaml
```
Hapus Pod:
```
kubectl delete -f snapshot-shell.yaml
```

Hapus objek PersistentVolumeClaim:

kubectl delete pvc example-pvc pvc-restore

Langkah selanjutnya

Baca dokumentasi Snapshot Volume Kubernetes.
Instal driver CSI tambahan.