CS Fundamentals Trainer · Guias

Estratégias de cache

Onde os caches vivem, cache-aside e os outros padrões, remoção, corridas de invalidação e como sobreviver a stampedes.

24 min de leitura

Um cache guarda uma cópia dos dados em algum lugar mais rápido ou mais próximo, para que a próxima requisição não repita um trabalho caro. É a forma mais barata de tornar um sistema mais rápido e a mais fácil de torná-lo errado: no dia em que você adiciona um cache, também adiciona uma segunda cópia da verdade, e as cópias se afastam uma da outra. Este guia cobre onde os caches vivem, os padrões para ler e escrever através deles, como mantê-los corretos e como eles falham.

1. Por que fazer cache, e o que colocar nele

Cache compensa quando três coisas valem ao mesmo tempo:

Se qualquer uma faltar, o cache rende pouco: resultados únicos nunca são reutilizados, trabalho barato não vale o salto extra, e dados que precisam ser exatos ao milissegundo (o saldo de uma conta durante uma transferência) não devem vir de uma cópia.

Os números que importam

Dois números descrevem um cache: a taxa de acerto (a parcela de requisições respondidas pelo cache) e o custo de um miss. Digamos que uma consulta ao cache leve 1 ms e o banco de dados leve 20 ms. Um miss custa os dois (você olha primeiro no cache), então 21 ms.

Taxa de acertoLatência médiaCarga no banco de dados
0 % (sem cache)20 ms100 %
90 %0,9 × 1 + 0,1 × 21 = 3,0 ms10 %
99 %0,99 × 1 + 0,01 × 21 = 1,2 ms1 %

Ir de 90 % para 99 % reduz a latência em 2,5 vezes (3,0 ms para 1,2 ms), mas o ganho maior é que a carga do banco de dados cai mais dez vezes. É por isso que a taxa de acerto é o primeiro número a acompanhar, e por que um cache que esfria (após uma reinicialização ou um deploy ruim) pode derrubar o banco de dados que está atrás dele.

2. Onde os caches vivem

As requisições passam por várias camadas, e cada uma pode guardar uma cópia. Quanto mais perto do usuário, mais rápido e mais difícil de invalidar.

Diagram: Layers of caching between a user and the data

Uma combinação comum e boa é um minúsculo cache em processo (segundos de vida) na frente do cache Redis compartilhado, para as poucas chaves mais quentes.

3. Ler e escrever: os cinco padrões

Esses nomes aparecem em toda discussão, então vale saber exatamente o que cada um faz.

PadrãoLeituraEscritaBom paraCuidado com
Cache-aside (lazy loading)O app consulta o cache; em um miss, carrega do banco de dados e preenche o cacheO app escreve no banco de dados e depois apaga a chave em cacheO padrão para a maioria dos appsDados desatualizados após corridas; um cache frio é lento
Read-throughIgual ao cache-aside, mas a biblioteca de cache carrega do banco de dados por conta própriaMuitas vezes combinado com write-throughCódigo de app mais simplesExige um cache que suporte loaders
Write-throughn/aA escrita vai ao cache, que escreve no banco de dados antes de responderDados lidos logo após serem escritosEscritas mais lentas; guarda em cache dados que talvez nunca sejam lidos
Write-behind (write-back)n/aA escrita vai ao cache; o banco de dados é atualizado depois, em lotesTaxas de escrita muito altas, contadoresPerda de dados se o cache morrer antes do flush
Write-aroundn/aA escrita vai direto ao banco de dados, pulando o cacheDados escritos uma vez e raramente lidosA primeira leitura após uma escrita é sempre um miss

Cache-aside, passo a passo

É o padrão para conhecer melhor, porque não exige nada do cache além de get, set e delete.

Diagram: Cache-aside: a miss, then a hit

