Redis được dùng làm cache như thế nào?

Question

Accepted Answer

**Caching** là use case phổ biến nhất của Redis — lưu dữ liệu hay truy cập trong bộ nhớ nhanh để ứng dụng tránh các thao tác chậm hơn (truy vấn database, gọi API, tính toán). Hiểu pattern caching cơ bản là kiến thức hàng ngày thiết yếu.

## Pattern cache-aside (phổ biến nhất)

```text
1. App needs data → CHECK Redis first (cache lookup)
2. CACHE HIT (found) → return it immediately (fast!) ✓
3. CACHE MISS (not found) → query the database, store the result in Redis (with TTL),
   then return it. Next time it'll be a hit.
```

```js
async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // CACHE HIT — nhanh, bỏ qua DB

const user = await db.users.findById(id);        // CACHE MISS — truy vấn DB
  await redis.set(`user:${id}`, JSON.stringify(user), "EX", 3600);  // cache nó (TTL 1h)
  return user;
}
```

App kiểm tra Redis trước; khi miss, nó lấy từ nguồn, cache kết quả (với TTL), và trả về. Các request sau là cache hit nhanh.

## Tại sao caching giúp ích

```text
✓ SPEED — Redis (in-memory) is far faster than a database (disk) or external API
✓ REDUCED LOAD — fewer queries hit the database (it handles less, scales better)
✓ Result: faster responses, lower database load, better scalability
→ Caching is one of the most effective ways to improve application performance.
```

## Cache invalidation (phần khó)

```js
// khi dữ liệu thay đổi, cache phải được cập nhật hoặc bỏ (nếu không nó sẽ CŨ)
async function updateUser(id, data) {
  await db.users.update(id, data);
  await redis.del(`user:${id}`);    // INVALIDATE cache (lần đọc sau sẽ lấy mới)
}
```

```text
Stale data is the main caching challenge:
  → Use TTLs (data auto-expires, eventually refreshing)
  → Invalidate (delete/update the cache) when the source data changes
  → "There are only two hard things: cache invalidation and naming things."
```

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

Dùng Redis làm cache là ứng dụng phổ biến và có ảnh hưởng nhất của nó, nên hiểu pattern caching cơ bản là kiến thức thiết yếu, có thể áp dụng rộng rãi để xây ứng dụng có hiệu năng cao.

Kỹ thuật cốt lõi — lưu dữ liệu hay truy cập trong bộ nhớ nhanh của Redis để ứng dụng tránh các thao tác chậm hơn (truy vấn database, gọi API, tính toán tốn kém) — là một trong những cách hiệu quả nhất để cải thiện hiệu năng và khả năng mở rộng, được dùng trong vô số hệ thống production.

Hiểu **pattern cache-aside** (kiểm tra Redis trước; khi hit trả về ngay; khi miss lấy từ nguồn, cache kết quả với TTL, và trả về) là kỹ thuật caching nền tảng mà mọi developer nên biết — đó là cách phần lớn caching được triển khai.

Hiểu **tại sao caching giúp ích** (Redis in-memory nhanh hơn nhiều so với database trên disk hay API ngoài, và caching giảm tải cho database nên nó mở rộng tốt hơn) giải thích lợi ích kép về tốc độ và giảm tải backend.

Quan trọng nhất, hiểu **cache invalidation** — "vấn đề khó" nổi tiếng về việc giữ cho dữ liệu cache không bị cũ, được giải quyết bằng TTL (tự hết hạn) và invalidation tường minh (xóa/cập nhật cache khi dữ liệu nguồn thay đổi) — là thiết yếu vì dữ liệu cũ là cạm bẫy caching chính, và quản lý nó đúng là điều phân biệt các cache hoạt động tốt với các cache lỗi tinh vi.

Vì caching là use case Redis chủ đạo và một trong những kỹ thuật hiệu năng quan trọng nhất trong phần mềm, và vì pattern cache-aside (với invalidation đúng) là cách cơ bản để làm điều đó, hiểu Redis được dùng làm cache như thế nào — pattern, lợi ích của nó, và thách thức invalidation — là kiến thức thiết yếu, thường xuyên được áp dụng để xây ứng dụng nhanh, có khả năng mở rộng, có thể nói là kỹ năng Redis thực hành quan trọng nhất.