Kubernetes: o que é, objetos básicos e quando não usar

Kubernetes (ou K8s) é uma plataforma open source que gerencia containers em várias máquinas. Ele decide onde cada container roda, reinicia o que cai e escala conforme a demanda. O Google abriu o código do projeto em 2014, e o nome vem do grego para timoneiro ou piloto.

Rodar um container é fácil. Rodar mil deles, distribuídos por dezenas de máquinas, reiniciando os que caem e escalando conforme o tráfego, é um pesadelo para fazer na mão.

O Kubernetes é o piloto automático dos containers. Você declara o estado que quer ("50 réplicas rodando"), e ele trabalha sem parar para manter a realidade igual à sua declaração.

O Kubernetes funciona por um ciclo de controle contínuo:

O que é Kubernetes

Antes do Kubernetes, é preciso entender containers: unidades leves e portáteis que empacotam uma aplicação com todas as suas dependências e fazem com que ela rode igual em qualquer ambiente. O problema aparece na escala: gerenciar centenas ou milhares de containers na mão é inviável.

É aí que entra o Kubernetes, uma plataforma open source de orquestração de containers. Ele automatiza balanceamento de carga, escalonamento e recuperação de falhas, e libera o time de TI para cuidar da aplicação em si.

O modelo dele é declarativo: em vez de dar comandos passo a passo, você declara o estado desejado ("quero 50 réplicas deste app rodando"), e o K8s se encarrega de alcançar e manter esse estado, recriando o que cair e ajustando o que faltar.

Como o Kubernetes funciona: os componentes

O K8s gerencia um cluster, um conjunto de máquinas que trabalham juntas. As peças que você precisa conhecer:

O control plane distribui os pods entre os nodes de forma eficiente e monitora tudo constantemente: se um container falha, ele o reinicia; se um node inteiro cai, ele redistribui os pods para nodes saudáveis, sem intervenção manual.

Os objetos básicos: pod, deployment, service e ingress

Você descreve objetos num arquivo YAML e envia para a API com kubectl apply -f arquivo.yaml. Quatro objetos cobrem a maior parte de uma aplicação web:

• Pod: a menor unidade do cluster, com um ou mais containers que dividem rede e armazenamento.
• Deployment: guarda o estado desejado (imagem, réplicas) e troca os pods aos poucos a cada nova versão.
• Service: dá um nome e um endereço estável a um grupo de pods, que nascem e morrem com IPs diferentes.
• Ingress: publica rotas HTTP e HTTPS de fora do cluster para os Services, por host e caminho.

O YAML abaixo sobe três réplicas do Nginx. Um Service com selector: app: web daria a elas um endereço fixo.

apiVersion: apps/v1
kind: Deployment          # o controlador que mantém as réplicas
metadata:
  name: web
spec:
  replicas: 3             # estado desejado: três pods
  selector:
    matchLabels:
      app: web            # quais pods este Deployment gerencia
  template:               # o molde de cada pod
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: nginx
        image: nginx:stable

Se você apagar um desses pods na mão, o Deployment cria outro para voltar às três réplicas. O Ingress depende de um Ingress controller instalado no cluster, e criar só o objeto não tem efeito. A documentação do Ingress também avisa que a API dele está congelada e que o projeto recomenda a Gateway API no lugar.

O que o Kubernetes faz por você

As funções que fazem diferença em produção:

• Escalonamento automático. Sobe o número de containers quando o tráfego aumenta e reduz quando cai, o que economiza recursos.
• Recuperação de falhas (self-healing). Reinicia containers que quebram e realoca os pods de um node que caiu, o que dá alta disponibilidade sem plantão manual.
• Balanceamento de carga. Distribui o tráfego entre os containers de uma aplicação para que nenhum fique sobrecarregado.
• Gestão de configurações e segredos. Armazena senhas e chaves de forma segura e as injeta nos containers, sem embutir dados sensíveis no código.

Juntas, essas funções deixam DevOps e CI/CD bem mais fáceis de adotar e encurtam o tempo de entrega de novas versões.

Docker ou Kubernetes? (não é "ou")

Essa é a confusão mais comum. Eles não competem, trabalham juntos:

• O Docker cria e executa containers individuais. É o empacotador.
• O Kubernetes orquestra muitos containers num cluster. É o coordenador.

