Cache em camadas: navegador, CDN, aplicação e banco

Onde colocar cache e o que cada camada resolve. Invalidação, stampede, chave de cache e por que cache mal feito é pior que nenhum cache.

Equipe Solvefy 7 min de leitura

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.

CamadaOnde ficaEconomizaDificuldade de invalidar
Navegadorno dispositivo do usuáriotudoaltíssima
CDNna borda da redeservidor e bandamédia
Proxy reversona sua infraestruturaaplicação e bancobaixa
Aplicaçãomemória ou Redisbancobaixa
Bancobuffer do próprio bancodiscoautomá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.

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

  1. Dimensione a memória do banco e corrija os índices. Muita "necessidade de cache" desaparece aqui.
  2. Arquivos estáticos com nome versionado e validade longa.
  3. CDN para estáticos e para páginas públicas iguais para todos.
  4. Cache de aplicação para o que for caro de calcular, com chave completa e versionada.
  5. Proteção contra avalanche nos itens mais acessados.
  6. 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ê.

Faça agora o seu diagnóstico e orçamento

Inicie com um diagnóstico gratuito da sua infraestrutura e receba uma proposta personalizada, com escopo, cronograma e valores.