RabbitMQ In Practice

Explore the AMQP protocol and RabbitMQ’s implementation for asynchronous, platform independent messaging between producers and consumers, with messages consisting of headers, properties, and a body.

Learn to run a single RabbitMQ node in three steps: download RabbitMQ binaries, install Erlang, and start RabbitMQ from the command line.

Configure RabbitMQ using environment variables, external configuration files, and runtime parameters to manage ports, locations, frame settings, and the management plugin with the new configuration format.

Install the management plugin to enable a web admin UI and extended statistics, stop RabbitMQ to install it, then start RabbitMQ and access the UI at localhost:15672 using guest/guest credentials.

Explore RabbitMQ in practice with the management plugin, covering node overview, memory metrics and alarms, connections and channels, exchanges, and secure admin tasks like changing the default guest password.

Use the RabbitMQ RESTful API on the management port to integrate external systems and build custom monitoring UIs. Fetch node details with GET /api/nodes and access full documentation at /api.

Explore how exchanges, queues, bindings, and routing keys route messages in RabbitMQ. Understand how default, fanout, direct, topic, and headers exchanges use binding keys and routing keys to deliver messages.

Create a queue in the web management UI with a chosen type, name (for example q.logs.test), and durability, then publish a message and consume it with positive acknowledgment.

Discover most common routing and consuming patterns in RabbitMQ, from simple queues to work queues. Explore publish and subscribe, and RPC (remote procedure call) models, using the web management UI.

Set up a simple queue pattern in RabbitMQ to enable communication between applications written in different languages, publish messages as persistent to durable queues, and consume with automatic acknowledgment.

Learn how work queues distribute time-consuming tasks across multiple workers to scale out processing. Use acknowledgements, requeue, and dead letter exchange concepts to ensure reliable delivery.

Learn how topic exchanges enable publish-subscribe messaging with selective delivery by routing keys and bindings, using stars and hashes, reducing bindings and guiding hierarchical topic naming.

Explore headers exchange in RabbitMQ, using x-match any and all to route messages by headers, bind queues, publish messages, and compare with direct exchanges.

Demonstrates building a RabbitMQ RPC system using a single RPC queue and exclusive client reply queues. Use correlation ID to map requests to responses across multiple methods and clients.

Enable the Consistent Hash exchange to split long queues into smaller ones and distribute messages across queues using binding keys as weights, with default hash calculated from routing key.

Learn how dead letter exchange patterns in RabbitMQ move messages that cannot be consumed to a dead letter queue, using TTL and requeue settings to diagnose issues and model delays.

Leverage delay and delay scheduled patterns in RabbitMQ using a dead letter exchange to model delayed publication and automatic retries, with batch publication and ttl-based handling through the x-message-ttl attribute.

Explore data safety in RabbitMQ through consumer acknowledgments, transactions, and publisher confirms, highlighting automatic vs manual acknowledgments, rollback scenarios, and durability and throughput.

Policies apply ttl and max-queue-len via dynamic arguments for queues or exchanges, using virtual-host scope and regex-based matching with priority.

Explore how RabbitMQ priority queues work by using the x-max-priority attribute to assign 1–255 priorities, observe delivery order, performance implications, and caveats like ttl, max-length, and internal queue behavior.

Learn to run RabbitMQ as a Windows service by configuring with two environment variables (RABBITMQ_BASE and ERLANG_HOME) and a configuration file, using rabbitmq-service to install, start, and manage the service.

Build a three-node RabbitMQ cluster to improve fault tolerance, high availability, and throughput, with replicated queues and a shared cluster name for seamless failover.

Learn how to scale in a RabbitMQ cluster by removing a node, forgetting it from the cluster, stopping its application, resetting its database, and updating remaining nodes.

Learn how shovels enable cross-cluster message transfer in RabbitMQ. Use dynamic shovels for runtime configuration to copy messages from a source queue to a target, with traceable headers.

Learn to configure federated exchanges across two RabbitMQ clusters, enabling upstream–downstream federation, policies, and management, and observe cross-cluster message transmission and routing via federation.

Practice federated queues to balance a single logical queue across clusters by linking an upstream and downstream, with messages moving to the downstream only when a consumer connects.

Learn to configure highly available, mirrored queues in RabbitMQ with a mirroring policy (ha-mode, ha-params), creating masters and mirrors across nodes, and choose manual or automatic synchronization.

Quorum queues provide durable, raft-based high-availability queues with a leader and followers, automatic synchronization, and read-from-followers, with tradeoffs like higher memory use and missing some classic features.

Explore RabbitMQ throughput testing with PerfTest, installing and running scenarios from a simple producer–consumer to IoT workloads, and measure throughput, latency, and memory impact.

Explore proactive RabbitMQ monitoring practices, using RESTful API and command-line tools to track cluster and node metrics, trigger autoscaling, and quickly identify root causes.

Secure RabbitMQ by removing the default guest account, creating per-application users, and enabling TLS across all protocols to protect data in transit and disable unencrypted ports.

Explore how RabbitMQ handles authentication and authorization, define permissions with configure, read, and write, and manage complex cases like bindings, dead-letter exchanges, topic permissions, and management plugin tags.