Microservices communications. Why you should switch to message queues.
Tags: microservices, cloud, amqp, rest
Published: 2018-02-23 16:59:52

---
title: Microservices communications. Why you should switch to message queues.
published: true
description: A common pattern in Microservices is to use HTTP and REST to communicate. But there are better solutions out there.
tags: microservices, cloud, amqp, rest
---
*This is actually a more elaborate version of an old comment I wrote [here](https://dev.to/matteojoliveau/comment/1bk1)*

When doing microservices, a fairly crucial design point is: how should my services communicate with each other?
Many people usually choose to design some RESTful HTTP API that each service expose and then have the other services invoke it with a normal HTTP client.
This has some advantages, primarily making it easy to discover services by using DNS resolution and API Gateways, but it has many drawbacks too.
For example, what if the called service has crashed down and cannot respond? Your client service has to implement some kind of reconnection or failover logic, otherwise, you risk to lose requests and pieces of information. A cloud architecture should be resilient and recover gracefully from failures. Also, an HTTP request is a blocking API, making it asynchronous implies some tricky shenanigans on the client side.

## Entering message queues
Using message queues is actually a fairly old solution when dealing with multiple intercommunicating services. Think about old approaches like Enterprise Service Buses or the Java JMS specification.
  
Let's start by introducing some terminology:  
* *Message*: a package for information, usually composed of two parts. Some **headers**, key-value pairs containing metadata, and a **body**, a binary package containing the actual message itself.
* *Producer*: whoever creates and sends a message
* *Consumer*: whoever receives and reads a message
* *Queue*: a communication channel that enqueues messages for later retrieval by one or more consumers
* *Exchange*: a queue aggregator that abstract away message queues and routes messages to the appropriate queue based on some predefined logic.

A message queue architecture requires an additional service called a *message broker* that is tasked with gathering, routing and distributing your messages from senders to the right receivers.  
Think of it as a mail service. You (the producer) are sending a letter (your message) to someone (the consumer), and you do this by specifying the address (the routing logic for the message, such as the topic on which it is published) and by giving the letter to the local Post office (the message broker). After you deliver the letter, it's no longer your business to ensure that it actually arrives at your friend. The postal service will take care of that.

In a microservice environment, it's actually a really solid solution because it adds a layer of abstraction (the message broker itself) between loosely coupled services and allows for fully asynchronous communications.

## Errors will occur. Let's deal with them instead of simply avoiding them
Remember, a cloud environment should be error-resilient and services must fail gracefully and not take down the whole application if one of them dies. With message queues if a microservice dies unexpectedly the broker can still receive incoming messages, store them for later (so that the dead service can recover them when it comes back online) and optionally send back a *Last Will and Testament* message to the other service saying that the receiver has died. Also, *Push/Pull*, *Publish/Subscribe* and *Topic* queue mechanisms give more flexibility and efficiency when designing inter-service communications, and the ability to send binary payloads allow for easy use of formats like [Google ProtoBuff](https://github.com/google/protobuf) or [MessagePack](https://msgpack.org/) instead of JSON, which are much more efficient in terms of bandwidth usage.

## Security is key
Advanced broker servers like [RabbitMQ](https://www.rabbitmq.com/) support multiple message protocols (AMQP, MQTT, STOMP...), have [flexible authorization mechanism](https://www.rabbitmq.com/access-control.html) (access control, virtual hosts and even third party/custom auth services via many different transports such as [HTTP](https://github.com/rabbitmq/rabbitmq-auth-backend-http) or [AMQP](https://github.com/rabbitmq/rabbitmq-auth-backend-amqp)) and will basically remove the burden of orchestrating requests authorization from your service. Plug a custom microservice into Rabbit's auth backend and code your policies in there. The rest will be taken care of by the broker.

## Infrastructure at scale
Using message queues with brokers like Rabbit helps a lot with scalability too, which is another crucial aspect of microservices.
If one of the services is struggling under load we want to be able to spin up more instances quickly and without having to reconfigure stuff around.  With HTTP as our communication method we would normally have a self-registering **Service Discovery Server** (like [Netflix Eureka](https://github.com/Netflix/eureka) or a container orchestration system like [Kubernetes](https://kubernetes.io/) or [Rancher](http://rancher.com/)) and some kind of load balancer integrated with it so that our traffic is distributed and routed to the various instances. With message queues, our broker IS the load balancer. If multiple consumers are listening to a topic at the same time messages will be delivered following a configured strategy (more on RabbitMQ's QoS [here](https://insidethecpu.com/2014/11/11/rabbitmq-qos-vs-competing-consumers/)).  
So, for example, we can have four instances of our service processing messages in a round robin fashion, but since the QoS parameter is customizable at runtime we could also switch to a [fair dispatching strategy](https://www.rabbitmq.com/tutorials/tutorial-two-java.html) if one of the consumers is taking too long to complete its work and we need to balance the load out. Also, note that the client configuration is entirely done at runtime (and so is exchanges, queues and topics declarations by the way) so there is no need to tinker with the broker's configuration or restart anything.

## Async == Efficiency
We said at the beginning that one of the key features of messages compared to HTTP requests is that they allow for fully async communications. If I need to make a request to another service I can send a message on it's topic and then move on with my work. I can deal with the response when it comes in on my own topic, without having to wait for it. [Correlation IDs](http://www.enterpriseintegrationpatterns.com/patterns/messaging/CorrelationIdentifier.html) are used to keep track of which response message refers to which request. This works in concert with what we said about resiliency.
In an HTTP scenario, if I make a request and the callee is down, the connection would be refused and I would have to try again and again until it comes back up.
With message systems, I can send my request and forget about it. If the callee cannot receive it the broker will keep the message in the queue, and then deliver it when the consumer connects back. My response will come back when it can and I won't have to block or wait for it.

## In conclusion, messages are great. Show them some love
This is by no mean a rant against HTTP (which is still great, especially for public front facing APIs) but rather a try to guide you towards a more efficient and proficient strategy to coordinate microservice communications and all of this can be achieved with open source software, open protocols such as AMQP that prevent vendor lock-in and with a low (and scalable) infrastructure cost (see [RabbitMQ's requirements](https://www.rabbitmq.com/production-checklist.html)).

I used RabbitMQ for all my microservices project and it has been a great experience. Let me know in the comments what are your thoughts! Have you used message queues before? What is your experience with it?