Pular para o conteúdo
Procuro leitores beta. A edição em português está traduzida. Ela será lançada quando eu tiver o retorno de alguns leitores beta. Se você quiser ser um deles, me avise: abra uma issue no GitHub · me escreva no X.
Capa de Kubernetes 101: fundo azul quase preto, o título em branco, o número 101 em azul Kubernetes e o nome de Javier Vela Aylón no rodapé.

Livro · Edição em português · 2026

Kubernetes 101 — o guia prático para entender Kubernetes do zero

15 capítulos, 5 apêndices e uma parte prática com 55 laboratórios em um cluster real, sem instalar nada. Você lê o conceito e o testa na hora.

371 páginas · Edição 2026 · Kubernetes 1.37 · Kindle e impresso

Ler grátis o início do livro

Para quem

Para quem é este livro?

Para qualquer pessoa que queira aprender Kubernetes de verdade, venha ou não do mundo de TI. Também — e sobretudo — para quem já trabalha com a tecnologia todo dia e nunca chegou a entender direito o que acontece por baixo.

É o livro que eu gostaria de ter lido alguns anos atrás: com diagramas que explicam quem faz o quê, e com uma parte prática onde quebrar coisas sem medo.

O prólogo

Leitores

O que dizem os que já leram

Conteúdo

O que você vai aprender

Cada capítulo tem seu laboratório, e o Apêndice D também. Além disso, há um bloco que existe só como laboratório: o desafio final.

  • Capítulo no livro
  • Laboratório prático
Capítulo 01

Introdução aos contêineres e à orquestração

Imagem, contêiner, controller e nó explicados antes de nomear o Kubernetes. Como se constrói a imagem que se implanta ao longo de todo o livro: Dockerfile multistage, base distroless e um processo que não roda como root. E as vantagens e desvantagens reais dos contêineres, com o que se complica ao orquestrá-los em escala.

Seu laboratório é o módulo de Contêineres: você constrói a imagem tienda/api e a publica no registry.

  • Capítulo no livro
  • Laboratório prático
Capítulo 02

Arquitetura do Kubernetes

O kube-apiserver e o kubelet, e a comunicação hub-and-spoke: por que tudo passa pelo API server e só ele fala com o etcd. O resto dos componentes é contado onde faz falta de verdade — o kube-proxy em Rede, o scheduler em Scheduling — e juntos, no final, no Apêndice D.

Seu laboratório é o módulo “O cluster por dentro”, sobre um cluster kubeadm de verdade, junto com o Apêndice D.

  • Capítulo no livro
  • Laboratório prático
Capítulo 03

Falar com o cluster

Por que o kubectl não é o Kubernetes, mas um cliente HTTP contra o API server, e como ver isso com --v. O Namespace tienda vazio, o primeiro Pod web dentro dele, olhá-lo por dentro, ler seus logs e apagá-lo. É o capítulo em que ainda não importa não entender direito o que você está implantando.

Compartilha laboratório com o capítulo 04, no módulo de Fundamentos.

  • Capítulo no livro
  • Laboratório prático
Capítulo 04

Objetos do Kubernetes

O primeiro Pod, Namespaces, labels e selectors, e annotations: como se nomeia e se agrupa o que vive no cluster. E por que a lista de tipos que um cluster entende não está congelada, que é a porta para o capítulo de Extensibilidade.

Compartilha laboratório com o capítulo 03, no módulo de Fundamentos.

  • Capítulo no livro
  • Laboratório prático
Capítulo 05

Workloads

Pods com probes, requests, limits e QoS. ReplicaSets, Deployments com rollout e rollback, StatefulSets, DaemonSets, Jobs e CronJobs.

  • Capítulo no livro
  • Laboratório prático
Capítulo 06

Escalonamento

Escalonamento automático de nós (Cluster Autoscaler e Karpenter) e de Pods: Horizontal Pod Autoscaler e Vertical Pod Autoscaler, o que cada um mede e quando eles atrapalham um ao outro.

  • Capítulo no livro
  • Laboratório prático
Capítulo 07

Rede

