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

Tìm kiếm

System DesignSenior25 phút đọc

Vì sao Kafka nhanh và bền: log, zero-copy, batching, replication

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

Cụm bài Kafka và message broker: 1. Message broker: 4 bài toán của request-response và cách chọn broker · 2. Vì sao Kafka nhanh và bền: log, zero-copy, batching, replication · 3. Cấu hình Kafka theo mục tiêu: throughput, latency, durability, availability · 4. Case study: gọi fraud-check đồng bộ qua Kafka và Redis — nên hay không? · 5. Ôn CCDAK: 40 câu hỏi Kafka đáng nhớ

“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.
flowchart LR
  subgraph T["Topic payments, 3 partition, replication factor 3"]
    P0["P0: leader B1, follower B2 B3"]
    P1["P1: leader B2, follower B3 B1"]
    P2["P2: leader B3, follower B1 B2"]
  end
  Prod[Producer] -->|key hash| P0
  Prod --> P1
  Prod --> P2
  P0 --> C1[Consumer 1, group G]
  P1 --> C1
  P2 --> C2[Consumer 2, group G]

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.

flowchart LR
  Pr1[Producer 1] --> P0 & P1 & P2
  Pr2[Producer 2] --> P3 & P4
  subgraph G[Consumer group G]
    C1[Consumer 1]
    C2[Consumer 2]
    C3[Consumer 3]
  end
  P0 --> C1
  P1 --> C1
  P2 --> C2
  P3 --> C2
  P4 --> C3

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 ISR
props.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.ms

try (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:

  1. Producer không đặt key, nên record rải đi nhiều partition và consumer khác nhau xử lý song song.
  2. Key là transaction_id cho PAYMENT nhưng refund_id cho REFUND, nên vào hai partition khác nhau.
  3. Idempotence bị tắt và có retry với nhiều in-flight request.
  4. 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.

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.