Men-deploy workload stateful dengan Filestore

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.

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

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

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/<FILESTORE_ZONE>/<INSTANCE_NAME>/<FILESTORE_SHARE_NAME>"
    volumeAttributes:
      ip: <IP_ADDRESS> # Modify this to Pre-provisioned Filestore instance IP
      volume: <FILESTORE_SHARE_NAME> # Modify this to Pre-provisioned Filestore instance share name

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
   

   Outputnya mirip dengan hal 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
   

Membuat Pod pembaca dan penulis

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
   

   Outputnya mirip dengan hal berikut ini:

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

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. Deploy Pod penulis:

   kubectl apply -f writer-fs.yaml
   

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

   kubectl get pods
   

   Outputnya mirip dengan hal 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
   

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
   

   Outputnya mirip dengan hal berikut ini:

   deployment.extensions/writer scaled
   

2. Pastikan jumlah replika yang berjalan:

   kubectl get pods
   

   Outputnya mirip dengan hal 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
   

   Outputnya mirip dengan hal 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