आप Node.js ऐप्लिकेशन को कई CPUs पर कैसे स्केल करते हैं?

Question

Accepted Answer

एक एकल Node प्रक्रिया केवल **एक CPU कोर** का उपयोग करती है (इसका JS एक थ्रेड पर चलता है)। मशीन के सभी कोर का उपयोग करने के लिए, आप **कई Node प्रक्रियाएं** चलाते हैं — `cluster` मॉड्यूल, PM2 जैसे प्रक्रिया प्रबंधक, या कंटेनर आर्केस्ट्रेशन के माध्यम से — और अनुरोधों को उनमें लोड-संतुलित करते हैं।

## समस्या

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

## The cluster module — fork worker processes

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

प्राथमिक प्रक्रिया प्रत्येक कोर के लिए एक कार्यकर्ता फोर्क करती है; सभी कार्यकर्ता एक ही पोर्ट साझा करते हैं, और आने वाले कनेक्शन उनके बीच वितरित किए जाते हैं — throughput गुणा करते हैं। विफल कार्यकर्ताओं को लचीलापन के लिए स्वचालित रूप से पुनः शुरू किया जा सकता है।

## व्यवहार में: 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 को संभालता है।

## या कंटेनर/आर्केस्ट्रेशन के साथ स्केल करें

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

## महत्वपूर्ण चेतावनी: 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) एक बाहरी store जैसे Redis में रहना चाहिए, प्रक्रिया मेमोरी में नहीं।

## यह क्यों महत्वपूर्ण है

Node सर्वर से पूर्ण प्रदर्शन प्राप्त करने के लिए सभी CPU कोर का उपयोग करना आवश्यक है — एक एकल प्रक्रिया एक मल्टी-कोर मशीन के अधिकांश को निष्क्रिय छोड़ देती है।

विकल्पों को जानना (cluster module, PM2 cluster mode, या container orchestration के साथ एक-प्रक्रिया-प्रति-कंटेनर) और, महत्वपूर्ण रूप से, **statelessness requirement** (बाहरी Redis-backed sessions/cache/real-time, चूंकि प्रक्रियाएं मेमोरी साझा नहीं करती) उत्पादन में Node को स्केल करने के लिए मौलिक है।

यह क्षैतिज स्केलिंग, statelessness के साथ मिलकर, यह है कि Node ऐप्स उच्च ट्रैफिक को विश्वसनीय रूप से कैसे संभालते हैं।