Kubernetes básico: orquestrando contêineres

1. Introdução ao Kubernetes e seus fundamentos

Kubernetes (também conhecido como K8s) é uma plataforma open-source para orquestração de contêineres, originalmente desenvolvida pelo Google e hoje mantida pela Cloud Native Computing Foundation (CNCF). Em um cenário onde aplicações são cada vez mais distribuídas e baseadas em microsserviços, gerenciar manualmente dezenas ou centenas de contêineres torna-se inviável. O Kubernetes resolve esse problema automatizando deploy, escalonamento e operação de contêineres em clusters.

A arquitetura básica do Kubernetes é composta por:

  • Cluster: conjunto de máquinas (físicas ou virtuais) que executam aplicações em contêineres
  • Nodes: máquinas individuais dentro do cluster (podem ser masters ou workers)
  • Pods: menor unidade computacional, que encapsula um ou mais contêineres
  • Control Plane: conjunto de componentes que gerenciam o cluster

As principais vantagens do Kubernetes incluem escalabilidade horizontal automática, auto-recuperação (reinicia contêineres que falham) e abstração da infraestrutura subjacente, permitindo que equipes foquem no desenvolvimento das aplicações.

2. Componentes essenciais do cluster

O Control Plane é o cérebro do cluster, composto por:

  • API Server (kube-apiserver): ponto de entrada para todas as operações, expõe a API REST do Kubernetes
  • Scheduler (kube-scheduler): decide em qual node cada Pod será executado
  • Controller Manager (kube-controller-manager): executa controladores que monitoram o estado desejado do cluster
  • etcd: banco de dados chave-valor distribuído que armazena todo o estado do cluster

Nos Nodes (máquinas worker), encontramos:

  • Kubelet: agente que garante que os contêineres estejam rodando conforme definido
  • Kube-proxy: gerencia as regras de rede e comunicação entre serviços
  • Container Runtime: software que executa os contêineres (Docker, containerd, CRI-O)

A comunicação entre componentes ocorre através da API Server, que atua como hub central. A rede interna do Kubernetes utiliza um modelo flat network, onde cada Pod recebe um IP único e pode se comunicar diretamente com outros Pods.

3. Trabalhando com Pods: a menor unidade de deploy

Um Pod é a unidade atômica do Kubernetes. Diferente de um contêiner isolado, um Pod pode conter múltiplos contêineres que compartilham recursos como rede e armazenamento. Contêineres dentro do mesmo Pod são sempre escalados juntos e executados no mesmo node.

O ciclo de vida de um Pod inclui os estados:

  • Pending: Pod foi aceito mas ainda não foi executado
  • Running: pelo menos um contêiner está em execução
  • Succeeded: todos os contêineres terminaram com sucesso
  • Failed: pelo menos um contêiner terminou com erro

Exemplo prático: criando e gerenciando Pods com kubectl:

# Criar um Pod simples com nginx
kubectl run nginx-pod --image=nginx --restart=Never

# Listar todos os Pods
kubectl get pods

# Ver detalhes de um Pod específico
kubectl describe pod nginx-pod

# Ver logs do Pod
kubectl logs nginx-pod

# Excluir o Pod
kubectl delete pod nginx-pod

4. Deployments: garantindo disponibilidade e atualizações

Deployments são objetos declarativos que gerenciam ReplicaSets, que por sua vez garantem que um número específico de réplicas de Pods esteja sempre em execução. O Deployment permite realizar Rolling Updates (atualizações graduais) e Rollbacks (reversão para versões anteriores) de forma controlada.

Exemplo de manifesto YAML para um Deployment:

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

Para aplicar e gerenciar o Deployment:

# Aplicar o manifesto
kubectl apply -f deployment.yaml

# Verificar o status
kubectl get deployments
kubectl get pods

# Atualizar a imagem (Rolling Update)
kubectl set image deployment/app-deployment app-container=nginx:1.26

# Ver histórico de rollouts
kubectl rollout history deployment/app-deployment

# Fazer rollback para versão anterior
kubectl rollout undo deployment/app-deployment

5. Services: expondo aplicações dentro e fora do cluster

Services são abstrações que definem uma política de acesso a um conjunto de Pods. Eles fornecem um IP estável e balanceamento de carga, mesmo quando Pods são criados ou destruídos.

Tipos de Service:

  • ClusterIP (padrão): expõe o serviço em um IP interno do cluster
  • NodePort: expõe o serviço em uma porta específica de cada Node
  • LoadBalancer: provisiona um balanceador de carga externo (em clouds como AWS, GCP, Azure)

Exemplo: conectando um Deployment a um Service:

apiVersion: v1
kind: Service
metadata:
  name: meu-servico
spec:
  selector:
    app: minha-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

Comandos para gerenciar Services:

# Aplicar o Service
kubectl apply -f service.yaml

# Listar Services
kubectl get services

# Obter detalhes do Service
kubectl describe service meu-servico

6. ConfigMap e Secrets: gerenciando configurações e dados sensíveis

ConfigMaps permitem separar configurações do código da aplicação, enquanto Secrets armazenam dados sensíveis como senhas e tokens de forma segura (codificados em base64).

Exemplo de ConfigMap:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: "production"
  DB_HOST: "db-service"

Exemplo de Secret:

apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  DB_PASSWORD: cGFzc3dvcmQxMjM=  # base64 de "password123"

Montando como variáveis de ambiente em um Pod:

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: minha-app:latest
    envFrom:
    - configMapRef:
        name: app-config
    env:
    - name: DB_PASSWORD
      valueFrom:
        secretKeyRef:
          name: db-secret
          key: DB_PASSWORD

7. Monitoramento e logs no Kubernetes

Comandos essenciais para diagnóstico:

# Ver logs de um Pod
kubectl logs pod-name

# Acompanhar logs em tempo real
kubectl logs -f pod-name

# Ver eventos do cluster
kubectl get events

# Ver uso de recursos
kubectl top pods
kubectl top nodes

# Descrever detalhes de um recurso
kubectl describe pod pod-name

Para monitoramento em produção, o Metrics Server coleta métricas de CPU e memória. Ferramentas como Prometheus e Grafana podem ser integradas para dashboards mais completos. Boas práticas incluem:

  • Centralizar logs usando ferramentas como Elasticsearch, Fluentd e Kibana (EFK Stack)
  • Configurar probes de saúde (liveness, readiness e startup)
  • Definir limites de recursos (requests e limits) para cada contêiner
  • Utilizar namespaces para organizar ambientes (dev, staging, production)

O Kubernetes oferece uma base sólida para orquestração de contêineres, permitindo que equipes entreguem aplicações mais resilientes e escaláveis. Dominar esses conceitos fundamentais é o primeiro passo para explorar recursos avançados como Helm charts, operadores customizados e service mesh.

Referências