Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
Vì sao Kafka nhanh và bền: log, zero-copy, batching, replication
1Kafka trong một hình
Topic chia thành partition; mỗi partition là một log chỉ ghi thêm, sao sang nhiều broker. "Nhanh" nghĩa là throughput cao, không phải latency thấp nhất.
Mỗi record có offset, không sửa, không xoá khi đọc
Một replica là leader, các bản khác là follower
Consumer group chỉ lưu offset cho mỗi partition
Metadata do KRaft quản lý; Kafka 4.0 bỏ ZooKeeper
2Vì sao broker nhanh
Broker làm ít việc nhất có thể: append tuần tự, gửi byte thẳng ra mạng, không fsync, không xoá khi đọc.
Kỹ thuật
Vì sao nhanh
Log append-only
I/O tuần tự, không B-tree
Zero-copy sendfile
Không copy qua user space
Ghi page cache, không fsync
ACK không chờ đĩa
Chỉ lưu offset
Thêm consumer group gần như miễn phí
3Zero-copy
Kafka lưu batch trên đĩa đúng định dạng gửi qua mạng, nên dữ liệu đi thẳng page cache sang card mạng. Bật TLS hoặc broker phải nén lại là mất zero-copy.
flowchart TD
D["Đĩa"] --> PC["Page cache"]
PC -->|"cách thường"| U["Buffer ứng dụng"]
U --> S["Socket buffer"]
S --> N["Card mạng"]
PC -->|"sendfile"| N
4Phía client: batch, nén, key
Nút thắt thường là số request, không phải đĩa. Producer gom batch, nén cả batch (JSON thường 3–10 lần), và băm key để chọn partition.
props.put("acks", "all");
props.put("enable.idempotence", "true");
props.put("linger.ms", "5");
props.put("compression.type", "lz4");
// cùng key → cùng partition → giữ thứ tự
producer.send(new ProducerRecord<>(
"payments", accountId, json), callback);
5Partition và consumer group
Partition là đơn vị song song. Trong một group, mỗi partition chỉ thuộc một consumer; thứ tự chỉ đảm bảo trong một partition.
Bền nhờ replication, không nhờ fsync. Record chỉ ACK khi nằm trên đủ replica trong ISR (các replica bắt kịp leader). Bộ ba: RF 3, min.insync.replicas=2, acks=all.
acks
Leader ACK khi
Mất dữ liệu khi
0
Không chờ gì
Bất kỳ lỗi nào
1
Leader đã ghi
Leader chết trước follower
all
Mọi replica trong ISR có
Cả ISR cùng mất
💡 Ghi nhớ
Kafka đổi vài ms latency lấy throughput.
Consumer chỉ đọc tới high watermark, không thấy record có thể mất.
Tăng partition làm key đổi partition; không giảm được.
Idempotent producer chặn trùng và đảo thứ tự khi retry.
⭐ Điểm phỏng vấn
Tự trả lời trước, rồi bấm từng câu để xem đáp án.
Không fsync sao vẫn bền?
Record nằm trong RAM nhiều broker, khác rack.
Kafka đảm bảo thứ tự thế nào?
Chỉ trong partition; cùng key vào cùng partition.
Unclean leader election là gì?
Replica ngoài ISR lên leader: sống nhanh, mất dữ liệu.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Đặt min.insync.replicas=2 nhưng một service còn acks=1: không được bảo vệ.
Thiếu ISR, ứng dụng chỉ thấy TimeoutException, đổ nhầm cho mạng.
Ép log.flush.interval.messages=1 để "bền hơn": throughput sụp, vẫn không cứu hỏng đĩa.
🛠 Tự tay làm
Tự viết phần lõi, chưa nhờ agent. Tick từng bước khi xong.
Nhiệm vụ: Hai chương trình Java thuần dùng kafka-clients (Phase 3): đo throughput producer theo linger.ms, batch.size, nén; giết leader giữa lúc gửi, đếm message mất và trùng.
Tự viết:ProducerBench, DurabilityCheck · Được nhờ agent: compose 3 node KRaft (khoảng 1 GB RAM), script kill/pause broker.
Gửi 200.000 event JSON với bốn cấu hình; in records/s, batch-size-avg, request-total, tỉ lệ nén.
Tạo topic 1 partition; gửi 300.000 message đánh số, 20.000/s, sau 4 giây docker kill leader.
Đọc lại từ đầu, đếm: đã ACK mà không có là mất, có hai lần là trùng.
Lặp lại, docker pause hai follower 3 giây trước khi kill; so acks=1 với acks=all + idempotence.
Kết quả phải thấy
variant records/s MB/s batch avg requests ratio
linger=0 batch=16KB none 54895 9.5 16308 2281 1.00
linger=10 batch=64KB none 197032 34.0 65300 575 1.00
linger=10 batch=64KB lz4 242834 41.9 26814 339 0.24
linger=10 batch=64KB zstd 585043 101.0 23809 214 0.14
== acks=1, followers stalled 3s: 300000 messages at 20000/s, kill the leader after 4 s
in topic=239360 LOST(acked, missing)=60640 DUPLICATES=0 unacked-but-stored=0
== acks=all, followers stalled 3s: 300000 messages at 20000/s, kill the leader after 4 s
in topic=300000 LOST(acked, missing)=0 DUPLICATES=0 unacked-but-stored=0
Thử phá
Chỉ kill (bước 3) thì cả hai acks đều 0 mất: follower cùng máy theo kịp quá nhanh, nên bước 5 làm chúng tụt lại. Giữ acks=all, tắt enable.idempotence rồi kill: 0 mất, 115 bản trùng.
Agent hỏi lại bạn
acks=1 mất 60.640 message mà producer không báo lỗi: vì sao?
Vì sao follower bị pause 3 giây vẫn được bầu làm leader?
Lần chạy khác ra 23.618 records/s cho dòng đầu: đo sao cho tin được?
Xong bài thực hành. Giờ dán 3 câu hỏi cuối cho agent để nó chất vấn code của bạn.
“Kafka nhanh” nghĩa là throughput rất cao (hàng trăm MB/giây mỗi broker), không phải latency thấp nhất. Bài này giải thích các quyết định thiết kế đứng sau con số đó, rồi bổ sung phần slide bỏ trống: vì sao Kafka bền (replication, ISR, acks, min.insync.replicas). Nên đọc trước bài 1 về message broker.
Các thí nghiệm trong bài chạy trên cluster 3 broker KRaft (Confluent Platform 7.5, tức Kafka 3.5) với Java client kafka-clients 4.1.
1. Kafka trong một hình
Ý chính: topic chia thành partition; mỗi partition là một log chỉ ghi thêm, được sao sang nhiều broker. Consumer chỉ cần nhớ mình đã đọc tới offset nào.
Partition: một log append-only (chỉ ghi thêm vào cuối) của một topic (luồng event có tên). Mỗi record có offset (số thứ tự tăng dần). Record không bị sửa, không bị xoá khi đọc; chỉ bị dọn theo retention (thời gian, dung lượng) hoặc compaction (giữ bản mới nhất của mỗi key).
Replication: mỗi partition có bản sao trên nhiều broker. Một bản là leader (nhận ghi, phục vụ đọc), các bản khác là follower (kéo dữ liệu từ leader).
Producer chọn partition cho record; consumer cùng consumer group chia nhau partition và tự giữ offset.
Metadata (topic, partition, leader, ISR) do controller quorum quản lý bằng Raft (KRaft). Kafka 4.0 đã bỏ hẳn ZooKeeper.
2. Đính chính: Kafka tối ưu throughput, không phải latency
Ý chính: Kafka không làm từng message đi qua thật nhanh; nó đổi một ít latency lấy throughput. Cần p99 dưới 1 ms cho từng message thì Kafka không phải lựa chọn tự nhiên.
Latency đầu-cuối điển hình vài ms đến vài chục ms, đủ tốt cho hầu hết hệ thống. Các quyết định thiết kế chia ba nhóm: phía broker, phía client, và song song hoá bằng partition.
3. Phía broker
Ý chính: broker làm ít việc nhất có thể: append tuần tự, gửi byte thẳng từ page cache ra mạng, không fsync, không xoá khi đọc.
3.1. I/O tuần tự trên log append-only
“Đĩa chậm” chỉ đúng với truy cập ngẫu nhiên. Đọc ghi tuần tự nhanh hơn nhiều, và hệ điều hành còn tối ưu thêm (read-ahead: đọc trước phần kế tiếp; gom nhiều lần ghi thành một).
Slide nêu nhanh hơn 3–4 lần; thực tế HDD có thể chênh hàng trăm lần (không phải dịch đầu đọc), SSD ít hơn nhưng vẫn đáng kể.
Kafka chỉ append và đọc tuần tự từ một offset: không B-tree, không cập nhật tại chỗ.
Bên trong một partition: segment, index và retention
Mỗi partition là một thư mục gồm các segment. Segment đang hoạt động chỉ được append; khi đủ lớn (segment.bytes, mặc định 1 GB) hoặc đủ lâu thì đóng lại và mở segment mới. Mỗi segment có ba file (đã xem trong container lab):
/var/lib/kafka/data/payments-3/ 00000000000000000000.log # dữ liệu record, chỉ append 00000000000000000000.index # offset -> vị trí byte (index thưa) 00000000000000000000.timeindex # timestamp -> offset
Ghi: append vào cuối .log.
Đọc: tìm vị trí byte trong .index (index thưa, tìm nhị phân) rồi đọc tuần tự.
Retention: xoá cả file segment cũ, không xoá từng record.
3.2. Zero-copy
Cách gửi file thông thường tốn bốn lần copy và bốn lần chuyển ngữ cảnh: đĩa → page cache (kernel) → buffer của ứng dụng (user space) → socket buffer (kernel) → card mạng. Kafka dùng sendfile (Java: FileChannel.transferTo): dữ liệu đi thẳng từ page cache sang card mạng, không qua user space.
flowchart LR
subgraph Thường
D1[Đĩa] --> K1[Page cache] --> U1[Buffer ứng dụng] --> S1[Socket buffer] --> N1[NIC]
end
subgraph Zero-copy
D2[Đĩa] --> K2[Page cache] --> N2[NIC]
end
Điều này chỉ làm được vì Kafka lưu batch trên đĩa đúng định dạng gửi qua mạng: broker không phải giải mã hay dựng lại record.
Zero-copy trong Java và vì sao broker cần page cache lớn
3.3. Ghi vào page cache, không fsync
Quyết định gây ngạc nhiên nhất: broker trả ACK khi record đã nằm trong page cache, không gọi fsync. Page cache là vùng RAM hệ điều hành dùng để đệm file; fsync là lệnh ép đẩy nó xuống đĩa ngay. Hệ điều hành sẽ tự flush sau; log.flush.interval.messages và log.flush.interval.ms mặc định là “không bao giờ chủ động flush”.
sequenceDiagram
participant P as Producer
participant B as Broker (leader)
participant OS as Page cache
participant D as Đĩa
P->>B: produce batch
B->>OS: write() vào page cache
B-->>P: ACK
OS--)D: flush sau (do hệ điều hành)
Chỉ một broker thì cách này không an toàn: mất điện trước khi flush là mất dữ liệu đã ACK. Kafka lấy độ bền từ replication: record chỉ được coi là đã commit khi nằm trong bộ nhớ của nhiều broker. Ba máy ở ba rack cùng mất điện hiếm hơn nhiều (xem mục 6).
Có nên ép fsync? Và page cache vận hành thế nào
Page cache vận hành thế nào (RAM “trống” không bị bỏ phí; page cache tính vào memory của container nên container_memory_usage_bytes của broker tăng dần mà không phải leak): xem Bộ nhớ ảo, page cache và JVM. Đường đi của write() xuống đĩa, I/O tuần tự và ngẫu nhiên chênh bao nhiêu, fsync tốn cỡ nào: xem I/O model: blocking, epoll và file descriptor.
3.4. Consumer rẻ: giữ message, chỉ lưu offset
Queue truyền thống xoá message khi consumer ack: I/O nhảy lung tung (random I/O) và broker phải theo dõi trạng thái từng message.
Kafka không xoá khi đọc. Mỗi consumer group chỉ lưu một con số cho mỗi partition: offset kế tiếp cần đọc, ghi vào topic nội bộ __consumer_offsets (một topic có compaction). Hệ quả:
Thêm consumer group gần như miễn phí: mười group đọc cùng topic vẫn là đọc tuần tự, thường trúng page cache.
Consumer tua lại được (seek, hoặc kafka-consumer-groups --reset-offsets) để xử lý lại.
Consumer chậm không làm broker chậm: dữ liệu vẫn nằm đó tới khi hết retention.
4. Phía client
Ý chính: nút thắt thường là mạng và số request, không phải đĩa. Client gom batch, nén cả batch và tự chọn partition, nên broker chỉ việc append.
4.1. Batching
10.000 record gửi lẻ là 10.000 lượt đi-về; gửi batch 500 record chỉ còn 20 request.
Producer gom record theo partition vào batch (batch.size, mặc định 16 KB) và chờ tối đa linger.ms để batch đầy hơn. Kafka 4.0 đổi mặc định linger.ms từ 0 thành 5 ms (KIP-1030): chờ vài ms cho throughput tốt hơn mà latency gần như không đổi. Consumer cũng kéo theo batch (fetch.min.bytes, max.poll.records). Số đo thật của linger.ms và nén trên Kafka 4.3 có ở bài producer bên trong.
4.2. Nén theo batch
Nén từng record nhỏ thì tỉ lệ kém; nén cả batch các record JSON cùng cấu trúc thì rất tốt (thường 3–10 lần). Batch nén ở producer, lưu nguyên dạng nén trên broker, giải nén ở consumer. Lợi ba lần: ít băng thông mạng, ít dung lượng đĩa, ít I/O đĩa.
Codec: lz4 cân bằng tốc độ/tỉ lệ, zstd tỉ lệ tốt nhất (tốn CPU hơn), snappy, gzip (chậm, ít dùng).
4.3. Client thông minh, broker đơn giản
Client gom batch, nén, băm key để chọn partition, tính checksum, retry, và tự lấy metadata để gửi thẳng tới leader. Broker chỉ append và đọc tuần tự, nên phục vụ được rất nhiều client.
Cách Java producer chọn partition:
Có key: partition = toPositive(murmur2(keyBytes)) % numPartitions. Cùng key luôn vào cùng partition, nên sự kiện của một tài khoản giữ đúng thứ tự.
Không có key: “sticky partitioning” (KIP-480, cải tiến thành uniform sticky ở KIP-794 từ Kafka 3.3). Producer dính vào một partition tới khi batch đầy rồi mới chuyển, để batch to hơn so với rải round-robin từng record.
Thí nghiệm murmur2 và hệ quả khi tăng số partition
Mình tự cài lại murmur2 và so với partition thật do broker trả về cho 6 key trên topic 6 partition: khớp cả 6, và gửi lại cùng key luôn vào cùng partition. Key acc-1 vào partition 3 khi topic có 6 partition, nhưng tính lại với 8 partition thì ra 5.
5. Song song hoá: partition và consumer group
Ý chính: partition là đơn vị song song. Trong một group, mỗi partition chỉ thuộc một consumer, nên số consumer hữu ích tối đa bằng số partition.
Partition chia tải ghi cho nhiều broker, cho phép mở rộng ngang (thêm broker, chuyển bớt partition sang), và là đơn vị replicate.
Consumer cùng group.id chia nhau partition: mỗi partition chỉ giao cho một consumer trong group tại một thời điểm; một consumer có thể nhận nhiều partition. Ví dụ trong slide: consumer 1 nhận P0, P1; consumer 2 nhận P2, P3; consumer 3 nhận P4.
Rebalance là lúc group chia lại partition. Nó xảy ra khi consumer vào, ra hoặc chết (không gửi heartbeat trong session.timeout.ms, hoặc không gọi poll trong max.poll.interval.ms). Cần nhớ:
Consumer thứ 6 trong group đọc topic 5 partition sẽ ngồi chơi.
Thứ tự chỉ đảm bảo trong một partition, không có thứ tự toàn cục. Muốn sự kiện của một tài khoản đúng thứ tự thì dùng account id làm key.
6. Vì sao Kafka bền: replication, ISR, acks
Ý chính: record chỉ được ACK khi đã nằm trên đủ nhiều replica. Độ bền là tổ hợp replication.factor=3, min.insync.replicas=2 và acks=all; thiếu một trong ba là hở.
Slide hứa phần “Why is Kafka reliable?” nhưng dừng ở song song hoá; phần dưới bổ sung theo tài liệu Kafka.
6.1. Leader, follower và ISR
Mỗi partition có replication.factor bản (thường 3). Producer chỉ ghi vào leader. Follower liên tục gửi fetch request tới leader để kéo record mới, giống hệt một consumer.
ISR (in-sync replicas): các replica (gồm cả leader) đã bắt kịp leader trong replica.lag.time.max.ms (mặc định 30 giây). Tụt quá ngưỡng thì bị loại; bắt kịp thì được đưa vào lại.
High watermark: offset lớn nhất mà mọi replica trong ISR đều có. Consumer chỉ đọc tới đây, nên không bao giờ thấy record có thể mất khi đổi leader.
sequenceDiagram
participant P as Producer (acks=all)
participant L as Leader B1
participant F1 as Follower B2
participant F2 as Follower B3
P->>L: produce offset 100
L->>L: append vào page cache
F1->>L: fetch từ 100
F2->>L: fetch từ 100
L-->>F1: record 100
L-->>F2: record 100
F1->>L: fetch từ 101 (xác nhận đã có 100)
F2->>L: fetch từ 101
L->>L: high watermark = 101
L-->>P: ACK
6.2. acks và min.insync.replicas
acks ở producer quyết định khi nào leader trả ACK:
acks
Leader trả ACK khi
Mất dữ liệu khi
0
Không chờ gì (producer không đợi phản hồi)
Bất kỳ lỗi mạng hay broker nào
1
Leader đã ghi vào log của nó
Leader chết trước khi follower kịp sao chép
all (-1)
Mọi replica trong ISR hiện tại đã có record
Chỉ khi tất cả replica trong ISR cùng mất
Trong lúc chờ follower, request acks=all nằm trong “purgatory” của broker, được hẹn giờ bằng hierarchical timing wheel (timing wheel hoạt động thế nào).
Lỗ hổng của acks=all: ISR co lại chỉ còn leader thì “mọi replica trong ISR” chỉ là một máy, bền như acks=1. min.insync.replicas chặn lỗ này: với acks=all, ISR nhỏ hơn ngưỡng thì leader từ chối ghi (NotEnoughReplicasException) thay vì nhận rồi có nguy cơ mất.
Thí nghiệm trên cluster 3 broker, dừng broker 3:
Topic
RF
min.insync.replicas
ISR còn
acks=all
acks=1
payments
3
2
2
Ghi được
Ghi được
strict
3
3
2
Lỗi sau delivery.timeout.ms
Ghi được
Khi thiếu ISR, ứng dụng thật sự thấy lỗi gì
6.3. Unclean leader election
Leader chết thì controller chọn leader mới trong ISR, nên leader mới chắc chắn có mọi record đã commit. Nếu mọi replica trong ISR đều chết, chỉ còn replica ngoài ISR (đang tụt lại), có hai lựa chọn:
6.4. Producer idempotent: không trùng, không đảo thứ tự khi retry
Retry gây trùng (leader đã ghi nhưng ACK mất, producer gửi lại) và đảo thứ tự (nhiều request đang bay, max.in.flight.requests.per.connection > 1: batch 1 lỗi, retry sau khi batch 2 đã thành công).
enable.idempotence=true (idempotent: làm lại nhiều lần vẫn như một lần; mặc định từ Kafka 3.0, cùng với acks=all) giải cả hai. Mỗi producer có producer id, mỗi batch có sequence number theo partition; broker bỏ batch có sequence đã thấy và từ chối batch đến sai thứ tự. Giới hạn: max.in.flight.requests.per.connection ≤ 5, và chỉ chống trùng trong một phiên producer (restart có id mới; muốn chống trùng xuyên phiên thì dùng transactional.id). Transaction chạy bên trong thế nào (coordinator, control marker, LSO, fencing) có ở bài producer bên trong.
send là bất đồng bộ: nó chỉ đưa record vào buffer và trả về Future<RecordMetadata>. Bọc send trong try/catch không bắt được lỗi broker; lỗi chỉ đến qua callback hoặc future.get().
Đảo thứ tự khi tắt idempotence, và producer Java mẫu cho sự kiện thanh toán
Producer cho sự kiện thanh toán: key là account id để giữ thứ tự theo tài khoản, xử lý kết quả trong callback (đã chạy với lab: ba record cùng key vào cùng partition 1, offset 2, 3, 4):
var props = new Properties();props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:19092,localhost:19093");props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);props.put(ProducerConfig.ACKS_CONFIG, "all"); // chờ mọi replica trong ISRprops.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true); // retry không trùng, không đảo thứ tựprops.put(ProducerConfig.LINGER_MS_CONFIG, 10);props.put(ProducerConfig.BATCH_SIZE_CONFIG, 32_768);props.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "lz4");props.put(ProducerConfig.DELIVERY_TIMEOUT_MS_CONFIG, 60_000); // phải >= linger.ms + request.timeout.mstry (var producer = new KafkaProducer<String, String>(props)) { var record = new ProducerRecord<>("payments", "acc-42", "{\"type\":\"TOPUP\",\"amount\":200000}"); producer.send(record, (meta, ex) -> { // chạy trên I/O thread của producer, đừng làm việc nặng ở đây if (ex != null) log.error("publish failed", ex); // báo động, hoặc để outbox gửi lại else log.info("partition={} offset={}", meta.partition(), meta.offset()); });}
Bài tập
Bài 1: Bao nhiêu partition?
Topic clickstream cần 600 MB/giây lúc cao điểm. Một producer ghi được khoảng 100 MB/giây vào một partition, một consumer xử lý được 30 MB/giây. Dự kiến tải tăng gấp đôi trong 2 năm. Chọn số partition.
Lời giải Bài 1
Hiện tại: max(600/100, 600/30) = max(6, 20) = 20 partition, consumer là giới hạn. Sau 2 năm: 1.200/30 = 40. Vì không giảm được và tăng thì phá thứ tự theo key, chọn khoảng 40–48 partition ngay từ đầu (48 chia hết cho 2, 3, 4, 6, 8, 12 nên dễ cân consumer). Bắt đầu khoảng 20 consumer, tăng dần tới 48 khi cần.
Bài 2: Kịch bản mất broker
Topic RF=3. Với mỗi cấu hình, trả lời: khi một broker chết, producer acks=all còn ghi được không? Khi hai broker chết thì sao? Record đã ACK có thể mất không?
min.insync.replicas=1
min.insync.replicas=2
min.insync.replicas=3
1 broker chết
2 broker chết
Lời giải Bài 2
min.insync.replicas=1
min.insync.replicas=2
min.insync.replicas=3
1 broker chết
Ghi được
Ghi được
Không ghi được
2 broker chết
Ghi được, nhưng record chỉ nằm trên một máy
Không ghi được
Không ghi được
Record đã ACK với acks=all nằm trên mọi replica của ISR lúc đó, nên chỉ mất khi mọi replica đó cùng mất trước khi flush, hoặc khi bật unclean leader election. Với min ISR = 1 sau khi 2 broker chết, mất máy còn lại là mất dữ liệu. (Với KRaft chạy controller chung trên 3 node, mất 2 node còn làm mất quorum controller, nên không bầu được leader mới; production nên tách controller riêng.)
Bài 3: Giữ thứ tự theo tài khoản
Service ví gửi các sự kiện TOPUP, PAYMENT, REFUND vào topic wallet-transactions 12 partition. Consumer cập nhật số dư và đôi khi thấy REFUND trước PAYMENT của cùng giao dịch. Tìm nguyên nhân có thể và cách sửa.
Lời giải Bài 3
Nguyên nhân thường gặp:
Producer không đặt key, nên record rải đi nhiều partition và consumer khác nhau xử lý song song.
Key là transaction_id cho PAYMENT nhưng refund_id cho REFUND, nên vào hai partition khác nhau.
Idempotence bị tắt và có retry với nhiều in-flight request.
Consumer tự xử lý song song bằng thread pool trong một partition.
Sửa: dùng cùng một key cho mọi sự kiện cần đúng thứ tự với nhau, ở đây là account_id (thứ tự theo tài khoản là thứ số dư cần); giữ enable.idempotence=true; consumer muốn song song trong một partition thì phải song song theo key, không theo record.
Ghi nhớ
Giải thích được vì sao Kafka “nhanh” là nói về throughput, và linger.ms đổi latency lấy throughput thế nào.
Kể được bốn lý do phía broker (I/O tuần tự, zero-copy, page cache không fsync, chỉ lưu offset) và biết khi nào zero-copy bị tắt.
Giải thích được vì sao tăng số partition phá thứ tự theo key, và cách chọn số partition từ đầu.
Biết ba cấu hình phải đi cùng để không mất dữ liệu, và vì sao acks=1 vô hiệu hoá min.insync.replicas.
Phân biệt được ISR, high watermark và unclean leader election.
Câu hỏi phỏng vấn
Junior
Topic, partition và offset là gì?
Topic là luồng record có tên, chia thành partition; offset là số thứ tự của record trong partition.
Mỗi partition là một log append-only có thứ tự. Consumer group lưu offset đã đọc cho mỗi partition để biết đọc tiếp từ đâu.
Kafka đảm bảo thứ tự như thế nào?
Chỉ trong một partition; giữa các partition không có thứ tự.
Record trong một partition được đọc đúng thứ tự ghi. Muốn sự kiện của một thực thể đúng thứ tự thì dùng id của thực thể làm key, vì cùng key luôn vào cùng partition.
Consumer chưa đọc thì Kafka có giữ message mãi không?
Không. Kafka xoá theo retention của topic (mặc định retention.ms = 7 ngày, retention.bytes không giới hạn), bất kể consumer đã đọc hay chưa; consumer chậm quá retention sẽ mất dữ liệu.
Kafka xoá cả segment (file log khoảng 1 GB mặc định), và không bao giờ xoá segment đang ghi, nên dữ liệu có thể nằm lâu hơn retention một chút.
Consumer quay lại với offset đã bị xoá: auto.offset.reset quyết định nhảy về đầu hiện có (earliest) hay cuối (latest), tức là mất hoặc bỏ qua một đoạn mà không báo lỗi.
Topic cleanup.policy=compact giữ bản cuối cùng của mỗi key thay vì xoá theo thời gian, dùng cho dữ liệu dạng “trạng thái hiện tại”.
Theo dõi consumer lag tính theo thời gian, cảnh báo trước khi lag tiến gần retention.
Mid
Vì sao Kafka đạt throughput cao dù ghi xuống đĩa?
Vì mọi thứ đều tuần tự và theo lô: log append-only, zero-copy, batch nén ở client, và partition chạy song song.
Log append-only nên đọc ghi đều tuần tự; ghi vào page cache, không fsync.
Phục vụ consumer bằng zero-copy sendfile.
Không xoá khi đọc nên không có random I/O, chỉ lưu offset.
Client gom batch và nén cả batch nên ít request, ít byte; client tự chọn partition và gửi thẳng tới leader.
Partition cho phép song song trên nhiều broker và nhiều consumer.
acks=0, 1, all khác nhau thế nào?
Khác ở chỗ leader chờ bao nhiêu bản sao trước khi ACK: không chờ, chỉ leader, hay mọi replica trong ISR.
0: producer không chờ phản hồi, nhanh nhất, mất dữ liệu khi có lỗi bất kỳ. 1: leader ghi xong là ACK, mất nếu leader chết trước khi follower sao chép. all: chờ mọi replica trong ISR, chỉ mất khi chúng cùng mất; kết hợp min.insync.replicas=2 để ISR không co về một máy. Từ Kafka 3.0 mặc định là all.
Consumer group hoạt động thế nào và khi nào rebalance?
Consumer cùng group.id chia nhau partition, mỗi partition thuộc đúng một consumer; group rebalance khi thành viên hoặc số partition thay đổi.
Số consumer hữu ích tối đa bằng số partition. Rebalance xảy ra khi consumer vào hoặc rời group, không heartbeat trong session.timeout.ms, không poll trong max.poll.interval.ms, hoặc số partition của topic thay đổi.
Tăng số partition của một topic đang chạy có vấn đề gì?
Key bị chuyển sang partition khác, nên mất thứ tự theo key; và không giảm lại được.
Partition của key tính bằng murmur2(key) % số partition. Tăng partition thì record cũ và mới của cùng key nằm ở hai partition, state store theo key bị lệch. Nên chọn dư từ đầu, hoặc tạo topic mới và chuyển dần.
Senior
Kafka không fsync trước khi ACK, vậy sao gọi là bền?
Kafka chuyển độ bền từ “nằm trên đĩa một máy” sang “nằm trong bộ nhớ của nhiều máy”.
Với acks=all, record chỉ được ACK khi mọi replica trong ISR đã có, và min.insync.replicas=2 đảm bảo ít nhất hai máy. Replica ở các rack/AZ khác nhau thì xác suất tất cả cùng mất điện trước khi hệ điều hành flush rất thấp. Ép fsync mỗi message làm sụp throughput mà không bảo vệ thêm nhiều.
ISR và high watermark là gì?
ISR là tập replica đã bắt kịp leader; high watermark là offset lớn nhất mà mọi replica trong ISR đều có.
Bắt kịp nghĩa là trong replica.lag.time.max.ms; follower tụt lại bị loại, bắt kịp được đưa vào lại. Leader chỉ được bầu từ ISR (nếu không bật unclean election). Consumer chỉ đọc tới high watermark, nên không đọc phải record có thể mất khi đổi leader.
Unclean leader election là gì, khi nào bật?
Là cho replica ngoài ISR lên làm leader khi mọi replica trong ISR đã chết: sống lại ngay nhưng mất dữ liệu.
Mặc định tắt. Bật cho dữ liệu chấp nhận mất (log, metric) để ưu tiên sẵn sàng; tắt cho thanh toán, đơn hàng, nơi thà dừng còn hơn mất dữ liệu.
Producer idempotent hoạt động thế nào và giới hạn của nó?
Producer id + sequence number theo partition giúp broker bỏ batch trùng và từ chối batch sai thứ tự; nhưng chỉ trong một phiên producer.
Retry không tạo bản trùng, không đảo thứ tự, với tối đa 5 request đang bay mỗi connection. Giới hạn: chỉ trong một phiên và chỉ trong Kafka. Producer restart, hoặc ứng dụng gọi send hai lần cho cùng một nghiệp vụ, vẫn tạo trùng; cần transactional.id hoặc consumer idempotent.
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
append-only log
/əˈpend ˈəʊnli lɒɡ/
log chỉ ghi thêm vào cuối
“Each partition is an append-only log, so writes are sequential.”
sequential I/O
/sɪˈkwenʃl ˌaɪ ˈəʊ/
đọc ghi tuần tự
“Sequential I/O is why disks aren’t the bottleneck for Kafka.”
page cache
/peɪdʒ kæʃ/
bộ nhớ đệm file của hệ điều hành
“Consumers reading the tail are served from the page cache.”
zero-copy
/ˈzɪərəʊ ˈkɒpi/
gửi dữ liệu không copy qua user space
“TLS disables zero-copy because the broker has to encrypt in the JVM.”
replication factor
/ˌreplɪˈkeɪʃn ˈfæktə/
số bản sao của partition
“We run a replication factor of three across availability zones.”
in-sync replica (ISR)
/ɪn sɪŋk ˈreplɪkə/
replica đã bắt kịp leader
“With acks=all, the leader waits for every in-sync replica.”
high watermark
/haɪ ˈwɔːtəmɑːk/
offset lớn nhất đã có trên mọi ISR
“Consumers can only read up to the high watermark.”
unclean leader election
/ʌnˈkliːn ˈliːdə ɪˈlekʃn/
bầu leader từ replica chưa bắt kịp
“We keep unclean leader election off for payment topics.”
idempotent producer
/ˌaɪdemˈpəʊtənt/
producer retry không tạo trùng
“The idempotent producer uses sequence numbers to drop duplicates.”
partition key
/pɑːˈtɪʃn kiː/
key quyết định partition
“We use the account id as the partition key to keep per-account order.”
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.