> ## Documentation Index
> Fetch the complete documentation index at: https://resources.devweekends.com/llms.txt
> Use this file to discover all available pages before exploring further.

# RabbitMQ Crash Course

> Master message queuing - the glue that holds distributed systems together

<Frame>
  <img src="https://mintcdn.com/devweeekends/emzPt-9B_R8UKdqm/images/courses/devops-tools/rabbitmq-architecture.svg?fit=max&auto=format&n=emzPt-9B_R8UKdqm&q=85&s=d03a81e1aa28eae7070f588156cb41aa" alt="RabbitMQ Architecture Overview" width="1080" height="1080" data-path="images/courses/devops-tools/rabbitmq-architecture.svg" />
</Frame>

# RabbitMQ Crash Course

> **"RabbitMQ is like a post office that never loses a letter."**

When services need to talk to each other without waiting, when you need to survive failures gracefully, when you want to decouple your microservices - that is when you reach for RabbitMQ. Built on Erlang (the language that powers telecom switches with 99.999% uptime), RabbitMQ is battle-tested reliability.

***

## Why RabbitMQ Matters

<CardGroup cols={2}>
  <Card title="Decoupling" icon="link-slash">
    Services don't need to know about each other
  </Card>

  <Card title="Reliability" icon="shield-check">
    Messages persist, guaranteed delivery
  </Card>

  <Card title="Scalability" icon="chart-line">
    Handle millions of messages per second
  </Card>

  <Card title="Flexibility" icon="wand-magic-sparkles">
    Multiple messaging patterns supported
  </Card>
</CardGroup>

***

## The Story Behind RabbitMQ

**2007**: Rabbit Technologies created RabbitMQ to implement AMQP (Advanced Message Queuing Protocol).

**The Problem**:

* Tight coupling between services
* Lost messages during failures
* Difficult to scale distributed systems
* No standard messaging protocol

**The Solution**: RabbitMQ

* Reliable message delivery
* Flexible routing
* Multiple messaging patterns
* Language-agnostic (AMQP protocol)

**Today**: RabbitMQ powers:

* Instagram (message queuing)
* Reddit (asynchronous tasks)
* Uber (event-driven architecture)
* NASA (mission-critical systems)

**Acquired by**: VMware (2013), now part of Broadcom

***

## What You'll Learn

<Steps>
  <Step title="Fundamentals">
    Queues, exchanges, bindings, producers, consumers. The mental model for message-based architectures.
    [Start Here](/courses/devops-tools/rabbitmq-fundamentals)
  </Step>

  <Step title="Internals Deep Dive">
    Erlang/OTP, message flow mechanics, clustering internals, quorum queues. If you love understanding how things actually work, this one is for you.
    [Explore Internals](/courses/devops-tools/rabbitmq-internals)
  </Step>

  <Step title="Messaging Patterns">
    Work queues, pub/sub, routing, topics, RPC. The patterns that solve real problems.
    [Learn Patterns](/courses/devops-tools/rabbitmq-patterns)
  </Step>

  <Step title="Reliability">
    Clustering, high availability, quorum queues, disaster recovery. When messages absolutely cannot be lost.
    [Build Reliable Systems](/courses/devops-tools/rabbitmq-reliability)
  </Step>
</Steps>

***

## Course Structure

### Module 1: Fundamentals (2-3 hours)

AMQP protocol, exchanges, queues, bindings. You will build the mental model for how messages flow through RabbitMQ -- from the moment a producer publishes to the moment a consumer acknowledges. By the end, you will be able to trace a message through every component and explain why each exists.

### Module 2: Internals Deep Dive (2-3 hours)

Erlang/OTP foundation, supervision trees, message flow, credit flow, queue internals. This is where you learn *why* RabbitMQ is so reliable -- the Erlang "let it crash" philosophy, how supervision trees auto-heal failures, and how quorum queues achieve consensus. **If you love understanding what happens under the hood, this module is a goldmine. If not, skip to Module 3 -- no judgment.**

### Module 3: Messaging Patterns (2-3 hours)

Work queues for load distribution, pub/sub for broadcast, topic routing for selective delivery, RPC for request-reply, and dead letter exchanges for error handling. These are the architectural recipes you will reach for when designing real systems. Each pattern includes production-ready code with proper error handling.

### Module 4: Reliability (2 hours)

The three pillars of message safety: publisher confirms, durable persistence, and consumer acknowledgments. Then clustering, quorum queues vs mirrored queues, retry strategies with backoff, and connection recovery. This module is where "it works in development" becomes "it works in production at 3 AM when a node goes down."

***

Ready to master RabbitMQ? Start with [RabbitMQ Fundamentals](/courses/devops-tools/rabbitmq-fundamentals) or jump to [Internals Deep Dive](/courses/devops-tools/rabbitmq-internals) if you want to understand why Erlang makes RabbitMQ so reliable.