Katere strategije predpomnenja izboljšajo zmogljivost Node API?

Question

Accepted Answer

**Predpomnenje** shranjuje rezultate dragih operacij (poizvedbe baze podatkov, izračuni, klici zunanjih API-jev), tako da lahko ponavljajoče se zahteve hitro servira brez ponovnega izvajanja dela. To je ena izmed strategij optimizacije zmogljivosti z največjim vplივom za API.

## Predpomnenje v pomnilniku (najhitrejše, ena instanca)

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

Enostavno in izredno hitro, vendar je predpomnenje **vezano na proces** (ne deljeno med instancami) in se izgubi ob ponovnem zagonu. Primerno za majhne, pogosto dostopane podatke — vendar zahteva izračun (uporabite predpomnenje LRU kot `lru-cache`) za omejitev pomnilnika.

## Distribuirano predpomnenje s Redis-om (deljeno, razširljivo)

```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 za predpomnenje na več serverskih instancah — skupna, hitra shranjevalna mesto, ki preživi ponovni zagon in se skalira z vašo aplikacijo. **TTL** (čas do izteka) avtomatično preneha z veljavnostjo vnosed, zato podatki ne ostanejo zastareli za vedno.

## Predpomnenje HTTP (omogočite odjemalcem/CDN-om predpomnenje)

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

HTTP glava predpomnenja preusmeri predpomnenje na brskalnike in CDN-e v celoti — najhitrejše predpomnenje je zahteva, ki nikoli ne doseže vašega strežnika.

## Težak del: nevažnost predpomnenja

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

Največja izziv predpomnenja je **nevažnost** — zagotavljanje, da posodobitve počistijo/osvežijo vplivane vnose predpomnenja, tako da uporabniki ne vidijo zastarele podatke. Strategije: TTL (sprejmi kratkotrajno zastarelost), pisanje skozi (posodobi predpomnenje ob pisanju) ali izrecno brisanje ob mutaciji.

## Kaj predpomniti (in kaj 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
```

## Zakaj je to pomembno

Predpomnenje dramatično zmanjša zakasnjenje in obremenitev baze podatkov/zunanjih virov, pogosto razlika med počasnim API in hitrim, razširljivim.

Izvedba slojev — predpomnenje v pomnilniku (najhitrejše, vezano na instanco, omejeno z LRU), Redis (deljeno med instancami) in HTTP/CDN predpomnenje (preusmeri v celoti) — vam omogoča izbiro prave strategije.

In razumevanje osrednje težave predpomnenja, **nevažnosti** (preko TTL ali izrecnega čiščenja ob pisanju), je tisto, kar preprečuje klasični neuspeh kompromisa med služenjem uporabnikom zastarele podatke.

Učinkovito predpomnenje je eno izmed najbolj vplivnih orodij za zmogljivost in razširljivost API.