Acesse o painel da sua conta

Não tem uma conta? Registrar

Entrar em contato

Visite também nosso site craftxp.com.br

  • img
  • img
  • img
  • img
  • img
  • img

Entre em contato

Kubernetes na Prática: Orquestração de Containers para Aplicações Modernas

Kubernetes na Prática: Orquestração de Containers para Aplicações Modernas

O que é Kubernetes?

Kubernetes (k8s) é uma plataforma open-source de orquestração de containers criada pelo Google e hoje mantida pela Cloud Native Computing Foundation (CNCF). Inspirada no sistema Borg — que o Google usou por mais de uma década para gerenciar bilhões de containers por semana — o Kubernetes automatiza a implantação, o escalonamento e a operação de aplicações em containers.

Kubernetes abstrai a infraestrutura subjacente e oferece uma API declarativa para descrever o estado desejado do sistema. Você define como sua aplicação deve ser executada, e o Kubernetes se encarrega de garantir que a realidade corresponda a essa definição — substituindo containers com falha, escalando réplicas sob demanda e distribuindo tráfego de rede.

Empresas como Spotify, Airbnb, Adidas e Nintendo executam Kubernetes em produção, processando milhões de requisições por segundo.

Por que Kubernetes em 2026?

Cinco anos após a maturidade do ecossistema, Kubernetes não é mais uma tendência — é o padrão de mercado para orquestração:

  • Portabilidade total: o mesmo manifest YAML roda em qualquer cluster — AWS EKS, Azure AKS, Google GKE, DigitalOcean, on-premises ou Raspberry Pi
  • Auto-recuperação: containers com falha são reiniciados automaticamente, nós problemáticos são drenados e pods são reagendados
  • Escalabilidade elástica: Horizontal Pod Autoscaler (HPA) ajusta réplicas em segundos com base em CPU, memória ou métricas customizadas
  • Rolling updates e rollbacks: implantações zero-downtime com controle de versão e reversão automática em caso de falha
  • Service Mesh nativo: Istio, Linkerd e Cilium estendem o Kubernetes com observabilidade, mTLS e roteamento avançado
  • Ecoessistema CNCF: Helm, Prometheus, ArgoCD, cert-manager, Crossplane — centenas de projetos maduros e integrados

Arquitetura do Kubernetes

Um cluster Kubernetes é composto por dois planos principais:

Control Plane (Plano de Controle)

Gerencia o estado do cluster e toma decisões globais. Executa em nós dedicados (masters):

  • API Server (kube-apiserver): porta de entrada para todas as operações. Expõe a API REST do Kubernetes. Toda comunicação interna e externa passa por ele.
  • etcd: banco chave-valor distribuído que armazena todo o estado do cluster. Consistência eventual via Raft consensus.
  • Scheduler (kube-scheduler): decide em qual nó cada pod será executado, considerando recursos, afinidade e restrições.
  • Controller Manager (kube-controller-manager): executa controllers que monitoram o estado atual e reconcilam com o estado desejado.

Data Plane (Nós de Trabalho)

Executa as aplicações reais:

  • kubelet: agente que roda em cada nó. Garante que os containers estejam rodando conforme definido nos PodSpecs.
  • Container Runtime: executa os containers (containerd, CRI-O, Docker via cri-dockerd).
  • kube-proxy: mantém regras de rede nos nós, implementando Services e balanceamento de carga.
# Estrutura básica de um cluster Kubernetes
#
# ┌──────────────────────────────────────────────────┐
# │                    CLUSTER                        │
# │  ┌──────────────┐  ┌──────────────┐              │
# │  │  Control Plane│  │  Worker Node │              │
# │  │  ┌──────────┐│  │  ┌────────┐  │              │
# │  │  │ API Server││  │  │ kubelet │  │              │
# │  │  ├──────────┤│  │  ├────────┤  │              │
# │  │  │  etcd    ││  │  │ Pod A   │  │              │
# │  │  ├──────────┤│  │  ├────────┤  │              │
# │  │  │Scheduler ││  │  │ Pod B   │  │              │
# │  │  ├──────────┤│  │  ├────────┤  │              │
# │  │  │Controller││  │  │ Pod C   │  │              │
# │  │  └──────────┘│  │  └────────┘  │              │
# │  └──────────────┘  └──────────────┘              │
# └──────────────────────────────────────────────────┘

