Cluster

[Stable: 2 - 安定]

ソースコード: lib/cluster.js

Node.js プロセスのクラスタは、アプリケーションスレッド間でワークロードを分散できる Node.js の複数のインスタンスを実行するために使用できます。プロセス分離が必要ない場合は、代わりに worker_threads モジュールを使用してください。これにより、単一の Node.js インスタンス内で複数のアプリケーションスレッドを実行できます。

cluster モジュールを使用すると、すべてがサーバーポートを共有する子プロセスを簡単に作成できます。

ESMCJS

import cluster from 'node:cluster'
import http from 'node:http'
import { availableParallelism } from 'node:os'
import process from 'node:process'

const numCPUs = availableParallelism()

if (cluster.isPrimary) {
  console.log(`プライマリ ${process.pid} が実行中です`)

  // ワーカーをフォークします。
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`ワーカー ${worker.process.pid} が終了しました`)
  })
} else {
  // ワーカーは任意の TCP 接続を共有できます
  // この場合は HTTP サーバーです
  http
    .createServer((req, res) => {
      res.writeHead(200)
      res.end('hello world\n')
    })
    .listen(8000)

  console.log(`ワーカー ${process.pid} が開始しました`)
}

const cluster = require('node:cluster')
const http = require('node:http')
const numCPUs = require('node:os').availableParallelism()
const process = require('node:process')

if (cluster.isPrimary) {
  console.log(`プライマリ ${process.pid} が実行中です`)

  // ワーカーをフォークします。
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`ワーカー ${worker.process.pid} が終了しました`)
  })
} else {
  // ワーカーは任意の TCP 接続を共有できます
  // この場合は HTTP サーバーです
  http
    .createServer((req, res) => {
      res.writeHead(200)
      res.end('hello world\n')
    })
    .listen(8000)

  console.log(`ワーカー ${process.pid} が開始しました`)
}

Node.js を実行すると、ポート 8000 がワーカー間で共有されるようになります。

bash

$ node server.js
プライマリ 3596 が実行中です
ワーカー 4324 が開始しました
ワーカー 4520 が開始しました
ワーカー 6056 が開始しました
ワーカー 5644 が開始しました

Windows では、ワーカーで名前付きパイプサーバーをセットアップすることはまだできません。

仕組み

ワーカープロセスは、child_process.fork() メソッドを使用して生成されるため、IPC を介して親と通信し、サーバーハンドルをやり取りできます。

cluster モジュールは、着信接続を分散する 2 つの方法をサポートしています。

1 つ目（および Windows を除くすべてのプラットフォームでのデフォルト）は、ラウンドロビンアプローチです。このアプローチでは、プライマリプロセスがポートをリッスンし、新しい接続を受け入れ、ワーカープロセス全体にラウンドロビン方式で分散します。この際、ワーカープロセスに過負荷がかからないように、いくつかの組み込みのスマート機能が使用されます。

2 つ目のアプローチは、プライマリプロセスがリッスンソケットを作成し、それを関心のあるワーカーに送信するものです。その後、ワーカーは着信接続を直接受け入れます。

2 つ目のアプローチは、理論的には最高のパフォーマンスが得られるはずです。しかし実際には、オペレーティングシステムのスケジューラの気まぐれにより、分散が非常に不均衡になる傾向があります。負荷が 8 つのプロセスのうち、わずか 2 つのプロセスにすべての接続の 70% 以上が集中した例も観測されています。

server.listen() はほとんどの処理をプライマリプロセスに委譲するため、通常の Node.js プロセスとクラスターワーカーの間で動作が異なるケースが 3 つあります。

Node.js はルーティングロジックを提供しません。したがって、セッションやログインなどのためにインメモリデータオブジェクトに過度に依存しないようにアプリケーションを設計することが重要です。

ワーカーはすべて個別のプロセスであるため、他のワーカーに影響を与えることなく、プログラムのニーズに応じて強制終了したり、再生成したりできます。一部のワーカーが稼働している限り、サーバーは接続を受け入れ続けます。ワーカーが稼働していない場合、既存の接続は切断され、新しい接続は拒否されます。ただし、Node.js はワーカーの数を自動的に管理しません。アプリケーション独自のニーズに基づいてワーカープールを管理するのはアプリケーションの責任です。

node:cluster モジュールの主なユースケースはネットワーキングですが、ワーカープロセスを必要とする他のユースケースにも使用できます。

