Kako se Redis koristi kao cache?

Question

Accepted Answer

**Caching** je najčešće korišten slučaj primjene Redisa — pohrana često pristupanih podataka u brzoj memoriji kako bi aplikacije izbjegle sporije operacije (upite baze podataka, API pozive, proračune). Razumijevanje osnovnog vzora cachiranja je bitno svakodnevno znanje.

## Uzorak cache-aside (najčešće korišten)

```text
1. App needs data → CHECK Redis first (cache lookup)
2. CACHE HIT (found) → return it immediately (fast!) ✓
3. CACHE MISS (not found) → query the database, store the result in Redis (with TTL),
   then return it. Next time it'll be a hit.
```

```js
async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // CACHE HIT — fast, skip the DB

const user = await db.users.findById(id);        // CACHE MISS — query the DB
  await redis.set(`user:${id}`, JSON.stringify(user), "EX", 3600);  // cache it (1h TTL)
  return user;
}
```

Aplikacija prvo provjerava Redis; na cache miss, dohvaća iz izvora, cachira rezultat (s TTL-om) i vraća ga. Sljedeći zahtjevi su brzi cache hitovi.

## Zašto cachiranje pomaže

```text
✓ SPEED — Redis (in-memory) is far faster than a database (disk) or external API
✓ REDUCED LOAD — fewer queries hit the database (it handles less, scales better)
✓ Result: faster responses, lower database load, better scalability
→ Caching is one of the most effective ways to improve application performance.
```

## Cache invalidacija (teški dio)

```js
// when data changes, the cache must be updated or removed (else it's STALE)
async function updateUser(id, data) {
  await db.users.update(id, data);
  await redis.del(`user:${id}`);    // INVALIDATE the cache (next read re-fetches fresh)
}
```

```text
Stale data is the main caching challenge:
  → Use TTLs (data auto-expires, eventually refreshing)
  → Invalidate (delete/update the cache) when the source data changes
  → "There are only two hard things: cache invalidation and naming things."
```

## Zašto je važno

Korištenje Redisa kao cachea je njegova najčešća i najutjecajnija primjena, pa razumijevanje osnovnog vzora cachiranja je bitno, široko primjenjivo znanje za izgradnju performantnih aplikacija.

Tehnika jezgre — pohrana često pristupanih podataka u Redisovoj brzoj memoriji kako bi aplikacija izbjegla sporije operacije (upite baze podataka, API pozive, skupe proračune) — je jedan od najefikasnijih načina za poboljšanje performansi i skalabilnosti, korišten u ogromnom broju produkcijskih sustava.

Razumijevanje **uzorka cache-aside** (provjeri Redis prvo; na hit odmah vrati; na miss dohvati iz izvora, cachira rezultat s TTL-om i vrati ga) je temeljni teknika cachiranja koju bi svaki razvojni inženjer trebao znati — to je kako je većina cachiranja implementirana.

Razumijevanje **zašto cachiranje pomaže** (Redisova memorija je daleko brža od disk-baziranih baza podataka ili vanjskih API-ja, i cachiranje smanjuje opterećenje na bazi podataka pa se bolje skalira) objašnjava dvostranu korist brzine i smanjene opterećenosti backendu.

Kritično, razumijevanje **cache invalidacije** — poznate "teške problema" održavanja cachiranih podataka od zastarijevanja, rješavane s TTL-ima (auto-istjecom) i eksplicitnom invalidacijom (brisanjem/ažuriranjem cachea kada se izvorni podaci promijene) — je bitno jer zastarjeli podaci su glavni problem cachiranja, i upravljanje njime ispravno je ono što odvaja radijuće cacheve od suptilno buggynih.

Budući da je cachiranje dominantna primjena Redisa i jedna od najvažnijih tehnika performansi u softveru, i budući da je uzzorak cache-aside (s ispravnom invalidacijom) temeljni način kako se to radi, razumijevanje kako se Redis koristi kao cache — uzorak, njegove prednosti i izazov invalidacije — je bitno, često primjenjeno znanje za izgradnju brzih, skalabilnih aplikacija, vjerojatno najjednostavnije važnije praktično znanje o Redisu.