Node.js అనువర్తనాన్ని అనేక CPUలలో ఎలా స్కేల్ చేయాలి?

Question

Accepted Answer

ఒకే Node ప్రక్రియ **ఒక CPU కోర్** మాత్రమే ఉపయోగించుకుంటుంది (దీని JS ఒక thread-లో నడుస్తుంది). యంత్రంలో అన్ని కోర్‌లను ఉపయోగించుకోవడానికి, మీరు **బహుళ Node ప్రక్రియలను** నడుపుతారు — `cluster` మాడ్యూల్ ద్వారా, PM2 వంటి ప్రక్రియ నిర్వాహకం, లేదా కంటైనర్ సమన్వయం — మరియు వాటిలో అంతటా అభ్యర్థనలను load-balance చేస్తారు.

## సమస్య

```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 మాడ్యూల్ — worker ప్రక్రియలను 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);
}
```

ప్రాథమిక ప్రక్రియ ఒక్కో కోర్ కోసం ఒక worker ను fork చేస్తుంది; అన్ని workers ఒకే port ను భాగస్వామ్యం చేస్తారు, మరియు ఇన్‌కమింగ్ కనెక్షన్‌లు వాటిలో పంపిణీ చేయబడతాయి — throughput ను గుణించారు. క్రాష్‌డ్ workers నిరోధకత కోసం ఆటో-రీస్టార్ట్ చేయవచ్చు.

## ఆచరణలో: PM2 ఉపయోగించండి (cluster mode)

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

ప్రొడక్షన్ అనువర్తనాలు సాధారణంగా **PM2** (లేదా సమానమైనది) ఉపయోగించుకుంటాయి — cluster కోడ్ ను చేతితో రాయకుండా — ఇది forking, load balancing, zero-downtime reloads, monitoring, మరియు restarts ను నిర్వహిస్తుంది.

## లేదా containers/orchestration తో స్కేల్ చేయండి

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

## విమర్శనమైన caveat: statelessness

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

బహు-ప్రక్రియ స్కేలింగ్ కోసం పని చేయుటకు, మీ అనువర్తనం **stateless** ఉండాలి — ఏదైనా భాగస్వామ్య state (sessions, cache, real-time coordination) Redis వంటి బాహ్య store లో నివసించాలి, ప్రక్రియ మెమరిలో కాదు.

## దీని ఎందుకు ప్రాముఖ్యతైనది

Node సర్వర్ నుండి పూర్తి పనితీరు పొందడానికి అన్ని CPU కోర్‌లను ఉపయోగించుకోవడం చాలా ముఖ్యమైనది — ఒకే ప్రక్రియ మల్టీ-కోర్ మెషిన్‌లో చాలా వరకు నిష్క్రియంగా ఉంటుంది.

NODE ని ప్రొడక్షన్‌లో స్కేల్ చేయడానికి ఆప్షన్‌లను తెలుసుకోవడం (cluster మాడ్యూల్, PM2 cluster mode, లేదా orchestration తో ఒక-ప్రక్రియ-ప్రతి-కంటైనర్) మరియు, కీలకంగా, **statelessness requirement** (బాహ్య Redis-backed sessions/cache/real-time, ప్రక్రియలు మెమరీని భాగస్వామ్యం చేయవు కాబట్టి) ఆధారమైనది.

ఈ సమాంతర స్కేలింగ్, statelessness తో, Node అనువర్తనాలు ఎక్కువ ట్రాఫిక్ నమ్రతగా నిర్వహించే విధానం.