Bagaimana Anda melakukan scaling aplikasi Node.js di berbagai CPU?

Question

Accepted Answer

Satu proses Node hanya menggunakan **satu inti CPU** (JS-nya berjalan pada satu thread). Untuk menggunakan semua inti pada mesin, Anda menjalankan **berbagai proses Node** — melalui modul `cluster`, pengelola proses seperti PM2, atau orkestrasi kontainer — dan menyeimbangkan beban permintaan di antara mereka.

## Masalahnya

```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.
```

## The 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);
}
```

Proses utama melakukan fork satu worker per inti; semua worker berbagi port yang sama, dan koneksi masuk didistribusikan di antara mereka — meningkatkan throughput. Worker yang mogok dapat dimulai ulang secara otomatis untuk resilience.

## Dalam praktik: gunakan PM2 (cluster mode)

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

Aplikasi produksi biasanya menggunakan **PM2** (atau serupa) daripada menulis kode cluster secara manual — ia menangani forking, load balancing, reloads tanpa downtime, monitoring, dan restart.

## Atau scaling dengan kontainer/orkestrasi

```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.
```

## Peringatan kritis: 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
```

Untuk scaling multi-proses berfungsi, aplikasi Anda harus **stateless** — setiap state bersama (session, cache, koordinasi real-time) harus berada di toko eksternal seperti Redis, bukan di memori proses.

## Mengapa ini penting

Menggunakan semua inti CPU sangat penting untuk mendapatkan kinerja penuh dari server Node — satu proses meninggalkan sebagian besar mesin multi-inti dalam keadaan idle.

Mengetahui pilihan (modul cluster, PM2 cluster mode, atau satu-proses-per-kontainer dengan orkestrasi) dan, yang paling penting, **persyaratan statelessness** (session/cache/real-time yang didukung Redis eksternal, karena proses tidak berbagi memori) adalah fundamental untuk scaling Node di produksi.

Scaling horizontal ini, dikombinasikan dengan statelessness, adalah cara aplikasi Node menangani traffic tinggi secara andal.