Comment Redis est-il utilisé comme cache ?

Question

Accepted Answer

**La mise en cache** est le cas d'usage le plus courant de Redis — stocker les données fréquemment accédées dans une mémoire rapide pour que les applications évitent des opérations plus lentes (requêtes de base de données, appels API, calculs). Comprendre le motif de mise en cache basique est une connaissance essentielle au quotidien.

## Le motif cache-aside (le plus courant)

```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;
}
```

L'application vérifie d'abord Redis ; en cas d'absence, elle récupère la source, met en cache le résultat (avec un TTL), et le retourne. Les requêtes ultérieures sont des accès rapides au cache.

## Pourquoi la mise en cache aide

```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.
```

## Invalidation du cache (la partie difficile)

```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."
```

## Pourquoi c'est important

Utiliser Redis comme cache est son application la plus courante et la plus impactante, donc comprendre le motif de mise en cache basique est une connaissance essentielle et largement applicable pour construire des applications performantes.

La technique fondamentale — stocker les données fréquemment accédées dans la mémoire rapide de Redis pour que l'application évite des opérations plus lentes (requêtes de base de données, appels API, calculs onéreux) — est l'un des moyens les plus efficaces d'améliorer les performances et la scalabilité, utilisé dans un grand nombre de systèmes en production.

Comprendre le **motif cache-aside** (vérifier d'abord Redis ; en cas d'accès retourner immédiatement ; en cas d'absence récupérer de la source, mettre en cache le résultat avec un TTL, et le retourner) est la technique de mise en cache fondamentale que chaque développeur devrait connaître — c'est ainsi que la plupart de la mise en cache est implémentée.

Comprendre **pourquoi la mise en cache aide** (Redis en mémoire est beaucoup plus rapide que les bases de données sur disque ou les API externes, et la mise en cache réduit la charge sur la base de données pour qu'elle se scale mieux) explique le double avantage de la vitesse et de la réduction de la charge sur le backend.

De manière critique, comprendre **l'invalidation du cache** — le fameux « problème difficile » de garder les données en cache à jour, résolu par les TTLs (expiration automatique) et l'invalidation explicite (suppression/mise à jour du cache quand les données sources changent) — est essentiel car les données obsolètes sont le principal piège de la mise en cache, et la gérer correctement est ce qui distingue les caches fonctionnels des caches subtilement bogués.

Puisque la mise en cache est le cas d'usage dominant de Redis et l'une des techniques de performance les plus importantes en logiciels, et puisque le motif cache-aside (avec l'invalidation appropriée) est la façon fondamentale de le faire, comprendre comment Redis est utilisé comme cache — le motif, ses avantages, et le défi d'invalidation — est une connaissance essentielle et fréquemment appliquée pour construire des applications rapides et scalables, probablement la compétence Redis pratique la plus importante.