I&#39;d like to compare somehow capabilities of grpc vs. zeromq &amp; its patterns: and I&#39;d like to create some comparsion (feature set) - somehow - 0mq is &quot;better&quot; sockets - but anyways - if I apply 0mq patterns - I get comparable &#39;frameworks&#39; I think - and here 0mq seems to be much more flexible ...

The main requirements are:

 - async req / res communication (inproc or remote) between nodes
 - flexible messages routing 
 - loadbalancing support
 - well documented

any ideas? 

thanks!


grpc and zeromq comparsion

what&#39;s the difference between a message bus[1] and a message broker[2]

  - Both is middleware for applications
  - Both can be used to decouple various systems 
  - Both can have a canonical data model
  - Both route messages and could offer other features such as data transform

As i see, the only relevent difference is the picture used to represent each of one..  

If there&#39;s some difference between then, please tell-me what.  
If they are the same, plese tell-me why two concepts to refer the same functionality.

Thanks.

[1] http://www.eaipatterns.com/MessageBus.html  
[2] http://www.eaipatterns.com/MessageBroker.html


Difference between message bus and message broker

I&#39;ve been evaluating messaging technologies for my company but I&#39;ve become very confused by the conceptual differences between a few terms:

**Pub/Sub** vs **Multicast** vs **Fan Out**
I am working with the following definitions:

 - **Pub/Sub** has publishers delivering a separate copy of each message to
   each subscriber which means that the opportunity to guarantee delivery exists
 - **Fan Out** has a single queue pushing to all listening
   clients. 
 - **Multicast** just spams out data and if someone is listening
   then fine, if not, it doesn&#39;t matter.  No possibility to guarantee a client definitely gets a message.

Are these definitions right?  Or is Pub/Sub the pattern and multicast, direct, fanout etc. ways to acheive the pattern?

I&#39;m trying to work the out-of-the-box RabbitMQ definitions into our architecture but I&#39;m just going around in circles at the moment trying to write the specs for our app.

Please could someone advise me whether I am right?

Messaging Confusion: Pub/Sub vs Multicast vs Fan Out

