Men-deploy workload stateful dengan Filestore

Tutorial ini menunjukkan cara men-deploy workload stateful pembaca/penulis sederhana menggunakan Volume Persisten (PV) dan Klaim Volume Persisten (PVC) di Google Kubernetes Engine (GKE). Ikuti tutorial ini untuk mempelajari cara mendesain skalabilitas menggunakan Filestore, yaitu sistem file jaringan terkelola Google Cloud.

Latar belakang

Secara alami, Pod bersifat sementara. Artinya, GKE menghancurkan status dan nilai yang disimpan dalam Pod saat Pod dihapus, dikeluarkan, atau dijadwalkan ulang.

Sebagai operator aplikasi, Anda mungkin ingin mempertahankan workload stateful. Contoh workload tersebut mencakup aplikasi yang memproses artikel WordPress, aplikasi pesan, dan aplikasi yang memproses operasi machine learning.

Dengan menggunakan Filestore di GKE, Anda dapat melakukan operasi berikut:

• Men-deploy beban kerja stateful yang skalabel.
• Mengaktifkan beberapa Pod agar memiliki ReadWriteMany sebagai accessMode-nya, sehingga beberapa Pod dapat membaca dan menulis secara bersamaan ke penyimpanan yang sama.
• Menyiapkan GKE untuk memasang volume ke beberapa Pod secara bersamaan.
• Mempertahankan penyimpanan saat Pod dihapus.
• Memungkinkan Pod untuk berbagi data dan menskalakan dengan mudah.

Mengonfigurasi penyimpanan file terkelola dengan Filestore menggunakan CSI

GKE menyediakan cara untuk men-deploy dan mengelola driver CSI Filestore Kubernetes secara otomatis di cluster. Dengan menggunakan Filestore CSI, Anda dapat membuat atau menghapus instance Filestore secara dinamis dan menggunakannya dalam workload Kubernetes dengan StorageClass atau Deployment.

Anda dapat membuat instance Filestore baru dengan membuat PVC yang secara dinamis menyediakan instance Filestore dan PV, atau mengakses instance Filestore yang telah disediakan dalam workload Kubernetes.

Catatan: Untuk menggunakan driver CSI Filestore, cluster Anda harus menggunakan GKE versi 1.21 atau yang lebih baru.

Instance baru

Membuat Kelas Penyimpanan

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: filestore-sc
provisioner: filestore.csi.storage.gke.io
volumeBindingMode: Immediate
allowVolumeExpansion: true
parameters:
  tier: standard
  network: default

• volumeBindingMode disetel ke Immediate, yang memungkinkan penyediaan volume segera dimulai.
• tier disetel ke standard untuk waktu pembuatan instance Filestore yang lebih cepat. Jika Anda memerlukan penyimpanan NFS yang lebih tinggi, snapshot untuk pencadangan data, replikasi data di beberapa zona, dan fitur tingkat perusahaan lainnya, tetapkan tier ke enterprise. Catatan: Kebijakan klaim kembali untuk PV yang dibuat secara dinamis akan berubah secara default ke Delete jika reclaimPolicy di StorageClass tidak ditetapkan.

1. Buat resource StorageClass:

   kubectl create -f filestore-storageclass.yaml
   

2. Pastikan bahwa Kelas Penyimpanan telah dibuat:

   kubectl get sc
   

   Output-nya mirip dengan berikut ini:

   NAME                     PROVISIONER                    RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
   filestore-sc             filestore.csi.storage.gke.io   Delete          Immediate              true                   94m
   

Instance yang telah disediakan

Membuat Kelas Penyimpanan

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: filestore-sc
provisioner: filestore.csi.storage.gke.io
volumeBindingMode: Immediate
allowVolumeExpansion: true

Jika volumeBindingMode disetel ke Immediate, penyediaan volume akan segera dimulai.

1. Buat resource StorageClass:

     kubectl create -f preprov-storageclass.yaml
   

2. Pastikan bahwa Kelas Penyimpanan telah dibuat:

     kubectl get sc
   

   Output-nya mirip dengan berikut ini:

     NAME                     PROVISIONER                    RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
     filestore-sc             filestore.csi.storage.gke.io   Delete          Immediate              true                   94m
   

