Jaké strategie cachování zvyšují výkon Node API?

Question

Accepted Answer

**Cachování** ukládá výsledky nákladných operací (databázové dotazy, výpočty, volání externích API), aby mohly být opakované požadavky obslouženy rychle bez opakování práce. Je to jednou z nejúčinnějších optimalizací výkonu pro API.

## In-memory cachování (nejrychlejší, jednoinstance)

```js
const cache = new Map();

async function getUser(id) {
  if (cache.has(id)) return cache.get(id); // cache HIT — instant
  const user = await db.findUser(id);       // cache MISS — do the work
  cache.set(id, user);
  return user;
}
```

Jednoduché a extrémně rychlé, ale cache je **na proces** (není sdílena mezi instancemi) a je ztracena při restartování. Vhodné pro malá, aktivně používaná data — ale vyžaduje evikci (použijte LRU cache jako `lru-cache`) k omezení paměti.

## Distribuované cachování s Redis (sdílené, škálovatelné)

```js
import { createClient } from "redis";
const redis = createClient();

async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // hit

const user = await db.findUser(id);
  await redis.setEx(`user:${id}`, 3600, JSON.stringify(user)); // cache for 1h (TTL)
  return user;
}
```

**Redis** je standard pro cachování napříč více serverovými instancemi — sdílené, rychlé úložiště, které přežije restartování a škáluje se s vaší aplikací. **TTL** (time-to-live) automaticky vypršuje záznamy, aby data nezůstala zastaralá navždy.

## HTTP cachování (nechat klienty/CDN cachovat)

```js
res.set("Cache-Control", "public, max-age=3600"); // browsers/CDN cache for 1h
res.set("ETag", hash);                            // conditional requests (304 Not Modified)
```

HTTP cache headery přesouvají cachování na prohlížeče a CDN zcela — nejrychlejší cache je požadavek, který se nikdy nedostane na váš server.

## Obtížná část: invalidace cache

```js
// when data changes, the cache must be updated or cleared, or users see stale data
async function updateUser(id, data) {
  await db.updateUser(id, data);
  await redis.del(`user:${id}`); // INVALIDATE — next read repopulates with fresh data
}
```

Největší výzvou cachování je **invalidace** — zajištění, aby aktualizace vymazaly/osvěžily ovlivněné záznamy cache, aby uživatelé neviděli zastaralá data. Strategie: TTL (přijmout krátkou zastaralost), write-through (aktualizovat cache při zápisu), nebo explicitní smazání při mutaci.

## Co cachovat (a co ne)

```text
✓ Read-heavy, infrequently-changing data (config, product catalogs, user profiles)
✓ Expensive computations, external API responses
✗ Highly dynamic/personalized or rapidly-changing data (or use very short TTLs)
✗ Sensitive data without care for who can read the cache
```

## Proč je to důležité

Cachování dramaticky snižuje latenci a zatížení databáze/externích služeb, často to je rozdíl mezi pomalým API a rychlým, škálovatelným.

Znalost vrstev — in-memory (nejrychlejší, na instanci, omezené s LRU), Redis (sdílené mezi instancemi) a HTTP/CDN cachování (kompletně přesunutí) — vám umožňuje zvolit správnou strategii.

A porozumění centrální obtíži cachování, **invalidaci** (přes TTL nebo explicitní smazání při zápisech), je to, co předchází klasickému selhání trade-offu – servírování zastaralých dat uživatelům.

Efektivní cachování je jedním z nejvlivnějších nástrojů pro výkon a škálovatelnost API.