RabbitMQ

Overview

RabbitMQ is a message broker implementing AMQP. Producers publish to exchanges, and exchanges route messages to queues using bindings: direct (exact routing key), topic (wildcard patterns), fanout (all bound queues), or headers. Consumers receive messages from queues and acknowledge them individually.

RabbitMQ shines at flexible routing, per-message acknowledgments, priorities, delayed and dead-lettered messages, and request-reply patterns. It is a traditional 'smart broker, simple consumer' design, whereas Kafka is 'simple broker, smart consumer' with retained logs.

When to use it

• Task queues with complex routing rules.
• Per-message acks, retries, priorities, and TTLs.
• Request-reply (RPC over messaging).
• Moderate throughput with low latency.

Where it shows up in interviews

Where it is used in real software

Key terms

Exchange

Receives messages and routes them to queues.

Binding / routing key

Rule linking exchange to queue / label used for routing.

Direct / topic / fanout exchange

Exact match / wildcard pattern / broadcast.

Prefetch (QoS)

Max unacknowledged messages per consumer.

Dead-letter exchange

Where rejected or expired messages go.

How it works, step by step

1. 1
   Declare exchanges and queues

   Durable, with bindings and DLX settings.

2. 2
   Publish with a routing key

   For example notify.email.welcome.

3. 3
   Exchange routes

   To every queue whose binding matches.

4. 4
   Consumers receive with prefetch

   Limits in-flight messages per worker.

5. 5
   Ack, nack, or reject

   Ack removes; nack requeues or dead-letters.

Exchange types

Routing key: notify.email.welcome

Topic exchanges give flexible routing without producers knowing which queues exist.

Implementation

1import amqp from "amqplib";2 3const conn = await amqp.connect(process.env.AMQP_URL!);4const ch = await conn.createChannel();5 6await ch.assertExchange("notify", "topic", { durable: true });7await ch.assertExchange("notify.dlx", "fanout", { durable: true });8await ch.assertQueue("email-jobs", { durable: true, arguments: { "x-queue-type": "quorum", "x-dead-letter-exchange": "notify.dlx" } });9await ch.bindQueue("email-jobs", "notify", "notify.email.*");10 11// Publish (persistent)12ch.publish("notify", "notify.email.welcome", Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true });13 14// Consume with prefetch and explicit acks15await ch.prefetch(20);16await ch.consume("email-jobs", async (msg) => {17  if (!msg) return;18  try {19    await sendEmail(JSON.parse(msg.content.toString()));20    ch.ack(msg);21  } catch {22    ch.nack(msg, false, false); // do not requeue: route to dead-letter exchange23  }24});

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Auto-ack mode.

  Fix: Messages are lost if the consumer crashes; use manual acks.

• Unlimited prefetch.

  Fix: One consumer grabs everything; set prefetch.

• Requeueing poison messages forever.

  Fix: Dead-letter after a retry limit.

Interview questions

Practice problems