Arquitetura de Sistemas · Insper · Lab 5 · Capítulo 7

Lab 5 — Caching

Cache-aside com Redis no catalog: hit ratio, p99, invalidação — e um stampede, reproduzido e corrigido

A história até aqui

antes · lab 4um gateway na frente de 3 réplicas stateless
→
capítulo 7 · lab 5cache-aside com Redis no catalog
→
depois · lab 6capítulo 6: assentos, reservas, locks

Toda réplica pergunta ao PostgreSQL e as páginas de evento são lidas ~100× mais do que mudam. Quantas dessas leituras a memória consegue responder?

  • Capítulo 7 antes do 6: primeiro as leituras, com o catalog que você tem; assentos no lab 6.

O candidato perfeito a cache

Quantas vezes "próximos eventos em São Paulo, página 1" é lido para cada vez que muda?

  • Milhares de leituras, poucas escritas por dia.
  • Forte concentração de popularidade: poucos eventos recebem a maior parte das visitas.
  • Lab 2: o pool do banco é o gargalo.

O que você vai construir

fã
→
edge → gatewayrodízio
→
catalog-1..3EventCache · header X-Cache
→
compartilhados pelas três réplicas
redis :6379256 MB, allkeys-lru, sem persistência
dbPostgreSQL: só num miss
  • Primeiro GET /catalog/events/42: X-Cache: MISS — o banco responde, a notação de objetos JavaScript (JSON, JavaScript Object Notation) vai para o Redis.
  • O segundo, mesmo em outra réplica: X-Cache: HIT — nenhum acesso ao banco.

Cache-aside no EventCache

GET key
hit →
devolve o JSONX-Cache: HIT
GET key
nil →
SELECT … no PostgreSQL
→
SET key json PX ttl + 0–10%
→
devolveX-Cache: MISS
Padrão Quem carrega Escritas
cache-aside ✅ a aplicação, no miss banco, depois remove
read-through o cache —
write-through — cache + banco, síncrono
write-behind — cache agora, banco depois ⚠️

Chaves e tempo de vida (TTL, time to live)

Chave TTL Invalidação
catalog:event:{id} 60 s removida em update/delete
catalog:events:city=…:page=… 10 s só expira
  • Guarde o JSON da resposta: um hit não custa banco nem serialização.
  • Ponha jitter no TTL (+0–10%): chaves escritas juntas não expiram juntas.

Invalidação

PUT /catalog/events/42token de admin
→
UPDATE + COMMIT
→
DEL catalog:event:42próxima leitura: MISS, dado novo
chaves de listagem intactasdesatualizadas por até 10 s
  • Remova, não sobrescreva: atualizações concorrentes poderiam deixar em cache uma versão mais antiga.
  • Toda chave mantém um TTL: a rede de segurança para toda corrida.

Um admin muda um preço. Por quanto tempo um fã pode ver o antigo, em cada página?

Quando o Redis falha

GET key
→
Redis fora ou lentotimeout de 200 ms
→
registra, trata como miss
→
200 do PostgreSQLX-Cache: MISS
  • O timeout padrão do Lettuce é 60 s → defina 200 ms.
  • Todo erro do Redis vira um miss: mais lento, mas funcionando.
  • Sem persistência: depois de um reinício o cache está frio.

Se o cache absorvia 95% das leituras, a queda dele manda 20× a carga para o banco.

A conta do hit ratio

  • Leituras no banco = (1 − h) × total de leituras.
  • h = 90% → o banco vê 10%. h = 99% → o banco vê 1%.
  • O hit ratio depende do espaço de chaves, da concentração e do TTL — não da velocidade do Redis.

Meça

CACHE_ENABLED=false docker compose up -d --wait && k6 run -e RATE=300 load/cache.js
CACHE_ENABLED=true  docker compose up -d --wait && docker compose exec redis redis-cli FLUSHALL
k6 run -e RATE=300 load/cache.js     # cold
k6 run -e RATE=300 load/cache.js     # warm
  • 80% das requisições de detalhe vão para os 2.000 eventos mais quentes (1% do catálogo).
  • O k6 lê o X-Cache: taxa cache_hit, latency_hit, latency_miss.
  • Numa execução deste lab: ~72% frio, 72% de novo quente com o TTL de 60 s; com CACHE_TTL_EVENT=5m, 83% quente contra 71% frio.

