Halaman ini diterjemahkan oleh Cloud Translation API.

Mencadangkan penyimpanan Filestore menggunakan snapshot volume

Autopilot Standard

Halaman ini menunjukkan cara mencadangkan dan memulihkan penyimpanan Filestore menggunakan snapshot volume Kubernetes.

Membuat snapshot volume Kubernetes setara dengan membuat cadangan Filestore. Untuk informasi selengkapnya, lihat Tentang snapshot volume Kubernetes.

Persyaratan

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

Anda harus men-deploy driver CSI Filestore. Hanya tingkat layanan Filestore berikut yang didukung:
- HDD Dasar dengan GKE versi 1.21 atau yang lebih baru
- SSD Dasar dengan GKE versi 1.21 atau yang lebih baru
- Zonal (10 TiB hingga 100 TiB) dengan GKE versi 1.27 atau yang lebih baru
- Enterprise dengan GKE versi 1.25 atau yang lebih baru
Gunakan control plane versi 1.17 atau yang lebih baru. Untuk menggunakan driver CSI Filestore di VolumeSnapshot, gunakan nomor versi GKE yang berlaku untuk tingkat layanan Anda.

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

Volume snapshot memiliki batasan ukuran yang sama dengan volume reguler. Misalnya, snapshot Filestore harus berukuran lebih besar dari atau sama dengan 1 TiB untuk tingkat HDD dasar.
Driver CSI Filestore tidak mendukung alur kerja penyediaan atau pencadangan dinamis untuk tingkat layanan Filestore berikut:
- Zonal (1 TiB hingga 9,75 TiB)
- Regional
Anda hanya dapat mencadangkan satu share per instance dalam satu waktu. Sehubungan dengan kumpulan penyimpanan, permintaan pencadangan yang dikeluarkan dari dua share yang berbeda dari dua instance Filestore yang berbeda akan dijalankan secara bersamaan.
Cadangan singleshare hanya dapat dipulihkan ke volume singleshare. Dengan menggunakan driver CSI Filestore, Anda hanya dapat memulihkan volume singleshare ke instance Filestore baru.
- Instance baru harus menggunakan tingkat layanan yang sama dengan cadangan.
- Instance baru harus cocok dengan kapasitas minimum yang sama seperti cadangan.
Operasi backup restore Filestore ke sumber atau ke instance Filestore yang ada tidak didukung. Untuk mengetahui daftar lengkap batasan fitur, lihat Batasan fitur pencadangan Filestore.
Pencadangan multi-berbagi tidak didukung.

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan 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 gcloud components update.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region dan compute/zone. Dengan menetapkan lokasi default, Anda dapat menghindari error di gcloud CLI seperti berikut: One of [--zone, --region] must be supplied: Please specify location.

Membuat dan menggunakan snapshot volume

Contoh dalam dokumen ini menunjukkan cara melakukan tugas berikut:

Buat PersistentVolumeClaim dan Deployment.
Tambahkan file ke PersistentVolume yang digunakan Deployment.
Buat VolumeSnapshotClass untuk mengonfigurasi snapshot.
Buat snapshot volume PersistentVolume.
Hapus file pengujian.
Pulihkan PersistentVolume ke snapshot yang Anda buat.
Verifikasi bahwa pemulihan berfungsi.

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

Buat objek VolumeSnapshotClass untuk menentukan driver CSI dan kebijakan penghapusan untuk snapshot Anda.
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.

Membuat `PersistentVolumeClaim` dan `Deployment`

Untuk membuat objek PersistentVolumeClaim, simpan manifes berikut sebagai my-pvc.yaml:
Filestore
```
 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: enterprise-rwx
   accessModes:
   - ReadWriteMany
   resources:
     requests:
       storage: 1Ti
```
Contoh ini membuat PVC Filestore tingkat Enterprise. Untuk mempelajari lebih lanjut, lihat Mengakses instance Filestore dengan driver CSI Filestore.
Untuk spec.storageClassName, Anda dapat menentukan class penyimpanan apa pun yang menggunakan driver CSI yang didukung.
Terapkan manifes:
```
kubectl apply -f my-pvc.yaml
```

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

Terapkan manifes:
```
kubectl apply -f my-deployment.yaml
```
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

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

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.

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.

Simpan manifes berikut sebagai volumesnapshotclass.yaml.
Filestore
```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: my-snapshotclass
driver: filestore.csi.storage.gke.io
parameters:
  type: backup
deletionPolicy: Delete
```
Dalam contoh ini:
- Kolom driver digunakan oleh driver CSI untuk menyediakan snapshot. Dalam contoh ini, filestore.csi.storage.gke.io menggunakan driver CSI Filestore.
- 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.

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.

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

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.

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 mengikatkannya 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

Hapus file pengujian yang Anda buat:

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

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.

Untuk mereferensikan VolumeSnapshot dalam PersistentVolumeClaim, tambahkan kolom dataSource ke PersistentVolumeClaim Anda.

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

Simpan manifes berikut sebagai pvc-restore.yaml:

Filestore

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-restore
spec:
  dataSource:
    name: my-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  storageClassName: enterprise-rwx
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Ti

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

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

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

Terapkan manifes yang diupdate:
```
kubectl apply -f my-deployment.yaml
```

Pastikan snapshot berhasil dipulihkan

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 resource Google Cloud lain yang dibuat di cluster lain.

Temukan nama snapshot Anda.

Konsol Google Cloud

Buka https://console.cloud.google.com/compute/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

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

Terapkan manifes:

kubectl apply -f restored-snapshot.yaml

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: filestore.csi.storage.gke.io
  source:
    snapshotHandle: projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
  volumeSnapshotRef:
    kind: VolumeSnapshot
    name: restored-snapshot
    namespace: default

Terapkan manifes:

kubectl apply -f restored-snapshot-content.yaml

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: enterprise-rwx
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

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

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

Terapkan manifes:
```
kubectl apply -f restored-pod.yaml
```

Pastikan 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 pada halaman ini, ikuti langkah-langkah berikut.

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.

Hapus VolumeSnapshotClass.

kubectl delete volumesnapshotclass my-snapshotclass

Hapus Deployment.
```
kubectl delete deployments hello-app
```
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 Filestore sebagai opsi penyimpanan file untuk GKE.

Mencadangkan penyimpanan Filestore menggunakan snapshot volume

Persyaratan

Batasan

Sebelum memulai

Membuat dan menggunakan snapshot volume

Membuat PersistentVolumeClaim dan Deployment

Filestore

Menambahkan file pengujian ke volume

Membuat objek VolumeSnapshotClass.

Filestore

Membuat VolumeSnapshot

Menghapus file pengujian

Memulihkan snapshot volume

Filestore

Pastikan snapshot berhasil dipulihkan

Mengimpor snapshot yang sudah ada

Konsol Google Cloud

Google Cloud CLI

Pembersihan

Langkah selanjutnya

Membuat `PersistentVolumeClaim` dan `Deployment`

Membuat objek `VolumeSnapshotClass`.

Membuat `VolumeSnapshot`