तपाईंले Node.js अनुप्रयोगलाई एकै साथ सिपियु (CPU) मार्फत कसरी स्केल गर्नुहुन्छ?

Question

Accepted Answer

एक Node process ले केवल **एक CPU core** मात्र प्रयोग गर्छ (यसको JS एक thread मा चल्छ)। मेसिनका सबै cores प्रयोग गर्न, तपाईंले **एकै साथ धेरै Node processes** चलाउनुहुन्छ — `cluster` module मार्फत, 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 module — worker processes 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);
}
```

प्राथमिक प्रक्रियाले प्रत्येक core को लागि एक worker fork गर्छ; सबै workers एक पोर्ट साझा गर्छन्, र आने जडानहरु तिनमाझ वितरित हुन्छन् — throughput लाई गुणा गर्दै। क्रैश भएका workers लचीलोपनको लागि स्वचालित रूपमा पुनः सुरु गर्न सकिन्छ।

## व्यवहारमा: PM2 प्रयोग गर्नुहोस् (cluster mode)

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

उत्पादन अनुप्रयोगहरु सामान्यतः **PM2** (वा समान) प्रयोग गर्छन् cluster code हाতले लेख्नुको सट्टा — यो forking, load balancing, zero-downtime reloads, निगरानी, र 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 समन्वय) Redis जस्तो बाह्य store मा बस्नुपर्छ, प्रक्रिया स्मृतिमा होइन।

## यो किन महत्त्वपूर्ण छ

सबै CPU cores को उपयोग गर्नु Node सर्भरबाट पूर्ण कार्यक्षमता प्राप्त गर्न आवश्यक छ — एक प्रक्रियाले एक multi-core मेसिनको अधिकांश भाग अक्षम राख्छ।

विकल्पहरु जान्नु (cluster module, PM2 cluster mode, वा container-प्रति-एक-प्रक्रिया अर्केस्ट्रेशनको साथ) र, महत्त्वपूर्ण रूपमा, **statelessness आवश्यकता** (बाह्य Redis-backed sessions/cache/real-time, किनभने प्रक्रियाहरु स्मृति साझा गर्दैनन्) उत्पादनमा Node लाई स्केल गर्न आधारभूत छ।

यो horizontal scaling, statelessness को साथ संयुक्त, Node अनुप्रयोगहरु उच्च ट्राफिक विश्वसनीय रूपमा सम्हाल्ने तरिका हो।