クラス: `Worker`

追加: v0.7.0

拡張: <EventEmitter>

Workerオブジェクトには、ワーカーに関するすべての公開情報とメソッドが含まれています。プライマリでは、cluster.workersを使用して取得できます。ワーカーでは、cluster.workerを使用して取得できます。

イベント: `'disconnect'`

追加: v0.7.7

cluster.on('disconnect')イベントに似ていますが、このワーカーに固有のものです。

cluster.fork().on('disconnect', () => {
  // ワーカーが切断されました
})

イベント: `'error'`

追加: v0.7.3

このイベントは、child_process.fork()によって提供されるものと同じです。

ワーカー内では、process.on('error')も使用できます。

イベント: `'exit'`

追加: v0.11.2

code <number> 正常に終了した場合の終了コード。
signal <string> プロセスを強制終了させたシグナルの名前（例: 'SIGHUP'）。

cluster.on('exit')イベントに似ていますが、このワーカーに固有のものです。

ESMCJS

import cluster from 'node:cluster'

if (cluster.isPrimary) {
  const worker = cluster.fork()
  worker.on('exit', (code, signal) => {
    if (signal) {
      console.log(`worker was killed by signal: ${signal}`)
    } else if (code !== 0) {
      console.log(`worker exited with error code: ${code}`)
    } else {
      console.log('worker success!')
    }
  })
}

const cluster = require('node:cluster')

if (cluster.isPrimary) {
  const worker = cluster.fork()
  worker.on('exit', (code, signal) => {
    if (signal) {
      console.log(`worker was killed by signal: ${signal}`)
    } else if (code !== 0) {
      console.log(`worker exited with error code: ${code}`)
    } else {
      console.log('worker success!')
    }
  })
}

イベント: `'listening'`

追加: v0.7.0

address <Object>

cluster.on('listening')イベントに似ていますが、このワーカーに固有のものです。

ESMCJS

cluster.fork().on('listening', address => {
  // ワーカーがリスニングしています
})

cluster.fork().on('listening', address => {
  // ワーカーがリスニングしています
})

これはワーカー内では発行されません。

イベント: `'message'`

追加: v0.7.0

message <Object>
handle <undefined> | <Object>

cluster の 'message' イベントに似ていますが、このワーカーに固有のものです。

ワーカー内では、process.on('message') も使用できます。

process イベント: 'message' を参照してください。

以下は、メッセージシステムを使用する例です。ワーカーによって受信された HTTP リクエストの数をプライマリプロセスでカウントし続けます。

ESMCJS

import cluster from 'node:cluster'
import http from 'node:http'
import { availableParallelism } from 'node:os'
import process from 'node:process'

if (cluster.isPrimary) {
  // http リクエストを追跡
  let numReqs = 0
  setInterval(() => {
    console.log(`numReqs = ${numReqs}`)
  }, 1000)

  // リクエストをカウント
  function messageHandler(msg) {
    if (msg.cmd && msg.cmd === 'notifyRequest') {
      numReqs += 1
    }
  }

  // ワーカーを開始し、notifyRequestを含むメッセージをリッスン
  const numCPUs = availableParallelism()
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  for (const id in cluster.workers) {
    cluster.workers[id].on('message', messageHandler)
  }
} else {
  // ワーカープロセスには http サーバーがあります。
  http
    .Server((req, res) => {
      res.writeHead(200)
      res.end('hello world\n')

      // プライマリにリクエストを通知
      process.send({ cmd: 'notifyRequest' })
    })
    .listen(8000)
}

const cluster = require('node:cluster')
const http = require('node:http')
const numCPUs = require('node:os').availableParallelism()
const process = require('node:process')

if (cluster.isPrimary) {
  // http リクエストを追跡
  let numReqs = 0
  setInterval(() => {
    console.log(`numReqs = ${numReqs}`)
  }, 1000)

  // リクエストをカウント
  function messageHandler(msg) {
    if (msg.cmd && msg.cmd === 'notifyRequest') {
      numReqs += 1
    }
  }

  // ワーカーを開始し、notifyRequestを含むメッセージをリッスン
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  for (const id in cluster.workers) {
    cluster.workers[id].on('message', messageHandler)
  }
} else {
  // ワーカープロセスには http サーバーがあります。
  http
    .Server((req, res) => {
      res.writeHead(200)
      res.end('hello world\n')

      // プライマリにリクエストを通知
      process.send({ cmd: 'notifyRequest' })
    })
    .listen(8000)
}

