Strategi caching apa saja yang meningkatkan performa Node API?

Question

Accepted Answer

**Caching** menyimpan hasil operasi mahal (query DB, komputasi, panggilan API eksternal) sehingga permintaan berulang dapat dilayani dengan cepat tanpa mengulang pekerjaan. Ini adalah salah satu optimasi performa dengan dampak tertinggi untuk sebuah API.

## Caching dalam memori (tercepat, 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 dan sangat cepat, namun cache **per-process** (tidak dibagikan antar instance) dan hilang saat restart. Bagus untuk data kecil dan aktif — tetapi memerlukan eviction (gunakan cache LRU seperti `lru-cache`) untuk membatasi memori.

## Caching terdistribusi dengan Redis (dibagikan, 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** adalah standar untuk caching di beberapa instance server — penyimpanan bersama yang cepat dan bertahan setelah restart serta scalable dengan aplikasi Anda. **TTL** (time-to-live) secara otomatis mengakhiri entry sehingga data tidak tetap usang selamanya.

## Caching HTTP (biarkan klien/CDN melakukan 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 memindahkan caching ke browser dan CDN sepenuhnya — cache tercepat adalah permintaan yang tidak pernah mencapai server Anda.

## Bagian sulit: invalidasi 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 terbesar adalah **invalidasi** — memastikan update menghapus/menyegarkan cache entry yang terpengaruh sehingga pengguna tidak melihat data usang. Strategi: TTL (terima kesegaran singkat), write-through (update cache saat write), atau penghapusan eksplisit saat mutasi.

## Apa yang dicache (dan tidak)

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

Caching secara dramatis mengurangi latency dan beban database/eksternal, sering kali perbedaan antara API lambat dan yang cepat serta scalable.

Mengetahui layer — in-memory (tercepat, per-instance, dibatasi dengan LRU), Redis (dibagikan antar instance), dan caching HTTP/CDN (pindahkan sepenuhnya) — memungkinkan Anda memilih strategi yang tepat.

Dan memahami kesulitan caching pusat, **invalidasi** (melalui TTL atau penghapusan eksplisit saat write), adalah apa yang mencegah kegagalan trade-off klasik melayani pengguna data usang.

Caching efektif adalah salah satu alat paling berdampak untuk performa dan skalabilitas API.