Cache é a alavanca de desempenho com melhor relação entre esforço e resultado que existe. Também é a fonte de uma categoria inteira de bug difícil: o usuário que vê dado antigo, a alteração que não aparece, o relatório que mostra número diferente do painel.
A diferença entre os dois resultados está em duas coisas: colocar o cache na camada certa e resolver a invalidação antes de precisar dela.
As camadas, de fora para dentro
Cada uma intercepta a requisição mais cedo e, por isso, economiza mais — e é mais difícil de invalidar.
| Camada | Onde fica | Economiza | Dificuldade de invalidar |
|---|---|---|---|
| Navegador | no dispositivo do usuário | tudo | altíssima |
| CDN | na borda da rede | servidor e banda | média |
| Proxy reverso | na sua infraestrutura | aplicação e banco | baixa |
| Aplicação | memória ou Redis | banco | baixa |
| Banco | buffer do próprio banco | disco | automática |
A regra geral: quanto mais perto do usuário, mais eficiente e menos controlável. Dado que muda raramente pode ir para fora; dado que muda com frequência fica perto.
Navegador: eficiente e irreversível
O cache do navegador é o mais barato — a requisição nem sai do dispositivo. E é o único que você não consegue limpar: uma vez que o navegador guardou algo com validade de um ano, não há como alcançá-lo.
A solução é o padrão que resolve isso de forma definitiva: arquivos estáticos com nome versionado. Em vez de app.js, use app.a1b2c3.js, onde o sufixo muda a cada build. Assim:
- O arquivo pode ter validade longa, porque o nome nunca se repete com conteúdo diferente.
- A versão nova tem nome novo, então o navegador busca.
- Não existe invalidação a fazer.
E o HTML que referencia esses arquivos não deve ser cacheado de forma agressiva — ele é o ponto de entrada que aponta para as versões novas.
A regra prática: validade longa para o que tem nome versionado, validação a cada requisição para o resto.
CDN: a camada de maior impacto
Serve conteúdo a partir de servidores próximos do usuário. Resolve latência e tira carga da sua infraestrutura.
O que colocar: arquivos estáticos (imagem, script, estilo, fonte), downloads, e — o que muita gente não aproveita — páginas inteiras que são iguais para todos os visitantes. Uma página de produto, um artigo, uma listagem pública.
Esse último ponto é onde está o ganho maior e o menos explorado. Se a sua aplicação gera a mesma página para todo visitante não autenticado, cacheá-la na borda pode reduzir drasticamente a carga.
O cuidado central é não cachear resposta personalizada. Página com nome do usuário logado servida a outro visitante é um vazamento de dado, não um bug de desempenho. O que previne:
- Separar claramente as rotas públicas das autenticadas.
- Marcar explicitamente como privada toda resposta que depende de sessão.
- Nunca deixar que um cabeçalho de autenticação participe da chave de cache sem intenção.
E mantenha um mecanismo de purga testado. A primeira vez que você precisar remover algo da borda não deve ser a primeira vez que tenta.
Proxy reverso
Um cache na sua própria infraestrutura, antes da aplicação. Faz o que a CDN faz, sob o seu controle total, sem a vantagem geográfica.
Útil para quem não usa CDN, para conteúdo interno, e como segunda linha — se a CDN pede, o proxy responde sem incomodar a aplicação.
Tem um recurso que vale conhecer: servir conteúdo vencido quando a origem está fora do ar. Em vez de erro, o usuário recebe a versão anterior. É uma rede de proteção barata que transforma indisponibilidade em desatualização, o que quase sempre é preferível.
Aplicação: onde mora a complexidade
Cache em memória do processo ou em Redis, guardando resultado de consulta, objeto montado, resposta de API externa.
É a camada mais flexível e onde ficam os problemas interessantes.
A chave de cache
Decisão mais importante e mais errada. A chave precisa incluir tudo que muda o resultado: identificador do recurso, usuário ou permissão quando o conteúdo varia, idioma, filtros, paginação, e a versão do formato.
Esse último item evita um incidente específico: a versão nova mudou o formato do objeto guardado, você precisa reverter, e a versão antiga lê algo que não entende. Incluir a versão na chave faz cada versão usar o próprio espaço — o custo é um período de cache frio, infinitamente melhor que erro de leitura em produção.
A invalidação
As duas estratégias:
- Por tempo: o dado expira sozinho. Simples, e aceita servir conteúdo desatualizado por até o tempo definido.
- Por evento: quando o dado muda, o cache é removido. Preciso, e exige disciplina — toda escrita precisa lembrar de invalidar.
O desenho mais robusto combina as duas: invalidação por evento com um tempo de expiração como rede de proteção. Se alguém esquecer de invalidar em algum caminho de escrita, o dado se corrige sozinho em alguns minutos em vez de ficar errado para sempre.
O problema da avalanche
Um item popular expira. Mil requisições chegam ao mesmo tempo, nenhuma encontra o cache, e todas vão ao banco simultaneamente — derrubando exatamente o que o cache protegia.
As soluções, em ordem de simplicidade:
- Trava: a primeira requisição recalcula, as outras esperam o resultado dela.
- Expiração com variação aleatória, para que itens não expirem todos no mesmo instante.
- Recálculo antecipado, atualizando o item antes de ele vencer.
- Servir vencido enquanto revalida, devolvendo o valor antigo e atualizando em segundo plano.
A última é a melhor experiência: ninguém espera, e o dado se atualiza sozinho.
Banco: o cache que já existe
Todo banco mantém um cache em memória dos dados mais acessados, e esse é o primeiro lugar a olhar antes de adicionar camadas.
Um banco com memória bem dimensionada atende a maior parte das leituras sem tocar o disco. A taxa de acerto desse cache é uma métrica que vale monitorar: quando ela cai, o volume de dados cresceu além da memória — e isso é uma decisão de capacidade, não um caso para cache de aplicação.
Vale dizer com clareza: consulta lenta por falta de índice não se resolve com cache. Cache esconde o sintoma e o problema volta na primeira invalidação, ou em qualquer consulta que não passe pelo cache. Índice primeiro, cache depois.
O que medir
- Taxa de acerto por camada. Cache com taxa baixa está custando sem entregar.
- Latência com e sem acerto, para saber o ganho real.
- Volume de invalidações, que revela se a estratégia está correta.
- Memória usada contra o limite, e quantas chaves estão sendo removidas por falta de espaço — remoção alta significa cache pequeno demais.
- Idade do conteúdo servido, para saber o quão desatualizado o usuário está vendo.
Erros comuns
- Cachear resposta personalizada na CDN, vazando dado entre usuários.
- Arquivo estático com validade longa e sem nome versionado.
- HTML cacheado agressivamente, apontando para versões antigas.
- Chave de cache sem todos os parâmetros que mudam o resultado.
- Chave sem versão, quebrando no rollback.
- Invalidação só por evento, sem tempo de expiração como rede de proteção.
- Nenhuma proteção contra avalanche na expiração.
- Usar cache para esconder falta de índice.
- Tratar o cache como fonte da verdade.
- Não monitorar taxa de acerto nem remoção por falta de memória.
- Nunca ter testado a purga da CDN.
- Adicionar camada de cache antes de dimensionar a memória do banco.
A ordem de adoção
- Dimensione a memória do banco e corrija os índices. Muita "necessidade de cache" desaparece aqui.
- Arquivos estáticos com nome versionado e validade longa.
- CDN para estáticos e para páginas públicas iguais para todos.
- Cache de aplicação para o que for caro de calcular, com chave completa e versionada.
- Proteção contra avalanche nos itens mais acessados.
- Medição de taxa de acerto e idade do conteúdo.
Começar pelo passo 4 é o mais comum, e costuma adicionar complexidade onde o passo 1 resolveria.
Onde a Solvefy/Cloud entra
Tratamos cache como parte do desenho de desempenho, não como remendo: começamos dimensionando banco e índices — que é onde o ganho costuma estar —, depois estruturamos as camadas com chave completa e versionada, invalidação combinada, proteção contra avalanche e separação clara entre rota pública e autenticada, que é o que evita vazamento na borda. Implantamos a medição de taxa de acerto e de idade do conteúdo, e operamos Redis em produção com os modos de falha resolvidos.
Sua aplicação está lenta ou só está sem cache? Diagnóstico gratuito, sem compromisso, em solvefy.cloud.
Solvefy/Cloud — Infraestrutura que cresce com você.