イベント: `'online'`

追加: v0.7.0

cluster.on('online') イベントと同様ですが、このワーカーに固有です。

cluster.fork().on('online', () => {
  // ワーカーがオンラインになりました
})

ワーカー内では発行されません。

`worker.disconnect()`

[履歴]

バージョン	変更点
v7.3.0	このメソッドは `worker` への参照を返すようになりました。
v0.7.7	追加: v0.7.7

戻り値: <cluster.Worker> worker への参照。

ワーカー内では、この関数はすべてのサーバーを閉じ、それらのサーバーで 'close' イベントを待ち、その後 IPC チャネルを切断します。

プライマリでは、ワーカーに内部メッセージが送信され、自身で .disconnect() を呼び出すようにします。

.exitedAfterDisconnect が設定される原因となります。

サーバーが閉じられた後、新しい接続を受け入れなくなりますが、他のリッスンしているワーカーによって接続を受け入れることができます。既存の接続は通常通り閉じることを許可されます。それ以上の接続が存在しない場合、server.close() を参照してください。ワーカーへの IPC チャネルは閉じられ、正常に終了できます。

上記は サーバー 接続にのみ適用されます。クライアント接続はワーカーによって自動的に閉じられず、切断しても終了を待機しません。

ワーカーでは process.disconnect が存在しますが、これはこの関数ではありません。disconnect() です。

長時間存続するサーバー接続はワーカーの切断を妨げる可能性があるため、メッセージを送信して、それらを閉じるためのアプリケーション固有のアクションを実行できるようにすると便利な場合があります。また、タイムアウトを実装し、一定時間経過後に 'disconnect' イベントが発行されない場合はワーカーを強制終了すると便利な場合があります。

if (cluster.isPrimary) {
  const worker = cluster.fork()
  let timeout

  worker.on('listening', address => {
    worker.send('shutdown')
    worker.disconnect()
    timeout = setTimeout(() => {
      worker.kill()
    }, 2000)
  })

  worker.on('disconnect', () => {
    clearTimeout(timeout)
  })
} else if (cluster.isWorker) {
  const net = require('node:net')
  const server = net.createServer(socket => {
    // 接続は決して終了しない
  })

  server.listen(8000)

  process.on('message', msg => {
    if (msg === 'shutdown') {
      // サーバーへの接続を正常に閉じるための処理を開始
    }
  })
}

`worker.exitedAfterDisconnect`

追加: v6.0.0

<boolean>

このプロパティは、ワーカーが .disconnect() によって終了した場合に true になります。ワーカーがそれ以外の方法で終了した場合は false になります。ワーカーが終了していない場合は undefined になります。

boolean の worker.exitedAfterDisconnect を使うと、自発的な終了と偶発的な終了を区別することができ、プライマリはこの値に基づいてワーカーを再生成しないことを選択できます。

cluster.on('exit', (worker, code, signal) => {
  if (worker.exitedAfterDisconnect === true) {
    console.log('ああ、自発的な終了だっただけだ - 心配する必要はない')
  }
})

// ワーカーをkillする
worker.kill()

`worker.id`

追加: v0.8.0

<integer>

新しいワーカーにはそれぞれ一意の ID が与えられ、この ID は id に格納されます。

ワーカーが生きている間、これは cluster.workers 内でワーカーをインデックス化するキーになります。

`worker.isConnected()`

追加: v0.11.14

この関数は、ワーカーがその IPC チャネルを介してプライマリに接続されている場合は true を返し、そうでない場合は false を返します。ワーカーは作成された後、プライマリに接続されます。'disconnect' イベントが発行された後、切断されます。

`worker.isDead()`

追加: v0.11.14

この関数は、ワーカーのプロセスが終了した場合（終了またはシグナルによる場合）は true を返します。それ以外の場合は false を返します。

ESMCJS

import cluster from 'node:cluster'
import http from 'node:http'
import { availableParallelism } from 'node:os'
import process from 'node:process'

const numCPUs = availableParallelism()

