Esegui il deployment di un workload stateful con Filestore

Configura l'archiviazione di file gestiti con Filestore utilizzando CSI

GKE offre un modo per eseguire automaticamente il deployment e la gestione del driver CSI Kubernetes Filestore nei cluster. L'utilizzo di Filestore CSI consente di creare o eliminare dinamicamente istanze Filestore e utilizzarle nei carichi di lavoro Kubernetes con un StorageClass o un Deployment.

Puoi creare una nuova istanza Filestore creando una PVC che esegue il provisioning dinamico di un'istanza Filestore e del PV oppure accedere a istanze Filestore di cui è stato eseguito il provisioning preliminare nei carichi di lavoro 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/<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

Usa un oggetto PersistentVolumeClaim per accedere al volume

Il seguente file manifest pvc.yaml fa riferimento al StorageClass del driver CSI Filestore denominato filestore-sc.

Per avere più pod del lettore e del writer nel volume, accessMode è impostato su ReadWriteMany.

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

1. Esegui il deployment della PVC:

   kubectl create -f pvc.yaml 

2. Verifica che il PVC sia stato creato:

   kubectl get pvc 

   L'output è simile al seguente:

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

3. Verifica che l'istanza Filestore appena creata sia pronta:

   gcloud filestore instances list 

   L'output è simile al seguente:

   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 

Crea un pod del lettore e del writer

In questa sezione, creerai un pod del lettore e un pod del writer. Questo tutorial utilizza i deployment Kubernetes per creare i pod. Un deployment è un oggetto API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster.

Crea il pod del lettore

Il pod del lettore leggerà il file scritto dai pod del writer. I pod di lettore vedranno l'ora e la replica del pod di writer che ha scritto nel 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

Il pod del lettore leggerà dal percorso /usr/share/nginx/html condiviso tra tutti i pod.

1. Esegui il deployment del pod del lettore:

   kubectl apply -f reader-fs.yaml 

2. Verifica che le repliche del lettore siano in esecuzione con una query sull'elenco dei pod:

   kubectl get pods 

   L'output è simile al seguente:

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

Crea il pod del writer

Il pod writer scrive periodicamente in un file condiviso a cui possono accedere altri pod writer e reader. Il pod writer registra la sua presenza scrivendo il nome host nel file condiviso.

L'immagine utilizzata per il pod writer è un'immagine personalizzata di Alpine Linux, che viene utilizzata per le utilità e le applicazioni di produzione. Include uno script indexInfo.html che recupera i metadati dell'ultimo autore e tiene traccia di tutti gli autori unici e delle scritture totali.

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

Per questo tutorial, il pod writer scrive ogni 30 secondi nel percorso /html/index.html. Modifica il valore del numero sleep per avere una frequenza di scrittura diversa.

1. Esegui il deployment del pod del writer:

   kubectl apply -f writer-fs.yaml 

2. Verifica che i pod di scrittura siano in esecuzione con una query sull'elenco dei pod:

   kubectl get pods 

   L'output è simile al seguente:

   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 

Esporre il workload del lettore a un bilanciatore del carico del servizio e accedervi

Per esporre un carico di lavoro all'esterno del cluster, crea un servizio di tipo LoadBalancer. Questo tipo di servizio crea un bilanciatore del carico esterno con un indirizzo IP raggiungibile tramite internet.

1. Crea un servizio di tipo LoadBalancer denominato reader-lb:

   kubectl create -f loadbalancer.yaml 

2. Guarda il deployment per vedere che GKE assegna un EXTERNAL-IP per il servizio reader-lb:

   kubectl get svc --watch 

   Quando Service è pronto, la colonna EXTERNAL-IP mostra l'indirizzo IP pubblico del bilanciatore del carico:

     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. Premi Ctrl+C per terminare il processo di monitoraggio.

4. Utilizza un browser web per accedere a EXTERNAL-IP assegnato al bilanciatore del carico. La pagina viene aggiornata ogni 30 secondi. Più sono i writer Pod e più breve è la frequenza, più voci verranno visualizzate.

Per visualizzare ulteriori dettagli sul servizio di bilanciamento del carico, consulta loadbalancer.yaml.

Fai lo scale up del writer

Poiché il PV accessMode è stato impostato su ReadWriteMany, GKE può aumentare il numero di pod in modo che più pod del writer possano scrivere in questo volume condiviso (o più lettori possano leggerli).

1. Aumenta lo scale up di writer a cinque repliche:

   kubectl scale deployment writer --replicas=5 

   L'output è simile al seguente:

   deployment.extensions/writer scaled 

2. Verifica il numero di repliche in esecuzione:

   kubectl get pods 

   L'output è simile al seguente:

   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. Utilizza un browser web per tornare a EXTERNAL-IP assegnato al bilanciatore del carico.

A questo punto, hai configurato e scalato il cluster per supportare cinque pod writer stateful. Dove più pod di scrittura scrivono contemporaneamente nello stesso file. Anche i pod reader possono essere facilmente scalati.

(Facoltativo) Accedi ai dati dal pod Writer

Questa sezione mostra come utilizzare un'interfaccia a riga di comando per accedere a un pod di lettura o scrittura. Puoi vedere il componente condiviso in cui lo scrittore sta scrivendo e il lettore sta leggendo.

1. Ottieni il nome del pod del writer:

   kubectl get pods 

   L'output è simile al seguente:

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

   Prendi nota del nome host di un pod del writer (esempio: writer-5465d65b46-7hxv4).

2. Esegui questo comando per accedere al pod writer:

   kubectl exec -it WRITER_HOSTNAME -- /bin/sh 

3. Visualizza il componente condiviso nel file indexData.html:

   cd /html cat indexData.html 

4. Cancella il file indexData.html:

   echo '' > indexData.html 

   Aggiorna il browser web che ospita l'indirizzo EXTERNAL-IP per visualizzare la modifica.

5. Esci dall'ambiente:

   exit