Arquitetura de Sistemas · Insper · Lab 3

Lab 3 — Borda

Nginx como proxy reverso, balanceador de carga e rate limiter sobre três réplicas do catalog

A história até aqui

lab 2 · o joelhoum catalog: algumas centenas de req/s
→
capítulo 4 · lab 3o Nginx sobre três réplicas
→
depois · lab 4gateway e identidade

Às 10:00:00 cerca de 100.000 requisições/s chegam à borda; uma réplica mantém a meta de latência só até algumas centenas. 3× as réplicas dão 3× a capacidade?

  • Com três, uma também pode falhar enquanto as outras continuam atendendo.

Uma réplica são dois problemas

O catalog sai da meta de latência em algumas centenas de req/s (o joelho do lab 2) e um deploy o derruba. O que resolve os dois de uma vez?

  • Capacidade: mais cópias idênticas dividem a carga.
  • Disponibilidade: uma cópia falha, as outras continuam atendendo.
  • Pré-condição: o serviço é stateless.

A topologia

k6 / fãs
:80 →
edgeNginx 1.30 · a única porta publicada
round robin →
rede do Compose · sem ports:
catalog-11 CPU
catalog-21 CPU
catalog-31 CPU
→
dbPostgreSQL, compartilhado
  • As réplicas são privadas, como instâncias numa sub-rede privada de uma VPC na nuvem (aula 12).
  • Cabeçalho X-Instance: qual réplica respondeu. A única mudança de código do lab.

Três réplicas com uma âncora

x-catalog: &catalog
  build: ./services/catalog
  image: boxoffice-catalog
  deploy: { resources: { limits: { cpus: "1.0", memory: 768M } } }

services:
  catalog-1: { <<: *catalog, hostname: catalog-1 }
  catalog-2: { <<: *catalog, hostname: catalog-2 }
  catalog-3: { <<: *catalog, hostname: catalog-3 }

O upstream

upstream catalog {
    zone catalog 64k;
    server catalog-1:8082 resolve max_fails=3 fail_timeout=10s;
    server catalog-2:8082 resolve max_fails=3 fail_timeout=10s;
    server catalog-3:8082 resolve max_fails=3 fail_timeout=10s;
    keepalive 64;
}
  • Round robin por padrão; least_conn a uma linha de distância.
  • resolve: resolve os nomes de novo pelo Sistema de Nomes de Domínio (DNS, Domain Name System) do Docker a cada 10 s — sobe mesmo com uma réplica fora do ar e a retoma quando ela volta.

Timeouts e retries

GET
→
catalog-3 congeladoconnect 1 s · read 5 s numa conexão reaproveitada
timeout →
next upstreamsegunda e última tentativa
→
catalog-1: 200cerca de 1 s atrasado, sem erro
proxy_connect_timeout  1s;
proxy_read_timeout     5s;
proxy_next_upstream    error timeout http_502 http_503 http_504;
proxy_next_upstream_tries  2;
  • GET que falhou → repetido em outra réplica.
  • POST não é repetido por padrão: pode não ser idempotente.

Morta vs congelada

Falha O Nginx vê O cliente vê
stop recusada → retry na hora; depois o nome some do DNS ✅ ~nada
pause sem resposta: 1 s (conexão nova) ou 5 s (reaproveitada) → retry ⚠️ nenhum erro, latência no percentil 99 (p99) de ~1–5 s
3 falhas em 10 s fora do rodízio por 10 s, depois uma requisição de teste normal de novo

Uma réplica morta é fácil. Uma lenta é perigosa: o timeout decide quanto ela custa.

Health checks passivos vs ativos

  • Passivos (Nginx open source): aprendem com requisições reais que falharam.
  • Ativos (Envoy, HAProxy, load balancers da nuvem, readiness do Kubernetes): sondam /actuator/health/readiness.
  • Readiness ≠ liveness: pode atender vs está viva.