Membuat Volume Persisten untuk instance Filestore

apiVersion: v1
kind: PersistentVolume
metadata:
  name: fileserver
  annotations:
    pv.kubernetes.io/provisioned-by: filestore.csi.storage.gke.io
spec:
  storageClassName: filestore-sc
  capacity:
    storage: 1Ti
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Delete
  volumeMode: Filesystem
  csi:
    driver: filestore.csi.storage.gke.io
    # Modify this to use the zone, filestore instance and share name.
    volumeHandle: "modeInstance/<LOCATION>/<INSTANCE_NAME>/<FILE_SHARE_NAME>"
    volumeAttributes:
      ip: <IP_ADDRESS> # Modify this to Pre-provisioned Filestore instance IP
      volume: <FILE_SHARE_NAME> # Modify this to Pre-provisioned Filestore instance share name

1. Pastikan instance Filestore yang sudah ada sudah siap:

     gcloud filestore instances list
   

   Output-nya mirip dengan berikut ini, dengan nilai STATE adalah READY:

     INSTANCE_NAME: stateful-filestore
     LOCATION: us-central1-a
     TIER: ENTERPRISE
     CAPACITY_GB: 1024
     FILE_SHARE_NAME: statefulpath
     IP_ADDRESS: 10.109.38.98
     STATE: READY
     CREATE_TIME: 2022-04-05T18:58:28
   

   Perhatikan INSTANCE_NAME, LOCATION, FILE_SHARE_NAME, dan IP_ADDRESS dari instance Filestore.

2. Isi variabel konsol instance Filestore:

     INSTANCE_NAME=INSTANCE_NAME
     LOCATION=LOCATION
     FILE_SHARE_NAME=FILE_SHARE_NAME
     IP_ADDRESS=IP_ADDRESS
   

3. Ganti variabel placeholder dengan variabel konsol yang diperoleh di atas ke file preprov-pv.yaml:

     sed "s/<INSTANCE_NAME>/$INSTANCE_NAME/" preprov-pv.yaml > changed.yaml && mv changed.yaml preprov-pv.yaml
     sed "s/<LOCATION>/$LOCATION/" preprov-pv.yaml > changed.yaml && mv changed.yaml preprov-pv.yaml
     sed "s/<FILE_SHARE_NAME>/$FILE_SHARE_NAME/" preprov-pv.yaml > changed.yaml && mv changed.yaml preprov-pv.yaml
     sed "s/<IP_ADDRESS>/$IP_ADDRESS/" preprov-pv.yaml > changed.yaml && mv changed.yaml preprov-pv.yaml
   

4. Buat PV

     kubectl apply -f preprov-pv.yaml
   

5. Verifikasi bahwa STATUS PV diatur ke Bound:

     kubectl get pv
   

   Output-nya mirip dengan berikut ini:

     NAME        CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                STORAGECLASS    REASON   AGE
     fileserver  1Ti        RWX            Delete           Bound    default/fileserver   filestore-sc             46m
   

Menggunakan PersistentVolumeClaim untuk mengakses volume

Manifes pvc.yaml berikut mereferensikan StorageClass driver CSI Filestore bernama filestore-sc.

Agar beberapa Pod dapat membaca dan menulis ke volume, accessMode disetel ke ReadWriteMany.

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: fileserver
spec:
  accessModes:
  - ReadWriteMany
  storageClassName: filestore-sc
  resources:
    requests:
      storage: 1Ti

1. Deploy PVC:

   kubectl create -f pvc.yaml
   

2. Pastikan PVC dibuat:

   kubectl get pvc
   

   Output-nya mirip dengan berikut ini:

   NAME         STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS        AGE
   fileserver   Bound    pvc-aadc7546-78dd-4f12-a909-7f02aaedf0c3   1Ti        RWX            filestore-sc        92m
   

3. Pastikan instance Filestore yang baru dibuat sudah siap:

   gcloud filestore instances list
   

   Output-nya mirip dengan berikut ini:

   INSTANCE_NAME: pvc-5bc55493-9e58-4ca5-8cd2-0739e0a7b68c
   LOCATION: northamerica-northeast2-a
   TIER: STANDARD
   CAPACITY_GB: 1024
   FILE_SHARE_NAME: vol1
   IP_ADDRESS: 10.29.174.90
   STATE: READY
   CREATE_TIME: 2022-06-24T18:29:19
   

