d. Execução
Experimente
Sem Docker à mão? O simulador roda a pilha do lab: lb, três gateways, account-1 e account-2, Redis e PostgreSQL, com a chave (accounts::42), o TTL e as anotações do lab; play ou → roda uma página e os botões funcionam a qualquer momento. Em Execução, a segunda requisição é um hit mesmo com account-2 respondendo, a medição dá 0,058 s e 0,004 s, o TTL responde 287 e o INFO stats termina em keyspace_hits:8 e keyspace_misses:2 (80%). Em local × compartilhado, sem type: redis as duas réplicas dão miss duas vezes e um PUT por account-1 deixa account-2 servindo "Ada Lovelace"; com o Redis, um miss serve as duas. Em TTL e dado desatualizado, um UPDATE no psql fica invisível até o TTL de 300 s acabar e um 404 nunca vai para o cache.
Reconstrua e suba a stack completa com o Redis:
Verifique se o container redis está rodando junto com todos os outros serviços:
A saída esperada inclui:
NAME STATUS PORTS
store-redis-1 running 0.0.0.0:6379->6379/tcp
store-lb-1 running 0.0.0.0:8080->80/tcp
store-gateway-1 running
store-gateway-2 running
store-gateway-3 running
store-account-1 running
store-account-2 running
store-auth-1 running
store-db-1 running 0.0.0.0:5432->5432/tcp
Verificar o comportamento do cache
Primeira requisição — cache miss
Envie uma requisição para buscar uma conta:
A primeira chamada vai ao banco de dados. Abra uma sessão do Redis CLI e inspecione a chave que foi gravada:
Esperado:
Leia o valor em cache:
Esperado — uma string JSON:
Segunda requisição — cache hit
Envie a mesma requisição novamente:
Confira os logs do serviço — desta vez o banco de dados não deve ser consultado:
Se o cache estiver funcionando, você verá uma linha de log para a primeira requisição, mas nenhuma para a segunda.
As duas requisições lado a lado. O Nginx e o Docker as espalham pelas réplicas, então a segunda pode cair na outra réplica de account: mesmo assim é um hit, porque as duas leem o mesmo Redis.
sequenceDiagram
participant C as curl
participant G as lb e gateway
participant A as account
participant R as redis
participant DB as db
C->>G: GET /accounts/42 (primeira)
G->>A: GET /accounts/42
A->>R: GET accounts::42
R-->>A: (nil)
A->>DB: SELECT ... WHERE id = '42'
A->>R: SET accounts::42 ... PX 300000
A-->>C: 200, cerca de 0,058 s
C->>G: GET /accounts/42 (segunda)
G->>A: GET /accounts/42
A->>R: GET accounts::42
R-->>A: o JSON
A-->>C: 200, cerca de 0,004 s, sem SELECT Medir a diferença de latência
Use a saída de tempos embutida do curl para comparar os tempos de resposta. A chave ainda está no cache por causa das requisições acima, então apague-a antes — senão o "miss" abaixo também é um hit:
Um resultado típico:
O cache hit é de 10 a 15× mais rápido, porque o Redis responde em < 1 ms e a resposta passa apenas pelo gateway — sem ida e volta ao banco de dados.
Inspecionar a expiração do TTL
Veja quanto tempo falta para uma chave em cache expirar:
Quando o TTL chega a 0, o Redis remove a chave automaticamente. A próxima requisição será um cache miss e o banco de dados será consultado de novo — mantendo o cache eventualmente consistente com o banco.
stateDiagram-v2
state "ausente" as absent
state "em cache" as cached
[*] --> absent
absent --> cached: GET com miss, depois SET com TTL de 300 s
cached --> cached: GET com hit (o TTL continua descendo)
cached --> cached: PUT, @CachePut grava o valor novo
cached --> absent: o TTL chega a 0
cached --> absent: DELETE, @CacheEvict
absent --> absent: GET de um id inexistente, 404 não vai para o cache Monitorar a taxa de acertos do cache
Observe a atividade do cache em tempo real com o comando MONITOR, embutido no Redis (use com cuidado em produção — ele registra todos os comandos):
Envie várias requisições e acompanhe a passagem dos comandos GET (hit ou nil) e SET (miss + armazenamento).
Para estatísticas agregadas, use INFO stats:
Estes são os números depois dos passos desta página, com quatro requisições durante o MONITOR: dois misses (a primeira requisição e a que vem depois do DEL) e oito hits — o GET e o TTL do próprio redis-cli também contam como leituras. Os seus números dependem de quantas requisições você enviou.
Uma taxa de acertos saudável fica acima de 90% em workloads com muitas leituras. Se a taxa de misses estiver alta, considere aumentar o TTL ou pré-aquecer o cache na inicialização.
Pronto! O Redis agora atua como uma camada de cache compartilhada e persistente entre todas as réplicas dos microsserviços. A carga no banco de dados cai na proporção da taxa de acertos do cache e todas as réplicas do gateway compartilham o mesmo estado de cache, não importa qual instância atenda cada requisição. O banco por trás do cache, porém, ainda é um único container: o hands-on 9 o transforma em um cluster com réplicas e failover.