Trilhas
Cada trilha é uma sequência: começa no que você precisa saber antes e termina em algo que roda em produção. Você não precisa fazer todas — comece pela que resolve o seu problema de hoje.
Linux, redes, Git e shell — a base que sustenta todo o resto. Quase todo problema difícil de Kubernetes é um problema de Linux ou de rede mal compreendido.
- Linux para quem opera — Processos, systemd, permissões, sistema de arquivos e as ferramentas de diagnóstico que você vai usar todo dia.
- Redes na prática — TCP/IP, DNS, TLS e HTTP do ponto de vista de quem depura conexão que não fecha.
- Git além do commit — Modelo de objetos, rebase, bisect e resolução de conflito sem medo.
- Shell script que não quebra — Bash defensivo: set -euo pipefail, quoting, trap e o que fazer quando o script vira ferramenta.
Bash avançado, Python para infraestrutura, Go para ferramentas e orquestração de tarefas locais.
- Python para infraestrutura — Scripts confiáveis, SDKs de nuvem, empacotamento e testes.
- Go para ferramentas de plataforma — Por que a maioria das ferramentas cloud-native é escrita em Go, e como escrever a sua.
- Make, Task e a interface do repositório — Padronizar os comandos de um projeto para que humano e CI executem o mesmo caminho.
Estratégias de branch, commits com significado, revisão de código e monorepo.
- Trunk-based vs GitFlow — Qual estratégia de branch sustenta entregas frequentes, e por que GitFlow costuma ser a escolha errada hoje.
- Commits que geram changelog — Conventional Commits, versionamento semântico e release automatizado.
- Revisão de código que agrega — Como revisar sem virar gargalo nem carimbo.
- Monorepo e polirrepo — Trade-offs reais de cada topologia e o que muda no CI.
Do commit ao deploy: pipelines, estratégias de entrega e GitOps.
- Anatomia de um pipeline — Os estágios que todo pipeline sério tem e o que cada um deve garantir.
- GitHub Actions em profundidade — Workflows, matrizes, cache, reusable workflows, runners e segredos.
- GitLab CI — Stages, needs, templates e o modelo de ambientes do GitLab.
- Estratégias de deploy — Rolling, blue/green, canário e feature flags — o que cada uma custa e protege.
- GitOps com Argo CD e Flux — O repositório como fonte da verdade do que roda em produção.
Docker, imagens OCI, registries e segurança de imagem.
- O que é um container, de verdade — Namespaces, cgroups e a diferença real para uma máquina virtual.
- Dockerfile em produção — Multi-stage, cache de camadas, usuário não-root e imagens pequenas.
- Registries e distribuição — Tags, digests, retenção, mirror e custo de egress.
- Segurança de imagem — Scan de vulnerabilidade, SBOM, assinatura e o que fazer com o resultado.
Do primeiro Pod ao cluster de produção: workloads, rede, storage, segurança e diagnóstico.
- Arquitetura do Kubernetes — Control plane, kubelet, etcd e o modelo de reconciliação.
- Workloads — Pod, Deployment, StatefulSet, DaemonSet, Job e CronJob.
- Rede no Kubernetes — Service, Ingress, Gateway API, DNS interno e políticas de rede.
- Armazenamento — PV, PVC, StorageClass, snapshots e estado em cluster.
- Segurança do cluster — RBAC, ServiceAccount, Pod Security, secrets e superfície de ataque.
- Helm e Kustomize — Empacotar e customizar manifests sem virar sopa de template.
- Escala automática — HPA, VPA, KEDA e autoscaler de nós.
- Operators e CRDs — Estender a API do Kubernetes com a sua própria lógica operacional.
- Diagnóstico em Kubernetes — O roteiro para quando o Pod não sobe, o Service não responde e o nó fica NotReady.
- Service mesh — Istio, Linkerd e Cilium — o que ganham, o que custam.
Terraform e OpenTofu, Ansible, Pulumi, Crossplane e testes de infraestrutura.
- Princípios de IaC — Declarativo e imperativo, idempotência, drift e imutabilidade.
- Terraform e OpenTofu — HCL, providers, ciclo plan/apply e o que muda entre os dois.
- State: onde tudo dá errado — Backend remoto, locking, workspaces e recuperação de state corrompido.
- Módulos que outros times usam — Composição, versionamento, interface e documentação de módulo.
- Ansible — Configuração de sistemas existentes, inventário, roles e idempotência real.
- Pulumi e CDK — IaC em linguagem de programação: quando ajuda e quando vira armadilha.
- Crossplane — Provisionar nuvem a partir da API do Kubernetes.
- Testando infraestrutura — Validação estática, política, testes de integração e custo.
AWS, Azure, GCP e OCI pelos domínios que importam: identidade, rede, computação e dados.
- Modelos de serviço e responsabilidade — IaaS, PaaS, serverless e o modelo de responsabilidade compartilhada.
- Identidade e acesso — IAM, princípio do menor privilégio e federação sem chave estática.
- Rede na nuvem — VPC, sub-redes, peering, NAT e conexão híbrida.
- AWS: o mapa essencial — Os serviços que você realmente vai usar e como eles se conectam.
- Azure: o mapa essencial — Grupos de recursos, AKS, Entra ID e o modelo de assinatura.
- GCP: o mapa essencial — Projetos, GKE, IAM e o modelo de rede global.
- Landing zone e organização de contas — Estrutura de contas, guardrails e baseline de segurança.
Métricas, logs e traces com Prometheus, Grafana, Loki, Tempo e OpenTelemetry.
- Os três pilares, e o que falta neles — Métrica, log e trace: o que cada um responde e onde param.
- Prometheus e PromQL — Modelo de dados, coleta, PromQL e regras de gravação.
- Grafana: painéis que alguém usa — Design de dashboard, variáveis e os métodos RED e USE.
- Logs estruturados e Loki — Log que se pesquisa, custa pouco e diz o que aconteceu.
- Tracing distribuído — Spans, contexto propagado e amostragem.
- OpenTelemetry — O padrão que desacopla instrumentação de backend.
- Alertas que não viram ruído — Alertar sobre sintoma, não causa. Fadiga de alerta e como sair dela.
Confiabilidade como disciplina de engenharia: SLO, incidente, postmortem e capacidade.
- O que SRE é, e o que não é — A disciplina, não o cargo. Toil, error budget e a relação com DevOps.
- SLI, SLO e error budget — Como escolher indicador, definir alvo e usar o orçamento de erro para decidir.
- Resposta a incidentes — Papéis, comunicação, severidade e o que fazer nos primeiros dez minutos.
- Postmortem sem culpado — Como escrever um que gere mudança real.
- Plantão sustentável — Escala, escopo, compensação e o que fazer para o plantão não destruir o time.
- Planejamento de capacidade — Previsão de carga, folga e testes que dizem algo.
- Engenharia do caos — Injetar falha de propósito para descobrir o que já estava quebrado.
Segurança dentro do pipeline: análise, cadeia de suprimentos, segredos e política como código.
- Segurança no pipeline — SAST, DAST, SCA e como não transformar o pipeline num muro.
- Cadeia de suprimentos de software — SBOM, SLSA, procedência e assinatura.
- Gestão de segredos — Vault, External Secrets, rotação e o que fazer quando vaza.
- Política como código — OPA, Kyverno e regras que valem no plan e na admissão.
- Hardening — Reduzir superfície em host, container e cluster.
- Compliance e LGPD para infraestrutura — Trilha de auditoria, retenção, dado pessoal e o que a lei exige da sua stack.
Plataforma interna como produto: golden paths, self-service e experiência do desenvolvedor.
- Quando construir uma plataforma — O sinal de que faz sentido, e o custo de fazer cedo demais.
- Golden paths — O caminho pavimentado que é mais fácil de seguir do que de contornar.
- Backstage e catálogos de serviço — Catálogo, templates e o custo de manter um portal interno.
- Experiência do desenvolvedor — Medir e reduzir o atrito interno.
Migrations no pipeline, backup testado, alta disponibilidade e recuperação de desastre.
- Migrations em entrega contínua — Mudar esquema sem downtime e sem quebrar o rollback.
- Backup que funciona — A regra 3-2-1, teste de restauração e RPO/RTO reais.
- Alta disponibilidade em banco de dados — Replicação, failover e o que você perde em cada modelo.
- Recuperação de desastre — Estratégias por custo, e o plano que alguém consegue executar sob pressão.
DNS, TLS, CDN, balanceamento e zero trust do ponto de vista de operação.
- DNS em operação — TTL, propagação, health check e migração sem downtime.
- TLS e certificados — Emissão automática, renovação, mTLS e os erros que derrubam produção.
- Balanceamento de carga — Camada 4 e camada 7, algoritmos, health checks e drenagem de conexão.
- CDN e cache — Chaves de cache, invalidação e o que não deve ser cacheado.
- Zero trust na prática — Identidade em vez de perímetro, acesso a recurso interno sem VPN.
DORA, SPACE, Team Topologies e como medir sem virar vigilância.
- O que DevOps é, afinal — A origem, o que o termo perdeu pelo caminho e o que sobrou de útil.
- Métricas DORA — As quatro medidas que separam alta de baixa performance, e como não distorcê-las.
- SPACE e produtividade — Por que uma métrica só sempre mente.
- Team Topologies — Quatro tipos de time, três modos de interação e a lei de Conway.
- Mapeamento de fluxo de valor — Encontrar o gargalo real entre a ideia e a produção.
Visibilidade, otimização e responsabilidade sobre o custo de nuvem.
- Visibilidade de custo — Tagging, alocação e mostrar a conta para quem gera o gasto.
- Otimização de custo — Rightsizing, spot, compromissos e desligar o que ninguém usa.
- Unit economics — Custo por transação, por cliente, por time — a métrica que muda a conversa.
AIOps, LLM no pipeline, agentes de operação e os riscos que vêm junto.
- AIOps: o que funciona hoje — Detecção de anomalia, correlação de alerta e triagem — separando entrega de promessa.
- LLM no pipeline — Revisão assistida, geração de teste, análise de log e os limites necessários.
- Agentes de operação — Automação com autonomia: onde parar.
- Riscos de IA na infraestrutura — Injeção de prompt, vazamento de dado e dependência de fornecedor.
Roadmap por senioridade, certificações, entrevistas e o mercado brasileiro.
- Roadmap por senioridade — O que se espera de júnior, pleno, sênior e além — em competência, não em anos.
- Certificações que valem — CKA, CKAD, CKS, Terraform Associate e as de nuvem — o que cada uma prova.
- Entrevistas de DevOps e SRE — O que é perguntado, como estudar e como demonstrar experiência real.
- Mercado brasileiro — Faixas, modalidades, PJ e CLT, e trabalho para o exterior.