Hvordan skalerer du en Node.js-app på tværs af flere CPUer?

Question

Accepted Answer

En enkelt Node-proces bruger kun **én CPU-kerne** (dens JS kører på én tråd). For at bruge alle kerner på en maskine kører du **flere Node-processer** — via `cluster`-modulet, en process-manager som PM2, eller container-orkestrering — og load-balancerer requests på tværs af dem.

## Problemet

```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-modulet — fork worker-processer

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

Hovedprocessen forker én worker pr. kerne; alle workers deler samme port, og indgående forbindelser distribueres mellem dem — hvilket mangedobler gennemstrømningen. Nedstyrtede workers kan genstarte automatisk for resiliens.

## I praksis: brug PM2 (cluster mode)

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

Produktions-apps bruger normalt **PM2** (eller lignende) i stedet for at skrive cluster-kode manuelt — det håndterer forking, load-balancering, zero-downtime reloads, overvågning og genstarter.

## Eller skalér med containers/orkestrering

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

## Det kritiske forbehold: tilstandsløshed

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

For at multi-proces skalering virker, skal din app være **tilstandsløs** — enhver delt tilstand (sessioner, cache, real-time koordinering) skal bo i en ekstern butik som Redis, ikke i process-hukommelse.

## Hvorfor det betyder noget

At udnytte alle CPU-kerner er essentielt for at få fuld ydeevne fra en Node-server — en enkelt proces lader størstedelen af en multi-core-maskine stå ubrugt.

At kende mulighederne (cluster-modul, PM2 cluster mode, eller én-proces-per-container med orkestrering) og, afgørende, kravet om **tilstandsløshed** (ekstern Redis-understøttet sessioner/cache/real-time, da processer ikke deler hukommelse) er grundlæggende for skalering af Node i produktion.

Denne horisontale skalering, kombineret med tilstandsløshed, er hvordan Node-apps håndterer høj trafik pålideligt.