O stampede

  • Uma chave quente expira.
  • Toda requisição que chega durante a recarga dá miss.
  • 200 consultas pesadas idênticas atingem o banco ao mesmo tempo.
CACHE_TTL_LIST=3s CACHE_STAMPEDE_PROTECTION=false docker compose up -d --wait
k6 run load/stampede.js       # cache_misses ≫ expirations

Correção: uma reconstrução por chave

miss
→
SET key:lock token NX PX 2000
ganhou →
confere de novo, carrega, SET, liberauma consulta por expiração
todas as outras
perdeu →
consulta o cache a cada 25 ms≤ 500 ms, depois carrega mesmo assim
→
HIT
  • Numa execução de teste (200 usuários virtuais, 60 s): misses 2.238 → 19; p99 ~1 s → ~0,3 s; unidade central de processamento (CPU, central processing unit) do db 234% → 4%.
  • O lock expira se o dono morrer; libere só o seu token (de forma atômica: um script Lua).

Outras curas

Técnica Trade-off
jitter no TTL não ajuda com uma chave quente
atualização antecipada probabilística algum trabalho duplicado
stale-while-revalidate clientes veem dados velhos por pouco tempo
refresh-ahead precisa conhecer as chaves quentes
agrupamento de requisições na borda só respostas cacheáveis do protocolo de transferência de hipertexto (HTTP, Hypertext Transfer Protocol)

Sem Docker: o simulador

Confira (passo 5)MISS em catalog-2, HIT em catalog-3, TTL 62
Listagem após uma atualizaçãoum HIT desatualizado por 7 s, ≤ CACHE_TTL_LIST
TTL e BYPASSum miss por expiração, cada BYPASS uma consulta
  • A página Cache-aside embute o cache do lab 5 como simulador: mesmas chaves, TTLs e saídas.
  • Pare o Redis: ainda um 200; inicie-o: vazio, porque não há persistência.

O que quebra em seguida

lab 5 · leituraso banco só vê 1 − h das leituras
→
as escritasnenhum cache pode responder "o assento 42 está livre?" · 33.000 reservas/s contra ~1.100
→
lab 6 · capítulo 6inventory: qual lock nunca vende um assento duas vezes?
  • Às 10:00 os fãs param de ler e começam a reservar assentos.

Pontos-chave

  1. Cache-aside: a aplicação carrega no miss, remove na escrita, toda chave tem um TTL.
  2. Um cache só é tão bom quanto o seu hit ratio — que se alimenta de concentração.
  3. O cache é uma otimização: falhe aberto para o banco, com timeouts curtos.
  4. Chaves quentes expirando causam stampedes: junte misses concorrentes em uma só carga.
  5. Declare a defasagem que você aceita — é uma decisão de produto.

Capítulo 7 da história da disciplina, construído antes do capítulo 6. Roteiro: (1) por que fazer cache do catálogo; (2) o que você vai construir; (3) cache-aside e EventCache; (4) chaves e tempo de vida; (5) invalidação; (6) tratamento de falhas; (7) a conta do hit ratio e a medição; (8) stampede e o lock; (9) outras curas; (10) o simulador.

A história da disciplina (visão geral de 2027.1, "A história da disciplina"): o capítulo 7 abre com a razão de ~100x leituras por escrita. O lab 4 mediu a porta de entrada como barata (de uma fração de ms a poucos ms no p50), então o custo de uma leitura é o banco. Os labs fazem o capítulo 7 antes do 6.

Com 60 s, as chaves gravadas no começo da execução fria expiram no começo da seguinte: cada chave quente dá miss cerca de uma vez por minuto nas duas. Um TTL mais longo que a execução mostra o cache quente vencer. Aquecimentos antes de cada execução: as réplicas recriadas são JVMs frias.

O simulador fica no fim do passo 5 de Cache-aside.