Kako skalirate Node.js aplikaciju na više CPU jezgri?

Question

Accepted Answer

Jedan Node proces koristi samo **jednu CPU jezgru** (njegov JS se izvršava u jednoj niti). Kako biste koristili sve jezgre na stroju, trebate pokrenuti **više Node procesa** — preko `cluster` modula, upravitelja procesa poput PM2-a ili orkestracijom kontejnera — i rasporediti zahtjeve između njih.

## Problem

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

Primarni proces kreira jedan worker po jezgri; svi workeri dijele istu luku, a dolazne veze se distribuiraju među njima — što se umnožava propusnost. Srušeni workeri mogu se automatski ponovno pokrenuti za otpornost.

## U praksi: koristite PM2 (cluster mode)

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

Produkcijske aplikacije obično koriste **PM2** (ili slično) umjesto ručnog pisanja cluster koda — brine se o kreiranju procesa, raspodjeli opterećenja, nultom vremenu mirovanja, nadgledanju i ponovnom pokretanju.

## Ili skaliranje s kontejnerima/orkestracijom

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

## Kritično upozorenje: stanje bez statusa

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

Da bi višeprocesno skaliranje funkcioniralo, vaša aplikacija mora biti **bez stanja (stateless)** — bilo koji dijeljeni dio stanja (sesije, cache, sinkronizacija u stvarnom vremenu) mora biti u vanjskom pohraništu poput Redisa, a ne u memoriji procesa.

## Zašto je to važno

Iskorištavanje svih CPU jezgri ključno je za dobivanje pune performanse Node servera — jedan proces ostavlja većinu jezgri na multi-jezgros stroju neiskorištenom.

Poznavanja opcija (cluster modul, PM2 cluster mode ili jedan-proces-po-kontejneru s orkestracijom) i, što je odlučujuće, **zahtjev za stanjem bez statusa** (vanjski Redis-podržani sesije/cache/sinkronizacija u stvarnom vremenu, jer procesi ne dijele memoriju) fundamental je za skaliranje Node-a u produkciji.

Ovo horizontalno skaliranje, kombinirano sa stanjem bez statusa, je kako Node aplikacije pouzdano rukovode s visokim prometom.