Explore e Debugue Aplicações Kubernetes: Guia de Solução de Problemas

Introdução

Neste laboratório, você explorará e depurará aplicações Kubernetes. Você iniciará um cluster Kubernetes local usando Minikube, implantará uma aplicação de exemplo e aprenderá várias técnicas de depuração, como inspecionar a configuração da aplicação, visualizar logs, executar comandos dentro de pods e examinar eventos do cluster. Essas habilidades são essenciais para desenvolver e solucionar problemas em aplicações baseadas em Kubernetes.

Iniciar o Cluster Kubernetes

Nesta etapa, você aprenderá como iniciar e verificar um cluster Kubernetes local usando Minikube. Este é um primeiro passo essencial para desenvolver e testar aplicações Kubernetes em sua máquina local.

Primeiro, inicie o cluster Minikube:

minikube start

Exemplo de saída:

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🚀  Launching Kubernetes ...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Agora, verifique o status do cluster usando múltiplos comandos:

minikube status
kubectl get nodes

Exemplo de saída:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Esses comandos confirmam que:

Minikube está rodando com sucesso
Um cluster Kubernetes local foi criado
O cluster está pronto para uso
Você tem um cluster de nó único com capacidades de plano de controle

Vamos verificar o contexto do cluster para garantir que você está conectado ao cluster correto:

kubectl config current-context

Exemplo de saída:

minikube

Isso verifica que kubectl está configurado para usar o cluster Minikube.

Ilustração para a configuração do cluster Kubernetes

Implantar uma Aplicação de Exemplo

Nesta etapa, você aprenderá como criar e implantar uma aplicação Kubernetes simples usando manifestos YAML. Criaremos tanto um Pod quanto um Deployment para demonstrar diferentes maneiras de implantar aplicações.

Primeiro, crie um diretório para seus manifestos Kubernetes:

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Crie um manifesto de Pod NGINX simples:

nano nginx-pod.yaml

Adicione o seguinte conteúdo:

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx:latest
      ports:
        - containerPort: 80

Pressione Ctrl+X, depois Y e Enter para salvar e sair.

Agora, crie um manifesto de Deployment:

nano nginx-deployment.yaml

Adicione o seguinte conteúdo:

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

Aplique os manifestos para criar os recursos:

kubectl apply -f nginx-pod.yaml
kubectl apply -f nginx-deployment.yaml

Exemplo de saída:

pod/nginx-pod created
deployment.apps/nginx-deployment created

Verifique os recursos criados:

kubectl get pods
kubectl get deployments

Exemplo de saída:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          1m
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           1m

Aguarde o deployment criar as réplicas. A coluna READY deve mostrar 3/3 quando todas as réplicas estiverem prontas.

Principais diferenças entre Pod e Deployment:

Pod: Instância única de uma aplicação
Deployment: Gerencia múltiplas réplicas e fornece auto-cura

Diferenças entre Pod e Deployment

Verificar a Configuração da Aplicação

Nesta etapa, você aprenderá como inspecionar e recuperar os detalhes de configuração de Deployments e Pods Kubernetes usando vários comandos kubectl. Entender como examinar as configurações de recursos é crucial para solucionar problemas e entender a configuração da sua aplicação.

Primeiro, vamos recuperar a configuração YAML do Pod que criamos na etapa anterior:

kubectl get pod nginx-pod -o yaml

Exemplo de saída (parcial):

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  namespace: default
  labels:
    app: nginx
spec:
  containers:
    - image: nginx:latest
      imagePullPolicy: Always
      name: nginx
      ports:
        - containerPort: 80
      resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always

Agora, vamos examinar a configuração do Deployment:

kubectl get deployment nginx-deployment -o yaml

Exemplo de saída (parcial):

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

Use kubectl describe para obter informações mais detalhadas sobre os recursos:

kubectl describe pod nginx-pod
kubectl describe deployment nginx-deployment

Exemplo de saída para describe pod (parcial):

Name:         nginx-pod
Namespace:    default
Priority:     0
Node:         minikube/172.17.0.2
Start Time:   [timestamp]
Labels:       app=nginx
Annotations:  <none>
Status:       Running
IP:           172.17.0.5
Containers:
  nginx:
    Container ID:   docker://[container-id]
    Image:          nginx:latest
    Image ID:       docker-pullable://nginx@[image-digest]
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
    Ready:          True
    Restart Count:  0
Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True

