Node.js uygulamasını birden fazla CPU'ya nasıl ölçeklersiniz?

Question

Accepted Answer

Tek bir Node işlemi yalnızca **bir CPU çekirdeği** kullanır (JS'si bir thread'de çalışır). Bir makinedeki tüm çekirdekleri kullanmak için, **birden fazla Node işlemi** çalıştırırsınız — `cluster` modülü, PM2 gibi bir process manager veya container orchestration aracılığıyla — ve istekleri aralarında load-balance edersiniz.

## Sorun

```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 modülü — worker işlemlerini fork edin

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

Birincil işlem her çekirdek için bir worker fork eder; tüm worker'lar aynı port'u paylaşır ve gelen bağlantılar aralarında dağıtılır — throughput'u çoğaltır. Çöken worker'lar esneklik için otomatik olarak yeniden başlatılabilir.

## Pratikte: PM2 kullanın (cluster mode)

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

Üretim uygulamaları genellikle cluster kodunu elle yazmak yerine **PM2** (veya benzer bir araç) kullanır — forking, load balancing, zero-downtime reloads, monitoring ve restart işlemlerini gerçekleştirir.

## Veya container'lar/orchestration ile ölçekleyin

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

## Neden önemli

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

Multi-process ölçeklemeyi çalışır hale getirmek için uygulamanız **stateless** olmalıdır — herhangi bir paylaşılan state (sessions, cache, real-time coordination) Redis gibi bir harici store'da bulunmalı, process belleğinde değil.

## Neden önemli

Node sunucusundan tam performans elde etmek için tüm CPU çekirdeklerini kullanmak önemlidir — tek bir işlem multi-core bir makinenin çoğunu boşta bırakır.

Node'u üretimde ölçekleme seçeneklerini bilmek (cluster modülü, PM2 cluster mode veya orchestration ile bir-işlem-per-container) ve kritik olarak **statelessness gereksinimi** (işlemler belleği paylaşmadığı için harici Redis-backed sessions/cache/real-time) Node'u üretimde ölçekleme için temeldir.

Bu yatay ölçekleme, statelessness ile birlikte, Node uygulamalarının yüksek trafiği güvenilir bir şekilde işlemesinin yoludur.