O Que é Kubernetes e Para Que Serve

O que o Kubernetes faz

Rodar um container Docker em uma máquina, na mão, é fácil. Rodar cinquenta containers em dez máquinas — reiniciando cada um quando cai, movendo-os quando uma máquina morre, dividindo o tráfego entre eles, atualizando sem downtime — não é. O Kubernetes (abreviado como K8s) é o sistema que faz esse gerenciamento por você.

O Que é Kubernetes?

Kubernetes é uma plataforma de código aberto para orquestração de containers. Foi criada pelo Google em 2014, baseada em 15 anos de experiência gerenciando containers em larga escala, e agora é mantida pela Cloud Native Computing Foundation (CNCF).

Orquestração, concretamente: uma orquestra sinfônica precisa de um maestro para manter dezenas de músicos no tempo.

• Os músicos são seus containers, cada um sabe tocar seu instrumento
• O maestro é o Kubernetes, que coordena todos os músicos
• A partitura é a configuração que define como devem tocar juntos

Sem um maestro, cada músico tocaria por conta própria. Com Kubernetes, todos os containers trabalham em harmonia para fazer sua aplicação funcionar.

O Nome Kubernetes

O nome vem do grego κυβερνήτης (kybernetes), que significa “timoneiro” ou “piloto”. O logo com o leme de sete raios representa esse conceito. A abreviação K8s surge do fato de haver 8 letras entre o “K” e o “s”.

Por Que Você Precisa do Kubernetes?

Docker resolve o problema de criar e executar containers individuais. Mas em produção as coisas se complicam:

• O que acontece se um container falha às 3 da manhã?
• Como você distribui o tráfego entre 10 instâncias da mesma aplicação?
• Como você atualiza a aplicação sem tempo de inatividade?
• Como você gerencia 50 microsserviços que precisam se comunicar entre si?

Kubernetes responde a todas essas perguntas.

Docker vs Kubernetes: não são alternativas

Um mal-entendido comum é pensar que Kubernetes substitui o Docker. Na realidade, eles trabalham juntos:

Kubernetes pode usar Docker (ou outros runtimes como containerd) para executar os containers. Você não precisa escolher entre um ou outro: você usa ambos.

Para Que Serve Kubernetes: 6 Problemas que Resolve

1. Self-Healing: Containers que Se Reparam Sozinhos

Se um container falha, Kubernetes detecta e automaticamente inicia um novo. Ninguém precisa estar acordado às 3 da manhã para reiniciar serviços manualmente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Kubernetes garante sempre 3 réplicas ativas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3  # Se uma morre, K8s cria uma nova
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:latest

2. Escalabilidade Automática

Tem um pico de tráfego? Kubernetes pode aumentar automaticamente o número de containers. O tráfego diminui? Ele os reduz para economizar recursos.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Escala automaticamente entre 2 e 10 réplicas baseado na CPU
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

3. Balanceamento de Carga Integrado

Kubernetes distribui automaticamente o tráfego entre todos os containers disponíveis. Se um container está sobrecarregado ou não responde, o tráfego é redirecionado para os outros.

4. Rolling Updates: Atualizações Sem Tempo de Inatividade

Quando você faz deploy de uma nova versão, Kubernetes:

1. Inicia os novos containers com a versão atualizada
2. Verifica que estão funcionando corretamente
3. Gradualmente transfere o tráfego para os novos containers
4. Encerra os containers antigos

Se algo der errado, pode fazer rollback automático para a versão anterior.

5. Service Discovery

Em um sistema com muitos microsserviços, como o serviço A encontra o serviço B? Kubernetes fornece um sistema DNS interno: cada serviço tem um nome e Kubernetes se encarrega de traduzi-lo para o endereço correto.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# O serviço "database" será acessível como "database.default.svc.cluster.local"
apiVersion: v1
kind: Service
metadata:
  name: database
spec:
  selector:
    app: postgres
  ports:
  - port: 5432

6. Gerenciamento de Secrets e Configurações

Senhas, API keys, configurações: Kubernetes os gerencia de forma segura e os injeta nos containers sem hardcodá-los no código.

1
2
3
4
5
6
7
8
9

# Secret para as credenciais do banco de dados
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: YWRtaW4=      # codificado em base64
  password: cGFzc3dvcmQ=  # codificado em base64

Conceitos do Kubernetes: Pod, Node, Cluster, Deployment, Service

Pod

O Pod é a unidade básica do Kubernetes. Contém um ou mais containers que compartilham rede e armazenamento. Na maioria dos casos, um Pod contém um único container.

Node

