Question

用这一个撕掉我的头发......有没有人设法将Socket.IO扩展到由Node.js的cluster模块生成的多个“工人”进程？

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

// on the server
var express = require('express');
var server = express();
var socket = require('socket.io');
var io = socket.listen(server);

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

});

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

setInterval(send, 1000);

在浏览器上......

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

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

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

如何确保邮件只发送一次？

Answer 1

编辑：在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);
}

如果您有一个主节点需要发布到其他Socket.IO进程，但本身不接受套接字连接，请使用socket.io-emitter而不是socket.io-redis。

如果您在扩展时遇到问题，请使用DEBUG=*运行您的节点应用程序。 Socket.IO现在实现debug，它还将打印出Redis适配器调试消息。示例输出：

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

如果主进程和子进程都显示相同的解析器消息，那么您的应用程序正在正确扩展。

如果您是从单个工作人员发出的，那么您的设置应该没有问题。您正在做的是从所有四个工作人员中发出的，并且由于Redis发布/订阅，消息不会重复，而是写入四次，就像您要求应用程序执行的那样。这是Redis所做的简单图表：

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

正如您所看到的，当您从工作人员发出时，它会将emit发布到Redis，并且它将从已订阅Redis数据库的其他工作人员进行镜像。这也意味着您可以使用连接同一实例的多个套接字服务器，并且将在所有连接的服务器上触发一台服务器上的emit。

对于群集，当客户端连接时，它将连接到您的四个工作者之一，而不是所有四个工作者。这也意味着您从该工作人员发出的任何内容只会向客户显示一次。所以，是的，应用程序正在扩展，但是你正在这样做，你从所有四个工作人员中散发出来，而Redis数据库就像你在一个工人上调用它四次一样。如果客户端实际连接到所有四个套接字实例，则它们每秒接收十六条消息，而不是四条消息。

套接字处理的类型取决于您将拥有的应用程序类型。如果您要单独处理客户端，那么您应该没有问题，因为连接事件将仅针对每个客户端的一个工作程序触发。如果您需要全局“心跳”，那么您可以在主进程中拥有套接字处理程序。由于工作程序在主进程终止时死亡，因此应该从主进程中抵消连接负载，并让子进程处理连接。这是一个例子：

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

在该示例中，有五个Socket.IO实例，一个是主实例，四个是子实例。主服务器从不调用listen()，因此该进程没有连接开销。但是，如果在主进程上调用emit，它将发布到Redis，并且四个工作进程将在其客户端上执行emit。这会将连接负载抵消给工作人员，如果工作人员死亡，主应用程序逻辑将在主服务器中不受影响。

请注意，使用Redis时，即使在命名空间或空间中，所有发出都将由其他工作进程处理，就像您从该进程触发了emit一样。换句话说，如果你有两个带有一个Redis实例的Socket.IO实例，那么在第一个worker中的套接字上调用emit()会将数据发送给它的客户端，而worker 2就会像调用它一样调用从那个工人那里散发出来。

Answer 2

让主服务器处理您的心跳（下面的示例）或在内部启动不同端口上的多个进程，并使用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');
    }); 
}

Answer 3

这实际上看起来像Socket.IO成功扩展。您可能希望来自一个服务器的消息转到该房间中的所有套接字，无论它们碰巧连接到哪个服务器。

最好的办法是让每一个主进程每秒发送一条消息。例如，只有cluster.isMaster运行它才能执行此操作。

Answer 4

进程间通信不足以使socket.io 1.4.5与群集一起工作。强制websocket模式也是必须的。见WebSocket handshake in Node.JS, Socket.IO and Clusters not working

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

4 个答案: