Menggunakan persistent disk yang sudah ada sebagai PersistentVolume

Autopilot Standard

Halaman ini menjelaskan cara membuat PersistentVolume menggunakan persistent disk yang sudah ada yang diisi dengan data, dan cara menggunakan PersistentVolume di sebuah Pod.

Ringkasan

Ada dua skenario umum yang menggunakan persistent disk yang sudah ada.

Membuat PersistentVolumeClaim dan PersistentVolume secara manual, mengikat keduanya, dan merujuk ke PersistentVolumeClaim dalam spesifikasi Pod.
Menggunakan StatefulSet untuk otomatis menghasilkan PersistentVolumeClaim yang terikat dengan PersistentVolume yang dihasilkan secara manual yang sesuai dengan serangkaian persistent disk yang sudah ada.

Contoh di halaman ini menggunakan Persistent disk Compute Engine yang sudah ada.

Meskipun ext4 adalah jenis sistem file default, Anda dapat menggunakan persistent disk yang sudah ada sebelumnya dengan sistem file xfs selama image node Anda mendukungnya. Untuk menggunakan disk xfs, ubah spec.csi.fsType menjadi xfs di manifes PersistentVolume.

Windows tidak mendukung jenis sistem file ext4. Anda harus menggunakan sistem file NTFS untuk node pool Windows Server. Untuk menggunakan disk NTFS, ubah spec.csi.fsType menjadi NTFS di manifes PersistentVolume.

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 initialize 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.

Pastikan Anda sudah memiliki persistent disk. Untuk menyediakan disk, lihat Menyediakan persistent disk regional.
Pastikan cluster Anda menggunakan driver CSI persistent disk Compute Engine.

Menggunakan PersistentVolumeClaim yang terikat dengan PersistentVolume

Agar container dapat mengakses persistent disk yang sudah ada, Anda harus melakukan hal berikut:

Menyediakan persistent disk yang sudah ada sebagai PersistentVolume.
Mengikat PersistentVolume tersebut ke sebuah PersistentVolumeClaim.
Memberi container di Pod akses ke PersistentVolume tersebut.

Membuat PersistentVolume dan PersistentVolumeClaim

Ada beberapa cara untuk mengikat PersistentVolumeClaim ke PersistentVolume tertentu. Misalnya, manifes YAML berikut membuat PersistentVolume dan PersistentVolumeClaim baru, lalu mengikat klaim ke volume menggunakan claimRef, yang memastikan bahwa PersistentVolume hanya dapat terikat dengan PersistentVolumeClaim tersebut.

Untuk mengikat PersistentVolume ke PersistentVolumeClaim, storageClassName dari kedua resource harus cocok dengan capacity, accessModes, dan volumeMode. Anda dapat menghilangkan storageClassName, tetapi Anda harus menentukan "" untuk mencegah Kubernetes menggunakan StorageClass default.

storageClassName tidak perlu merujuk ke objek StorageClass yang ada. Jika hanya perlu mengikat klaim ke volume, Anda dapat menggunakan nama apa pun yang diinginkan. Namun, jika Anda memerlukan fungsionalitas tambahan yang dikonfigurasi oleh StorageClass, seperti pengubahan ukuran volume, storageClassName harus merujuk ke objek StorageClass yang sudah ada.

Untuk detail selengkapnya, baca dokumentasi Kubernetes tentang PersistentVolume.

