Comment fonctionne la persistance Redis (RDB vs AOF) ?

Question

Accepted Answer

Bien que Redis soit en mémoire, il peut **persister les données sur disque** pour que les données survivent aux redémarrages. Il offre deux mécanismes — **RDB** (snapshots ponctuels) et **AOF** (journal d'opérations) — avec des compromis différents en termes de durabilité/performance.

## RDB — snapshots ponctuels

```text
RDB takes SNAPSHOTS of the dataset at intervals, saving a compact binary file.
  ✓ Compact single-file backups; fast restarts (load the snapshot)
  ✓ Good for backups and disaster recovery; less impact on performance
  ✗ You can LOSE data since the last snapshot (e.g. last few minutes) if Redis crashes
→ Configure save points: e.g. "save after 900s if ≥1 change, 300s if ≥10 changes"
```

RDB sauvegarde périodiquement l'ensemble des données dans un fichier compact — efficace et excellent pour les sauvegardes, mais un crash entraîne la perte des modifications apportées depuis le dernier snapshot.

## AOF — journal d'ajout seul

```text
AOF logs EVERY write operation to a file; on restart, Redis replays the log to rebuild data.
  ✓ More DURABLE — less data loss (can fsync every second, or every write)
  ✓ The log can be rewritten/compacted to stay manageable
  ✗ Larger files; can be slower than RDB; restart (replay) can be slower
→ fsync policies: always (safest, slowest), everysec (good balance), no (fastest, riskiest)
```

AOF enregistre chaque écriture, la rejeu pour reconstruire les données au redémarrage — plus durable (moins de perte de données) mais avec des fichiers plus volumineux et potentiellement des performances plus lentes/redémarrages plus lents.

## RDB vs AOF — le compromis

```text
RDB → better performance, compact backups, faster restart, BUT more potential data loss
AOF → better durability (minimal data loss), BUT larger files, slower

BEST PRACTICE: use BOTH together → RDB for backups + AOF for durability
  → Redis can use both; AOF for recovery, RDB for snapshots/backups
OR: pure cache use → you may DISABLE persistence entirely (data is recreatable)
```

## Pourquoi c'est important

Comprendre la persistance Redis est important pour **assurer la durabilité des données** de manière appropriée lorsque Redis contient des données qui importent, c'est donc une connaissance précieuse pour utiliser Redis correctement.

Bien que Redis soit principalement en mémoire, le fait qu'il **puisse persister sur disque** (de sorte que les données survivent aux redémarrages et aux crashes) est important à comprendre, tout comme les deux mécanismes et leurs compromis. **RDB** (snapshots ponctuels) offre des sauvegardes compactes, des redémarrages rapides et un faible impact sur les performances, mais risque de **perdre les données depuis le dernier snapshot** en cas de crash — bon pour les sauvegardes et acceptable lorsqu'une certaine perte de données est tolérable. **AOF** (enregistrement de chaque opération d'écriture, rejeu au redémarrage) offre **une meilleure durabilité** (perte de données minimale, configurable via les politiques fsync) mais avec des fichiers plus volumineux et potentiellement des performances plus lentes/redémarrages plus lents.

Comprendre le **compromis** (RDB pour les performances et les sauvegardes compactes vs AOF pour la durabilité) et la **meilleure pratique commune d'utiliser les deux ensemble** (RDB pour les snapshots/sauvegardes plus AOF pour la durabilité) reflète un jugement de configuration sain.

Il est également important de reconnaître que pour un **usage de pur cache** (où les données sont recréables à partir de la source), la persistance peut être entièrement désactivée — Redis n'a pas toujours besoin de durabilité.

Choisir la bonne configuration de persistance en fonction du cas d'usage (besoins de durabilité vs performance, ou aucun pour un pur cache) est la compétence pratique clé.

Since data durability matters when Redis holds important data (sessions, queues, primary data), and since understanding RDB, AOF, their trade-offs, and the best practices (both together, or none for caching) is necessary to configure Redis appropriately, understanding Redis persistence is valuable, practically-relevant knowledge for using Redis responsibly — ensuring the right level of durability for the data Redis holds, a topic that reflects understanding of Redis beyond simple caching.