O kube-proxy e as regras que fazem o IP de um Service acabar em um Pod. Services e DNS interno com CoreDNS, Ingress, Gateway API — o Ingress é derrubado e refeito — e NetworkPolicy para fechar o tráfego nas camadas 3 e 4.

  • Capítulo no livro
  • Laboratório prático
Capítulo 08

Configuração

ConfigMaps para o que não é confidencial e Secrets para o que é, consumidos como variáveis de ambiente ou como arquivos montados no Pod. imagePullSecrets para baixar imagens de um registry privado, e a Downward API para que o Pod saiba quem é e onde roda.

  • Capítulo no livro
  • Laboratório prático
Capítulo 09

Armazenamento

StorageClass, PersistentVolume e PersistentVolumeClaim com provisioners CSI, como um Pod acaba montando o disco que não pode perder, e VolumeSnapshot para os backups.

  • Capítulo no livro
  • Laboratório prático
Capítulo 10

Segurança

Autenticação e autorização diante da API, RBAC e ServiceAccounts, a cadeia de admissão, securityContext e os Pod Security Standards que o PSA aplica por Namespace. E o que o securityContext não protege: a supply chain, com SBOM e assinatura com cosign.

  • Capítulo no livro
  • Laboratório prático
Capítulo 11

Policies

ResourceQuota e LimitRange: o orçamento de CPU e memória de um Namespace e os valores padrão de cada contêiner.

  • Capítulo no livro
  • Laboratório prático
Capítulo 12

Scheduling

Taints e tolerations, nodeSelector, afinidades e nodeName; prioridade e preemption, PodDisruptionBudgets e Dynamic Resource Allocation.

  • Capítulo no livro
  • Laboratório prático
Capítulo 13

Trabalhando com o cluster

Contextos e Namespaces, o arquivo de preferências kuberc, quatro armadilhas que se repetem, o que o Kustomize traz e o que o Helm traz, GitOps com Argo CD e Flux, e o que olhar quando algo quebra na tienda, a loja de exemplo do livro. A referência de comandos inteira vive no Apêndice E.

  • Capítulo no livro
  • Laboratório prático
Capítulo 14

Extensibilidade

O CRD que ensina ao cluster uma palavra nova — a Promocion da tienda — e o operador que faz com que ela signifique algo: o loop de reconciliação, o que o status conta e quando não escrever um operador. No laboratório você o escreve inteiro, em Go e com controller-runtime.

  • Capítulo no livro
  • Laboratório prático
Capítulo 15

Observabilidade

Os Events do cluster, métricas, logs e traces — Prometheus, Loki, Grafana —, qual dos quatro olhar primeiro e a observabilidade emergente com eBPF.

  • Capítulo no livro
  • Laboratório prático

E um bloco que só existe como laboratório

Ele está dentro da parte prática e é de acesso gratuito, mas não tem capítulo correspondente no livro. Não precisa: não há nada novo para aprender, é a prova de tudo o que veio antes.

Só na parte prática

Desafio final: desligue o scheduler

Diagnostique o cluster de coração aberto, sem scheduler, e traga-o de volta à vida. O que deixa de funcionar e o que continua funcionando, e não é o que a maioria espera.

E cinco apêndices

Apêndice A

Glossário de siglas

As 74 siglas que aparecem no livro, reunidas em uma tabela para consultá-las de relance. Publicado completo no glossário do site (em espanhol).

Apêndice B

O sistema completo

Tudo o que foi construído capítulo a capítulo, junto e em ordem de aplicação: mais de seiscentas linhas de YAML que não se digitam a partir de uma folha de papel, porque vivem no repositório de código.

Apêndice C

Desde quando funciona cada peça

Capítulo a capítulo, quais funcionalidades o livro data e desde qual versão elas existem, para conferir de relance se o que você lê continua valendo no seu cluster. Tudo referido ao Kubernetes 1.37.

Apêndice D

O cluster por dentro

A casa de máquinas, no final e não no começo: o etcd, o controller-manager, o cloud-controller-manager, como os contêineres são executados de verdade — CRI, runtimes e OCI — e os Leases. É o único apêndice com laboratório próprio, sobre um cluster kubeadm de verdade.

  • Laboratório prático
Apêndice E

Colinha de kubectl

