Cache com Redis sem dor de cabeça: TTL, invalidação e o efeito manada
Cache é a otimização mais barata até o dia em que ele derruba o seu banco. Os padrões que uso para cachear com segurança em aplicações de alto tráfego.
Existe uma piada antiga de que as duas coisas mais difíceis em computação são invalidar cache e dar nome às coisas. Depois de anos trabalhando com sistemas que só sobreviviam a picos de tráfego graças ao Redis, eu acrescentaria uma terceira: o que acontece quando o cache expira.
Este artigo reúne os padrões que uso para que o cache ajude em vez de atrapalhar.
Cache-aside: o padrão de partida
O padrão mais comum — e o que recomendo na maioria dos casos — é o cache-aside: a aplicação procura no cache; se não encontrar, busca na fonte, grava no cache e devolve.
No Laravel isso é uma linha:
$premios = Cache::remember('campanha:42:premios', now()->addMinutes(10), function () {
return Premio::where('campanha_id', 42)->orderBy('ordem')->get();
});
Simples e eficaz. O problema começa quando essa chave é acessada milhares de vezes por segundo.
O efeito manada (cache stampede)
Imagine que a chave acima expira exatamente quando 2.000 requisições chegam ao mesmo tempo. Todas encontram o cache vazio, todas executam a consulta, todas tentam gravar o resultado. O banco, que estava tranquilo porque o cache absorvia tudo, recebe 2.000 consultas idênticas de uma vez.
Em sistemas de alto tráfego, esse é um dos jeitos mais comuns de derrubar um banco de dados que “estava funcionando bem”.
Solução 1: lock na regeneração
Só uma requisição recalcula; as outras esperam um pouco e leem o resultado:
$premios = Cache::get('campanha:42:premios');
if ($premios === null) {
$premios = Cache::lock('lock:campanha:42:premios', 10)->block(5, function () {
return Cache::remember('campanha:42:premios', now()->addMinutes(10), fn () =>
Premio::where('campanha_id', 42)->orderBy('ordem')->get()
);
});
}
Solução 2: servir o valor antigo enquanto recalcula
Ainda melhor: ninguém espera. O valor antigo continua sendo servido enquanto um processo em segundo plano calcula o novo — o conceito de stale-while-revalidate. As versões recentes do Laravel trazem isso pronto:
// Fresco por 5 min; entre 5 e 15 min serve o valor antigo e recalcula em background.
$premios = Cache::flexible('campanha:42:premios', [300, 900], fn () =>
Premio::where('campanha_id', 42)->orderBy('ordem')->get()
);
Solução 3: TTL com variação
Se você aquece o cache de muitas chaves de uma vez (no deploy, por exemplo), todas vão expirar juntas. Adicionar uma variação aleatória ao TTL espalha as expirações:
$ttl = now()->addSeconds(600 + random_int(0, 120));
Invalidação: prefira chaves versionadas
Apagar chaves específicas quando um dado muda funciona até você esquecer de uma delas. Uma alternativa mais robusta é incluir uma versão na chave:
$versao = Cache::rememberForever('campanha:42:versao', fn () => 1);
$chave = "campanha:42:v{$versao}:premios";
// Ao alterar qualquer prêmio da campanha:
Cache::increment('campanha:42:versao');
Todas as chaves antigas ficam órfãs e expiram sozinhas pelo TTL. Não é preciso saber quais chaves existem.
O que não colocar no cache
- Dados que precisam ser exatos no momento da escrita. Saldo, estoque disponível para reserva, limite de participações. Para esses, use operações atômicas do Redis (
INCR,DECR, scripts Lua) ou o banco com lock adequado — não um valor cacheado. - Respostas personalizadas com chaves genéricas. Já vi dados de um usuário aparecerem para outro porque a chave do cache não incluía o ID dele. Revise as chaves com o mesmo cuidado de uma regra de permissão.
- Objetos enormes. Serializar e desserializar uma coleção de 5 MB a cada requisição pode ser mais lento que a consulta original.
Meça antes e depois
Cache adiciona complexidade, então precisa se justificar. Acompanhe a taxa de acerto (hit rate), a memória usada e a latência das operações. Um cache com 20% de acerto provavelmente está cacheando a coisa errada.
O Redis é uma das ferramentas mais versáteis que conheço, mas cache não é mágica: é uma cópia dos seus dados com prazo de validade. Tratá-lo assim — pensando em quando expira, quem recalcula e o que acontece no meio do caminho — é o que separa um cache que salva o sistema de um que o derruba.