RabbitMQ cho production: channel, quorum queue, confirm và DLQ

- Published on
- 14 mins read
Một message mang JSON hỏng lọt vào queue. Consumer parse lỗi, ném exception, message quay lại queue, consumer nhận lại, lại ném. Hàng nghìn message hợp lệ phía sau cứ thế đứng chờ.
Trong Event-Driven Architecture và Microservices, Message Broker giống như hệ thần kinh của cả hệ thống. Nó gánh mấy đợt tải tăng đột ngột (Load Leveling / Peak Shaving), tách các service ra khỏi nhau (Decoupling), và giữ cho không giao dịch nào bị thất lạc khi có service sập.
RabbitMQ chạy trên máy ảo Erlang OTP (BEAM), vốn làm ra cho hệ thống viễn thông của Ericsson (con số "chín số 9" hay được nhắc là Ericsson công bố cho tổng đài AXD301 viết bằng Erlang). Theo trang chủ RabbitMQ, đây là message broker mã nguồn mở được triển khai rộng rãi nhất, và là cài đặt AMQP 0-9-1 phổ biến nhất.
Có điều ở hệ thống lớn, bê nguyên cấu hình mặc định từ mấy bài hướng dẫn nhập môn lên production thì sớm muộn cũng đụng sự cố. Cái message hỏng ở trên chỉ là một trong số đó:
- App hết socket descriptor vì worker thread nào cũng tự mở một kết nối TCP riêng, không dùng Channel Multiplexing.
- Mất dữ liệu khi node broker sập vì vẫn dùng Classic Mirrored Queues (đã bị gỡ khỏi RabbitMQ 4.0) thay vì Quorum Queues.
- Consumer tràn RAM vì để
prefetchCount = 0(không giới hạn). Spring AMQP mặc định đã đặt prefetch 250, nhưng client Java thuần hay thư viện khác thì chưa chắc. - Một bản tin lỗi (Poison Pill Message) làm tắc cả hàng đợi vì thiếu Dead Letter Exchange (DLX) và Exponential Backoff.
# kiến trúc amqp 0-9-1: connection vs channel multiplexing
Lỗi cơ bản nhưng gây hậu quả nhanh nhất là để mỗi worker thread mở một kết nối TCP riêng tới broker. Mỗi TCP Connection đòi hỏi bắt tay 3 bước (3-way handshake), thương lượng TLS và ngốn một file descriptor ở tầng hệ điều hành. Nếu 500 Virtual Threads hoặc 200 HTTP workers cùng lúc mở kết nối riêng mỗi khi cần bắn một sự kiện, RabbitMQ sẽ nhanh chóng cạn tài nguyên mạng và từ chối kết nối mới.
Giao thức AMQP 0-9-1 giải quyết việc này bằng Channel Multiplexing (ghép nhiều kênh ảo trên cùng một đường truyền vật lý):
# nguyên tắc cần nhớ
- Mỗi app chỉ nên giữ một (hoặc vài) TCP Connection tới RabbitMQ Broker.
- Từng thread sẽ mở AMQP Channel, một kênh ảo rất nhẹ nằm bên trong kết nối TCP đó.
- Channel không thread-safe. Mỗi thread phải có Channel riêng (
RabbitTemplatecủa Spring tự lo chuyện này qua pool).
# 4 loại Exchange & Consistent Hash Exchange
Message từ Producer không bao giờ đi thẳng vào Queue. Nó luôn phải qua một Exchange, Exchange dựa vào Routing Key để chuyển tiếp:
# wildcard trong topic exchange
*(Star): khớp đúng 1 từ (ví dụorder.*.createdkhớporder.vn.created, nhưng không khớporder.vn.retail.created).#(Hash): khớp 0 hoặc nhiều từ (ví dụaudit.#khớp mọi routing key bắt đầu bằngaudit.).
# scale ngang: consistent hash exchange
Khi cần chia một lượng dữ liệu cực lớn (ví dụ 100,000 event/giây) ra 10 Queue, mà vẫn phải đảm bảo message của cùng một user_id luôn rơi vào cùng một Queue để giữ đúng thứ tự:
- Consistent Hash Exchange dùng consistent hashing trên routing key để chọn queue, nhờ vậy scale-out consumer theo chiều ngang mà không lo race condition.
Loại exchange này không nằm trong 4 loại chuẩn, nó là plugin rabbitmq_consistent_hash_exchange có sẵn trong bản cài nhưng phải bật (rabbitmq-plugins enable rabbitmq_consistent_hash_exchange). Và hash chỉ đảm bảo cùng user_id vào cùng queue. Muốn giữ thứ tự thật thì mỗi queue chỉ được một consumer xử lý tại một thời điểm (bật x-single-active-consumer, concurrency 1). Mấy consumer cùng đọc một queue là thứ tự lại vỡ.
# quorum queues (raft consensus)
Suốt hơn một thập kỷ, bài toán High Availability của RabbitMQ được giải bằng Classic Mirrored Queues (ha-mode). Cơ chế cũ này có mấy nhược điểm lớn: không dựa trên thuật toán đồng thuận chuẩn nên khi mạng nội bộ bị chia cắt (network partition) rất dễ rơi vào trạng thái Split-Brain hai nhánh tự nhận mình là chính; còn lúc một node mới vào lại cụm và chạy đồng bộ dữ liệu (synchronization) thì toàn bộ queue bị khóa đứng. Vì những hạn chế đó, tính năng mirroring trên classic queue đã bị đánh dấu deprecated từ năm 2021, RabbitMQ 3.13 là bản cuối cùng còn hỗ trợ, và từ RabbitMQ 4.0 đã bị xóa sổ hoàn toàn.
# quorum queues: lựa chọn mặc định cho enterprise
Thay thế cho Mirrored Queues là Quorum Queues, được xây dựng dựa trên thuật toán đồng thuận phân tán Raft Consensus:
Với mô hình Raft, một bản tin chỉ được xác nhận thành công (confirm) về cho Producer sau khi đã được ghi xuống đĩa (fsync) trên quá bán số node trong cụm (Quorum: N/2 + 1, ví dụ 2 trên 3 node). Chừng nào đa số node còn sống thì không một bản tin đã confirm nào bị mất; nếu node giữ vai trò Leader của queue bị sập, hai Follower còn lại sẽ tự bầu Leader mới (thường mất cỡ vài giây, tuỳ cấu hình phát hiện lỗi) và tiếp tục phục vụ. Tất nhiên sự an toàn này có giá của nó: vì mọi bản tin đều phải ghi đĩa và nhân bản qua mạng trước khi confirm, thông lượng của Quorum Queue sẽ thấp hơn classic queue không nhân bản, và cụm cần ít nhất 3 node (thường chọn số lẻ; nếu chỉ dựng 2 node thì sập 1 node là mất quá bán, cả queue sẽ ngừng hoạt động).
# không để mất message: producer confirms & manual ack
Muốn có At-Least-Once Delivery thật sự thì cả chuỗi từ Producer tới Consumer, khâu nào cũng phải có xác nhận:
# hai thứ bắt buộc phải có
- Producer Confirms: đừng bao giờ "bắn rồi quên" (fire and forget). Producer phải chờ broker confirm, với Spring thì gắn
CorrelationDatavào lúc gửi và đọc kết quả từ nó (xem code ở dưới). - Consumer chỉ ack sau khi xử lý xong: không dùng auto-ack của giao thức AMQP (trong Spring là
AcknowledgeMode.NONE), vì broker coi message đã xong ngay lúc gửi đi, consumer chết giữa chừng là mất. Chỉ gửibasicAckSAU KHI database transaction của consumer đã commit xong.
Chỗ này hay bị hiểu nhầm: AcknowledgeMode.AUTO của Spring không phải auto-ack của AMQP. Ở chế độ AUTO, container của Spring gọi listener, listener chạy xong không ném exception thì Spring mới basicAck, ném exception thì Spring basicNack/basicReject. Listener có @Transactional thì transaction commit trước khi method trả về, nên ack luôn đi sau commit. Đây là chế độ nên dùng trong đa số trường hợp. MANUAL chỉ cần khi bạn muốn tự ack ở thời điểm khác (ack theo lô, ack bất đồng bộ), và khi đó listener phải nhận Channel + deliveryTag để tự gọi basicAck; quên gọi hoặc ném exception mà không nack là message nằm "unacked" mãi, prefetch đầy dần rồi consumer đứng hình.
# xử lý message độc: dead letter exchange (dlx) & exponential retry
Một sự cố kinh điển khác trên production là Poison Pill Message (bản tin độc): giả sử một message bị sai định dạng JSON hoặc thiếu trường bắt buộc khiến Consumer văng NullPointerException. Nếu gặp lỗi mà Consumer lại trả basicNack(requeue = true) để nhét bản tin đó quay lại đầu hàng đợi, chỉ vài mili-giây sau chính Consumer sẽ nhận lại đúng bản tin hỏng đó, lại crash rồi lại nack. Vòng lặp vô tận này nhanh chóng đốt 100% CPU, phun đầy ổ cứng log và làm tắc nghẽn toàn bộ các bản tin hợp lệ đang xếp hàng phía sau:
# cấu hình spring boot 3 cho production
Cấu hình dưới đây gom các ý ở trên: quorum queue, DLX, deliveryLimit, prefetch, retry có backoff. Mình đã biên dịch thử với Spring Boot 3.5 (Spring AMQP 3.2).
package com.company.messaging.config;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.RetryInterceptorBuilder;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.retry.RejectAndDontRequeueRecoverer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class EnterpriseRabbitMqConfig {
public static final String ORDERS_EXCHANGE = "orders.direct.exchange";
public static final String ORDERS_QUEUE = "orders.processing.queue";
public static final String ORDERS_ROUTING_KEY = "orders.process";
public static final String DLX_EXCHANGE = "orders.dlx.exchange";
public static final String DLQ_QUEUE = "orders.dlq.queue";
public static final String DLX_ROUTING_KEY = "orders.dlx";
// 1. Khai báo Dead Letter Queue (Quorum Queue)
@Bean
public Queue deadLetterQueue() {
return QueueBuilder.durable(DLQ_QUEUE)
.quorum() // Cấu hình Quorum Queue (Raft)
.build();
}
@Bean
public DirectExchange deadLetterExchange() {
return new DirectExchange(DLX_EXCHANGE);
}
@Bean
public Binding dlqBinding() {
return BindingBuilder.bind(deadLetterQueue()).to(deadLetterExchange()).with(DLX_ROUTING_KEY);
}
// 2. Khai báo Main Processing Queue có gắn Dead Letter Routing
@Bean
public Queue mainOrdersQueue() {
return QueueBuilder.durable(ORDERS_QUEUE)
.quorum() // Sử dụng Quorum Queue thay cho Classic Queue
.deadLetterExchange(DLX_EXCHANGE)
.deadLetterRoutingKey(DLX_ROUTING_KEY)
.deliveryLimit(5) // Lưới an toàn cuối: bị trả về quá 5 lần thì sang DLQ
// Dead-letter kiểu at-least-once (mặc định quorum queue là at-most-once,
// broker lỗi giữa chừng thì message dead-letter có thể mất)
.overflow(QueueBuilder.Overflow.rejectPublish)
.withArgument("x-dead-letter-strategy", "at-least-once")
.build();
}
@Bean
public DirectExchange mainOrdersExchange() {
return new DirectExchange(ORDERS_EXCHANGE);
}
@Bean
public Binding mainOrdersBinding() {
return BindingBuilder.bind(mainOrdersQueue()).to(mainOrdersExchange()).with(ORDERS_ROUTING_KEY);
}
// 3. Cấu hình Listener Container với Prefetch Count chuẩn mực
@Bean
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
CachingConnectionFactory connectionFactory) {
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
// BẮT BUỘC: Khống chế Prefetch Count để tránh OOM
factory.setPrefetchCount(50); // Mỗi consumer chỉ nhận tối đa 50 messages chưa ack
// AUTO của Spring: listener chạy xong mới ack, ném exception thì nack
factory.setAcknowledgeMode(AcknowledgeMode.AUTO);
// Retry trong bộ nhớ với exponential backoff: 1s, 2s (tối đa 10s), thử 3 lần.
// Hết lượt thì reject không requeue -> message sang DLX
factory.setAdviceChain(RetryInterceptorBuilder.stateless()
.maxAttempts(3)
.backOffOptions(1000, 2.0, 10000)
.recoverer(new RejectAndDontRequeueRecoverer())
.build());
return factory;
}
}Có hai tầng retry ở đây. RetryInterceptorBuilder retry ngay trong consumer, có backoff, nhưng trong lúc chờ thì thread consumer đứng yên, nên chỉ hợp với backoff ngắn (vài giây). Muốn chờ lâu hơn (vài phút, vài giờ) mà không giữ thread thì dùng mô hình retry queue có TTL như sơ đồ ở trên. Còn deliveryLimit của quorum queue là lưới an toàn cuối: consumer crash, mất kết nối, message bị trả về quá 5 lần thì broker tự đẩy sang DLX. Từ RabbitMQ 4.0, quorum queue có delivery-limit mặc định là 20 kể cả khi bạn không đặt.
Phía producer, bật confirm trong application.yml rồi chờ kết quả qua CorrelationData:
spring:
rabbitmq:
publisher-confirm-type: correlated # broker trả confirm cho từng message
publisher-returns: true # message không route được vào queue nào thì bị trả lại
template:
mandatory: truepublic void publish(OrderEvent event) throws Exception {
CorrelationData correlation = new CorrelationData(UUID.randomUUID().toString());
rabbitTemplate.convertAndSend(ORDERS_EXCHANGE, ORDERS_ROUTING_KEY, event, correlation);
// Chờ broker confirm (quorum queue: đã ghi xuống đa số node)
CorrelationData.Confirm confirm = correlation.getFuture().get(5, TimeUnit.SECONDS);
if (!confirm.isAck()) {
throw new IllegalStateException("Broker nack: " + confirm.getReason());
}
if (correlation.getReturned() != null) {
throw new IllegalStateException("Message không route được tới queue nào");
}
}Chờ đồng bộ từng message như trên là dễ hiểu nhất nhưng chậm. Lưu lượng lớn thì gửi cả loạt rồi mới chờ các future, hoặc xử lý confirm bất đồng bộ qua rabbitTemplate.setConfirmCallback(...). Message của Spring mặc định đã là persistent (deliveryMode = 2), không cần set thêm.
TIP
Chọn Prefetch Count cho hợp: đừng bao giờ để prefetchCount = 0 (unbounded). Consumer xử lý mất 100ms/message thì prefetch tầm 20-50 là đẹp, vừa tận dụng được pipeline mạng vừa không đầy RAM khi traffic dồn lên.
# so sánh: rabbitmq vs apache kafka
| Tiêu chí | RabbitMQ (AMQP 0-9-1) | Apache Kafka |
|---|---|---|
| Mô hình | Smart Broker / Dumb Consumer (Broker theo dõi ack, xong thì xoá message) | Dumb Broker / Smart Consumer (Log phân tán bất biến, Consumer tự quản lý offset) |
| Độ trễ (Latency) | ⚡ Cực thấp (Dưới 1 mili-giây / Sub-millisecond) | 🟡 Vài mili-giây (Tối ưu cho Throughput theo batch) |
| Throughput (TPS) | 🟡 Hàng chục tới vài trăm nghìn messages/giây mỗi cluster, tuỳ loại queue | 🚀 Hàng triệu messages/giây |
| Khả năng định tuyến | 🚀 Rất linh hoạt (Direct, Topic, Fanout, Headers, Hash) | 🟡 Đơn giản (Chỉ dựa trên Topic và Partition Key) |
| Lưu trữ & Replay | 🔴 Queue thường không replay được (xoá sau khi ack); riêng RabbitMQ Streams (từ 3.9) lưu log và replay được | 🟢 Lưu trữ lâu dài, cho phép replay lại từ đầu |
| Use Case điển hình | Giao dịch ngân hàng, Background Jobs, Task Queues, RPC | Data Streaming, Event Sourcing, Log Aggregation, Analytics |
# tổng kết
Đem cấu hình RabbitMQ đang chạy ra đối chiếu với bốn câu hỏi. Câu nào trả lời "không" thì đó là việc của sprint tới:
- Mỗi app có dùng chung một kết nối TCP và mở nhiều Channel trên đó (Channel Multiplexing) không?
prefetchCountcó được giới hạn ở mọi consumer, kể cả consumer không viết bằng Spring, để khỏi tràn RAM không?- Queue quan trọng đã là Quorum Queues (Raft Consensus) chưa, và producer có bật Producer Confirms, consumer có ACK sau khi xử lý xong (Manual ACK hoặc AUTO của Spring) không?
- Có Dead Letter Queue (DLQ) cùng
deliveryLimitđể cách ly message độc như cái message JSON hỏng không?
Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!
Happy coding 😎 👍🏻 🚀 🔥.
On this page
- # kiến trúc amqp 0-9-1: connection vs channel multiplexing
- # nguyên tắc cần nhớ
- # 4 loại Exchange & Consistent Hash Exchange
- # wildcard trong topic exchange
- # scale ngang: consistent hash exchange
- # quorum queues (raft consensus)
- # quorum queues: lựa chọn mặc định cho enterprise
- # không để mất message: producer confirms & manual ack
- # hai thứ bắt buộc phải có
- # xử lý message độc: dead letter exchange (dlx) & exponential retry
- # cấu hình spring boot 3 cho production
- # so sánh: rabbitmq vs apache kafka
- # tổng kết