Kaip Redis naudojamas kaip cache'as?

Question

Accepted Answer

**Caching** yra Redis dažniausia naudojimo sritis — dažnai pasikartojančių duomenų saugojimas greitoje atmintyje, kad programos išvengtų lėtesnių operacijų (duomenų bazės užklausų, API iškviečių, skaičiavimų). Pagrindinės caching šablono supratimas yra būtinas kasdieninis žinias.

## Cache-aside šablonas (dažniausiai naudojamas)

```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;
}
```

Programėlė pirmiausia tikrina Redis; nepavykus gauti duomenų, ji gauna iš šaltinio, saugo rezultatą (su TTL) ir jį grąžina. Vėlesni užklausai yra greitai grąžinti iš cache'o.

## Kodėl caching padeda

```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'o nukreipimas (sunkioji dalis)

```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."
```

## Kodėl tai svarbu

Naudojant Redis kaip cache'ą, tai yra jo dažniausias ir poveikiausias taikymas, todėl pagrindinės caching šablono supratimas yra būtinas, plačiai taikomas žinias kuriant produktyvias programas.

Pagrindinė technika — dažnai pasikartojančių duomenų saugojimas Redis greitoje atmintyje, kad programa išvengtų lėtesnių operacijų (duomenų bazės užklausų, API iškviečių, brangiųjų skaičiavimų) — yra vienas iš veiksmingiausiųjų būdų pagerinti našumą ir masteliabilumą, naudojamas labai didelėje gamybinių sistemų dalyje.

**Cache-aside šablono** supratimas (pirmiausia patikrinti Redis; jei yra — nedelsiant grąžinti; jei nėra — gauti iš šaltinio, saugoti rezultatą su TTL ir jį grąžinti) yra pagrindinis caching metodas, kurį turėtų žinoti kiekvienas kūrėjas — tai yra kaip dauguma caching yra implementuojama.

**Supratimas, kodėl caching padeda** (atmintinė Redis yra daug greitesnė nei diske pagrįstos duomenų bazės ar išoriniai API, o caching sumažina apkrovą duomenų bazei, todėl ji geriau masteliuojama) paaiškina dvigubą naudą — greitumą ir sumažintą backend apkrovą.

Critically, understanding **cache invalidation** — garsusis „sunkus uždavinys