Apa strategi caching lan pola sing ana karo Redis?

Question

Accepted Answer

Beyond basic cache-aside, ana sawetara **caching strategies** — cache-aside, write-through, write-behind, read-through — saben-saben duwe trade-offs consistency lan performance sing beda-beda. Mangerteni iku (lan eviction policies) mbantu sampeyan ndesain caching sing 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 lan 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)
```

## Eviction policies (ketika memory 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.
```

## Ngindhari 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
```

## Apa sing penting

Mangerteni strategi caching iku berharga kanggo **ndesain sistem caching sing efektif**, ngembangake cache-aside dasar, dadi iku ilmu sing berguna kanggo karya sing fokus karo performance.

Saliyane cache-aside (lazy loading — mriksa cache, ngunggal saka DB nalika miss, ngisi cache) iku default umum, mangerteni **jangkauan strategi** ndadekake sampeyan bisa milih sing tepat kanggo situasi: **write-through** (nulis menyang cache lan DB babar blas kanggo cache sing tansah seger nanging nulis luwih alon), **write-behind** (nulis menyang cache ora luwih lan DB kanthi asynchronous kanggo nulis sing cepet nanging duwe risiko kehilangan data), lan **read-through** (cache layer kanthi transparan ngunggal saka DB) — saben-saben duwe trade-offs consistency/performance sing beda-beda sing penting kanggo requirement consistency lan write-pattern sing beda-beda.

Mangerteni **eviction policies** (LRU, LFU, TTL-based, lsp. — cara Redis mutusake key endi sing dibusak ketika memory penuh) iku penting kanggo nglengkapi Redis minangka cache kanthi bener (nyetel `maxmemory` lan policy sing sesuai kaya `allkeys-lru` kanggo cache murni), dadi iku berperilaku apik nalika tekanan memory.

Ngerteni cara **ngindhari masalah cache umum** — cache **stampede** (akeh miss sing simultaneous ngebom database, dikurangi kanthi locking utawa staggered TTLs), **stale data** (dikelola kanthi TTLs lan invalidation), lan **penetration** cache (query berulang-ulang kanggo key sing ora ana, dikurangi kanthi caching negative results) — nunutupake ndesain caching sing dewasa sing ngindhari masalah production nyata.

Karang caching sing efektif nyata nyakot performance lan strategi/konfigurasi sing bener gumantung saka use case, lan karang mangerteni strategi, eviction policies, lan pitfalls umum ndadekake ndesain caching sing robust, mangerteni caching strategies lan patterns iku ilmu berharga lan praktis kanggo performance engineering karo Redis, munggak caching saka pola dasar menyang sistem sing ndesain apik sing nangani consistency, memory, lan failure modes kanthi bener.