Lộ Trình .NET: Làm Chủ Tin Nhắn Dịch Vụ (Messaging) Với RabbitMQ, Kafka, và Azure Service Bus

Gọi HTTP giữa hai service là hợp lý cho tới khi service B chậm. Rồi A timeout, người dùng bấm lại, và bạn có hai đơn hàng. Messaging không làm hệ thống đơn giản hơn — nó đổi “chờ nhau” lấy “phải chịu được việc chạy hai lần”. Bài này đi qua Messaging với RabbitMQ, Kafka và Azure Service Bus, code trên client hiện hành, và những thứ quyết định thành công mà không thư viện nào cài sẵn: idempotency, outbox, dead-letter, schema.

Cập nhật 2026

  • RabbitMQ.Client 7.2.2 đã bỏ API đồng bộ: CreateModel, BasicPublish, EventingBasicConsumer không còn. Dùng CreateChannelAsync, BasicPublishAsync, AsyncEventingBasicConsumer.
  • Confluent.Kafka 2.16 giữ API ổn định; điểm cần chú ý là commit offset thủ công và ordering theo key.
  • Azure.Messaging.ServiceBus 7.21 là SDK hiện hành; ServiceBusProcessor với AutoCompleteMessages = false là mặc định nên dùng cho consumer nghiệp vụ.
  • MassTransit 9.2.5 và NServiceBus 10.2.9 đều là sản phẩm thương mại — MassTransit 9 chuyển sang mô hình license, NServiceBus vốn commercial. Đừng đưa vào dự án mà chưa kiểm tra điều kiện license.

Khi nào dùng messaging, khi nào dùng HTTP

Dùng HTTP khi caller cần câu trả lời để tiếp tục: kiểm tra tồn kho, lấy giá, xác thực. Dùng messaging khi caller không cần kết quả ngay và bạn muốn chịu được việc consumer chết:

  • Fan-out: một event OrderPlaced cần tới billing, inventory, email, analytics. HTTP sẽ buộc order service biết cả bốn và xử lý bốn lỗi khác nhau.
  • Đệm tải: lượng đơn tăng gấp 10 lúc khuyến mãi; broker hấp thụ, consumer xử lý theo năng lực.
  • Tách thời gian: producer sống ở giờ hành chính, consumer chạy batch về đêm.
  • Độ bền sự kiện: event phải còn sau khi service restart; HTTP request thì không.

Ngược lại, đừng dùng messaging cho request/response đồng bộ giả lập (gửi message rồi chờ reply) — bạn vừa mất tính đơn giản của HTTP vừa thêm độ phức tạp của broker, và tự tạo ra timeout hai tầng.

Bốn khái niệm quyết định mọi thứ

  • Queue (point-to-point): mỗi message tới đúng một consumer. Phù hợp lệnh (command).
  • Exchange + binding (RabbitMQ): producer không gửi vào queue mà gửi vào exchange với routing key; binding quyết định queue nào nhận.
  • Partition + offset (Kafka): topic chia partition, mỗi partition là log chỉ-ghi-thêm; consumer đọc theo offset. Thứ tự chỉ được bảo toàn trong một partition.
  • Session (Azure Service Bus): gom message cùng SessionId để một consumer xử lý tuần tự — mô phỏng ordering mà không cần partition.

Chọn mô hình trước, chọn sản phẩm sau. Nếu nghiệp vụ của bạn là “mỗi lệnh chỉ một nơi xử lý”, queue là đúng và Kafka sẽ là overkill.

RabbitMQ 7.2.2

Producer khai báo exchange, queue, binding rồi publish. Tất cả đều async trong 7.x:

// File: src/Messaging/RabbitPublisher.cs
var factory = new ConnectionFactory
{
    HostName = "rabbit",
    UserName = "app",
    Password = "secret",
    AutomaticRecoveryEnabled = true
};

