Kaip išplėsti Node.js programą keliuose CPU procesorių branduoliuose?

Question

Accepted Answer

Vienas Node procesas naudoja tik **vieną CPU branduolį** (jo JS veikia viename gijoje). Norint naudoti visus kompiuterio branduolius, turite paleisti **kelis Node procesus** — per `cluster` modulį, proceso valdiklį kaip PM2 arba konteinerio orkestraciją — ir pasiskirstyti užklausas tarp jų.

## Problema

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

## cluster modulis — darbininko procesų sukūrimas (fork)

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

Pagrindinė procesas sukuria vieną darbininką kiekvienam branduoliui; visi darbininkai naudoja tą pačią prievadą, ir gaunamieji ryšiai pasiskirstomi tarp jų — padidindami pralaidumą. Sugriuvę darbininkai gali būti automatiškai iš naujo paleisti siekiant patikimumo.

## Praktikoje: naudokite PM2 (cluster režimą)

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

Produkcijos programos paprastai naudoja **PM2** (arba panašią) vietoj to, kad pačios rašytų cluster kodą — ji tvarko procesų sukūrimą, apkrovos balansinį, nulinio sustojimo įkėlimą, stebėseną ir iš naujo paleidimą.

## Arba mastelis su konteineriais/orkestracija

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

## Kritinis įspėjimas: beasmenybė

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

Norint, kad kelių procesų mastelis veiktų, jūsų programa turi būti **beasmenis** — bet kuris bendrasis būsena (seansai, talpykla, realaus laiko koordinacija) turi egzistuoti išorinėje saugykloje, pvz. Redis, o ne proceso atmintyje.

## Kodėl tai svarbu

Visų CPU branduolių išnaudojimas yra būtinas norint gauti maksimalų Node serverio efektyvumą — vienas procesas palikti didžiąją dalį daugiakalio kompiuterio neaktyvią.

Žinojimas apie galimybes (`cluster` modulis, PM2 cluster režimas arba vienas procesas konteineriu su orkestracija) ir, svarbiausia, **beasmenybės reikalavimas** (išorinės Redis pagrindinės seansai/talpykla/realaus laiko, nes procesai negali dalytis atmintimi) yra pagrindingas Node masteliui gamyboje.

Šis horizontalus mastelis, sujungtas su beasmenybe, yra tai, kaip Node programos patikimai apdoroja didelį srautą.