Distributed Systems with Python and RabbitMQ

Designing Reliable, Scalable Messaging Architectures for Production

Chapter 1: Why Distributed Systems Matter

1. The Inevitability of Distribution
2. What Goes Wrong (and Often Does)
3. The Cost of Getting It Right
4. How This Book Is Structured

Chapter 2: Foundations of Distributed Systems

1. The CAP Theorem (and What It Really Means)
2. Consistency Models from Strong to Eventual
3. Fault Tolerance and Failure Modes
4. Reliability, Availability, Durability
5. Idempotency as a Design Principle

Chapter 3: Messaging and Communication Patterns

1. Synchronous vs Asynchronous Communication
2. Point-to-Point and Queue-Based Messaging
3. Publish/Subscribe and Event Streaming
4. Request/Reply Patterns
5. Event-Driven Architecture Fundamentals

Chapter 4: RabbitMQ Architecture and Core Concepts

1. Installing and Configuring RabbitMQ
2. Nodes, Clusters, and Topology
3. Virtual Hosts and Namespaces
4. Exchanges and Their Types
5. Queues, Bindings, and Routing Keys
6. The Message Lifecycle

Chapter 5: Python Clients and Connection Management

1. Choosing Your Client Library
2. Connection Parameters and Heartbeats
3. Channel Management Best Practices
4. Async vs Sync Clients
5. Robust Reconnection Strategies
6. Resource Cleanup and Graceful Shutdown

Chapter 6: Building Reliable Producers and Consumers

1. Publishing Messages Correctly
2. Consumer Acknowledgements and Nacks
3. Publisher Confirms for Delivery Guarantees
4. Message Durability and Persistence
5. Prefetch Tuning and Flow Control
6. Error Handling Patterns

Chapter 7: Advanced RabbitMQ Features

1. Priority Queues for Critical Workloads
2. Delayed and Scheduled Messaging
3. Dead-Letter Exchanges and Retry Strategies
4. Message Time-to-Live and Expiration
5. RabbitMQ RPC Pattern Implementation
6. Queue Arguments and Advanced Configuration

Chapter 8: Designing Robust Distributed Systems

1. Retry Strategies with Exponential Backoff
2. Circuit Breaker Pattern Implementation
3. The Saga Pattern for Distributed Transactions
4. Idempotent Consumer Design
5. Message Ordering Guarantees
6. Handling Duplicate and Out-of-Order Messages

Chapter 9: Project One - Production Task Queue System

1. Requirements and Architecture Decisions
2. Project Structure and Configuration
3. Task Serialization and Schema Design
4. Worker Implementation with Graceful Shutdown
5. Retry Logic and Dead-Letter Handling
6. Testing the Task Queue System
7. Docker and Deployment Configuration

Chapter 10: Event-Driven Microservices with CQRS

1. Microservice Communication via Events
2. Implementing the CQRS Pattern
3. Event Sourcing Integration Concepts
4. Inter-Service Saga Orchestration
5. Domain Events and Event Versioning
6. Handling Schema Evolution

Chapter 11: Observability in Production

1. Structured Logging for Distributed Systems
2. Metrics Collection with Prometheus
3. Distributed Tracing with OpenTelemetry
4. Health Checks and Readiness Probes
5. Debugging Message Flow Issues
6. Correlation IDs Across Services

Chapter 12: Security, Authentication, and Authorization

1. TLS/SSL Encryption End-to-End
2. User Authentication and Password Policies
3. Authorization and Access Control
4. VHost Isolation Strategies
5. Secrets Management in Production
6. Network Security and Firewalls

Chapter 13: Deployment, Scaling, and High Availability

1. Docker and Docker Compose Setup
2. RabbitMQ Clustering Fundamentals
3. Quorum Queues for High Availability
4. Federation and Shovel Plugins
5. Kubernetes Deployment Patterns
6. Performance Tuning and Capacity Planning

Chapter 14: Production Pitfalls and Troubleshooting

1. Memory Pressure and Flow Control
2. Disk Alarms and Storage Management
3. Diagnosing Consumer Lag
4. Connection Storms and Resource Exhaustion
5. Split-Brain Scenarios
6. Systematic Troubleshooting Methodology

Conclusion

References