Principais Objetos do Kubernetes

Pod

Unidade mínima do Kubernetes. Um pod encapsula um ou mais containers com armazenamento compartilhado e endereço de rede único. Containers no mesmo pod compartilham o mesmo loopback de rede e podem se comunicar via localhost.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.25
    ports:
    - containerPort: 80
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 500m
        memory: 256Mi

Deployment

Gerencia pods de forma declarativa com ReplicaSets. Suporta rolling updates, rollbacks e escalonamento horizontal. O Deployment é o recurso mais usado para workloads stateless.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-pagamentos
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-pagamentos
  template:
    metadata:
      labels:
        app: api-pagamentos
    spec:
      containers:
      - name: api
        image: minha-app:latest
        ports:
        - containerPort: 3000
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 3
          periodSeconds: 5
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
      maxSurge: 1

Service

Abstração de rede que expõe pods como um serviço de rede estável. Tipos principais: ClusterIP (acesso interno), NodePort (exposição em porta estática), LoadBalancer (balanceador cloud) e ExternalName (alias DNS).

apiVersion: v1
kind: Service
metadata:
  name: svc-api-pagamentos
spec:
  selector:
    app: api-pagamentos
  ports:
  - port: 80
    targetPort: 3000
    protocol: TCP
  type: ClusterIP

Ingress

Gerencia acesso HTTP/HTTPS externo ao cluster. Oferece roteamento baseado em host/path, TLS termination, rate limiting e autenticação.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-principal
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: api.craftxp.com.br
    http:
      paths:
      - path: /pagamentos
        pathType: Prefix
        backend:
          service:
            name: svc-api-pagamentos
            port:
              number: 80
      - path: /pedidos
        pathType: Prefix
        backend:
          service:
            name: svc-api-pedidos
            port:
              number: 80

ConfigMaps e Secrets

Gerenciamento de configuração desacoplado da imagem do container:

  • ConfigMap: armazena dados não sensíveis como variáveis de ambiente, arquivos de configuração e argumentos de linha de comando
  • Secret: armazena dados sensíveis (senhas, tokens, chaves SSH) codificados em base64 com criptografia opcional em repouso
# ConfigMap com variáveis de ambiente
apiVersion: v1
kind: ConfigMap
metadata:
  name: config-app
data:
  DB_HOST: postgres-cluster.internal
  DB_PORT: "5432"
  LOG_LEVEL: info
---
# Secret
apiVersion: v1
kind: Secret
metadata:
  name: secrets-app
type: Opaque
data:
  DB_PASSWORD: c3VwZXJzZWNyZXQ=
  API_KEY: YWJjMTIzNDU2Nzg5
---
# Pod usando ConfigMap + Secret
apiVersion: v1
kind: Pod
metadata:
  name: app-com-config
spec:
  containers:
  - name: app
    image: minha-app
    envFrom:
    - configMapRef:
        name: config-app
    env:
    - name: DB_PASSWORD
      valueFrom:
        secretKeyRef:
          name: secrets-app
          key: DB_PASSWORD

Ferramentas Essenciais do Ecossistema

  • Helm: gerenciador de pacotes do Kubernetes. Charts reutilizáveis para instalar aplicações complexas com um comando.
  • kubectl: CLI principal para interagir com o cluster. Essencial para diagnóstico e gerenciamento.
  • ArgoCD: GitOps para Kubernetes. Sincroniza o cluster com repositórios Git automaticamente.
  • Prometheus + Grafana: monitoramento e alertas. Métricas nativas do k8s + dashboards prontos.
  • cert-manager: emissão e renovação automática de certificados TLS com Let's Encrypt.
  • Kustomize: customização declarativa de manifestos YAML sem templates.
  • Lens / k9s: interfaces gráficas e TUI para navegação visual do cluster.

