Cụm bài Kafka: bài toán và pattern: 1. Số partition, message lớn, lag và tác vụ chạy lâu · 2. Dual write, exactly-once và thứ tự message · 3. Case study: phát hiện gian lận với Kafka và Redis
Biết Kafka chạy thế nào chưa đủ; phỏng vấn senior hỏi bạn làm gì khi topic quá hẹp, message quá to, consumer tụt lại hay một record làm kẹt cả partition. Bài này gom các bài toán đó, mỗi bài một pattern kèm trade-off. Nên đọc trước Vì sao Kafka nhanh và bền và Cấu hình Kafka theo mục tiêu.
1. Chọn số partition
Ý chính: tính số partition riêng cho phía ghi và phía đọc, lấy số lớn hơn, rồi dư ra một chút cho tăng trưởng. Partition chỉ tăng được, không giảm được.
Hai sự thật làm việc này khó:
- Chỉ tăng, không giảm. Tăng không làm gián đoạn client, nhưng không có lệnh giảm.
- Hash không nhất quán khi đổi số partition. Partitioner mặc định lấy
murmur2(key) % số_partition. Đổi mẫu số thì cùng key sang partition khác, mất thứ tự theo key.
Công thức: số partition = throughput mong muốn / throughput một partition. Throughput có hai chiều, và chiều nào hẹp hơn quyết định.
| Loại topic | Ví dụ | Throughput một partition | Gợi ý của khoá học |
|---|---|---|---|
| Nặng về ghi | IoT, clickstream | ~10 MB/s ghi; message ~700 B, ~500 B sau nén | < 10k msg/s: < 4; 10k–100k: 8–16; 100k–1M: 20–32 |
| Nặng về đọc | thanh toán, đơn hàng | phụ thuộc logic và DB, phải load test | < 1k msg/s: ≤ 8; 1k–10k: 8–16 |
Ví dụ: topic sự kiện thanh toán, đỉnh 5.000 msg/s, mỗi message 500 B. Phía ghi: 5.000 × 500 B = 2,5 MB/s, một partition là đủ. Phía đọc: load test cho thấy một consumer (ghi DB, gọi ledger) xử lý 400 msg/s, cần 5.000 / 400 = 12,5, tức 13 consumer. Chọn 16: đủ cho 13 consumer, còn dư cho tăng trưởng, và chia đều cho 2, 4, 8 instance.
2. Giảm số partition: chuyển sang topic mới
Ý chính: không giảm tại chỗ được, nên tạo topic mới đúng kích thước, sao chép dữ liệu, rồi chuyển producer và consumer sang theo thứ tự.
- Tạo topic mới với số partition mong muốn.
- Sao chép từ topic cũ sang bằng MirrorMaker 2 (hoặc một consumer/producer tự viết).
- Khi bản sao đuổi kịp, cắt: dừng producer một lúc ngắn để hai bên khớp nhau.
- Chuyển producer sang ghi topic mới (khoá học gợi ý ghi đôi cả hai topic một thời gian để consumer cũ chưa chuyển không bị đứt).
- Chuyển consumer sang topic mới, chọn điểm bắt đầu:
auto.offset.reset=latest: bắt đầu từ lúc cắt; consumer phải idempotent vì vùng chồng lấn có thể đọc trùng.earliesthoặc reset offset về timestamp lúc cắt (kafka-consumer-groups --reset-offsets --to-datetime): không bỏ sót, nhưng chắc chắn đọc trùng một đoạn.
3. Message lớn: claim check
Ý chính: giới hạn mặc định của một record khoảng 1 MB. Đừng nâng nó; đưa payload lên object storage và chỉ gửi tham chiếu.
Ví dụ: producer muốn gửi file báo cáo 20 MB cho consumer xử lý.
- Cách 1, nâng giới hạn:
max.message.bytes(topic),message.max.bytes(broker), cộngmax.request.sizeở producer vàmax.partition.fetch.bytes,fetch.max.bytesở consumer. Khoá học coi đây là anti-pattern và đặt trần thực tế ~10 MB: record to làm chậm replication, giảm throughput, chiếm bộ nhớ consumer, và một record to chặn mọi record nhỏ phía sau trong cùng partition. - Cách 2, claim check: producer tải file lên S3 (hoặc MinIO, GCS), gửi message chứa URL, kích thước, checksum. Consumer đọc message rồi tải file về xử lý. Đơn giản và nhanh; giá là thêm một hệ thống lưu trữ.
Chi tiết claim check: thứ tự ghi, dọn rác, bảo mật
- Thứ tự: tải file lên trước, xác nhận xong mới gửi message. Ngược lại consumer có thể nhận URL trỏ tới file chưa tồn tại.
- Dọn rác: file tải lên mà message không gửi được sẽ mồ côi. Đặt lifecycle rule trên bucket (xoá sau N ngày) dài hơn retention của topic.
- Bảo mật: gửi object key thay vì URL công khai; consumer dùng quyền của nó để đọc, hoặc tạo presigned URL ngắn hạn.
- Idempotency: đặt object key theo nội dung (hash) hoặc theo id nghiệp vụ, để producer retry không tạo nhiều bản.
- Message vừa vừa (1–5 MB): thử nén (
compression.type=zstd) trước; JSON thường nén 5–10 lần.
4. Message lag: đo trước, scale sau
Ý chính: lag = offset cuối của partition trừ offset group đã commit. Khi lag tăng, tìm nguyên nhân bằng monitoring trước; scale consumer chỉ đúng khi nguyên nhân là consumer chậm, và bị chặn bởi số partition.
- Lag theo số message:
log-end-offset − committed-offset, tính cho từng partition. - Lag theo thời gian:
(last_produced − last_consumed) / tốc độ produce. Con số này dễ đặt SLO hơn (“chậm tối đa 30 giây”).
Lag kéo dài gây ra:
- Latency không chấp nhận được với người dùng.
- Mất dữ liệu: nếu lag vượt retention, record bị xoá trước khi được đọc.
- Consumer bị coi là chết và bị rebalance, nếu nguyên nhân là xử lý lâu (mục 5).
Nguyên nhân thường gặp: producer tăng đột biến, consumer chậm đi (DB chậm, API ngoài chậm), tác vụ dài, mạng, GC pause dài, rebalance liên tục.
flowchart LR
A[Lag tăng] --> B{Tốc độ produce tăng?}
B -- có, tạm thời --> C[Chờ hoặc chịu lag, kiểm retention]
B -- không --> D{Thời gian xử lý mỗi record tăng?}
D -- có --> E[Sửa phụ thuộc chậm: DB, API, GC]
D -- không --> F{Rebalance liên tục?}
F -- có --> G[Xem mục 5: liveness]
F -- không --> H[Scale consumer, tăng partition nếu cần]
Đo lag: công cụ, metric và code Java
- CLI:
kafka-consumer-groups.sh --bootstrap-server ... --describe --group paymentinCURRENT-OFFSET,LOG-END-OFFSET,LAGcho từng partition. - Metric phía consumer:
records-lag-max(JMX, client Java) cho biết partition tụt nhiều nhất mà consumer đó đang giữ. Không thấy được partition chưa ai giữ. - Giám sát từ ngoài: Burrow (khoá học khuyên dùng, đánh giá trạng thái theo cửa sổ thay vì ngưỡng cứng), Kafka Lag Exporter (lag theo thời gian, xuất cho Prometheus), Confluent Control Center.
- Tự đo bằng AdminClient:
try (Admin admin = Admin.create(props)) {
Map<TopicPartition, OffsetAndMetadata> committed =
admin.listConsumerGroupOffsets("payment").partitionsToOffsetAndMetadata().get();
Map<TopicPartition, OffsetSpec> latest = committed.keySet().stream()
.collect(Collectors.toMap(tp -> tp, tp -> OffsetSpec.latest()));
var ends = admin.listOffsets(latest).all().get();
committed.forEach((tp, om) ->
System.out.printf("%s lag=%d%n", tp, ends.get(tp).offset() - om.offset()));
}
- Cảnh báo tốt: lag theo thời gian vượt SLO trong 5 phút liên tục, và lag vượt 50% retention (sắp mất dữ liệu).
5. Tác vụ chạy lâu: async, chỉnh liveness, pipeline
Ý chính: consumer nên xử lý càng nhanh càng tốt. Khi một record cần vài phút (báo cáo, job ML, hồ sơ vay), có ba cách: xử lý bất đồng bộ, nới tham số liveness, hoặc chia thành pipeline nhiều stage.
Vấn đề: consumer bị coi là chết khi không gọi poll() trong max.poll.interval.ms (mặc định 5 phút), hoặc không gửi heartbeat trong session.timeout.ms (mặc định 45 giây). Bị coi là chết thì group rebalance, partition chuyển cho consumer khác, record đang xử lý dở bị xử lý lại, rồi consumer mới cũng chậm như vậy: vòng lặp rebalance. Cơ chế heartbeat, coordinator và số đo của vòng lặp này có trong bài consumer group, rebalance và liveness.
| Cách | Làm gì | Được | Mất |
|---|---|---|---|
| Async | poll, commit ngay, giao record cho thread pool | latency thấp, vòng poll đơn giản | at-most-once (crash là mất), khó xử lý lỗi, mất thứ tự |
| Chỉnh liveness | giảm max.poll.records (500), tăng max.poll.interval.ms |
không sửa code | mong manh: một record chậm bất thường là lại rebalance; phát hiện consumer treo chậm hơn |
| Pipeline | chia thành stage, mỗi stage là một consumer đọc topic của stage trước | at-least-once, theo dõi được từng stage, stage tách rời, trong một quy trình vẫn có thứ tự | nhiều topic hơn, các quy trình khác nhau xen kẽ nhau |
flowchart LR
C[(command topic)] --> S0[Stage 0: kiểm tra hồ sơ]
S0 --> T1[(stage-1 topic)]
T1 --> S1[Stage 1: chấm điểm]
S1 --> T2[(stage-2 topic)]
T2 --> S2[Stage 2: tạo hợp đồng]
Khoá học còn có biến thể gọn hơn: một Initializer đọc command topic và ghi stage đầu vào một stage topic chung; một Stage Processor đọc stage topic, làm một bước, rồi ghi stage kế tiếp vào chính topic đó cho tới khi xong.
Cách thứ tư: pause partition và xử lý ngoài vòng poll
Muốn giữ at-least-once mà không chia pipeline: poll một batch, gọi consumer.pause(assignment), giao batch cho worker thread, và vẫn gọi poll() định kỳ (trả về rỗng vì đang pause) để không vượt max.poll.interval.ms. Worker xong thì commit offset của batch đó từ thread poll (KafkaConsumer không thread-safe), rồi resume().
Cần xử lý onPartitionsRevoked: đợi worker xong hoặc huỷ, commit những gì đã xong, trước khi nhường partition. Spring Kafka có sẵn hỗ trợ tương tự; nếu tự viết thì đây là chỗ hay sai nhất.
Một lựa chọn khác cho job thật sự dài (hàng chục phút): Kafka chỉ chở lệnh, job ghi trạng thái vào DB (bảng job với status, attempt, heartbeat_at), và một scheduler riêng dọn job treo. Lúc đó Kafka không còn phải giữ consumer sống trong suốt job.
6. Poison pill, retry topic và dead letter topic
Ý chính: một record luôn lỗi (poison pill) mà consumer retry mãi sẽ làm kẹt partition, lag tăng không ngừng. Retry vài lần có backoff, rồi đẩy sang dead letter topic (DLT) để partition chạy tiếp. Phần này mình bổ sung, slide không có.
Hai loại lỗi cần tách:
- Lỗi tạm thời (DB timeout, API 503): retry có ích.
- Lỗi vĩnh viễn (không deserialize được, dữ liệu sai nghiệp vụ): retry vô ích, đẩy thẳng sang DLT.
Với client thuần (không Spring), record không deserialize được làm poll() ném lỗi ở cùng offset mãi cho tới khi bạn seek qua; xem bài consumer group.
| Kiểu retry | Cách làm | Thứ tự theo key | Khi nào dùng |
|---|---|---|---|
| Blocking | retry tại chỗ, backoff có trần, rồi DLT | giữ | cần thứ tự (sự kiện số dư) |
| Non-blocking | chuyển record sang orders-retry-1m, orders-retry-10m, rồi orders-dlt |
mất | độc lập giữa các record (gửi email) |
Spring Kafka: DefaultErrorHandler, @RetryableTopic và lỗi deserialize
Blocking retry rồi DLT:
@Bean
DefaultErrorHandler errorHandler(KafkaTemplate<Object, Object> template) {
var recoverer = new DeadLetterPublishingRecoverer(template); // gửi sang <topic>-dlt
var backoff = new ExponentialBackOffWithMaxRetries(3);
backoff.setInitialInterval(1_000);
backoff.setMultiplier(2.0);
var handler = new DefaultErrorHandler(recoverer, backoff);
handler.addNotRetryableExceptions(ValidationException.class); // lỗi vĩnh viễn: DLT ngay
return handler;
}
Non-blocking retry: @RetryableTopic(attempts = "4", backoff = @Backoff(delay = 60_000, multiplier = 10)) trên listener; Spring tự tạo các topic retry và DLT.
Poison pill do deserialize: lỗi xảy ra trong poll(), trước khi tới listener, nên consumer kẹt ở offset đó. Bọc deserializer thật bằng ErrorHandlingDeserializer để lỗi thành một record mang exception, error handler đẩy được nó sang DLT.
DLT cần chủ nhân: cảnh báo khi DLT có record, dashboard xem header lỗi (Spring thêm kafka_dlt-exception-message, topic và offset gốc), và công cụ replay record từ DLT về topic chính sau khi sửa lỗi.
7. Hot partition
Ý chính: key phân bố lệch (một merchant lớn, một tài khoản bot) dồn tải vào một partition; thêm partition không giúp vì key đó vẫn vào một chỗ. Phần này mình bổ sung.
- Phát hiện: bytes-in theo partition lệch hẳn, lag chỉ tăng ở một partition, một consumer CPU cao trong khi các consumer khác rảnh.
- Tách key nóng: thêm hậu tố (
merchant-42#0..7) để rải ra 8 partition. Mất thứ tự cho riêng key đó, nên chỉ làm khi thứ tự theo key ấy không cần, hoặc gộp lại ở bước sau. - Tách đường: đưa key nóng sang topic riêng có consumer riêng.
- Làm consumer nhanh hơn cho key đó: gom nhiều record cùng key thành một lần ghi DB.
Bài tập
Bài 1: Tính số partition
Topic user-click: đỉnh 200.000 sự kiện/giây, mỗi sự kiện 600 B sau nén, consumer chỉ ghi vào ClickHouse theo lô và một consumer xử lý được 30.000 sự kiện/giây. Topic loan-application: đỉnh 50 hồ sơ/giây, mỗi hồ sơ cần 2 giây xử lý. Tính số partition cho mỗi topic và chỉ ra rủi ro chính.
Lời giải Bài 1
user-click: phía ghi 200.000 × 600 B = 120 MB/s; với ~10 MB/s mỗi partition cần 12. Phía đọc 200.000 / 30.000 ≈ 6,7, cần 7. Lấy số lớn hơn là 12, dư cho tăng trưởng thành 24 (chia hết cho 2, 3, 4, 6, 8, 12). Rủi ro: broker và đĩa (120 MB/s × RF 3 = 360 MB/s ghi trong cluster), không phải số partition.
loan-application: một consumer xử lý tuần tự được 0,5 hồ sơ/giây, cần 50 / 0,5 = 100 consumer song song, tức 100 partition: quá nhiều cho 50 msg/s. Đây là tác vụ chạy lâu: chia pipeline, hoặc để Kafka chở lệnh và chạy job trên worker pool riêng có trạng thái trong DB. Khi đó 8–12 partition là đủ.
Bài 2: Lag tăng lúc 2 giờ sáng
Mỗi đêm lúc 2:00, lag topic payment-events tăng từ 0 lên 400.000 trong 20 phút rồi giảm dần tới 4:00. Tốc độ produce không đổi. Liệt kê các giả thuyết theo thứ tự kiểm tra và metric để xác nhận mỗi giả thuyết.
Lời giải Bài 2
Produce không đổi nên nghi phía consumer và phụ thuộc của nó:
- Job batch đêm tranh DB (backup, báo cáo,
VACUUM): xem latency query của consumer và tải DB lúc 2:00. - Rebalance liên tục: xem log
Revoke/Assignvà metricrebalance-rate-per-hour; có thể do deploy tự động hoặc tác vụ dài vượtmax.poll.interval.ms. - GC pause dài: GC log,
jvm_gc_pause_secondslúc 2:00 (ví dụ do cache được nạp lại). - Phụ thuộc ngoài chậm (ngân hàng đối tác bảo trì đêm): latency gọi API theo giờ.
Chỉ khi cả bốn đều sạch mới tính tăng consumer. Đồng thời kiểm tra 400.000 record còn xa retention để chắc không mất dữ liệu.
Ghi nhớ
- Tính được số partition cho một topic từ throughput ghi, throughput đọc đã load test, và giải thích vì sao chọn số chia hết nhiều.
- Kể được các bước giảm partition bằng topic mới và chỗ consumer có thể đọc trùng.
- Giải thích được vì sao claim check tốt hơn nâng
max.message.bytes. - Biết đo lag theo số và theo thời gian, và thứ tự tìm nguyên nhân trước khi scale.
- So sánh được ba cách xử lý tác vụ dài, và biết poison pill cần retry có trần rồi DLT.
Câu hỏi phỏng vấn
Junior
Consumer lag là gì và đo thế nào?
Là khoảng cách giữa offset cuối của partition và offset group đã commit; đo bằng kafka-consumer-groups --describe hoặc metric records-lag-max.
Nên theo dõi thêm lag theo thời gian (số giây consumer chậm hơn producer) vì nó dễ đặt SLO. Lag vượt retention nghĩa là sắp mất dữ liệu.
Có giảm số partition của một topic được không?
Không. Phải tạo topic mới nhỏ hơn, sao chép dữ liệu (MirrorMaker 2), rồi chuyển producer và consumer sang.
Khi chuyển consumer, chọn rõ điểm bắt đầu trên topic mới (latest, earliest, hoặc timestamp lúc cắt) và chấp nhận đọc trùng một đoạn, nên consumer phải idempotent.
Mid
Cần gửi file 50 MB qua Kafka, bạn làm thế nào?
Dùng claim check: tải file lên object storage, gửi message chứa object key, kích thước và checksum.
Nâng max.message.bytes lên tới ~10 MB vẫn là anti-pattern: replication chậm, consumer tốn bộ nhớ, record to chặn record nhỏ phía sau. Tải file lên trước rồi mới gửi message, và đặt lifecycle rule để dọn file mồ côi.
Lag tăng, bạn có thêm consumer ngay không?
Không. Tìm nguyên nhân trước: produce tăng đột biến, xử lý mỗi record chậm đi, rebalance liên tục, GC.
Thêm consumer chỉ giúp khi consumer là nút cổ chai và còn partition chưa có người đọc. Nếu DB phía sau đang nghẽn, thêm consumer làm DB tệ hơn.
Record nào đó luôn làm consumer ném exception. Chuyện gì xảy ra và xử lý thế nào?
Nếu retry vô hạn, partition đó kẹt ở offset ấy và lag tăng mãi. Retry vài lần có backoff rồi đẩy sang dead letter topic.
Tách lỗi tạm thời (retry) với lỗi vĩnh viễn (DLT ngay). Lỗi deserialize xảy ra trước listener nên phải bọc bằng ErrorHandlingDeserializer. DLT cần cảnh báo và công cụ replay.
Senior
Bạn chọn số partition cho topic thanh toán mới thế nào?
Tính theo cả hai chiều rồi lấy số lớn hơn: throughput ghi / ~10 MB/s mỗi partition, và TPS đỉnh / TPS một consumer đo bằng load test. Sau đó dư khoảng 2 lần cho tăng trưởng.
Topic thanh toán thường nghẽn ở phía đọc (DB, ledger), nên load test quyết định. Vì cần thứ tự theo tài khoản, mình cấp dư từ đầu để không phải tăng sau này, tránh xáo key. Chọn số như 12, 16, 24 để chia đều cho số instance.
Một consumer cần 6–10 phút cho mỗi record. Thiết kế thế nào?
Không để Kafka giữ consumer sống suốt job: chia pipeline nhiều stage ngắn, hoặc để Kafka chở lệnh còn job chạy trên worker có trạng thái trong DB.
Chỉnh max.poll.interval.ms và max.poll.records=1 chạy được nhưng mong manh, và chặn cả partition trong lúc xử lý. Async commit-trước thì mất at-least-once. Cách pause partition rồi poll định kỳ giữ được at-least-once nhưng phải xử lý revoke cẩn thận.
Một merchant chiếm 40% lưu lượng và partition của nó luôn lag. Bạn xử lý thế nào?
Đây là hot partition do key lệch; thêm partition không giúp. Tách key nóng (thêm hậu tố để rải ra nhiều partition) hoặc đưa nó sang topic và consumer riêng.
Rải key làm mất thứ tự cho merchant đó, nên hỏi nghiệp vụ trước: nếu cần thứ tự theo đơn hàng thay vì theo merchant, đổi key thành order_id. Ngoài ra gom ghi theo lô cho key nóng để consumer nhanh hơn.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu tiếng Anh dùng trong phỏng vấn |
|---|---|---|---|
| topic width | /ˈtɒpɪk wɪdθ/ | số partition của topic | “Topic width is a one-way decision: you can grow it but never shrink it.” |
| over-provision | /ˌəʊvə prəˈvɪʒn/ | cấp dư | “We over-provision partitions for keyed topics to avoid re-hashing later.” |
| claim check | /kleɪm tʃek/ | gửi tham chiếu thay cho payload | “Large files go to S3; the event only carries a claim check.” |
| consumer lag | /kənˈsjuːmə læɡ/ | độ tụt của consumer | “We alert on time lag, not just offset lag.” |
| root cause | /ruːt kɔːz/ | nguyên nhân gốc | “Find the root cause before scaling the consumer group.” |
| long-running task | /lɒŋ ˈrʌnɪŋ tɑːsk/ | tác vụ chạy lâu | “Long-running tasks belong in a pipeline, not in one poll loop.” |
| liveness | /ˈlaɪvnəs/ | dấu hiệu còn sống | “Consumer liveness is judged by heartbeats and by poll intervals.” |
| poison pill | /ˈpɔɪzn pɪl/ | record luôn gây lỗi | “A poison pill blocks the partition until we move it to the dead letter topic.” |
| dead letter topic | /ded ˈletə ˈtɒpɪk/ | topic chứa record lỗi | “Every dead letter topic needs an owner, an alert and a replay tool.” |
| hot partition | /hɒt pɑːˈtɪʃn/ | partition bị dồn tải | “A skewed key created a hot partition.” |
| skewed | /skjuːd/ | lệch | “The key distribution is heavily skewed toward one merchant.” |
Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.