A mesma função em quatro linguagens (escolha uma linguagem nas abas; sua escolha é lembrada). Note os detalhes: o limite de tempo tem uma parte aleatória (explicada na seção 6), um cache fora do ar não deve derrubar o app junto, em nenhum dos sentidos (um SET que falha e um DELETE que falha são ambos toleráveis), e a versão em Python também guarda "não encontrado" por pouco tempo, o que a seção 6 explica. As outras versões omitem isso para ficarem curtas.

import json
import logging
import random

from redis.exceptions import RedisError

log = logging.getLogger(__name__)
# r is a redis.Redis client created with decode_responses=True


def get_user(user_id):
    key = f"user:{user_id}"
    try:
        cached = r.get(key)
        if cached is not None:                       # "null" is a cached "not found"
            return json.loads(cached)
    except RedisError:
        pass                                         # the cache is down: carry on without it

    user = db.fetch_user(user_id)                    # a miss: read the source of truth
    # the random part spreads out expiry; "not found" is cached too, but only briefly
    ttl = 300 + random.randint(0, 60) if user is not None else 30
    try:
        r.set(key, json.dumps(user), ex=ttl)
    except RedisError:
        pass
    return user


def update_user(user_id, fields):
    db.update_user(user_id, fields)                  # write the database first
    try:
        r.delete(f"user:{user_id}")                  # then drop the cached copy
    except RedisError:
        # the write is done; the old copy lives until its TTL runs out, so log it and go on
        log.warning("could not invalidate user:%s", user_id)

