Implantar uma carga de trabalho com estado usando o Filestore

Configurar o armazenamento de arquivos gerenciados com o Filestore usando CSI

O GKE oferece uma maneira de implantar e gerenciar automaticamente o driver CSI do Kubernetes Filestore nos clusters. Usar o CSI do Filestore permite criar ou excluir instâncias do Filestore de forma dinâmica e usá-las nas cargas de trabalho do Kubernetes com um StorageClass ou Deployment.

É possível criar uma nova instância do Filestore criando um PVC que provisione dinamicamente uma instância do Filestore e o PV ou acesse instâncias pré-provisionadas do Filestore em cargas de trabalho do 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

Usar um PersistentVolumeClaim para acessar o volume

O manifesto pvc.yaml a seguir faz referência ao StorageClass do driver CSI do Filestore chamado filestore-sc.

Para que vários pods leiam e gravem no volume, o accessMode está definido como ReadWriteMany.

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

1. Implante o PVC:

   kubectl create -f pvc.yaml
   

2. Verifique se o PVC foi criado:

   kubectl get pvc
   

   O resultado será assim:

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

3. Verifique se a instância recém-criada do Filestore está pronta:

   gcloud filestore instances list
   

   O resultado será assim:

   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
   

Criar um leitor e um pod de gravação

Criar o pod do leitor

O pod do leitor vai ler o arquivo que está sendo gravado pelos pods de gravação. Os pods do leitor verão qual hora e qual réplica de pod de gravação escreveu no arquivo.

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

O pod do leitor vai ler o caminho /usr/share/nginx/html, que é compartilhado entre todos os pods.

1. Implante o pod do leitor:

   kubectl apply -f reader-fs.yaml
   

2. Consulte a lista de pods para verificar se as réplicas do leitor estão em execução:

   kubectl get pods
   

   O resultado será assim:

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

Crie o pod do gravador

O pod de gravador grava periodicamente em um arquivo compartilhado que outros pods de gravador e de leitor podem acessar. O pod de gravador grava a presença gravando o nome do host no arquivo compartilhado.

A imagem usada para o pod do gravador é uma imagem personalizada do Alpine Linux, usada para utilitários e aplicativos de produção. Ela inclui um script indexInfo.html que receberá os metadados do gravador mais recente e manterá a contagem de todos os gravadores exclusivos e o total de gravações.

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

Neste tutorial, o pod de gravação grava a cada 30 segundos no caminho /html/index.html. Modifique o valor do número sleep para ter uma frequência de gravação diferente.

1. Implante o pod de gravador:

   kubectl apply -f writer-fs.yaml
   

2. Consulte a lista de pods para verificar se eles estão em execução:

   kubectl get pods
   

   O resultado será assim:

   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
   

Expor e acessar a carga de trabalho do leitor em um balanceador de carga de serviço

Para expor uma carga de trabalho fora do cluster, crie um serviço do tipo LoadBalancer. Esse tipo de serviço cria um balanceador de carga externo com um endereço IP acessível pela Internet.

1. Crie um serviço do tipo LoadBalancer chamado reader-lb:

   kubectl create -f loadbalancer.yaml
   

2. Observe a implantação para ver que o GKE atribui um EXTERNAL-IP ao serviço reader-lb:

   kubectl get svc --watch
   

   Quando Service estiver pronto, a coluna EXTERNAL-IP exibirá o endereço IP público do balanceador de carga:

     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. Pressione Ctrl+C para encerrar o processo de observação.

4. Use um navegador da Web para navegar até o EXTERNAL-IP atribuído ao balanceador de carga. A página é atualizada a cada 30 segundos. Quanto mais pods de gravadores e menor a frequência, mais entradas serão exibidas.

Para ver mais detalhes sobre o serviço de balanceador de carga, consulte loadbalancer.yaml.

Escalone o gravador

Como o PV accessMode foi definido como ReadWriteMany, o GKE pode escalonar o número de pods para que mais pods de gravação possam gravar nesse volume compartilhado (ou mais leitores podem ler para lê-los).

1. Aumente os recursos do writer para cinco réplicas:

   kubectl scale deployment writer --replicas=5
   

   O resultado será assim:

   deployment.extensions/writer scaled
   

2. Verifique o número de réplicas em execução:

   kubectl get pods
   

   O resultado será assim:

   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. Use um navegador da Web para navegar novamente para o EXTERNAL-IP atribuído ao balanceador de carga.

Neste ponto, você configurou e escalonou seu cluster para aceitar cinco pods de gravador com estado. Onde vários pods de gravação estão gravando no mesmo arquivo simultaneamente. Os pods do leitor também podem ser escalonados facilmente.

Opcional: acessar dados do pod de gravador

Nesta seção, demonstramos como usar uma interface de linha de comando para acessar um pod de leitor ou de gravador. É possível ver o componente compartilhado em que o autor está escrevendo e o leitor está lendo.

1. Consiga o nome do pod do gravador:

   kubectl get pods
   

   O resultado será assim:

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

   Anote o nome do host de um pod de gravação (exemplo: writer-5465d65b46-7hxv4).

2. Execute o seguinte comando para acessar o pod de gravador:

   kubectl exec -it WRITER_HOSTNAME -- /bin/sh
   

3. Veja o componente compartilhado no arquivo indexData.html:

   cd /html
   cat indexData.html
   

4. Limpe o arquivo indexData.html:

   echo '' > indexData.html
   

   Atualize o navegador da Web que hospeda o endereço do EXTERNAL-IP para ver a alteração.

5. Saia do ambiente:

   exit