Gerenciamento de Volumes no Kubernetes

Volumes servem para que possamos persistir dados das nossas aplicações. Aqui iremos abordar superficialmente o tema, porém quando estudarmos statefulset, este conteúdo será visto novamente.

Um volume nada mais é que uma pasta que os containers usarão para armazenar e fazer leitura de arquivos. Existem 2 tipos básicos de volumes, os efêmeros (temporários) e persistentes.

Arquivos gravados em containers são efêmeros (ou seja, não são persistentes). No momento em que um container dá problema (crash), o kubelet reinicia o container com problema e os arquivos que nele estão são perdidos,

Se um container estiver compartilhando dados com o mesmo Pod que foi reiniciado, teremos mais containers que podem necessitar dos dados, correndo o risco de não obte-los.

K8s tem volumes mais elaborados que o Docker. No docker, um volume pode ser em disco ou em outro container.

K8s oferece vários tipos de volumes, inclusive, suporte a volumes que o Docker não tem, porem pode utilizá-los.

Não há limites de quantidade de volumes utilizados por um Pod

Volumes efêmeros tem a vida útil ligados a vida do Pod, ou seja, quando um pode é deletado, os volumes também são deletados.

Quando um Pod é criado, um volume também é criado, podendo ser volumes efemeros ou volumes persistentes.

Todos os seus containers dentro do seu Pod pode acessar (ler e gravar) os mesmos arquivos neste volume. Este volume compartilhado pode ser montado em caminhos diferentes para seus containers (como se fosse alias para a mesma localização)

O volume do tipo emptyDir é um volume efemero, mas ele sobrevive a uma reinicialização de container, como consequencia de uma falha de sanidade por exemplo. O volume só será removido se o container morrer. Dessa forma, empyDir é muito utilizado para cache.

emptyDir aceitar fazer a montagem em diversos tipos de mídia, como disco, ssd, storage, rede. Ele suporta mondar no emptyDir

tmpfs (Temporary File System) também é suportado, armazenado na memória Ram, simulando um disco. A grande vantagem é a velocidade. A disvantagem é que se consome memória do seu container.

K8s inclui protocolos de armazenagens de rede, como NFS & iSCSI e obviamente, também para provedores de nuvem como Elastic Block Store (AWS), Files and Disk Storage (Azure), Persistent Disk (Google)

Configurando um emptyDir Volume

Vamos fazer a criação de um arquivo chamado my-volumes.yaml, contendo o seguinte conteúdo. Salve o arquivo:

apiVersion: v1
kind: Pod
metadata:
  name: redis-pod
spec:
  containers:
  - name: redis-container
    image: redis
    volumeMounts:
    - name: "cache--storage"
      mountPath: "/my-volume"
  volumes:
  - name: cache--storage
    emptyDir: {}

Vamos aplicar o arquivo:

kubectl apply -f my-volumes.yaml

Vamos monitorar o get pods em tempo real. No mesmo terminal, execute o comando:

watch kubectl get pods

Abra um outro terminal, e vamos conectar no nosso container:

kubectl exec -it redis-pod -- /bin/bash

Após conectado, podemos navegar no volume que especificamos no arquivo yaml:

cd /my-volume/

Vamos criar um arquivo qualquer dentro do volume, executando o comando:

echo "Hello World" > teste.txt

Verifique a existencia do arquivo e veja o conteúdo do arquivo:

ls
cat teste.txt

Vamos instalar o procps para fazer outras analises dentro do redis-pod. Execute o comando:

apt-get update

Para instalar o procps, execute o comando e confirme com Y

apt-get install procps

Vamos verificar os processos que estão sendo executados:

ps -aux

Posicione aproximadamente as telas uma em baixo da outra do terminal 1 e 2. Veja que no termial 1, a columa RESTARTS está com 0.

No terminal 2, vamos matar o processo do redis

kill -9 1

Caso nao tenha matado o processo, o Pod pode estar protengendo o serviço principal.

Saia do shell com o comando:

exit

Veja temos algum processo redis, com o comando:

ps -aux |grep redis

Vamos matar o processo do redis:

sudo kill -9 467709