Você também pode usar a saída JSON para formatos mais legíveis por máquina:

kubectl get pod nginx-pod -o json

Coisas importantes para procurar ao inspecionar configurações:

Metadados do recurso (nome, rótulos, namespace)
Imagem e portas do container
Contagem de réplicas (para Deployments)
Status e condições do recurso

Visualizar Logs de uma Aplicação

Nesta etapa, você aprenderá como visualizar e inspecionar logs para Pods Kubernetes usando kubectl logs. Visualizar logs é crucial para entender o comportamento da aplicação, depurar problemas e monitorar o desempenho da aplicação.

Primeiro, liste os Pods disponíveis para garantir que você está trabalhando com os recursos corretos:

kubectl get pods

Exemplo de saída:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          20m
nginx-deployment-xxx-yyy            1/1     Running   0          20m
nginx-deployment-xxx-zzz            1/1     Running   0          20m
nginx-deployment-xxx-www            1/1     Running   0          20m

Visualize os logs para um Pod específico:

## Visualize os logs para o nginx-pod
kubectl logs nginx-pod

Exemplo de saída:

/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
...
2023/xx/xx [notice] xxxx#x: signal process started

Visualize os logs para os Pods de um Deployment:

## Visualize os logs para um pod específico no deployment
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')
kubectl logs $POD_NAME

Explore opções adicionais de visualização de logs:

## Visualize as últimas 50 linhas dos logs
kubectl logs nginx-pod --tail=50

## Acompanhe os logs em tempo real
kubectl logs -f nginx-pod

Exemplo de acompanhamento de logs:

[real-time log output will be displayed]

Saia da visualização de logs em tempo real pressionando Ctrl + C.

Para Pods com múltiplos containers, especifique o nome do container:

## Se um Pod tiver múltiplos containers
kubectl logs nginx-pod -c nginx

Principais técnicas de visualização de logs:

Visualizar todo o histórico de logs
Limitar as linhas de log
Acompanhar os logs em tempo real
Especificar o container em Pods com múltiplos containers

Debug usando kubectl exec

Nesta etapa, você aprenderá como usar kubectl exec para executar comandos dentro de um Pod Kubernetes, o que é essencial para depurar e investigar ambientes de container.

Primeiro, verifique os Pods disponíveis:

kubectl get pods

Exemplo de saída:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          30m
nginx-deployment-xxx-yyy            1/1     Running   0          30m
nginx-deployment-xxx-zzz            1/1     Running   0          30m
nginx-deployment-xxx-www            1/1     Running   0          30m

Execute um shell interativo no nginx-pod:

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

Exemplos de interações dentro do Pod:

## Verifique a configuração do nginx
cat /etc/nginx/nginx.conf

## Verifique os pacotes instalados
apt update && apt list --installed

## Saia do shell do pod
exit

Certifique-se de usar exit no shell interativo para retornar ao prompt do shell.

Execute comandos específicos sem entrar em um shell interativo:

## Verifique a versão do nginx
kubectl exec nginx-pod -- nginx -v

## Liste os arquivos na raiz web
kubectl exec nginx-pod -- ls /usr/share/nginx/html

Para Pods de Deployment, selecione um Pod específico:

## Obtenha o nome de um Pod do deployment
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')

## Execute comandos no Pod do deployment
kubectl exec -it $POD_NAME -- /bin/bash

Principais técnicas de kubectl exec:

Executar shells interativos
Executar comandos específicos
Investigar os detalhes internos do Pod
Depurar configurações de container

Usar kubectl describe para solução de problemas

Nesta etapa, você aprenderá como usar kubectl describe para diagnosticar e solucionar problemas de recursos Kubernetes, fornecendo informações detalhadas sobre os status de Pod, Deployment e componentes do cluster.

Primeiro, vamos criar um deployment problemático para demonstrar a depuração:

cd ~/project/k8s-manifests
nano problematic-deployment.yaml

Adicione o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: debug-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: debug
  template:
    metadata:
      labels:
        app: debug
    spec:
      containers:
        - name: debug-container
          image: non-existent-image:latest
          ports:
            - containerPort: 80

Aplique o deployment:

kubectl apply -f problematic-deployment.yaml