Um Node é uma máquina (física ou virtual) que executa os Pods. Um cluster Kubernetes tipicamente tem vários Nodes para garantir alta disponibilidade.

Cluster

O Cluster é o conjunto de todos os Nodes gerenciados pelo Kubernetes. Inclui:

• Control Plane: o “cérebro” que toma decisões (onde colocar os Pods, quando escalá-los, etc.)
• Worker Nodes: as máquinas que realmente executam os containers

Deployment

Um Deployment descreve o estado desejado da sua aplicação: qual imagem usar, quantas réplicas, como atualizá-la. Kubernetes garante que o estado real corresponda sempre ao estado desejado.

Service

Um Service expõe os Pods à rede. Fornece um endereço IP estável e balanceamento de carga, mesmo quando os Pods subjacentes mudam.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────────┐
│                      CLUSTER                            │
│  ┌─────────────────────────────────────────────────┐   │
│  │              CONTROL PLANE                       │   │
│  │  • API Server  • Scheduler  • Controller        │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │   NODE 1    │  │   NODE 2    │  │   NODE 3    │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod A  │ │  │ │  Pod A  │ │  │ │  Pod B  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod B  │ │  │ │  Pod C  │ │  │ │  Pod C  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  └─────────────┘  └─────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────────┘

Kubernetes vs Docker Swarm

Docker tem seu próprio orquestrador integrado: Docker Swarm. Qual é a diferença?

Quando escolher Docker Swarm:

• Projetos pequenos/médios
• Equipes com pouca experiência em orquestração
• Necessidade de começar rapidamente

Quando escolher Kubernetes:

• Projetos empresariais ou em crescimento
• Necessidade de funcionalidades avançadas
• Equipe disposta a investir em aprendizado
• Requisitos de escalabilidade importantes

Quando NÃO Usar Kubernetes

Kubernetes nem sempre é a resposta certa. Evite-o se:

• Você tem poucos containers: gerenciar 2-3 containers com K8s é como usar um caminhão para fazer compras
• A equipe é pequena: a complexidade operacional pode superar os benefícios
• A aplicação é monolítica: K8s brilha com microsserviços
• Você não tem requisitos de escalabilidade: se o tráfego é constante e previsível, você pode não precisar dele
• Orçamento limitado: clusters Kubernetes têm custos operacionais significativos

Alternativas Mais Simples

Em um único host, o Docker Compose cobre a maior parte do que as pessoas primeiro procuram no Kubernetes.

Como Começar com Kubernetes

Se você quer explorar Kubernetes sem enlouquecer, aqui está um caminho gradual:

1. Aprenda os Fundamentos do Docker

Se você ainda não fez isso, comece com Docker. Kubernetes orquestra containers, então você precisa primeiro saber criá-los.

2. Experimente Localmente com Minikube

Minikube cria um cluster Kubernetes no seu computador. Perfeito para aprender sem custos de cloud.

1
2
3
4
5

# Instale Minikube e inicie um cluster local
minikube start

# Verifique se funciona
kubectl get nodes

3. Explore kubectl

kubectl é o comando para interagir com Kubernetes. Aprenda as operações básicas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Ver os Pods em execução
kubectl get pods

# Criar recursos a partir de um arquivo YAML
kubectl apply -f deployment.yaml

# Ver os logs de um Pod
kubectl logs nome-pod

# Entrar em um container
kubectl exec -it nome-pod -- /bin/bash

4. Experimente um Cluster Gerenciado

Quando estiver pronto para produção, use um serviço gerenciado:

• Google Kubernetes Engine (GKE)
• Amazon Elastic Kubernetes Service (EKS)
• Azure Kubernetes Service (AKS)

Esses serviços gerenciam o Control Plane para você, reduzindo a complexidade operacional.

Você realmente precisa de Kubernetes?

O Kubernetes compensa a própria complexidade quando você roda muitos serviços, em mais de uma máquina, com uptime que importa. Self-healing, autoscaling e rolling updates são difíceis de construir sozinho, e o Kubernetes entrega tudo isso pronto.

Abaixo dessa linha, ele custa mais do que devolve. Um punhado de containers em um servidor roda bem no Docker Compose. Um cluster pequeno, com necessidades modestas, roda bem no Docker Swarm. Recorra ao Kubernetes quando esses pararem de dar conta, não antes.

Para aprender sem pagar por um cluster de produção, comece com o Minikube na sua própria máquina e percorra os conceitos acima um de cada vez.

Artigos relacionados

• O que é Docker e para que serve
• O que é um volume Docker
• Docker vs Podman: qual escolher