Apa strategi caching sing nambah performa Node API?

Question

IT Interview Practice · Accepted Answer

**Caching** nyimpen asil operasi sing mahal (query DB, komputasi, panggilan API eksternal) supaya request sing diulang bisa dilayani kanthi cepet tanpa ngulang kerjo. Iku minangka salah siji optimisasi performa sing paling dampak gedhe kanggo API.

## Caching in-memory (paling cepet, 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;
}
```

Sederhana lan sangat cepet, nanging cache iku **per-process** (ora dibagi antarane instance) lan ilang sak restart. Apik kanggo data cilik sing panas — nanging butuh eviction (gunakake cache LRU kaya `lru-cache`) kanggo batasi memori.

## Distributed caching karo Redis (dibagi, scalable)

```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** minangka standar kanggo caching antarane multiple server instance — toko sing dibagi, cepet, lan selamet restart sarta skalabel karo app. **TTL** (time-to-live) auto-expire entry supaya data ora basi selamane.

## HTTP caching (biarine klien/CDN cache)

```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 headers ngilangi caching menyang browser lan CDN sakabèhé — cache paling cepet yaiku request sing ora tau tekan server.

## Bagean sing angel: invalidation 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
}
```

Challenge caching paling gedhe yaiku **invalidation** — maksa update nebus/refresh affected cache entry supaya user ora weruh data basi. Strategi: TTL (terima staleness singkat), write-through (update cache sak write), utawa deletion eksplisit sak mutation.

## Apa sing dicache (lan ora)

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

## Mengapa iku penting

Caching nyuda latency lan database/external load kanthi drastis, asring minangka beda antarane API alon lan cepet, scalable.

Ngngerti layer — in-memory (paling cepet, per-instance, diwatesi LRU), Redis (dibagi antarane instance), lan HTTP/CDN caching (ilang sakabèhé) — ngidini kowe pilih strategi sing bener.

Lan ngerti kesulitan sentral caching, **invalidation** (via TTL utawa clearing eksplisit sak write), yaiku sing nyegah kegagalan trade-off klasik nglayani user data basi.

Caching efektif yaiku salah siji alat paling impactful kanggo performa lan scalability API.

Caching in-memory (paling cepet, single-instance)

Distributed caching karo Redis (dibagi, scalable)

HTTP caching (biarine klien/CDN cache)

Bagean sing angel: invalidation cache

Apa sing dicache (lan ora)

Mengapa iku penting

Pitakon sing gegandhengan