Hogyan lehet egy Node.js alkalmazást több CPU magra skálázni?

Question

Accepted Answer

Egy Node folyamat csak **egy CPU magot** használ (a JS egy szálon fut). Annak érdekében, hogy a gép összes magjának használhassuk, több Node folyamatot kell futtatnunk — a `cluster` modulon keresztül, egy folyamatkezelővel, például PM2-vel, vagy konténer orkesztráció segítségével — és terheléselosztást végezzünk a kérések között.

## A probléma

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

Az elsődleges folyamat egy munkavégzőt indít magjánként; az összes munkavégző ugyanazt a portot osztja meg, és a bejövő kapcsolatok elosztódnak köztük — az átviteli sebesség megsokszorozódik. Az összeomlott munkavégzők automatikusan újraindíthatók az ellenálló képesség érdekében.

## A gyakorlatban: használja a PM2-t (cluster mode)

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

A termelési alkalmazások általában **PM2-t** (vagy hasonlót) használnak, nem pedig kézzel írott cluster kód — kezeli a forkingot, a terheléselosztást, a leállás nélküli újratöltéseket, a monitorozást és az újraindításokat.

## Vagy skálázás konténerekkel/orkesztráció segítségével

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

## Kritikus figyelmeztetés: állapot nélküliség

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

Ahhoz, hogy a többfolyamatos skálázás működjön, az alkalmazásnak **állapot nélkülinek (stateless)** kell lennie — bármely megosztott állapot (munkamenetek, gyorsítótár, valós idejű koordináció) egy külső tárolóban, például Redisben kell lennie, nem a folyamat memóriájában.

## Miért fontos

Az összes CPU mag kihasználása elengedhetetlen a Node szerver teljes teljesítményéhez — egy egyetlen folyamat egy többmagos gépnek a többségét tétlenül hagyja.

A lehetőségek ismerete (cluster modul, PM2 cluster mode, vagy egy-folyamat-konténerenként orkesztráció segítségével) és a **szükséges állapot nélküliség** (külső Redis-alapú munkamenetek/gyorsítótár/valós idejű, mivel a folyamatok nem osztják meg a memóriát) alapvető a Node termelésben való skálázásához.

Ez a horizontális skálázás, az állapot nélküliséggel kombinálva, azt mutatja meg, hogyan kezeljük a Node alkalmazások a magas forgalmat megbízhatóan.