એક જ Node process માત્ર એક CPU core ને વાપરે છે (તેનો JS એક thread પર ચાલે છે). મશીન પર તમામ cores ને વાપરવા માટે, તમે બહુવિધ Node processes ચલાવો છો — cluster module દ્વારા, PM2 જેવા process manager દ્વારા, અથવા 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);
}
પ્રાથમિક process એક worker ને પ્રતિ core તરીકે fork કરે છે; તમામ workers એક જ port ને શેર કરે છે, અને આવતા connections તેમની વચ્ચે વિતરિત કર્યા જાય છે — throughput ને ગુણાકાર કરે છે. ક્રેશ થયેલા workers ને સ્થિતિશીલતા માટે સ્વયંક્રિયપણે પુનઃશરૂ કરી શકાય છે.
pm2 start app.js -i max # run one instance per CPU core, with auto-restart & monitoring
ઉત્પાદન apps સામાન્યતઃ PM2 (અથવા સમાન) નો ઉપયોગ કરે છે cluster code ને હાથથી લખવાને બદલે — તે forking, load balancing, zero-downtime reloads, monitoring, અને restarts ને સંભાળે છે.
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
બહુ-process scaling ને કાર્યરત કરવા માટે, તમારો app stateless હોવો જોઈએ — કોઈ પણ શેર કરેલ state (sessions, cache, real-time coordination) બાહ્ય store જેમ કે Redis માં રહેવું જોઈએ, process memory માં નહીં.
તમામ CPU cores નો ઉપયોગ કરવો એ Node server થી સંપૂર્ણ કાર્યક્ષમતા મેળવવા માટે આવશ્યક છે — એક જ process બહુ-core મશીનનો મોટો ભાગ નિષ્ક્રિય રાખે છે.
વિકલ્પોને જાણવું (cluster module, PM2 cluster mode, અથવા container orchestration સાથે એક-process-per-container) અને, નિર્ણાયક રીતે, statelessness requirement (external Redis-backed sessions/cache/real-time, કારણ કે processes મેમરી ને શેર કરતા નથી) Node ને production માં સ્કેલ કરવા માટે મૌલિક છે.
यહ horizontal scaling, statelessness સાથે, એ છે કે કેવી રીતે Node apps ઊચ્ચ traffic ને વિશ્વસનીય રીતે સંભાળે છે.