Bagaimana cara kerja persistensi Redis (RDB vs AOF)?

Question

Accepted Answer

Meskipun Redis adalah in-memory, Redis dapat **mempertahankan data ke disk** sehingga data bertahan setelah restart. Redis menawarkan dua mekanisme — **RDB** (snapshot point-in-time) dan **AOF** (append-only log operasi) — dengan trade-off durabilitas/performa yang berbeda.

## RDB — snapshot point-in-time

```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 secara berkala menyimpan seluruh dataset ke file yang kompak — efisien dan bagus untuk backup, tetapi crash akan kehilangan perubahan yang dibuat sejak snapshot terakhir.

## 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 mencatat setiap write, memutarnya kembali untuk membangun kembali data saat restart — lebih tahan lama (kehilangan data lebih sedikit) tetapi dengan file yang lebih besar dan potensi performa/restart yang lebih lambat.

## RDB vs AOF — trade-off

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

## Mengapa ini penting

Memahami persistensi Redis penting untuk **memastikan durabilitas data** dengan tepat ketika Redis menyimpan data yang penting, sehingga merupakan pengetahuan yang berharga untuk menggunakan Redis dengan benar.

Meskipun Redis terutama in-memory, fakta bahwa Redis **dapat mempertahankan ke disk** (sehingga data bertahan setelah restart dan crash) penting untuk dipahami, bersama dengan dua mekanisme dan trade-off mereka. **RDB** (snapshot point-in-time) menawarkan backup yang kompak, restart cepat, dan dampak performa rendah, tetapi berisiko **kehilangan data sejak snapshot terakhir** saat crash — bagus untuk backup dan dapat diterima ketika beberapa kehilangan data dapat ditoleransi. **AOF** (mencatat setiap operasi write, diputar kembali saat restart) menawarkan **durabilitas lebih baik** (kehilangan data minimal, dapat dikonfigurasi melalui kebijakan fsync) tetapi dengan file yang lebih besar dan potensi performa/restart yang lebih lambat.

Memahami **trade-off** (RDB untuk performa dan backup yang kompak vs AOF untuk durabilitas) dan **best practice umum menggunakan keduanya bersama** (RDB untuk snapshot/backup ditambah AOF untuk durabilitas) mencerminkan penilaian konfigurasi yang solid.

Juga penting untuk mengenali bahwa untuk **penggunaan pure caching** (di mana data dapat dibuat ulang dari sumber), persistensi dapat dinonaktifkan sepenuhnya — Redis tidak selalu memerlukan durabilitas.

Memilih konfigurasi persistensi yang tepat berdasarkan use case (kebutuhan durabilitas vs performa, atau tidak ada untuk pure cache) adalah keterampilan praktis kunci.

Karena durabilitas data penting ketika Redis menyimpan data penting (session, queue, data primer), dan karena memahami RDB, AOF, trade-off mereka, dan best practice (keduanya bersama, atau tidak ada untuk caching) diperlukan untuk mengkonfigurasi Redis dengan tepat, memahami persistensi Redis adalah pengetahuan yang berharga dan relevan secara praktis untuk menggunakan Redis dengan bertanggung jawab — memastikan tingkat durabilitas yang tepat untuk data yang disimpan Redis, sebuah topik yang mencerminkan pemahaman Redis di luar caching sederhana.