if (cluster.isPrimary) {
  console.log(`プライマリ ${process.pid} が実行中です`)

  // ワーカーをフォークします。
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  cluster.on('fork', worker => {
    console.log('ワーカーは死んでいます:', worker.isDead())
  })

  cluster.on('exit', (worker, code, signal) => {
    console.log('ワーカーは死んでいます:', worker.isDead())
  })
} else {
  // ワーカーは任意の TCP 接続を共有できます。この場合、それは HTTP サーバーです。
  http
    .createServer((req, res) => {
      res.writeHead(200)
      res.end(`現在のプロセス\n ${process.pid}`)
      process.kill(process.pid)
    })
    .listen(8000)
}

const cluster = require('node:cluster')
const http = require('node:http')
const numCPUs = require('node:os').availableParallelism()
const process = require('node:process')

if (cluster.isPrimary) {
  console.log(`プライマリ ${process.pid} が実行中です`)

  // ワーカーをフォークします。
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  cluster.on('fork', worker => {
    console.log('ワーカーは死んでいます:', worker.isDead())
  })

  cluster.on('exit', (worker, code, signal) => {
    console.log('ワーカーは死んでいます:', worker.isDead())
  })
} else {
  // ワーカーは任意の TCP 接続を共有できます。この場合、それは HTTP サーバーです。
  http
    .createServer((req, res) => {
      res.writeHead(200)
      res.end(`現在のプロセス\n ${process.pid}`)
      process.kill(process.pid)
    })
    .listen(8000)
}

`worker.kill([signal])`

追加: v0.9.12

signal <string> ワーカープロセスに送信する kill シグナルの名前。デフォルト: 'SIGTERM'

この関数はワーカーを強制終了します。プライマリワーカーでは、worker.processを切断し、切断後にsignalで強制終了します。ワーカーでは、signalでプロセスを強制終了します。

kill()関数は、正常な切断を待たずにワーカープロセスを強制終了します。これはworker.process.kill()と同じ動作をします。

このメソッドは、後方互換性のためにworker.destroy()としてエイリアスされています。

ワーカーでは、process.kill()が存在しますが、これはこの関数ではなく、kill()です。

`worker.process`

追加: v0.7.0

<ChildProcess>

すべてのワーカーはchild_process.fork()を使用して作成されます。この関数から返されたオブジェクトは.processとして保存されます。ワーカーでは、グローバルなprocessが保存されます。

参照: Child Process モジュール。

ワーカーは、processで'disconnect'イベントが発生し、.exitedAfterDisconnectがtrueでない場合、process.exit(0)を呼び出します。これは、誤った切断に対する保護です。

`worker.send(message[, sendHandle[, options]][, callback])`

[履歴]

バージョン	変更
v4.0.0	`callback`パラメータがサポートされました。
v0.7.0	v0.7.0 で追加されました。

message <Object>
sendHandle <Handle>
options <Object> options引数は、特定の種類のハンドルの送信をパラメータ化するために使用されるオブジェクトです。optionsは次のプロパティをサポートしています。
- keepOpen <boolean> net.Socketのインスタンスを渡す際に使用できる値です。trueの場合、ソケットは送信プロセスで開いたままになります。デフォルト: false。
callback <Function>
戻り値: <boolean>

オプションでハンドルとともに、ワーカーまたはプライマリにメッセージを送信します。

プライマリでは、これは特定のワーカーにメッセージを送信します。これは、ChildProcess.send()と同じです。

ワーカーでは、これはプライマリにメッセージを送信します。これはprocess.send()と同じです。

この例では、プライマリからのすべてのメッセージをエコーバックします。

if (cluster.isPrimary) {
  const worker = cluster.fork()
  worker.send('hi there')
} else if (cluster.isWorker) {
  process.on('message', msg => {
    process.send(msg)
  })
}

イベント: `'disconnect'`

追加: v0.7.9

worker <cluster.Worker>

ワーカーの IPC チャネルが切断された後に発生します。これは、ワーカーが正常に終了した場合、強制終了された場合、または（worker.disconnect() などで）手動で切断された場合に発生する可能性があります。

'disconnect' イベントと 'exit' イベントの間には遅延が発生する可能性があります。これらのイベントを使用して、プロセスがクリーンアップでスタックしているかどうか、または長期間接続が存在するかどうかを検出できます。

cluster.on('disconnect', worker => {
  console.log(`ワーカー #${worker.id} が切断されました`)
})

イベント: `'exit'`

追加: v0.7.9

