多个处理器(PM2，集群，Reclust，Naught)上的NodeJS

问题描述

我正在研究在多核环境中运行节点的选项.

I am investigating options for running node in a multi-core environment.

我正在尝试确定最佳方法，到目前为止，我已经看到了这些选项

I'm trying to determine the best approach and so far I've seen these options

• 使用内置的群集库来加速工作并响应信号
• 使用PM，但PM2-i被列为beta.
• 一无所获
• 集群

还有其他选择吗?人们在生产中使用什么?

Are there other alternatives? What are folks using in production?

推荐答案

我一直在使用默认的集群库，并且效果很好.我已经有超过10,000个并发(在多个服务器上有多个集群)，并且效果很好.

I've been using the default cluster library, and it works very well. I've had over 10,000 concurrents(multiple clusters on multiple servers) and it works very well.

建议使用具有域的群集进行错误处理.

It is suggested to use clusters with domain for error handling.

直接从 http://nodejs.org/api/domain.html 取消我对它如何为计算机的每个核心产生新的群集进行了一些更改.并删除了if/else并添加了express.

This is lifted straight from http://nodejs.org/api/domain.html I've mades some changes on how it spawns new clusters for each core of your machine. and got rid of if/else and added express.

var cluster = require('cluster'),
    http = require('http'),
    PORT = process.env.PORT || 1337,
    os = require('os'),
    server;

function forkClusters () {
    var cpuCount = os.cpus().length;
    // Create a worker for each CPU
    for (var i = 0; i < cpuCount ; i += 1) {
        cluster.fork();
    }
}

// Master Process
if (cluster.isMaster) {

    // You can also of course get a bit fancier about logging, and
    // implement whatever custom logic you need to prevent DoS
    // attacks and other bad behavior.
    //
    // See the options in the cluster documentation.
    //
    // The important thing is that the master does very little,
    // increasing our resilience to unexpected errors.

    forkClusters ()

    cluster.on('disconnect', function(worker) {
        console.error('disconnect!');
        cluster.fork();
    });

}
function handleError (d) {
    d.on('error', function(er) {
        console.error('error', er.stack);

        // Note: we're in dangerous territory!
        // By definition, something unexpected occurred,
        // which we probably didn't want.
        // Anything can happen now!Be very careful!

        try {
            // make sure we close down within 30 seconds
            var killtimer = setTimeout(function() {
                process.exit(1);
            }, 30000);
            // But don't keep the process open just for that!
            killtimer.unref();

            // stop taking new requests.
            server.close();

            // Let the master know we're dead.This will trigger a
            // 'disconnect' in the cluster master, and then it will fork
            // a new worker.
            cluster.worker.disconnect();
        } catch (er2) {
            // oh well, not much we can do at this point.
            console.error('Error sending 500!', er2.stack);
        }
    });
}
// child Process
if (cluster.isWorker) {
    // the worker
    //
    // This is where we put our bugs!

    var domain = require('domain');
    var express = require('express');
    var app = express();
    app.set('port', PORT);

    // See the cluster documentation for more details about using
    // worker processes to serve requests.How it works, caveats, etc.

    var d = domain.create();
    handleError(d);

    // Now run the handler function in the domain.
    //
    // put all code here. any code included outside of domain.run will not handle errors on the domain level, but will crash the app.
    //

    d.run(function() {
        // this is where we start our server
        server = http.createServer(app).listen(app.get('port'), function () {
            console.log('Cluster %s listening on port %s', cluster.worker.id, app.get('port'));
        });
    });
}

这篇关于多个处理器(PM2，集群，Reclust，Naught)上的NodeJS的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！