Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

System DesignSenior19 phút đọc

Kafka consumer group bên trong: rebalance, assignor, static membership và liveness

Ôn 15 thẻ
Trong bài này

Cụm bài Kafka bên trong: 1. Producer bên trong · 2. Serialization và Schema Registry · 3. Consumer group, rebalance và liveness

Consumer group là cách Kafka chia partition cho nhiều consumer và chia lại khi có người vào, ra hay chết. Bài này đi vào giao thức bên dưới, đo cái giá của từng cách chia, và giải thích hai câu hỏi liveness: “consumer còn sống không?” và “nó còn làm việc không?”. Bài cấu hình Kafka theo mục tiêu có bảng tham số; ở đây là cơ chế và số đo.

1. Coordinator và group leader

Ý chính: coordinator là một broker, quản lý thành viên, offset và liveness của group. Ở giao thức cũ (classic), việc tính “ai giữ partition nào” lại do một consumer làm: group leader.

  • Tìm coordinator: consumer hỏi FindCoordinator(group.id); câu trả lời là broker đang làm leader của partition hash(group.id) % 50 trong topic nội bộ __consumer_offsets (50 là offsets.topic.num.partitions). Mọi broker đều làm coordinator cho một phần các group.
  • Group leader (classic): thường là consumer vào group đầu tiên. Nó nhận danh sách thành viên và đăng ký của họ, chạy assignor, gửi kết quả cho coordinator.
  • Vì sao tính ở client: thêm hay đổi chiến lược chia (kể cả assignor tự viết) không cần nâng cấp broker. KIP-848 đảo lại quyết định này (mục 5).

2. Giao thức classic: JoinGroup, SyncGroup và eager rebalance

Ý chính: rebalance classic có hai pha: mọi thành viên gửi JoinGroup (khai báo topic và assignor), leader tính phân chia; rồi mọi thành viên gửi SyncGroup để nhận phần của mình. Giữa hai pha, ở chế độ eager, không ai giữ partition nào.

sequenceDiagram
  participant C0 as Consumer 0 (leader)
  participant C1 as Consumer 1
  participant GC as Coordinator
  C0->>GC: JoinGroup(topics, assignors)
  C1->>GC: JoinGroup(topics, assignors)
  GC-->>C0: bạn là leader, danh sách thành viên
  GC-->>C1: leader là C0
  C0->>C0: chạy assignor
  C0->>GC: SyncGroup(phân chia cho mọi người)
  C1->>GC: SyncGroup()
  GC-->>C0: phần của C0
  GC-->>C1: phần của C1
  • Mỗi lần rebalance xong, group có generation mới (số thế hệ). Commit offset mang generation cũ bị từ chối: đó là cách Kafka chặn consumer đã bị đá commit đè lên người mới.
  • Eager: trước khi JoinGroup, mọi consumer gọi onPartitionsRevoked cho toàn bộ partition đang giữ. Cả group dừng tới khi SyncGroup xong (“stop-the-world”).
  • Rebalance xảy ra khi: consumer vào, ra (đóng hoặc bị đá), đổi subscription, topic thêm partition, hoặc topic khớp regex mới xuất hiện.

3. Assignor: đo bốn cách chia

Ý chính: chọn assignor là cân giữa chia đều, ít di chuyển partition và ít dừng. Cooperative-sticky (hoặc KIP-848) tốt nhất cho hầu hết trường hợp; range còn cần khi phải đồng phân vùng (co-partitioning) hai topic.

Lab trên Kafka 4.3.2, client Java 4.1.1: hai topic A và B, mỗi topic 3 partition. Khởi động c1, sau 4 giây thêm c2, sau 6 giây thêm c3.

Assignor c1 + c2 c1 + c2 + c3 Lần thu hồi (c1 / c2) Partition đổi chủ khi thêm c3
Range (eager) c1: A0 A1 B0 B1, c2: A2 B2 (4/2) 2/2/2 10 / 2 4
RoundRobin (eager) 3/3 2/2/2 9 / 3 4
CooperativeSticky 3/3 2/2/2 4 / 1 2
KIP-848 (uniform) c1: A0–A2, c2: B0–B2 2/2/2 4 / 1 2

