Jak škálujete Node.js aplikaci na více CPU jáder?

Question

Accepted Answer

Jeden Node proces využívá pouze **jedno CPU jádro** (jeho JS běží na jednom vlákně). Abyste použili všechna jádra na stroji, spustíte **více Node procesů** — přes modul `cluster`, process manager jako PM2, nebo orchestraci kontejnerů — a vyrovnáváte zátěž požadavků mezi nimi.

## Problém

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

## Modul cluster — fork pracovních procesů

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

Primární proces vytvoří jeden worker na jádro; všichni workeri sdílí stejný port a příchozí spojení jsou mezi nimi distribuována — násobí to propustnost. Porouchané workery lze automaticky restartovat pro zvýšení spolehlivosti.

## V praxi: použijte PM2 (cluster mode)

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

Produktivní aplikace obvykle používají **PM2** (nebo podobné) spíše než psaní cluster kódu ručně — stará se o forking, vyrovnávání zátěže, bezstratové restarty, monitorování a restartování.

## Nebo škálujte s kontejnery/orchestrací

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

## Kritické varování: bezstavovost

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

Aby fungovala škálování s více procesy, vaše aplikace musí být **bezstavová** — jakýkoli sdílený stav (sessions, cache, real-time koordinace) musí žít v externím úložišti jako Redis, nikoli v paměti procesu.

## Proč je to důležité

Využití všech CPU jader je nezbytné pro dosažení plného výkonu Node serveru — jeden proces nechá většinu jader multi-core stroje nečinnou.

Znalost možností (modul cluster, PM2 cluster mode, nebo jeden proces na kontejner s orchestrací) a, zejména, **požadavku na bezstavovost** (sessions/cache/real-time se zálohováním na Redisu, protože procesy nesdílí paměť) je základní pro škálování Node v produkci.

Toto horizontální škálování v kombinaci s bezstavovostí je způsob, jak Node aplikace zvládají vysokou zátěž spolehlivě.