Catatan: Pembuatan instance Filestore dapat memerlukan waktu 5 menit. Lanjutkan ke langkah berikutnya sambil menunggu.

Membuat Pod pembaca dan penulis

Di bagian ini, Anda akan membuat Pod pembaca dan Pod penulis. Tutorial ini menggunakan Deployment Kubernetes untuk membuat Pod. Deployment adalah objek Kubernetes API yang memungkinkan Anda menjalankan beberapa replika Pod yang didistribusikan di antara node dalam cluster.

Membuat Pod pembaca

Pod pembaca akan membaca file yang sedang ditulis oleh Pod penulis. Pod pembaca akan melihat waktu dan replika Pod penulis yang menulis ke file.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: reader
spec:
  replicas: 1
  selector:
    matchLabels:
      app: reader
  template:
    metadata:
      labels:
        app: reader
    spec:
      containers:
      - name: nginx
        image: nginx:stable-alpine
        ports:
        - containerPort: 80
        volumeMounts:
        - name: fileserver
          mountPath: /usr/share/nginx/html # the shared directory 
          readOnly: true
      volumes:
      - name: fileserver
        persistentVolumeClaim:
          claimName: fileserver

Pod pembaca akan membaca dari jalur /usr/share/nginx/html yang dibagikan di antara semua Pod.

1. Men-deploy Pod pembaca:

   kubectl apply -f reader-fs.yaml
   

2. Pastikan replika pembaca berjalan dengan membuat kueri daftar Pod:

   kubectl get pods
   

   Output-nya mirip dengan berikut ini:

   NAME                      READY   STATUS    RESTARTS   AGE
   reader-66b8fff8fd-jb9p4   1/1     Running   0          3m30s
   

Catatan: Saat Pod pembaca sedang dibuat, lanjutkan ke langkah berikutnya.

Membuat Pod penulis

Pod penulis akan menulis secara berkala ke file bersama yang dapat diakses oleh Pod penulis dan pembaca lainnya. Pod penulis mencatat kehadirannya dengan menuliskan nama host-nya ke file bersama.

Image yang digunakan untuk Pod penulis adalah image kustom Alpine Linux, yang digunakan untuk aplikasi utilitas dan produksi. Ini mencakup indexInfo.html skrip yang akan mendapatkan metadata penulis terbaru, dan mempertahankan jumlah semua penulis unik dan total penulisan.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: writer
spec:
  replicas: 2 # start with 2 replicas
  selector:
    matchLabels:
      app: writer
  template:
    metadata:
      labels:
        app: writer
    spec:
      containers:
      - name: content
        image: us-docker.pkg.dev/google-samples/containers/gke/stateful-workload:latest
        volumeMounts:
        - name: fileserver
          mountPath: /html # the shared directory
        command: ["/bin/sh", "-c"]
        args:
        - cp /htmlTemp/indexInfo.html /html/index.html;
          while true; do
          echo "<b> Date :</b> <text>$(date)</text> <b> Writer :</b> <text2> ${HOSTNAME} </text2> <br>  " >> /html/indexData.html;
          sleep 30;  
          done
      volumes:
      - name: fileserver
        persistentVolumeClaim:
          claimName: fileserver

Untuk tutorial ini, Pod penulis menulis setiap 30 detik ke jalur /html/index.html. Ubah nilai angka sleep agar memiliki frekuensi tulis yang berbeda.

1. Men-deploy Pod penulis:

   kubectl apply -f writer-fs.yaml
   

2. Pastikan bahwa Pod penulis sedang berjalan dengan membuat kueri daftar Pod:

   kubectl get pods
   

   Output-nya mirip dengan berikut ini:

   NAME                      READY   STATUS    RESTARTS   AGE
   reader-66b8fff8fd-jb9p4   1/1     Running   0          3m30s
   writer-855565fbc6-8gh2k   1/1     Running   0          2m31s
   writer-855565fbc6-lls4r   1/1     Running   0          2m31s
   

   Catatan: Pembuatan pod mungkin memerlukan waktu hingga lima menit.