Đọc bảng:

  • Range chia từng topic riêng, và consumer đứng đầu (theo thứ tự member id) nhận phần dư của mỗi topic. Nhiều topic thì phần dư cộng dồn vào cùng một consumer: 4/2 thay vì 3/3.
  • Ở eager, c1 thu hồi 6 rồi 4 partition (tổng 10), dù lần thêm c3 chỉ cần chuyển 2 partition. Range còn xáo trộn: c2 mất A2, B2 nhưng lại nhận A1, B1.
  • Cooperative-sticky giữ nguyên gần hết: khi c3 vào, chỉ A1 (của c1) và B2 (của c2) đổi chủ. Log cho thấy hai vòng cách nhau khoảng 3 giây: vòng 1 thu hồi, vòng 2 giao cho c3.
ConsumerRebalanceListener: commit ở đâu, và revoked khác lost thế nào
consumer.subscribe(List.of("orders"), new ConsumerRebalanceListener() {
  public void onPartitionsRevoked(Collection<TopicPartition> parts) {
    // còn là thành viên hợp lệ: commit phần đã xử lý xong của các partition sắp mất
    consumer.commitSync(currentOffsets(parts));
  }
  public void onPartitionsAssigned(Collection<TopicPartition> parts) {
    // nạp state cục bộ, hoặc seek tới offset lưu ngoài Kafka (ví dụ trong DB cùng transaction)
  }
  public void onPartitionsLost(Collection<TopicPartition> parts) {
    // đã bị đá: partition có thể đang ở người khác, KHÔNG commit, chỉ dọn tài nguyên
  }
});
  • Với eager, onPartitionsRevoked nhận mọi partition; với cooperative, chỉ nhận partition thật sự phải chuyển (lab: c1 chỉ nhận [A1]).
  • onPartitionsLost được gọi khi consumer phát hiện mình không còn trong group (hết session, quá max.poll.interval.ms). Commit ở đây sẽ thất bại, hoặc tệ hơn là đè offset của chủ mới nếu có lỗi logic.
  • Các callback chạy trên thread gọi poll(), nên giữ chúng ngắn: rebalance của cả group chờ callback chậm nhất.
  • Spring Kafka: container tự commit offset đang chờ khi bị thu hồi (với AckMode mặc định BATCH); muốn can thiệp thì cấu hình ConsumerAwareRebalanceListener.

4. Static membership: restart không gây rebalance

Ý chính: đặt group.instance.id cố định cho mỗi instance (ví dụ tên pod) thì coordinator nhớ phần partition của nó. Instance quay lại trong session.timeout.ms sẽ nhận lại đúng phần cũ, không ai khác bị ảnh hưởng.

Lab (classic, cooperative-sticky, session.timeout.ms=20000, hai instance pod-1 và pod-2):

Bước Kết quả
pod-2 tắt 5 giây rồi bật lại pod-2 nhận lại đúng [A1, B0, B2]; pod-1 bị thu hồi 0 partition
pod-2 tắt 25 giây (quá session timeout) Sau khoảng 22,8 giây pod-1 nhận thêm [A1, B0, B2]

Member động (không có group.instance.id) khi đóng sẽ gửi LeaveGroup và gây rebalance ngay; member tĩnh không gửi, coordinator chờ hết session timeout.

5. KIP-848: giao thức consumer mới

Ý chính: từ Kafka 4.0, đặt group.protocol=consumer thì broker tính phân chia và gửi cho từng consumer qua heartbeat. Không còn group leader, không còn JoinGroup/SyncGroup, không còn rào chắn bắt cả group chờ nhau.

Classic KIP-848 (group.protocol=consumer)
Ai tính phân chia Group leader (client) Coordinator (broker), group.remote.assignor = uniform (mặc định) hoặc range
Cơ chế JoinGroup + SyncGroup, mọi người chờ nhau Heartbeat mang “phần đích”; mỗi consumer tự thả rồi nhận dần
Một consumer chậm Làm chậm rebalance của cả group Chỉ chậm phần của nó
Heartbeat, session Client đặt heartbeat.interval.ms, session.timeout.ms Broker đặt group.consumer.heartbeat.interval.ms (5 s), group.consumer.session.timeout.ms (45 s)

Lab ở bảng mục 3: KIP-848 cho cùng số lần thu hồi như cooperative-sticky (4 / 1), không cần cấu hình assignor phía client. max.poll.interval.ms vẫn là cấu hình phía client.

6. Liveness: còn sống và còn làm việc