Simpan manifes YAML berikut:
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: PV_NAME
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  capacity:
    storage: DISK_SIZE
  accessModes:
    - ReadWriteOnce
  claimRef:
    namespace: default
    name: PV_CLAIM_NAME
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: DISK_ID
    fsType: FS_TYPE
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  namespace: default
  name: PV_CLAIM_NAME
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  volumeName: PV_NAME
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: DISK_SIZE
```
Ganti kode berikut:
- PV_NAME: nama PersistentVolume baru Anda.
- STORAGE_CLASS_NAME: nama StorageClass baru Anda.
- DISK_SIZE: ukuran persistent disk yang sudah ada. Contoh, 500G.
- PV_CLAIM_NAME: nama PersistentVolumeClaim baru Anda.
- DISK_ID: ID persistent disk yang sudah ada. Formatnya adalah projects/{project_id}/zones/{zone_name}/disks/{disk_name} untuk Persistent disk zona, atau projects/{project_id}/regions/{region_name}/disks/{disk_name} untuk Persistent disk regional.
- FS_TYPE: jenis sistem file. Anda dapat membiarkan jenis sistem file ext4 sebagai default, atau menggunakan xfs. Jika cluster Anda menggunakan node pool Windows Server, Anda harus mengubahnya menjadi NTFS.
Untuk menerapkan konfigurasi ini dan membuat resource PersistentVolume serta PersistentVolumeClaim, jalankan perintah berikut:
```
kubectl apply -f FILE_PATH
```
Ganti FILE_PATH dengan jalur ke file YAML.

Menggunakan PersistentVolume di sebuah Pod

Setelah membuat dan mengikat PersistentVolume dan PersistentVolumeClaim, Anda dapat memberikan akses ke volume tersebut kepada container Pod dengan menentukan nilai di kolom volumeMounts.

Konfigurasi YAML berikut membuat Pod baru dan container yang menjalankan image nginx, lalu memasang PersistentVolume di Pod tersebut:

kind: Pod
apiVersion: v1
metadata:
  name: POD_NAME
spec:
  volumes:
    - name: VOLUME_NAME
      persistentVolumeClaim:
        claimName: PV_CLAIM_NAME
  containers:
    - name: CONTAINER_NAME
      image: nginx
      ports:
        - containerPort: 80
          name: "http-server"
      volumeMounts:
        - mountPath: "/usr/share/nginx/html"
          name: VOLUME_NAME

Ganti kode berikut:

POD_NAME: nama Pod baru Anda.
VOLUME_NAME: nama volume.
PV_CLAIM_NAME: nama PersistentVolumeClaim yang Anda buat pada langkah sebelumnya.
CONTAINER_NAME: nama container baru.

Terapkan konfigurasi:

kubectl apply -f FILE_PATH

Ganti FILE_PATH dengan jalur ke file YAML.

Untuk memastikan volume sudah terpasang, jalankan perintah berikut:

kubectl describe pods POD_NAME

Di output, pastikan PersistentVolumeClaim telah terpasang:

...
Volumes:
  VOLUME_NAME:
    Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  PV_CLAIM_NAME
    ReadOnly:   false
Events:
  Type    Reason                  Age   From                     Message
  ----    ------                  ----  ----                     -------
  Normal  Scheduled               29s   default-scheduler        Successfully assigned default/POD_NAME to gke-cluster-1-default-pool-d5cde866-o4g4
  Normal  SuccessfulAttachVolume  21s   attachdetach-controller  AttachVolume.Attach succeeded for volume "PV_NAME"
  Normal  Pulling                 19s   kubelet                  Pulling image "nginx"
  Normal  Pulled                  19s   kubelet                  Successfully pulled image "nginx"
  Normal  Created                 18s   kubelet                  Created container CONTAINER_NAME
  Normal  Started                 18s   kubelet                  Started container CONTAINER_NAME

Menggunakan disk yang sudah ada sebelumnya di StatefulSet

Anda dapat menggunakan persistent disk Compute Engine yang sudah ada sebelumnya di StatefulSet menggunakan PersistentVolume. StatefulSet otomatis menghasilkan PersistentVolumeClaim untuk setiap replika. Anda dapat memprediksi nama PersistentVolumeClaim yang dihasilkan dan mengikatnya ke PersistentVolume menggunakan claimRef.

Pada contoh berikut, Anda mengambil dua persistent disk yang sudah ada, membuat PersistentVolume untuk menggunakan disk tersebut, lalu memasang volume ini di StatefulSet dengan dua replika di namespace default.

Tentukan nama untuk StatefulSet baru Anda, nama untuk template PersistentVolumeClaim, dan jumlah replika di StatefulSet.
Berikan nama untuk PersistentVolumeClaim yang dihasilkan secara otomatis. StatefulSet menggunakan format berikut untuk nama PersistentVolumeClaim:
```
PVC_TEMPLATE_NAME-STATEFULSET_NAME-REPLICA_INDEX
```
Ganti kode berikut:
- PVC_TEMPLATE_NAME: nama template PersistentVolumeClaim baru.
- STATEFULSET_NAME: nama StatefulSet baru.
- REPLICA_INDEX: indeks replika StatefulSet. Untuk contoh ini, gunakan 0 dan 1.

Buat PersistentVolume. Anda harus membuat PersistentVolume untuk setiap replika di StatefulSet.

Simpan manifes YAML berikut:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-ss-demo-0
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  capacity:
    storage: DISK1_SIZE
  accessModes:
    - ReadWriteOnce
  claimRef:
    namespace: default
    name: PVC1_NAME
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: DISK1_ID
    fsType: FS_TYPE
 ---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-ss-demo-1
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  capacity:
    storage: DISK2_SIZE
  accessModes:
    - ReadWriteOnce
  claimRef:
    namespace: default
    name: PVC2_NAME
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: DISK2_ID
    fsType: FS_TYPE

Ganti kode berikut:

DISK1_SIZE and DISK2_SIZE: ukuran persistent disk yang sudah ada.
DISK1_ID and DISK2_ID: ID persistent disk yang sudah ada.
PVC1_NAME and PVC2_NAME: nama PersistentVolumeClaim yang dihasilkan secara otomatis.
STORAGE_CLASS_NAME: nama StorageClass.

Terapkan konfigurasi:
```
kubectl apply -f FILE_PATH
```
Ganti FILE_PATH dengan jalur ke file YAML.

Buat StatefulSet menggunakan nilai yang Anda pilih pada langkah 1. Pastikan penyimpanan yang Anda tetapkan di volumeClaimTemplates kurang dari atau sama dengan total kapasitas PersistentVolume Anda.

Simpan manifes YAML berikut:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: STATEFULSET_NAME
spec:
  selector:
    matchLabels:
      app: nginx
  serviceName: "nginx"
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: nginx
        image: registry.k8s.io/nginx-slim:0.8
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: PVC_TEMPLATE_NAME
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: PVC_TEMPLATE_NAME
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: "STORAGE_CLASS_NAME"
      resources:
        requests:
          storage: 100Gi

Ganti kode berikut:

STATEFULSET_NAME: nama StatefulSet baru.
PVC_TEMPLATE_NAME: nama template PersistentVolumeClaim baru.
STORAGE_CLASS_NAME: nama StorageClass.

Terapkan konfigurasi:
```
kubectl apply -f FILE_PATH
```
Ganti FILE_PATH dengan jalur ke file YAML.

Langkah selanjutnya

Pelajari cara men-deploy aplikasi stateful.