Boas Práticas em Produção

  • Resource Requests e Limits: sempre defina requests e limits para CPU e memória. Isso evita o efeito "barulhento" (noisy neighbor) em clusters compartilhados.
  • Pod Disruption Budgets (PDB): garanta que um número mínimo de pods fique disponível durante manutenções nos nós.
  • Network Policies: isole tráfego entre pods com políticas de rede. Por padrão, todo pod pode falar com todo pod — corrija isso.
  • RBAC: aplique o princípio do menor privilégio para contas de serviço e usuários.
  • Health Checks: configure liveness e readiness probes em todos os pods. Sem elas, o Kubernetes não sabe se sua aplicação está realmente saudável.
  • Labels e Annotations: use labels para identificar recursos (app, versão, ambiente) e annotations para metadados de ferramentas.
  • Backup do etcd: faça backups regulares do banco etcd. Sem ele, não há cluster para recuperar.
  • Namespaces: isole ambientes (dev, staging, prod) e equipes em namespaces diferentes com quotas de recursos.

Pitfalls Comuns (e Como Evitá-los)

  • Pods em CrashLoopBackOff sem logs úteis: sempre configure o stdout/stderr correto no container e use kubectl logs --previous para ver logs do container anterior.
  • ImagePullBackOff por rate limit no Docker Hub: configure um registry mirror ou use um registry privado (ECR, GCR, Harbor).
  • Pending forever sem nós disponíveis: verifique Cluster Autoscaler, taints/tolerations e recursos disponíveis com kubectl describe node.
  • DNS resolution falhando entre services: o CoreDNS pode estar sem recursos suficientes ou sem permissão de rede. Verifique o CoreDNS Deployment.
  • PersistentVolumeClaim nunca Bound: o StorageClass pode não ter provisioner dinâmico configurado, ou a região não tem discos disponíveis.

Kubernetes no Pipeline CI/CD

Um fluxo moderno de GitOps com Kubernetes segue este ciclo:

# 1. Desenvolvedor faz push no repositório Git
# 2. CI (GitHub Actions / GitLab CI) constrói e publica a imagem Docker
# 3. CD (ArgoCD / Flux) detecta a mudança no repositório Git de manifests
# 4. ArgoCD sincroniza o cluster com o novo estado
# 5. Kubernetes executa rolling update com zero-downtime
#
# Exemplo de GitHub Action para deploy em cluster k8s:
#
# deploy:
#   runs-on: ubuntu-latest
#   steps:
#     - uses: actions/checkout@v4
#     - name: Configurar kubectl
#       uses: azure/setup-kubectl@v4
#     - name: Deploy no cluster
#       run: |
#         kubectl set image deployment/api-pagamentos \
#           api=registry.craftxp.com/api-pagamentos:${{ github.sha }} \
#           --namespace producao

Conclusão

Kubernetes transformou a maneira como executamos software em produção. Em 2026, não se trata mais de decidir se usar orquestração, mas como usar bem. A curva de aprendizado é íngreme — os primeiros contatos com YAML, RBAC e networking podem ser intimidadores — mas o retorno sobre o investimento é imenso: aplicações mais resilientes, escaláveis e portáveis.

Comece pequeno: implante um cluster local com minikube ou kind (Kubernetes in Docker), explore os recursos básicos com kubectl explain, e gradualmente avance para Deployments, Services, Ingress, Helm charts e GitOps. O ecossistema CNCF oferece ferramentas para cada desafio que você encontrará no caminho. Kubernetes não é o destino — é a plataforma que viabiliza a próxima geração de aplicações cloud-native.

Craft XP
Craft XP