Skip to main content
Mapagam

53 SECTIONS · 1470 TOPICS

Rabbitmq Roadmap

  1. Installing and Configuring RabbitMQ

    1. 1. Installing via Package Manager
    2. Example: Install RabbitMQ on Ubuntu/Debian
    3. Example: Install RabbitMQ on RHEL/CentOS
    4. 2. Installing via Docker
    5. Example: Run RabbitMQ with Docker
    6. 3. Installing on Windows
    7. Example: Download and Install RabbitMQ on Windows
    8. 4. Installing via Kubernetes
    9. Example: Deploying RabbitMQ on Kubernetes
    10. Installation Steps
    11. 5. Starting and Stopping Service
    12. Example: Managing RabbitMQ Service
    13. 6. Verifying Installation
    14. Example: Check RabbitMQ Service Status
    15. 7. Configuring rabbitmq.conf
    16. Example: Basic RabbitMQ Configuration
    17. Configuration Best Practices
    18. 8. Configuring advanced.config
    19. Example: Basic advanced.config structure
    20. Key Points for Configuration
    21. 9. Setting Environment Variables
    22. Example: RabbitMQ Environment Variables
    23. 10. Setting Node Name
    24. Example: Setting Node Name via Environment Variable
    25. Example: Setting Node Name via Configuration File
    26. 11. Configuring Data Directory
    27. Example: Setting Custom Data Directory
    28. 12. Configuring Log Levels
    29. Example: Setting Log Level via Configuration File
    30. 13. Enabling Management Plugin
    31. Example: Enabling Management Plugin via Configuration File
    32. Example: Enabling Management Plugin via CLI

  2. Understanding Virtual Hosts

    1. 1. Understanding Default vhost
    2. Example: Connecting to Default vhost
    3. 2. Creating Virtual Host
    4. Example: Create a Virtual Host via CLI
    5. 3. Listing Virtual Hosts
    6. Example: Listing Virtual Hosts
    7. Example: Listing Virtual Hosts in Quiet Mode
    8. 4. Deleting Virtual Host
    9. Example: Delete Virtual Host
    10. 5. Using vhost for Isolation
    11. Example: Creating a vhost and setting permissions
    12. Best Practices for vhost Isolation
    13. 6. Setting vhost Limits
    14. Example: Configuring vhost limits via rabbitmq.conf
    15. Example: Setting limits using rabbitmqctl
    16. 7. Granting User Permissions
    17. Example: Setting User Permissions
    18. 8. Configuring vhost Metadata
    19. Example: Setting vhost metadata via CLI
    20. Example: Setting vhost metadata via Management API
    21. 9. Monitoring vhost Resources
    22. Example: Monitoring vhost resources via CLI
    23. Example: Checking message count in a specific vhost
    24. 10. Tracing vhost Activity
    25. Example: Enable tracing for a virtual host
    26. Tracing Configuration Summary
    27. 11. Backing Up vhost
    28. Example: Backup a Virtual Host
    29. 12. Understanding vhost Best Practices
    30. Best Practices for RabbitMQ Virtual Hosts

  3. Configuring Users and Permissions

    1. 1. Creating User
    2. Example: Creating a User via CLI
    3. Example: Setting User Tags
    4. 2. Deleting User
    5. Example: Delete a User
    6. 3. Changing Password
    7. Example: Changing User Password
    8. 4. Using Guest User
    9. Example: Connecting with Guest User
    10. 5. Setting User Tags
    11. Example: Setting User Tags via CLI
    12. 6. Granting Permissions
    13. Example: Setting Permissions for a User
    14. 7. Understanding Permission Scopes
    15. Example: Setting User Permissions
    16. 8. Using Regular Expressions
    17. Example: Setting up user permissions with regex
    18. 9. Listing User Permissions
    19. Example: Using rabbitmqctl to list permissions
    20. 10. Listing vhost Permissions
    21. Example: Listing vhost permissions using rabbitmqctl
    22. Example: Listing permissions for a specific vhost
    23. 11. Implementing RBAC
    24. Example: Creating a User with RBAC
    25. RBAC Configuration Summary
    26. 12. Auditing User Activity
    27. Example: Enabling Audit Logging
    28. Audit Logging Configuration

  4. Working with Connections

    1. 1. Creating Connection
    2. Example: Creating a Connection in Python
    3. 2. Understanding Connection String Format
    4. Example: Connection String Format
    5. 3. Configuring Connection Parameters
    6. Example: Basic Connection Configuration
    7. Example: Secure Connection with TLS
    8. 4. Setting Connection Timeout
    9. Example: Configuring Connection Timeout in RabbitMQ
    10. 5. Configuring Heartbeat Interval
    11. Example: Setting Heartbeat Interval
    12. 6. Using Connection Pooling
    13. Example: Configuring Connection Pool in Java
    14. 7. Handling Connection Failures
    15. Example: Basic Connection Recovery Configuration
    16. Example: Reconnecting with Retry Logic
    17. Connection Failure Recovery Strategy
    18. 8. Using Blocked Connection Notifications
    19. Example: Setting up blocked connection notifications
    20. 9. Closing Connections Gracefully
    21. Example: Closing Connection with Code and Reason
    22. 10. Monitoring Active Connections
    23. Example: List active connections via CLI
    24. Example: Using management plugin API
    25. Key Metrics for Connection Monitoring
    26. 11. Understanding Connection Limits
    27. Example: Configuring Connection Limits
    28. 12. Troubleshooting Connection Issues
    29. Example: Connection timeout error handling

  5. Working with Channels

    1. 1. Creating Channels
    2. Example: Creating a Channel
    3. 2. Understanding Channel Lifecycle
    4. Example: Channel Lifecycle Management
    5. 3. Setting Channel Prefetch
    6. Example: Setting Prefetch on a Channel
    7. 4. Understanding Channel vs Connection
    8. Example: Creating a Channel from a Connection
    9. 5. Using Multiple Channels
    10. Example: Declaring and Using Multiple Channels
    11. 6. Handling Channel Errors
    12. Example: Error Handling in Channel
    13. 7. Closing Channels Gracefully
    14. Example: Closing a Channel
    15. 8. Setting Channel Max
    16. Example: Configuring Channel Max in RabbitMQ
    17. 9. Understanding Channel Flow Control
    18. Example: Enabling Flow Control
    19. Key Points
    20. 10. Monitoring Active Channels
    21. Example: List Active Channels
    22. 11. Using Confirm Mode per Channel
    23. Example: Enabling Confirm Mode
    24. 12. Understanding Channel Best Practices
    25. Channel Best Practices Summary
    26. Example: Channel Usage Best Practices

  6. Creating and Managing Exchanges

    1. 1. Declaring Exchange
    2. Example: Declaring a Direct Exchange
    3. 2. Creating Direct Exchange
    4. Example: Creating a Direct Exchange in RabbitMQ using Python
    5. 3. Creating Topic Exchange
    6. Example: Create Topic Exchange with RabbitMQ Management UI
    7. Example: Create Topic Exchange using Python (pika)
    8. 4. Creating Fanout Exchange
    9. Example: Create Fanout Exchange with RabbitMQ Management UI
    10. Example: Create Fanout Exchange using Python (pika)
    11. 5. Creating Headers Exchange
    12. Example: Declare Headers Exchange
    13. Key Features of Headers Exchange
    14. 6. Setting Exchange Durability
    15. Example: Declaring a Durable Exchange
    16. 7. Setting Auto-Delete Flag
    17. Example: Declaring an Auto-Delete Exchange
    18. 8. Using Internal Exchanges
    19. Example: Declaring an Internal Exchange
    20. 9. Configuring Alternate Exchange
    21. Example: Setting up an alternate exchange
    22. 10. Deleting Exchange
    23. Example: Delete Exchange with CLI
    24. Example: Delete Exchange with Force
    25. 11. Listing Exchanges
    26. 12. Checking Exchange Bindings
    27. Example: Using RabbitMQ CLI to Check Bindings
    28. Example: Using RabbitMQ Management API to Check Bindings

  7. Creating and Managing Queues

    1. 1. Declaring Queue
    2. Example: Declaring a Queue in Java
    3. 2. Creating Durable Queue
    4. Example: Creating a Durable Queue in RabbitMQ
    5. 3. Creating Exclusive Queue
    6. Example: Creating an Exclusive Queue in RabbitMQ (Java)
    7. 4. Creating Auto-Delete Queue
    8. Example: Creating an Auto-Delete Queue in RabbitMQ
    9. 5. Setting Queue Arguments
    10. Example: Declaring a durable queue with TTL and DLX
    11. 6. Configuring Queue TTL
    12. Example: Setting Queue TTL via RabbitMQ Management UI
    13. Example: Setting Max Length by Bytes
    14. 8. Setting Max Length Bytes
    15. Example: Configuring max-length-bytes in a queue declaration
    16. 9. Configuring Overflow Behavior
    17. Example: Setting overflow behavior to drop-head
    18. 10. Purging Queue Messages
    19. Example: Purging Messages from a Queue
    20. 11. Deleting Queue
    21. Example: Delete a Queue
    22. 12. Listing Queues
    23. Example: Listing Queues via CLI
    24. Example: Listing Queues via Management API
    25. 13. Checking Queue Status
    26. Example: Using RabbitMQ Management API to Check Queue Status
    27. Example: Using RabbitMQ CLI to Check Queue Status

  8. Working with Bindings

    1. 1. Creating Queue Binding
    2. Example: Bind a queue to an exchange
    3. 2. Using Routing Keys
    4. Example: Publishing with Routing Key
    5. Example: Binding Queue with Routing Key
    6. 3. Binding with Direct Exchange
    7. Example: Binding a Queue to Direct Exchange
    8. 4. Binding with Topic Exchange
    9. Example: Binding a Queue to a Topic Exchange
    10. 5. Binding with Fanout Exchange
    11. Example: Binding a Queue to a Fanout Exchange
    12. 6. Binding with Headers Exchange
    13. Example: Binding Headers Exchange
    14. 7. Creating Exchange-to-Exchange Binding
    15. Example: Creating Exchange-to-Exchange Binding
    16. 8. Using Multiple Bindings
    17. Example: Creating Multiple Bindings
    18. Summary of Multiple Bindings
    19. 9. Understanding Binding Arguments
    20. Example: Binding with routing key
    21. Example: Binding with headers
    22. 10. Unbinding Queue
    23. Example: Unbind Queue from Exchange
    24. 11. Unbinding Exchange
    25. Example: Unbind Exchange from Queue
    26. 12. Listing Bindings
    27. Example: Using rabbitmqctl to list bindings
    28. Example: Using rabbitmqctl to list bindings for a specific exchange
    29. Example: Using rabbitmqctl to list bindings for a specific queue

  9. Publishing Messages

    1. 1. Publishing Basic Message
    2. Example: Publishing a Basic Message
    3. 2. Setting Routing Key
    4. Example: Publishing with routing key
    5. 3. Publishing to Default Exchange
    6. Example: Publishing to Default Exchange
    7. 4. Setting Mandatory Flag
    8. Example: Publishing with Mandatory Flag
    9. 5. Handling Unroutable Messages
    10. Example: Publishing with Mandatory Flag
    11. 6. Using Publisher Confirms
    12. Example: Enabling Publisher Confirms
    13. Example: Publishing with Confirm Callbacks
    14. 7. Batching Messages
    15. Example: Publishing Batches of Messages
    16. 8. Setting Message Priority
    17. Example: Setting Priority in AMQP
    18. 9. Publishing Large Messages
    19. Example: Publishing Large Message
    20. 10. Using Transactional Publishes
    21. Example: Publishing with Transactional Semantics
    22. 11. Measuring Publish Rate
    23. Example: Monitoring publish rate via RabbitMQ Management Plugin
    24. 12. Handling Publish Errors
    25. Example: Error Handling in Publisher

  10. Working with Message Properties

    1. 1. Setting Delivery Mode
    2. Example: Setting Delivery Mode in Python
    3. 2. Setting Content Type
    4. Example: Setting Content Type in a Message
    5. 3. Setting Content Encoding
    6. Example: Setting Content Encoding in a Message
    7. 4. Setting Message ID
    8. Example: Setting Message ID in Java
    9. 5. Setting Correlation ID
    10. Example: Setting Correlation ID in a Message
    11. 6. Setting Reply-To Queue
    12. Example: Setting Reply-To Queue in Message Properties
    13. 7. Setting Expiration TTL
    14. Example: Setting Message TTL in Queue Declaration
    15. Example: Setting Message TTL in Message Properties
    16. 8. Setting Timestamp
    17. Example: Setting Timestamp in RabbitMQ Message
    18. 9. Setting User ID
    19. Example: Setting User ID in a Message
    20. 10. Setting App ID
    21. Example: Setting App ID in a Message
    22. 11. Setting Message Type
    23. Example: Setting Message Type
    24. 12. Using Custom Headers
    25. Example: Setting Custom Headers in a Message

  11. Working with Message Serialization

    1. 1. Using JSON Format
    2. Example: Publishing a JSON Message
    3. Example: Consuming a JSON Message
    4. 2. Using Protocol Buffers
    5. Example: Defining a Protocol Buffer Schema
    6. Example: Publishing a Message with Protocol Buffer
    7. Example: Consuming a Message with Protocol Buffer
    8. Protocol Buffer Benefits
    9. 3. Using Avro Format
    10. Example: Publishing Avro Message in Java
    11. Example: Consuming Avro Message in Java
    12. 4. Using MessagePack
    13. Example: Publishing a Message with MessagePack
    14. Example: Consuming a Message with MessagePack
    15. 5. Using Plain Text
    16. Example: Sending Plain Text Message
    17. Example: Receiving Plain Text Message
    18. 6. Implementing Custom Serializers
    19. Example: Custom JSON Serializer Implementation
    20. Example: Registering Custom Serializer
    21. 7. Setting Content-Type Header
    22. Example: Setting Content-Type in a Message
    23. 8. Handling Schema Evolution
    24. Example: Versioned JSON Message
    25. Best Practices for Schema Evolution
    26. 9. Validating Message Format
    27. Example: Validating Message Format in Python
    28. 10. Choosing Serialization Format
    29. Example: JSON Serialization in RabbitMQ
    30. Summary of Format Considerations

  12. Consuming Messages

    1. 1. Creating Consumer
    2. Example: Creating a Basic Consumer
    3. 2. Setting Consumer Tag
    4. Example: Setting Consumer Tag
    5. 3. Using Auto-Ack Mode
    6. Example: Consuming with Auto-Ack
    7. 4. Using Manual Ack Mode
    8. Example: Setting Up Manual Ack Mode
    9. 5. Getting Single Message
    10. Example: Fetching a Single Message
    11. 6. Setting No-Local Flag
    12. Example: Using no-local Flag
    13. 7. Setting Exclusive Consumer
    14. Example: Setting an Exclusive Consumer
    15. 8. Using Consumer Priorities
    16. Example: Setting Consumer Priority
    17. 9. Implementing Consumer Callbacks
    18. Example: Basic Message Processing
    19. Example: Error Handling in Callbacks
    20. 10. Cancelling Consumer
    21. Example: Cancel Consumer
    22. 11. Handling Consumer Cancellation
    23. Example: Consumer Cancellation Handling
    24. 12. Monitoring Active Consumers
    25. Example: Get Active Consumers via Management Plugin
    26. Example: Consumer Details in Management UI

  13. Understanding Message Acknowledgments

    1. 1. Sending Basic Ack
    2. Example: Sending Basic Ack
    3. 2. Sending Basic Nack
    4. Example: Using basic.nack to requeue a message
    5. 3. Sending Basic Reject
    6. Example: Rejecting a Message
    7. 4. Using Multiple Ack
    8. Example: Acknowledging Multiple Messages
    9. 5. Requeuing Messages
    10. Example: Requeuing a Message
    11. 6. Understanding Unacked Messages
    12. Example: Tracking Unacked Messages
    13. 7. Understanding Redelivered Flag
    14. Example: Handling Redelivered Messages
    15. 8. Setting Ack Timeout
    16. Example: Configuring Ack Timeout
    17. 9. Handling Ack Failures
    18. Example: Consumer handles nack with retry logic
    19. Best Practices for Ack Failures
    20. 10. Recovering from Nack
    21. Example: Requeuing a Message
    22. 11. Using Manual Ack Best Practices
    23. 12. Monitoring Unacked Messages
    24. Example: Using RabbitMQ Management Plugin to View Unacked Messages
    25. Example: Setting Up a Consumer with Manual Acknowledgment

  14. Configuring Quality of Service

    1. 1. Setting Prefetch Count
    2. Example: Configuring Prefetch Count in JavaScript
    3. 2. Setting Prefetch Size
    4. Example: Setting Prefetch Size
    5. 3. Using Channel-Level QoS
    6. Example: Setting Channel-Level QoS
    7. 4. Using Global QoS
    8. Example: Setting Global QoS
    9. 5. Configuring Consumer Prefetch
    10. Example: Setting Prefetch Count
    11. 6. Understanding QoS Impact
    12. Example: Setting QoS for a Consumer
    13. QoS Impact Summary
    14. 7. Tuning Prefetch for Performance
    15. Example: Setting Prefetch Count
    16. 8. Using QoS with Auto-Ack
    17. Example: Setting QoS with Auto-Ack
    18. 9. Combining QoS with Priority
    19. Example: Setting QoS with Priority
    20. 10. Monitoring Prefetch Metrics
    21. Example: Setting Prefetch Limit

  15. Implementing Single Active Consumer

    1. 1. Enabling Single Active Consumer
    2. Example: Enabling SAC in a Queue
    3. 2. Understanding Consumer Failover
    4. Example: Consumer Failover Configuration
    5. Key Points for Failover
    6. 3. Using with Ordered Processing
    7. Example: Declaring a Queue with Single Active Consumer
    8. Key Points
    9. 4. Combining with Prefetch
    10. Example: Setting Prefetch Count
    11. 5. Monitoring Active Consumer
    12. Example: Consumer Metrics
    13. Key Monitoring Points
    14. 6. Handling Consumer Failures
    15. Example: Consumer Failure with Manual Acknowledgement
    16. Consumer Failure Handling Strategy
    17. 7. Understanding Limitations
    18. Key Limitations of Single Active Consumer Pattern
    19. 8. Using with Quorum Queues
    20. Example: Declaring a Quorum Queue with SAC

  16. Working with Message TTL

    1. 1. Setting Per-Message TTL
    2. Example: Setting TTL on a Message
    3. 2. Setting Per-Queue TTL
    4. Example: Declaring a Queue with Per-Queue TTL
    5. 3. Understanding TTL Priority
    6. Example: Setting TTL on a Queue
    7. 4. Setting Queue Expiration
    8. Example: Configure Queue with TTL
    9. 5. Using TTL with Dead Letter
    10. Example: Setting up TTL with DLX
    11. Key Points
    12. 6. Implementing Delayed Messages
    13. Example: Setting up a delayed queue
    14. 7. Handling TTL Edge Cases
    15. Example: Message with Zero TTL
    16. Handling TTL Edge Cases Summary
    17. 8. Monitoring Expired Messages
    18. Example: Configure TTL and Dead Letter Exchange
    19. Example: Check Queue TTL Configuration
    20. Example: Consume Expired Messages
    21. 9. Using TTL for Cache Invalidation
    22. Example: Setting up TTL with Dead Letter Exchange
    23. Example: Consuming Expired Messages
    24. Cache Invalidation Workflow
    25. 10. Optimizing TTL Performance
    26. Example: Setting TTL on Queue
    27. Example: Setting TTL on Message

  17. Working with Dead Letter Exchanges

    1. 1. Configuring DLX
    2. Example: Declaring a Queue with DLX
    3. 2. Setting Dead Letter Routing Key
    4. Example: Setting Dead Letter Routing Key
    5. 3. Understanding DLX Triggers
    6. Example: Message TTL Expiry
    7. Example: Rejection with Nack
    8. 4. Creating DLX Queue
    9. Example: Declaring DLX Queue with RabbitMQ Management UI
    10. 5. Preserving Message Headers
    11. Example: Configuring Dead Letter Headers
    12. 6. Analyzing Failed Messages
    13. Example: Configuring Dead Letter Exchange
    14. Workflow: Analyzing Failed Messages
    15. 7. Implementing Retry Logic
    16. Example: Retry Queue Configuration
    17. Example: Message Processing with Retry
    18. 8. Using DLX for Error Handling
    19. Example: Configuring DLX on a Queue
    20. Example: Error Handling with DLX
    21. 9. Preventing DLX Loops
    22. Example: Configuring Dead Letter Exchange with Loop Prevention
    23. Preventing DLX Loops - Best Practices
    24. 10. Monitoring DLX Activity
    25. Example: Using rabbitmq-diagnostics
    26. Example: Monitoring via Management Plugin UI

  18. Implementing Priority Queues

    1. 1. Declaring Priority Queue
    2. Example: Declare Priority Queue in RabbitMQ
    3. 2. Setting Message Priority
    4. Example: Publishing a High-Priority Message
    5. 3. Understanding Priority Limitations
    6. Key Considerations
    7. 4. Consuming by Priority
    8. Example: Consuming High-Priority Messages First
    9. 5. Using Priority with Prefetch
    10. Example: Setting Prefetch Count
    11. 6. Handling Priority Starvation
    12. Example: Configuring Priority Queue with Starvation Handling
    13. Starvation Handling Workflow
    14. Best Practices for Priority Queue Starvation
    15. 7. Combining Priority with TTL
    16. Example: Declaring a Priority Queue with TTL
    17. 8. Optimizing Priority Performance
    18. Example: Configuring Priority Queue with Optimized Settings
    19. Best Practices for Priority Queue Optimization
    20. Steps to Optimize Priority Queue Performance
    21. 9. Monitoring Priority Distribution
    22. Example: Checking Priority Queue Statistics
    23. Example: Using RabbitMQ Management Plugin
    24. 10. Using Priority for SLA
    25. Example: Publishing a High-Priority Message
    26. SLA Implementation Strategy

  19. Understanding Publisher Confirms

    1. 1. Enabling Confirm Mode
    2. Example: Enabling Confirm Mode
    3. 2. Handling Basic Ack
    4. Example: Handling Basic Ack in Java
    5. 3. Handling Basic Nack
    6. Example: Handling Nack in Publisher Confirms
    7. 4. Using Delivery Tags
    8. Example: Acknowledging Messages with Delivery Tags
    9. 5. Implementing Synchronous Confirms
    10. Example: Synchronous Confirm Implementation
    11. 6. Implementing Asynchronous Confirms
    12. Example: Basic Async Confirm Setup
    13. Example: Handling Multiple Confirms
    14. 7. Batching Confirms
    15. Example: Batching Publisher Confirms
    16. 8. Handling Confirm Timeouts
    17. Example: Setting Confirm Timeout
    18. 9. Using Confirms for Reliability
    19. Example: Publisher Confirms Setup
    20. Reliability Patterns with Publisher Confirms
    21. 10. Handling Nack Scenarios
    22. Example: Handling Nack in Java
    23. 11. Combining Confirms with Transactions
    24. Example: Publishing Messages with Confirms and Transactions
    25. 12. Monitoring Confirm Rate
    26. Example: Monitoring Confirm Rate via Management Plugin
    27. Example: Using RabbitMQ Metrics in Prometheus

  20. Implementing Transactions

    1. 1. Starting Transaction
    2. Example: Starting a Transaction
    3. 2. Committing Transaction
    4. Example: Committing a Transaction
    5. 3. Rolling Back Transaction
    6. Example: Rolling Back a Transaction
    7. 4. Understanding Transaction Scope
    8. Example: Transactional Publishing
    9. 5. Using Transactions with Publishes
    10. Example: Publishing within a Transaction
    11. 6. Using Transactions with Acks
    12. Example: Declaring a Transactional Channel with Acks
    13. Key Points
    14. 7. Handling Transaction Failures
    15. Example: Transaction Rollback on Failure
    16. 8. Avoiding Nested Transactions
    17. Example: Transaction State Management
    18. Best Practices for Transaction Management
    19. 9. Understanding Performance Impact
    20. Example: Transactional Publishing Overhead
    21. Performance Considerations
    22. 10. Comparing Transactions vs Confirms
    23. Transactions vs Confirms: Key Differences
    24. Example: Transactional Publishing
    25. Example: Confirm Mode Publishing

  21. Working with Quorum Queues

    1. 1. Declaring Quorum Queue
    2. Example: Declaring a Quorum Queue in RabbitMQ
    3. 2. Understanding Raft Consensus
    4. Example: Raft Election Process
    5. Key Points of Raft Consensus in Quorum Queues
    6. 3. Setting Quorum Size
    7. Example: Declaring a Quorum Queue with Custom Size
    8. 4. Understanding Replication
    9. Example: Queue Replication Configuration
    10. 5. Handling Leader Failover
    11. Example: Configuring Leader Failover
    12. 6. Using Poison Message Handling
    13. Example: Configuring Poison Message Handling
    14. Example: Dead Letter Exchange Setup
    15. 7. Setting Dead Letter Strategy
    16. Example: Configure Dead Letter Exchange
    17. Example: Set Message TTL and DLX
    18. 8. Configuring Memory Limit
    19. Example: Setting Memory Limit via RabbitMQ Configuration
    20. 9. Using Quorum Queue Length Limit
    21. Example: Setting Queue Length Limit
    22. 10. Understanding Performance Characteristics
    23. Example: Performance Testing Configuration
    24. 11. Monitoring Quorum Queue Metrics
    25. Example: Collecting Queue Metrics via RabbitMQ Management Plugin
    26. Example: Using Prometheus to Export Metrics
    27. 12. Migrating Classic to Quorum
    28. Migration Steps
    29. Example: Creating a Quorum Queue
    30. Classic vs Quorum Queue Behavior
    31. Migration Considerations

  22. Working with Stream Queues

    1. 1. Declaring Stream Queue
    2. Example: Declaring a Stream Queue with RabbitMQ Management UI
    3. Example: Declaring a Stream Queue with RabbitMQ CLI
    4. 2. Understanding Log-Based Storage
    5. Example: Log Segment Configuration
    6. 3. Setting Retention Policy
    7. Example: Configure Stream Queue Retention
    8. 4. Using Offset Tracking
    9. Example: Consuming from a specific offset
    10. 5. Implementing Stream Consumers
    11. Example: Basic Stream Consumer Implementation
    12. Example: Stream Consumer with Manual Offset
    13. 6. Publishing to Streams
    14. Example: Publishing to a Stream with AMQP
    15. 7. Using Stream Filtering
    16. Example: Filtering Messages by Content Type
    17. 8. Understanding Replication
    18. Example: Creating a Stream with Replication
    19. Replication Behavior
    20. 9. Using Streams for Event Sourcing
    21. Example: Basic Stream Configuration for Event Sourcing
    22. Event Sourcing vs Traditional Messaging
    23. Event Sourcing Workflow
    24. 10. Comparing Streams vs Queues
    25. When to Use Streams vs Queues
    26. 11. Configuring Stream Performance
    27. Example: Stream Performance Configuration
    28. 12. Monitoring Stream Metrics
    29. Example: Collecting Stream Metrics via Management Plugin
    30. Key Metrics for Stream Monitoring

  23. Understanding Queue Types Comparison

    1. 1. Comparing Classic vs Quorum Queues
    2. Example: Creating a Quorum Queue
    3. 2. Comparing Classic vs Stream Queues
    4. Example: Declaring a Classic Queue
    5. Example: Declaring a Stream Queue
    6. 3. Understanding Classic Queue Limitations
    7. 4. Understanding Quorum Queue Benefits
    8. Quorum Queues vs Classic Queues
    9. Example: Declaring a Quorum Queue
    10. 5. Understanding Stream Queue Benefits
    11. Stream Queues vs Traditional Queues
    12. Example: Declaring a Stream Queue
    13. 6. Choosing Queue Type
    14. Queue Type Comparison
    15. Example: Choosing Queue Type Based on Use Case
    16. Decision Guide
    17. 7. Understanding Migration Paths
    18. Migration Strategies Overview
    19. Migration Steps
    20. 8. Handling Mixed Queue Types
    21. Queue Type Comparison
    22. 9. Understanding Performance Trade-offs
    23. Queue Type Performance Characteristics
    24. Performance Optimization Steps
    25. 10. Using Lazy Queues
    26. Example: Declaring a Lazy Queue
    27. 11. Configuring Queue Mode Policy
    28. Example: Setting Queue Mode Policy via CLI
    29. Example: Setting Queue Mode Policy via Management API
    30. 12. Monitoring Queue Type Metrics
    31. Example: Queue Metrics Overview
    32. Monitoring Workflow
    33. Example: Using rabbitmqctl to Get Queue Stats

  24. Working with Classic Queue Mirroring

    1. 1. Understanding Classic Mirroring
    2. Example: Enabling Mirroring on a Queue
    3. Key Concepts of Classic Mirroring
    4. 2. Setting ha-mode
    5. Example: Setting ha-mode to 'all'
    6. Example: Setting ha-mode to 'exactly'
    7. Example: Setting ha-mode to 'nodes'
    8. 3. Configuring ha-params
    9. Example: Setting ha-params for queue mirroring
    10. 4. Setting ha-sync-mode
    11. Example: Setting ha-sync-mode via RabbitMQ Management UI
    12. Example: Setting ha-sync-mode via RabbitMQ Configuration File
    13. 5. Promoting Queue Master
    14. Example: Promoting a Queue Master
    15. 6. Using ha-promote-on-shutdown
    16. Example: Setting ha-promote-on-shutdown
    17. 7. Setting ha-promote-on-failure
    18. Example: Configuring ha-promote-on-failure
    19. 8. Monitoring Mirror Status
    20. Example: Check mirror status of a queue
    21. Example: Using RabbitMQ Management Plugin
    22. Monitoring Mirror Status Summary
    23. 9. Understanding Split-Brain Scenarios
    24. Example: Configuring Split-Brain Protection
    25. Key Considerations for Split-Brain Prevention
    26. 10. Migrating to Quorum Queues
    27. Example: Creating a Quorum Queue
    28. Classic Mirrored vs Quorum Queue

  25. Working with Policies

    1. 1. Creating Policy
    2. Example: Creating a Policy
    3. 2. Using Policy Pattern
    4. Example: Define a policy for message TTL
    5. 3. Setting Policy Priority
    6. Example: Setting Policy Priority
    7. 4. Setting HA Policy
    8. Example: Setting HA Policy
    9. 5. Setting Federation Policy
    10. Example: Setting Federation Policy
    11. 6. Setting TTL Policy
    12. Example: Set TTL Policy
    13. 7. Setting Max-Length Policy
    14. Example: Setting max-length policy via CLI
    15. Example: Setting max-length-bytes policy via CLI
    16. 8. Setting Queue Mode
    17. Example: Setting Queue Mode via Policy
    18. 9. Combining Multiple Definitions
    19. Example: Combining Policy Definitions
    20. 10. Understanding Policy Application
    21. Example: Applying a Policy to Queues
    22. 11. Listing Policies
    23. Example: List all policies
    24. Example: List policies with specific pattern
    25. 12. Clearing Policy
    26. Example: Clearing a Policy

  26. Working with Delayed Messages

    1. 1. Installing Delayed Message Plugin
    2. 2. Declaring Delayed Exchange
    3. Example: Declare Delayed Exchange Using RabbitMQ Management UI
    4. 3. Setting Delay Header
    5. Example: Setting Delay Header in Java
    6. 4. Understanding Delay Limitations
    7. Key Considerations for Delayed Messages
    8. 5. Using TTL + DLX Alternative
    9. Example: Setting up a Delayed Message Queue
    10. Summary of TTL + DLX Approach
    11. 6. Implementing Scheduled Messages
    12. Example: Publishing a Delayed Message
    13. Key Points for Scheduled Messages
    14. 7. Monitoring Delayed Messages
    15. Example: Delayed Message Counters
    16. Example: Using RabbitMQ Dashboard
    17. Monitoring Metrics Overview
    18. 8. Handling Delay Overflow
    19. Example: Configuring Delay Overflow Strategy
    20. Overflow Handling Strategies

  27. Working with Consistent Hash Exchange

    1. 1. Installing Consistent Hash Plugin
    2. 2. Declaring Consistent Hash Exchange
    3. Example: Declaring Consistent Hash Exchange in RabbitMQ
    4. 3. Setting Hash Header
    5. Example: Setting Hash Header
    6. 4. Using Routing Key Hash
    7. Example: Declaring a Consistent Hash Exchange
    8. Example: Publishing Messages with Hashed Routing Keys
    9. 5. Configuring Weight
    10. Example: Setting Queue Weight
    11. 6. Understanding Partitioning Behavior
    12. Example: Message Routing with Consistent Hash
    13. Key Concepts
    14. 7. Adding and Removing Queues
    15. Example: Adding a Queue to Consistent Hash Exchange
    16. Example: Removing a Queue from Consistent Hash Exchange
    17. 8. Monitoring Hash Distribution
    18. Example: Hash Distribution Metrics
    19. Monitoring Hash Distribution

  28. Implementing Work Queue Pattern

    1. 1. Creating Task Queue
    2. Example: Declaring a Task Queue in Python
    3. 2. Distributing Tasks
    4. Example: Publishing a Task
    5. Example: Consuming a Task
    6. 3. Using Multiple Workers
    7. Example: Setting up multiple workers with prefetch
    8. 4. Implementing Fair Dispatch
    9. Example: Setting up Fair Dispatch in RabbitMQ
    10. 5. Ensuring Message Durability
    11. Example: Declaring a Durable Queue
    12. Example: Publishing a Durable Message
    13. 6. Implementing Acknowledgments
    14. Example: Manual Acknowledgment in Consumer
    15. Example: Rejecting Messages with Nack
    16. Key Points for Acknowledgments
    17. 7. Handling Worker Failures
    18. Example: Worker Failure Handling
    19. Failure Handling Strategies
    20. 8. Using Message Priority
    21. Example: Setting Message Priority
    22. 9. Implementing Task Timeout
    23. Example: Configuring Task Timeout
    24. 10. Monitoring Queue Depth
    25. Example: Using RabbitMQ Management Plugin to Monitor Queue Depth
    26. Example: Programmatically Monitoring Queue Depth with Python

  29. Implementing Publish-Subscribe Pattern

    1. 1. Creating Fanout Exchange
    2. Example: Creating Fanout Exchange in RabbitMQ
    3. 2. Creating Temporary Queues
    4. Example: Declaring a Temporary Queue in Java
    5. 3. Binding Subscriber Queues
    6. Example: Binding Queues to Exchange
    7. 4. Publishing to All Subscribers
    8. Example: Publishing a Message to All Subscribers
    9. Key Points
    10. 5. Implementing Durable Subscriptions
    11. Example: Setting up a durable subscription
    12. 6. Handling Subscriber Failures
    13. Example: Message Requeue on NACK
    14. Example: Dead Letter Exchange (DLX) Configuration
    15. Key Recovery Strategies
    16. 7. Using Multiple Publishers
    17. Example: Publishing to Exchange
    18. 8. Implementing Topic-Based Pub/Sub
    19. Example: Publishing a Message with Topic Routing
    20. Example: Consuming Messages with Topic Binding
    21. Topic Exchange Patterns
    22. 9. Filtering Messages
    23. Example: Using Header Filters
    24. 10. Monitoring Subscriber Count
    25. Example: Using RabbitMQ Management Plugin

  30. Implementing Routing Pattern

    1. 1. Creating Direct Exchange
    2. Example: Creating a Direct Exchange in RabbitMQ
    3. 2. Using Routing Keys
    4. Example: Publishing a Message with Routing Key
    5. Example: Binding Queue with Routing Key Pattern
    6. 3. Binding with Multiple Keys
    7. Example: Binding Multiple Keys to a Queue
    8. 4. Implementing Multi-Criteria Routing
    9. Example: Direct Exchange with Multiple Bindings
    10. Example: Topic Exchange for Flexible Routing
    11. Multi-Criteria Routing Summary
    12. 5. Using Topic Exchange
    13. Example: Publishing to Topic Exchange
    14. Example: Binding with Wildcards
    15. Topic Exchange Rules
    16. 6. Understanding Wildcard Routing
    17. Example: Setting up wildcard exchange
    18. Example: Publishing messages with wildcard matching
    19. 7. Combining Routing Patterns
    20. Routing Pattern Combinations
    21. Example: Combining Direct and Topic Exchanges
    22. Example: Fanout and Headers Exchange Combination
    23. 8. Implementing Conditional Routing
    24. Example: Setting up a Headers Exchange with Conditional Routing
    25. Example: Publishing a Message with Headers for Conditional Routing
    26. 9. Using Default Exchange
    27. Example: Publishing to Default Exchange
    28. 10. Monitoring Routing Metrics
    29. Example: Collecting Metrics via Management Plugin
    30. Example: Using Prometheus with RabbitMQ Exporter

  31. Implementing Headers-Based Routing

    1. 1. Creating Headers Exchange
    2. Example: Declare Headers Exchange
    3. 2. Setting x-match Argument
    4. Example: Using x-match with 'all'
    5. Example: Using x-match with 'any'
    6. 3. Binding with Header Conditions
    7. Example: Binding Headers to a Queue
    8. 4. Using Multiple Header Criteria
    9. Example: Routing with Multiple Headers
    10. Header Matching Strategies
    11. 5. Combining Headers with Routing Keys
    12. Example: Headers and Routing Key Binding
    13. Key Points
    14. 6. Understanding Match-All vs Match-Any
    15. Example: Match-All Headers
    16. Example: Match-Any Headers
    17. 7. Setting Optional Headers
    18. Example: Setting Optional Headers in a Message
    19. 8. Implementing Content-Based Routing
    20. Example: Basic Content-Based Routing Setup
    21. 9. Handling Missing Headers
    22. Example: Using x-match with missing headers
    23. 10. Monitoring Headers Exchange Performance
    24. Example: Basic Headers Exchange Monitoring Setup
    25. Key Metrics to Monitor

  32. Implementing RPC Pattern

    1. 1. Creating Reply Queue
    2. Example: Setting up reply queue in RabbitMQ
    3. 2. Setting Correlation ID
    4. Example: Setting Correlation ID in RPC Request
    5. 3. Using Reply-To Property
    6. Example: Setting Reply-To Property
    7. 4. Implementing RPC Server
    8. Example: Basic RPC Server Implementation
    9. RPC Server Workflow
    10. 5. Implementing RPC Client
    11. Example: Basic RPC Client Implementation
    12. 6. Using Direct Reply-To
    13. Example: Publishing RPC Request with Direct Reply-To
    14. 7. Handling RPC Timeouts
    15. Example: Configuring RPC Timeout
    16. 8. Implementing Async RPC
    17. Example: Client-side Async RPC
    18. Example: Server-side Async RPC
    19. 9. Handling RPC Failures
    20. Example: Client-side timeout handling
    21. Example: Server-side error handling
    22. 10. Monitoring RPC Performance
    23. Example: RPC Server Metrics
    24. Example: RPC Client Metrics
    25. Key Performance Indicators (KPIs)

  33. Implementing Retry Patterns

    1. 1. Using Dead Letter Exchange
    2. Example: Setting up a Dead Letter Exchange
    3. 2. Implementing Exponential Backoff
    4. Example: Retry Configuration with Exponential Backoff
    5. 3. Setting Retry Limits
    6. Example: Configuring Retry Limits in RabbitMQ
    7. 4. Tracking Retry Count
    8. Example: Application-level Retry Counter
    9. 5. Using Delayed Message Exchange
    10. Example: Publishing a Delayed Message
    11. Key Features of Delayed Message Exchange
    12. 6. Creating Retry Queue Chain
    13. Example: Retry Queue Chain Setup
    14. Retry Queue Chain Summary
    15. 7. Implementing Circuit Breaker
    16. Example: Configuring Circuit Breaker in RabbitMQ
    17. Circuit Breaker States
    18. 8. Moving to Error Queue
    19. Example: Configure Dead Letter Exchange
    20. Key Points
    21. 9. Alerting on Retry Failures
    22. Example: Configuring Dead Letter Exchange for Retry Failures
    23. Example: Using RabbitMQ Management Plugin for Alerting
    24. Alerting Configuration Summary
    25. 10. Testing Retry Behavior
    26. Example: Testing Retry with RabbitMQ and Spring AMQP
    27. Testing Retry Behavior Summary

  34. Implementing Idempotency

    1. 1. Using Message ID
    2. Example: Message ID in Producer
    3. Example: Message ID in Consumer
    4. 2. Using Correlation ID
    5. Example: Setting Correlation ID in Publisher
    6. Example: Consuming with Correlation ID Check
    7. 3. Implementing Deduplication Logic
    8. Example: Basic Deduplication with Message ID
    9. 4. Storing Processed Message IDs
    10. Example: Redis-based ID Storage
    11. 5. Setting Deduplication Window
    12. Example: Configuring Deduplication Window
    13. 6. Handling Redelivered Messages
    14. Example: Check if message is redelivered
    15. 7. Using Single Active Consumer
    16. Example: Declaring a Queue with Single Active Consumer
    17. Key Points
    18. 8. Implementing Exactly-Once Semantics
    19. Example: Message ID Usage
    20. Example: Idempotent Consumer
    21. Key Points for Exactly-Once Semantics
    22. 9. Combining Acks with Idempotency
    23. Example: Acknowledging Messages with Idempotent Processing
    24. 10. Testing Idempotent Behavior
    25. Example: Testing Idempotent Message Processing
    26. Idempotency Testing Best Practices

  35. Implementing Message Compression

    1. 1. Compressing Message Payload
    2. Example: Setting Compression in RabbitMQ Configuration
    3. Example: Using Compression in Producer
    4. 2. Using Content-Encoding Header
    5. Example: Setting Content-Encoding Header
    6. 3. Implementing Compression Libraries
    7. Example: Using LZ4 with RabbitMQ
    8. 4. Setting Compression Threshold
    9. Example: Configuring Compression Threshold
    10. 5. Decompressing on Consumer
    11. Example: Consumer decompressing gzip-encoded message
    12. 6. Using Compression with Large Messages
    13. Example: Configuring Compression for Large Messages
    14. Example: Message Size Before and After Compression
    15. 7. Understanding Performance Trade-offs
    16. Compression Algorithms Comparison
    17. When to Use Compression
    18. 8. Monitoring Compression Ratio
    19. Example: Calculating Compression Ratio
    20. Key Metrics for Compression Monitoring
    21. 9. Handling Compression Errors
    22. Example: Error Handling in Consumer
    23. 10. Benchmarking Compression Impact
    24. Example: Measuring Compression Impact

  36. Implementing Rate Limiting

    1. 1. Using Prefetch Count
    2. Example: Setting Prefetch Count in a Consumer
    3. 2. Implementing Producer Rate Limiting
    4. Example: Producer Rate Limiting Configuration
    5. 3. Using Queue Length Limits
    6. Example: Configuring Queue with Max Length
    7. 4. Configuring Memory Alarms
    8. Example: Setting Memory Alarm in rabbitmq.conf
    9. 5. Implementing Token Bucket
    10. Example: Token Bucket Implementation in Python
    11. 6. Using Credit Flow
    12. Example: Configuring Credit Flow
    13. 7. Setting Connection Limits
    14. Example: Configuring Connection Limits via rabbitmq.conf
    15. 8. Monitoring Rate Metrics
    16. Example: Rate Limiting Metrics in RabbitMQ
    17. Rate Limiting Metrics Overview

  37. Implementing Authentication

    1. 1. Using Internal Authentication
    2. Example: Configure Internal Authentication
    3. 2. Configuring LDAP Authentication
    4. Example: Basic LDAP Authentication Configuration
    5. Example: LDAP Authentication with SSL
    6. 3. Configuring HTTP Authentication
    7. Example: HTTP Authentication Configuration
    8. 4. Using Certificate Authentication
    9. Example: Client Configuration with Certificates
    10. Steps to Enable Certificate Authentication
    11. 5. Implementing OAuth 2.0
    12. Example: Middleware Integration
    13. 6. Configuring Multiple Backends
    14. Example: Multiple Backend Configuration
    15. Summary of Backend Priorities
    16. 7. Setting Authentication Cache
    17. Example: Enabling Memory-Based Authentication Cache
    18. 8. Implementing SSO
    19. Example: LDAP Configuration
    20. SSO Implementation Summary
    21. 9. Handling Authentication Failures
    22. Example: Error Handling in RabbitMQ Consumer
    23. 10. Monitoring Authentication Events
    24. Example: Authentication Event Log Entry
    25. Monitoring Authentication Events

  38. Implementing TLS/SSL Security

    1. 1. Generating Certificates
    2. Example: Generate CA Certificate
    3. Example: Generate Server Certificate
    4. 2. Configuring TLS Listeners
    5. Example: Basic TLS listener configuration in rabbitmq.conf
    6. 3. Setting Certificate Paths
    7. Example: RabbitMQ Configuration with TLS
    8. 4. Enforcing Client Certificates
    9. Example: Enforcing Client Certificates in RabbitMQ Configuration
    10. 5. Setting TLS Versions
    11. Example: Configuring TLS Versions in RabbitMQ
    12. 6. Configuring Cipher Suites
    13. Example: RabbitMQ Configuration for Cipher Suites
    14. 7. Using SNI
    15. Example: Configuring SNI in RabbitMQ
    16. 8. Enabling OCSP Stapling
    17. Example: Enabling OCSP Stapling in RabbitMQ Configuration
    18. 9. Rotating Certificates
    19. Example: Updating SSL Configuration for Certificate Rotation
    20. Certificate Rotation Best Practices
    21. 10. Testing TLS Connection
    22. Example: Test TLS Connection with openssl s_client
    23. Example: Verify Certificate Details
    24. 11. Monitoring TLS Metrics
    25. Example: TLS Metrics Configuration
    26. 12. Troubleshooting TLS Issues
    27. Example: Common TLS Error Messages
    28. Workflow: Diagnosing TLS Connection Failures
    29. Summary: Common TLS Troubleshooting Steps

  39. Setting Up Clustering

    1. 1. Understanding Cluster Requirements
    2. Example: Cluster Configuration
    3. 2. Understanding Node Types
    4. 3. Joining Cluster Node
    5. Example: Joining Cluster Node
    6. 4. Verifying Cluster Status
    7. Example: Check cluster status via CLI
    8. Example: Check cluster status via Management Plugin
    9. Cluster Status Verification Steps
    10. 5. Using Cluster Names
    11. Example: Setting Cluster Name
    12. 6. Removing Cluster Node
    13. Workflow
    14. Example: Removing a Node from the Cluster
    15. 7. Resetting Node
    16. Example: Resetting a Node
    17. 8. Handling Network Partitions
    18. Example: Configuring Partition Handling Policy
    19. Partition Handling Strategies
    20. Steps to Handle Network Partitions
    21. 9. Configuring Partition Handling
    22. Example: Configuring Partition Handling
    23. Partition Handling Strategies
    24. 10. Load Balancing Connections
    25. Example: Configuring Load Balancing Strategy
    26. 11. Understanding Cluster Limitations
    27. Key Considerations for Cluster Limitations
    28. 12. Monitoring Cluster Health
    29. Example: Check cluster status via CLI
    30. Example: View node statistics
    31. Monitoring Tools Comparison

  40. Implementing Federation

    1. 1. Understanding Federation Use Cases
    2. Common Federation Scenarios
    3. 2. Enabling Federation Plugin
    4. Example: Enable Federation Plugins
    5. 3. Defining Upstream
    6. Example: Defining an upstream
    7. Example: Defining an upstream set
    8. 4. Setting Upstream Parameters
    9. Example: Federation Upstream Configuration
    10. 5. Applying Federation Policy
    11. Example: Define federation policy
    12. Policy Application Steps
    13. 6. Using Exchange Federation
    14. Example: Configuring Exchange Federation
    15. 7. Using Queue Federation
    16. Example: Configuring Queue Federation
    17. 8. Configuring Federation Links
    18. Example: Federation Link Configuration
    19. 9. Setting Max-Hops
    20. Example: Configuring max-hops in rabbitmq.conf
    21. 10. Understanding Federation Topology
    22. Federation vs. Mirroring
    23. Example: Federated Exchange Configuration
    24. Topology Components
    25. Setting Up Federation Topology
    26. 11. Monitoring Federation Status
    27. Example: Federation Status Check
    28. Example: Federation Health Check
    29. 12. Troubleshooting Federation Issues
    30. Example: Check federation link status

  41. Implementing Shovel

    1. 1. Understanding Shovel Use Cases
    2. Shovel Use Cases
    3. 2. Enabling Shovel Plugin
    4. Example: Enable Shovel Plugins
    5. 3. Configuring Static Shovel
    6. Example: Static Shovel Configuration
    7. 4. Configuring Dynamic Shovel
    8. Example: Declaring a Dynamic Shovel
    9. 5. Setting Source Configuration
    10. Example: Source Configuration
    11. 6. Setting Destination Configuration
    12. Example: Destination Configuration
    13. 7. Using Shovel Acknowledgments
    14. Example: Configuring Shovel Acknowledgments
    15. 8. Setting Reconnect Delay
    16. Example: Configuring Reconnect Delay in Shovel
    17. 9. Using Shovel for Migration
    18. Example: Basic Migration Configuration
    19. Migration Strategy Summary
    20. 10. Combining Shovel with Federation
    21. Example: Configuring Federation and Shovel Together
    22. 11. Monitoring Shovel Status
    23. Example: Check Shovel Status via CLI
    24. Example: Query Shovel Metrics via Management API
    25. 12. Troubleshooting Shovel Issues
    26. Common Shovel Problems and Solutions
    27. Example: Diagnosing Shovel Configuration Errors
    28. Shovel Troubleshooting Workflow

  42. Managing Plugins

    1. 1. Listing Available Plugins
    2. Example: Listing Plugins
    3. Example: Output Format
    4. 2. Enabling Plugin
    5. Example: Enabling a Plugin
    6. 3. Disabling Plugin
    7. Example: Disabling a Plugin
    8. 4. Understanding Plugin Dependencies
    9. Example: Plugin app.src dependency declaration
    10. Dependency Resolution Process
    11. 5. Using Management Plugin
    12. Example: Enabling Management Plugin
    13. Example: Accessing Management UI
    14. 6. Using Federation Plugin
    15. Example: Configuring Federation Exchange
    16. Example: Federating a Queue
    17. 7. Using Shovel Plugin
    18. Example: Configuring a Shovel
    19. 8. Using Delayed Message Plugin
    20. Example: Declaring a Delayed Exchange
    21. Example: Publishing a Delayed Message
    22. Key Features of Delayed Message Plugin
    23. 9. Using Consistent Hash Exchange
    24. Example: Declaring a Consistent Hash Exchange
    25. Example: Publishing Messages to Consistent Hash Exchange
    26. 10. Using Top Plugin
    27. Example: Running rabbitmq-top
    28. 11. Using Tracing Plugin
    29. Example: Enable Tracing Plugin
    30. Example: Configure Tracing Output
    31. 12. Using Recent History Exchange
    32. Example: Configuring Recent History Exchange
    33. Example: Using Recent History Exchange in a Consumer

  43. Using Management UI

    1. 1. Accessing Web Interface
    2. Example: Enabling Management Plugin
    3. 2. Navigating Overview Tab
    4. Example: Viewing Queue Details
    5. 3. Managing Connections
    6. Example: Viewing Connection Details
    7. Example: Closing a Connection
    8. 4. Managing Channels
    9. Example: Creating a Channel
    10. Workflow: Managing Channels via Management UI
    11. 5. Managing Exchanges
    12. Example: Create a Direct Exchange
    13. Example: Bind Exchange to Queue
    14. 6. Managing Queues
    15. Example: Create a durable queue with TTL
    16. Example: Delete a queue
    17. 7. Viewing Bindings
    18. Example: Binding a Queue to an Exchange
    19. 8. Publishing Test Messages
    20. Example: Publish a test message via Management UI
    21. 9. Consuming Test Messages
    22. Example: Consume a test message from a queue
    23. 10. Monitoring Metrics
    24. Example: Viewing Metrics in Management UI
    25. 11. Managing Users and vhosts
    26. Example: Creating a New User
    27. Example: Creating a New Virtual Host
    28. Example: Setting Permissions for a User in a vhost
    29. 12. Importing/Exporting Definitions
    30. Example: Exporting Definitions
    31. Example: Importing Definitions

  44. Using Management CLI

    1. 1. Using rabbitmqctl
    2. Example: Listing Queues with Details
    3. Example: Listing Users and Their Permissions
    4. 2. Listing Queues
    5. Example: List all queues on a RabbitMQ instance
    6. Example: List queues with specific name pattern
    7. Example: List queues with detailed information
    8. 3. Listing Exchanges
    9. Example: Listing Exchanges via CLI
    10. Example: Listing Exchanges with Details
    11. 4. Listing Bindings
    12. Example: Listing bindings using CLI
    13. Example: Listing bindings with specific source
    14. Example: Listing bindings with specific destination
    15. 5. Listing Connections
    16. 6. Listing Channels
    17. Example: Listing Channels
    18. Example: Listing Channels in Specific Virtual Host
    19. 7. Listing Consumers
    20. Example: Listing Consumers
    21. 8. Using rabbitmqadmin
    22. Example: Listing Queues with Details
    23. Example: Creating a Queue with Arguments
    24. 9. Declaring Resources
    25. Example: Declaring an Exchange
    26. Example: Declaring a Queue
    27. Example: Binding a Queue to an Exchange
    28. 10. Purging and Deleting
    29. Example: Purge a Queue
    30. Example: Delete a Queue
    31. 11. Exporting Definitions
    32. Example: Exporting Definitions
    33. 12. Importing Definitions
    34. Example: Importing Definitions from a File
    35. Importing Definitions - Summary

  45. Configuring Logging

    1. 1. Setting Log Level
    2. Example: Configuring Log Level
    3. 2. Configuring Log File
    4. Example: Log File Configuration
    5. 3. Using JSON Logging
    6. Example: Enabling JSON Logging
    7. 4. Filtering Log Categories
    8. Example: Configuring Log Levels in rabbitmq.conf
    9. 5. Enabling Connection Logging
    10. Example: Enabling Connection Logging
    11. 6. Enabling Channel Logging
    12. Example: Enabling Channel Logging in RabbitMQ Configuration
    13. 7. Logging AMQP Commands
    14. Example: Enabling AMQP Command Logging
    15. 8. Using Syslog
    16. Example: Syslog Configuration in rabbitmq.conf
    17. 9. Rotating Log Files
    18. Example: Configuring Log Rotation in rabbitmq.conf
    19. 10. Parsing Log Patterns
    20. Example: Log Pattern Matching in Configuration
    21. Key Points for Log Parsing
    22. 11. Integrating with Log Aggregators
    23. Example: Configuring RabbitMQ to Send Logs to a Centralized Service
    24. Comparison: Log Aggregator Integration Options
    25. 12. Troubleshooting via Logs
    26. Example: Setting Log Level in rabbitmq.conf
    27. Common Log Analysis Patterns
    28. Log File vs Console Output

  46. Monitoring and Observability

    1. 1. Using Management API
    2. Example: Fetching Queue Details
    3. Example: Getting Node Statistics
    4. Common Management API Use Cases
    5. 2. Monitoring Queue Metrics
    6. Example: Fetching Queue Metrics via RabbitMQ Management API
    7. Example: Sample Response from Management API
    8. 3. Monitoring Connection Metrics
    9. Example: Fetching Connection Metrics via RabbitMQ Management API
    10. Example: Parsing Connection Metrics in JavaScript
    11. 4. Monitoring Node Metrics
    12. Example: Fetching Node Metrics via Management API
    13. Example: Monitoring CPU Usage with Prometheus
    14. 5. Monitoring Channel Metrics
    15. Example: Publishing a message and monitoring metrics
    16. 6. Collecting Prometheus Metrics
    17. Example: Enable Prometheus in RabbitMQ
    18. Example: Prometheus scrape configuration
    19. Key Metrics Exposed by RabbitMQ
    20. 7. Setting Alarms
    21. Example: Configure queue length alarm via RabbitMQ Management UI
    22. 8. Using Health Checks
    23. Example: RabbitMQ Health Check Endpoint
    24. Example: Kubernetes Liveness Probe Configuration
    25. 9. Enabling Event Logging
    26. Example: Enable Console Logging
    27. Example: Set Log File Path
    28. 10. Using Tracing
    29. Example: Setting up OpenTelemetry for RabbitMQ
    30. Tracing Configuration Options
    31. 11. Integrating with Grafana
    32. Example: Setting up RabbitMQ Grafana Dashboard
    33. 12. Setting Up Alerting
    34. Example: Basic RabbitMQ Alerting Configuration
    35. Example: Using Management API to Set Alert Thresholds

  47. Handling Flow Control

    1. 1. Understanding Memory Alarms
    2. Example: Configuring Memory Alarms
    3. 2. Understanding Disk Alarms
    4. Example: Configuring Disk Alarm Limits
    5. Key Points
    6. 3. Setting Memory Thresholds
    7. Example: Configuring Memory Thresholds
    8. 4. Setting Disk Thresholds
    9. Example: Configuring Disk Free Limit
    10. 5. Handling Blocked Connections
    11. Example: Detecting and Responding to Blocked Connections
    12. Best Practices for Blocked Connections
    13. 6. Monitoring Flow Control State
    14. Example: Checking Flow Control Status
    15. 7. Recovering from Alarms
    16. Example: Basic Alarm Recovery Configuration
    17. Recovery Strategy Options
    18. 8. Configuring Paging
    19. Example: RabbitMQ Configuration for Paging
    20. 9. Using Queue Length Limits
    21. Example: Declaring a Queue with Length Limit
    22. 10. Implementing Backpressure
    23. Example: Configuring RabbitMQ Flow Control
    24. Example: Handling Flow Control in Publisher
    25. 11. Tuning Memory Management
    26. Example: Setting Memory Limits in rabbitmq.conf
    27. 12. Understanding Flow Control Impact
    28. Example: Producer Backpressure Handling
    29. Key Considerations for Flow Control Impact

  48. Optimizing Performance

    1. 1. Tuning Prefetch Count
    2. Example: Setting Prefetch Count
    3. 2. Batching Operations
    4. Example: Publishing Batches of Messages
    5. Example: Acknowledging Batches of Messages
    6. 3. Using Connection Pooling
    7. Example: Configuring Connection Pooling in Java
    8. 4. Optimizing Message Size
    9. Example: Setting message size limit in RabbitMQ configuration
    10. Best Practices for Message Size Optimization
    11. 5. Using Lazy Queues
    12. Example: Declaring a Lazy Queue
    13. 6. Setting Queue Length Limits
    14. Example: Configuring Queue Length Limits
    15. 7. Using Persistent vs Transient
    16. Example: Setting Delivery Mode
    17. Comparison: Persistent vs Transient Messages
    18. 8. Optimizing Disk I/O
    19. Example: Configuring disk free limit
    20. Key Tips for Disk I/O Optimization
    21. 9. Optimizing Erlang VM
    22. Example: Setting Erlang VM Parameters in rabbitmq.conf
    23. 10. Using Flow Control
    24. Example: Enabling Flow Control
    25. 11. Monitoring Resource Usage
    26. Example: Monitoring Memory Usage via CLI
    27. Example: Setting Up Prometheus Exporter
    28. 12. Benchmarking Performance
    29. Example: Running a basic performance test
    30. Key Metrics to Monitor

  49. Handling Errors and Failures

    1. 1. Handling Connection Errors
    2. Example: Reconnecting on Connection Failure
    3. 2. Handling Channel Errors
    4. Example: Channel Error Handler
    5. 3. Recovering from Publish Failures
    6. Example: Retry Logic with Exponential Backoff
    7. 4. Handling Consumer Errors
    8. Example: Consumer Error Handling with Retry Logic
    9. 5. Implementing Retry Logic
    10. Example: Retry Configuration in RabbitMQ
    11. Example: Exponential Backoff Retry
    12. 6. Using Circuit Breaker Pattern
    13. Example: Basic Circuit Breaker Implementation
    14. State Transitions
    15. 7. Using DLX for Failed Messages
    16. Example: Declaring a Queue with DLX
    17. Example: Rejecting a Message to Trigger DLX
    18. 8. Implementing Poison Message Detection
    19. Example: Basic Poison Message Handling Setup
    20. Example: Consuming Poison Messages
    21. Key Poison Message Handling Concepts
    22. 9. Handling Split-Brain Scenarios
    23. Example: Isolating a Partition
    24. Example: Merging Partitions
    25. Split-Brain Recovery Strategies
    26. 10. Implementing Graceful Degradation
    27. Example: Basic Consumer Error Handling
    28. Example: Dead Letter Exchange Configuration
    29. Graceful Degradation Strategies
    30. 11. Logging Error Details
    31. Example: Logging Error in RabbitMQ Consumer
    32. 12. Alerting on Critical Errors
    33. Example: Configuring Alerting for Critical Errors

  50. Debugging and Troubleshooting

    1. 1. Using rabbitmqctl Commands
    2. Example: Check queue details
    3. Example: List all exchanges with types
    4. 2. Enabling AMQP Traces
    5. Example: Enable AMQP Traces in RabbitMQ
    6. 3. Using Firehose
    7. Example: Enabling Firehose via Management UI
    8. Example: Firehose Output Message Format
    9. 4. Analyzing Queue Backlogs
    10. Example: Check queue backlog using RabbitMQ Management UI
    11. Example: Monitor queue length via CLI
    12. 5. Investigating Memory Issues
    13. Example: Setting Memory Limits
    14. Example: Monitoring Memory Usage
    15. 6. Debugging Consumer Issues
    16. Example: Consumer Acknowledgment
    17. 7. Checking Network Connectivity
    18. Example: Test RabbitMQ Port Connectivity
    19. Example: Test Management Plugin Port
    20. Workflow: Troubleshooting Network Issues
    21. 8. Analyzing Logs
    22. Example: Log Configuration in rabbitmq.conf
    23. Example: Using rabbitmqctl to view logs
    24. Log Analysis Best Practices
    25. 9. Using Management API
    26. Example: Fetching Queue Details
    27. Example: Listing All Queues
    28. Example: Deleting a Queue via API
    29. 10. Inspecting Message Content
    30. Example: Fetching Message Content via Management Plugin
    31. Example: Inspecting Message Headers Programmatically (JavaScript)
    32. 11. Testing with PerfTest
    33. Example: Running PerfTest
    34. 12. Resolving Common Issues
    35. Common RabbitMQ Issues and Solutions
    36. Example: Check Queue Status
    37. Example: Set Message TTL Policy

  51. Implementing Backup and Recovery

    1. 1. Exporting Definitions
    2. Example: Exporting Definitions Using rabbitmqctl
    3. Example: Exporting Definitions Using rabbitmqadmin
    4. 2. Using Definitions File
    5. Example: Exporting Definitions
    6. Example: Importing Definitions
    7. 3. Importing Definitions
    8. Example: Importing Definitions
    9. 4. Backing Up Configuration
    10. Example: Exporting All Definitions
    11. 5. Backing Up Message Data
    12. Example: Using RabbitMQ Management Plugin to Export Definitions
    13. Example: Using rabbitmq-backup Tool to Backup Messages
    14. 6. Backing Up Erlang Cookie
    15. Example: Locate and Backup Erlang Cookie
    16. 7. Implementing Automated Backups
    17. Example: RabbitMQ Backup Script
    18. Backup Strategy Summary
    19. Automated Backup Workflow
    20. 8. Using Shovel for Data Migration
    21. Example: Configuring a Shovel
    22. Shovel Configuration Summary
    23. 9. Testing Restore Procedures
    24. Example: Basic Restore Test Script
    25. Restore Test Checklist
    26. 10. Replicating to Secondary Cluster
    27. Example: Setting up replication
    28. 11. Handling Schema Upgrades
    29. Example: Schema Upgrade Script
    30. 12. Documenting Recovery Procedures
    31. Example: Recovery Procedure Documentation Template

  52. Deploying in Containers

    1. 1. Using Official Docker Image
    2. Example: Run RabbitMQ with Docker
    3. 2. Configuring via Environment Variables
    4. Example: Setting up RabbitMQ with Environment Variables
    5. 3. Mounting Configuration Files
    6. Example: Mounting RabbitMQ Configuration
    7. 4. Setting Resource Limits
    8. Example: Docker Compose with Resource Limits
    9. 5. Deploying on Kubernetes
    10. Example: RabbitMQ Deployment in Kubernetes
    11. Example: RabbitMQ Service Configuration
    12. Key Considerations for Kubernetes Deployment
    13. 6. Using Helm Charts
    14. Example: Deploying RabbitMQ with Helm
    15. 7. Configuring Cluster Operator
    16. Example: Basic RabbitMQ Cluster Configuration
    17. Configuration Summary
    18. 8. Implementing Persistent Storage
    19. Example: Docker Compose with Persistent Storage
    20. 9. Configuring Health Probes
    21. Example: Kubernetes Deployment with Health Probes
    22. 10. Managing Secrets
    23. Example: Environment-based secret injection
    24. Best Practices for Secret Management
    25. 11. Setting Up Auto-Scaling
    26. Example: RabbitMQ Auto-Scaling Configuration
    27. Workflow: Configuring Auto-Scaling for RabbitMQ
    28. 12. Monitoring Container Metrics
    29. Example: RabbitMQ Container Metrics
    30. Example: Prometheus Metrics Endpoint

  53. Integrating with Client Libraries

    1. 1. Using Official Java Client
    2. Example: Basic Connection and Queue Declaration
    3. Example: Publishing a Message
    4. Example: Consuming a Message
    5. 2. Using Official .NET Client
    6. 3. Using Python Pika Library
    7. Example: Basic RabbitMQ Publisher with Pika
    8. Example: Basic RabbitMQ Consumer with Pika
    9. 4. Using Node.js amqplib
    10. Example: Basic Connection and Queue Declaration
    11. Example: Publishing and Consuming Messages
    12. Key Concepts
    13. 5. Using Go amqp091-go Library
    14. Example: Connecting to RabbitMQ with amqp091-go
    15. 6. Using Spring AMQP
    16. Example: Basic RabbitTemplate Configuration
    17. Example: Sending a Message
    18. Example: Receiving a Message
    19. 7. Configuring Client Timeouts
    20. Example: Setting Connection Timeouts in Java Client
    21. 8. Implementing Client-Side Reconnection
    22. Example: Basic Reconnection Logic
    23. 9. Handling Client Errors
    24. Example: Error Handling in RabbitMQ Client
    25. 10. Using Client Metrics
    26. Example: Configuring client metrics with RabbitMQ
    27. 11. Testing Client Integration
    28. Example: Basic Integration Test
    29. Testing Workflow
    30. 12. Implementing Connection Factories
    31. Example: Basic Connection Factory Setup