await using var connection = await factory.CreateConnectionAsync();
await using var channel = await connection.CreateChannelAsync();

await channel.ExchangeDeclareAsync("orders", ExchangeType.Topic, durable: true, autoDelete: false);
await channel.QueueDeclareAsync("billing.orders", durable: true, exclusive: false, autoDelete: false,
    arguments: new Dictionary<string, object?>
    {
        ["x-dead-letter-exchange"] = "orders.dlx"
    });
await channel.QueueBindAsync("billing.orders", "orders", "order.placed");

var body = JsonSerializer.SerializeToUtf8Bytes(new { OrderId = orderId, Total = 125.5m });
await channel.BasicPublishAsync(exchange: "orders", routingKey: "order.placed", body: body);

Consumer với prefetch và ack thủ công:

// File: src/Messaging/RabbitConsumer.cs
await channel.BasicQosAsync(prefetchSize: 0, prefetchCount: 20, global: false);

var consumer = new AsyncEventingBasicConsumer(channel);
consumer.ReceivedAsync += async (_, ea) =>
{
    try
    {
        var json = Encoding.UTF8.GetString(ea.Body.Span);
        await handler.HandleAsync(json, ea.CancellationToken);
        await channel.BasicAckAsync(ea.DeliveryTag, multiple: false);
    }
    catch (Exception ex)
    {
        // requeue: false -> message sang DLX nếu queue có cấu hình dead-letter
        await channel.BasicNackAsync(ea.DeliveryTag, multiple: false, requeue: false);
    }
};

await channel.BasicConsumeAsync("billing.orders", autoAck: false, consumer: consumer);

prefetchCount là van điều tiết quan trọng nhất: quá cao thì một consumer ôm 500 message trong bộ nhớ khi sự cố; quá thấp thì throughput tụt. Bắt đầu ở 10–20 và đo. autoAck: true là cách mất dữ liệu khi process crash giữa chừng — không dùng cho nghiệp vụ.

Kafka 2.16

// File: src/Messaging/KafkaProducer.cs
using Confluent.Kafka;

var config = new ProducerConfig
{
    BootstrapServers = "kafka:9092",
    Acks = Acks.All,
    EnableIdempotence = true,
    LingerMs = 5
};

using var producer = new ProducerBuilder<string, string>(config).Build();

var result = await producer.ProduceAsync("orders", new Message<string, string>
{
    Key = orderId.ToString(),   // cùng key -> cùng partition -> giữ thứ tự
    Value = JsonSerializer.Serialize(new OrderPlaced(orderId, total))
});
// File: src/Messaging/KafkaConsumer.cs
var config = new ConsumerConfig
{
    BootstrapServers = "kafka:9092",
    GroupId = "billing",
    AutoOffsetReset = AutoOffsetReset.Earliest,
    EnableAutoCommit = false,
    MaxPollIntervalMs = 300_000
};

using var consumer = new ConsumerBuilder<string, string>(config).Build();
consumer.Subscribe("orders");

while (!ct.IsCancellationRequested)
{
    var record = consumer.Consume(ct);
    await handler.HandleAsync(record.Message.Key, record.Message.Value, ct);
    consumer.Commit(record);   // commit chỉ sau khi xử lý xong
}

Ba điều quan trọng: key quyết định ordering — hai event cùng orderId vào cùng partition và được xử lý tuần tự; commit sau xử lý cho at-least-once, commit trước cho at-most-once (mất dữ liệu khi crash); và MaxPollIntervalMs phải lớn hơn thời gian xử lý lô lớn nhất, nếu không consumer bị kick khỏi group và partition rebalance giữa chừng. Consumer group cho phép scale ngang, nhưng số consumer hữu ích tối đa bằng số partition — thêm consumer thứ 9 cho topic 8 partition là thêm một instance ngồi không.

Azure Service Bus 7.21

// File: src/Messaging/ServiceBusConsumer.cs
await using var client = new ServiceBusClient(connectionString);

