Node.js Douilles.io, Redis pub/sub haut volume, à faible latence difficultés

Lorsque l'on associe socket.io/node.js et redis pub/sub dans une tentative de créer un web en temps réel du système de diffusion entraînée par les événements de serveur qui peut gérer de multiples transports, il semble y avoir trois approches:

  1. 'createClient' un redis connexion et de vous abonner à canal(s). Sur la socket.io de connexion du client, de joindre le client dans une prise.io chambre. Dans le redis.sur("message", ...) de l'événement, appelez io.les sockets.dans(chambre).émettre("événement", données) pour les distribuer à tous les clients dans la salle. Comme Comment réutiliser le redis connexion de socket.io?

  2. 'createClient' un redis connexion. Sur la socket.io de connexion du client, de joindre le client dans une prise.io de chambre et de vous abonner pertinentes redis channel(s). Inclure redis.sur("message", ...) à l'intérieur de la connexion du client de fermeture et sur la réception du message d'appel du client.émettre("événement", données) pour déclencher l'événement sur le client. Comme la réponse dans Des exemples en utilisant RedisStore dans le support.io

  3. Utiliser le RedisStore cuit dans la douille.io et de "diffusion" de l'unique "envoi" de canal dans le Redis à la suite de la socketio-spec protocole.

Numéro 1 permet de traiter le Redis sous et associés événement une fois pour tous les clients. Numéro 2 offre un branchement direct dans le Redis pub/sub. Le numéro 3 est plus simple, mais offre peu de contrôle sur les événements de messagerie.

Cependant, dans mes tests, tous présentent de façon inattendue faible performance avec plus de 1 client connecté. Le serveur d'événements en question sont de 1 000 messages publiés sur un redis canal le plus rapidement possible, pour être distribués aussi rapidement que possible. La Performance est mesurée par des timings sur les clients connectés (socket.io-client en fonction de journal horodateurs dans un Redis liste pour l'analyse).

Ce que j'ai supposer, c'est que dans l'option 1, le serveur reçoit le message, puis de manière séquentielle, écrit-il à tous les clients connectés. Dans l'option 2, le serveur reçoit chaque message plusieurs fois (une fois par abonnement client) et l'écrit pour le client concerné. Dans les deux cas, le serveur n'est pas à la deuxième événement de message jusqu'à ce qu'elle est communiquée à tous les clients connectés. Une situation clairement exacerbée par la hausse de la concurrence.

Cela semble en contradiction avec la perception de la sagesse des piles de capacités. Je veux bien le croire, mais j'ai du mal.

Est ce scénario (faible latence de la distribution à haut volume de messages) tout simplement pas une option avec ces outils (encore?), ou alors j'ai loupé un truc?

  • avez-vous essayé de pub-sub avec les serveurs de messagerie comme 0MQ/AMQ et reçu les mêmes performances?
  • la meilleure chance d'obtenir plus de réponses, je suis curieux de voir les opinions des experts carillon. Ma réponse ici, a été principalement basée sur les docs flottant autour de l'internet.
  • Salut lebear, j'ai exactement le même souci et j'ai trouvé ce lien après avoir regardé autour. Si vous avez trouvé la réponse à votre propre question, j'aimerais l'entendre ainsi.
