Como o Redis é usado como cache?

Question

Accepted Answer

**Caching** é o caso de uso mais comum do Redis — armazenar dados frequentemente acessados em memória rápida para que aplicações evitem operações mais lentas (queries de banco de dados, chamadas de API, computações). Entender o padrão básico de caching é conhecimento essencial do dia a dia.

## O padrão cache-aside (mais comum)

```text
1. App needs data → CHECK Redis first (cache lookup)
2. CACHE HIT (found) → return it immediately (fast!) ✓
3. CACHE MISS (not found) → query the database, store the result in Redis (with TTL),
   then return it. Next time it'll be a hit.
```

```js
async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // CACHE HIT — fast, skip the DB

const user = await db.users.findById(id);        // CACHE MISS — query the DB
  await redis.set(`user:${id}`, JSON.stringify(user), "EX", 3600);  // cache it (1h TTL)
  return user;
}
```

A app verifica o Redis primeiro; em caso de miss, ela busca da origem, faz cache do resultado (com TTL), e o retorna. Requisições subsequentes são cache hits rápidos.

## Por que caching ajuda

```text
✓ SPEED — Redis (in-memory) is far faster than a database (disk) or external API
✓ REDUCED LOAD — fewer queries hit the database (it handles less, scales better)
✓ Result: faster responses, lower database load, better scalability
→ Caching is one of the most effective ways to improve application performance.
```

## Invalidação de cache (a parte difícil)

```js
// when data changes, the cache must be updated or removed (else it's STALE)
async function updateUser(id, data) {
  await db.users.update(id, data);
  await redis.del(`user:${id}`);    // INVALIDATE the cache (next read re-fetches fresh)
}
```

```text
Stale data is the main caching challenge:
  → Use TTLs (data auto-expires, eventually refreshing)
  → Invalidate (delete/update the cache) when the source data changes
  → "There are only two hard things: cache invalidation and naming things."
```

## Por que isso importa

Usar Redis como cache é sua aplicação mais comum e impactante, então entender o padrão básico de caching é conhecimento essencial e amplamente aplicável para construir aplicações performáticas.

A técnica central — armazenar dados frequentemente acessados na memória rápida do Redis para que a aplicação evite operações mais lentas (queries de banco de dados, chamadas de API, computações caras) — é uma das formas mais efetivas de melhorar performance e escalabilidade, usada em um número vasto de sistemas em produção.

Entender o **padrão cache-aside** (verificar o Redis primeiro; em caso de hit retornar imediatamente; em caso de miss buscar da origem, fazer cache do resultado com TTL, e retorná-lo) é a técnica fundamental de caching que todo desenvolvedor deve conhecer — é assim que a maioria do caching é implementado.

Entender **por que caching ajuda** (Redis em memória é muito mais rápido que bancos de dados em disco ou APIs externas, e caching reduz carga no banco de dados para que escale melhor) explica o benefício duplo de velocidade e redução de carga no backend.

Criticamente, entender **invalidação de cache** — o famoso "problema difícil" de manter dados em cache de ficar obsoletos, endereçado por TTLs (expiração automática) e invalidação explícita (deletar/atualizar o cache quando dados da origem mudam) — é essencial porque dados obsoletos são o principal problema de caching, e gerenciá-lo corretamente é o que diferencia caches funcionando de sutilmente bugados.

Já que caching é o caso de uso dominante do Redis e uma das técnicas de performance mais importantes em software, e já que o padrão cache-aside (com invalidação apropriada) é a forma fundamental de como é feito, entender como o Redis é usado como cache — o padrão, seus benefícios, e o desafio de invalidação — é conhecimento essencial e frequentemente aplicado para construir aplicações rápidas e escaláveis, argumentavelmente a habilidade mais importante e prática com Redis.