Piye carane ngskalani aplikasi Node.js ing macem-macem CPU?

Question

Accepted Answer

Siji Node proses mung nganggo **siji CPU core** (JS-ne mlaku ing siji thread). Kanggo nganggo kabeh core ing mesin, lagi-lagi njalanake **macem-macem Node proses** — liwat modul `cluster`, pengelola proses kaya PM2, utawa orkestrasi kontainer — lan nyandheng-nyandheng permintaan ing antarane.

## Masalahe

```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 nggawe fork siji worker per core; kabeh worker mbarengi port sing padha, lan koneksi masuk didistribusi antarane — nambah throughput. Worker sing rusak bisa diwiwiti maneh kanthi otomatis kanggo kelenturan.

## Ing praktek: gunakake PM2 (cluster mode)

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

Apalikasi produksi biasane nggunakake **PM2** (utawa serupa) tinimbang nulis kode cluster kanthi manual — nangani forking, load balancing, reload tanpa downtime, monitoring, lan restart.

## Utawa skala karo 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
```

Kanggo multi-proses scaling bisa gumana, aplikasimu kudu **stateless** — suwene kondisi bersama (session, cache, koordinasi real-time) kudu ana ing panyimpenan eksternal kaya Redis, ora ana ing memori proses.

## Kenapa iki penting

Nggunakake kabeh CPU core penting kanggo njaluk kinerja lengkap saka server Node — siji proses ninggalake sebagian besar mesin multi-core dadi idle.

Ngerti pilihan (modul cluster, PM2 cluster mode, utawa siji-proses-per-kontainer karo orkestrasi) lan, sing paling penting, **persyaratan statelessness** (session/cache/real-time sing didukung Redis eksternal, amarga proses ora mbarengi memori) minangka dhasar kanggo scaling Node ing produksi.

Scaling horisontal iki, digabungake karo statelessness, mau carane aplikasi Node nangani traffic dhuwur kanthi dipercaya.