RabbitMQ Cheatsheet: Complete Reference Guide

Quick Start

Installation

# Docker (recommended for development)
docker run -d --name rabbitmq \
  -p 5672:5672 -p 15672:15672 \
  -e RABBITMQ_DEFAULT_USER=admin \
  -e RABBITMQ_DEFAULT_PASS=secret \
  rabbitmq:3.13-management

# Ubuntu/Debian
curl -1sLf 'https://packagecloud.io/rabbitmq/rabbitmq-server/gpgkey' | sudo gpg --dearmor -o /usr/share/keyrings/rabbitmq.gpg
sudo apt-get install rabbitmq-server

# Enable management plugin
rabbitmq-plugins enable rabbitmq_management

Access Points

Service	Default URL/Port	Description
AMQP Protocol	`localhost:5672`	Client connections
Management UI	`http://localhost:15672`	Web interface
Management API	`http://localhost:15672/api`	REST API
Default Credentials	`guest/guest`	Local only, change in production

CLI Commands (rabbitmqctl)

Cluster Management

# Check cluster status
rabbitmqctl cluster_status

# Join cluster
rabbitmqctl stop_app
rabbitmqctl join_cluster rabbit@node1
rabbitmqctl start_app

# Change cluster node type
rabbitmqctl change_cluster_node_type disc  # or ram

# Remove node from cluster
rabbitmqctl forget_cluster_node rabbit@node2

# Force boot (use when cluster metadata is corrupted)
rabbitmqctl force_boot

User Management

# List users
rabbitmqctl list_users

# Add user
rabbitmqctl add_user username password

# Delete user
rabbitmqctl delete_user username

# Change password
rabbitmqctl change_password username newpassword

# Set user tags (roles)
rabbitmqctl set_user_tags username administrator
rabbitmqctl set_user_tags username monitoring management

# Set permissions (vhost, configure, write, read regex)
rabbitmqctl set_permissions -p / username ".*" ".*" ".*"
rabbitmqctl set_permissions -p /production username "^app-.*" "^app-.*" "^app-.*"

# List permissions
rabbitmqctl list_permissions -p /
rabbitmqctl list_user_permissions username

Virtual Hosts (vhosts)

# List vhosts
rabbitmqctl list_vhosts

# Add vhost
rabbitmqctl add_vhost /production

# Delete vhost (deletes all exchanges, queues, bindings)
rabbitmqctl delete_vhost /old-vhost

# Set vhost limits
rabbitmqctl set_vhost_limits -p / '{"max-connections": 1000}'
rabbitmqctl set_vhost_limits -p / '{"max-queues": 500}'

Queue Management

# List queues with details
rabbitmqctl list_queues name messages consumers memory state

# List all queue info
rabbitmqctl list_queues name messages_ready messages_unacknowledged

# Purge queue
rabbitmqctl purge_queue queue_name -p /

# Delete queue
rabbitmqctl delete_queue queue_name -p /

Exchange Management

# List exchanges
rabbitmqctl list_exchanges name type durable auto_delete

# Delete exchange
rabbitmqctl delete_exchange exchange_name -p /

Connections & Channels

# List connections
rabbitmqctl list_connections name peer_host peer_port state channels

# List channels
rabbitmqctl list_channels connection name number messages_unacknowledged

# Close connection
rabbitmqctl close_connection "<connection_name>" "Maintenance"

# Close all connections
rabbitmqctl close_all_connections "Cluster maintenance"

Health Checks

# Node health
rabbitmqctl node_health_check

# Check if node is running
rabbitmqctl status

# Disk space check
rabbitmqctl check_running
rabbitmqctl check_local_alarms

# Memory check
rabbitmqctl environment | grep memory

Maintenance

# Stop app (keeps Erlang VM running)
rabbitmqctl stop_app

# Start app
rabbitmqctl start_app

# Full restart
rabbitmqctl shutdown
systemctl start rabbitmq-server

# Rotate logs
rabbitmqctl rotate_logs

# Reset node (WARNING: deletes all data)
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl start_app

Configuration (rabbitmq.conf)

Core Settings

# Network & Listeners
listeners.tcp.default = 5672
listeners.ssl.default = 5671

# Management plugin
management.tcp.port = 15672
management.ssl.port = 15671

# Memory limits
vm_memory_high_watermark.relative = 0.6  # 60% of available RAM
vm_memory_high_watermark.absolute = 2GB

# Disk space limits
disk_free_limit.absolute = 5GB
disk_free_limit.relative = 1.5  # 1.5x RAM

# Heartbeat
heartbeat = 60

# Channel max
channel_max = 2048

# Frame max (max message size)
frame_max = 131072  # 128KB

# Default vhost
default_vhost = /

# Default user
default_user = guest
default_pass = guest
default_user_tags.administrator = true

