ਇੱਕ ਸਿੰਗਲ Node ਪ੍ਰੋਸੇਸ ਸਿਰਫ ਇੱਕ CPU ਕੋਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ (ਇਸ ਦਾ JS ਇੱਕ thread ਤੇ ਚਲਦਾ ਹੈ)। ਮਸ਼ੀਨ ਦੇ ਸਾਰੇ ਕੋਰਸ ਨੂੰ ਵਰਤਣ ਲਈ، ਤੁਸ ਮਲਟੀਪਲ Node ਪ੍ਰੋਸੇਸਜ ਚਲਾਉਂਦੇ ਹੋ — cluster ਮੋਡਿਊਲ ਰਾਹੀਂ، PM2 ਵਰਗੇ ਪ੍ਰੋਸੇਸ ਮਿਨੇਜਰ ਰਾਹੀਂ، ਜਾਂ container orchestration ਰਾਹੀਂ — ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਅੱਖ ਪਾਸੇ requests ਨੂੰ load-balance ਕਰਦੇ ਹੋ।
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.
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);
}
ਪ੍ਰਾਇਮਰੀ ਪ੍ਰੋਸੇਸ ਇੱਕ ਪ੍ਰਤਿ ਕੋਰ ਵਰਕਰ fork ਕਰਦਾ ਹੈ; ਸਾਰੇ ਵਰਕਰ ਇੱਕੋ port ਸ਼ੇਅਰ ਕਰਦੇ ਹਨ، ਅਤੇ ਆਉਣ ਵਾਲੀਆਂ connections ਨੂੰ ਉਨ੍ਹਾਂ ਦੇ ਅੱਖ ਪਾਸੇ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ — throughput ਨੂੰ ਗੁਣਾ ਕਰਦੇ ਹੋ। Crashed ਵਰਕਰਸ ਨੂੰ resilience ਲਈ auto-restart ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
pm2 start app.js -i max # run one instance per CPU core, with auto-restart & monitoring
ਪ੍ਰੋਡਕਸ਼ਨ ਐਪਸ ਆਮ ਤੌਰ 'ਤੇ PM2 (ਜਾਂ ਸਮਾਨ) ਵਰਤਦੀਆਂ ਹਨ ਹੱਥੋ-ਹੱਥ ਕਲਸਟਰ ਕੋਡ ਲਿਖਣ ਦੀ ਬਜਾਏ — ਇਹ forking، load balancing، zero-downtime reloads، monitoring، ਅਤੇ restarts ਨੂੰ handle ਕਰਦਾ ਹੈ।
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.
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 ਵਿੱਚ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ، ਪ੍ਰੋਸੇਸ ਮੈਮੋਰੀ ਵਿੱਚ ਨਹੀਂ।
ਸਾਰੇ CPU cores ਨੂੰ ਵਰਤਣਾ ਇੱਕ Node server ਤੋਂ ਪੂਰੀ performance ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਇੱਕ ਸਿੰਗਲ ਪ੍ਰੋਸੇਸ ਇੱਕ ਮਲਟੀ-ਕੋਰ ਮਸ਼ੀਨ ਦਾ ਜ਼ਿਆਦਾਤਰ idle ਛੱਡ ਦਿੰਦਾ ਹੈ।
ਵਿਕਲਪਾਂ ਨੂੰ ਜਾਣਨਾ (cluster module، PM2 cluster mode، ਜਾਂ containers ਦੇ ਨਾਲ ਇੱਕ-process-per-container orchestration) ਅਤੇ، ਖਾਸ ਤੌਰ 'ਤੇ، statelessness ਲੋੜ (external Redis-backed sessions/cache/real-time، ਕਿਉਂਕਿ processes memory ਨੂੰ share ਨਹੀਂ ਕਰਦੇ) Node ਨੂੰ production ਵਿੱਚ ਸਕੇਲ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।
ਇਹ horizontal scaling، statelessness ਦੇ ਨਾਲ، ਉਹ ਹੈ ਜਿਥੇ Node ਐਪਸ high traffic ਨੂੰ reliably handle ਕਰਦੀਆਂ ਹਨ।