Arquitetura de Sistemas · Insper

Hands-on 10 — Kubernetes

Declare o estado desejado; deixe os laços de controle manterem o BoxOffice lá

A história até aqui

capítulo 10 · lab 9os padrões contêm um provedor lento
→
capítulo 11 · lab 10kind, probes, autoscaling, Ingress
→
depois · lab 11entrega: pipeline, GitOps, canary

O lab 9 trouxe o GET /orders/{id} de 9 s na mediana de volta a milissegundos — mas toda mitigação foi uma pessoa num terminal. Quem reinicia uma réplica morta, adiciona pods do catalog às 09:45 ou desfaz uma release ruim?

Ninguém edita YAML às 10:00

O lab 3 escalou o catalog editando o Compose. O lab 9 reiniciou à mão um serviço que caiu. Quem faz isso durante a venda relâmpago?

  • Kubernetes: você declara o estado desejado ("≥ 2 réplicas prontas, mais acima de 60% de unidade central de processamento (CPU, central processing unit)").
  • Os controllers comparam desejado vs real a cada poucos segundos e agem.
  • Autocura, rollouts e autoscaling são a mesma ideia: reconciliação.

Passo 1 · Um cluster no laptop

vocêlocalhost:80
→ :30080
control-plane
TraefikIngress controller · Helm · NodePort 30080
metrics-serverCPU para o autoscaler
worker
catalog
db-0 · redis
worker2
catalog
  • kind: cada nó é um contêiner Docker. O Horizontal Pod Autoscaler (HPA) precisa do metrics-server (--kubelet-insecure-tls só no kind).
  • Imagens: docker tag … boxoffice/catalog:dev + kind load docker-image — nunca latest.

O ingress-nginx foi aposentado em março de 2026. Escolha componentes mantidos para o que fica exposto à internet.

Passo 2 · Kustomize: base + overlays

k8s/base/namespace, config, db, redis, catalog, hpa, ingress
+
k8s/overlays/local/tag "dev" da imagem + secrets do lab
→ kubectl apply -k →
namespace boxoffice11 objetos, um estado desejado
  • secretGenerator → db-credentials-<hash>: conteúdo novo, nome novo, rollout.
  • O lab 11 adiciona um overlay de GitOps sem tocar na base.

Stateful vs stateless

db catalog
Tipo StatefulSet Deployment
Identidade estável: db-0 intercambiável
Armazenamento PersistentVolumeClaim (PVC) por réplica nenhum
Service headless (clusterIP: None) ClusterIP, com balanceamento

Bancos em produção: serviço gerenciado ou um operator (backups, failover, upgrades).

Três probes, três perguntas

Probe Pergunta Em caso de falha
startup terminou de iniciar? as outras probes esperam; restart depois do orçamento
liveness travou sem conserto? restart
readiness deve receber tráfego agora? removido do Service

Nunca verifique uma dependência compartilhada na liveness: uma oscilação do banco de dados → todos os pods reiniciam de uma vez.

Recursos e graceful shutdown

  • requests (250m, 512Mi): o que o scheduler reserva; a % do HPA é relativa a eles.
  • limits (1 CPU, 768Mi): CPU estrangulada, memória → OOMKilled; heap = 75% do limit.
  • Rollout maxSurge: 1, maxUnavailable: 0: nunca abaixo do número desejado de prontos.
pod Terminating
→
endpoints removidoso Traefik atualiza um instante depois
∥
preStop: sleep 5a máquina virtual Java (JVM, Java virtual machine) ainda atende
→
SIGTERMserver.shutdown=graceful
→
saibem dentro de 30 s

Convergência eventual

O catalog reiniciou duas vezes logo depois do kubectl apply. Bug?

  • Sem depends_on: o catalog subiu antes do PostgreSQL → o Flyway falhou → saiu → restart com back-off.
  • Os componentes tentam de novo até as dependências existirem; o sistema converge.
  • A primeira inicialização também roda as migrations → o orçamento de startup precisa cobri-las (subimos para 5 min).

Veja os controllers trabalhando

Autocura
apagar os dois pods
→
ReplicaSet: 0 de 2dois pods novos na hora
→
2/2 prontospartida da JVM: dezenas de segundos
Perder um nó
docker stop worker2
→
NotReadycerca de um minuto
→
despejadodepois da toleration de 5 min
→
substituído no worker
Rolling update
+1 pod novomaxSurge: 1
→ pronto →
−1 pod antigomaxUnavailable: 0
→
repete
  • Cronometre cada um: o tempo da autocura é o tempo médio de reparo (MTTR, mean time to repair) da queda de um pod.
  • A detecção domina o nó perdido; a partida da JVM domina o pod apagado.

Sem cluster: o simulador

  • As páginas trazem o cluster do lab como simulador: os mesmos nós, manifestos e comandos.
  • Deploy: apply -k (o catalog reinicia duas vezes), autocura, um nó perdido.
  • Meça: o experimento B, com e sem readiness + preStop.
  • Modo livre: mude quanto tempo o Traefik leva para ver uma mudança de endpoint.

Rode antes do lab para saber o que procurar; os números que você reporta continuam vindo do seu cluster.

Passo 3 · O HPA

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
spec:
  minReplicas: 2
  maxReplicas: 8
  metrics: [{ type: Resource, resource: { name: cpu,
             target: { type: Utilization, averageUtilization: 60 } } }]
  behavior:
    scaleUp:   { stabilizationWindowSeconds: 0 }    # + at most 100% or 2 pods / 15 s
    scaleDown: { stabilizationWindowSeconds: 120 }  # - 1 pod / 30 s

desejadas = ⌈atuais × utilização / alvo⌉ → 2 pods a 150% → ⌈2 × 150 / 60⌉ = 5.

