ContainerProbe no Kubernetes: Guia Completo

Introdução

No Kubernetes, uma probe (sonda) é uma ferramenta de diagnóstico utilizada para determinar se um container (contêiner) está ativo e pronto para aceitar tráfego. Existem dois tipos de probes: liveness probes (sondas de vivacidade) e readiness probes (sondas de prontidão). Neste laboratório, focaremos no ContainerProbe, que é uma ferramenta usada para detectar quando um container está pronto para aceitar tráfego.

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
```
Iniciar 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.
Verificar 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 Deployment (Implantação)

O primeiro passo é criar um deployment (implantação) no Kubernetes. Usaremos este deployment para testar o ContainerProbe.

Crie um novo arquivo chamado deployment.yaml no diretório /home/labex/project.
Copie e cole o seguinte código no arquivo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: containerprobe-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: containerprobe
  template:
    metadata:
      labels:
        app: containerprobe
    spec:
      containers:
        - name: containerprobe
          image: nginx
          ports:
            - containerPort: 80

Este código cria um deployment com uma réplica, um seletor com o rótulo app: containerprobe e um container executando a imagem nginx.

Aplique o deployment ao seu cluster:

kubectl apply -f deployment.yaml

Adicionar um Liveness Probe (Sonda de Vivacidade)

O próximo passo é adicionar uma liveness probe (sonda de vivacidade) ao container nginx. Uma liveness probe é usada para determinar se o container está ativo. Se a sonda falhar, o Kubernetes reiniciará o container.

Atualize o deployment.yaml no diretório /home/labex/project com o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: containerprobe-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: containerprobe
  template:
    metadata:
      labels:
        app: containerprobe
    spec:
      containers:
        - name: containerprobe
          image: nginx
          ports:
            - containerPort: 80
          livenessProbe:
            httpGet:
              path: /
              port: 80

Este código especifica que a liveness probe deve enviar uma requisição HTTP GET para o caminho raiz na porta 80.

Atualize o deployment:

kubectl apply -f deployment.yaml

Testar o Liveness Probe (Sonda de Vivacidade)

Agora que adicionamos uma liveness probe (sonda de vivacidade), podemos testá-la para ver se está funcionando corretamente.

Obtenha o nome do pod:

kubectl get pods -l app=containerprobe -o jsonpath='{.items[0].metadata.name}'

Este comando obtém o nome do pod criado pelo deployment.

Obtenha o status da liveness probe:

kubectl describe pod <pod-name>

Substitua <pod-name> pelo nome do pod obtido no passo anterior.

Você deve ver uma saída que inclui o seguinte:

Liveness: http-get http://:80/ delay=0s timeout=1s period=10s #success=1 #failure=3

Isso indica que a liveness probe está configurada corretamente.

Adicionar uma Readiness Probe (Sonda de Prontidão)

O próximo passo é adicionar uma readiness probe (sonda de prontidão) ao container nginx. Uma readiness probe é usada para determinar se o container está pronto para aceitar tráfego. Se a sonda falhar, o Kubernetes não enviará tráfego para o container.

Adicione o seguinte código à definição do container em deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: containerprobe-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: containerprobe
  template:
    metadata:
      labels:
        app: containerprobe
    spec:
      containers:
        - name: containerprobe
          image: nginx
          ports:
            - containerPort: 80
          livenessProbe:
            httpGet:
              path: /
              port: 80
          readinessProbe:
            httpGet:
              path: /
              port: 80

Este código especifica que a readiness probe deve enviar uma requisição HTTP GET para o caminho raiz na porta 80.

Atualize o deployment:

kubectl apply -f deployment.yaml

Testar a Readiness Probe (Sonda de Prontidão)

Agora que adicionamos uma readiness probe (sonda de prontidão), podemos testá-la para ver se está funcionando corretamente.

Obtenha o nome do pod:

kubectl get pods -l app=containerprobe -o jsonpath='{.items[0].metadata.name}'

Este comando obtém o nome do pod criado pelo deployment.

Obtenha o status da readiness probe:

kubectl describe pod <pod-name>

Substitua <pod-name> pelo nome do pod da etapa anterior.

Você deve ver uma saída que inclui o seguinte:

Readiness: http-get http://:80/ delay=0s timeout=1s period=10s #success=1 #failure=3

Isso indica que a readiness probe está configurada corretamente.

Resumo

Neste laboratório, aprendemos como usar o ContainerProbe no Kubernetes. Criamos um deployment (implantação), adicionamos uma liveness probe (sonda de vivacidade), testamos a liveness probe, adicionamos uma readiness probe (sonda de prontidão) e testamos a readiness probe. Ao usar o ContainerProbe, podemos garantir que nossos containers estão prontos para aceitar tráfego e estão funcionando corretamente.