Ý chính: Kafka kiểm hai điều khác nhau. Heartbeat (thread nền) trả lời “process còn sống không”; khoảng cách giữa hai lần poll() trả lời “nó còn tiến lên không”. Hỏng một trong hai là bị đá khỏi group.

Liveness (điều tốt rồi sẽ xảy ra: record rồi sẽ được xử lý) đi cùng safety (điều xấu không bao giờ xảy ra). Slide ghi safety là “ít nhất một consumer cho mỗi partition”; đúng phải là nhiều nhất một consumer trong group giữ một partition, cộng thứ tự trong partition được giữ.

Kiểm tra Ai làm Tham số (mặc định) Hỏng khi
Còn sống Heartbeat thread gửi tới coordinator heartbeat.interval.ms 3 s, session.timeout.ms 45 s Process chết, mạng đứt, GC dừng quá lâu
Còn làm việc Client tự đo giữa hai lần poll() max.poll.interval.ms 300 s, max.poll.records 500 Xử lý một lần poll quá lâu, thread xử lý bị treo

Quy tắc: session.timeout.ms ≥ 3 × heartbeat.interval.ms (mất hai heartbeat liên tiếp chưa bị coi là chết). Đặt cả hai quá nhỏ làm broker bận và gây báo động giả.

Lab vòng lặp vô tận (classic, max.poll.interval.ms=4000, max.poll.records=5, mỗi record xử lý 1,2 s, tức 6 s mỗi lần poll):

[  287 ms] poll -> 5 records from offset 0; processing 1.2 s each
[ 6295 ms] commitSync FAILED: CommitFailedException ... consumer was kicked out of the group
[ 6296 ms] LOST [lv-slow-0]
[ 6303 ms] assigned [lv-slow-0]
[ 6309 ms] poll -> 5 records from offset 0; processing 1.2 s each
[12315 ms] commitSync FAILED: CommitFailedException ...

Ba vòng liền, consumer xử lý lại đúng 5 record từ offset 0. Heartbeat vẫn đều nên nhìn từ ngoài, consumer “khỏe”; lag không giảm, và mọi side effect bị lặp lại.

Cùng kịch bản với KIP-848, và static member khi quá hạn poll

Chạy lại lab với group.protocol=consumer (hai lần, cùng kết quả): commit sau 6 giây thành công, rồi partition bị báo LOST, consumer tham gia lại và đọc tiếp từ offset 5, không xử lý lại. Mình đoán lý do là trong lab group chỉ có một thành viên: khi nó rời, group rỗng và broker chấp nhận commit. Với group có thành viên khác đã nhận partition, commit này nhiều khả năng bị từ chối. Mình không dựa vào hành vi này; công thức ở pitfall trên vẫn là cách đúng.

Static member (group.instance.id) quá max.poll.interval.ms thì không gửi LeaveGroup như member động. Coordinator chỉ phát hiện khi hết session.timeout.ms. Trong khoảng đó, partition không được ai xử lý tiến lên.

Đo nhanh trong production: metric time-between-poll-avg / time-between-poll-max và last-poll-seconds-ago của consumer (nhóm consumer-metrics). time-between-poll-max chạm gần max.poll.interval.ms là cảnh báo sớm trước khi vòng lặp bắt đầu.

7. Poison pill ở mức client

Ý chính: poison pill là record mà consumer không bao giờ xử lý được. Nếu không có cơ chế bỏ qua, consumer kẹt ở đúng offset đó mãi, cả partition đứng.

Hai loại:

  • Lỗi deserialize: byte không đúng format. Với client thuần, poll() ném RecordDeserializationException (có topicPartition() và offset()), và lần poll sau ném lại đúng lỗi đó, vì vị trí đọc không tiến.
  • Lỗi xử lý: deserialize được nhưng logic nghiệp vụ ném exception (dữ liệu sai, vi phạm ràng buộc).

Lab: topic có 3 record, record ở offset 1 là 5 byte rác thay vì số nguyên 4 byte. Consumer đọc được offset 0, rồi ba lần poll liền ném RecordDeserializationException at lv-poison-0 offset 1. Sau khi seek(partition, 2), nó đọc tiếp offset 2.

try {
  for (var r : consumer.poll(Duration.ofMillis(500))) handle(r);
  consumer.commitSync();
} catch (RecordDeserializationException e) {
  deadLetter.send(e.topicPartition(), e.offset(), e);   // ghi lại để điều tra
  consumer.seek(e.topicPartition(), e.offset() + 1);    // bỏ qua record hỏng
}

