Cluster

[Stable: 2 - Stable]

Исходный код: 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 поддерживает два метода распределения входящих соединений.

Первый (и используемый по умолчанию на всех платформах, кроме Windows) — это подход "карусель", когда основной процесс прослушивает порт, принимает новые соединения и распределяет их между рабочими процессами по очереди, с некоторой встроенной логикой, позволяющей избежать перегрузки рабочего процесса.

Второй подход заключается в том, что основной процесс создает сокет прослушивания и отправляет его заинтересованным рабочим процессам. Затем рабочие процессы принимают входящие соединения напрямую.

Второй подход, теоретически, должен обеспечивать наилучшую производительность. На практике, однако, распределение, как правило, оказывается очень несбалансированным из-за особенностей работы планировщика операционной системы. Наблюдались нагрузки, когда более 70% всех соединений приходилось всего на два процесса из восьми.

Поскольку server.listen() передает большую часть работы основному процессу, существуют три случая, когда поведение обычного процесса Node.js и рабочего процесса кластера отличается:

Node.js не предоставляет логики маршрутизации. Поэтому важно разработать приложение таким образом, чтобы оно не слишком сильно зависело от объектов данных в памяти для таких вещей, как сессии и вход в систему.

Поскольку рабочие процессы являются отдельными процессами, они могут быть завершены или перезапущены в зависимости от потребностей программы, не затрагивая другие рабочие процессы. Пока есть живые рабочие процессы, сервер будет продолжать принимать соединения. Если нет ни одного живого рабочего процесса, существующие соединения будут разорваны, а новые соединения будут отклонены. Node.js не управляет автоматически количеством рабочих процессов. Ответственность за управление пулом рабочих процессов в зависимости от собственных потребностей несет приложение.

Хотя основным вариантом использования модуля node:cluster являются сетевые операции, он также может использоваться для других случаев, требующих рабочих процессов.

Класс: `Worker`

Добавлено в: v0.7.0

Расширяет: <EventEmitter>

Объект Worker содержит всю публичную информацию и методы о worker-е. В основном процессе его можно получить с помощью cluster.workers. В worker-е его можно получить с помощью cluster.worker.

Событие: `'disconnect'`

Добавлено в: v0.7.7

Аналогично событию cluster.on('disconnect'), но относится конкретно к этому worker-у.

cluster.fork().on('disconnect', () => {
  // Worker отключился
})

Событие: `'error'`

Добавлено в: v0.7.3

Это событие аналогично тому, которое предоставляется child_process.fork().

Внутри worker-а также можно использовать process.on('error').

Событие: `'exit'`

Добавлено в: v0.11.2

code <number> Код выхода, если он вышел нормально.
signal <string> Имя сигнала (например, 'SIGHUP'), который вызвал завершение процесса.

Аналогично событию cluster.on('exit'), но относится конкретно к этому worker-у.

ESMCJS

import cluster from 'node:cluster'

if (cluster.isPrimary) {
  const worker = cluster.fork()
  worker.on('exit', (code, signal) => {
    if (signal) {
      console.log(`worker был завершен сигналом: ${signal}`)
    } else if (code !== 0) {
      console.log(`worker завершился с кодом ошибки: ${code}`)
    } else {
      console.log('worker успешно завершен!')
    }
  })
}

const cluster = require('node:cluster')

if (cluster.isPrimary) {
  const worker = cluster.fork()
  worker.on('exit', (code, signal) => {
    if (signal) {
      console.log(`worker был завершен сигналом: ${signal}`)
    } else if (code !== 0) {
      console.log(`worker завершился с кодом ошибки: ${code}`)
    } else {
      console.log('worker успешно завершен!')
    }
  })
}

Событие: `'listening'`

Добавлено в: v0.7.0

address <Object>

Аналогично событию cluster.on('listening'), но относится конкретно к этому worker-у.

ESMCJS

cluster.fork().on('listening', address => {
  // Worker прослушивает
})

cluster.fork().on('listening', address => {
  // Worker прослушивает
})

Оно не вызывается в worker-е.

Событие: `'message'`

Добавлено в: v0.7.0

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

Аналогично событию 'message' кластера cluster, но специфично для этого рабочего процесса.

Внутри рабочего процесса также можно использовать 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>

Это свойство имеет значение true, если рабочий процесс завершился из-за .disconnect(). Если рабочий процесс завершился каким-либо другим способом, то значение будет false. Если рабочий процесс не завершился, то значение будет undefined.

Булево значение worker.exitedAfterDisconnect позволяет различать добровольный и случайный выход, основной процесс может решить не перезапускать рабочий процесс на основе этого значения.

