Armazenando dados de aplicação com PersistentVolumes

Introdução

Neste laboratório, você aprenderá como armazenar dados de aplicações usando PersistentVolumes no Kubernetes.

PersistentVolumes (PVs) são recursos do Kubernetes que representam uma unidade de armazenamento em rede dentro de um cluster. Eles podem ser utilizados para armazenar dados de aplicações de forma independente do ciclo de vida do contêiner. Isso significa que os dados podem ser preservados mesmo se o contêiner for encerrado ou movido para outro nó.

Neste laboratório, você criará um PersistentVolume e o utilizará para armazenar dados de uma aplicação web simples. Em seguida, você modificará a aplicação para utilizar um PersistentVolumeClaim (PVC) para acessar o PersistentVolume. Por fim, você modificará o PVC para solicitar recursos de armazenamento específicos.

Iniciar o cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. O Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

Navegue até o seu diretório de trabalho:

Abra o terminal e navegue até a pasta padrão do projeto:
```
cd /home/labex/project
```
Inicie o Minikube:

Inicie o Minikube para inicializar um cluster Kubernetes:
```
minikube start
```
- Este comando configura um cluster Kubernetes de nó único em sua máquina local.
- O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.
Verifique se o Minikube está em execução:

Verifique o status do cluster Minikube:
```
minikube status
```
- Procure por componentes como kubelet e apiserver listados como Running.
- Se o cluster não estiver em execução, execute minikube start novamente.

Caso encontre problemas ao iniciar o Minikube, utilize minikube delete para redefinir o ambiente, se necessário.

Criar um PersistentVolume

Nesta etapa, você criará um PersistentVolume que pode ser usado para armazenar dados. Você criará um arquivo YAML chamado pv.yaml com o seguinte conteúdo:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  hostPath:
    path: /mnt/data

Este arquivo cria um PersistentVolume com capacidade de 1Gi e modo de acesso ReadWriteOnce. O campo hostPath especifica que os dados serão armazenados na máquina host no caminho /mnt/data. O campo persistentVolumeReclaimPolicy está definido como Retain, o que significa que os dados serão preservados mesmo se o PersistentVolume for excluído.

Aplique o PersistentVolume ao seu cluster com o seguinte comando:

kubectl apply -f pv.yaml

Implantar uma aplicação web simples

Nesta etapa, você implantará uma aplicação web simples que armazenará dados no PersistentVolume que você criou na etapa anterior. Você criará um arquivo YAML chamado web-app.yaml com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
        - name: web-app
          image: nginx
          volumeMounts:
            - name: data
              mountPath: /usr/share/nginx/html/data
      volumes:
        - name: data
          persistentVolumeClaim:
            claimName: my-pvc

Este arquivo cria um Deployment com uma réplica e um contêiner que executa a imagem nginx. O campo volumeMounts especifica que o contêiner deve montar o PersistentVolume no caminho /usr/share/nginx/html/data. O campo volumes especifica que o contêiner deve usar um PersistentVolumeClaim chamado my-pvc.

Aplique o Deployment ao seu cluster com o seguinte comando:

kubectl apply -f web-app.yaml

Criar um PersistentVolumeClaim

Nesta etapa, você criará um PersistentVolumeClaim que será usado para solicitar armazenamento do PersistentVolume que você criou na etapa 2. Você criará um arquivo YAML chamado pvc.yaml com o seguinte conteúdo:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi

Este arquivo cria um PersistentVolumeClaim com modo de acesso ReadWriteOnce e uma solicitação de 500Mi de armazenamento do PersistentVolume.

Aplique o PersistentVolumeClaim ao seu cluster com o seguinte comando:

kubectl apply -f pvc.yaml

Verificar a persistência de dados

Nesta etapa, você verificará se os dados estão sendo persistidos no PersistentVolume. Você acessará a aplicação web em execução no contêiner e gravará alguns dados no PersistentVolume.

Primeiro, encontre o nome do pod que está executando sua aplicação com o seguinte comando:

kubectl get pods -l app=web-app

Você deverá ver um único pod executando sua aplicação. Anote o nome do pod.

Em seguida, execute o comando abaixo para abrir uma sessão de shell no contêiner que executa sua aplicação:

kubectl exec -it pod-name -- /bin/sh

Substitua pod-name pelo nome do pod que você anotou anteriormente.

Assim que estiver na sessão do shell, execute o comando abaixo para adicionar um arquivo test.txt:

echo "This is a test file." > /usr/share/nginx/html/data/test.txt

Este comando cria um arquivo chamado test.txt com o texto "This is a test file." no diretório de dados do PersistentVolume.

Exclua a aplicação web com o seguinte comando:

kubectl delete deployment web-app

Recrie a aplicação web com o seguinte comando:

kubectl apply -f web-app.yaml

Verifique se o arquivo que você criou no diretório de dados ainda existe com o seguinte comando:

kubectl get pods -l app=web-app
kubectl exec pod-name -- cat /usr/share/nginx/html/data/test.txt

Substitua pod-name pelo nome do pod que você anotou anteriormente.

Modificar os recursos de armazenamento do PVC

Nesta etapa, você modificará o PVC para solicitar recursos de armazenamento específicos do PersistentVolume. Você modificará o arquivo pvc.yaml para solicitar 1Gi de armazenamento em vez de 500Mi.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Adicione um campo allowVolumeExpansion: true ao storageclass na última linha.

kubectl edit storageclass standard

Exemplo de modificação de armazenamento do PVC

Aplique o PersistentVolumeClaim atualizado ao seu cluster com o seguinte comando:

kubectl delete deployment web-app
kubectl delete pvc my-pvc
kubectl apply -f web-app.yaml
kubectl apply -f pvc.yaml

Resumo

Neste laboratório, você aprendeu como armazenar dados de aplicações com PersistentVolumes no Kubernetes. Você criou um PersistentVolume, implantou uma aplicação web simples que utilizava o PersistentVolume, criou um PersistentVolumeClaim para solicitar armazenamento do PersistentVolume e modificou o PersistentVolumeClaim para solicitar recursos de armazenamento específicos. Você também verificou que os dados foram persistidos no PersistentVolume mesmo após o contêiner ser encerrado ou movido para outro nó.