Toda a referência de comandos, ordenada pelo que você quer fazer e não por verbo: situar-se, olhar o cluster, olhar dentro de um Pod, mudar à mão, mudar com arquivos, nós e manutenção, permissões e auditoria, e Helm.

Incluído com o livro

A parte prática: 55 laboratórios em 15 módulos

15 módulos, 53 unidades e 7 challenges: tutoriais passo a passo com o YAML explicado, e challenges em que entregam a você um cluster com algo quebrado e você tem que consertá-lo.

Um cluster de Kubernetes real no navegador, pronto em segundos. Sem instalar nada, sem configurar nada e sem custo adicional. A parte prática é pública e gratuita: não há código, nem cupom, nem nada para validar. Não é preciso ter o livro para começar: os laboratórios se explicam sozinhos. O que o livro acrescenta é o porquê — de onde sai cada decisão e o que falha em silêncio quando você não a toma — mais os 54 diagramas e os cinco apêndices, que não cabem em um terminal.

Ver a parte prática

Uma olhada por dentro

Diagramas do livro

Cada conceito é explicado com um diagrama que mostra quem faz o quê e por quê. Seis dos cinquenta e quatro que você vai encontrar lá dentro; clique em qualquer um para vê-lo em tamanho completo.

  • Diagrama da arquitetura de um cluster: à esquerda o control plane com kube-apiserver, etcd, kube-scheduler e kube-controller-manager; à direita os nós worker com kubelet, kube-proxy e o runtime de contêineres. Todas as setas dos nós apontam para o kube-apiserver, e só o kube-apiserver fala com o etcd.

    Fundamentos · diagrama 1 de 6

    Arquitetura do cluster

    Control plane e nós worker: quem fala com quem, e por que o kube-apiserver é o único portão de entrada para o etcd.

  • Diagrama hierárquico: um Deployment em cima, embaixo dois ReplicaSets (a revisão antiga encolhendo até zero e a nova crescendo) e, sob cada um, seus Pods. As setas mostram o rolling update e a volta à revisão anterior.

    Workloads · diagrama 2 de 6

    Deployments, rollout e rollback

    Um Deployment gerencia um ReplicaSet por revisão: é assim que ele faz rolling updates e volta atrás sem downtime.

  • Diagrama comparativo dos tipos de Service: ClusterIP, NodePort e LoadBalancer. Mostra o caminho do tráfego desde o exterior até os Pods, passando pelo kube-proxy e pelos EndpointSlices que indicam quais Pods estão prontos.

    Rede · diagrama 3 de 6

    Services e roteamento

    ClusterIP, NodePort e LoadBalancer: como o tráfego chega aos Pods via kube-proxy e os EndpointSlices.

  • Diagrama com vários nós marcados com taints e Pods com e sem tolerations. Indica o resultado de cada combinação segundo o efeito do taint: NoSchedule, PreferNoSchedule e NoExecute.

    Scheduling · diagrama 4 de 6

    Taints e tolerations

    Como dirigir Pods para — ou para longe de — certos nós, com os três efeitos possíveis de um taint.

  • Diagrama da arquitetura de observabilidade: os Pods expõem métricas que o Prometheus recolhe em modo pull, os logs viajam em modo push para o Loki e os traces se agrupam em spans. Os três fluxos convergem no Grafana como camada de visualização.

    Observabilidade · diagrama 5 de 6

    Métricas, logs e traces

    Os três pilares são recolhidos separadamente e convergem no Grafana, com Prometheus, Loki e traces.

  • Diagrama do loop de reconciliação de um operador: o watch avisa de uma mudança no recurso, o operador volta a ler o estado desejado e o real, age para aproximá-los e escreve o resultado no status. O aviso e a leitura do estado são duas setas distintas.

    Extensibilidade · diagrama 6 de 6

    O loop de reconciliação

    Por que um operador não age sobre o aviso, mas volta a ler: tanto faz se chegam dois avisos juntos ou se um se perde.

1 / 6

Como se lê uma página

239 perguntas, ao pé do YAML

