W jaki sposób Redis jest używany jako cache?

Question

Accepted Answer

**Cache'owanie** jest najczęstszym przypadkiem użycia Redis — przechowywanie często dostępnych danych w szybkiej pamięci, aby aplikacje unikały wolniejszych operacji (zapytania do bazy danych, połączenia API, obliczenia). Zrozumienie podstawowego wzorca cache'owania jest istotną codzienną wiedzą.

## Wzorzec cache-aside (najczęściej używany)

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

Aplikacja sprawdza najpierw Redis; w przypadku chybienia pobiera dane ze źródła, cache'uje wynik (z TTL) i go zwraca. Kolejne żądania to szybkie trafienia cache'u.

## Dlaczego cache'owanie pomaga

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

## Inwalidacja cache'u (trudna część)

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

## Dlaczego to ważne

Wykorzystanie Redis jako cache'u jest jego najczęstszą i najbardziej wpływową aplikacją, dlatego zrozumienie podstawowego wzorca cache'owania jest wiedzą niezbędną, wszechstronnie zastosowaną do budowania wydajnych aplikacji.

Technika podstawowa — przechowywanie często dostępnych danych w szybkiej pamięci Redis, aby aplikacja unikała wolniejszych operacji (zapytania do bazy danych, połączenia API, kosztowne obliczenia) — jest jednym z najbardziej efektywnych sposobów na poprawę wydajności i skalowalności, stosowanym w ogromnej liczbie systemów produkcyjnych.

Zrozumienie **wzorca cache-aside** (sprawdzenie Redis najpierw; przy trafieniu zwrócenie natychmiast; przy chybienia pobranie ze źródła, cache'owanie wyniku z TTL i jego zwrócenie) jest fundamentalną techniką cache'owania, którą każdy deweloper powinien znać — to w jaki sposób większość cache'owania jest implementowana.

Zrozumienie **dlaczego cache'owanie pomaga** (Redis w pamięci jest znacznie szybszy niż bazy danych oparte na dysku lub zewnętrzne API, a cache'owanie zmniejsza obciążenie bazy danych, dzięki czemu lepiej się skaluje) wyjaśnia dwojakie korzyści: szybkość i zmniejszone obciążenie backendu.

Krytycznie ważne jest zrozumienie **inwalidacji cache'u** — słynnego „trudnego problemu