Todos os artigos

· 3 min de leitura

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.

  • Redis
  • Cache
  • Performance

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.