Với Spring Kafka, ErrorHandlingDeserializer + DefaultErrorHandler + DeadLetterPublishingRecoverer làm việc này (xem bài 2 và bài tác vụ chạy lâu).

Bài tập

Bài 1: Rolling deploy làm lag tăng vọt

Service có 20 pod, mỗi pod một consumer, group đọc topic 60 partition, assignor mặc định, mỗi pod restart mất khoảng 40 giây. Mỗi lần deploy, lag tăng vọt trong 10 phút. Giải thích và đề xuất.

Lời giải Bài 1

Vì sao: assignor mặc định [Range, CooperativeSticky] nghĩa là range với eager rebalance. Mỗi pod tắt gây một rebalance (member động gửi LeaveGroup), bật lại gây thêm một: khoảng 40 lần stop-the-world, mỗi lần mọi consumer trả hết partition, có thể mất vài giây tới hàng chục giây nếu có consumer xử lý batch dài (rebalance phải chờ nó gọi poll).

Đề xuất theo thứ tự:

  1. Nếu broker và client đều 4.x: group.protocol=consumer. Không rào chắn, mỗi pod chỉ ảnh hưởng phần của nó.
  2. Nếu còn classic: chuyển sang CooperativeStickyAssignor (hai lượt rolling deploy).
  3. Static membership: group.instance.id=${POD_NAME} (StatefulSet để tên ổn định), session.timeout.ms khoảng 60 s (lớn hơn 40 s restart). Pod restart trong 60 s thì không rebalance.
  4. Giảm thời gian rebalance còn lại: max.poll.records nhỏ để consumer gọi poll thường xuyên, tắt gọn (consumer.wakeup() + close()) để commit trước khi rời.

Đo trước và sau bằng số lần rebalance (rebalance-total trong consumer-coordinator-metrics) và lag p99 trong lúc deploy.

Bài 2: Chọn max.poll.records

Consumer gọi API bên ngoài cho mỗi record: p50 120 ms, p99 1,5 s, timeout của API 5 s. max.poll.interval.ms mặc định. Chọn max.poll.records và giải thích vì sao không dùng p50.

Lời giải Bài 2

Trường hợp xấu là cả batch gặp record chậm, nên tính theo timeout của API (5 s, trần thật của một record), không theo p50:

  • Theo timeout: 300 s / 5 s = 60 record; biên an toàn 2 lần → 30.
  • Theo p99: 300 / 1,5 / 2 = 100. Nhưng khi API bên ngoài gặp sự cố, mọi record đều chạm timeout 5 s, và 100 × 5 s = 500 s > 300 s: vòng lặp xử lý lại bắt đầu đúng lúc hệ thống đang yếu nhất.
  • p50 cho 1.250 record, sai hoàn toàn.

Chọn 30. Nếu throughput không đủ, đừng tăng records: xử lý song song trong một batch (giữ thứ tự theo key), hoặc tách việc gọi API ra hàng đợi riêng.

Ghi nhớ

  • Giải thích được coordinator được chọn thế nào và vì sao classic để client tính phân chia.
  • Kể được cái giá của eager rebalance bằng số đo: 10 lần thu hồi so với 4 lần.
  • Biết range chia theo từng topic, và khi nào vẫn cần range.
  • Biết static membership đổi gì lấy gì, và session timeout nên đặt bao nhiêu.
  • Phân biệt được heartbeat và max.poll.interval.ms, và tính được max.poll.records an toàn.

Câu hỏi phỏng vấn

Junior

Hai consumer cùng group có đọc cùng một partition không?

Không: trong một group, mỗi partition chỉ thuộc nhiều nhất một consumer. Consumer nhiều hơn partition thì có consumer ngồi không.

Hai group khác nhau thì độc lập, mỗi group đọc đủ dữ liệu.

Khi nào consumer group rebalance?

Khi có consumer vào, ra hoặc bị coi là chết (mất heartbeat, quá max.poll.interval.ms), khi đổi subscription, hoặc khi topic thêm partition.

Static membership làm việc restart nhanh không còn là “ra rồi vào”.

Mid

Eager và cooperative rebalance khác nhau thế nào về số đo?

Eager thu hồi mọi partition của mọi consumer mỗi lần; cooperative chỉ thu hồi phần phải chuyển, qua hai vòng.