worker <cluster.Worker>
code <number> 正常に終了した場合の終了コード。
signal <string> プロセスが強制終了された原因となったシグナルの名前（例：'SIGHUP'）。

いずれかのワーカーが終了すると、cluster モジュールは 'exit' イベントを発行します。

これは、fork() を再度呼び出すことでワーカーを再起動するために使用できます。

cluster.on('exit', (worker, code, signal) => {
  console.log('worker %d が終了しました (%s)。再起動します...', worker.process.pid, signal || code)
  cluster.fork()
})

child_process event: 'exit' を参照してください。

イベント: `'fork'`

追加: v0.7.0

worker <cluster.Worker>

新しいワーカーがフォークされると、cluster モジュールは 'fork' イベントを発行します。これは、ワーカーのアクティビティをログに記録したり、カスタムタイムアウトを作成したりするために使用できます。

const timeouts = []
function errorMsg() {
  console.error('接続に問題があるようです ...')
}

cluster.on('fork', worker => {
  timeouts[worker.id] = setTimeout(errorMsg, 2000)
})
cluster.on('listening', (worker, address) => {
  clearTimeout(timeouts[worker.id])
})
cluster.on('exit', (worker, code, signal) => {
  clearTimeout(timeouts[worker.id])
  errorMsg()
})

イベント: `'listening'`

追加: v0.7.0

worker <cluster.Worker>
address <Object>

ワーカーから listen() が呼び出された後、サーバーで 'listening' イベントが発生すると、プライマリの cluster でも 'listening' イベントが発生します。

イベントハンドラーは、2 つの引数で実行されます。worker にはワーカーオブジェクトが含まれ、address オブジェクトには、address、port、addressType の接続プロパティが含まれます。ワーカーが複数のアドレスでリッスンしている場合に非常に役立ちます。

cluster.on('listening', (worker, address) => {
  console.log(`ワーカーが ${address.address}:${address.port} に接続されました`)
})

addressType は次のいずれかです。

4 (TCPv4)
6 (TCPv6)
-1 (Unix ドメインソケット)
'udp4' または 'udp6' (UDPv4 または UDPv6)

イベント: `'message'`

[履歴]

バージョン	変更
v6.0.0	`worker` パラメーターが渡されるようになりました。詳細については下記を参照してください。
v2.5.0	追加: v2.5.0

worker <cluster.Worker>
message <Object>
handle <undefined> | <Object>

クラスタープライマリがワーカーからメッセージを受信したときに発生します。

child_process イベント: 'message'を参照してください。

イベント: `'online'`

追加: v0.7.0

worker <cluster.Worker>

新しいワーカーをフォークした後、ワーカーはオンラインメッセージで応答する必要があります。プライマリがオンラインメッセージを受信すると、このイベントが発生します。'fork' と 'online' の違いは、fork はプライマリがワーカーをフォークしたときに発生し、'online' はワーカーが実行されているときに発生するということです。

cluster.on('online', worker => {
  console.log('フォーク後、ワーカーが応答しました')
})

イベント: `'setup'`

追加: v0.7.1

settings <Object>

.setupPrimary() が呼び出されるたびに発生します。

settings オブジェクトは、.setupPrimary() が呼び出された時点での cluster.settings オブジェクトであり、単一のティック内で .setupPrimary() が複数回呼び出される可能性があるため、参考情報としてのみ使用してください。

精度が重要な場合は、cluster.settings を使用してください。

`cluster.disconnect([callback])`

追加: v0.7.7

callback <Function> すべてのワーカーが切断され、ハンドルが閉じられたときに呼び出されます。

cluster.workers 内の各ワーカーで .disconnect() を呼び出します。

切断されると、すべての内部ハンドルが閉じられ、他にイベントを待機していない場合、プライマリプロセスが正常に終了できるようになります。

このメソッドは、完了時に呼び出されるオプションのコールバック引数を取ります。

これはプライマリプロセスからのみ呼び出すことができます。

`cluster.fork([env])`

追加: v0.6.0

env <Object> ワーカープロセスの環境に追加するキーと値のペア。
戻り値: <cluster.Worker>

新しいワーカープロセスを生成します。

これはプライマリプロセスからのみ呼び出すことができます。

`cluster.isMaster`

追加: v0.8.1

非推奨: v16.0.0 以降

[安定版: 0 - 非推奨]

安定版: 0 安定性: 0 - 非推奨