Performance Tuning

# Queue settings
queue_master_locator = min-masters  # Balance queue masters
queue_index_embed_msgs_below = 4096

# Lazy queues (disk-based)
queue_mode = lazy

# Message TTL (milliseconds)
message_ttl = 3600000  # 1 hour

# Consumer timeout
consumer_timeout = 1800000  # 30 minutes

# Connection & channel limits per vhost
vhost_limits.max_connections = 1024
vhost_limits.max_queues = 512

Clustering

# Cluster name
cluster_name = production-cluster

# Cluster partition handling
cluster_partition_handling = autoheal  # or pause_minority

# Network tick time (cluster heartbeat)
net_ticktime = 60

TLS/SSL

listeners.ssl.default = 5671
ssl_options.cacertfile = /path/to/ca_certificate.pem
ssl_options.certfile = /path/to/server_certificate.pem
ssl_options.keyfile = /path/to/server_key.pem
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
ssl_options.versions.1 = tlsv1.3
ssl_options.versions.2 = tlsv1.2

Management API

Authentication

# Basic auth
curl -u admin:secret http://localhost:15672/api/overview

# Get all vhosts
curl -u admin:secret http://localhost:15672/api/vhosts

Common Endpoints

Method	Endpoint	Description
`GET`	`/api/overview`	Cluster overview
`GET`	`/api/nodes`	List all nodes
`GET`	`/api/connections`	List connections
`GET`	`/api/channels`	List channels
`GET`	`/api/queues`	List all queues
`GET`	`/api/queues/{vhost}/{name}`	Queue details
`GET`	`/api/exchanges`	List exchanges
`POST`	`/api/queues/{vhost}/{name}`	Declare queue
`DELETE`	`/api/queues/{vhost}/{name}`	Delete queue
`POST`	`/api/exchanges/{vhost}/{name}`	Declare exchange
`POST`	`/api/bindings/{vhost}/e/{ex}/q/{queue}`	Create binding

Examples

# Get queue details
curl -u admin:secret http://localhost:15672/api/queues/%2F/my-queue

# Create queue
curl -u admin:secret -X PUT \
  -H "content-type:application/json" \
  -d '{"durable":true,"auto_delete":false}' \
  http://localhost:15672/api/queues/%2F/new-queue

# Purge queue
curl -u admin:secret -X DELETE \
  http://localhost:15672/api/queues/%2F/my-queue/contents

# Get messages (non-destructive)
curl -u admin:secret -X POST \
  -H "content-type:application/json" \
  -d '{"count":10,"ackmode":"ack_requeue_true","encoding":"auto"}' \
  http://localhost:15672/api/queues/%2F/my-queue/get

# Publish message
curl -u admin:secret -X POST \
  -H "content-type:application/json" \
  -d '{"properties":{},"routing_key":"my-queue","payload":"hello","payload_encoding":"string"}' \
  http://localhost:15672/api/exchanges/%2F/amq.default/publish

Client Libraries

Python (pika)

import pika

# Connection
connection = pika.BlockingConnection(
    pika.ConnectionParameters(
        host='localhost',
        port=5672,
        credentials=pika.PlainCredentials('admin', 'secret'),
        heartbeat=60,
        blocked_connection_timeout=300
    )
)
channel = connection.channel()

# Declare queue
channel.queue_declare(
    queue='tasks',
    durable=True,
    arguments={'x-max-length': 10000}
)

# Publish message
channel.basic_publish(
    exchange='',
    routing_key='tasks',
    body='Hello World',
    properties=pika.BasicProperties(
        delivery_mode=2,  # persistent
        content_type='application/json',
        expiration='3600000'  # 1 hour TTL
    )
)

# Consume messages
def callback(ch, method, properties, body):
    print(f"Received {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_qos(prefetch_count=10)
channel.basic_consume(queue='tasks', on_message_callback=callback)
channel.start_consuming()

Java (Spring AMQP)

@Configuration
public class RabbitConfig {
    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory("localhost");
        factory.setUsername("admin");
        factory.setPassword("secret");
        factory.setRequestedHeartBeat(60);
        factory.setConnectionTimeout(30000);
        return factory;
    }

    @Bean
    public Queue tasksQueue() {
        return QueueBuilder.durable("tasks")
            .maxLength(10000L)
            .ttl(3600000) // 1 hour
            .build();
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
        RabbitTemplate template = new RabbitTemplate(factory);
        template.setMandatory(true);
        template.setMessageConverter(new Jackson2JsonMessageConverter());
        return template;
    }
}

// Publisher
@Service
public class Publisher {
    @Autowired
    private RabbitTemplate template;

    public void send(String message) {
        template.convertAndSend("tasks", message);
    }
}

