Kubernetes Docker DevOps

Kubernetes: orquestração de contêineres passo a passo

Kubernetes resolve um problema real: gerenciar dezenas de contêineres em produção é caótico sem um orquestrador. Este guia explica sua arquitetura e seus componentes e leva você do início até um serviço exposto no Minikube.

Jean Michael Estevez Alvarez 26 abr 2026 · 9 min de leitura

Que problema o Kubernetes resolve?

Com um único servidor e alguns contêineres Docker, docker run é suficiente. O problema surge quando você tem dez serviços, precisa escalar o processador de pagamentos na Black Friday sem mexer no restante, quer que outro contêiner inicie automaticamente se um falhar e ainda precisa atualizar a aplicação sem indisponibilidade. É exatamente isso que o Kubernetes orquestra.

Kubernetes (K8s) é um sistema de orquestração de contêineres de código aberto criado pelo Google em 2014 e doado à CNCF. Ele abstrai a infraestrutura subjacente e expõe uma API declarativa: você descreve o estado desejado (“quero 3 réplicas deste serviço”), e o K8s trabalha continuamente para manter esse estado.

Componentes principais

O cluster se divide em dois planos:

• Control Plane — o cérebro do cluster. Composto pelo API Server (ponto de entrada de toda comunicação), etcd (banco de dados chave-valor que armazena o estado), o Scheduler (decide em qual nó cada Pod executa) e o Controller Manager (ciclo de reconciliação que aplica mudanças).
• Worker Nodes — máquinas nas quais as cargas executam. Cada nó tem kubelet (agente que se comunica com o API Server), kube-proxy (gerencia regras de rede) e um runtime de contêineres (Docker, containerd, CRI-O).

A menor unidade implantável é o Pod: um ou mais contêineres que compartilham rede e armazenamento, sempre no mesmo nó.

Instalação com Minikube (ambiente local)

Minikube inicia um cluster de nó único na sua máquina, ideal para aprender e desenvolver.

# Instalar Minikube (Linux/macOS con Homebrew)
brew install minikube

# Instalar kubectl
brew install kubectl

# Levantar el clúster (usa Docker como driver por defecto)
minikube start

# Verificar que el clúster está listo
kubectl cluster-info
kubectl get nodes

No Windows, você pode usar winget install Kubernetes.minikube e winget install Kubernetes.kubectl. Depois de iniciar, kubectl get nodes deve retornar o nó com o estado Ready.

Primeiro deployment

Um Deployment é o objeto do K8s que gerencia réplicas de Pods e controla as atualizações. Você pode criá-lo de duas formas: imperativa (rápida para testes) ou declarativa com um manifesto YAML (a forma correta para produção).

# Forma imperativa — útil para explorar
kubectl create deployment hello-web \
  --image=nginx:1.25 \
  --replicas=2

# Verificar
kubectl get deployments
kubectl get pods

O equivalente em YAML, que deve ser versionado no repositório:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-web
  labels:
    app: hello-web
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-web
  template:
    metadata:
      labels:
        app: hello-web
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: "100m"
              memory: "64Mi"
            limits:
              cpu: "250m"
              memory: "128Mi"

# Aplicar el manifiesto
kubectl apply -f deployment.yaml

# Ver eventos de despliegue
kubectl rollout status deployment/hello-web

Expor o serviço

Um Pod tem um IP interno efêmero. Para torná-lo acessível, usa-se um Service, que atua como um balanceador de carga estável para o grupo de Pods.

apiVersion: v1
kind: Service
metadata:
  name: hello-web-svc
spec:
  selector:
    app: hello-web        # apunta a los Pods con este label
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort          # en Minikube; en cloud usar LoadBalancer

kubectl apply -f service.yaml

# En Minikube, abrir en el navegador directamente:
minikube service hello-web-svc

Para clusters na nuvem (GKE, EKS, AKS), usa-se type: LoadBalancer e o provedor provisiona um IP público automaticamente. Para domínios personalizados e TLS, adiciona-se um Ingress com um Ingress Controller, como o nginx.

Escalar e atualizar sem indisponibilidade

# Escalar a 5 réplicas
kubectl scale deployment hello-web --replicas=5

# Actualizar imagen (rolling update automático)
kubectl set image deployment/hello-web nginx=nginx:1.26

# Ver progreso del rolling update
kubectl rollout status deployment/hello-web

# Revertir si algo salió mal
kubectl rollout undo deployment/hello-web

Por padrão, o K8s usa uma estratégia RollingUpdate: inicia Pods novos antes de encerrar os antigos, garantindo disponibilidade contínua. Você pode configurar maxUnavailable e maxSurge na especificação do Deployment para controlar a velocidade do processo.

Namespaces e organização

Os Namespaces são partições lógicas do cluster. Permitem isolar equipes, ambientes (dev/staging/prod) ou aplicações sem exigir clusters separados. Cada recurso existe dentro de um namespace.

# Crear namespace para el entorno de staging
kubectl create namespace staging

# Desplegar en ese namespace
kubectl apply -f deployment.yaml -n staging

# Ver todos los recursos de staging
kubectl get all -n staging

Próximos passos

1. ConfigMaps e Secrets — externalizar a configuração e as credenciais dos contêineres.
2. Persistent Volumes — armazenamento persistente para bancos de dados e arquivos de estado.
3. Horizontal Pod Autoscaler (HPA) — escalar automaticamente conforme CPU/memória ou métricas personalizadas.
4. Helm — gerenciador de pacotes para K8s; empacota, versiona e compartilha manifestos como charts.
5. Observabilidade — stack Prometheus + Grafana para métricas, Loki para logs e Jaeger para rastreamento distribuído.