Javascript 使用群集将Socket.IO扩展到多个Node.js进程

用这个扯掉我的头发。。。是否有人能够扩展到Node.js模块生成的多个“工作”进程

假设我在四个工作进程（伪）上有以下内容：

在浏览器上

// on the client
socket = io.connect();
socket.emit('join', ['room']);

socket.on('data', function(data){
  console.log(data);
});

问题：由于四个独立的工作进程发送消息，我每秒都会收到四条消息

---

如何确保消息只发送一次？

这实际上看起来像是Socket.IO成功地进行了扩展。您可能希望来自一台服务器的消息发送到该房间中的所有套接字，而不管它们连接到哪个服务器

---

您最好的选择是拥有一个每秒发送一条消息的主进程。例如，只有在

cluster.isMaster

的情况下才能运行它。

让主机处理您的心跳信号（下面的示例）或在不同端口上启动多个进程，并使用nginx（它还支持V1.3以上版本的websockets）对它们进行负载平衡

带主服务器的群集

// on the server
var express = require('express');
var server = express();
var socket = require('socket.io');
var io = socket.listen(server);
var cluster = require('cluster');
var numCPUs = require('os').cpus().length;

// socket.io
io.set('store', new socket.RedisStore);

// set-up connections...
io.sockets.on('connection', function(socket) {
    socket.on('join', function(rooms) {
        rooms.forEach(function(room) {
            socket.join(room);
        });
    });

    socket.on('leave', function(rooms) {
        rooms.forEach(function(room) {
            socket.leave(room);
        });
    });

});

if (cluster.isMaster) {
    // Fork workers.
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }

    // Emit a message every second
    function send() {
        console.log('howdy');
        io.sockets.in('room').emit('data', 'howdy');
    }

    setInterval(send, 1000);


    cluster.on('exit', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' died');
    }); 
}