Quase todos os livros técnicos colocam o manifesto, explicam três campos e seguem em frente. Os outros nove ficam ali. Aqui, embaixo de cada manifesto vai o que a gente se pergunta ao lê-lo pela primeira vez, respondido: não um teste no final do capítulo, mas a resposta onde aparece a dúvida. Quatro páginas da edição impressa em espanhol, tal como saem da gráfica.

  • Página 48 da edição impressa em espanhol. Em cima, o final do manifesto YAML do Pod web. No meio, a explicação campo por campo: apiVersion, kind, metadata.name, metadata.namespace, metadata.labels, spec e spec.containers. Embaixo, três perguntas em negrito com sua resposta: por que apiVersion é v1 e não apps/v1, o que acontece se o namespace não é indicado, e se podem existir dois objetos com o mesmo name.

    Capítulo 4 · Objetos do Kubernetes · página 48

    O primeiro manifesto, linha a linha

    Doze linhas de YAML explicadas campo por campo, e depois três perguntas: por que apiVersion é v1 e não algo como apps/v1? · o que acontece se eu não indicar o namespace? · posso ter dois objetos com o mesmo name?

  • Página 49 da edição impressa em espanhol. Em cima, duas perguntas com resposta sobre o status e os labels. Depois, a seção Namespaces, com os quatro Namespaces que o Kubernetes traz de fábrica, o manifesto YAML do Namespace tienda, e a pergunta de quais recursos não são namespaced.

    Capítulo 4 · Objetos do Kubernetes · página 49

    Namespaces, e o que eles não isolam

    A que mais gente erra está nesta página: os Namespaces isolam o tráfego de rede? Não. Eles separam nomes e permissões, não pacotes; para isolar tráfego é preciso uma NetworkPolicy, que chega três capítulos depois.

  • Página 132 da edição impressa em espanhol. Em cima, o final de um manifesto que reserva 2 CPU e 4 GiB. Depois, três perguntas com resposta sobre onde está o erro se o manifesto não dá nenhuma falha, por que importa se sobra espaço no cluster, e por que não consertar os números à mão. Embaixo, o manifesto YAML do VerticalPodAutoscaler do Deployment holgazan.

    Capítulo 6 · Escalonamento · página 132

    O manifesto que não dá nenhuma falha

    Pede 2 CPU e 4 GiB, e usa um décimo disso. Não há evento vermelho nem Pod em Pending: só um terço da cota do Namespace gasto em ar. É a falha mais cara do Kubernetes justamente porque não se parece com uma falha.

  • Página 261 da edição impressa em espanhol. Manifesto YAML de um PodDisruptionBudget para o Deployment web, seguido de duas perguntas com resposta: por que o PDB não é declarado dentro do Deployment, e o que acontece se minAvailable é colocado igual ao número de réplicas.

    Capítulo 12 · Scheduling · página 261

    A proteção que bloqueia a manutenção

    O que acontece se eu colocar minAvailable: 3 com só 3 réplicas? Você bloqueia qualquer despejo voluntário, inclusive a drenagem de nós, e acaba com atualizações de cluster travadas.

1 / 4

O capítulo de Workloads tem 45 perguntas e o de Segurança, 42. As 239 estão distribuídas pelos quinze capítulos, sempre coladas ao manifesto que as provoca.

A parte prática

Como funcionam os laboratórios

  1. Passo 1

    Leia o capítulo

    O conceito explicado com seu diagrama e seus exemplos, sem dar nada por sabido.

  2. Passo 2

    Abra o laboratório

    Um cluster real no navegador, pronto em segundos. Nada para instalar na sua máquina.

  3. Passo 3

    Conserte o cluster quebrado

    Você diagnostica, repara, e o laboratório verifica a sua solução. Você aprende fazendo, não memorizando.

Um respiro

O que dizem os componentes do cluster