// Consumer
@Service
public class Consumer {
    @RabbitListener(queues = "tasks", concurrency = "5-10")
    public void process(String message) {
        System.out.println("Received: " + message);
    }
}

Node.js (amqplib)

const amqp = require('amqplib');

async function main() {
  // Connect
  const conn = await amqp.connect({
    protocol: 'amqp',
    hostname: 'localhost',
    port: 5672,
    username: 'admin',
    password: 'secret',
    heartbeat: 60
  });

  const channel = await conn.createChannel();

  // Declare queue
  await channel.assertQueue('tasks', {
    durable: true,
    arguments: { 'x-max-length': 10000 }
  });

  // Publish
  channel.sendToQueue('tasks', Buffer.from('Hello'), {
    persistent: true,
    expiration: '3600000' // 1 hour
  });

  // Consume
  channel.prefetch(10);
  channel.consume('tasks', async (msg) => {
    console.log('Received:', msg.content.toString());
    channel.ack(msg);
  });
}

main().catch(console.error);

Exchange Types & Patterns

Direct Exchange

# Use case: Point-to-point routing
# Routing: Exact routing key match

rabbitmqadmin declare exchange name=logs type=direct durable=true
rabbitmqadmin declare queue name=error-logs durable=true
rabbitmqadmin declare binding source=logs destination=error-logs routing_key=error

Fanout Exchange

# Use case: Broadcast to all queues
# Routing: Ignores routing key

rabbitmqadmin declare exchange name=notifications type=fanout durable=true
rabbitmqadmin declare queue name=email-queue durable=true
rabbitmqadmin declare queue name=sms-queue durable=true
rabbitmqadmin declare binding source=notifications destination=email-queue
rabbitmqadmin declare binding source=notifications destination=sms-queue

Topic Exchange

# Use case: Pattern-based routing
# Routing: Wildcard matching (* = one word, # = zero or more words)

rabbitmqadmin declare exchange name=events type=topic durable=true
rabbitmqadmin declare binding source=events destination=user-created routing_key="user.created.*"
rabbitmqadmin declare binding source=events destination=all-errors routing_key="*.*.error"

Headers Exchange

# Use case: Route by message headers
# Routing: Matches header key-value pairs

rabbitmqadmin declare exchange name=tasks type=headers durable=true
rabbitmqadmin declare binding source=tasks destination=high-priority \
  arguments='{"x-match":"all","priority":"high","type":"critical"}'

Monitoring & Metrics

Key Metrics to Watch

Metric	Command	Warning Threshold
Memory Usage	`rabbitmqctl status \| grep memory`	>70% of limit
Disk Free	`rabbitmqctl environment \| grep disk_free`	<1.5x RAM
Connections	`rabbitmqctl list_connections \| wc -l`	>80% of limit
Queues	`rabbitmqctl list_queues \| wc -l`	>1000 queues
Unacked Messages	`rabbitmqctl list_queues messages_unacknowledged`	Growing over time
Message Rate	Check Management UI	Sustained >10k msg/s
File Descriptors	`rabbitmqctl status`	>80% of ulimit

Prometheus Metrics

# Enable Prometheus plugin
rabbitmq-plugins enable rabbitmq_prometheus

# Metrics endpoint
curl http://localhost:15692/metrics

# Key metrics:
# - rabbitmq_queue_messages
# - rabbitmq_queue_messages_ready
# - rabbitmq_queue_messages_unacknowledged
# - rabbitmq_connections
# - rabbitmq_channels
# - rabbitmq_erlang_vm_memory_bytes

Production Best Practices

High Availability

Practice	Configuration	Benefit
Quorum Queues	`x-queue-type: quorum`	Data safety, replication
Lazy Queues	`x-queue-mode: lazy`	Handle millions of messages
Cluster Size	3 or 5 nodes (odd number)	Fault tolerance
Load Balancer	HAProxy/nginx in front	Connection distribution
Publisher Confirms	Enable in client	Guaranteed delivery

Queue Configuration

# Production-ready queue
channel.queue_declare(
    queue='tasks',
    durable=True,              # Survive restarts
    arguments={
        'x-queue-type': 'quorum',           # HA queue
        'x-max-length': 100000,             # Limit queue size
        'x-message-ttl': 86400000,          # 24h TTL
        'x-dead-letter-exchange': 'dlx',    # DLX for failed msgs
        'x-dead-letter-routing-key': 'failed.tasks',
        'x-max-priority': 10                # Priority support
    }
)

Performance Tuning

Setting	Production Value	Reason
Prefetch Count	10-50	Balance throughput & fairness
Connection Pool	5-10 per app	Reuse connections
Channel Pool	1 per thread	Channels not thread-safe
Heartbeat	60s	Detect dead connections
Publisher Confirms	Enabled	Durability guarantee
Consumer ACK Mode	Manual	Control processing