//在服务器上
var express=需要（“express”）；
var server=express（）；
var socket=require（'socket.io'）；
var io=socket.listen（服务器）；
var cluster=require（'cluster'）；
var numpus=require（'os'）.cpus（）.length；
//socket.io
io.set（'store'，新套接字.redistore）；
//设置连接。。。
io.sockets.on（'connection'，函数（socket）{
插座开（'join'，功能（房间）{
房间。forEach（功能（房间）{
插座连接（房间）；
});
});
插座打开（'离开'），功能（房间）{
房间。forEach（功能（房间）{
离开（房间）；
});
});
});
if（cluster.isMaster）{
//叉工。
对于（变量i=0；i

编辑：在Socket.IO 1.0+中，现在可以使用更简单的Redis适配器模块，而不是使用多个Redis客户端设置存储

var io = require('socket.io')(3000);
var redis = require('socket.io-redis');
io.adapter(redis({ host: 'localhost', port: 6379 }));

下面显示的示例更像这样：

var cluster = require('cluster');
var os = require('os');

if (cluster.isMaster) {
  // we create a HTTP server, but we do not use listen
  // that way, we have a socket.io server that doesn't accept connections
  var server = require('http').createServer();
  var io = require('socket.io').listen(server);
  var redis = require('socket.io-redis');

  io.adapter(redis({ host: 'localhost', port: 6379 }));

  setInterval(function() {
    // all workers will receive this in Redis, and emit
    io.emit('data', 'payload');
  }, 1000);

  for (var i = 0; i < os.cpus().length; i++) {
    cluster.fork();
  }

  cluster.on('exit', function(worker, code, signal) {
    console.log('worker ' + worker.process.pid + ' died');
  }); 
}

if (cluster.isWorker) {
  var express = require('express');
  var app = express();

  var http = require('http');
  var server = http.createServer(app);
  var io = require('socket.io').listen(server);
  var redis = require('socket.io-redis');

  io.adapter(redis({ host: 'localhost', port: 6379 }));
  io.on('connection', function(socket) {
    socket.emit('data', 'connected to worker: ' + cluster.worker.id);
  });

  app.listen(80);
}

如果您的主进程和子进程都显示相同的解析器消息，那么您的应用程序可以正确地伸缩

---

如果您是从单个工作进程发射，那么您的设置应该不会有问题。您所做的是从所有四个Worker发出消息，由于Redis publish/subscribe，消息不会重复，而是像您要求应用程序那样写入四次。以下是Redis的简单功能图：

Client  <--  Worker 1 emit -->  Redis
Client  <--  Worker 2  <----------|
Client  <--  Worker 3  <----------|
Client  <--  Worker 4  <----------|

客户端Redis
客户端进程间通信不足以使socket.io 1.4.5与集群协同工作。强制websocket模式也是必须的。请参见
您使用的是哪个版本的socket.io？Socket.IO 0.6设计为单个进程服务器。见本帖第三条的答案。0.9.16使用Redistore您可以使用SocketCluster（socket的接口与socket.io兼容）：它成功地“共享”了套接字，但没有成功地确定哪些消息不应重复。集群是一个很好的想法，但它并不是真正的“扩展”。。。这是一个管理工作的过程4@Lee您希望它使用什么逻辑来决定是否“复制”消息？当您向房间发送消息时，它会发送给房间中的每个人-这是预期的行为。如果希望每个进程以一定的间隔发送消息，那么每个进程都可以有一个空间。我想更好的逻辑应该是socket.emit以某种方式跨进程同步。我不知道如何实现这一目标。“每个进程一个房间”的方法无法解决10台不同服务器（每个服务器有4个内核）的可伸缩性问题。。。但是，当只涉及一台服务器时，这可能是一个好主意。@Lee Socket.IO通常使用的方式是，在一台服务器上发生的某个事件（例如http请求）会触发发送到房间的消息。您可能希望此消息传递给房间中的每个人，而不仅仅是碰巧连接到同一服务器的人。“一个过程管理4个人的工作”-我不确定你的实际逻辑是什么，但每秒发送一条消息并不费力。我的目的是想弄清楚如何做到这一点，但要有规模。现在，对10000个客户来说，这一点都不征税。。。但是当它是一百万的时候呢？我正在构建的应用程序有大量的web套接字连接，用于一个需求量相当高的stats应用程序，并且该API很容易在短时间内达到每天1000多万个套接字事务。我只是想做好必要的扩展准备-仍然不确定如何在1服务器、1进程模型之外做到这一点。这是一个不错的建议，但它仍然只是一个主进程，负责潜在的500000个websocket连接。。。没有真正解决跨多个服务器/每个服务器的进程的“可伸缩性”问题如何：使用两层负载平衡器。AWS示例：第一层使用弹性负载平衡器在多台机器之间分配工作负载。第二层在机器上的多个实例之间分配工作负载。您可以运行cpu.count节点实例，并通过nginx将工作负载分配给它们，或者使用节点集群（在这种情况下，不需要nginx）。我更喜欢nginx版本。对于自动缩放，请使用OpsWork，并让它根据cpu负载处理您的缩放。它将自动添加和删除机器，并且非常容易设置。当我使用
var socket=require（'socket.io'）（1338）我得到了这个错误错误：监听EADDRINUSE:：：1338如何在同一个服务器上实现！回答得好。谢谢在某种程度上起了作用。当我发出io.sockets.emit（'userstreamssock'，posted）时；从师父那里，我不明白，我
socket.io:server initializing namespace / +0ms
socket.io:server creating engine.io instance with opts {"path":"/socket.io"} +2ms
socket.io:server attaching client serving req handler +2ms
socket.io-parser encoding packet {"type":2,"data":["event","payload"],"nsp":"/"} +0ms
socket.io-parser encoded {"type":2,"data":["event","payload"],"nsp":"/"} as 2["event","payload"] +1ms
socket.io-redis ignore same uid +0ms

Client  <--  Worker 1 emit -->  Redis
Client  <--  Worker 2  <----------|
Client  <--  Worker 3  <----------|
Client  <--  Worker 4  <----------|

var cluster = require('cluster');
var os = require('os');

if (cluster.isMaster) {
  // we create a HTTP server, but we do not use listen
  // that way, we have a socket.io server that doesn't accept connections
  var server = require('http').createServer();
  var io = require('socket.io').listen(server);

  var RedisStore = require('socket.io/lib/stores/redis');
  var redis = require('socket.io/node_modules/redis');

  io.set('store', new RedisStore({
    redisPub: redis.createClient(),
    redisSub: redis.createClient(),
    redisClient: redis.createClient()
  }));

  setInterval(function() {
    // all workers will receive this in Redis, and emit
    io.sockets.emit('data', 'payload');
  }, 1000);

  for (var i = 0; i < os.cpus().length; i++) {
    cluster.fork();
  }

  cluster.on('exit', function(worker, code, signal) {
    console.log('worker ' + worker.process.pid + ' died');
  }); 
}

if (cluster.isWorker) {
  var express = require('express');
  var app = express();

  var http = require('http');
  var server = http.createServer(app);
  var io = require('socket.io').listen(server);

  var RedisStore = require('socket.io/lib/stores/redis');
  var redis = require('socket.io/node_modules/redis');

  io.set('store', new RedisStore({
    redisPub: redis.createClient(),
    redisSub: redis.createClient(),
    redisClient: redis.createClient()
  }));

  io.sockets.on('connection', function(socket) {
    socket.emit('data', 'connected to worker: ' + cluster.worker.id);
  });

  app.listen(80);
}