cluster.isPrimary の非推奨のエイリアス。

`cluster.isPrimary`

追加: v16.0.0

<boolean>

プロセスがプライマリの場合は true です。これは process.env.NODE_UNIQUE_ID によって決定されます。 process.env.NODE_UNIQUE_ID が未定義の場合、isPrimary は true です。

`cluster.isWorker`

追加: v0.6.0

<boolean>

プロセスがプライマリでない場合（cluster.isPrimary の否定）、true。

`cluster.schedulingPolicy`

追加: v0.11.2

スケジューリングポリシーは、ラウンドロビン方式の cluster.SCHED_RR か、オペレーティングシステムに任せる cluster.SCHED_NONE のいずれかです。これはグローバル設定であり、最初のワーカーが生成されるか、setupPrimary() が呼び出されるかのどちらかが先に行われると、事実上フリーズされます。

SCHED_RR は、Windows を除くすべてのオペレーティングシステムでデフォルトです。Windows は、libuv が大きなパフォーマンス低下を招くことなく IOCP ハンドルを効率的に分散できるようになると、SCHED_RR に変更されます。

cluster.schedulingPolicy は、NODE_CLUSTER_SCHED_POLICY 環境変数を通じて設定することもできます。有効な値は 'rr' および 'none' です。

`cluster.settings`

[履歴]

バージョン	変更
v13.2.0, v12.16.0	`serialization` オプションがサポートされるようになりました。
v9.5.0	`cwd` オプションがサポートされるようになりました。
v9.4.0	`windowsHide` オプションがサポートされるようになりました。
v8.2.0	`inspectPort` オプションがサポートされるようになりました。
v6.4.0	`stdio` オプションがサポートされるようになりました。
v0.7.1	追加: v0.7.1

<Object>
- execArgv <string[]> Node.js 実行可能ファイルに渡される文字列引数のリスト。デフォルト: process.execArgv。
- exec <string> ワーカーファイルのファイルパス。デフォルト: process.argv[1]。
- args <string[]> ワーカーに渡される文字列引数。デフォルト: process.argv.slice(2)。
- cwd <string> ワーカープロセスの現在の作業ディレクトリ。デフォルト: undefined (親プロセスから継承)。
- serialization <string> プロセス間でメッセージを送信するために使用するシリアル化の種類を指定します。可能な値は 'json' と 'advanced' です。詳細については、child_process の高度なシリアル化を参照してください。デフォルト: false。
- silent <boolean> 親の stdio に出力を送信するかどうか。デフォルト: false。
- stdio <Array> フォークされたプロセスの stdio を構成します。cluster モジュールは IPC に依存して機能するため、この構成には 'ipc' エントリを含める必要があります。このオプションが提供された場合、silent が上書きされます。child_process.spawn() の stdio を参照してください。
- uid <number> プロセスのユーザー ID を設定します。（setuid(2) を参照。）
- gid <number> プロセスのグループ ID を設定します。（setgid(2) を参照。）
- inspectPort <number> | <Function> ワーカーのインスペクターポートを設定します。これは数値であるか、引数を取らず数値を返す関数にすることができます。デフォルトでは、各ワーカーは独自のポートを取得し、プライマリの process.debugPort からインクリメントされます。
- windowsHide <boolean> 通常 Windows システムで作成されるフォークされたプロセスのコンソールウィンドウを非表示にします。デフォルト: false。

setupPrimary() (または fork()) を呼び出した後、この設定オブジェクトには、デフォルト値を含む設定が含まれます。

このオブジェクトは、手動で変更または設定することを意図していません。

`cluster.setupMaster([settings])`

[履歴]

バージョン	変更
v16.0.0	非推奨: v16.0.0 から
v6.4.0	`stdio` オプションがサポートされました。
v0.7.1	追加: v0.7.1

[安定版: 0 - 非推奨]

安定版: 0 安定性: 0 - 非推奨

cluster.setupPrimary() の非推奨エイリアスです。

`cluster.setupPrimary([settings])`

追加: v16.0.0

settings <Object> cluster.settings を参照してください。

setupPrimary は、デフォルトの 'fork' の動作を変更するために使用されます。一度呼び出されると、設定は cluster.settings に存在します。

設定の変更は、fork() の今後の呼び出しにのみ影響し、すでに実行中のワーカーには影響しません。