await using var processor = client.CreateProcessor("orders", new ServiceBusProcessorOptions
{
    MaxConcurrentCalls = 8,
    PrefetchCount = 16,
    AutoCompleteMessages = false
});

processor.ProcessMessageAsync += async args =>
{
    try
    {
        await handler.HandleAsync(args.Message.Body.ToString(), args.CancellationToken);
        await args.CompleteMessageAsync(args.Message);
    }
    catch (InvalidOrderException ex)
    {
        await args.DeadLetterMessageAsync(args.Message, "invalid-order", ex.Message);
    }
    catch (Exception)
    {
        await args.AbandonMessageAsync(args.Message);   // nhả lại, delivery count tăng
    }
};

await processor.StartProcessingAsync(ct);

Service Bus mạnh ở hai thứ mà RabbitMQ và Kafka không có sẵn: sessions (message cùng SessionId được một consumer xử lý tuần tự, đúng cho luồng theo khách hàng), và dead-letter tích hợp với lý do và mô tả do bạn đặt. Đổi lại, throughput bị giới hạn bởi tier và giá theo message — đừng dùng nó làm event bus cho hàng triệu event/ngày nếu chưa tính chi phí.

Session processor dùng CreateSessionProcessor với MaxConcurrentSessions; mỗi session là một đơn vị ordering, nên chọn SessionId theo thực thể nghiệp vụ (customer, account), không theo loại message.

MassTransit và NServiceBus: abstraction có giá

Hai thư viện này cho bạn topology, retry, saga, outbox và convention thay vì tự viết. MassTransit 9.2.5 chuyển sang mô hình license thương mại với một số tier miễn phí giới hạn; NServiceBus 10.2.9 là commercial, miễn phí cho dev và quy mô nhỏ. Với sản phẩm thương mại, hãy tính license vào chi phí kiến trúc ngay từ POC, đừng phát hiện lúc go-live. Nếu ngân sách không có, chọn một trong hai hướng: dùng client thô (RabbitMQ.Client/Confluent.Kafka) với vài lớp tự viết, hoặc giữ HTTP + outbox — rẻ hơn nhiều so với license nhưng bạn tự chịu trách nhiệm về idempotency.

At-least-once là mặc định, idempotency là bắt buộc

Cả ba broker đều cho bạn ít nhất một lần giao, không phải đúng một lần. Consumer có thể chết sau khi ghi database nhưng trước khi ack; message sẽ được giao lại. Vì vậy:

  • Ghi dấu đã xử lý trong cùng transaction với nghiệp vụ: bảng processed_messages(message_id PRIMARY KEY); insert trùng sẽ ném unique violation và bạn bỏ qua message.
  • Hoặc làm cho thao tác tự nhiên idempotent: UPDATE balance SET ... WHERE version = @v, upsert theo business key, chuyển trạng thái có guard.
  • Kafka: offset commit và ghi database không nằm trong một transaction, nên idempotent consumer theo (topic, partition, offset) hoặc theo business key là cách duy nhất để không xử lý trùng.

Transactional outbox

Vấn đề: bạn commit database rồi publish message; nếu process chết giữa hai bước, event mất. Publish trước rồi commit thì consumer có thể đọc event của một transaction chưa commit. Giải pháp outbox:

  1. Trong cùng transaction với thay đổi nghiệp vụ, insert một row vào outbox (payload + headers).
  2. Một worker (BackgroundService hoặc job scheduler) đọc row chưa publish, gửi lên broker, rồi đánh dấu published_at.
  3. Nếu gửi xong mà chưa kịp đánh dấu, message bị gửi lại — chấp nhận được vì consumer đã idempotent.

Đây là lý do “at-least-once” và “idempotency” luôn đi thành cặp. Outbox không cần thư viện; cần kỷ luật transaction và một index trên published_at.

Schema evolution: đừng phá consumer cũ