The [RabbitMQ Java client](http://www.rabbitmq.com/releases/rabbitmq-java-client/v3.1.5/rabbitmq-java-client-javadoc-3.1.5/) has the following concepts:

* `Connection` - a connection to a RabbitMQ server instance
* `Channel` - ???
* Consumer thread pool - a pool of threads that consume messages off the RabbitMQ server queues
* Queue - a structure that holds messages in FIFO order

I&#39;m trying to understand the relationship, **and more importantly**, the *associations* between them.

  1. I&#39;m still not quite sure what a `Channel` is, other than the fact that this is the structure that you publish and consume from, and that it is created from an open connection. If someone could explain to me what the &quot;Channel&quot; represents, it might help clear a few things up.
  2. What is the relationship between Channel and Queue? Can the same Channel be used to communicate to multiples Queues, or does it have to be 1:1?
  3. What is the relationship between Queue and the Consumer Pool? Can multiple Consumers be subscribed to the same Queue? Can multiple Queues be consumed by the same Consumer? Or is the relationship 1:1?

RabbitMQ and relationship between channel and connection

I am just starting to use RabbitMQ and AMQP in general.

 - I have a queue of messages
 - I have multiple consumers, which I would like to do different things with the **same message**. 

Most of the RabbitMQ documentation seems to be focused on round-robin, ie where a single message is consumed by a single consumer, with the load being spread between each consumer. This is indeed the behavior I witness. 

An example: the producer has a single queue, and send messages every 2 sec:

    var amqp = require(&#39;amqp&#39;);
    var connection = amqp.createConnection({ host: &quot;localhost&quot;, port: 5672 });
    var count = 1;

    connection.on(&#39;ready&#39;, function () {
      var sendMessage = function(connection, queue_name, payload) {
        var encoded_payload = JSON.stringify(payload);  
        connection.publish(queue_name, encoded_payload);
      }
  
      setInterval( function() {    
        var test_message = &#39;TEST &#39;+count
        sendMessage(connection, &quot;my_queue_name&quot;, test_message)  
        count += 1;
      }, 2000) 
  

    })

And here&#39;s a consumer:


    var amqp = require(&#39;amqp&#39;);
    var connection = amqp.createConnection({ host: &quot;localhost&quot;, port: 5672 });
    connection.on(&#39;ready&#39;, function () {
      connection.queue(&quot;my_queue_name&quot;, function(queue){
        queue.bind(&#39;#&#39;); 
        queue.subscribe(function (message) {
          var encoded_payload = unescape(message.data)
          var payload = JSON.parse(encoded_payload)
          console.log(&#39;Recieved a message:&#39;)
          console.log(payload)
        })
      })
    })

If I start the consumer twice, **I can see that each consumer is consuming alternate messages in round-robin behavior. Eg, I&#39;ll see messages 1, 3, 5 in one terminal, 2, 4, 6 in the other**.

My question is: 

 - Can I have each consumer receive the same messages? Ie, both consumers get message 1, 2, 3, 4, 5, 6? What is this called in AMQP/RabbitMQ speak? How is it normally configured?

 - Is this commonly done? Should I just have the exchange route the message into two separate queues, with a single consumer, instead? 

RabbitMQ / AMQP: single queue, multiple consumers for same message?

As a seasoned Spring user I was assuming that Spring Integration would make the most sense in a recent project requiring some (JMS) messaging capabilities ([more details][1]). After some days working with Spring Integration it still feels like a lot of configuration overhead given the amount of channels you have to configure to bring some request-response (listening on different JMS queues) communications in place. 

Therefore I was looking for some background information how Camel is different from Spring Integration, but it seems like information out there are pretty spare, I found:

* http://java.dzone.com/articles/spring-integration-and-apache (Very neutral comparison between implementing a real-world integration scenario in Spring Integration vs. Camel, from December 2009)
* http://hillert.blogspot.com/2009/10/apache-camel-alternatives.html (Comparing Camel with other solutions, October 2009)
* http://raibledesigns.com/rd/entry/taking_apache_camel_for_a (Matt Raible, October 2008)


Question is: what experiences did you make on using the one stack over the other? In which scenarios would you recommend Camel were Spring Integration lacks support? Where do you see pros and cons of each? Any advise from real-world projects are highly appreciated.


  [1]: https://stackoverflow.com/questions/3012802/how-to-leverage-spring-integration-in-a-real-world-jms-distributed-architecture

When to use Spring Integration vs. Camel?

I have gone through different questions/articles on Message Brokers and ESBs(Even on stackoverflow). Still not a clue as what is the CLEAR demarcating difference between an Message Broker and an ESB? Now here I am trying to compare products, Websphere Broker and Mule ESB!!

Firstly , is (any version) Webshere Broker an ESB? Our IBM product guys claims it to be an ESB!(I am not surprised about that).

My limited information tells me that a Message Broker works on a HUB-SPOKE model. However the ESB works on a bus architecture. Now what on earth is that supposed to mean? I have read than if the HUB fails(unavailable I guess) then the broker completely fails. Which is not the case of an ESB(So those guys say). What I dont understand here is &quot;What if the BUS&quot; fails?

Now the usual stuff about an  ESBs and Brokers is that , they provide routing,transformation, orchestration etc.. So if both of them provide this, then why would I choose one over the other.

Another area of conflict is regarding the TRANSFORMATION. Does ESBs facilitate it in a different way when compared to Message Brokers? I would really love some insight on this.

Now talking about HORIZONTAL scaling. Who outperforms the whom? Or are both of them equally scalable in terms of complexity(or any other factors). Ofcourse cost wise, Webshpere Broker is gonna charge you for each box(let alone each cpu). I believe , even the commercial MULE ESB doesnt do that. Leaving aside the Cost part of it, what are the implications of ESB scaling and Message Broker scaling. I happen to know you can scale up to Service Level in ESB. Is this possible in a Message Broker?


Difference between a Message Broker and an ESB

All of the [examples](https://www.google.com/#q=kafka+producer+key+value) of [Kafka](https://kafka.apache.org/090/javadoc/index.html?org/apache/kafka/clients/producer/KafkaProducer.html) | [producers](https://www.tutorialspoint.com/apache_kafka/apache_kafka_simple_producer_example.htm) show the `ProducerRecord`&#39;s key/value pair as not only being the same type (all examples show `&lt;String,String&gt;`), but the same **value**. For example:

    producer.send(new ProducerRecord&lt;String, String&gt;(&quot;someTopic&quot;, Integer.toString(i), Integer.toString(i)));

But in the Kafka docs, I can&#39;t seem to find where the key/value concept (and its underlying purpose/utility) is explained. In traditional messaging (ActiveMQ, RabbitMQ, etc.) I&#39;ve always fired a message at a particular topic/queue/exchange. But Kafka is the first broker that seems to require key/value pairs instead of just a regulare &#39;ole string message.

So I ask: **What is the purpose/usefulness of requiring producers to send KV pairs?**

What&#39;s the purpose of Kafka&#39;s key/value pair-based messaging?

What is the basic difference between stream processing and traditional message processing? As people say that kafka is good choice for stream processing but essentially kafka is a messaging framework similar to ActivMQ, RabbitMQ etc.

Why do we generally not say that ActiveMQ is good for stream processing as well.

Is it the speed at which messages are consumed by the consumer determines if it is a stream?

Difference between stream processing and message processing

I was wondering if there is a clear distinction between message driven and event driven environments when we refer to SOA or middleware and generally in cases of application and enterprise integration. I understand that a user interface resembles an event driven model where our system intercepts action by the user.

Also it is clear that messaging supports systems based on publish/subscribe, sychronous or asynchronous communication, transactions etc.

But is there a difference in the middleware/soa/application intergration context? (architecture level). I am trying to consult sources such wikipedia ([here][1], and [here][2]), but I am still somewhat confused. When should a developer prefer one solution over the other?

Are there examples or cases where one approach makes more sense than the other? Or any comprehensive resources and guides to implementing each one?

Many thanks for any insight.


  [1]: http://en.wikipedia.org/wiki/Message_Oriented_Middleware
  [2]: http://en.wikipedia.org/wiki/Event-driven_SOA

message driven vs. event driven approaches to application integration

We are in need of a distributed architecture messaging system/service bus with the capability of Publish/Subscribe. Does anyone have any reccomendations for a framework that we can use for .net applications?

.net service bus recommendations?

as opposed to writing your own library.

We&#39;re working on a project here that will be a self-dividing server pool, if one section grows too heavy, the manager would divide it and put it on another machine as a separate process. It would also alert all connected clients this affects to connect to the new server.

I am curious about using ZeroMQ for inter-server and inter-process communication. My partner would prefer to roll his own. I&#39;m looking to the community to answer this question.

I&#39;m a fairly novice programmer myself and just learned about messaging queues. As i&#39;ve googled and read, it seems everyone is using messaging queues for all sorts of things, but why? What makes them better than writing your own library? Why are they so common and why are there so many?

Why use AMQP/ZeroMQ/RabbitMQ

Im just wondering whether there is a way to call a method where i build the name of the method on the fly with a string.

e.g. I have a method called loaddata
    
    -(void)loadData;

to call this i would normally call it like

    [self loadData];

But i want to be able to call it dynamically with a string e.g.

    NSString *methodName = [[NSString alloc] initWithString:@&quot;loadData&quot;];
    [self methodName];

This is a stupid example but i hope you get my point. I am using it for databinding classes that I am setting up for my IPad application. Hard to explain but to get it to fire I need to work out how to call a method with a string.

Any ideas?

Thanks


Objective C calling method dynamically with a string

I&#39;m looking for (simple) examples of problems for which JMS is a good solution, and also reasons why JMS is a good solution in these cases. In the past I&#39;ve simply used the database as a means of passing messages from A to B when the message cannot necessarily be processed by B immediately.

A hypothetical example of such a system is where all newly registered users should be sent a welcome e-mail within 24 hours of registration. For the sake of argument, assume the DB does not record the time when each user registered, but instead a reference (foreign key) to each new user is stored in the pending_email table. The e-mail sender job runs once every 24 hours, sends an e-mail to all the users in this table, then deletes all the pending_email records.

This seems like the kind of problem for which JMS should be used, but it&#39;s not clear to me what benefit JMS would have over the approach I&#39;ve described. One advantage of the DB approach is that the messages are persistent. I understand that JMS message queues can also be persisted, but in that case there seems to be little difference between JMS and the &quot;database as message queue&quot; approach I&#39;ve described?

What am I missing?
- Don

what is JMS good for?

This two images are from http://zguide.zeromq.org/page:all.

What is the difference between this two pattern if we ignore sink in push-pull pattern ?
Is there a difference in how a message gets transfer, if yes what is the difference ?

![](https://github.com/imatix/zguide/raw/master/images/fig4.png)
![](https://github.com/imatix/zguide/raw/master/images/fig5.png)


 

difference between pub-sub and push-pull pattern in zeroMq

I just read [RabbitMQ&#39;s Java API docs](http://www.rabbitmq.com/api-guide.html), and found it very informative and straight-forward. The example for how to set up a simple `Channel` for publishing/consuming is very easy to follow and understand. But it&#39;s a very simple/basic example, and it left me with an important question: **How can I set up 1+ `Channels` to publish/consume to and from multiple queues?**

Let&#39;s say I have a RabbitMQ server with 3 queues on it: `logging`, `security_events` and `customer_orders`. So we&#39;d either need a single `Channel` to have the ability to publish/consume to all 3 queues, or more likely, have 3 separate `Channels`, each dedicated to a single queue.

On top of this, RabbitMQ&#39;s best practices dictate that we set up 1 `Channel` per consumer thread. For this example, let&#39;s say `security_events` is fine with only 1 consumer thread, but `logging` and `customer_order` both need 5 threads to handle the volume. So, if I understand correctly, does that mean we need:

* 1 `Channel` and 1 consumer thread for publishing/consuming to and from `security_events`; and
* 5 `Channels` and 5 consumer threads for publishing/consuming to and from `logging`; and
* 5 `Channels` and 5 consumer threads for publishing/consuming to and from `customer_orders`?

If my understanding is misguided here, please begin by correcting me. Either way, could some battle-weary RabbitMQ veteran **help me &quot;connect the dots&quot; with a decent code example for setting up publishers/consumers that meet my requirements here?** Thanks in advance!

RabbitMQ by Example: Multiple Threads, Channels and Queues

I am new to Messaging and want to know the difference between `ActiveMQ`, `Mule`, `ServiceMix` and `Camel`

Anyone knows how each of these product is different?

Thanks in advance !

**EDIT:** Also would like to know any good place/resource to learn these things.

All Messaging Solutions on Gang of Coders

Total of 17 Messaging Solutions