Quelles stratégies et patterns de cache existent avec Redis?

Question

Accepted Answer

Au-delà du pattern cache-aside basique, il existe plusieurs **stratégies de cache** — cache-aside, write-through, write-behind, read-through — chacune avec des compromis différents en termes de cohérence et de performance. Les comprendre (ainsi que les politiques d'éviction) vous aide à concevoir un caching efficace.

## Cache-aside (chargement paresseux — le plus courant)

```text
App checks cache → miss → load from DB → populate cache → return.
  ✓ Only requested data is cached (efficient); resilient (works if cache is down)
  ✗ First request is a miss (slower); cache can be stale until TTL/invalidation
→ The default, most common strategy.
```

## Write-through et write-behind

```text
WRITE-THROUGH → write to cache AND DB together (synchronously) on every write
  ✓ Cache always fresh/consistent  ✗ Writes are slower (two writes); caches unread data

WRITE-BEHIND (write-back) → write to cache immediately, write to DB ASYNC later
  ✓ Fast writes  ✗ Risk of data loss if cache fails before the DB write; more complex
```

## Read-through

```text
READ-THROUGH → the cache layer itself loads from the DB on a miss (abstracted)
  → app just reads from the cache; the cache handles DB loading transparently
  (similar to cache-aside but the loading logic lives in the cache layer/library)
```

## Politiques d'éviction (quand la mémoire est pleine)

```text
When Redis hits its memory limit (maxmemory), it EVICTS keys per a policy:
  LRU (Least Recently Used)  → evict least-recently-accessed (good general default)
  LFU (Least Frequently Used)→ evict least-frequently-accessed
  TTL-based (volatile-ttl)   → evict keys closest to expiry
  random / noeviction        → random, or reject writes when full
→ allkeys-lru is a common choice for a pure cache. Set maxmemory + a policy.
```

## Éviter les problèmes de cache

```text
✓ Cache STAMPEDE (many misses at once hammering the DB) → locking, staggered TTLs
✓ Stale data → appropriate TTLs + invalidation on writes
✓ Cache PENETRATION (querying non-existent keys) → cache negative results briefly
```

## Pourquoi c'est important

Comprendre les stratégies de cache est précieux pour **concevoir des systèmes de cache efficaces**, en s'appuyant sur le cache-aside basique, c'est donc une connaissance utile pour le travail axé sur la performance.

Bien que le cache-aside (chargement paresseux — vérifier le cache, charger depuis la DB en cas de miss, remplir le cache) soit le pattern courant par défaut, comprendre la **gamme de stratégies** vous permet de choisir la bonne selon la situation : **write-through** (écrire simultanément dans le cache et la DB pour un cache toujours frais au prix d'écritures plus lentes), **write-behind** (écrire immédiatement dans le cache et la DB de manière asynchrone pour des écritures rapides mais avec risque de perte de données), et **read-through** (la couche cache charge transparemment depuis la DB) — chacune avec des compromis distincts cohérence/performance qui importent pour différentes exigences de cohérence et de pattern d'écriture.

Comprendre les **politiques d'éviction** (LRU, LFU, basées sur TTL, etc. — comment Redis décide quelles clés supprimer quand la mémoire est pleine) est important pour configurer correctement Redis en tant que cache (en définissant `maxmemory` et une politique appropriée comme `allkeys-lru` pour un cache pur), afin qu'il se comporte bien sous pression mémoire.

Savoir comment **éviter les problèmes courants de cache** — le **stampede** de cache (de nombreux miss simultanés submergeant la base de données, atténué par le verrouillage ou les TTL échelonnés), les **données obsolètes** (gérées avec des TTL et l'invalidation), et la **pénétration du cache** (requêtes répétées pour des clés inexistantes, atténuées en cachant les résultats négatifs) — reflète une conception mature du cache qui évite les vrais problèmes de production.

Puisqu'un caching efficace impacte significativement les performances et que la bonne stratégie/configuration dépend du cas d'usage, et puisque comprendre les stratégies, les politiques d'éviction et les pièges courants permet de concevoir un caching robuste, comprendre les stratégies et patterns de cache est une connaissance précieuse et pratiquement pertinente pour l'ingénierie des performances avec Redis, faisant évoluer le cache du pattern basique vers des systèmes bien conçus qui gèrent correctement la cohérence, la mémoire et les modes de défaillance.