Uma volta do laço: o escalonamento reativo atrasa

metrics-serverCPU por pod
→
HPA, a cada 15 sdesejado = ⌈atual × CPU / 60%⌉
→
Deploymentde 2 a 8 réplicas
→
pod novopartida da JVM + probes: dezenas de s
→
prontoa CPU média cai
  • O HPA decide em segundos; a capacidade só chega quando uma JVM está pronta.
  • Durante o atraso, os pods existentes absorvem o degrau: o p95 sobe, depois cai.
  • Evento conhecido (abertura de vendas às 10:00) → pré-escalar; HPA para o inesperado.
  • Mais pods → mais conexões ao banco: o gargalo vai para a camada stateful.

Carregue: pods aquecidos primeiro

Uma JVM que acabou de iniciar queima CPU compilando código e o HPA escala com essa CPU também.

  • Logo depois de um rollout, PEAK=250 levou o catalog a 8 réplicas; a liveness estourou o timeout, pods reiniciaram e o k6 viu 26% de erros.
  • A mesma execução com pods aquecidos nunca saiu de 2 réplicas.
  • Aqueça com o script do lab 8, espere 2 réplicas e então k6 run -e PEAK=1000 load/catalog-hpa.js.
  • O PEAK deve levar dois pods aquecidos acima de 60% do request (≈ 600 req/s no laptop de teste).

Passo 4 · Ingress (e Gateway API)

curl localhost:80
→
nó :30080kind.yaml
→
Traefikregra /catalog
→
Service catalog:8082
→
um pod pronto
  • Ingress: regras por host/caminho, ingressClassName: traefik.
  • Gateway API: Gateway (time de plataforma) + HTTPRoute (time do serviço); pesos, headers, timeouts.

Service LoadBalancer = um endereço por serviço; Ingress = uma porta, muitos serviços; API gateway = autenticação, cotas, transformações.

Passo 5 · Meça

# Experimento Registrar
A 2 réplicas fixas vs HPA, rampa do k6 até o PEAK p95, p99, erros, máximo de réplicas, tempo para escalar
B rolling update sob 100 req/s, com vs sem readiness + preStop requisições com falha
C apagar um pod / parar um nó tempo até ficar pronto de novo

scripts/watch-hpa.sh registra CPU e réplicas desejadas, atuais e prontas a cada 5 s num arquivo de valores separados por vírgula (CSV, comma-separated values) → faça o gráfico.

A · Uma execução num laptop (ilustrativa)

t CPU (% do request) desired ready
1:48 63 2 2
2:03 79 3 2
3:33 247 8 4
7:31 220 8 8
13:00 4 2 2
  • O oitavo pod, pedido às 3:33, ficou pronto às 7:31 — depois de o patamar acabar.
  • HPA: p95 de 5–7 s, p99 ≈ 19 s, 0,3% de erros. Dois pods fixos aquecidos: p95 ≈ 34 ms, sem erros.
  • Num laptop, as JVMs novas dividem as CPUs que servem a carga: o scale-out custou mais do que acrescentou. O atraso é o que o pré-escalonamento remove.

B · Um rollout sob 100 req/s

Execução Readiness probe + preStop Requisições com falha (execução de teste)
com ✅ 0
sem ❌ cerca de 140 de 11.900 (1,2%, 502 e 504 do Traefik)
  • A startup probe continua mantendo um pod novo fora do Service até a JVM responder.
  • Sem a pausa do preStop, os pods antigos param de aceitar enquanto ainda estão na lista de endpoints do Traefik.

Experimente no playground

  • scale-out com o perfil stress: réplicas fixas até o p99 explodir, depois mais réplicas.
  • Vazão por réplica = o número por trás do alvo do seu HPA.
  • Mate uma réplica com e sem health check.

O playground prevê a forma; o seu CSV de réplicas ao longo do tempo é a evidência.

O que quebra em seguida

lab 10 · autocuraHPA: um terceiro pod 15 s depois de 60% de CPU; rollout: 0 de ~11.900 perdidas
→
o limitekubectl no laptop: qualquer imagem vai para todo pod, sem teste nem scan
→
lab 11 · entregatestes, orçamento, scan, GitOps, um canary que aborta
  • Uma versão que falha 30% das requisições chegaria a todos os fãs.

Pontos-chave

  1. Kubernetes = estado desejado + laços de controle; autocura, rollouts e autoscaling são reconciliação.
  2. StatefulSet + PVC para dados; Deployments para pods stateless intercambiáveis.
  3. Startup, liveness, readiness respondem perguntas diferentes — nada de dependências na liveness.
  4. Readiness + preStop + graceful shutdown = rollouts sem erros.
  5. A detecção domina a recuperação: os pods de um nó perdido só são substituídos depois do NotReady + a toleration.
  6. O HPA escala pela % dos requests; ele atrasa — pré-escale para picos conhecidos.
  7. O Ingress (ou a Gateway API) é a porta; escolha um controller mantido.

Capítulo 11 da história da disciplina. Roteiro: (1) por que laços de controle; (2) kind + Traefik + metrics-server; (3) base/overlay do Kustomize; (4) StatefulSet vs Deployment; (5) probes e graceful shutdown; (6) os controllers trabalhando e o gêmeo do lab; (7) HPA; (8) Ingress e Gateway API; (9) medir.

A história da disciplina (visão geral de 2027.1, "A história da disciplina"): o capítulo 11 abre com o que o Compose numa máquina só não faz — curar, escalar às 09:45, desfazer.

O simulador modela os tempos de um laptop (partida da JVM, inicialização do PostgreSQL) e os padrões do Kubernetes (back-off, detecção de nó, a toleration de 300 s); as dicas nas páginas citam os números dele.