Conas a scálann tú app Node.js trasna iomaad CPUs?

Question

Accepted Answer

Ní úsáideann próiseas Node aonair ach **cór CPU amháin** (ritheann a JS ar snáithe amháin). Chun gach cór ar an meaisín a úsáid, rithíonn tú **iomaad phróiseas Node** — trí mhodúl an `cluster`, bainisteoir próiseas cosúil le PM2, nó eagrú coimeádáin — agus déan dáileadh ualach ar iarratais trasna orthu.

## An fhadhb

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

## An modúl cluster — próiseas fothopair a fhorcáirniú

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

Forcáirníonn an próiseas príomhúil oibrí amháin in aghaidh an chóir; roinneann gach oibrí an port céanna, agus dáiltear na naisc isteach eatarthu — ag iolrú an fholuain. Is féidir oibrí a thit a atosú go huathoibríoch ar bhonús athléimneachta.

## Go praiticiúil: úsáid PM2 (modh cluster)

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

Is gnách go n-úsáideann feidhmchláir dhéantúsa **PM2** (nó cosúil leis) seachas cód cluster a scríobh de láimh — déanann sé an fhorcáirniú, an dáileadh ualach, an t-athlódáil gan dúnta, an monatóireacht, agus an atosú a láimhseáil.

## Nó scála le coimeádáin/eagrúchán

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

## An rabhaidh chriticiúil: gan stáit

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

Chun go n-oibreoinn scálú ilphróiseas, ní mór do do app a bheith **gan stáit** — ní mór do aon stáit roinnte (seisiúin, taisce, comhordú fíor-ama) a bheith i stór seachtrach cosúil le Redis, ní i cuimhne an phróiseas.

## Cén fáth a bhí tábhacht ann

Tá gach cór CPU a úsáid ríthábhachtach chun feidhmíocht iomlán a fháil ó fhreastalaí Node — fágann próiseas aonair an chuid is mó d'inneall ilchóir ar foluain.

Is bunúsach an eolas ar na roghanna (modúl cluster, modh cluster PM2, nó próiseas amháin-in-aghaidh-an-choimeádáin le eagrúchán) agus, go tábhachtach, an gealltanas **gan stáit** (seisiúin agus taisce agus fíor-ama a bhacáil le Redis, ós rud é nach n-imlíonann próiseas cuimhne) chun Node a scálú i dtáirgeachta.

Is é an scálú cothrománach seo, i bpáirt le gan stáit, conas a láimhsíonn feidhmchláir Node trácht ard go iontaofa.