Aqui não há resenhas: quem assina são os componentes do Kubernetes, que há anos aguentam o que não é pouco. É uma brincadeira, mas cada queixa é verdadeira.

  • “Há anos sou o único portão para o etcd e ninguém me entendia. Depois deste livro, até os Pods novos sabem me pedir as coisas pelo nome.”
    kube-apiserver, guardião do cluster
  • “Eu guardo tudo, mas explicar o consenso Raft era impossível. O capítulo de fundamentos finalmente conta a minha história sem perder um único dado.”
    etcd, memória do cluster
  • “Antes eu colocava Pods às cegas e me culpavam por tudo. Agora os leitores entendem minhas afinidades, taints e tolerations… e até o desafio de me desligar.”
    kube-scheduler, quem decide onde você mora
  • “Reinicio contêineres a noite inteira sem que ninguém me agradeça. Este livro explica minhas probes tão bem que agora me tratam melhor.”
    kubelet, vigia de cada nó
  • “Traduzir nomes de Services em IPs era a minha cruz silenciosa. Com o capítulo de rede, finalmente resolvem as minhas dúvidas antes que eu resolva as deles.”
    CoreDNS, a agenda do cluster
1 / 5

Grátis, agora

Baixe o início do livro

Assine o blog e receba o início do livro completo: “Antes de começar”, o capítulo de Arquitetura do Kubernetes e o Apêndice D: o cluster por dentro.

Trinta e uma páginas e os oito diagramas, tal como aparecem no livro (por enquanto, as páginas da edição em espanhol; o PDF em português vai substituí-las). Não é uma prévia recortada: é por onde se começa a lê-lo e onde se termina de entender a casa de máquinas.

É a forma mais honesta de saber se o livro serve para você antes de pagar qualquer coisa.

Se o formulário não carregar, assine em blog.javivela.dev.

Antes de começar

Perguntas frequentes

Não. O livro começa pelos fundamentos de contêineres e orquestração antes de tocar no Kubernetes, e não dá nada por sabido.

Nada. Cada laboratório sobe um cluster de Kubernetes real no navegador; você só precisa de conexão e de uma conta no iximiuz Labs.

Sim. Ele foi pensado também para quem usa a tecnologia todo dia e quer entender de verdade o que acontece por baixo, com os diagramas e os challenges como rede de segurança.

Os dois. A parte prática é a mesma em qualquer um dos dois formatos, e além disso é de acesso público: você pode abrir o guia da parte prática sem ter o livro. Há uma diferença por país: o Kindle está na Amazon.com.br, na Amazon.com e na Amazon.es, e o livro impresso só na Amazon.com e na Amazon.es, porque a Amazon não imprime sob demanda no Brasil. Do Brasil, o impresso se pede na Amazon.com com envio internacional; de Portugal, na Amazon.es.

Não. A parte prática é de acesso público e gratuito, e não exige nenhuma compra adicional. Ela está hospedada no iximiuz Labs.

Os 15 capítulos e os 5 apêndices, sim. Só há um bloco que existe unicamente como laboratório e não tem capítulo: o desafio final, e ele está marcado no conteúdo. A extensibilidade tem capítulo, sim, o 14: o livro define o CRD e explica o que faz um operador; o laboratório é onde você o escreve inteiro, em Go.

O livro é a edição 1.37. O Kubernetes publica três versões por ano, então nenhum livro vai estar nunca na última: por isso ele inclui o Apêndice C, que registra capítulo a capítulo o estado de cada funcionalidade e desde qual versão ela existe, para que você possa conferir de relance se o que está lendo continua valendo no seu cluster. O que a 1.37 traz está resumido em novidades do Kubernetes 1.37 (em espanhol), e as correções posteriores são publicadas na página de errata.

Sobre o autor

Javier Vela Aylón

Desenvolvedor .NET que virou Senior Software & Platform Engineer, com mais de 20 anos construindo e mantendo plataformas. Certificado em Azure e no ecossistema CNCF, e palestrante na DotNetters.

Escrevo sobre DevOps, Azure, AWS, CI/CD, Kubernetes, contêineres e arquitetura em blog.javivela.dev.

LinkedIn GitHub @jvela

Código

Todos os manifestos do livro, no GitHub

O repositório reúne os YAML, os exemplos e o operador em Go tal como aparecem nos capítulos e nos laboratórios. Clone-o, quebre-o e mande um pull request se encontrar algo para melhorar.

Ver o repositório no GitHub Parte prática Errata do livro Bibliografia (em espanhol)

Kubernetes 101

De um Pod avulso a um sistema que você entende

371 páginas, 15 capítulos, 5 apêndices e 55 laboratórios em um cluster real. Baseado no Kubernetes 1.37, a versão de referência do livro.

Ler grátis o início do livro