Mengekspos dan mengakses workload pembaca ke Load Balancer Service

Untuk mengekspos workload di luar cluster, buat Service jenis LoadBalancer. Jenis Service ini membuat load balancer eksternal dengan alamat IP yang dapat dijangkau melalui internet.

1. Buat Service jenis LoadBalancer bernama reader-lb:

   kubectl create -f loadbalancer.yaml
   

2. Pantau deployment untuk melihat bahwa GKE menetapkan EXTERNAL-IP untuk Service reader-lb:

   kubectl get svc --watch
   

   Jika Service sudah siap, kolom EXTERNAL-IP akan menampilkan alamat IP publik load balancer:

     NAME         TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)        AGE
     kubernetes   ClusterIP      10.8.128.1    <none>          443/TCP        2d21h
     reader-lb    LoadBalancer   10.8.131.79   34.71.232.122   80:32672/TCP   2d20h
   

3. Tekan Ctrl+C untuk menghentikan proses pemantauan ini.

4. Gunakan browser web untuk menavigasi ke EXTERNAL-IP yang ditetapkan untuk load balancer. Halaman dimuat ulang setiap 30 detik. Makin banyak Pod penulis dan makin pendek frekuensinya, makin banyak entri yang akan ditampilkan.

Untuk detail selengkapnya tentang layanan load balancer, lihat loadbalancer.yaml.

Meningkatkan skala penulis

Karena accessMode PV disetel ke ReadWriteMany, GKE dapat meningkatkan jumlah Pod sehingga lebih banyak Pod penulis dapat menulis ke volume bersama ini (atau lebih banyak pembaca dapat membacanya).

1. Tingkatkan skala writer menjadi lima replika:

   kubectl scale deployment writer --replicas=5
   

   Output-nya mirip dengan berikut ini:

   deployment.extensions/writer scaled
   

   Catatan: Penskalaan mungkin memerlukan waktu beberapa menit selagi cluster mengalokasikan lebih banyak resource.

2. Pastikan jumlah replika yang berjalan:

   kubectl get pods
   

   Output-nya mirip dengan berikut ini:

   NAME                      READY   STATUS    RESTARTS   AGE
   reader-66b8fff8fd-jb9p4   1/1     Running   0          11m
   writer-855565fbc6-8dfkj   1/1     Running   0          4m
   writer-855565fbc6-8gh2k   1/1     Running   0          10m
   writer-855565fbc6-gv5rs   1/1     Running   0          4m
   writer-855565fbc6-lls4r   1/1     Running   0          10m
   writer-855565fbc6-tqwxc   1/1     Running   0          4m
   

3. Gunakan browser web untuk membuka lagi EXTERNAL-IP yang ditetapkan untuk load balancer.

Pada tahap ini, Anda telah mengonfigurasi dan menskalakan cluster untuk mendukung lima Pod penulis stateful. Saat beberapa Pod penulis menulis ke file yang sama secara bersamaan. Pod pembaca juga dapat ditingkatkan skalanya dengan mudah.

Opsional: Mengakses data dari Pod penulis

Bagian ini menunjukkan cara menggunakan antarmuka command line untuk mengakses Pod pembaca atau penulis. Anda dapat melihat komponen bersama tempat penulis menulis dan tempat pembaca membaca.

1. Mendapatkan nama Pod penulis:

   kubectl get pods
   

   Output-nya mirip dengan berikut ini:

   NAME                      READY   STATUS    RESTARTS   AGE
   writer-5465d65b46-7hxv4   1/1     Running   0          20d
   

   Perhatikan nama host Pod penulis (Contoh: writer-5465d65b46-7hxv4).

2. Jalankan perintah berikut untuk mengakses Pod penulis:

   kubectl exec -it WRITER_HOSTNAME -- /bin/sh
   

3. Lihat komponen bersama dalam file indexData.html:

   cd /html
   cat indexData.html
   

4. Hapus file indexData.html:

   echo '' > indexData.html
   

   Muat ulang browser web yang menghosting alamat EXTERNAL-IP untuk melihat perubahannya.

5. Keluar dari lingkungan:

   exit