Kubernetes de Verdade — do zero ao cluster em produção

Kubernetes tem fama de complicado. Em parte, é. Mas a maior parte da confusão vem de aprender peças soltas: um tutorial de kubectl, outro de kubeadm, outro de Helm, outro de Prometheus — sem nunca ver o conjunto funcionando.

Este curso é diferente: vamos montar um cluster de verdade, colocar uma aplicação nele, operar o dia a dia e enfrentar os problemas reais. Cada capítulo tem conceito, laboratório, validação, erros comuns e checklist.

Selo do curso: comandos verificados em Kubernetes 1.35 e Ubuntu 24.04. O laboratório é seu; nada aqui deve ser executado em produção sem adaptação.

Para quem é

• Quem já ouviu falar de containers e quer entender Kubernetes sem achismo.
• Devs que precisam entender por que o deploy “passou no build e morreu no cluster”.
• Infra/analistas que querem montar um laboratório próprio e operar com segurança.
• Donos de MSP/consultoria que precisam explicar o assunto para clientes.

Não é preciso saber Kubernetes antes. É preciso saber usar o terminal e ter paciência para ler logs.

O que você vai construir

Um laboratório com:

• 3 masters e 3 workers (HA de control plane).
• CNI, Ingress, TLS e DNS.
• Storage persistente.
• PostgreSQL com failover (CloudNativePG).
• MinIO, RabbitMQ, Redis e Elasticsearch.
• Observabilidade (Prometheus/Grafana).
• Backup e restore testados (Velero + etcd).
• Deploy de uma aplicação com HPA, probes e PDB.
• Runbooks para os incidentes que realmente acontecem.

Como o curso funciona

Cada capítulo é um post independente, mas faz parte de uma temporada:

• Temporada 1 — Fundamentos e construção: do “o que é um pod” ao cluster HA.
• Temporada 2 — Operação e dados: storage, configuração, operadores, backup, upgrade de nós.
• Temporada 3 — Produção e incidentes: Helm, GitOps, CI/CD, segurança, capacidade, SLO e DR.

Entre os capítulos, publicamos postmortems curtos de incidentes reais do laboratório. Eles são a parte que mais ensina.

Programa

Temporada 1 — Fundamentos e construção

1. Kubernetes sem medo: o condomínio dos containers
2. Montando o laboratório: 6 VMs e um cluster que cabe no bolso
3. O primeiro pod e o primeiro deploy: YAML, kubectl e o que realmente acontece
4. kubeadm por dentro: certificados, static pods e o join
5. HA: 3 masters, VIP e etcd
6. CNI: flannel, Cilium e por que NetworkPolicy importa
7. Namespaces, labels, quotas e PDB
8. Deployments, StatefulSets e DaemonSets
9. Services, Ingress, DNS e TLS
10. O primeiro “não subiu”: diagnosticando pods

Temporada 1 concluída em 10 capítulos + 2 postmortems.

Postmortem: O failover do Postgres que me ensinou o que é PDB

Postmortem: O deploy que passou no build e morreu no cluster

Temporada 2 — Operação e dados

11. Storage: PV, PVC, NFS e local-path
12. ConfigMap, Secret e o guard de credenciais
13. Observabilidade: metrics-server, Prometheus e Grafana
14. Operadores: o que são e por que usar
15. Postgres com CloudNativePG: HA, failover e backup
16. MinIO: erasure coding, buckets e credenciais
17. RabbitMQ e Redis: quórum, sentinel e PDB
18. Elasticsearch/ECK na prática
19. Backup e restore: Velero + etcd + drill
20. Upgrade de nós com segurança

Temporada 2 concluída em 10 capítulos.

Temporada 3 — Produção e incidentes

21. Helm: empacotando a aplicação
22. GitOps com ArgoCD
23. Deploy sem downtime: probes, rolling update e HPA
24. CI/CD: imagens imutáveis e SBOM
25. Segurança: RBAC, PSA, NetworkPolicy e secrets
26. Capacidade e carga: HPA, k6 e rate limit
27. SLO/SLI, on-call e postmortem blameless
28. DR: RPO/RTO, restore drills e capstone

Curso completo em 3 temporadas e 28 capítulos.

Pré-requisitos

• Um computador com 16 GB de RAM (ou um servidor/Proxmox) para o laboratório.
• Ubuntu Server 24.04 nas VMs.
• Vontade de quebrar e consertar.

O que este curso não é

• Não é uma certificação.
• Não é um tutorial de cloud provider.
• Não é “copie e cole em produção”.
• Não esconde os erros: os incidentes fazem parte do material.

Comece por aqui

Leia o capítulo 01, monte o laboratório no 02 e suba o primeiro deploy no 03. Se algo falhar, o capítulo 10 é o seu mapa de diagnóstico.

Nos vemos no cluster.

Próximo: Curso Kubernetes 01 — Kubernetes sem medo