Security Checklist

# 1. Change default credentials
rabbitmqctl change_password guest "$(openssl rand -base64 32)"
rabbitmqctl delete_user guest  # In production

# 2. Create app-specific users
rabbitmqctl add_user myapp "$(openssl rand -base64 32)"
rabbitmqctl set_permissions -p / myapp "^myapp-.*" "^myapp-.*" "^myapp-.*"

# 3. Enable TLS
# Add to rabbitmq.conf:
# listeners.ssl.default = 5671
# ssl_options.cacertfile = /path/to/ca.pem
# ssl_options.certfile = /path/to/cert.pem
# ssl_options.keyfile = /path/to/key.pem

# 4. Limit vhost resources
rabbitmqctl set_vhost_limits -p / '{"max-connections": 1024, "max-queues": 500}'

# 5. Enable audit logging
rabbitmq-plugins enable rabbitmq_event_exchange

Troubleshooting

Common Issues

# 1. Connection refused
# Check: Is RabbitMQ running?
systemctl status rabbitmq-server
rabbitmqctl status

# 2. Memory alarm
# Check memory usage
rabbitmqctl environment | grep memory
# Purge unnecessary queues
rabbitmqctl list_queues name messages | sort -k2 -nr
rabbitmqctl purge_queue <large_queue>

# 3. Disk alarm
# Check disk space
df -h
rabbitmqctl environment | grep disk_free_limit
# Clean old logs
rabbitmqctl rotate_logs

# 4. Authentication failed
# List users and permissions
rabbitmqctl list_users
rabbitmqctl list_permissions -p /

# 5. Queue stuck/not processing
# Check consumers
rabbitmqctl list_queues name consumers
rabbitmqctl list_consumers
# Check for blocking
rabbitmqctl list_connections state

# 6. Messages not routing
# Check bindings
rabbitmqctl list_bindings
# Enable tracing (temporarily)
rabbitmqctl trace_on -p /
rabbitmqctl trace_off -p /

Debug Logging

# Enable debug logging
rabbitmqctl set_log_level debug

# Check logs
tail -f /var/log/rabbitmq/[email protected]

# Revert to info level
rabbitmqctl set_log_level info

Quick Reference Tables

Message Properties

Property	Type	Description	Example
`delivery_mode`	int	1=transient, 2=persistent	`2`
`priority`	int	0-255 (if queue supports)	`5`
`expiration`	string	TTL in milliseconds	`"60000"`
`content_type`	string	MIME type	`"application/json"`
`reply_to`	string	Callback queue	`"rpc-replies"`
`correlation_id`	string	Request ID	`"req-12345"`
`message_id`	string	Unique ID	`"msg-uuid"`
`timestamp`	int	Unix timestamp	`1640000000`

Queue Arguments

Argument	Type	Description
`x-message-ttl`	int	Message TTL (ms)
`x-expires`	int	Queue auto-delete after (ms)
`x-max-length`	int	Max queue size (messages)
`x-max-length-bytes`	int	Max queue size (bytes)
`x-dead-letter-exchange`	string	DLX name
`x-dead-letter-routing-key`	string	DLX routing key
`x-max-priority`	int	Max priority (0-255)
`x-queue-mode`	string	`lazy` or `default`
`x-queue-type`	string	`classic` or `quorum`

Common Ports

Port	Service
4369	Erlang Port Mapper Daemon (epmd)
5672	AMQP
5671	AMQPS (TLS)
15672	Management HTTP
15671	Management HTTPS
15692	Prometheus metrics
25672	Inter-node communication

Resources

Official Docs: https://www.rabbitmq.com/documentation.html
Management Plugin: https://www.rabbitmq.com/management.html
Monitoring Guide: https://www.rabbitmq.com/monitoring.html
Production Checklist: https://www.rabbitmq.com/production-checklist.html

Quick Start

Installation

Access Points

CLI Commands (rabbitmqctl)

Cluster Management

User Management

Virtual Hosts (vhosts)

Queue Management

Exchange Management

Connections & Channels

Health Checks

Maintenance

Configuration (rabbitmq.conf)

Core Settings

Performance Tuning

Clustering

TLS/SSL

Management API

Authentication

Common Endpoints

Examples

Client Libraries

Python (pika)

Java (Spring AMQP)

Node.js (amqplib)

Exchange Types & Patterns

Direct Exchange

Fanout Exchange

Topic Exchange

Headers Exchange

Monitoring & Metrics

Key Metrics to Watch

Prometheus Metrics

Production Best Practices

High Availability

Queue Configuration

Performance Tuning

Security Checklist

Troubleshooting

Common Issues

Debug Logging

Quick Reference Tables

Message Properties

Queue Arguments

Common Ports

Resources

Cite this guide