Kubernetes na Prática: Orquestração Inteligente de Containers para Aplicações Cloud-Native

O que é Kubernetes e por que ele domina a orquestração de containers?

Kubernetes, também conhecido como K8s, é o sistema open-source mais utilizado do mundo para automatizar a implantação, o escalonamento e o gerenciamento de aplicações em containers. Originalmente desenvolvido pelo Google — que o utiliza há mais de uma década para rodar bilhões de containers por semana — o Kubernetes se tornou o padrão de facto para orquestração de containers.

Empresas como Spotify, Airbnb, Pokémon GO e milhares de startups confiam no Kubernetes para garantir alta disponibilidade, resiliência e escalabilidade automática de suas aplicações.

Arquitetura do Cluster

Um cluster Kubernetes é composto por dois tipos de nós:

• Control Plane (Master): gerencia o cluster com API Server, Scheduler, Controller Manager e etcd (banco chave-valor).
• Worker Nodes: executam as aplicações em containers. Cada worker roda Kubelet, kube-proxy e o container runtime (Docker, containerd ou CRI-O).

A principal ferramenta de interação é o kubectl, que se comunica com o API Server.

Pods: a unidade mínima de execução

O Pod é a menor unidade no Kubernetes. Um Pod pode conter um ou mais containers que compartilham rede, IP e armazenamento. O padrão mais comum é um container por Pod, mas o padrão sidecar coloca containers auxiliares (proxies, coletores de log) no mesmo Pod.

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

Deployments: garantindo alta disponibilidade

Pods criados diretamente não são recriados se falharem. Para isso existem os Deployments, que gerenciam réplicas via ReplicaSets:

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

Com replicas: 3, o Kubernetes mantém três instâncias ativas. Se uma falha, outra é criada automaticamente — é o auto-healing.

Services: expondo sua aplicação

Pods são efêmeros e têm IPs dinâmicos. Para expor a aplicação de forma estável, usamos Services:

• ClusterIP: expõe dentro do cluster (padrão).
• NodePort: expõe em uma porta específica de cada nó.
• LoadBalancer: provisiona um load balancer externo (AWS, GCP, Azure).

apiVersion: v1
kind: Service
metadata:
  name: meu-app-service
spec:
  selector:
    app: meu-app
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer

Horizontal Pod Autoscaler

O Kubernetes escala automaticamente com base em métricas:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: meu-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: meu-app-deployment
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

ConfigMaps e Secrets

• ConfigMap: dados não sensíveis (variáveis de ambiente).
• Secret: dados sensíveis (senhas, tokens) codificados em base64.

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DATABASE_URL: postgres://localhost:5432/meudb
  LOG_LEVEL: debug

Monitoramento com Prometheus e Grafana

O ecossistema Kubernetes conta com Prometheus para coleta de métricas e Grafana para visualização. Com o Prometheus Operator, basta definir um ServiceMonitor apontando para os endpoints.

Boas práticas para produção

1. Resource limits: defina CPU e memória máximos para evitar que um Pod consuma todo o nó.
2. Health checks: configure livenessProbe e readinessProbe.
3. Namespaces: isole ambientes (dev, staging, prod).
4. RBAC: controle permissões com Role-Based Access Control.
5. Network Policies: restrinja a comunicação entre Pods.

livenessProbe:
  httpGet:
    path: /health
    port: 80
  initialDelaySeconds: 30
  periodSeconds: 10

Conclusão

O Kubernetes é a plataforma padrão para orquestração de containers em produção. Com sua arquitetura declarativa, auto-healing, escalabilidade horizontal e ecossistema maduro, ele é indispensável para quem trabalha com cloud-native. Comece com Minikube ou Kind localmente, pratique com estes manifestos e evolua para clusters gerenciados como Amazon EKS, Google GKE ou Azure AKS.