The RabbitMQ Management Plugin Guide
Even seasoned users of RabbitMQ find the management interface useful for reviewing or tweaking their existing configuration. When you are starting out with RabbitMQ, however, it is essential to help you overcome initial hurdles during the learning curve.
The API and command-line interface (CLI) can be used to manage its internal configuration without any problem, but when you’re actively monitoring, managing, or debugging, the user interface (UI) can definitely save you time and effort.
Here’s a deeper dive into the RabbitMQ management plugin and user interface, and how it can make your work easier.
What Is RabbitMQ Management?
The RabbitMQ management is a built-in plugin that comes as a part of the message broker but has to be manually enabled. As we said, you don’t have to, but it’s nice to have. For most installations, the overhead of enabling the plugin is minimal.
The plugin provides you with:
- A web-based UI that gives you a real-time overview of your RabbitMQ nodes and cluster, and
- An HTTP API that allows programmatic access to RabbitMQ’s monitoring and management capabilities.
The plugin shows the data collected by RabbitMQ about the various parts of the system and exposes it through the UI, a web application.
Since you can see an overview of your entire system in one window, debugging and managing queues becomes much easier.
Its HTTP API can be used by external management tools, such as the Kubernetes Topology Operator, Ansible, or Puppet, to configure not only exchanges or queues but also manage users, virtual hosts (vhosts), and other configurations as well.
In the past, it was common to use the HTTP API for connecting to monitoring systems, however nowadays it is better to use Prometheus and Grafana. We wrote blogposts on the Dashboards for RabbitMQ, and Review of Real Life Use Cases for Metrics.
In addition to the UI and API, the RabbitMQ management plugin also offers tools for:
- Memory usage analysis: monitoring how the various nodes are consuming memory
- Monitoring and metrics: getting real-time data on queue sizes, message rates, resource usage, etc.
- User and permission management: handling roles and access from the UI
- Topology management: controlling queues, exchanges, and bindings
The UI still provides a convenient interface to import and export definitions, which can be useful for backing up and testing different configurations.
Why Use RabbitMQ Management?
There are some good reasons why you might want to enable RabbitMQ management:
- Real-time visibility into queue health, message rates, and system load without writing API calls.
- Faster debugging by identifying slow consumers, inspecting stuck messages, and manual test message routing through the command line.
- Easier management by creating, binding, and modifying queues and exchanges on the fly instead of redeploying code.
- Simplified user and access handling, where adding users, tweaking permissions, and managing vhosts can be done without CLI commands.
- Easier to automate, as any action you can take can also be converted into a script through the HTTP API.
| Discover the common use cases of this open-source message broker. [Read more] |
Setting Up the RabbitMQ Management UI
Whilst the RabbitMQ plugin comes pre-installed, it’s deactivated by default. To enable it, run:
rabbitmq-plugins enable rabbitmq_management |
This will enable the management UI and the HTTP API without requiring a server restart.
For automated deployments, the plugin can be enabled by adding rabbitmq_management to the enabled_plugins file.
Once the plugin has been enabled, the UI can be accessed via the RabbitMQ management URL in a web browser. If it’s running locally:
http://localhost:15672/ |
If you’re accessing it remotely, use:
http://your-server-name:15672/ |
It’s important to note that port 15672 is only for the UI and API. It doesn’t support messaging protocols like AMQP, STOMP, or MQTT. If you have to send or receive messages, you’d need to use the appropriate protocol-specific port, like 5672 for AMQP, for example.
The installed UI comes with a default user:
Username: guest |
However, a guest can only access the UI from localhost, so you won’t be able to log in from another machine for security reasons. If you want to be able to do that, you will need to create a new user with admin rights:
rabbitmqctl add_user myuser mypasswordrabbitmqctl set_user_tags myuser administratorrabbitmqctl set_permissions -p / myuser ".*" ".*" ".*" |
Once the new user has been created, you can log in with these credentials from anywhere, as long as you have enabled remote access and set up listeners:
listeners.tcp.default = 5672 |
To make sure the plugin is running, check the enabled plugins:
rabbitmq-plugins list |
It should list rabbitmq_management marked as “enabled” with a “E*” or “e*” before its name, where * means that it was successfully started.
If the UI is still not accessible, check the RabbitMQ logs for errors related to plugin activation or port binding.
For production environments, you might want to enable HTTPS to encrypt credentials and data when accessing the UI:
management.ssl.port = 15671 |
If you need to disable the plugin:
rabbitmq-plugins disable rabbitmq_management |
Key Features of the RabbitMQ Management Plugin
User-Friendly API-Driven Interface
As mentioned before, the RabbitMQ management UI is a web application accessible from any modern browser, including Chrome, Firefox, Safari, and Edge. It’s built on the RabbitMQ HTTP API and dynamically fetches data for real-time updates without needing to reload the page.
The interface also allows you to manage RabbitMQ without CLI commands and automate tasks via API calls, meaning anything you do in the UI can also be scripted for automation and DevOps workflows. Just use your browser’s Developer Console to inspect requests, or view the API documentation inside your RabbitMQ by navigating to http://localhost:15672/api/index.html URL.
Queue and Exchange Management
With the RabbitMQ management console, you don’t need to memorise CLI commands to create, modify or delete queues and exchanges; you can do all that through the management UI and HTTP API. This is extremely useful when debugging or testing different routing configurations without changing the application code.
This visual management ability can also be used to set message policies for better control, such as applying time-to-live (TTL) to automatically remove old messages. To prevent excessive memory usage, you could define the maximum queue length, or experiment with more complex routing solutions, like dead-lettering to reroute failed or unprocessed messages to another queue, for example.
The interface’s ability to let you manually send and receive messages is also very useful. You can publish test messages to exchanges or queues for debugging or consume them to inspect their payload before processing.
You can also use the UI to dynamically modify queue bindings without restarting services. This makes testing different message routing strategies so much simpler.
Real-Time Monitoring and Metrics
The RabbitMQ management dashboard gives you visibility into message flow, system performance, and resource usage. It allows you to view the rate of message publishing, delivery, and acknowledgements across the system. You can even break down message flow per queue, exchange, or channel for granular analysis.
If there’s an issue with consumers not confirming receipt, you’re able to see it because of the unacknowledged messages.
RabbitMQ lets you track its memory consumption to check for overload and analyse CPU and disk usage to make sure the broker is not being overworked. The UI allows you to view open sockets and file descriptors at the node level to give you an idea of how many connections RabbitMQ is handling.
The interface is also quite useful for checking node health and performance. It lets you monitor garbage collection activity, track inter-node bandwidth, and detect disk and memory alarms.
As a result, detecting performance bottlenecks becomes quite quick. You’re able to see how many messages are waiting in the queue, whether they’re being processed efficiently, and which slow consumers might be causing the backlog. You can also ensure that the system is stable and resources aren’t being exhausted.
| Learn more about how effective monitoring and observability can get you more out of RabbitMQ. [Read more] |
User and Permission Management
The RabbitMQ management console makes security and compliance easier in multi-user environments. It allows you to add, delete, and manage users and roles, without the need for CLI commands or configuration files, quite smoothly from the interface.
It also follows the three-level permission model as followed by RabbitMQ. The permissions—read, write, configure—can be applied per vhost to ensure that users only access the queues and exchanges they need.
The interface also helps you enforce role-based access control (RBAC) to separate administrators, developers, and consumers. This is useful in preventing accidental modifications and limiting access to queues.
Advanced System Administration
For production environments—where it’s important to maintain stability and consistency—the RabbitMQ management interface offers several administrative tools.
The entire RabbitMQ configuration can be exported as a JSON file for a quick backup or imported into another instance to replicate setups across environments. This is very useful for a number of scenarios, including migrating between servers, maintaining versioned backups, or for consistent deployment.
The interface also helps with disaster recovery and exposing cluster setup information. It can reload definitions on startup instead of manually recreating them. When the server restarts, all settings are restored automatically, which helps with high-availability setups where downtime must be minimised.
The management console allows administrators to force-close client connections for troubleshooting if the connection is stuck, unresponsive, or misbehaving. It also prevents rogue consumers from overloading RabbitMQ with unnecessary connections and helps fix applications that cause queue congestion or fail to acknowledge messages.
Finally, it allows you to purge messages from bloated queues, which is useful when consumers aren’t processing messages fast enough and are causing queue backlogs. This also helps in testing scenarios where you want to reset queues but not delete them entirely.
If you still need help to manage your RabbitMQ, consider our bespoke consultancy service.
“As you can see, the plugin can make your work easier. It’s easy to implement and even easier to use. If you need a hand with implementing or managing RabbitMQ, get in touch with us. We’d be happy to help..“
Lajos Gerecs
RabbitMQ Consultant
