Fullstack Node.js & React
Trang chủ / Module 7
🧰 Module 7 / 19 · 4 ngày 📅 Tuần 5 ●●●○ Khó

Redis, caching, queue & background jobs

Cache đúng (và vô hiệu hoá cache đúng), hàng đợi việc nền với BullMQ, rate limiting, distributed lock, idempotency key và outbox pattern — để hệ thống nhanh mà không mất dữ liệu.

RedisCacheBullMQRate limitIdempotencyOutbox
📌 Vì sao module này quan trọng

Một API chậm 800ms vì gọi DB 12 lần có thể xuống 30ms nhờ cache — hoặc trả dữ liệu sai cho khách nếu cache không được vô hiệu hoá đúng. Một request gửi email trực tiếp sẽ timeout khi nhà cung cấp email chậm; đẩy vào queue thì trả về ngay và tự retry. Các pattern này là nội dung chính của câu hỏi system design ở vòng phỏng vấn senior.

🎯 Mục tiêu học tập

  • Dùng các cấu trúc dữ liệu Redis đúng việc
  • Áp dụng cache-aside, chọn TTL, tránh cache stampede, vô hiệu hoá cache
  • Xây queue với BullMQ: retry, backoff, concurrency, dead-letter, job định kỳ
  • Cài rate limiting và idempotency key cho API
  • Dùng outbox pattern để sự kiện không bị mất

Redis: chọn đúng cấu trúc dữ liệu

KiểuDùng cho
String (+TTL)Cache JSON, counter (INCR), cờ
HashObject nhiều field, session
SetNgười đang online, tag
Sorted setBảng xếp hạng, rate limit sliding window, hàng đợi ưu tiên
StreamLog sự kiện có consumer group
Pub/SubPhát sự kiện realtime giữa nhiều instance (Module 9)

Redis xử lý lệnh đơn luồng: mỗi lệnh là nguyên tử; nhiều lệnh cần nguyên tử thì dùng MULTI hoặc Lua script. Không dùng KEYS * trên production (dùng SCAN). Valkey là bản fork mã nguồn mở tương thích Redis mà nhiều cloud đã chuyển sang.

Cache-aside và vô hiệu hoá cache

async function getProject(id: string) {
  const key = `project:v1:${id}`;
  const hit = await redis.get(key);
  if (hit) return JSON.parse(hit);

  const project = await repo.findById(id);
  if (project) await redis.set(key, JSON.stringify(project), 'EX', 300 + Math.floor(Math.random() * 60)); // TTL có jitter
  return project;
}

async function updateProject(id: string, data: UpdateDto) {
  const p = await repo.update(id, data);
  await redis.del(`project:v1:${id}`);   // xoá SAU khi DB commit
  return p;
}
  • Cache stampede: key nóng hết hạn, 1000 request cùng đập vào DB. Giải: TTL có jitter, chỉ một tiến trình tải lại (single-flight), hoặc stale-while-revalidate.
  • Chỉ cache thứ đọc nhiều, ghi ít và chấp nhận dữ liệu cũ vài giây. Đo hit rate.
  • Các tầng cache: trình duyệt (Cache-Control) → CDN → cache trong tiến trình (LRU) → Redis → DB.

Queue và background jobs với BullMQ

// producer — trong API
await emailQueue.add('welcome', { userId }, {
  attempts: 5,
  backoff: { type: 'exponential', delay: 2000 },
  removeOnComplete: 1000,
  jobId: `welcome:${userId}`,          // chống tạo job trùng
});

// worker — tiến trình riêng, scale độc lập với API
new Worker('email', async (job) => {
  const user = await users.findById(job.data.userId);
  await mailer.send(welcomeTemplate(user));
}, { connection, concurrency: 10 });

// Job định kỳ
await reportsQueue.upsertJobScheduler('daily-report', { pattern: '0 2 * * *' }, { name: 'daily' });
  • Worker phải idempotent: job có thể chạy lại (retry, worker chết giữa chừng).
  • Job thất bại hết số lần → giữ lại để xem (dead-letter), có dashboard (Bull Board) và cảnh báo.
  • Nên đưa vào queue: email/thông báo, xử lý ảnh/video, gọi webhook ra ngoài, tạo báo cáo, đồng bộ hệ thống khác.

Rate limiting, idempotency, distributed lock

// Idempotency key cho POST /payments — khách bấm 2 lần hoặc mạng retry vẫn chỉ trừ tiền 1 lần
app.post('/payments', async (req, res) => {
  const key = req.header('Idempotency-Key');
  if (!key) throw new AppError(400, 'IDEMPOTENCY_KEY_REQUIRED', 'Missing Idempotency-Key');
  const cacheKey = `idem:${req.user.id}:${key}`;

  const locked = await redis.set(cacheKey, 'PENDING', 'EX', 86400, 'NX');
  if (!locked) {
    const prev = await redis.get(cacheKey);
    if (prev === 'PENDING') throw new AppError(409, 'IN_PROGRESS', 'Request is being processed');
    return res.status(200).json(JSON.parse(prev!));     // trả lại kết quả cũ
  }
  const result = await payments.charge(req.body);
  await redis.set(cacheKey, JSON.stringify(result), 'EX', 86400);
  res.status(201).json(result);
});
  • Rate limit: fixed window (INCR + EXPIRE), sliding window (sorted set), token bucket. Trả 429 + Retry-After. Giới hạn theo user/API key, không chỉ theo IP.
  • Distributed lock (SET NX PX) cho việc chỉ một instance được làm (cron). Lock có TTL và chỉ chủ sở hữu được gỡ. Với việc liên quan tiền, ưu tiên ràng buộc DB hơn lock Redis.

Outbox pattern

await prisma.$transaction(async (tx) => {
  const order = await tx.order.update({ where: { id }, data: { status: 'PAID' } });
  await tx.outbox.create({ data: { type: 'order.paid', payload: { orderId: order.id } } });
});
// Worker: đọc outbox chưa gửi (FOR UPDATE SKIP LOCKED), đẩy vào queue/broker, đánh dấu đã gửi.

Giải quyết "dual write": DB cập nhật xong nhưng tiến trình chết trước khi gửi sự kiện → sự kiện mất. Với outbox, sự kiện và dữ liệu cùng commit hoặc cùng rollback. Đảm bảo at-least-once, nên phía nhận vẫn phải idempotent.

🏋️ Bài tập thực hành

Làm hệ thống nhanh hơn và bền hơn

Trên API của bạn: (1) Cache endpoint chi tiết project, đo p95 trước/sau bằng k6 hoặc autocannon, và viết test chứng minh cập nhật xong thì không đọc ra dữ liệu cũ. (2) Gửi email mời thành viên qua BullMQ worker chạy tiến trình riêng, có retry + backoff; giả lập nhà cung cấp email lỗi 50% và chứng minh không mất email nào. (3) Rate limit 100 request/phút/user. (4) Idempotency key cho endpoint tạo thanh toán; script bắn cùng một key 20 lần đồng thời chỉ tạo 1 bản ghi. (5) Outbox cho sự kiện task.completed.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Áp dụng cache-aside có TTL jitter và vô hiệu hoá đúng
  • Có worker BullMQ chạy riêng, có retry và idempotent
  • API có rate limit và idempotency key
  • Giải thích được outbox pattern và vì sao cần nó