cluster.on('exit', (worker, code, signal) => {
  if (worker.exitedAfterDisconnect === true) {
    console.log('О, это было просто добровольно – не нужно беспокоиться')
  }
})

// убить рабочий процесс
worker.kill()

`worker.id`

Добавлено в: v0.8.0

<integer>

Каждому новому рабочему процессу присваивается свой уникальный идентификатор, этот идентификатор хранится в id.

Пока рабочий процесс жив, это ключ, который индексирует его в cluster.workers.

`worker.isConnected()`

Добавлено в: v0.11.14

Эта функция возвращает true, если рабочий процесс подключен к своему основному процессу через свой IPC-канал, 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> Имя сигнала завершения, отправляемого рабочему процессу. По умолчанию: '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.

См.: Модуль дочернего процесса.

Рабочие процессы вызовут process.exit(0), если событие 'disconnect' произойдет на process, а .exitedAfterDisconnect не будет true. Это защищает от случайного отключения.

`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('рабочий процесс %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' испускается на сервере, событие 'listening' также будет испущено на cluster в основном процессе.

Обработчик события выполняется с двумя аргументами: worker, который содержит объект рабочего процесса, и address, который содержит следующие свойства подключения: address, port и addressType. Это очень полезно, если рабочий процесс прослушивает несколько адресов.

cluster.on('listening', (worker, address) => {
  console.log(`Рабочий процесс теперь подключен к ${address.address}:${address.port}`)
})

addressType может быть одним из следующих значений:

4 (TCPv4)
6 (TCPv6)
-1 (Unix domain socket)
'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 - это объект cluster.settings на момент вызова .setupPrimary() и носит только рекомендательный характер, поскольку несколько вызовов .setupPrimary() могут быть сделаны за один такт.

Если важна точность, используйте cluster.settings.

`cluster.disconnect([callback])`

Добавлено в: v0.7.7

callback <Function> Вызывается, когда все работники отключены и дескрипторы закрыты.

Вызывает .disconnect() для каждого работника в cluster.workers.

Когда они отключаются, все внутренние дескрипторы будут закрыты, что позволит основному процессу корректно завершиться, если никакое другое событие не ожидает.

Метод принимает необязательный аргумент обратного вызова, который будет вызван по завершении.

Это может быть вызвано только из основного процесса.

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

Истина, если процесс является основным. Это определяется process.env.NODE_UNIQUE_ID. Если process.env.NODE_UNIQUE_ID не определен, то isPrimary равно true.

`cluster.isWorker`

Добавлено в: v0.6.0

<boolean>

True, если процесс не является основным (это отрицание cluster.isPrimary).

`cluster.schedulingPolicy`

Добавлено в: v0.11.2

Политика планирования, либо cluster.SCHED_RR для циклического перебора, либо cluster.SCHED_NONE, чтобы оставить ее операционной системе. Это глобальная настройка, которая фактически замораживается после запуска первого рабочего или вызова .setupPrimary(), в зависимости от того, что произойдет раньше.

SCHED_RR является значением по умолчанию во всех операционных системах, кроме Windows. Windows переключится на SCHED_RR, как только libuv сможет эффективно распределять дескрипторы IOCP без значительного снижения производительности.

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 для порожденных процессов. Поскольку модуль кластера полагается на IPC для работы, эта конфигурация должна содержать запись 'ipc'. Когда этот параметр предоставляется, он переопределяет silent. См. child_process.spawn() stdio.
- uid <number> Устанавливает идентификатор пользователя процесса. (См. setuid(2).)
- gid <number> Устанавливает идентификатор группы процесса. (См. 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 - Устарело

Устаревший псевдоним для .setupPrimary().

`cluster.setupPrimary([settings])`

Добавлено в версии: v16.0.0

settings <Object> См. cluster.settings.

setupPrimary используется для изменения поведения 'fork' по умолчанию. После вызова настройки будут присутствовать в cluster.settings.

Любые изменения настроек влияют только на будущие вызовы .fork() и не влияют на уже запущенные рабочие процессы.

Единственный атрибут рабочего процесса, который нельзя установить с помощью .setupPrimary(), это env, переданный в .fork().

Указанные выше значения по умолчанию применяются только к первому вызову; значения по умолчанию для последующих вызовов - это текущие значения на момент вызова cluster.setupPrimary().

ESMCJS

import cluster from 'node:cluster'

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

const cluster = require('node:cluster')

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

Этот метод можно вызывать только из основного процесса.

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

Хэш, который хранит активные объекты worker, с ключом по полю id. Это упрощает перебор всех worker-ов. Доступен только в основном процессе.

Worker удаляется из cluster.workers после того, как worker отключился и завершил работу. Порядок между этими двумя событиями нельзя определить заранее. Однако гарантируется, что удаление из списка 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`