Các chiến lược caching nào cải thiện hiệu năng API Node?

Question

Accepted Answer

**Caching** lưu kết quả của các thao tác tốn kém (truy vấn DB, tính toán, gọi API ngoài) để các request lặp lại được phục vụ nhanh mà không làm lại công việc. Đó là một trong những tối ưu hiệu năng tác động cao nhất cho một API.

## Cache trong bộ nhớ (nhanh nhất, một instance)

```js
const cache = new Map();

async function getUser(id) {
  if (cache.has(id)) return cache.get(id); // cache HIT — tức thì
  const user = await db.findUser(id);       // cache MISS — làm công việc
  cache.set(id, user);
  return user;
}
```

Đơn giản và cực nhanh, nhưng cache là **theo tiến trình** (không chia sẻ qua các instance) và mất khi khởi động lại. Tốt cho dữ liệu nhỏ, nóng — nhưng cần đào thải (dùng LRU cache như `lru-cache`) để giới hạn bộ nhớ.

## Cache phân tán với Redis (chia sẻ, mở rộng được)

```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 1 giờ (TTL)
  return user;
}
```

**Redis** là chuẩn cho caching qua nhiều instance server — một kho chia sẻ, nhanh, sống sót qua khởi động lại và mở rộng cùng app. **TTL** (time-to-live) tự hết hạn các mục để dữ liệu không cũ mãi.

## HTTP caching (để client/CDN cache)

```js
res.set("Cache-Control", "public, max-age=3600"); // trình duyệt/CDN cache 1 giờ
res.set("ETag", hash);                            // request có điều kiện (304 Not Modified)
```

Header HTTP cache đẩy việc caching hoàn toàn sang trình duyệt và CDN — cache nhanh nhất là request không bao giờ tới server bạn.

## Phần khó: vô hiệu hóa cache

```js
// khi dữ liệu đổi, cache phải được cập nhật hoặc xóa, nếu không user thấy dữ liệu cũ
async function updateUser(id, data) {
  await db.updateUser(id, data);
  await redis.del(`user:${id}`); // VÔ HIỆU — lần đọc sau nạp lại với dữ liệu mới
}
```

Thách thức caching lớn nhất là **vô hiệu hóa** — đảm bảo cập nhật xóa/làm mới các mục cache liên quan để user không thấy dữ liệu cũ. Chiến lược: TTL (chấp nhận cũ ngắn hạn), write-through (cập nhật cache khi ghi), hoặc xóa rõ ràng khi sửa đổi.

## Nên cache gì (và không)

```text
✓ Dữ liệu đọc nhiều, ít đổi (cấu hình, danh mục sản phẩm, hồ sơ user)
✓ Tính toán tốn kém, phản hồi API ngoài
✗ Dữ liệu rất động/cá nhân hóa hoặc đổi nhanh (hoặc dùng TTL rất ngắn)
✗ Dữ liệu nhạy cảm mà không cẩn thận về ai đọc được cache
```

## Tại sao điều này quan trọng

Caching giảm đáng kể độ trễ và tải database/ngoài, thường là khác biệt giữa một API chậm và một API nhanh, mở rộng được.

Biết các tầng — trong bộ nhớ (nhanh nhất, theo instance, giới hạn bằng LRU), Redis (chia sẻ qua instance), và HTTP/CDN caching (đẩy hoàn toàn) — giúp bạn chọn đúng chiến lược.

Và hiểu khó khăn trung tâm của caching, **vô hiệu hóa** (qua TTL hoặc xóa rõ ràng khi ghi), là điều ngăn thất bại đánh đổi kinh điển là phục vụ user dữ liệu cũ.

Caching hiệu quả là một trong những công cụ tác động nhất cho hiệu năng và khả năng mở rộng API.