Bagaimanakah kegigihan Redis berfungsi (RDB vs AOF)?

Question

Accepted Answer

Walaupun Redis dalam memori, ia boleh **menggigihkan data ke cakera** supaya data terselamat melalui mula semula. Ia menawarkan dua mekanisme — **RDB** (snapshot pada titik masa) dan **AOF** (log append-only bagi operasi) — dengan pertukaran ketahanan/prestasi yang berbeza.

## RDB — snapshot pada titik masa

```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 keseluruhan dataset ke fail padat — cekap dan sangat baik untuk sandaran, tetapi crash kehilangan perubahan yang dibuat sejak snapshot terakhir.

## AOF — log append-only

```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 merekodkan setiap tulisan, memainkannya semula untuk membina semula data semasa mula semula — lebih tahan lama (kurang kehilangan data) tetapi dengan fail yang lebih besar dan prestasi/mula semula yang berpotensi lebih perlahan.

## RDB vs AOF — pertukaran

```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 ia penting

Memahami kegigihan Redis adalah penting untuk **memastikan ketahanan data** dengan sewajarnya apabila Redis memegang data yang penting, jadi ia adalah pengetahuan bernilai untuk menggunakan Redis dengan betul.

Walaupun Redis utamanya dalam memori, hakikat bahawa ia **boleh menggigihkan ke cakera** (supaya data terselamat melalui mula semula dan crash) penting difahami, bersama dua mekanisme dan pertukaran mereka. **RDB** (snapshot pada titik masa) menawarkan sandaran padat, mula semula pantas, dan impak prestasi rendah, tetapi berisiko **kehilangan data sejak snapshot terakhir** semasa crash — baik untuk sandaran dan boleh diterima apabila sedikit kehilangan data boleh ditoleransi. **AOF** (melog setiap operasi tulisan, dimainkan semula semasa mula semula) menawarkan **ketahanan yang lebih baik** (kehilangan data minimum, boleh dikonfigurasi melalui dasar fsync) tetapi dengan fail yang lebih besar dan prestasi/mula semula yang berpotensi lebih perlahan.

Memahami **pertukaran** (RDB untuk prestasi dan sandaran padat vs AOF untuk ketahanan) dan **amalan terbaik** biasa menggunakan kedua-duanya bersama (RDB untuk snapshot/sandaran ditambah AOF untuk ketahanan) mencerminkan pertimbangan konfigurasi yang baik.

Juga penting ialah menyedari bahawa untuk penggunaan **caching tulen** (di mana data boleh dicipta semula daripada sumber), kegigihan boleh dilumpuhkan sepenuhnya — Redis tidak selalu memerlukan ketahanan.

Memilih konfigurasi kegigihan yang betul berdasarkan kes penggunaan (keperluan ketahanan vs prestasi, atau tiada untuk cache tulen) ialah kemahiran praktikal utama.

Memandangkan ketahanan data penting apabila Redis memegang data penting (sesi, queues, data utama), dan kerana memahami RDB, AOF, pertukaran mereka, dan amalan terbaik (kedua-duanya bersama, atau tiada untuk caching) diperlukan untuk mengkonfigurasi Redis dengan sewajarnya, memahami kegigihan Redis adalah pengetahuan bernilai yang relevan dari segi praktikal untuk menggunakan Redis secara bertanggungjawab — memastikan tahap ketahanan yang betul untuk data yang dipegang Redis, satu topik yang mencerminkan pemahaman tentang Redis melebihi caching mudah.