Hvordan fungerer Redis persistering (RDB vs AOF)?

Question

Accepted Answer

Selvom Redis er i-hukommelse, kan det **persistere data til disk**, så data overlever genstarter. Det tilbyder to mekanismer — **RDB** (point-in-time snapshots) og **AOF** (append-only log over operationer) — med forskellige holdbarhed/ydelses-afvejninger.

## RDB — point-in-time snapshots

```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 gemmer periodisk hele datasættet til en kompakt fil — effektivt og glimrende til backups, men et nedbrud mister ændringer foretaget siden sidste snapshot.

## AOF — append-only log

```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 registrerer hver skrivning, afspiller den for at genopbygge data ved genstart — mere holdbar (mindre datatab) men med større filer og potentielt langsommere ydelses/genstarter.

## RDB vs AOF — afvejningen

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

## Hvorfor det betyder noget

At forstå Redis persistering er vigtig for **at sikre dataholdbarhed** på passende måde, når Redis holder data, der betyder noget, så det er værdifuldt viden for at bruge Redis korrekt.

Selvom Redis primært er i-hukommelse, er det vigtig at forstå, at det **kan persistere til disk** (så data overlever genstarter og nedbrud) sammen med de to mekanismer og deres afvejninger. **RDB** (point-in-time snapshots) tilbyder kompakte backups, hurtige genstarter og lav ydelses påvirkning, men risikerer **at miste data siden sidste snapshot** ved et nedbrud — godt til backups og acceptabelt, når noget datatab er tolerabelt. **AOF** (logging af hver skrivehandling, afspillet ved genstart) tilbyder **bedre holdbarhed** (minimalt datatab, konfigurerbart via fsync-politik) men med større filer og potentielt langsommere ydelses/genstarter.

At forstå **afvejningen** (RDB for ydelses og kompakte backups vs AOF for holdbarhed) og den almindelige **best practice at bruge begge sammen** (RDB for snapshots/backups plus AOF for holdbarhed) afspejler klog konfigurationsvurdering.

Det er også vigtig at genkende, at for **ren cache-brug** (hvor data er genoprette bart fra kilden) kan persistering deaktiveres helt — Redis behøver ikke altid holdbarhed.

At vælge den rigtige persisteringskonfiguration baseret på use case (holdbarhedskrav vs ydelses, eller ingen til ren cache) er den vigtige praktiske færdighed.

Da dataholdbarhed betyder noget, når Redis holder vigtige data (sessioner, køer, primære data), og da det er nødvendigt at forstå RDB, AOF, deres afvejninger og best practices (begge sammen, eller ingen til caching) for at konfigurere Redis på passende måde, er forståelse af Redis persistering værdifuld, praktisk-relevant viden for at bruge Redis ansvarligt — sikre den rigtige niveau af holdbarhed for de data, Redis holder, et emne, der afspejler forståelse af Redis ud over simple caching.