Quel est le plus efficace node.js communication inter-processus de bibliothèque/méthode?

Si vous souhaitez envoyer des messages à partir d'une machine à une autre et ne se soucient pas de rappels puis Redis pub/sub est la meilleure solution. Il est vraiment facile à mettre en œuvre et Redis est vraiment très rapide.

Vous devez d'abord installer le Redis sur une de vos machines.

Son vraiment facile de se connecter à Redis:

var client = require('redis').createClient(redis_port, redis_host);

Mais ne pas oublier l'ouverture Redis port dans votre pare-feu!

Ensuite, vous devez souscrire chaque machine à certains canaux:

client.on('ready', function() {
  return client.subscribe('your_namespace:machine_name');
});

client.on('message', function(channel, json_message) {
  var message;
  message = JSON.parse(message);
  //do whatever you vant with the message
});

Vous pouvez sauter your_namespace et utiliser l'espace de noms global, mais vous allez le regretter tôt ou tard.

Il est vraiment facile pour envoyer des messages, trop:

var send_message = function(machine_name, message) {
  return client.publish("your_namespace:" + machine_name, JSON.stringify(message));
};

Si vous souhaitez envoyer des différents types de messages, vous pouvez utiliser pmessages au lieu de messages:

client.on('ready', function() {
  return client.psubscribe('your_namespace:machine_name:*');
});

client.on('pmessage', function(pattern, channel, json_message) {
  //pattern === 'your_namespace:machine_name:*'
  //channel === 'your_namespace:machine_name:'+message_type
  var message = JSON.parse(message);
  var message_type = channel.split(':')[2];
  //do whatever you want with the message and message_type
});

send_message = function(machine_name, message_type, message) {
  return client.publish([
    'your_namespace',
    machine_name,
    message_type
  ].join(':'), JSON.stringify(message));
};

La meilleure pratique consiste à donner un nom à votre processus (ou des machines) par leur fonctionnalité (par exemple,'send_email'). Dans ce cas, le processus (ou la machine) peuvent être abonné à plus d'un canal si elle met en œuvre plus d'une fonctionnalité.

En fait, il est possible de construire une communication bi-directionnelle à l'aide de redis. Mais c'est plus délicate, car il aurait besoin pour ajouter unique de rappel nom de la chaîne à chaque message afin de recevoir de rappel sans perdre contexte.

Donc, ma conclusion est: est-ce Utiliser Redis si vous avez besoin d' "envoyer et oublier", de communication, d'enquêter sur une autre solutions si vous en avez besoin à part entière de la communication bi-directionnelle.

Plus de 4 ans après la question été demander, il est un système de communication interprocessus module appelé nœud-cib. Il prend en charge unix/windows sockets pour la communication sur la même machine ainsi que TCP, TLS et UDP, affirmant qu'au moins les sockets TCP et UDP sont stables.

Voici un petit exemple tiré de la documentation depuis le dépôt github:

Serveur de Sockets Unix, Windows Sockets & les Sockets TCP

var ipc=require('node-ipc');

ipc.config.id   = 'world';
ipc.config.retry= 1500;

ipc.serve(
    function(){
        ipc.server.on(
            'message',
            function(data,socket){
                ipc.log('got a message : '.debug, data);
                ipc.server.emit(
                    socket,
                    'message',
                    data+' world!'
                );
            }
        );
    }
);

ipc.server.start();

Client pour les Sockets Unix & les Sockets TCP

var ipc=require('node-ipc');

ipc.config.id   = 'hello';
ipc.config.retry= 1500;

ipc.connectTo(
    'world',
    function(){
        ipc.of.world.on(
            'connect',
            function(){
                ipc.log('## connected to world ##'.rainbow, ipc.config.delay);
                ipc.of.world.emit(
                    'message',
                    'hello'
                )
            }
        );
        ipc.of.world.on(
            'disconnect',
            function(){
                ipc.log('disconnected from world'.notice);
            }
        );
        ipc.of.world.on(
            'message',
            function(data){
                ipc.log('got a message from world : '.debug, data);
            }
        );
    }
);

Je suis actuellement à l'évaluation de ce module pour un remplacement locale de la cib (mais il pourrait être à distance de la cib dans le futur) comme un remplacement pour une vieille solution via stdin/stdout. Peut-être que je vais développer ma réponse quand je suis fait pour donner plus d'informations comment et à quel point ce module fonctionne.

prendre un coup d'oeil au niveau du nœud-messenger

https://github.com/weixiyen/messenger.js

s'adapter à la plupart des besoins facilement (pub/sub ... le feu et oublier .. envoyer/demande) avec auto-entretenu connectionpool