Arquitetura de Sistemas · Insper · Lab 4

Lab 4 — Gateway e identidade

Um serviço auth que assina JSON Web Tokens (JWTs) e um Spring Cloud Gateway que os valida uma única vez

A história até aqui

lab 3 · borda3 réplicas; a carga mista presa no PostgreSQL
→
capítulos 4–5 · lab 4auth + gateway: identidade, uma vez
→
depois · lab 5um cache na frente do banco

A borda limita 20 requisições/s por chave, mas a chave é um cabeçalho que o cliente escolhe. Como 2 milhões de fãs provam quem são — uma vez, para todos os serviços?

  • Nenhuma réplica guarda sessão: o token viaja com cada requisição.

Quem é você e o que você pode fazer?

Hoje qualquer um consegue apagar eventos do catálogo. Cada serviço deveria aprender a conferir senhas?

  • Autenticação — quem está chamando.
  • Autorização — o que essa pessoa pode fazer.
  • Resolva uma vez, na porta de entrada: o gateway da interface de programação de aplicações (API, application programming interface).

O que você vai construir

fãs · k6
:80 →
edgeNginx · rate limit · /actuator → 404
→
gateway :8080JWT, regras, rotas, lb://catalog
→
serviços
auth :8081usuários, BCrypt, assina tokens
catalog-1..3 :8082confiam nos X-User-* do gateway
  • Dois load balancers: o edge distribui entre gateways, o gateway entre instâncias dos serviços.
  • Só o edge é público; a porta 8080 está publicada só para as medições.

Sessões vs tokens

Id de sessão JWT
O cliente guarda id aleatório claims assinadas
Verificação busca em um armazenamento verifica a assinatura localmente
Revogação imediata espera o exp
Escala com o armazenamento de sessões só unidade central de processamento (CPU, central processing unit)

RS256 e o JSON Web Key Set (JWKS)

authchave privada · assina
token →
clientemanda o Bearer em toda requisição
→
gatewaychave pública · verifica localmente
← uma vez
/auth/.well-known/jwks.jsonbaixado de novo só para um kid desconhecido
  • RS256 = uma assinatura Rivest–Shamir–Adleman (RSA) sobre SHA-256: só o auth emite; qualquer um verifica.
  • Com HS256, um código de autenticação de mensagem baseado em hash (HMAC, hash-based message authentication code), um segredo assina e verifica: quem o tem pode forjar tokens.

Assinado ≠ criptografado: qualquer um lê o payload.

O token

{ "iss": "boxoffice-auth", "aud": "boxoffice",
  "sub": "0b9d8a6e-…", "email": "ana@example.com",
  "scope": "user", "iat": 1795000000, "exp": 1795003600 }
  • O gateway verifica assinatura, exp, iss, aud.
  • scope → authorities SCOPE_user, SCOPE_admin.

O serviço auth

  • POST /auth/register — BCrypt (custo 10), nunca a senha.
  • POST /auth/login — o mesmo 401 para usuário desconhecido e senha errada.
  • GET /auth/me — confia no X-User-Id vindo do gateway.
  • Admin criado na inicialização a partir de ADMIN_EMAIL / ADMIN_PASSWORD.
  • Novo par de chaves RSA a cada inicialização: os tokens antigos morrem (veja Uma chave nova, adiante).

Rotas do gateway