Por que não proxy_read_timeout 100ms para pegar réplicas congeladas na hora?

Rate limiting na borda

limit_req_zone  $http_x_api_key  zone=per_key:10m  rate=20r/s;
limit_req  zone=per_key  burst=40  nodelay;
limit_req_status  429;
Cliente Enviadas (30 s) 200 429
greedy, 50 req/s 1.500 ~640 ~860
polite, 10 req/s 300 300 0
requisição
→
sem X-Api-Key?chave vazia: sem limite
senão →
excesso dentro de burst=40?escoa a 20/s
→
proxy
429

Quem é o cliente?

  • Um cabeçalho escolhido pelo cliente pode ser trocado por um atacante.
  • Limites reais: identidades verificadas (chaves de API emitidas, o sub de um JSON Web Token, JWT — lab 4) mais limite por IP para tráfego anônimo.
  • Limite por IP erra atrás de tradução de endereços (NAT, network address translation) — e estrangula o nosso k6 de um único IP.

Sem Docker: o gêmeo

4 · distribuição9 curls: 3 por réplica · log de acesso com rt e ut
5 · parar e congelarstop: nenhuma requisição lenta · pause: 58 esperam 1 ou 5 s · 0 erros, máximo de 5,02 s
6 · rate limitgreedy 640 × 200, 860 × 429 · polite 300 × 200
  • O nginx.conf do lab, requisição por requisição: round robin, max_fails, os dois timeouts, a repetição, limit_req.
  • O p99 do gêmeo fica em 29 ms: 58 requisições lentas em 18.000 são menos de 1%. A execução da página pegou mais e o p99 dela chegou a 1 s.
  • Depois do fail_timeout, o Nginx deixa passar uma requisição de teste a cada 10 s.

Meça: 1 vs 3 réplicas, duas cargas

Carga Gargalo 3 réplicas dão
só detalhes (LIST_SHARE=0) CPU da réplica perto de 3×
mistura do lab 2 (20% listagens) PostgreSQL pouco — ou pior

Eficiência de escala = capacidade(3) / (3 × capacidade(1)). Olhe o docker stats: quem está em 100%?

Por que não 3×?

  • Mistura: db em ~670% de CPU, cada réplica em ~20% — a camada compartilhada está saturada.
  • Mais réplicas = mais consultas pesadas simultâneas no mesmo banco.
  • Réplicas frias + max_fails podem cascatear até 502 no live upstreams: aqueça antes.

O que quebra em seguida

lab 3 · escala horizontaldetalhes: perto de 3×; a carga mista: pouco
→
dois limitesdb ~670% de CPU, réplicas ~20%; qualquer um chama qualquer coisa
→
lab 4 · gateway e identidadequem chama, verificado uma vez; réplicas stateless
  • O banco espera pelos labs 5 (cache) e 6 (índices).

Pontos-chave

  1. Serviços stateless escalam atrás de um balanceador de carga; o estado fica em outro lugar.
  2. A borda é a única porta pública: roteamento, balanceamento, limites, ids de requisição.
  3. Os timeouts transformam réplicas lentas em retries; defina-os pela latência medida.
  4. Só faça retry de requisições idempotentes.
  5. Rate limits protegem todos de um único cliente — use uma identidade verificada como chave.
  6. Escalar a camada stateless passa a pressão para a camada stateful compartilhada.

Capítulo 4 da história. Roteiro: (1) por que escalar horizontalmente; (2) a topologia; (3) réplicas no Compose; (4) nginx.conf; (5) distribuição; (6) falhas: stop vs pause; (7) rate limiting; (8) medir a eficiência do scale-out.

A história da disciplina (visão geral de 2027.1, "A história da disciplina"): todo capítulo abre com o número que o anterior deixou. O lab 3 constrói a borda do capítulo 4 (aula 4, Tráfego e Borda).

O simulador está no passo 5 da página do lab; cada roteiro repete um passo da página.