Most engineers who use RabbitMQ can publish to an exchange and consume from a queue, and would struggle to say what a channel is on the wire, why a positive publisher confirm is compatible with the message being silently discarded, or what happens to a publisher when a broker decides it has had enough. Those gaps are not academic. They are the reason a queue with no length limit takes down a cluster that was serving other traffic perfectly, the reason a consumer with the default prefetch hoards a backlog while its siblings idle, and the reason a retry loop quietly becomes an infinite one.

This course takes RabbitMQ apart. It starts with the AMQP model and its vocabulary, the frames on the connection and the channel multiplexing that makes them cheap, then works through exchange routing and the binding table that actually resolves a routing key. From there into the queue types: the classic queue's message store and queue index, quorum queues and the Raft log that replaced mirroring, and streams as an append-only log living inside a broker that is otherwise not one. Persistence and the memory and disk alarms get their own treatment, because the alarm is the single mechanism most likely to turn a local problem into a cluster-wide one.

The middle of the course is delivery guarantees, taken precisely rather than as slogans: what a publisher confirm promises and what it does not, why channel transactions are slower than confirms for a worse guarantee, acknowledgement modes and the redelivery accounting behind them, and dead-letter exchanges composed into retry ladders with bounded attempts. Then flow and scale: prefetch as the thing that decides consumer throughput, the credit-based flow control between the broker's internal processes, and clustering with the partition-handling strategies and what each one sacrifices.

The last third is practical. The pattern catalogue, work queues and RPC and pub/sub, delay mechanisms with their real trade-offs, priority queues and the fairness problem they create. Then operations: what the three monitoring interfaces can and cannot see, the handful of numbers that actually mean something, health checks that an orchestrator will not misuse, the failures that recur in every installation with their signatures, rolling upgrades and feature flags, and the migration from classic mirrored queues to quorum queues that most installations still owe. It closes with an honest comparison against Kafka, built on the one structural difference from which the rest follows.

Every section names the configuration settings it discusses together with their default values, works through the arithmetic an operator actually does, and prefers the failure case to the happy path. By the end you will be able to choose a queue type and defend it, set a prefetch from a measurement rather than a guess, design a retry topology that terminates, read an incident from four commands, and run a migration that does not discover its own preconditions halfway through.