.setupPrimary() で設定できないワーカーの唯一の属性は、fork() に渡される env です。

上記のデフォルトは最初の呼び出しにのみ適用されます。後の呼び出しのデフォルトは、cluster.setupPrimary() が呼び出された時点の現在の値です。

ESMCJS

import cluster from 'node:cluster'

cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'https'],
  silent: true,
})
cluster.fork() // https ワーカー
cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'http'],
})
cluster.fork() // http ワーカー

const cluster = require('node:cluster')

cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'https'],
  silent: true,
})
cluster.fork() // https ワーカー
cluster.setupPrimary({
  exec: 'worker.js',
  args: ['--use', 'http'],
})
cluster.fork() // http ワーカー

これは、プライマリプロセスからのみ呼び出すことができます。

`cluster.worker`

追加: v0.7.0

<Object>

現在のワーカーオブジェクトへの参照。プライマリプロセスでは使用できません。

ESMCJS

import cluster from 'node:cluster'

if (cluster.isPrimary) {
  console.log('私はプライマリです')
  cluster.fork()
  cluster.fork()
} else if (cluster.isWorker) {
  console.log(`私はワーカー #${cluster.worker.id} です`)
}

const cluster = require('node:cluster')

if (cluster.isPrimary) {
  console.log('私はプライマリです')
  cluster.fork()
  cluster.fork()
} else if (cluster.isWorker) {
  console.log(`私はワーカー #${cluster.worker.id} です`)
}

`cluster.workers`

追加: v0.7.0

<Object>

id フィールドをキーとしてアクティブなワーカーオブジェクトを格納するハッシュです。これにより、すべてのワーカーを簡単にループ処理できます。これはプライマリプロセスでのみ利用可能です。

ワーカーは、ワーカーが接続を解除し、終了した後に cluster.workers から削除されます。これらの 2 つのイベントの順序は事前に決定できません。ただし、cluster.workers リストからの削除は、最後の 'disconnect' または 'exit' イベントが発行される前に行われることが保証されています。

ESMCJS

import cluster from 'node:cluster'

for (const worker of Object.values(cluster.workers)) {
  worker.send('big announcement to all workers')
}

const cluster = require('node:cluster')

for (const worker of Object.values(cluster.workers)) {
  worker.send('big announcement to all workers')
}

Cluster ​

仕組み ​

クラス: Worker ​

イベント: 'disconnect' ​

イベント: 'error' ​

イベント: 'exit' ​

イベント: 'listening' ​

イベント: 'message' ​

イベント: 'online' ​

worker.disconnect() ​

worker.exitedAfterDisconnect ​

worker.id ​

worker.isConnected() ​

worker.isDead() ​

worker.kill([signal]) ​

worker.process ​

worker.send(message[, sendHandle[, options]][, callback]) ​

イベント: 'disconnect' ​

イベント: 'exit' ​

イベント: 'fork' ​

イベント: 'listening' ​

イベント: 'message' ​

イベント: 'online' ​

イベント: 'setup' ​

cluster.disconnect([callback]) ​

cluster.fork([env]) ​

cluster.isMaster ​

cluster.isPrimary ​

cluster.isWorker ​

cluster.schedulingPolicy ​

cluster.settings ​

cluster.setupMaster([settings]) ​

cluster.setupPrimary([settings]) ​

cluster.worker ​

cluster.workers ​

Cluster

仕組み

クラス: `Worker`

イベント: `'disconnect'`

イベント: `'error'`

イベント: `'exit'`

イベント: `'listening'`

イベント: `'message'`

イベント: `'online'`

`worker.disconnect()`

`worker.exitedAfterDisconnect`

`worker.id`

`worker.isConnected()`

`worker.isDead()`

`worker.kill([signal])`

`worker.process`

`worker.send(message[, sendHandle[, options]][, callback])`

イベント: `'disconnect'`

イベント: `'exit'`

イベント: `'fork'`

イベント: `'listening'`

イベント: `'message'`

イベント: `'online'`

イベント: `'setup'`

`cluster.disconnect([callback])`

`cluster.fork([env])`

`cluster.isMaster`

`cluster.isPrimary`

`cluster.isWorker`

`cluster.schedulingPolicy`

`cluster.settings`

`cluster.setupMaster([settings])`

`cluster.setupPrimary([settings])`

`cluster.worker`

`cluster.workers`