คุณจะปรับขนาด Node.js แอปทั่วหลาย CPU ได้อย่างไร

Question

Accepted Answer

กระบวนการ Node เดียว ใช้เพียง **หนึ่ง CPU core** (JS ของมันทำงานบน thread หนึ่ง) เพื่อใช้ทั้งหมด cores บนเครื่อง คุณเรียกใช้ **กระบวนการ Node หลายตัว** — ผ่าน `cluster` module, process manager เช่น PM2, หรือ container orchestration — และ load-balance คำขอทั่วพวกมัน

## ปัญหา

```text
A server with 8 CPU cores running ONE Node process → uses ~1 core, wastes 7.
Need multiple processes to utilize all cores and handle more concurrent load.
```

## cluster module — fork worker processes

```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(); // spawn one worker process per CPU core
  }
  cluster.on("exit", (worker) => {
    console.log(`worker ${worker.process.pid} died — restarting`);
    cluster.fork(); // restart a crashed worker (resilience)
  });
} else {
  // each worker runs the actual server; the OS load-balances connections across them
  http.createServer((req, res) => res.end("handled by " + process.pid)).listen(3000);
}
```

กระบวนการหลักจะ fork worker หนึ่งตัวต่อ core; workers ทั้งหมดใช้ port เดียวกัน และการเชื่อมต่อขาเข้าจะถูกกระจายไปยังพวกมัน — การเพิ่ม throughput การเพิ่ม Workers ที่หัก สามารถ auto-restarted เพื่อความยืดหยุ่น

## ในทางปฏิบัติ: ใช้ PM2 (cluster mode)

```bash
pm2 start app.js -i max   # run one instance per CPU core, with auto-restart & monitoring
```

แอปการผลิตโดยทั่วไปใช้ **PM2** (หรือคล้ายคลึงกัน) แทนการเขียนรหัส cluster ด้วยมือ — มันจัดการ forking, load balancing, zero-downtime reloads, monitoring, และ restarts

## หรือ scale ด้วย containers/orchestration

```text
Run ONE Node process per container, and run MANY containers (Kubernetes, ECS),
with a load balancer in front. This is the modern cloud approach — simpler
per-process model, scaling handled by the orchestrator across machines.
```

## การเตือน วิกฤตที่สำคัญ: statelessness

```text
Multiple processes don't share memory. So:
⚠️ Don't store sessions/state in process memory → use Redis/a shared store
⚠️ In-memory caches aren't shared across workers → use Redis for shared cache
⚠️ WebSocket connections live on one worker → use a Redis adapter to coordinate
```

เพื่อให้การปรับขนาด multi-process ทำงาน แอปของคุณต้องเป็น **stateless** — state ที่ใช้ร่วมกัน (sessions, cache, real-time coordination) ต้องอยู่ใน external store เช่น Redis ไม่ใช่ใน process memory

## ทำไมมันถึงสำคัญ

การใช้ประโยชน์จากทั้งหมด CPU cores เป็นสิ่งสำคัญเพื่อได้ประสิทธิภาพเต็มที่จากเซิร์ฟเวอร์ Node — กระบวนการเดียวปล่อยให้เครื่อง multi-core ส่วนใหญ่ idle

การรู้ตัวเลือก (cluster module, PM2 cluster mode หรือ one-process-per-container ด้วย orchestration) และ สำคัญที่สุดคือ **statelessness requirement** (external Redis-backed sessions/cache/real-time เนื่องจากกระบวนการไม่ share memory) เป็นสิ่งจำเป็นสำหรับการปรับขนาด Node ในการผลิต

การปรับขนาดตามแนวนอนนี้ ร่วมกับ statelessness คือวิธีที่แอป Node จัดการกับ traffic สูง อย่างน่าเชื่อถือ