Un utilisateur met à jour son profil, rafraîchit la page, et voit toujours l'ancienne valeur. L'équipe vérifie la base de données : la donnée est correcte. Le bug n'est pas dans l'écriture, il est dans le cache Redis qui a continué à servir l'ancienne valeur après la mise à jour. C'est le problème le plus fréquent avec le cache : pas sa présence, mais le moment exact où il faut le vider, et c'est précisément le point que la plupart des implémentations bâclent.

Les trois stratégies de base et quand les choisir

Cache-aside (lazy loading)

La stratégie la plus courante : l'application lit le cache, et si l'entrée est absente, lit la base puis remplit le cache.

async function getProduct(productId) {
  const cacheKey = `product:${productId}`;
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  const product = await db.query('SELECT * FROM products WHERE id = $1', [productId]);
  await redis.set(cacheKey, JSON.stringify(product), 'EX', 300);
  return product;
}

Simple, résilient (une panne Redis dégrade les performances mais ne casse pas la lecture, puisque le code retombe sur la base), mais la première requête après une expiration subit toujours la latence complète de la base de données. Sur un cache à fort trafic, une expiration simultanée de clés très demandées (par exemple toutes les clés posées à la même heure avec le même TTL) provoque une ruée de requêtes identiques vers la base au même instant : c'est le "thundering herd" ou effet de troupeau.

Write-through

L'écriture met à jour le cache et la base dans la même opération, avant de considérer l'écriture comme terminée.

async function updateProduct(productId, data) {
  const product = await db.query(
    'UPDATE products SET name = $1, price = $2 WHERE id = $3 RETURNING *',
    [data.name, data.price, productId]
  );
  await redis.set(`product:${productId}`, JSON.stringify(product), 'EX', 300);
  return product;
}

Le cache est toujours cohérent avec la base immédiatement après une écriture, ce qui élimine la classe de bug où l'utilisateur voit une donnée périmée juste après sa propre action. Le coût : chaque écriture devient plus lente (deux opérations au lieu d'une) et la logique d'écriture doit connaître la forme exacte de ce qui est mis en cache, ce qui couple le code métier au cache plus fortement que le cache-aside.

Write-behind (write-back)

L'écriture va d'abord dans le cache, et la synchronisation vers la base se fait de façon asynchrone. C'est rarement justifié pour des données métier critiques (le risque de perte en cas de panne avant synchronisation est réel), mais pertinent pour des compteurs à très fort débit (vues de page, likes) où une perte occasionnelle est acceptable en échange d'un débit d'écriture bien supérieur.

Le vrai problème : invalider au bon moment, pas juste expirer

Un TTL court (30 secondes, une minute) masque beaucoup de bugs d'invalidation en limitant la fenêtre pendant laquelle une donnée périmée peut être servie. C'est un pansement, pas une solution : il déplace un bug de correction en un bug de latence occasionnelle, et il ne protège pas contre le cas où l'utilisateur rafraîchit la page dans la seconde qui suit sa propre modification.

Invalidation directe sur écriture

La version minimale consiste à supprimer la clé affectée immédiatement après l'écriture en base :

async function updateProduct(productId, data) {
  const product = await db.query(
    'UPDATE products SET name = $1, price = $2 WHERE id = $3 RETURNING *',
    [data.name, data.price, productId]
  );
  await redis.del(`product:${productId}`);
  return product;
}

Ça fonctionne bien pour une clé isolée, mais échoue dès qu'une donnée est cachée sous plusieurs clés différentes : la fiche produit en cache sous product:42, mais aussi dans une liste cachée sous category:5:products, et dans un résultat de recherche caché sous search:query_hash. Oublier une de ces clés est le piège le plus courant du cache en production : chaque nouvel endroit où la donnée est dénormalisée dans le cache est un nouvel endroit où l'invalidation peut être oubliée.

Invalidation par tags

Pour éviter de traquer manuellement toutes les clés dérivées, une stratégie consiste à associer chaque entrée de cache à un ou plusieurs tags, stockés dans un SET Redis, et à invalider par tag plutôt que par clé individuelle :

