Strategi dan pola caching apa saja yang ada dengan Redis?

Question

Accepted Answer

Di luar cache-aside dasar, ada beberapa **strategi caching** — cache-aside, write-through, write-behind, read-through — masing-masing dengan trade-off konsistensi dan performa yang berbeda. Memahami mereka (dan kebijakan eviksi) membantu Anda merancang caching yang efektif.

## Cache-aside (lazy loading — paling umum)

```text
App checks cache → miss → load from DB → populate cache → return.
  ✓ Only requested data is cached (efficient); resilient (works if cache is down)
  ✗ First request is a miss (slower); cache can be stale until TTL/invalidation
→ The default, most common strategy.
```

## Write-through dan write-behind

```text
WRITE-THROUGH → write to cache AND DB together (synchronously) on every write
  ✓ Cache always fresh/consistent  ✗ Writes are slower (two writes); caches unread data

WRITE-BEHIND (write-back) → write to cache immediately, write to DB ASYNC later
  ✓ Fast writes  ✗ Risk of data loss if cache fails before the DB write; more complex
```

## Read-through

```text
READ-THROUGH → the cache layer itself loads from the DB on a miss (abstracted)
  → app just reads from the cache; the cache handles DB loading transparently
  (similar to cache-aside but the loading logic lives in the cache layer/library)
```

## Kebijakan eviksi (ketika memori penuh)

```text
When Redis hits its memory limit (maxmemory), it EVICTS keys per a policy:
  LRU (Least Recently Used)  → evict least-recently-accessed (good general default)
  LFU (Least Frequently Used)→ evict least-frequently-accessed
  TTL-based (volatile-ttl)   → evict keys closest to expiry
  random / noeviction        → random, or reject writes when full
→ allkeys-lru is a common choice for a pure cache. Set maxmemory + a policy.
```

## Menghindari masalah cache

```text
✓ Cache STAMPEDE (many misses at once hammering the DB) → locking, staggered TTLs
✓ Stale data → appropriate TTLs + invalidation on writes
✓ Cache PENETRATION (querying non-existent keys) → cache negative results briefly
```

## Mengapa ini penting

Memahami strategi caching sangat berharga untuk **merancang sistem caching yang efektif**, berdasarkan cache-aside dasar, sehingga ini adalah pengetahuan yang berguna untuk pekerjaan yang berfokus pada performa.

Sementara cache-aside (lazy loading — memeriksa cache, memuat dari DB saat miss, mengisi cache) adalah default yang umum, memahami **rangkaian strategi** memungkinkan Anda memilih yang tepat untuk situasi tersebut: **write-through** (menulis ke cache dan DB bersama untuk cache yang selalu segar dengan biaya penulisan yang lebih lambat), **write-behind** (menulis ke cache segera dan DB secara asinkron untuk penulisan yang cepat tetapi dengan risiko kehilangan data), dan **read-through** (layer cache secara transparan memuat dari DB) — masing-masing dengan trade-off konsistensi/performa yang berbeda yang penting untuk persyaratan konsistensi dan pola penulisan yang berbeda.

Memahami **kebijakan eviksi** (LRU, LFU, berbasis TTL, dll. — bagaimana Redis memutuskan kunci mana yang akan dihapus ketika memori penuh) penting untuk mengonfigurasi Redis sebagai cache dengan benar (mengatur `maxmemory` dan kebijakan yang sesuai seperti `allkeys-lru` untuk cache murni), sehingga berperilaku baik di bawah tekanan memori.

Mengetahui cara **menghindari masalah cache umum** — cache **stampede** (banyak miss simultan yang menghantam database, dimitigasi dengan locking atau TTL yang terstagger), **data basi** (dikelola dengan TTL dan invalidasi), dan cache **penetration** (pertanyaan berulang untuk kunci yang tidak ada, dimitigasi dengan caching hasil negatif) — mencerminkan desain caching yang matang yang menghindari masalah produksi nyata.

Karena caching yang efektif secara signifikan berdampak pada performa dan strategi/konfigurasi yang tepat tergantung pada kasus penggunaan, dan karena memahami strategi, kebijakan eviksi, dan jebakan umum memungkinkan merancang caching yang kokoh, memahami strategi dan pola caching adalah pengetahuan yang berharga dan relevan secara praktis untuk engineering performa dengan Redis, meningkatkan caching dari pola dasar menjadi sistem yang dirancang dengan baik yang menangani konsistensi, memori, dan mode kegagalan dengan benar.