กลยุทธ์ caching แบบใดบ้างที่ช่วยเพิ่มประสิทธิภาพของ Node API?

Question

Accepted Answer

**Caching** เก็บผลลัพธ์ของ operation ที่มีต้นทุนสูง (DB query, การคำนวณ, การเรียก external API) เพื่อให้ request ซ้ำได้รับการตอบสนองอย่างรวดเร็วโดยไม่ต้องทำงานใหม่ มันเป็นหนึ่งในการปรับปรุงประสิทธิภาพที่ได้ผลมากที่สุดสำหรับ API

## In-memory caching (เร็วที่สุด, 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;
}
```

เรียบง่ายและเร็วมาก แต่ cache เป็นแบบ **ต่อ process** (ไม่ถูกแชร์ข้าม instance) และหายไปเมื่อรีสตาร์ท เหมาะกับข้อมูลที่ร้อนและมีขนาดเล็ก — แต่ต้องมีการ evict (ใช้ LRU cache อย่าง `lru-cache`) เพื่อจำกัดหน่วยความจำ

## Distributed caching ด้วย Redis (แชร์ได้, scale ได้)

```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** เป็นมาตรฐานสำหรับการ cache ข้ามเซิร์ฟเวอร์หลาย instance — เป็นที่เก็บแบบแชร์ที่เร็ว ซึ่งอยู่รอดจากการรีสตาร์ทและ scale ไปพร้อมกับแอป **TTL** (time-to-live) จะหมดอายุ entry โดยอัตโนมัติเพื่อให้ข้อมูลไม่ค้างเก่าตลอดไป

## HTTP caching (ให้ client/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 header ผลักการ cache ไปให้ browser และ CDN ทั้งหมด — cache ที่เร็วที่สุดคือ request ที่ไม่เคยมาถึงเซิร์ฟเวอร์ของคุณเลย

## ส่วนที่ยาก: 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
}
```

ความท้าทายที่ใหญ่ที่สุดของ caching คือ **invalidation** — การทำให้แน่ใจว่าการอัปเดตล้าง/รีเฟรช cache entry ที่ได้รับผลกระทบ เพื่อให้ผู้ใช้ไม่เห็นข้อมูลค้างเก่า กลยุทธ์ได้แก่: TTL (ยอมรับความเก่าชั่วครู่), write-through (อัปเดต cache เมื่อ write) หรือการลบโดยชัดแจ้งเมื่อมีการ mutation

## ควร cache อะไร (และไม่ควร)

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

## ทำไมจึงสำคัญ

Caching ลด latency และภาระของ database/external ได้อย่างมาก มักเป็นความแตกต่างระหว่าง API ที่ช้ากับ API ที่เร็วและ scale ได้

การรู้จักชั้นต่าง ๆ — in-memory (เร็วที่สุด, ต่อ instance, จำกัดด้วย LRU), Redis (แชร์ข้าม instance) และ HTTP/CDN caching (ผลักออกไปทั้งหมด) — ช่วยให้คุณเลือกกลยุทธ์ที่เหมาะสม

และการเข้าใจความยากหลักของ caching คือ **invalidation** (ผ่าน TTL หรือการล้างโดยชัดแจ้งเมื่อ write) คือสิ่งที่ป้องกันความล้มเหลวคลาสสิกของการ trade-off ที่ทำให้ผู้ใช้เห็นข้อมูลค้างเก่า

Caching ที่มีประสิทธิภาพเป็นหนึ่งในเครื่องมือที่ทรงพลังที่สุดสำหรับประสิทธิภาพและความสามารถในการ scale ของ API