Làm thế nào để scale một ứng dụng Node.js trên nhiều CPU?

Question

Accepted Answer

Một tiến trình Node đơn lẻ chỉ dùng **một nhân CPU** (JS của nó chạy trên một luồng). Để dùng tất cả các nhân trên một máy, bạn chạy **nhiều tiến trình Node** — qua module `cluster`, một process manager như PM2, hoặc container orchestration — và cân bằng tải các request giữa chúng.

## Vấn đề

```text
Một server có 8 nhân CPU chạy MỘT tiến trình Node → dùng ~1 nhân, lãng phí 7.
Cần nhiều tiến trình để tận dụng tất cả các nhân và xử lý nhiều tải đồng thời hơn.
```

## Module cluster — fork các tiến trình worker

```js
import cluster from "cluster";
import { cpus } from "os";
import http from "http";

if (cluster.isPrimary) {
  const numCPUs = cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork(); // sinh một tiến trình worker cho mỗi nhân CPU
  }
  cluster.on("exit", (worker) => {
    console.log(`worker ${worker.process.pid} died — restarting`);
    cluster.fork(); // khởi động lại worker bị crash (khả năng phục hồi)
  });
} else {
  // mỗi worker chạy server thực sự; OS cân bằng tải các kết nối giữa chúng
  http.createServer((req, res) => res.end("handled by " + process.pid)).listen(3000);
}
```

Tiến trình primary fork một worker cho mỗi nhân; tất cả worker chia sẻ cùng một port, và các kết nối đến được phân phối giữa chúng — nhân lên thông lượng (throughput). Worker bị crash có thể được tự động khởi động lại để có khả năng phục hồi.

## Trong thực tế: dùng PM2 (cluster mode)

```bash
pm2 start app.js -i max   # chạy một instance cho mỗi nhân CPU, với auto-restart & monitoring
```

Các ứng dụng production thường dùng **PM2** (hoặc tương tự) thay vì tự viết tay code cluster — nó lo việc fork, cân bằng tải, reload không downtime, monitoring, và restart.

## Hoặc scale bằng containers/orchestration

```text
Chạy MỘT tiến trình Node mỗi container, và chạy NHIỀU container (Kubernetes, ECS),
với một load balancer phía trước. Đây là cách tiếp cận cloud hiện đại — mô hình mỗi
tiến trình đơn giản hơn, việc scale do orchestrator xử lý trên nhiều máy.
```

## Lưu ý tối quan trọng: tính stateless

```text
Nhiều tiến trình không chia sẻ bộ nhớ. Vì vậy:
⚠️ Đừng lưu session/state trong bộ nhớ tiến trình → dùng Redis/một kho chia sẻ
⚠️ Cache trong bộ nhớ không được chia sẻ giữa các worker → dùng Redis cho cache chia sẻ
⚠️ Kết nối WebSocket nằm trên một worker → dùng Redis adapter để điều phối
```

Để việc scale đa tiến trình hoạt động, ứng dụng của bạn phải **stateless** — mọi state chia sẻ (session, cache, điều phối thời gian thực) phải nằm trong một kho bên ngoài như Redis, không phải trong bộ nhớ tiến trình.

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

Tận dụng tất cả các nhân CPU là điều thiết yếu để đạt hiệu năng đầy đủ từ một server Node — một tiến trình đơn lẻ để phần lớn một máy đa nhân nằm không.

Biết các lựa chọn (module cluster, PM2 cluster mode, hoặc một-tiến-trình-mỗi-container với orchestration) và, quan trọng nhất, **yêu cầu về tính stateless** (session/cache/thời gian thực dựa trên Redis bên ngoài, vì các tiến trình không chia sẻ bộ nhớ) là nền tảng để scale Node trong production.

Việc scale theo chiều ngang này, kết hợp với tính stateless, là cách các ứng dụng Node xử lý lưu lượng cao một cách đáng tin cậy.