O fluxo comum é empacotar a aplicação com o Docker e usar o K8s para rodá-la em escala, com balanceamento, auto-scaling e self-healing. Para um app simples ou uma equipe pequena, o Docker (com Docker Compose) já resolve; o K8s entra quando a complexidade e a escala justificam.

Kubernetes ou Docker Compose: quando você não precisa de orquestrador

O Docker Compose define uma aplicação de vários containers num único arquivo YAML e sobe tudo com um comando (docker compose up). Ele roda num host com Docker, sem cluster, e a documentação diz que serve para produção.

O Compose basta quando a aplicação cabe num servidor ou VPS, a equipe é pequena e alguns minutos fora do ar numa troca de máquina são aceitáveis.

A visão geral do projeto lista o que ele não faz: não implanta código-fonte, não faz o build da aplicação e não impõe solução de logs ou monitoramento. Esses pedaços vêm de outras ferramentas.

Onde o Kubernetes brilha

Alguns casos de uso em que ele realmente compensa:

• Modernização de aplicações legadas, com monólitos divididos em microsserviços mais fáceis de escalar e manter.
• Ambientes multicloud, com cargas em AWS, Azure e Google Cloud geridas de forma unificada e menos vendor lock-in.
• Aplicações de alta disponibilidade, como e-commerce e serviços financeiros, que não podem ficar fora do ar.
• Workloads de machine learning, com recursos de treino que crescem e encolhem e modelos servidos sob demanda.

O ecossistema: ferramentas que completam o K8s

Algumas ferramentas ao redor cobrem o que o K8s não faz sozinho:

• Helm: o "gerenciador de pacotes" do K8s, que empacota aplicações em charts reutilizáveis.
• Prometheus: monitoramento e alertas, com coleta de métricas em tempo real.
• Istio: um service mesh que traz observabilidade, segurança e controle de tráfego entre microsserviços.
• ArgoCD: entrega contínua no modelo GitOps, onde o repositório é a fonte da verdade.

Como começar com Kubernetes

Não é preciso montar um cluster de produção para aprender:

1. Rode local com Minikube ou Kind. Sobem um cluster na sua máquina, ideal para estudar os conceitos sem infraestrutura complexa.
2. Use um serviço gerenciado. EKS (AWS), GKE (Google Cloud) e AKS (Azure) cuidam da configuração e da manutenção do cluster, deixando você focar nas aplicações.
3. Invista em aprendizado. A curva é real: comece pelo Docker antes do Kubernetes e use a documentação oficial como roteiro de estudo.

Perguntas frequentes sobre Kubernetes

O que é Kubernetes?

O Kubernetes é uma plataforma open source de orquestração de containers. Ele automatiza o deploy, o escalonamento e o gerenciamento de aplicações em containers, em nuvem ou no próprio data center.

Kubernetes é difícil de aprender?

Tem uma curva de aprendizado significativa: conceitos como pods, deployments, services, namespaces e ingress levam tempo para absorver. Comece pelo Docker e depois pratique num cluster local (Minikube ou Kind) antes de ir para produção.

Qual a diferença entre Docker e Kubernetes?

O Docker cria e executa containers individuais. O Kubernetes orquestra múltiplos containers em clusters e cuida de balanceamento de carga, auto-scaling, recuperação automática de falhas e rollouts sem downtime.

Preciso de Kubernetes para a minha aplicação?

Depende da escala e da complexidade. Para aplicações simples ou equipes pequenas, o Docker Compose ou um único servidor pode bastar. O K8s faz sentido quando você tem múltiplos serviços, alta disponibilidade e necessidade de escala horizontal.

Kubernetes funciona em qualquer nuvem?

Sim. AWS (EKS), Google Cloud (GKE), Azure (AKS) e outros provedores oferecem Kubernetes gerenciado. A portabilidade entre nuvens é uma das grandes vantagens: a maioria das configurações funciona em qualquer provedor.

Conclusão

O Kubernetes resolve um problema real: rodar containers em escala, com resiliência e sem trabalho manual. O modelo declarativo e as funções de escalonamento, self-healing e balanceamento servem da modernização de legados ao machine learning.

Para um app simples num servidor só, o Docker Compose basta. Quando os serviços e as máquinas se multiplicam, o K8s passa a poupar trabalho de operação. Comece pequeno, com Docker e depois Minikube, e evolua conforme a necessidade. A documentação oficial do Kubernetes tem versão em português e é o melhor ponto de partida.