About the course
RabbitMQ stands as a leading open-source message broker, serving as a critical component for enabling asynchronous communication, decoupling services, and building resilient applications across diverse architectures. For organisations relying on RabbitMQ to handle vital message traffic, ensuring its reliability, scalability, security, and performance is paramount. This 3-day intensive training course is designed for system administrators, DevOps engineers, and senior technical professionals who require an in-depth understanding of RabbitMQ beyond basic usage. It provides the knowledge and practical skills needed to effectively install, configure, secure, monitor, tune, and scale RabbitMQ deployments in production environments.
The course establishes a solid foundation by covering core messaging concepts, delving into the intricate details of RabbitMQ's architecture, and providing an overview of the Advanced Message Queuing Protocol (AMQP). Participants will gain hands-on experience with obtaining and installing RabbitMQ in various environments, mastering its initial configuration, and understanding critical aspects like logging, security mechanisms for authentication and authorisation, and the nuances of message persistence, memory management, and flow control within the broker.
Furthermore, the course provides detailed coverage of building highly available and scalable RabbitMQ clusters, including practical exercises with mirrored queues and understanding broker networks. Participants will learn how to effectively monitor RabbitMQ using the built-in Management UI and HTTP API, explore internal event mechanisms, and configure logging for diagnostics. A significant portion is dedicated to identifying performance bottlenecks and applying tuning techniques at the runtime, network, and asynchronous levels to optimise broker performance. The course also touches upon supporting additional protocols like MQTT and STOMP via the WebSockets plugin, equipping attendees with the comprehensive expertise required to build and maintain a resilient and high-performance messaging backbone for their applications.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Explain core messaging concepts, RabbitMQ architecture, and the AMQP protocol.
- Obtain, install, and perform initial configuration of a RabbitMQ broker in various environments.
- Configure security settings for authentication, authorisation, and secure communication in RabbitMQ.
- Understand RabbitMQ's message persistence mechanisms, memory management, and flow control.
- Design, implement, and manage highly available RabbitMQ clusters using features like Mirrored Queues.
- Effectively monitor RabbitMQ broker and cluster health and performance using the Management UI, API, and logging.
- Identify and apply techniques for performance tuning and optimisation of RabbitMQ deployments.
- Understand RabbitMQ's support for additional protocols like MQTT and STOMP via plugins.
-
This 3-day intensive training course is designed for IT professionals who are responsible for deploying, configuring, managing, and scaling RabbitMQ as a core part of their application infrastructure. It is ideal for:
System Administrators and DevOps Engineers who need to install, configure, monitor, and maintain robust RabbitMQ deployments.
Senior Developers and Software Architects who design and build applications relying heavily on RabbitMQ and require a deep understanding of its operational characteristics for building resilient systems.
Professionals looking to gain in-depth knowledge of RabbitMQ's advanced features, clustering, and performance tuning.
-
Participants should have:
Practical experience with administering Linux-based systems, including command-line navigation and basic scripting.
A fundamental understanding of networking concepts (IP addresses, ports, firewalls, basic troubleshooting).
General familiarity with messaging concepts (producers, consumers, queues, exchanges) is helpful, but the course will cover RabbitMQ-specific fundamentals.
Experience with virtualisation or cloud environments (for hands-on installation labs) is beneficial.
This course focuses on the operational aspects of the RabbitMQ broker itself rather than application-level messaging patterns implemented on top of it.
We can customise the training to match your team's experience and needs - with more time and coverage of fundamentals for those new to Linux, for instance.
-
This RabbitMQ course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
RabbitMQ Fundamentals
An overview of Messaging, Message Queues, and the role of Message Brokers in modern architectures.
RabbitMQ Architecture: Understanding Producers, Consumers, Exchanges, Queues, and Bindings.
The Message-Oriented Middleware concept.
Overview of the Advanced Message Queuing Protocol (AMQP 0-9-1) - Key concepts and terminology.
Basic concepts of Load Balancing in messaging systems.
Useful RabbitMQ CLI tools overview.
Hands-On Lab: Exploring messaging concepts and the RabbitMQ architecture using the Management UI (once installed).
RabbitMQ Installation and Initial Configuration
Obtaining RabbitMQ: Downloading packages for various platforms.
Installing RabbitMQ locally (e.g., on Linux/Windows).
Installing and enabling essential plugins (e.g., Management plugin).
Starting and Stopping the RabbitMQ service.
First steps in basic configuration: The rabbitmq.conf and advanced.config files.
Understanding RabbitMQ's Logging configuration and log file locations.
Hands-On Lab: Performing a local installation of RabbitMQ and the Management plugin, starting/stopping the service, making basic configuration changes, reviewing log files.
Security and Authentication
Importance of securing your RabbitMQ broker.
Authentication: Verifying client identity.
Authentication mechanisms: AMQPLAIN, PLAIN, External, TLS-based authentication.
Configuring users, virtual hosts (vhosts), and permissions (authorisation).
Controlling access to exchanges, queues, and bindings.
Configuring TLS/SSL for secure client connections.
Understanding and handling connection and channel error notifications.
Hands-On Lab: Configuring users, vhosts, and permissions via CLI and Management UI, setting up basic TLS for client connections.
RabbitMQ Persistence and Resource Management
Understanding the message lifecycle and persistence.
Configuring message durability and persistent message delivery.
Queue durability vs. Message durability.
RabbitMQ message store: How messages are stored on disk.
Memory usage: Monitoring and configuring memory high watermark.
Flow control: How RabbitMQ prevents overwhelming the broker.
Understanding and using Lazy Queues for reduced memory usage and disk-based storage.
Hands-On Lab: Configuring durable queues and persistent messages, observing memory usage and flow control behaviour, experimenting with lazy queues.
Module 5: RabbitMQ Clustering Fundamentals
Why cluster RabbitMQ brokers? (Scalability, High Availability).
Understanding the concept of a RabbitMQ cluster.
Node types: RAM nodes vs. Disk nodes.
Setting up a basic RabbitMQ cluster.
Managing cluster membership (joining, leaving nodes).
Troubleshooting clustering issues.
Hands-On Lab: Setting up a simple 2-node or 3-node RabbitMQ cluster, managing cluster membership via CLI.
High Availability with Mirrored Queues
Achieving High Availability for queues.
Understanding Mirrored Queues: Master/Replica synchronisation.
Configuring Mirrored Queues using policies.
Synchronising replicas.
Handling failover and recovery with Mirrored Queues.
Performance considerations for Mirrored Queues.
Broker Networks and Federation (overview, contrasting with clustering).
More on Load Balancing strategies for producers and consumers connecting to a cluster.
Hands-On Lab: Configuring mirrored queues via policies, simulating node failures and observing failover and recovery, testing client behaviour with Mirrored Queues.
Monitoring RabbitMQ
Importance of monitoring broker and cluster health.
Monitoring using the RabbitMQ Management UI: Overview, connections, channels, exchanges, queues, nodes, alarms.
Monitoring using the RabbitMQ HTTP API: Retrieving metrics and status programmatically.
Understanding the Internal Event Exchange (amq.rabbitmq.trace) for message tracing (overview).
Advanced Logging configuration: Controlling log levels and destinations.
Integrating RabbitMQ monitoring with external monitoring systems (overview).
Using Dead Letter Exchanges (DLX) for handling undeliverable messages.
Hands-On Lab: Exploring the Management UI in detail, using the HTTP API to retrieve metrics, configuring detailed logging, setting up a Dead Letter Exchange for error handling.
RabbitMQ Performance and Tuning Overview
Identifying performance bottlenecks in a messaging system.
Key metrics for measuring RabbitMQ performance (throughput, latency, resource usage).
Performance Tuning overview: Approaches and considerations.
Runtime tuning: Adjusting Erlang VM settings, process limits.
Network and TCP tuning: Optimising network configuration for messaging.
Async operations and their impact on performance.
Hands-On Lab: Using monitoring tools to identify potential bottlenecks, applying basic runtime or network tuning parameters and observing the effect on performance (potentially using load generation tools).
More RabbitMQ Tuning Tips and Best Practices
Optimising queue and exchange configuration for performance.
Client-side tuning: Connection pooling, channel usage, prefetch settings.
Using confirmations and transactions (understanding their performance impact).
Disk I/O considerations for persistent messages.
Understanding and avoiding common performance pitfalls.
Best practices for deploying and operating RabbitMQ at scale.
Hands-On Lab: Experimenting with client prefetch settings, comparing performance with and without confirmations/transactions, discussing best practices based on lab experiences.
Supporting Additional Protocols
RabbitMQ's multi-protocol support.
Understanding the WebSockets plugin.
Overview of the MQTT protocol: Lightweight messaging for IoT.
Overview of the STOMP protocol: Simple Text Oriented Messaging Protocol.
Enabling and configuring protocol plugins.
Basic interaction with RabbitMQ using MQTT or STOMP clients (demonstration/brief lab).
Hands-On Lab: Enabling the WebSockets plugin, connecting to RabbitMQ using a simple MQTT or STOMP client.
Disaster Recovery & Operational Best Practices
Strategies for RabbitMQ Disaster Recovery.
Backup and restore procedures for RabbitMQ data.
Planning for upgrades and maintenance.
Automating RabbitMQ deployment and management (overview of tools like Ansible, Chef, Kubernetes Operators).
Review of operational best practices for production RabbitMQ deployments.
Troubleshooting common operational issues.
Continuing your RabbitMQ journey: Resources and community.
Hands-On Lab: Practicing basic backup/restore procedures, discussing automated deployment strategies.
-
RabbitMQ Official Documentation: The primary and most comprehensive source for all aspects of RabbitMQ, including installation, configuration, clustering, monitoring, and plugins.
AMQP 0-9-1 Specification: Details the Advanced Message Queuing Protocol used by RabbitMQ. Useful for understanding the underlying wire protocol.
RabbitMQ Management Plugin Documentation: Specific documentation for the built-in web-based management UI and HTTP API.
RabbitMQ Blog: Contains articles and announcements from the RabbitMQ team.
RabbitMQ Tutorials: Official tutorials for various programming languages, useful for understanding client-side interaction patterns.
MQTT.org: Resources related to the MQTT protocol.
Trusted by