async function cacheWithTags(key, value, tags, ttl) {
  await redis.set(key, JSON.stringify(value), 'EX', ttl);
  for (const tag of tags) {
    await redis.sadd(`tag:${tag}`, key);
    await redis.expire(`tag:${tag}`, ttl + 60);
  }
}

async function invalidateTag(tag) {
  const keys = await redis.smembers(`tag:${tag}`);
  if (keys.length > 0) {
    await redis.del(...keys, `tag:${tag}`);
  }
}

// à l'écriture d'un produit
await cacheWithTags(`product:${id}`, product, [`product:${id}`, `category:${product.categoryId}`], 300);

// à la mise à jour de la catégorie 5
await invalidateTag('category:5');

Cette approche centralise la logique d'invalidation autour du modèle de données plutôt qu'autour de chaque endpoint, ce qui réduit le risque d'oubli, au prix d'une structure Redis légèrement plus complexe à maintenir et d'un SMEMBERS qui peut devenir coûteux si un tag regroupe des milliers de clés.

Le cache qui ment : race condition entre lecture et écriture

Un cas plus subtil que l'oubli d'invalidation : la race condition entre une lecture en cache-aside et une écriture concurrente. Si un thread A lit la base (donnée périmée, avant la mise à jour), et qu'entre sa lecture et son SET dans le cache, un thread B met à jour la base et invalide le cache, le SET du thread A écrase l'invalidation avec la donnée périmée qu'il avait lue avant la mise à jour.

T1: A lit la base -> valeur = "ancien prix"
T2: B met à jour la base -> valeur = "nouveau prix"
T3: B invalide le cache (DEL)
T4: A écrit dans le cache -> "ancien prix" (périmé, mais vient d'être écrit après le DEL)

Le cache contient alors durablement la valeur périmée jusqu'à la prochaine expiration du TTL. C'est ce qu'on appelle le cache qui ment : il ne renvoie pas une erreur, il renvoie une valeur plausible mais fausse, ce qui rend le bug particulièrement difficile à détecter en test. La protection courante est d'associer chaque entrée cachée à une version ou à un timestamp, et de refuser d'écrire dans le cache une valeur plus ancienne que celle qui y est déjà :

async function setIfNewer(key, value, version, ttl) {
  const script = `
    local current = redis.call('GET', KEYS[1])
    if current then
      local decoded = cjson.decode(current)
      if decoded.version >= tonumber(ARGV[2]) then
        return 0
      end
    end
    redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[3])
    return 1
  `;
  return redis.eval(script, 1, key, JSON.stringify({ value, version }), version, ttl);
}

L'exécution via un script Lua garantit l'atomicité de la vérification et de l'écriture côté Redis, ce qu'un GET puis SET séparés en JavaScript ne peuvent pas garantir sous charge concurrente.

Quand la solution facile ne suffit plus

Pour un système avec plusieurs instances de l'application et un cache partagé, invalider une clé localement ne suffit jamais : l'invalidation doit passer par Redis lui-même, jamais par un cache en mémoire locale à l'instance, sous peine d'incohérence entre instances. Pour des besoins d'invalidation très fins à grande échelle (des millions de clés dérivées d'une même entité), les tags Redis maison montrent leurs limites et une solution dédiée comme un cache applicatif avec invalidation par événements (CDC depuis la base, publication sur un bus de messages, consommation par les instances de cache) devient plus robuste qu'un SMEMBERS qui grossit indéfiniment.

À retenir

Un TTL court masque les bugs d'invalidation, il ne les corrige pas : la vraie question est de savoir exactement quelles clés dérivées invalider à chaque écriture, pas seulement la clé évidente. Les tags centralisent cette logique mais ont un coût de maintenance ; dans tous les cas, une race condition entre lecture et écriture concurrentes peut faire persister une valeur périmée bien après l'invalidation, et seule une vérification de version atomique (script Lua) protège réellement contre ce cas.