Lab 6 partition, thêm hai consumer: eager (range) thu hồi 10 partition ở consumer đầu, cooperative-sticky chỉ 4. Khi thêm consumer thứ ba, cooperative chỉ chuyển 2 partition.

Heartbeat và max.poll.interval.ms khác nhau thế nào?

Heartbeat chứng minh process còn sống, chạy ở thread nền; max.poll.interval.ms chứng minh vòng xử lý còn tiến, đo giữa hai lần poll().

Process sống nhưng kẹt trong xử lý vẫn heartbeat đều, chỉ kiểm tra poll mới bắt được. Vì vậy tăng session.timeout.ms không cứu được batch xử lý lâu.

Commit offset trong onPartitionsLost có được không?

Không nên: lúc đó consumer đã bị đá, partition có thể đã thuộc người khác, commit sẽ thất bại hoặc đè lên tiến độ của chủ mới.

Commit thuộc về onPartitionsRevoked, khi consumer vẫn là thành viên hợp lệ. onPartitionsLost chỉ dọn tài nguyên.

Senior

KIP-848 thay đổi gì so với giao thức classic?

Broker tính phân chia và gửi qua heartbeat; không còn group leader, không còn JoinGroup/SyncGroup và rào chắn toàn group; mỗi consumer thả và nhận partition dần.

Hệ quả: một consumer chậm không kéo cả group; heartbeat và session timeout cấu hình ở broker; assignor chọn bằng group.remote.assignor. Cần broker và client 4.0+.

Thiết kế consumer group cho rolling deploy 50 pod không làm lag tăng.

KIP-848 nếu có thể; nếu không thì cooperative-sticky cộng static membership với session timeout lớn hơn thời gian restart một pod.

Thêm: tắt gọn để commit trước khi rời, max.poll.records đủ nhỏ để rebalance không chờ batch dài, và đo rebalance-total cùng lag trong lúc deploy để chứng minh.

Consumer không lỗi, heartbeat đều, nhưng lag không giảm và side effect bị lặp. Bạn nghi gì?

Vòng lặp quá max.poll.interval.ms: bị đá, commit thất bại, nhận lại cùng batch và xử lý lại mãi.

Kiểm time-between-poll-max và log CommitFailedException. Sửa bằng cách giảm max.poll.records theo thời gian xử lý tệ nhất, hoặc đưa xử lý dài ra khỏi vòng poll.

Bạn xử lý poison pill thế nào mà vẫn giữ thứ tự theo key?

Phân loại lỗi: tạm thời thì retry, vĩnh viễn thì đưa vào DLT; với luồng cần thứ tự, chặn cả key đó và đưa các event sau của cùng key vào DLT theo.

Bỏ qua đơn thuần thì partition chạy tiếp nhưng thứ tự theo key vỡ; dừng partition thì giữ thứ tự nhưng một record xấu chặn mọi key khác. Chọn theo nghiệp vụ.

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
group coordinator /ɡruːp koʊˈɔːr.dən.eɪ.t̬ɚ/ broker quản lý group “The group coordinator is the leader of the group’s offsets partition.”
rebalance /ˌriːˈbæl.əns/ chia lại partition “Every pod restart triggered a rebalance before we added static membership.”
stop-the-world /stɑːp ðə wɝːld/ dừng toàn bộ “Eager rebalancing is stop-the-world for the whole group.”
incremental /ˌɪŋ.krəˈmen.t̬əl/ từng phần “Cooperative rebalancing is incremental; only moved partitions are revoked.”
assignor /əˈsaɪ.nɚ/ bộ chia partition “The range assignor works per topic, so remainders pile up on one consumer.”
static membership /ˈstæt̬.ɪk ˈmem.bɚ.ʃɪp/ thành viên tĩnh “With static membership a quick restart keeps the same partitions.”
liveness /ˈlaɪv.nəs/ tính sống, tiến triển “Heartbeats prove the process is alive; polling proves it’s making progress.”
session timeout /ˈseʃ.ən ˈtaɪm.aʊt/ hạn mất heartbeat “Raising the session timeout doesn’t help a slow batch.”
poison pill /ˈpɔɪ.zən pɪl/ record không xử lý được “One poison pill blocked the partition until we seeked past it.”
generation /ˌdʒen.əˈreɪ.ʃən/ thế hệ của group “Commits with a stale generation are rejected.”

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.