Pods Kubernetes: Executando Containers e Gerenciamento

Introdução

Neste laboratório, você aprenderá como executar containers em Pods do Kubernetes. Pods são a menor e mais simples unidade no Kubernetes, e podem conter um ou mais containers. Executar containers em Pods oferece muitos benefícios, incluindo melhor utilização de recursos, escalabilidade mais fácil e implantação mais eficiente.

Iniciar o Cluster Minikube

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

Navegue para o seu diretório de trabalho:

Abra o terminal e navegue até a pasta do projeto padrão:
```
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 (Em execução).
- Se o cluster não estiver em execução, execute novamente minikube start.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Criar um Pod com um Único Container

O primeiro passo é criar um Pod com um único container. Para fazer isso, você criará um arquivo YAML que define o Pod e seu container.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-1
spec:
  containers:
    - name: my-container
      image: nginx

Salve o código acima em um arquivo chamado /home/labex/project/pod-single-container.yaml e execute o seguinte comando:

kubectl apply -f /home/labex/project/pod-single-container.yaml

Este comando criará um Pod chamado my-pod-1 com um único container chamado my-container que executa a imagem Nginx.

Criar um Pod com Múltiplos Containers

O segundo passo é criar um Pod com múltiplos containers. Para fazer isso, você modificará o arquivo YAML anterior para adicionar outro container.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-2
spec:
  containers:
    - name: my-container
      image: nginx
    - name: my-sidecar
      image: busybox
      command: ["sh", "-c", "echo Hello from the sidecar! && sleep 3600"]

Salve o código acima em um arquivo chamado /home/labex/project/pod-multiple-containers.yaml e execute o seguinte comando:

kubectl apply -f /home/labex/project/pod-multiple-containers.yaml

Este comando criará um Pod chamado my-pod-2 com dois containers. O primeiro container executa a imagem Nginx, e o segundo container executa a imagem BusyBox e imprime uma mensagem no console.

Criar um Pod com Variáveis de Ambiente

O terceiro passo é criar um Pod com variáveis de ambiente. Para fazer isso, você modificará o arquivo YAML para adicionar variáveis de ambiente ao container Nginx.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-3
spec:
  containers:
    - name: my-container
      image: nginx
      env:
        - name: MY_ENV_VAR
          value: "Hello World!"

Salve o código acima em um arquivo chamado /home/labex/project/pod-env-vars.yaml e execute o seguinte comando:

kubectl apply -f /home/labex/project/pod-env-vars.yaml

Este comando criará um Pod chamado my-pod-3 com um único container chamado my-container que executa a imagem Nginx e possui uma variável de ambiente chamada MY_ENV_VAR com o valor Hello World!.

Criar um Pod com ConfigMaps

O quarto passo é criar um Pod com ConfigMaps. Um ConfigMap é um recurso do Kubernetes que permite armazenar dados de configuração (como variáveis de ambiente, arquivos de configuração) separadamente do código da sua aplicação. Essa separação facilita a alteração da configuração sem reconstruir seus containers.

Vamos dividir isso em passos simples:

Primeiro, crie um ConfigMap:
```
kubectl create configmap my-config --from-literal=MY_ENV_VAR=labex
```
Este comando cria um ConfigMap chamado my-config que armazena um único par chave-valor:
- Chave: MY_ENV_VAR
- Valor: labex
Você pode verificar se o ConfigMap foi criado e ver seu conteúdo usando:
```
kubectl get configmap my-config -o yaml
```

Em seguida, crie um Pod que usa este ConfigMap:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-4
spec:
  containers:
    - name: my-container
      image: nginx
      envFrom:
        - configMapRef:
            name: my-config

Salve este YAML em /home/labex/project/pod-configmap.yaml e aplique-o:

kubectl apply -f /home/labex/project/pod-configmap.yaml

Isso criará um Pod que tem acesso ao valor de configuração que armazenamos no ConfigMap. O valor estará disponível como uma variável de ambiente dentro do container. Você pode verificar isso executando:

kubectl exec -it my-pod-4 -- env | grep MY_ENV_VAR

Criar um Pod com Volumes Persistentes

O quinto passo é criar um Pod com um Volume Persistente (PV) e uma Declaração de Volume Persistente (PVC). PVs e PVCs são usados para armazenar e acessar dados persistentemente em reinicializações de Pod.

Para fazer isso, você primeiro criará um PV.

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

Salve o código acima em um arquivo chamado /home/labex/project/pv.yaml e execute o seguinte comando:

kubectl apply -f /home/labex/project/pv.yaml

Este comando criará um PV chamado my-pv com uma capacidade de 1Gi e um caminho de host de /mnt/data.

Em seguida, você criará um PVC que solicita 1Gi de armazenamento do PV.

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

Salve o código acima em um arquivo chamado /home/labex/project/pvc.yaml e execute o seguinte comando:

kubectl apply -f /home/labex/project/pvc.yaml

Este comando criará um PVC chamado my-pvc que solicita 1Gi de armazenamento.

Finalmente, você modificará o arquivo YAML para adicionar um volume e uma montagem de volume ao container Nginx.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-5
spec:
  containers:
    - name: my-container
      image: nginx
      volumeMounts:
        - name: my-volume
          mountPath: /mnt/data
  volumes:
    - name: my-volume
      persistentVolumeClaim:
        claimName: my-pvc

Salve o código acima em um arquivo chamado /home/labex/project/pod-pv.yaml e execute o seguinte comando:

kubectl apply -f /home/labex/project/pod-pv.yaml

Este comando criará um Pod chamado my-pod-5 com um único container chamado my-container que executa a imagem Nginx e possui uma montagem de volume em /mnt/data que é apoiada pelo PVC chamado my-pvc.

Resumo

Parabéns! Você concluiu este laboratório e aprendeu como executar containers em Pods do Kubernetes. Você também aprendeu como criar Pods com múltiplos containers, variáveis de ambiente, ConfigMaps e Volumes Persistentes. Estes são conceitos poderosos que o ajudarão a construir aplicações mais resilientes e escaláveis.

Executando Containers em Pods