Agora, use kubectl describe para investigar o deployment:

kubectl describe deployment debug-deployment

Exemplo de saída:

Name:                   debug-deployment
Namespace:              default
CreationTimestamp:      [timestamp]
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=debug
Replicas:               2 desired | 0 available | 2 total | 2 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Conditions:
  Type           Status   Reason
  ----           ------   ------
  Available      False    MinimumReplicasUnavailable
  Progressing    False    ProgressDeadlineExceeded
OldReplicaSets:  <none>
NewReplicaSet:   debug-deployment-xxx (2/2 replicas created)
Events:
  Type     Reason                    Age   From                   Message
  ----     ------                    ----  ----                   -------
  Warning  FailedCreate              1m    deployment-controller  Failed to create pod
  Normal   ScalingReplicaSet         1m    deployment-controller  Scaled up replica set

Descreva os Pods para obter mais detalhes:

kubectl describe pods -l app=debug

Exemplo de saída:

Name:           debug-deployment-xxx-yyy
Namespace:      default
Priority:       0
Node:           minikube/172.17.0.2
Start Time:     [timestamp]
Labels:         app=debug
Annotations:    <none>
Status:         Pending
Conditions:
  Type           Status
  Initialized    True
  Ready          False
  PodScheduled   True
Events:
  Type     Reason                  Age   From               Message
  ----     ------                  ----  ----               -------
  Warning  FailedCreatePodSandBox  1m    kubelet            Failed to create pod sandbox
  Warning  Failed                  1m    kubelet            Failed to pull image

Descreva os recursos do nó:

kubectl describe nodes minikube

Principais técnicas de solução de problemas:

Identificar o status do deployment e do pod
Visualizar mensagens de erro detalhadas
Entender por que os recursos não estão sendo executados
Verificar as condições do nó e do cluster

Examinar Eventos do Cluster (kubectl get events) para Pistas e Linhas do Tempo

Nesta etapa, você aprenderá como usar kubectl get events para investigar eventos em todo o cluster, entender as atividades do sistema e diagnosticar problemas em seu ambiente Kubernetes.

Primeiro, visualize todos os eventos do cluster:

kubectl get events

Exemplo de saída:

LAST SEEN   TYPE      REASON                 OBJECT                           MESSAGE
10m         Warning   FailedCreate           deployment/debug-deployment     Failed to create pod
5m          Normal    Scheduled              pod/nginx-pod                   Successfully assigned default/nginx-pod to minikube
3m          Normal    Pulled                 pod/nginx-deployment-xxx-yyy    Container image "nginx:latest" already present on machine

Filtre eventos por namespace:

kubectl get events -n default

Use opções de visualização de eventos mais detalhadas:

## Watch events in real-time
kubectl get events -w

## Get events sorted by timestamp
kubectl get events --sort-by='.metadata.creationTimestamp'

Crie um cenário personalizado de geração de eventos:

cd ~/project/k8s-manifests
nano event-test-deployment.yaml

Adicione o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: event-test
spec:
  replicas: 3
  selector:
    matchLabels:
      app: event-test
  template:
    metadata:
      labels:
        app: event-test
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          resources:
            limits:
              cpu: "100m"
              memory: "50Mi"

Aplique o deployment e examine os eventos:

kubectl apply -f event-test-deployment.yaml
kubectl get events

Filtragem avançada de eventos:

## Filter by event type
kubectl get events --field-selector type=Warning

## Filter by specific resource
kubectl get events --field-selector involvedObject.kind=Deployment

Principais técnicas de exame de eventos:

Visualizar eventos em todo o cluster
Filtrar eventos por namespace
Observação de eventos em tempo real
Identificar eventos de aviso e erro

Resumo

Neste laboratório, você aprendeu como iniciar e verificar um cluster Kubernetes local usando o Minikube, que é um primeiro passo essencial para desenvolver e testar aplicações Kubernetes em sua máquina local. Você também aprendeu como criar e implantar uma aplicação Kubernetes simples usando manifestos YAML, incluindo tanto um Pod quanto um Deployment. Adicionalmente, você explorou vários comandos para inspecionar a configuração, visualizar logs, depurar e solucionar problemas da aplicação, obtendo uma melhor compreensão de como gerenciar e monitorar aplicações Kubernetes.