Welche Caching-Strategien verbessern die Performance einer Node-API?

Question

Accepted Answer

**Caching** speichert die Ergebnisse teurer Operationen (DB-Abfragen, Berechnungen, externe API-Aufrufe), sodass wiederholte Anfragen schnell bedient werden können, ohne die Arbeit zu wiederholen. Es ist eine der wirkungsvollsten Performance-Optimierungen für eine API.

## In-Memory-Caching (schnellstes, Single-Instance)

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

Einfach und extrem schnell, aber der Cache ist **prozessabhängig** (nicht über Instanzen hinweg geteilt) und geht beim Neustart verloren. Gut für kleine, häufig abgerufene Daten – benötigt aber Eviction (verwenden Sie einen LRU-Cache wie `lru-cache`), um den Speicher zu begrenzen.

## Verteiltes Caching mit Redis (geteilt, skalierbar)

```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** ist der Standard für Caching über mehrere Server-Instanzen hinweg – ein gemeinsamer, schneller Speicher, der Neustarts übersteht und mit Ihrer App skaliert. Die **TTL** (Time-to-Live) lässt Einträge automatisch verfallen, damit Daten nicht für immer alt werden.

## HTTP-Caching (lassen Sie Clients/CDNs cachen)

```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-Header verlagern das Caching vollständig auf Browser und CDNs – der schnellste Cache ist die Anfrage, die Ihren Server nie erreicht.

## Der schwierige Teil: Cache-Invalidierung

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

Die größte Herausforderung beim Caching ist die **Invalidierung** – sicherzustellen, dass Updates betroffene Cache-Einträge löschen/aktualisieren, damit Benutzer keine veralteten Daten sehen. Strategien: TTL (kurze Veraltung akzeptieren), Write-Through (Cache beim Schreiben aktualisieren) oder explizites Löschen bei Änderungen.

## Was zu cachen ist (und nicht)

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

## Warum es wichtig ist

Caching reduziert Latenz und Datenbank-/externe Last dramatisch – oft der Unterschied zwischen einer langsamen und einer schnellen, skalierbaren API.

Die Kenntnis der Schichten – In-Memory (schnellstes, pro Instanz, begrenzt mit LRU), Redis (über Instanzen hinweg geteilt) und HTTP/CDN-Caching (vollständig ausgelagert) – ermöglicht es Ihnen, die richtige Strategie zu wählen.

Und das Verständnis für die zentrale Schwierigkeit des Caching, die **Invalidierung** (über TTL oder explizites Löschen bei Schreibvorgängen), ist das, was den klassischen Trade-Off-Fehler verhindert, bei dem Benutzer veraltete Daten sehen.

Effektives Caching ist eines der wirkungsvollsten Tools für API-Performance und Skalierbarkeit.