0Pricing
Redis Caching & Messaging (Pub/Sub, Streams) · Leçon

Stratégies d’invalidation du cache

Apprenez à conserver des données en cache à jour et cohérentes grâce aux TTL, à l’écriture immédiate, à l’écriture différée et à l’invalidation pilotée par les événements dans Redis.

Stratégies d’invalidation du cache est une leçon Redis Caching & Messaging (Pub/Sub, Streams) gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Redis Caching & Messaging (Pub/Sub, Streams), et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Redis Caching & Messaging (Pub/Sub, Streams) comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Why Invalidation Matters

Caching speeds up reads, but a cache that serves stale data can be worse than no cache at all. Cache invalidation is the discipline of removing or refreshing entries when the underlying source of truth changes.

It is famously hard: there are only two hard things in computer science, and one of them is cache invalidation.

TTL-Based Expiry

The simplest strategy is time-to-live. You accept that data may be stale for at most N seconds.

  • SET key value EX 60 expires after 60 seconds
  • EXPIRE key 60 sets a TTL on an existing key
  • TTL key shows remaining seconds
SET user:42:profile "...json..." EX 60
TTL user:42:profile
EXPIRE user:42:profile 120

Write-Through Caching

In write-through caching, every write goes to both the database and the cache in the same operation. Reads are always fresh, at the cost of slower writes.

The application is responsible for keeping the two in lockstep.

def save_user(user):
    db.update(user)
    redis.set('user:' + user.id, serialize(user))
    return user

Write-Behind Caching

Write-behind (write-back) writes to the cache first and flushes to the database asynchronously. Writes are fast, but you risk data loss if Redis goes down before the flush.

Use a queue or stream to buffer pending writes.

redis.set('order:' + id, data)
redis.lpush('pending_writes', id)

Explicit Deletion on Update

The cache-aside + delete pattern: on every update to the database, delete the cached key. The next read repopulates it.

This avoids serving stale data and is simpler than keeping the cache value in sync.

def update_product(p):
    db.update(p)
    redis.delete('product:' + p.id)

Why Delete Beats Update

Deleting the key (instead of overwriting it) avoids a race condition: two concurrent updates could otherwise write values in the wrong order. With deletion, the next read always pulls the latest from the source of truth.

Versioned Keys

Instead of invalidating, bump a version number embedded in the key. Old keys expire naturally via TTL while new reads use the new key.

INCR config:version
GET config:version
SET config:v7:settings "..."

Event-Driven Invalidation

Publish an invalidation event whenever data changes. Other application nodes subscribe and clear their local caches. This pairs Redis Pub/Sub with caching.

redis.publish('invalidate', 'user:42')
# subscribers:
redis.subscribe('invalidate')

Tag-Based Invalidation

Group related keys under a tag set. When a tag becomes invalid, delete all member keys in one sweep.

  • SADD tag:user:42 product:1 product:2
  • On change: SMEMBERS tag:user:42 then DEL each
SADD tag:user:42 cart:42 wishlist:42
SMEMBERS tag:user:42

Avoiding Stampedes

When a hot key expires, many requests may hit the database at once (a cache stampede). Mitigate with a short lock, probabilistic early expiry, or serving slightly stale data while one worker refreshes.

SET lock:user:42 1 NX EX 5

Choosing a Strategy

There is no single best approach:

  • TTL for tolerable staleness
  • Delete-on-write for correctness
  • Event-driven for multi-node consistency
  • Versioning for bulk config changes

Quick Check

Test your understanding of invalidation strategies.

Recap

You learned the major cache invalidation strategies: TTL expiry, write-through, write-behind, delete-on-write, versioned keys, event-driven, and tag-based invalidation, plus how to avoid cache stampedes. Pick the strategy that matches your tolerance for staleness and your consistency needs.

Questions Fréquemment Posées

La leçon « Stratégies d’invalidation du cache » est-elle gratuite ?

Oui — le texte complet de « Stratégies d’invalidation du cache » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Redis Caching & Messaging (Pub/Sub, Streams), passe à CoddyKit PRO. Le cours Redis Caching & Messaging (Pub/Sub, Streams) comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Stratégies d’invalidation du cache » ?

Apprenez à conserver des données en cache à jour et cohérentes grâce aux TTL, à l’écriture immédiate, à l’écriture différée et à l’invalidation pilotée par les événements dans Redis. Tu pratiques Redis Caching & Messaging (Pub/Sub, Streams) avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Redis Caching & Messaging (Pub/Sub, Streams) ?

Aucune expérience préalable n'est requise. Redis Caching & Messaging (Pub/Sub, Streams) sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Stratégies d’invalidation du cache » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Redis Caching & Messaging (Pub/Sub, Streams) ?

Oui. Chaque leçon Redis Caching & Messaging (Pub/Sub, Streams) inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Modèles de cache avancés
  2. Gestion des sessions avec Redis
  3. Limitation du débit et anti-modèles
  4. Stratégies d’invalidation du cache
← Retour à Redis Caching & Messaging (Pub/Sub, Streams)