routes:
  - id: auth
    uri: http://auth:8081
    predicates: [ Path=/auth/** ]
  - id: catalog
    uri: lb://catalog          # catalog-1..3, health-checked
    predicates: [ Path=/catalog/** ]
  • Timeouts: conexão 1 s, resposta 5 s. Um GET que falhou é repetido uma vez, em outra instância.
  • Health check: sonda o /actuator/health/readiness de cada uma a cada 5 s e pula as que não estão UP.

Quem pode chamar o quê

.pathMatchers("/auth/register", "/auth/login", "/auth/.well-known/**").permitAll()
.pathMatchers(HttpMethod.GET, "/catalog/**").permitAll()
.pathMatchers("/catalog/**").hasAuthority("SCOPE_admin")
.anyExchange().authenticated()
mandou token?validado antes, mesmo numa rota aberta
→
primeira regra que casaem ordem
→
permitida → roteia
sem token ou token ruim401
válido, scope errado403
  • Negar por padrão: rotas novas ficam protegidas automaticamente.

Headers de identidade

clienteBearer (Ana) + X-User-Id: admin
→
gatewayremove X-User-* · valida · sub = Ana
→
authX-User-Id: Ana
  • Remova X-User-* vindos do cliente — sempre; depois defina-os a partir do JWT validado.
  • Os serviços confiam neles porque só são alcançáveis pelo gateway.

O que muda em uma rede zero trust?

Teste de ponta a ponta

Requisição Resposta Quem respondeu
POST /auth/register 201 auth
POST /auth/login 200 + token auth
GET /auth/me com o token 200 Ana auth (pelo gateway)
GET /auth/me sem token 401 gateway
DELETE /catalog/events/2 como Ana 403 gateway
PUT /catalog/events/2 como admin 200 uma réplica do catalog
  • As recusas nunca chegam a um serviço: custam microssegundos ao gateway.

Uma chave nova a cada reinício

reinicia o authnovo par de chaves, kid B
→
token antigo (kid A)200: o gateway ainda tem o kid A em cache
→
primeiro token com kid Bkid desconhecido → baixa o JWKS
→
token antigo (kid A)401: não está mais no JWKS
  • O gateway guarda o JWKS em cache e só o baixa de novo para um kid desconhecido.
  • Produção: a chave fica num serviço de gerenciamento de chaves (KMS, key management service); o JWKS lista a atual e a anterior.
  • Tokens expirados: o gateway tolera 60 s de diferença de relógio além do exp.

Meça

Caminho O que acrescenta
só o catalog linha de base
gateway → catalog + o salto pelo gateway
edge → gateway → catalog + o salto pelo edge
o mesmo, com um token + validação do JWT
# k6 inside the compose network: catalog replicas publish no port
docker run --rm -i --network boxoffice_default -v "$PWD":/w -w /w \
  grafana/k6 run -e RATE=50 load/gateway.js

O login é lento de propósito

  • BCrypt custo 10 → dezenas de ms de CPU por verificação.
  • auth com 1 CPU: cerca de 10–20 logins/s.
  • Medido: 10 logins/s mantiveram o p99 < 200 ms (~80% de CPU); 20 logins/s → 504 no timeout de 5 s.
  • Consequências: reutilize tokens, ponha rate limit no /auth/login, faça login antes das 10:00.
for r in 5 10 20 40; do k6 run -q -e RATE=$r --summary-export results/lab4/rate-$r.json load/login.js; done

Sem Docker: o simulador

Teste de ponta a ponta201, 200, 200, 401, 403 · um download do JWKS
Casos de falhaheader forjado, payload editado, chave nova, 60 s de tolerância
Borda e réplicas/actuator 404, um GET repetido, 41 passam e 9 recebem 429
  • A visão geral embute a pilha do lab 4 como simulador: mesmas requisições, mesmas respostas.
  • O caminho acende até onde cada requisição chegou; a caixa que respondeu mostra o status.

O que quebra em seguida

lab 4 · a porta de entradasalto + JWT: ms ou menos; login: 10–20/s por núcleo
→
todo o estado no PostgreSQLpáginas lidas ~100× mais do que mudam
→
lab 5 · cachingo Redis responde a pergunta repetida
  • Os fãs fazem login antes das 10:00 e reutilizam o token.

Pontos-chave

  1. Autentique uma vez no gateway; autorize de forma fina onde os dados vivem.
  2. RS256 + JWKS: só o auth assina, todos verificam localmente.
  3. Valide exp, iss, aud — não só a assinatura.
  4. Negue por padrão; remova headers de identidade vindos dos clientes.
  5. O salto pelo gateway e a verificação do JWT são baratos; o hash de senhas não é.

Capítulos 4 e 5 da história. Roteiro: (1) autenticação vs autorização; (2) sessões vs JWT; (3) RS256 e JWKS; (4) serviço auth; (5) rotas e LB do gateway; (6) regras de segurança; (7) headers de identidade; (8) medições: salto, JWT, login.

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 4 fecha o capítulo 4 (identidade) e constrói a porta de entrada do capítulo 5 (serviços stateless).

Como na nuvem: um load balancer público de camada 7 → uma frota de API gateways → balanceamento interno dos serviços. A página desenha a mesma topologia em "O que você vai construir".

O simulador fica logo depois dos casos de falha em "Teste de ponta a ponta".