Pular para conteúdo

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:

docker compose up -d --build

Verifique se o container redis está rodando junto com todos os outros serviços:

docker compose ps -a

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:

curl -s http://localhost:8080/accounts/42 | jq

A primeira chamada vai ao banco de dados. Abra uma sessão do Redis CLI e inspecione a chave que foi gravada:

docker compose exec redis redis-cli
KEYS accounts::*

Esperado:

1) "accounts::42"

Leia o valor em cache:

GET "accounts::42"

Esperado — uma string JSON:

{"id":"42","name":"Ada Lovelace","email":"ada@example.com"}

Segunda requisição — cache hit

Envie a mesma requisição novamente:

curl -s http://localhost:8080/accounts/42 | jq

Confira os logs do serviço — desta vez o banco de dados não deve ser consultado:

docker compose logs account --tail 20

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:

docker compose exec redis redis-cli DEL "accounts::42"
curl -o /dev/null -s -w "Cache miss: %{time_total}s\n" http://localhost:8080/accounts/42
curl -o /dev/null -s -w "Cache hit:  %{time_total}s\n" http://localhost:8080/accounts/42

Um resultado típico:

Cache miss: 0.058s
Cache hit:  0.004s

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:

TTL "accounts::42"

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):

docker compose exec redis redis-cli MONITOR

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:

docker compose exec redis redis-cli INFO stats | grep -E "keyspace_(hits|misses)"
keyspace_hits:8
keyspace_misses:2

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.