func GetUser(ctx context.Context, id string) (*User, error) { key := "user:" + id s, err := rdb.Get(ctx, key).Result() if err == nil { var u User if json.Unmarshal([]byte(s), &u) == nil { return &u, nil } } // redis.Nil is a plain miss; any other error means the cache is down. // Either way, go on to the database.

u, err := db.FetchUser(ctx, id) // the source of truth if err != nil || u == nil { return u, err } if b, err := json.Marshal(u); err == nil { ttl := 300time.Second + time.Duration(rand.Intn(60))time.Second // random part spreads out expiry rdb.Set(ctx, key, b, ttl) // best effort } return u, nil }

func UpdateUser(ctx context.Context, id string, f Fields) error { if err := db.UpdateUser(ctx, id, f); err != nil { // write the database first return err } if err := rdb.Del(ctx, "user:"+id).Err(); err != nil { // then drop the cached copy // the write is done; the old copy lives until its TTL runs out, so log it and go on log.Printf("could not invalidate user:%s: %v", id, err) } return nil }

async function getUser(id) { const key = user:${id}; try { const cached = await redis.get(key); if (cached !== null) return JSON.parse(cached); } catch { // the cache is down: carry on without it }

const user = await db.fetchUser(id); // a miss: read the source of truth if (user) { const ttl = 300 + Math.floor(Math.random() * 60); // the random part spreads out expiry redis.set(key, JSON.stringify(user), "EX", ttl).catch(() => {}); } return user; }

async function updateUser(id, fields) { await db.updateUser(id, fields); // write the database first try { await redis.del(user:${id}); // then drop the cached copy } catch (err) { // the write is done; the old copy lives until its TTL runs out, so log it and go on console.warn(could not invalidate user:${id}, err); } }

public async Task<User?> GetUserAsync(string id) { var key = $"user:{id}"; try { var cached = await _redis.StringGetAsync(key); if (cached.HasValue) return JsonSerializer.Deserialize<User>((string)cached!); } catch (RedisException) { // the cache is down: carry on without it }

var user = await _db.FetchUserAsync(id); // a miss: read the source of truth if (user is not null) { var ttl = TimeSpan.FromSeconds(300 + Random.Shared.Next(0, 60)); // random part spreads out expiry _ = _redis.StringSetAsync(key, JsonSerializer.Serialize(user), ttl, flags: CommandFlags.FireAndForget); } return user; }

public async Task UpdateUserAsync(string id, Fields fields) { await _db.UpdateUserAsync(id, fields); // write the database first try { await _redis.KeyDeleteAsync($"user:{id}"); // then drop the cached copy } catch (RedisException e) { // the write is done; the old copy lives until its TTL runs out, so log it and go on _log.LogWarning(e, "Could not invalidate user:{Id}", id); } }


### Por que apagar na escrita, e não atualizar?

Em uma escrita, apague a chave em cache em vez de gravar nela o novo valor. Dois escritores que terminam em ordem diferente da que começaram deixariam o valor mais antigo no cache; um delete não pode deixar um valor errado para trás, apenas um espaço vazio que a próxima leitura preenche. Também poupa trabalho para dados que nunca mais são lidos. A seção 5 mostra a única corrida que apagar não resolve.

## 4. Remoção: o que jogar fora quando está cheio

Um cache tem memória fixa, então algo precisa sair quando ele enche. As políticas usuais:

- **LRU (least recently used):** remove o que não é tocado há mais tempo. Simples e um bom padrão, porque o uso recente prevê o uso futuro.
- **LFU (least frequently used):** remove o que é usado com menos frequência. Melhor quando poucos itens permanecem populares por muito tempo e uma varredura única (um crawler, um relatório grande) não deve expulsá-los.
- **FIFO e aleatório:** baratos e às vezes bons o bastante.
- **TTL (time to live):** não é uma política de remoção, mas um prazo em cada entrada. Limita o quanto um valor pode ficar desatualizado e se limpa sozinho.

Os trade-offs de cada política estão resumidos na Wikipedia [[7]](#fontes). O Redis deixa você escolher com `maxmemory-policy`: por exemplo `allkeys-lru`, `allkeys-lfu`, ou as versões `volatile-*` que só tocam chaves com TTL. O Redis não mantém uma lista LRU exata; ele amostra algumas chaves e remove o melhor candidato, o que é muito mais barato e próximo o suficiente do real [[3]](#fontes). A política padrão, `noeviction`, faz as escritas falharem quando a memória está cheia. Isso é certo para um banco de dados e errado para um cache, então defina-a deliberadamente.

Um pequeno LRU em Python mostra a ideia. Um dicionário que lembra a ordem de uso faz todo o trabalho:

from collections import OrderedDict

class LRU: def __init__(self, capacity): self.capacity = capacity self.items = OrderedDict()

def get(self, key): if key not in self.items: return None self.items.move_to_end(key) # now the most recently used return self.items[key]

def put(self, key, value): self.items[key] = value self.items.move_to_end(key) if len(self.items) > self.capacity: self.items.popitem(last=False) # drop the least recently used


## 5. Mantendo-se correto: invalidação

> Só existem duas coisas difíceis em ciência da computação: invalidação de cache e dar nomes às coisas. (Phil Karlton)

Há quatro formas de manter um cache honesto, e os sistemas reais as misturam.

1. **Limites de tempo (TTL).** Toda entrada expira após, digamos, 5 minutos. Nenhum código a escrever, e a defasagem é limitada. O preço: os usuários podem ver dados antigos por até um TTL inteiro.
2. **Invalidação explícita.** Quando os dados mudam, apague as chaves que os guardam. Fresco, mas você precisa encontrar toda chave afetada: o usuário, a lista em que o usuário aparece, a página que mostra a lista.
3. **Chaves versionadas.** Coloque uma versão na chave (`user:42:v7`). Uma mudança incrementa a versão, e as entradas antigas simplesmente nunca mais são lidas e envelhecem até sumir. Nada a apagar, e nenhuma corrida no delete.
4. **Orientada a eventos.** Mudanças no banco de dados publicam eventos (um change stream, ou o padrão outbox), e um consumidor apaga ou atualiza as chaves. Bom quando muitos escritores tocam os dados.

Combine sempre a invalidação explícita com um **TTL como rede de segurança**. Deletes ocasionalmente se perdem (uma queda entre a escrita no banco e o delete, uma falha de rede), e o TTL garante que um erro assim se corrija sozinho.

### A corrida que apagar não resolve

Até o cache-aside com delete na escrita tem uma brecha. Um leitor lento pode recolocar um valor antigo depois de o escritor ter invalidado:

%% title: A stale value written back after the delete sequenceDiagram participant A as Reader A participant C as Cache participant D as Database participant B as Writer B A->>C: GET (miss) A->>D: read, gets the OLD value B->>D: write the NEW value B->>C: DELETE the key A->>C: SET the OLD value Note over C: stale until the TTL runs out


Exige um leitor lento e uma escrita exatamente na brecha errada, então é rara, mas com tráfego suficiente acontece. Defesas, da simples à elaborada:

- **Um TTL curto.** O erro se cura sozinho.
- **Escritas versionadas.** Guarde a versão da linha junto com o valor e só aceite uma escrita no cache se sua versão não for mais antiga que a armazenada (por exemplo, com um pequeno script Lua no Redis).
- **Leases.** O memcache do Facebook descreve entregar ao leitor um token em um miss; um delete invalida o token, então o `SET` tardio é recusado [[4]](#fontes). O mesmo mecanismo também reduz stampedes.
- **Segundo delete atrasado.** Apague de novo um segundo ou mais depois da escrita, para eliminar um preenchimento tardio.

Decida quanta defasagem cada tipo de dado tolera, escreva isso e escolha a ferramenta mais barata que a atenda. A descrição de um produto pode ter cinco minutos. Um nível de estoque no checkout provavelmente não pode.

## 6. Como os caches falham

Quatro padrões de falha aparecem repetidamente em incidentes de cache. Todos tratam de muitas requisições chegando ao banco de dados ao mesmo tempo. (O artigo da AWS Builders' Library cobre terreno relacionado: caches frios, coalescência de requisições e cache de "não encontrado" [[6]](#fontes).)

### Stampede (thundering herd)

Uma entrada popular expira, e nos próximos milissegundos mil requisições erram o cache, e todas executam a consulta cara. O banco de dados, que estava seguro atrás do cache, recebe mil cópias do mesmo trabalho.

%% title: Without protection every waiting request runs the query sequenceDiagram participant R as Requests (1000) participant C as Cache participant D as Database R->>C: GET hot-key C-->>R: expired, miss (for all of them) R->>D: the same slow query, 1000 times


Defesas:

- **Single flight (coalescência de requisições).** Deixe a primeira requisição fazer o trabalho e faça as outras esperarem pela sua resposta. Uma consulta em vez de mil. Esta é a melhor primeira correção, e cabe em poucas linhas:

import threading

class SingleFlight: def __init__(self): self.lock = threading.Lock() self.calls = {} # key -> the call in progress

def do(self, key, fn): with self.lock: call = self.calls.get(key) leader = call is None if leader: call = self.calls[key] = {"done": threading.Event(), "value": None, "error": None} if leader: try: call["value"] = fn() # only the first caller does the work except Exception as e: call["error"] = e finally: with self.lock: del self.calls[key] call["done"].set() # wake everyone who waited else: call["done"].wait() if call["error"]: raise call["error"] return call["value"]

import "golang.org/x/sync/singleflight"

var group singleflight.Group

func LoadUser(ctx context.Context, id string) (User, error) { v, err, _ := group.Do("user:"+id, func() (any, error) { return db.FetchUser(ctx, id) // one call per key at a time; the rest share its result }) if err != nil { return nil, err } return v.(User), nil }

const inflight = new Map();

function singleFlight(key, load) { let promise = inflight.get(key); if (!promise) { promise = load().finally(() => inflight.delete(key)); // the first caller starts the work inflight.set(key, promise); } return promise; // everyone else shares the same promise }

private readonly ConcurrentDictionary<string, Lazy<Task<User?>>> _inflight = new();

public async Task<User?> LoadUserAsync(string id) { var key = "user:" + id; // Lazy makes sure the loader starts only once, even if two threads race to add it var call = _inflight.GetOrAdd(key, _ => new Lazy<Task<User?>>(() => _db.FetchUserAsync(id))); try { return await call.Value; // everyone shares the same task } finally { _inflight.TryRemove(new KeyValuePair<string, Lazy<Task<User?>>>(key, call)); } }


Isso funciona dentro de um processo. Com muitos servidores, você ainda tem uma consulta por servidor; isso costuma ser aceitável. Para uma consulta global, pegue um lock curto no Redis (`SET key token NX PX 5000`) e deixe os perdedores esperarem brevemente ou servirem um valor ligeiramente desatualizado.

- **Sirva o antigo enquanto atualiza.** Mantenha o valor expirado por um pouco mais de tempo e responda com ele enquanto uma requisição o atualiza em segundo plano (`stale-while-revalidate` [[2]](#fontes)). Os usuários nunca esperam.
- **Atualize cedo, de forma aleatória.** O algoritmo XFetch permite que cada requisição decida, com uma probabilidade que cresce conforme a expiração se aproxima, recalcular antes da hora. As chaves quentes são renovadas antes de chegarem a expirar, sem coordenação [[5]](#fontes):

De onde vem o tempo de recálculo? Você o mede e o guarda junto com o valor: ao carregar do banco de dados, cronometre a chamada e salve `{"value": ..., "delta": seconds_it_took, "expiry": unix_time}` na entrada do cache. Cada leitor então pergunta:

import math import random import time

def should_refresh_early(entry, beta=1.0):

log(random) is negative, so this moves "now" forward by a random amount,

larger when the last recompute (entry["delta"]) was slow

return time.time() - entry["delta"] * beta * math.log(random.random()) >= entry["expiry"]


Com um recálculo de 2 segundos, um leitor tem cerca de 1 % de chance de atualizar antecipadamente 10 segundos antes da expiração, 13 % aos 4 segundos, 61 % a 1 segundo, e certeza na expiração. Cálculos lentos começam mais cedo; os rápidos quase nada. Um `beta` acima de 1 atualiza mais cedo.

### Avalanche

Muitas chaves expiram no mesmo instante, porque foram todas preenchidas juntas (após uma reinicialização ou uma carga em massa) com o mesmo TTL. O cache esvazia de uma só vez e o banco de dados recebe tudo. **Adicione uma parte aleatória a todo TTL** (como no código acima) e aqueça o cache gradualmente após uma reinicialização.

### Penetração

Requisições pedem chaves que não existem (ids aleatórios de um bot, ou um bug). Elas sempre erram, então cada uma vai ao banco de dados, e o cache nunca se preenche. Correções: guardar a resposta "não encontrado" por pouco tempo (30-60 segundos), validar ids antes da busca, ou colocar na frente um Bloom filter de ids válidos.

### Hot key

Uma chave recebe tantas requisições que um único nó de cache não consegue atendê-la, mesmo com uma taxa de acerto perfeita. Correções: um cache em processo em cada servidor de aplicação para as chaves mais quentes, ou dividir a chave em várias cópias (`hot:1` ... `hot:8`) e ler uma aleatória.

## 7. Respostas personalizadas e caches compartilhados

Um cache compartilhado (uma CDN, um proxy reverso, ou um Redis para todos os usuários) dá a mesma resposta armazenada a todos que pedem a mesma chave. Esse é o objetivo, e também o perigo: **se a chave não inclui tudo de que a resposta depende, os dados de uma pessoa vão para outra.**

- **Coloque toda entrada na chave.** Usuário ou tenant, idioma, moeda, feature flags, classe de dispositivo. `GET /account` armazenado sob a chave `/account` é um vazamento esperando para acontecer.
- **Marque as respostas HTTP com honestidade.** `Cache-Control: private` significa "somente o navegador do próprio usuário pode guardar isto"; `no-store` significa "não guarde em lugar nenhum"; `public` permite caches compartilhados. Use `private` ou `no-store` para qualquer coisa pessoal e tenha cuidado com CDNs que fazem cache por padrão [[1]](#fontes).
- **Use `Vary` quando a mesma URL dá respostas diferentes** conforme um header da requisição (`Vary: Accept-Language`, `Vary: Accept-Encoding`). Um `Vary` ausente serve a página em inglês ao leitor francês. Nunca use `Vary` em `Cookie` para uma CDN, a menos que aceite quase nenhum compartilhamento.
- **Não guarde em cache compartilhado respostas que definem cookies ou tokens.**
- **Faça cache da parte compartilhada, não da pessoal:** a página do produto é guardada para todos, e o fragmento "olá, Ana" é carregado separadamente.

## 8. Réplicas e caches em muitos servidores

### Ler a própria escrita

Um usuário salva um perfil e recarrega. Se as leituras vêm de uma réplica com um segundo de atraso, ele vê o perfil antigo, e o cache-aside piora: o miss preenche o cache **a partir da réplica atrasada**, então o valor antigo é armazenado e servido a todos até o TTL acabar. Defesas:

- **Leia do primário por um curto período após uma escrita** (alguns segundos, lembrado por usuário em um cookie ou na sessão), ou para as leituras que mais importam.
- **Preencha o cache somente a partir do primário** para dados em que a defasagem não é aceitável.
- **Grave o novo valor no cache** com o número de versão da escrita (escritas versionadas, seção 5) para as páginas que o escritor está prestes a ver.

### Caches em processo em muitos servidores

Um delete no Redis alcança todos. Um delete na memória de um servidor não alcança mais ninguém, então os outros servidores mantêm o valor antigo. As opções, da simples à complicada:

- **Um TTL muito curto** (1 a 10 segundos). A defasagem é limitada e não há nada a coordenar. Esta é a resposta padrão para chaves quentes.
- **Invalidações por broadcast.** Em uma escrita, publique a chave no pub/sub do Redis (ou em um barramento de mensagens); cada servidor se inscreve e descarta sua cópia local. Mensagens podem se perder quando um servidor reconecta, então mantenha também o TTL curto.
- **Números de versão nas chaves.** Mantenha um pequeno valor de "versão" por entidade no Redis e inclua-o na chave local; uma mudança incrementa a versão e as entradas locais antigas simplesmente nunca mais são acessadas.

## 9. Escolhendo um TTL e um tamanho

- **TTL:** parta do que o negócio aceita. Segundos para dados que mudam rápido, minutos para conteúdo típico, horas ou dias para coisas que quase nunca mudam. Adicione a parte aleatória. Se você também usa invalidação explícita, o TTL pode ser generoso.
- **Tamanho:** meça a taxa de acerto contra o tamanho do cache. Ela sobe de forma íngreme no começo e depois se achata: os primeiros por cento dos dados muitas vezes atendem a maioria das requisições. Pare de aumentar o cache quando mais memória compra pouco. Um exemplo prático: 10 milhões de usuários com um perfil de 2 KB em cache dão 20 GB se você guardar todo mundo. Se os 20 % de usuários mais quentes fazem a maioria das requisições, guardá-los leva cerca de 4 GB. Some o overhead por chave do próprio cache (dezenas de bytes por chave no Redis; meça com `MEMORY USAGE`) e deixe folga, porque um cache cheio remove ou falha. A 20 000 requisições por segundo e uma taxa de acerto de 95 %, o banco de dados vê cerca de 1 000 por segundo.
- **O que armazenar:** a menor coisa que poupa o trabalho. Guarde o resultado pronto (o fragmento renderizado ou o JSON), não as linhas cruas que você ainda teria de montar.
- **Serialização:** formatos compactos e compressão importam quando milhões de chaves são armazenadas; meça os bytes por chave.

## 10. Testando um cache

- **Hit, miss, fill:** a primeira chamada vai ao banco de dados, a segunda não.
- **Invalidação:** depois de `update_user`, a próxima leitura retorna os dados novos.
- **O cache está fora do ar:** pare o Redis no teste (ou aponte para uma porta fechada) e verifique que as leituras ainda funcionam e que uma escrita não falha.
- **Stampede:** inicie 50 chamadas concorrentes para uma chave ausente e conte as chamadas ao banco de dados. Com single flight, deve ser uma.
- **TTL e jitter:** muitos preenchimentos produzem tempos de expiração dentro da faixa esperada, e não todos iguais.
- **Não encontrado:** uma chave ausente é guardada por pouco tempo, e o banco de dados é consultado uma vez.
- **Isolamento de usuários:** dois usuários pedindo "a sua" página recebem duas respostas diferentes (o teste de vazamento da seção 7).
- **Partida a frio:** um teste de carga com cache vazio. O banco de dados sobrevive ao primeiro minuto?

Execute isso contra um Redis real (um contêiner descartável), não um mock: as falhas interessantes estão em expiração, timeouts e remoção, que um mock não reproduz.

## 11. O que medir

- **Taxa de acerto,** por cache e por prefixo de chave. Uma queda repentina significa que um deploy mudou as chaves, um precipício de expiração ou um ataque.
- **Latência** das chamadas ao cache, com timeouts curtos. Um cache lento é pior que nenhum cache, então desista rápido e use o banco de dados.
- **Remoções por segundo.** Um fluxo constante significa que o cache é pequeno demais.
- **Uso de memória e contagem de chaves,** e quantas chaves não têm TTL (são as que ficam para sempre).
- **Carga do banco de dados,** o número que o cache existe para proteger.

## 12. Coisas a mencionar em uma entrevista

- Diga por que você faz cache (muita leitura, trabalho caro, tolerância à defasagem) e cite a taxa de acerto.
- Descreva o cache-aside primeiro, depois diga quando escolheria write-through ou write-behind e o que cada um arrisca.
- Nomeie as camadas: navegador, CDN, em processo, distribuído.
- Explique a invalidação com honestidade: TTL como rede de segurança, delete na escrita e a corrida que não dá para eliminar por completo.
- Cubra stampede, avalanche, penetração e hot keys com uma correção para cada.
- Mencione dados pessoais em caches compartilhados e réplicas que preenchem o cache com dados antigos.
- Diga que o cache precisa ser opcional: se ele falha, o sistema fica mais lento, não errado.

## Resumo rápido

1. Um cache vale a pena quando o trabalho é caro, repetido e pode ficar um pouco desatualizado.
2. A taxa de acerto decide tudo: 90 % reduz a carga do banco de dados dez vezes, 99 % cem vezes.
3. Use cache-aside como padrão: leia o cache, recorra ao banco de dados, preencha e apague na escrita.
4. Sempre defina um TTL, com uma parte aleatória.
5. Planeje stampedes com single flight, stale-while-revalidate ou atualização antecipada.
6. Guarde "não encontrado" por pouco tempo e fique atento a hot keys.
7. Meça taxa de acerto, latência e remoções, e trate o cache como opcional.

## Fontes

1. IETF, [RFC 9111: HTTP Caching](https://www.rfc-editor.org/rfc/rfc9111).
2. IETF, [RFC 5861: HTTP Cache-Control Extensions for Stale Content](https://www.rfc-editor.org/rfc/rfc5861). `stale-while-revalidate` e `stale-if-error`.
3. Documentação do Redis, [Key eviction](https://redis.io/docs/latest/develop/reference/eviction/). As políticas, e o LRU e LFU aproximados.
4. Nishtala et al., [Scaling Memcache at Facebook](https://www.usenix.org/conference/nsdi13/technical-sessions/presentation/nishtala), NSDI 2013. Leases contra sets desatualizados e thundering herds.
5. Vattani, Chierichetti e Lowenstein, [Optimal Probabilistic Cache Stampede Prevention](https://www.vldb.org/pvldb/volumes/8/paper/Optimal%20Probabilistic%20Cache%20Stampede%20Prevention), VLDB 2015. O algoritmo XFetch.
6. Amazon Builders' Library, [Caching challenges and strategies](https://aws.amazon.com/builders-library/caching-challenges-and-strategies/).
7. Wikipedia, [Cache stampede](https://en.wikipedia.org/wiki/Cache_stampede) e [Cache replacement policies](https://en.wikipedia.org/wiki/Cache_replacement_policies).

Pratique este tema: System Design System Design › Reliability and scale

Mais guias