InformationsquelleAutor lebear | 2012-05-11
  1. 30

    Je pensais que c'était une question tout à fait raisonnable et avait fait des recherches brièvement tout à l'arrière. J'ai passé un peu de temps à chercher des exemples de ce que vous pouvez être en mesure de ramasser quelques conseils utiles de.

    Exemples

    J'aime bien commencer avec straight forward exemples:

    La lumière de l'échantillon est une seule page (notez que vous aurez envie de le remplacer redis-nœud-client avec quelque chose comme node_redis par Matt Ranney:

    /*
* Mclarens Bar: Redis based Instant Messaging
* Nikhil Marathe - 22/04/2010
* A simple example of an IM client implemented using
* Redis PUB/SUB commands so that all the communication
* is offloaded to Redis, and the node.js code only
* handles command interpretation,presentation and subscribing.
* 
* Requires redis-node-client and a recent version of Redis
*    http://code.google.com/p/redis
*    http://github.com/fictorial/redis-node-client
*
* Start the server then telnet to port 8000
* Register with NICK <nick>, use WHO to see others
* Use TALKTO <nick> to initiate a chat. Send a message
* using MSG <nick> <msg>. Note its important to do a
* TALKTO so that both sides are listening. Use STOP <nick>
* to stop talking to someone, and QUIT to exit.
*
* This code is in the public domain.
*/
var redis = require('./redis-node-client/lib/redis-client');
var sys = require('sys');
var net = require('net');
var server = net.createServer(function(stream) {
var sub; //redis connection
var pub;
var registered = false;
var nick = "";
function channel(a,b) {
return [a,b].sort().join(':');
}
function shareTable(other) {
sys.debug(nick + ": Subscribing to "+channel(nick,other));
sub.subscribeTo(channel(nick,other), function(channel, message) {
var str = message.toString();
var sender = str.slice(0, str.indexOf(':'));
if( sender != nick )
stream.write("[" + sender + "] " + str.substr(str.indexOf(':')+1) + "\n");
});
}
function leaveTable(other) {
sub.unsubscribeFrom(channel(nick,other), function(err) {
stream.write("Stopped talking to " + other+ "\n");
});
}
stream.addListener("connect", function() {
sub = redis.createClient();
pub = redis.createClient();
});
stream.addListener("data", function(data) {
if( !registered ) {
var msg = data.toString().match(/^NICK (\w*)/);
if(msg) {
stream.write("SERVER: Hi " + msg[1] + "\n");
pub.sadd('mclarens:inside', msg[1], function(err) {
if(err) {
stream.end();
}
registered = true;
nick = msg[1];
//server messages
sub.subscribeTo( nick + ":info", function(nick, message) {
var m = message.toString().split(' ');
var cmd = m[0];
var who = m[1];
if( cmd == "start" ) {
stream.write( who + " is now talking to you\n");
shareTable(who);
}
else if( cmd == "stop" ) {
stream.write( who + " stopped talking to you\n");
leaveTable(who);
}
});
});
}
else {
stream.write("Please register with NICK <nickname>\n");
}
return;
}
var fragments = data.toString().replace('\r\n', '').split(' ');
switch(fragments[0]) {
case 'TALKTO':
pub.publish(fragments[1]+":info", "start " + nick, function(a,b) {
});
shareTable(fragments[1]);
break;
case 'MSG':
pub.publish(channel(nick, fragments[1]),
nick + ':' +fragments.slice(2).join(' '),
function(err, reply) {
if(err) {
stream.write("ERROR!");
}
});
break;
case 'WHO':
pub.smembers('mclarens:inside', function(err, users) {
stream.write("Online:\n" + users.join('\n') + "\n");
});
break;
case 'STOP':
leaveTable(fragments[1]);
pub.publish(fragments[1]+":info", "stop " + nick, function() {});
break;
case 'QUIT':
stream.end();
break;
}
});
stream.addListener("end", function() {
pub.publish(nick, nick + " is offline");
pub.srem('mclarens:inside', nick, function(err) {
if(err) {
sys.debug("Could not remove client");
}
});
});
});
server.listen(8000, "localhost");

    Documents

    Il y a une tonne de documentation là-bas, et l'api sont en évolution rapide sur ce type de pile, de sorte que vous aurez à peser à la fois la pertinence de chaque document.

    Questions Liées

    Juste quelques questions, c'est un sujet chaud sur pile:

    Notable conseils (ymmv)

    Éteindre ou d'optimiser la prise de mise en commun, l'utilisation efficace de liaisons, de surveiller les temps de latence, et assurez-vous que vous n'êtes pas une duplication du travail (c'est à dire pas besoin de publier à tous les auditeurs à deux reprises).

    InformationsquelleAutor Mark Essel