Apakah strategi caching yang meningkatkan prestasi API Node?

Question

Accepted Answer

**Caching** menyimpan hasil operasi mahal (pertanyaan DB, pengiraan, panggilan API luaran) supaya request berulang boleh dilayan dengan pantas tanpa mengulangi kerja itu. Ia adalah salah satu pengoptimuman prestasi berimpak tertinggi untuk sesebuah API.

## Caching dalam memori (terpantas, satu 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;
}
```

Mudah dan sangat pantas, tetapi cache adalah **setiap proses** (tidak dikongsi merentasi instances) dan hilang apabila dimulakan semula. Sesuai untuk data hangat yang kecil — tetapi memerlukan penyingkiran (eviction) (gunakan cache LRU seperti `lru-cache`) untuk menghadkan memori.

## Caching teragih dengan Redis (dikongsi, boleh berskala)

```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** ialah standard untuk caching merentasi berbilang instance pelayan — stor pantas yang dikongsi, yang kekal melepasi permulaan semula dan berskala dengan aplikasi anda. **TTL** (time-to-live) menamatkan entri secara automatik supaya data tidak menjadi basi selama-lamanya.

## Caching HTTP (biarkan 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)
```

Header cache HTTP memunggah caching kepada pelayar dan CDN sepenuhnya — cache terpantas ialah request yang tidak pernah sampai ke pelayan anda.

## Bahagian sukar: pembatalan cache (cache invalidation)

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

Cabaran caching terbesar ialah **pembatalan (invalidation)** — memastikan kemas kini membersihkan/menyegarkan entri cache yang terjejas supaya pengguna tidak melihat data basi. Strategi: TTL (terima kebasian sebentar), write-through (kemas kini cache semasa tulis), atau pemadaman eksplisit semasa mutasi.

## Apa yang perlu di-cache (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 ia penting

Caching mengurangkan latensi dan beban pangkalan data/luaran secara mendadak, selalunya perbezaan antara API yang perlahan dan satu yang pantas serta boleh berskala.

Mengetahui lapisan-lapisannya — dalam memori (terpantas, setiap instance, dihadkan dengan LRU), Redis (dikongsi merentasi instances), dan caching HTTP/CDN (memunggah sepenuhnya) — membolehkan anda memilih strategi yang betul.

Dan memahami kesukaran utama caching, **pembatalan** (melalui TTL atau pembersihan eksplisit semasa tulisan), adalah yang menghalang kegagalan tukar ganti klasik iaitu melayan pengguna dengan data basi.

Caching yang berkesan ialah salah satu alat paling berimpak untuk prestasi dan keterskalaan API.