Veja que no terminal 1, agora temos a alteração do restart:

No termial 1, entre novamente no shell

kubectl exec -it redis-pod -- /bin/bash

Veja que o arquivo persistiu no my-volume após a queda e restabelecimento do redis-pod

cd /
cd my-volume
ls

Vamos deletar agora o pods redis-pod:

No terminal1, digite o seguinte comando:

kubectl get pods
kubectl delete pods redis-pod

Veja que no terminal 2, ele saiu do shell do pod:

Recrie novamente o Pod, aplicando o arquivo:

kubectl apply -f my-volumes.yaml

No terminal 2, entre novamente no shell:

kubectl exec -it redis-pod -- /bin/bash

Dê o comando para voltar ao diretório principal e liste as pastas do redis-pod

cd /
ls

Entre no my-volume

cd my-volume
ls

Veja que o arquivo txt não se encontra mais dentro do my-volume, ou seja, ele não resiste a recriação do Pod.

Criação de Volumes Persistentes - hostPath

Outro tipo de volume que podemos trabalhar no K8s é o hostPath. Esse é um tipo de volume que mantém os dados, mesmo que seja dado um restart de container e também mantém os dados caso o seu Pod venha a ser removido e recriado. É um tipo de volume que consegue persistir dados dentro do seu worker node.

Dentro do seu node será criado um hostPath. Todos os seus dados gravados em hostPath volume, a qual eles serão gravados em disco dentro do seu worker node. Esses dados permanecerão até que seu cluster seja removidos ou seu worker node ser removido. (os arquivos também podem ser removidos manualmente)

HostPath também pode ser usado para persistencia de dados e essa persistencia de dados é feito dentro daquele worker node através do nosso hostPath.

Abra um novo arquivo, salve com o nome de my-volume-persist.yaml, e com o seguinte conteúdo:

apiVersion: v1
kind: Pod
metadata:
  name: redis-pod
spec:
  containers:
  - name: redis-container
    image: redis
    volumeMounts:
    -  mountPath: "/my-data"
       name: "my-hostpath-vol"
  volumes:
  - name: "my-hostpath-vol"
    hostPath:
      path: "/var/lib/2-persist"

Aplique o arquivo descrito acima, em um terminal 1

kubectl apply -f my-volumes-persist.yaml

Abra um terminal 2, e vamos entrar nesse container:

kubectl exec -it redis-pod -- /bin/bash

Vamos entrar nesse volume:

cd /my-data

Vamos criar um arquivo com echo:

echo "Hello World!" > teste.txt

Veja o conteúdo do arquivo:

cat teste.txt

Mas, para onde está este arquivo? Estamos usando o workder node minikube, então ele está gravado dentro do minikube. Vamos confirmar a gravação desse arquivo.

Abra o Files do Ubuntu para que voce consiga navegar entre as pastas mais facilmente:

Entrre nas pastas a seguir: var/lib/docker/volumes/minikube/_data/lib, Dentro da pasta Docker, ele vai pedir a senha de root. Se voce estiver utilizando a VM que estamos usando, a senha será 123456 do usuário vboxuser.

Entre na pasta 2-persist, e veja que o arquivo criado dentro do shell do redis-pod está nessa pasta.

Vamos fazer um crash desse container, para verificar que o arquivo não irá sumir. Vá para o terminal 1, e vamos deletar o pod:

kubectl delete pod redis-pod

Mesmo com o Pod deletado, o arquivo continua onde está:

Vamos novamente fazer a aplicação do arquivo my-volume-persist.yaml, no terminal 1

kubectl apply -f my-volumes-persist.yaml

No terminal 2, conecte novamente no bash:

kubectl exec -it redis-pod -- /bin/bash

Veja se o arquivo continua como estava:

cd /data
ls

Esse arquivo se permaneceu, mesmo fazendo a deleção do Pod.

Para finalizar, faça a limpeza, excluindo o pod:

kubectl delete pod redis-pod

Em temas mais adiante, como StatefulSets, retornaremos a esse assunto, que ainda tem muita coisa a ser vista!

Esperamos que tenham gostado.

Obrigado e até +!