Explore e Debugue Aplicações Kubernetes

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:

1. Minikube está rodando com sucesso
2. Um cluster Kubernetes local foi criado
3. O cluster está pronto para uso
4. 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.

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

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.