Message Queue - Introduction

Overview

Message Queue là một architectural pattern cho phép các components giao tiếp với nhau một cách asynchronous thông qua messages. Trong hệ thống phân tán, message queues đóng vai trò thiết yếu trong việc decouple producers và consumers, đảm bảo reliable delivery và enable scaling.

┌─────────────────────────────────────────────────────────────────┐
│                    MESSAGE QUEUE ARCHITECTURE                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Producer              Queue              Consumer             │
│       │                  │                    │                 │
│       │   ┌──────────┐   │                    │                 │
│       ├──▶│ Message  │──▶│                    │                 │
│       │   └──────────┘   │   ┌──────────┐    │                 │
│       │                  ├──▶│ Message  │───▶│                 │
│       │                  │   └──────────┘    │                 │
│       │                  │                    │                 │
│       │                  │   ┌──────────┐    │                 │
│       └──▶  (async) ────▶│──▶│ Message  │────│──▶ Process      │
│                          │   └──────────┘    │                 │
│                          │                    │                 │
│   Non-blocking           │                    │                 │
│   Reliable delivery       │                    │                 │
└─────────────────────────────────────────────────────────────────┘

Core Concepts

1. Producer

Component tạo và gửi messages vào queue.

// Producer sends message without waiting for processing
public class OrderService
{
    private readonly QueueClient _queueClient;
    
    public async Task CreateOrder(Order order)
    {
        var message = new QueueMessage
        {
            Body = BinaryData.FromObjectAsJson(order),
            MessageId = Guid.NewGuid().ToString()
        };
        
        // Fire and forget - non-blocking
        await _queueClient.SendMessageAsync(message);
        
        // Continue with other work immediately
        return order.Id;
    }
}

2. Queue

Buffer lưu trữ messages cho đến khi được xử lý.

┌─────────────────────────────────────────────────────────────────┐
│                         QUEUE STRUCTURE                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐  │
│   │  Message 1  │  Message 2  │  Message 3  │  Message N    │  │
│   │  (FIFO)     │  (FIFO)     │  (FIFO)     │  (FIFO)       │  │
│   └─────────────────────────────────────────────────────────┘  │
│                                                                  │
│   Properties:                                                   │
│   - Name: Unique identifier                                     │
│   - Size: Current message count                                 │
│   - TTL: Time-to-live for messages                              │
│   - VisibilityTimeout: Time message is invisible              │
└─────────────────────────────────────────────────────────────────┘

3. Consumer

Component nhận và xử lý messages từ queue.

// Consumer processes messages
public class OrderProcessor : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var messages = await _queueClient.ReceiveMessagesAsync(
                maxMessages: 10,
                visibilityTimeout: TimeSpan.FromMinutes(5));
            
            foreach (var message in messages.Value)
            {
                await ProcessMessageAsync(message);
                await _queueClient.DeleteMessageAsync(
                    message.MessageId, 
                    message.PopReceipt);
            }
        }
    }
}

Message Queue Benefits

Benefit	Description
Decoupling	Producers và consumers không cần biết về nhau
Reliability	Messages được lưu persistently cho đến khi processed
Scalability	Thêm consumers không ảnh hưởng producers
Load Leveling	Xử lý traffic spikes bằng cách queue messages
Asynchronous	Non-blocking communication

Types of Message Queues

1. Point-to-Point

Một message chỉ được xử lý bởi một consumer.

┌─────────────────────────────────────────────────────────────────┐
│                   POINT-TO-POINT PATTERN                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Producer                                                      │
│       │                                                         │
│       ├──▶ [Queue] ──▶ Consumer A                             │
│       │                                                         │
│       └──▶ [Queue] ──▶ Consumer B  (không nhận được)          │
│                                                                  │
│   Message chỉ được xử lý một lần                               │
└─────────────────────────────────────────────────────────────────┘

Một message được gửi đến tất cả subscribers.

┌─────────────────────────────────────────────────────────────────┐
│                      PUB/SUB PATTERN                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Publisher                                                     │
│       │                                                         │
│       ├──▶ [Topic] ──▶ Subscriber 1                            │
│       │                                                        │
│       ├──▶ [Topic] ──▶ Subscriber 2                            │
│       │                                                        │
│       └──▶ [Topic] ──▶ Subscriber 3                            │
│                                                                  │
│   Tất cả subscribers nhận được cùng message                    │
└─────────────────────────────────────────────────────────────────┘

When to Use Message Queue

Use Case	Description
Order Processing	Xử lý đơn hàng asynchronously
Background Jobs	Scheduled tasks, batch processing
Microservices Communication	Service-to-service messaging
Email/Notifications	Async notification delivery
File Processing	Upload, transform, process
Event-Driven Architecture	System-wide event distribution

Common Message Queue Services

Service	Provider	Type	Best For
Azure Queue Storage	Microsoft	Point-to-Point	Simple, cost-effective
Azure Service Bus	Microsoft	Pub/Sub	Enterprise features
RabbitMQ	Open Source	Hybrid	Flexible deployment
Kafka	Open Source	Log-based	High throughput
AWS SQS	Amazon	Point-to-Point	AWS integration
AWS SNS	Amazon	Pub/Sub	AWS integration

Next Steps

Azure Queue Storage - Basic implementation
Queue Best Practices - Error handling, retry
Multiple Queues - Managing multiple queues
Service Bus Topics - Pub/Sub patterns

Learning