What is RabbitMQ?

RabbitMQ is a widely used open-source message broker that facilitates the exchange of messages between different systems and services. It implements the Advanced Message Queuing Protocol (AMQP), which provides robust, reliable, and scalable communication between distributed applications. RabbitMQ is commonly employed in microservices architectures, where it allows systems to communicate asynchronously, enabling scalability, decoupling, and fault tolerance.

When to Use RabbitMQ?

Distributed Systems: When you have multiple independent services that need to communicate asynchronously.
Message Delivery Guarantees: If your system requires reliable delivery of messages, including guaranteed "at least once" or "exactly once" delivery.
Workload Balancing: When you need to distribute heavy workloads across multiple workers or instances.
RabbitMQ allows multiple consumers to process messages from a queue, helping to spread the load and increase throughput.
Event-Driven Architectures: In event-driven systems, where services emit events (e.g., user sign-up) and other services act upon them (e.g., send a welcome email).

Example of RabbitMQ

The user sends a PDF creation request to the web application.
The web application (the producer) sends a message to RabbitMQ that includes data from the request such as name and email.
An exchange accepts the messages from the producer and routes them to correct message queues for PDF creation.
The PDF processing worker (the consumer) receives the task message and starts processing the PDF.

Online shopping example

Order Service:

When a user places an order, the order service sends a message to the "order queue".
The order is acknowledged immediately, ensuring a fast response time for the user.

Payment Service:

A consumer in the payment service listens to the "order queue" and processes the payment.
If payment fails, the message can be re-queued or moved to a dead-letter queue for further investigation.

Inventory Service:

Another consumer listens to the same "order queue" and updates the inventory once the order is processed.
The inventory service doesn’t need to wait for the payment to complete but can operate independently.

Email Notification Service:

The email service listens to a separate "notification queue" and sends an email to the user confirming the order.
Even if the email service is down, RabbitMQ will hold the message until it is ready to process it.

Exchange in RabbitMQ

Messages are not sent directly to a queue by the producer. Instead, they are first sent to an exchange, which is responsible for directing the messages to the appropriate queues. This routing process is guided by bindings and routing keys. A binding establishes the connection between a queue and an exchange, helping determine how messages are routed.

Message Flow in RabbitMQ

The producer sends a message to an exchange.
When creating an exchange, its type must be specified. There are four types of exchanges: direct, topic, headers, and fanout.
The exchange receives the message and becomes responsible for routing it. Depending on the type of exchange, various message attributes such as the routing key are taken into consideration.
Bindings must be established between the exchange and queues. In this scenario, there are two bindings linking the exchange to two different queues.
The exchange routes the message to the appropriate queues based on message attributes.
Messages remain in the queue until they are processed by a consumer.
The consumer retrieves and processes the message.

Exchange Type in RabbitMQ

Exchange Type	Routing Logic	Use Case
Direct	Exact match between routing key and queue’s binding key.	Point-to-point communication, task distribution.
Fanout	Broadcasts messages to all bound queues.	Pub-sub patterns, sending the same message to multiple queues.
Topic	Pattern matching with routing key and binding key (wildcards).	Routing messages based on complex topic hierarchies.
Headers	Message headers are used for routing, instead of routing keys.	Content-based routing based on message metadata.

Key concepts in RabbitMQ

Producer: The entity that sends messages to an exchange.
Consumer: The entity that retrieves and processes messages from a queue.
Exchange: A component responsible for routing messages to queues based on routing rules.
Connection: A TCP connection between your application and the RabbitMQ broker.
Queue: A buffer where messages are stored until consumed by consumers.
Binding: A link between an exchange and a queue, defining routing rules for messages.
Routing Key: A key used to determine how messages are routed to queues from an exchange.
Message: The data sent from the producer to the consumer via exchanges and queues.
AMQP: Advanced Message Queuing Protocol, the protocol used by RabbitMQ for messaging.
Acknowledgment: A signal from the consumer indicating that a message was received and processed successfully.
Dead-Letter Exchange: An exchange where messages are routed if they cannot be delivered or are rejected by a queue.

How to handle message expiration and dead-lettering in RabbitMQ?

Message Expiration: Set a expiration property on messages or queues to automatically remove messages after a certain time period. This is useful for handling time-sensitive messages.


    channel.basic_publish(
        exchange='',
        routing_key='my_queue',
        body='message',
        properties=pika.BasicProperties(expiration='60000')  # Message expires in 60 seconds
    )

Dead-Letter Exchanges (DLX): Configure a dead-letter exchange to route messages that cannot be delivered or are rejected by consumers. Set the x-dead-letter-exchange argument on the original queue to specify the DLX.


    channel.queue_declare(
        queue='original_queue',
        arguments={
            'x-dead-letter-exchange': 'dlx_exchange'
        }
    )

Install RabbitMQ using Docker Desktop

Download Docker Desktop : https://docs.docker.com/desktop/install/windows-install/
Open Docker Desktop and ensure it's running.
Open a terminal or command prompt.
Pull the RabbitMQ Docker image:
```
docker pull rabbitmq:management
```
Run the RabbitMQ container:
```
docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:management
```
- -d runs the container in detached mode.
- --name rabbitmq assigns a name to the container.
- -p 5672:5672 maps port 5672 from the container to port 5672 on your host machine.
- -p 15672:15672 maps port 15672 from the container to port 15672 on your host machine.
Access RabbitMQ Management Interface at http://localhost:15672 using default credentials:
- Username: guest
- Password: guest

Reference : https://cloudamqp.com/blog/part1-rabbitmq-for-beginners-what-is-rabbitmq.html