Cụm bài Kafka bên trong: 1. Producer bên trong · 2. Serialization và Schema Registry · 3. Consumer group, rebalance và liveness
Bài vì sao Kafka nhanh và bền đã giải thích acks, ISR, batching và idempotent producer ở mức ý tưởng. Bài này mở nắp producer Java: send() thật sự làm gì, các con số đo được khi chỉnh linger.ms và nén, partitioner chọn partition thế nào, và transaction của Kafka chạy ra sao bên dưới. Đọc xong, bạn giải thích được vì sao send() có thể treo 60 giây và vì sao một transaction mở làm consumer read_committed đứng yên.
1. Đường đi của send()
Ý chính: send() chỉ đưa record vào hàng đợi trong RAM và trả về một Future. Việc gửi qua mạng do sender thread làm sau, theo từng batch cho mỗi partition.
flowchart LR
A["send(record)"] --> B["Serializer key/value"]
B --> C["Partitioner"]
C --> D["RecordAccumulator<br/>batch theo partition"]
D --> E["Sender thread<br/>gom batch theo broker"]
E --> F["Broker leader"]
F -- "ack" --> E
E -- "callback / Future" --> A
Từng bước, trên thread của bạn:
- Chờ metadata của topic (partition nào, leader ở đâu) nếu chưa có.
- Serialize key và value thành byte (bài 2 của cụm).
- Partitioner chọn partition (mục 3).
- Thêm record vào batch đang mở của partition đó trong RecordAccumulator. Batch đầy
batch.sizehoặc chờ đủlinger.msthì sẵn sàng gửi.
Sender thread gom các batch sẵn sàng theo broker: một request mang batch của nhiều partition cùng leader. Mỗi connection cho tối đa max.in.flight.requests.per.connection (mặc định 5) request chưa có ack.
Các tham số quanh accumulator và timeout của một lần gửi
| Tham số | Mặc định | Ý nghĩa |
|---|---|---|
buffer.memory |
32 MB | Tổng RAM cho các batch chưa gửi, chung cho mọi partition |
max.block.ms |
60.000 | Thời gian tối đa send() (và partitionsFor, initTransactions…) được chặn |
batch.size |
16.384 byte | Kích thước tối đa của một batch cho một partition |
linger.ms |
5 (từ Kafka 4.0, trước đó 0) | Chờ thêm để batch đầy hơn |
max.request.size |
1 MB | Request (và record) lớn nhất; record lớn hơn bị từ chối ngay ở client |
request.timeout.ms |
30.000 | Chờ phản hồi một request |
delivery.timeout.ms |
120.000 | Tổng thời gian từ send() tới khi báo thành công hay thất bại, gồm cả chờ trong accumulator và mọi lần retry |
Một record lớn hơn batch.size vẫn gửi được (nằm một mình trong batch riêng) miễn là nhỏ hơn max.request.size và message.max.bytes của broker.
Metric nên theo dõi (producer-metrics): record-queue-time-avg (record nằm chờ trong accumulator bao lâu), batch-size-avg, records-per-request-avg, compression-rate-avg, buffer-available-bytes, record-error-rate, request-latency-avg.
2. Batching và nén: số đo thật
Ý chính: linger.ms chỉ có tác dụng khi tải thấp hơn sức gửi; khi đó vài ms chờ giảm số request hàng chục lần. Nén tính trên cả batch nên batch càng đầy, tỉ lệ nén càng tốt.
Mình đo trên Kafka 4.3.2 (một broker KRaft chạy trên máy, client Java 4.1.1, JDK 21, acks=all). Mỗi record là một JSON đơn hàng 179 byte, gửi đều 5.000 record/giây trong 3 giây vào topic 3 partition:
linger.ms |
Số request | Record mỗi request | Batch trung bình | Thời gian tới ack (trung bình) |
|---|---|---|---|---|
| 0 | 14.333 | 1,0 | 263 B | 0,3 ms |
| 5 | 554 | 27,3 | 1.828 B | 3,0 ms |
| 20 | 147 | 104,9 | 6.856 B | 10,8 ms |
20 + lz4 |
147 | 104,9 | 1.698 B | 10,7 ms |
Đọc bảng: linger.ms=0 gần như gửi mỗi record một request. Thêm 5 ms giảm 26 lần số request, đổi lại mỗi record chờ thêm khoảng 3 ms. Đây là lý do Kafka 4.0 đổi mặc định từ 0 sang 5 (KIP-1030).
Khi ghi dồn hết tốc độ (200.000 record), batch tự đầy trước khi hết linger.ms, nên linger không còn ý nghĩa; lúc đó codec mới quyết định:
| Codec | Tỉ lệ nén (compression-rate-avg) |
Record mỗi request |
|---|---|---|
| none | 1,00 | 240 |
| lz4 | 0,21 | 264 |
| snappy | 0,19 | 725 |
| zstd | 0,09 | 840 |
| gzip | 0,10 | 1.342 |
batch.size tính trên dữ liệu đã nén (ước lượng), nên codec nén mạnh nhét được nhiều record hơn vào một batch 16 KB. Với JSON lặp cấu trúc, zstd và gzip nén còn khoảng 1/10; lz4 và snappy khoảng 1/5.
Vì sao bảng “ghi dồn” không dùng để so latency, và cách tự đo
Số “thời gian tới ack” khi ghi dồn phụ thuộc vào hàng đợi trong accumulator chứ không phải codec: 200.000 record được send() gần như cùng lúc, record cuối phải chờ cả trăm batch trước nó. Mình chỉ dùng bảng đó để so tỉ lệ nén và số record mỗi request. Muốn so latency phải gửi theo nhịp cố định (như bảng 5.000 msg/s) và đo phân vị (p99), không đo trung bình.
Công cụ có sẵn: kafka-producer-perf-test.sh --topic t --num-records 1000000 --record-size 200 --throughput 5000 --producer-props linger.ms=5 compression.type=lz4 in ra throughput và latency p50/p95/p99. Dùng payload thật của bạn (--payload-file), vì dữ liệu ngẫu nhiên gần như không nén được và làm mọi codec trông giống nhau.
Mọi số trong bài đo trên một broker chạy trên laptop, mạng loopback. Trên cluster thật với RTT 1–2 ms giữa máy, lợi ích của batching còn lớn hơn vì mỗi request tiết kiệm được là một lượt đi-về mạng.
3. Partitioner: chọn partition thế nào
Ý chính: thứ tự ưu tiên: partition chỉ định trong record → băm key (murmur2) → không key thì dính một partition tới khi đủ một batch rồi chuyển. Từ Kafka 3.3, phần “không key” còn tự né broker chậm.
Phần có key (murmur2, đổi số partition làm đổi chỗ key) đã có ở bài vì sao Kafka nhanh. Phần không key đi qua ba thế hệ:
| Thời kỳ | Cách chọn khi không có key | Hệ quả |
|---|---|---|
| Trước 2.4 | Round-robin từng record | Mỗi partition một batch nhỏ, nhiều request, latency cao |
| 2.4 (KIP-480) | Sticky: dính một partition tới khi batch đầy, rồi chọn ngẫu nhiên partition khác | Batch to, ít request |
| 3.3 (KIP-794) | Uniform sticky: chuyển sau khi gửi khoảng batch.size byte vào partition; nghiêng về broker có hàng đợi ngắn |
Phân bố đều hơn, né broker chậm |
Đo 30.000 record không key vào topic 3 partition: phân bố [11.666, 8.969, 9.365] với 94 lần đổi partition (trung bình 316 record liên tiếp vào cùng partition). “Đều” ở đây là đều dần theo thời gian, không phải đều từng record.
Adaptive partitioning và partitioner tự viết cho hot key
Uniform sticky đo độ dài hàng đợi của từng broker và chọn partition mới nghiêng về broker ít việc (partitioner.adaptive.partitioning.enable=true, mặc định). Thêm partitioner.availability.timeout.ms > 0 thì partition có broker không nhận batch quá thời gian đó sẽ bị bỏ qua tạm thời. Điều này chỉ áp dụng cho record không key; record có key luôn phải về đúng partition của nó.
Hot key (một key chiếm phần lớn traffic, ví dụ một merchant lớn) làm một partition quá tải. Hai cách thường dùng:
- Thêm hậu tố vào key:
merchantId + "#" + (orderId % 4), rải một key thành 4 partition. Đổi lại mất thứ tự giữa các đơn của merchant đó; chỉ làm được khi nghiệp vụ chấp nhận. - Partitioner riêng: dành sẵn vài partition cho tenant lớn, còn lại băm như thường.
public class TenantPartitioner implements Partitioner {
private static final Set<String> BIG = Set.of("merchant-42");
public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
int n = cluster.partitionCountForTopic(topic);
String k = (String) key;
if (BIG.contains(k)) return n - 1; // partition riêng cho tenant lớn
return Utils.toPositive(Utils.murmur2(keyBytes)) % (n - 1); // phần còn lại
}
public void close() {}
public void configure(Map<String, ?> configs) {}
}
Code này mình chưa chạy; nó minh hoạ hình dạng interface Partitioner của kafka-clients.
4. Retry: lỗi nào thử lại, thử bao lâu
Ý chính: producer tự retry lỗi tạm thời (mất leader, mạng chập chờn) trong giới hạn delivery.timeout.ms. Lỗi không thể retry (record quá lớn, sai cấu hình, không có quyền) trả về ngay cho callback.
| Loại | Ví dụ | Producer làm gì |
|---|---|---|
| Retriable | NOT_LEADER_OR_FOLLOWER, LEADER_NOT_AVAILABLE, NOT_ENOUGH_REPLICAS, timeout mạng |
Tự retry sau retry.backoff.ms (100 ms, tăng dần tới retry.backoff.max.ms 1 s) |
| Không retriable | RecordTooLargeException, InvalidTopicException, TopicAuthorizationException, SerializationException |
Báo lỗi ngay, ứng dụng phải xử lý |
Slide gợi ý retries=30. Mình không theo: retries mặc định đã là Integer.MAX_VALUE từ Kafka 2.1, và cái giới hạn thật là thời gian. Đếm số lần retry thì phụ thuộc backoff và độ dài sự cố, khó đoán. Hỏi “chịu mất leader tối đa bao lâu?” rồi đặt delivery.timeout.ms theo đó dễ hơn.
5. Transaction từ bên trong
Ý chính: transaction cho phép ghi nhiều partition (và commit offset) cùng thành công hoặc cùng huỷ. Nó dựa trên ba thứ: transactional.id cố định để fencing, transaction coordinator ghi nhật ký, và control marker trong từng partition để consumer biết record nào đã commit.
Bài dual write, exactly-once và thứ tự nói khi nào dùng transaction (luồng consume-transform-produce) và khi nào không đủ. Ở đây là cơ chế bên dưới.
sequenceDiagram
participant P as Producer
participant TC as Transaction coordinator
participant B as Partition leaders
P->>TC: InitProducerId(transactional.id)
TC-->>P: PID + epoch mới (instance cũ bị fence)
P->>TC: AddPartitionsToTxn(orders-0, payments-1)
P->>B: Produce batch (PID, epoch, sequence)
P->>TC: EndTxn(COMMIT)
TC->>TC: ghi PREPARE_COMMIT vào __transaction_state
TC->>B: WriteTxnMarkers(COMMIT)
TC->>TC: ghi COMPLETE_COMMIT
- Coordinator: broker giữ partition
hash(transactional.id) % 50của topic nội bộ__transaction_state. Nó lưu trạng thái transaction như một máy trạng thái, nên sống sót khi broker chết. - Control marker: một record đặc biệt (COMMIT hoặc ABORT) ghi vào mỗi partition tham gia. Nó chiếm một offset, ứng dụng không bao giờ thấy.
- LSO (last stable offset): offset đầu tiên còn thuộc một transaction đang mở. Consumer
read_committedchỉ đọc tới LSO; consumerread_uncommitted(mặc định) đọc tới high watermark, thấy cả record bị abort.
Lab trên Kafka 4.3.2, partition 0 của topic pl-tx: commit A1, A2; abort B1, B2; commit C1; mở transaction D1 và để đó.
| Consumer | Đọc được | Vị trí dừng |
|---|---|---|
read_uncommitted |
0:A1, 1:A2, 3:B1, 4:B2, 6:C1, 8:D1 | 9 |
read_committed |
0:A1, 1:A2, 6:C1 | 8 (LSO, kẹt trước D1) |
read_committed sau khi instance mới initTransactions() |
0:A1, 1:A2, 6:C1 | 10 (D1 đã bị abort) |
Offset 2, 5, 7, 9 là control marker: đó là lý do offset có “lỗ” mà slide Core Concepts nhắc. Instance mới cùng transactional.id gọi initTransactions() mất 216 ms, abort transaction dở của instance cũ. Instance cũ gửi tiếp thì nhận InvalidProducerEpochException: nó đã bị fence (chặn vì epoch cũ).
Code Java thuần của lab và cách làm tương đương trong Spring Kafka
Phần chính của lab (toàn bộ ở StickyTxLab.java):
Properties p = new Properties();
p.put("bootstrap.servers", "localhost:39092");
p.put("key.serializer", StringSerializer.class.getName());
p.put("value.serializer", StringSerializer.class.getName());
p.put("transactional.id", "lab-tx-1"); // tự bật idempotence, acks=all
var prod = new KafkaProducer<String, String>(p);
prod.initTransactions(); // lấy PID + epoch, fence instance cũ
prod.beginTransaction();
prod.send(new ProducerRecord<>("pl-tx", 0, "k", "A1"));
prod.send(new ProducerRecord<>("pl-tx", 0, "k", "A2"));
prod.commitTransaction();
prod.beginTransaction();
prod.send(new ProducerRecord<>("pl-tx", 0, "k", "B1-aborted"));
prod.flush();
prod.abortTransaction();
Xử lý lỗi theo tài liệu của KafkaProducer: ProducerFencedException, OutOfOrderSequenceException, AuthorizationException là lỗi không cứu được, phải close() producer. Các KafkaException khác thì abortTransaction() rồi thử lại cả transaction.
Spring Boot 3 (chưa chạy trong bài này):
spring:
kafka:
producer:
transaction-id-prefix: payment-tx- # bật transaction cho KafkaTemplate
consumer:
isolation-level: read_committed
enable-auto-commit: false
@Transactional("kafkaTransactionManager") // hoặc kafkaTemplate.executeInTransaction(t -> ...)
public void publish(OrderPaid e) {
kafkaTemplate.send("orders", e.orderId(), e);
kafkaTemplate.send("ledger", e.accountId(), toLedger(e));
}
Với transaction-id-prefix, Spring Boot tạo KafkaTransactionManager; listener container dùng nó thì offset của record đang xử lý được gửi vào cùng transaction (consume-transform-produce). Lưu ý: @Transactional của JPA và của Kafka là hai transaction khác nhau; lồng chúng không làm DB và Kafka nguyên tử (xem bài dual write ở trên).
Bài tập
Bài 1: send() làm treo API
Service đặt hàng gọi kafkaTemplate.send() trong controller. Khi cluster Kafka bảo trì 2 phút, toàn bộ API đặt hàng trả timeout, kể cả endpoint không dùng Kafka. Giải thích vì sao và đề xuất cấu hình cùng thiết kế.
Lời giải Bài 1
Vì sao: send() chặn khi không lấy được metadata hoặc khi buffer.memory đầy, tối đa max.block.ms = 60 s. Thread của Tomcat (mặc định 200) bị giữ ở send(), hết thread thì mọi endpoint đều chờ, kể cả endpoint không liên quan.
Sửa ngắn hạn:
max.block.ms=1000cho producer phục vụ request đồng bộ. Hết hạn thì trả 503 cóRetry-After, không giữ thread.delivery.timeout.msvừa với SLA (ví dụ 30 s) và callback ghi lỗi ra metric.- Bulkhead: giới hạn số request đồng thời vào luồng đặt hàng (semaphore hoặc thread pool riêng) để luồng khác không chết theo.
Sửa đúng: transactional outbox. Controller chỉ ghi đơn và một dòng outbox trong cùng transaction DB; relay đẩy lên Kafka sau. Kafka bảo trì thì outbox dồn lại, API vẫn chạy. Đây cũng là cách bỏ dual write.
Bài 2: Đọc offset có lỗ
Một partition chỉ có producer transactional ghi vào. Consumer read_committed thấy offset 0, 1, 3, 4, 8. Giải thích những offset bị thiếu, và vì sao endOffset - committedOffset (lag tính kiểu thông thường) không bao giờ về 0 dù consumer đã đọc hết.
Lời giải Bài 2
- Offset 2, 5, 6, 7 không phải record của ứng dụng đã commit. Một cách đọc khớp: 0, 1 thuộc T1, 2 = marker COMMIT của T1; 3, 4 thuộc T2, 5 = marker COMMIT của T2; 6 là record của T3 bị abort, 7 = marker ABORT của T3; 8 thuộc T4. Chỉ nhìn số thì không chắc chắn;
kafka-dump-log.sh --print-data-login raisControl: truevà loại marker. - Lag không về 0: sau record cuối cùng luôn có một marker. Consumer đọc hết thì position = offset sau marker, nhưng có lúc consumer commit offset ngay sau record cuối (chưa qua marker), nên lag hiển thị 1. Hơn nữa nếu còn transaction mở, consumer
read_committedchỉ tới LSO, lag theo high watermark sẽ treo ở mức > 0. - Kết luận: với topic transactional, cảnh báo lag phải chịu được lệch nhỏ (1–2) và nên theo dõi thêm
LastStableOffsetLag; đừng viết logic nghiệp vụ dựa trên “offset liên tục”.
Bài 3: Chọn linger.ms
Hai producer: (a) ghi log truy cập 50.000 record/s, không ai đọc ngay; (b) gửi lệnh chuyển tiền 200 record/s, SLA end-to-end p99 50 ms. Chọn linger.ms, batch.size, codec và giải thích.
Lời giải Bài 3
- (a) Log truy cập:
linger.ms=20–50,batch.size=64–256 KB,compression.type=zstd,acks=1hoặcalltuỳ mức chịu mất. Ở 50.000 record/s batch tự đầy nên linger ít tốn latency; zstd giảm 5–10 lần băng thông và đĩa. - (b) Chuyển tiền: 200 record/s là tải thấp: với
linger.ms=5một batch chỉ có khoảng 1 record mỗi partition, nên linger gần như chỉ cộng 5 ms mà không gom được gì. Giữlinger.ms0–5 (mặc định 5 vẫn nằm trong SLA 50 ms),batch.sizemặc định,lz4hoặc không nén (record nhỏ, ít lợi),acks=all, idempotence bật, key =accountId. Đo p99 thực tế trước khi tinh chỉnh.
Ghi nhớ
- Vẽ được đường đi
send()→ serializer → partitioner → accumulator → sender thread, và chỉ ra hai chỗsend()chặn. - Giải thích được vì sao
linger.mschỉ có tác dụng khi tải thấp, với số đo 14.333 → 554 request. - Biết partitioner chọn partition ra sao khi không có key từ Kafka 3.3, và vì sao không đặt
partitioner.classcũ. - Biết giới hạn retry bằng
delivery.timeout.msthay vìretries. - Kể được các bước của một transaction (InitProducerId, AddPartitions, EndTxn, marker) và vì sao transaction mở làm consumer
read_committedđứng yên.
Câu hỏi phỏng vấn
Junior
KafkaProducer.send() có đồng bộ không?
Không: nó bỏ record vào bộ đệm và trả về Future ngay; một thread nền gửi theo batch. Nhưng nó có thể chặn khi thiếu metadata hoặc bộ đệm đầy.
Muốn chờ kết quả thì send().get() (chậm, mất batching) hoặc dùng callback. Trong Spring KafkaTemplate.send() trả CompletableFuture; lỗi gửi nằm trong future, try/catch quanh lời gọi không bắt được.
Record không có key thì vào partition nào?
Producer dính vào một partition tới khi gửi đủ khoảng một batch rồi chuyển sang partition khác (sticky), nên lâu dài phân bố đều nhưng từng đoạn ngắn dồn vào một partition.
Trước Kafka 2.4 là round-robin từng record. Từ 3.3 việc chọn partition mới còn nghiêng về broker ít tải.
Mid
linger.ms và batch.size tương tác thế nào?
Batch được gửi khi đầy batch.size hoặc khi chờ đủ linger.ms, cái nào tới trước.
Tải cao: batch đầy trước, linger gần như không tốn latency. Tải thấp: linger quyết định; lab của mình ở 5.000 msg/s cho 14.333 request với linger 0 và 554 request với linger 5. Mặc định linger là 5 ms từ Kafka 4.0.
Bạn đặt retries bao nhiêu cho producer?
Để mặc định (Integer.MAX_VALUE) và giới hạn bằng delivery.timeout.ms, vì cái cần kiểm soát là thời gian chịu sự cố, không phải số lần.
Kèm theo: idempotence bật để retry không gây trùng hay đảo thứ tự, và callback xử lý lỗi không retriable (record quá lớn, không có quyền) cũng như TimeoutException khi hết hạn.
Vì sao không nên đặt codec nén ở topic khác với producer?
Broker sẽ phải giải nén và nén lại mọi batch, tốn CPU và mất zero-copy; để compression.type=producer thì broker lưu nguyên batch.
Codec chọn ở producer: lz4 cho latency, zstd cho tỉ lệ. Consumer tự giải nén theo codec ghi trong batch, không cần cấu hình.
Senior
Giải thích transaction của Kafka chạy thế nào bên dưới.
Producer có transactional.id được coordinator cấp PID và epoch; coordinator ghi trạng thái vào __transaction_state; khi commit, nó ghi marker COMMIT vào mọi partition tham gia, và consumer read_committed chỉ đọc tới LSO.
initTransactions()tăng epoch, fence instance cũ, hoàn tất transaction dở.- Mỗi partition mới trong transaction được đăng ký với coordinator; offset của consumer gửi qua
sendOffsetsToTransaction. - Commit là hai pha: PREPARE_COMMIT trong log của coordinator (điểm không quay lại), rồi ghi marker.
- Giá: thêm round-trip, marker chiếm offset, và transaction mở chặn consumer
read_committed.
Zombie producer là gì và Kafka chặn nó thế nào?
Zombie là instance cũ tưởng mình còn sống (ví dụ sau GC pause dài) trong khi instance mới đã thay thế; Kafka chặn bằng epoch gắn với transactional.id.
Instance mới gọi initTransactions() làm epoch tăng; mọi request của instance cũ mang epoch thấp hơn bị từ chối (ProducerFencedException / InvalidProducerEpochException). Vì vậy transactional.id phải cố định theo vai trò, không sinh ngẫu nhiên.
Consumer lag tăng nhưng consumer không báo lỗi, partition là topic transactional. Bạn nghi gì?
Một transaction đang mở (hoặc treo) giữ LSO, nên consumer read_committed không đọc tiếp được dù có dữ liệu mới.
Kiểm tra: so LSO với high watermark (LastStableOffsetLag), kafka-transactions.sh find-hanging --broker-id N. Xử lý: tìm producer giữ transaction lâu, giảm transaction.timeout.ms, abort transaction treo bằng công cụ.
send() treo 60 giây khi cluster lỗi. Bạn thiết kế lại thế nào?
Giảm max.block.ms cho luồng đồng bộ, cô lập bằng bulkhead, và tốt nhất là tách việc ghi Kafka khỏi request bằng outbox.
send() chặn vì metadata hoặc buffer.memory đầy. Theo dõi buffer-available-bytes và record-queue-time-avg để thấy sớm; outbox biến sự cố Kafka thành độ trễ thay vì lỗi API.
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 |
|---|---|---|---|
| record accumulator | /ˈrek.ɚd əˈkjuː.mjə.leɪ.t̬ɚ/ | bộ đệm batch theo partition | “send() only appends to the record accumulator, a background thread does the I/O.” |
| linger | /ˈlɪŋ.ɡɚ/ | nán lại, chờ thêm | “A few milliseconds of linger cut our request count by twenty-six times.” |
| backpressure | /ˈbæk.preʃ.ɚ/ | áp lực ngược khi bên nhận chậm | “When the buffer fills up, send() blocks; that’s the producer’s backpressure.” |
| sticky partitioner | /ˈstɪk.i pɑːrˈtɪʃ.ən.ɚ/ | partitioner dính một partition | “Keyless records stick to one partition until a batch is full.” |
| retriable error | /rɪˈtraɪ.ə.bəl ˈer.ɚ/ | lỗi có thể thử lại | “Leader changes are retriable, an oversized record is not.” |
| delivery timeout | /dɪˈlɪv.ɚ.i ˈtaɪm.aʊt/ | hạn tổng cho một lần gửi | “I bound retries by delivery timeout, not by a retry count.” |
| control marker | /kənˈtroʊl ˈmɑːr.kɚ/ | record đánh dấu commit/abort | “Each committed transaction leaves a control marker in every partition it touched.” |
| last stable offset | /læst ˈsteɪ.bəl ˈɔf.set/ | offset ổn định cuối cùng | “Read-committed consumers can’t go past the last stable offset.” |
| fencing | /ˈfen.sɪŋ/ | chặn instance cũ | “Bumping the epoch fences the zombie producer.” |
| zombie | /ˈzɑːm.bi/ | instance cũ còn chạy | “After a long GC pause the old instance came back as a zombie.” |
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.