Message là hợp đồng giữa các team, và hợp đồng sẽ đổi. Quy tắc tối thiểu:

  • Luôn có messageId, occurredAt (UTC), type, version trong envelope.
  • Chỉ thêm field optional; không đổi nghĩa field cũ, không xoá field đang được đọc.
  • Consumer phải chịu được field lạ — System.Text.Json mặc định bỏ qua member không map, nhưng nếu bạn dùng JsonSerializerOptions chặt hoặc source-generated strict, hãy kiểm tra.
  • Breaking change = event mới (OrderPlacedV2) và chạy song song đến khi consumer cũ ngừng; với Kafka, dùng Schema Registry (Avro/Protobuf) để chặn incompatible schema ở CI.

Retry, DLQ và poison message

Retry tại chỗ (requeue/abandon) giữ nguyên vị trí message và chặn cả partition/queue phía sau — một message lỗi có thể làm dừng toàn bộ luồng. Vì vậy:

  • Lỗi tạm thời (timeout, 503): retry có backoff, giới hạn 3–5 lần; với Kafka nên đẩy sang retry topic thay vì ngủ trong vòng lặp consume.
  • Lỗi vĩnh viễn (payload sai schema, nghiệp vụ không hợp lệ): DLQ ngay, kèm lý do. RabbitMQ dùng dead-letter exchange, Service Bus dùng DeadLetterMessageAsync, Kafka phải tự viết DLQ topic.
  • Poison message: đếm delivery count; vượt ngưỡng thì DLQ, đừng retry vô hạn.
  • Giám sát DLQ depth như một SLO. DLQ đầy mà không ai xem là dữ liệu mất im lặng.

Observability cho messaging

Một message đi qua ba tiến trình; nếu không propagate trace context trong header, bạn sẽ debug bằng log rời. Ghi traceparent (W3C) vào message header, tạo span cho publish và consume, và log messageId ở cả hai đầu. Đo: publish rate, consume rate, consumer lag (Kafka), DLQ depth, thời gian xử lý p95. Consumer lag tăng đều là dấu hiệu sớm nhất của sự cố — thấy nó trước khi khách hàng thấy.

Bảng quyết định

Tiêu chí RabbitMQ Kafka Azure Service Bus
Mô hình Queue + exchange linh hoạt Log phân vùng, replay được Queue/topic + session, DLQ sẵn
Hợp với Command, task queue, routing phức tạp Event stream, throughput cao, event sourcing Nghiệp vụ cloud, ordering theo thực thể
Vận hành Tự chạy hoặc managed Nặng hơn; cần hiểu partition/rebalance PaaS, không tự vận hành

Không có lựa chọn “tốt nhất”: có hệ thống dùng Kafka để ingest và RabbitMQ để điều phối command là hợp lý, miễn bạn chấp nhận hai thứ phải vận hành.

Nhìn tới 2027

.NET 11 GA tháng 11/2026 (STS) không đổi bức tranh messaging; thay đổi thực tế đến từ hạ tầng — Aspire/Dapr phổ biến hơn cho local orchestration, và outbox + idempotent consumer dần được đóng gói trong thư viện thay vì tự viết. MassTransit và NServiceBus sẽ tiếp tục là lựa chọn trả tiền cho team muốn convention; client thô vẫn là nền tảng khi bạn cần kiểm soát.

Checklist trước khi thêm broker

  • Viết rõ: message này là command hay event? Ai được phép đọc? Thứ tự có bắt buộc không?
  • Chọn key/session id theo thực thể nghiệp vụ, không theo loại message.
  • Thiết kế consumer idempotent trước khi viết consumer.
  • Có outbox nếu publish đi cùng transaction database.
  • Đặt DLQ và alert trên DLQ depth ngay từ ngày đầu.
  • Ước tính chi phí license và chi phí vận hành trước khi cam kết với sếp.

Đọc tiếp trong series: