Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
Kafka trong thực tế (1): số partition, message lớn, lag và tác vụ chạy lâu
1Chọn số partition
Số partition = throughput mong muốn / throughput một partition, tính cho cả phía ghi và phía đọc, lấy số lớn hơn rồi chừa chỗ tăng trưởng.
Phía
Topic thanh toán, đỉnh 5.000 msg/s
Cần
Ghi
5.000 × 500 B = 2,5 MB/s
1 partition
Đọc
1 consumer xử lý 400 msg/s
13 consumer
Chọn
Dư cho tăng trưởng, chia đều
16
2Giảm partition: chuyển topic
Partition chỉ tăng, và tăng làm đổi partition của key (murmur2(key) % số_partition). Muốn giảm thì tạo topic mới rồi chuyển dần.
flowchart TD
A["Tạo topic mới đúng kích thước"] --> B["Sao chép bằng MirrorMaker 2"]
B --> C["Bản sao đuổi kịp: cắt"]
C --> D["Producer ghi topic mới"]
D --> E["Consumer chọn rõ điểm bắt đầu"]
3Message lớn: claim check
Giới hạn mặc định một record khoảng 1 MB. Đừng nâng lên 10 MB; đưa file lên object storage và chỉ gửi tham chiếu.
Tải file lên S3 trước, xong mới gửi message
Message chứa object key, kích thước, checksum
Lifecycle rule trên bucket dọn file mồ côi
File 1–5 MB: thử nén zstd trước
4Lag: đo trước, scale sau
Lag = offset cuối của partition trừ offset group đã commit. Lag vượt retention là mất dữ liệu. Tìm nguyên nhân trước khi thêm consumer.
flowchart TD
A["Lag tăng"] --> B{"Produce tăng đột biến?"}
B -- có --> C["Chờ, kiểm retention"]
B -- không --> D{"Xử lý mỗi record chậm đi?"}
D -- có --> E["Sửa DB, API, GC"]
D -- không --> F["Scale consumer, partition"]
5Tác vụ chạy lâu
Không gọi poll() trong max.poll.interval.ms (mặc định 5 phút) là bị coi là chết, group rebalance, record bị xử lý lại.
Cách
Được
Mất
Async, commit ngay
Latency thấp
Crash là mất, mất thứ tự
Chỉnh liveness
Không sửa code
Mong manh
Pipeline nhiều stage
At-least-once, theo dõi từng stage
Nhiều topic hơn
6Poison pill và DLT
Một record luôn lỗi mà retry mãi sẽ kẹt cả partition. Retry có trần và backoff, rồi đẩy sang dead letter topic.
var dlt = new DeadLetterPublishingRecoverer(tpl);
var bo = new ExponentialBackOffWithMaxRetries(3);
bo.setInitialInterval(1_000);
var h = new DefaultErrorHandler(dlt, bo);
// lỗi vĩnh viễn: vào DLT ngay
h.addNotRetryableExceptions(
ValidationException.class);
💡 Ghi nhớ
Tính partition cho cả phía ghi lẫn đọc, lấy số lớn hơn.
Partition chỉ tăng; tăng là xáo key, mất thứ tự.
Scale consumer bị chặn bởi số partition.
Lỗi tạm thời thì retry, lỗi vĩnh viễn thì DLT ngay.
⭐ Điểm phỏng vấn
Tự trả lời trước, rồi bấm từng câu để xem đáp án.
Giảm số partition được không?
Không; tạo topic mới, sao chép, chuyển dần.
Gửi file 50 MB qua Kafka?
Claim check: lên S3, Kafka chở tham chiếu.
Mỗi record cần 6–10 phút?
Chia pipeline nhiều stage, hoặc Kafka chỉ chở lệnh.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Thêm consumer khi nút cổ chai là DB: DB còn chậm hơn.
Tăng session.timeout.ms cho tác vụ dài; giới hạn thật là max.poll.interval.ms.
Group mới trên topic mới quên điểm bắt đầu, latest bỏ qua dữ liệu đã chép.
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.
earliest hoặ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.
Cách 1, nâng giới hạn: max.message.bytes (topic), message.max.bytes (broker), cộng max.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 payment in CURRENT-OFFSET, LOG-END-OFFSET, LAG cho 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.
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:
@BeanDefaultErrorHandler 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/Assign và metric rebalance-rate-per-hour; có thể do deploy tự động hoặc tác vụ dài vượt max.poll.interval.ms.
GC pause dài: GC log, jvm_gc_pause_seconds lú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.
Một broker chứa được bao nhiêu partition? Có nên tạo thật nhiều partition cho chắc?
Không có giới hạn cứng, nhưng mỗi partition replica tốn file handle, bộ nhớ và công replicate trên broker; hướng dẫn cũ thời ZooKeeper là khoảng 4.000 partition mỗi broker, 200.000 mỗi cluster. Tạo dư vài lần nhu cầu là đủ, không tạo hàng nghìn “cho chắc”.
Mỗi partition là một thư mục với nhiều segment, mỗi segment có file .log, .index, .timeindex: số file mở tăng theo partition × segment.
Nhiều partition hơn: producer chia batch mỏng hơn (giảm hiệu quả nén và batching), failover phải bầu nhiều leader hơn, rebalance của consumer lâu hơn.
KRaft (bắt buộc từ Kafka 4.0, không còn ZooKeeper) làm metadata và failover nhanh hơn nhiều, nới giới hạn cấp cluster; chi phí trên từng broker vẫn còn.
Partition thuộc topic, được rải lên các broker; một broker giữ partition của nhiều topic, vừa leader của cái này vừa follower của cái kia.
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.