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

Tìm kiếm

System DesignSenior25 phút đọc

Case study: gọi fraud-check đồng bộ qua Kafka và Redis — nên hay không?

Ôn 19 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ớ

Bài này review một service ví (Spring Boot 3.2) gửi lệnh kiểm tra gian lận vào Kafka rồi poll Redis chờ kết quả, trong lúc người dùng đứng chờ. Đọc xong, bạn chỉ ra được tám lỗi, biết các phương án thay thế và trả lời được “có nên request-reply qua Kafka không”. Nên đọc trước: Vì sao Kafka nhanh và bền (partition, key, consumer group), Cấu hình Kafka theo mục tiêu (auto-commit) và Idempotency phần 2 (consumer idempotent, outbox).

1. Bài toán và ràng buộc

Ý chính: trước khi trừ tiền, ví phải hỏi fraud-detection xem giao dịch có đáng ngờ không. Bốn ràng buộc làm bài toán khó:

  • Fraud-detection chỉ nhận đầu vào qua Kafka, không có HTTP API.
  • Người dùng đang chờ: phản hồi dưới 1–2 giây, fraud-check chỉ được vài trăm mili giây.
  • Ví chạy nhiều instance: instance gửi lệnh chưa chắc là instance nhận kết quả.
  • Tiền thật: phải quyết định khi fraud-check chậm hoặc chết: cho qua (fail-open) hay chặn (fail-closed).

Code gốc có hai endpoint. POST /api/v1/payments giả lập giao dịch rồi bắn event FUND_TRANSFER (gửi xong là quên). POST /api/v1/payments/sync bắn command kiểm tra gian lận rồi đứng chờ; bài này chủ yếu nói về endpoint này.

2. Message envelope và đặt tên topic

Ý chính: mọi message được bọc trong một envelope (vỏ bọc chứa metadata) gồm meta, message_code, payload. Ý tốt, nhưng thiếu schema_version, reply_to và deadline.

Các trường của envelope, quy ước topic và chỗ đặt metadata
  • meta: message_id (UUID), original_message_id (id của message mà message này trả lời, null nếu không trả lời ai), type (EVENT, COMMAND…), service_id (service gửi), timestamp, auto_retry.
  • message_code: loại nghiệp vụ, ví dụ FUND_TRANSFER.
  • payload: dữ liệu giao dịch (id, loại PAYMENT/TOPUP, tài khoản nợ, tài khoản có, số tiền, trạng thái, thời điểm tạo).

Tên topic: <tenant>-<service sở hữu>-<tên>-<môi trường>, ví dụ ronin-wallet-transactions-dev, ronin-fraud-detection-result-dev. Môi trường trong tên topic chỉ hợp lý khi nhiều môi trường dùng chung cluster; tách cluster an toàn hơn.

Envelope đã có id khử trùng, id tương quan và loại message. Senior sẽ bổ sung:

  • schema_version hoặc schema registry, để consumer biết đang đọc phiên bản payload nào.
  • reply_to và deadline: trả lời vào đâu, và sau lúc nào thì khỏi trả lời (không thì fraud vẫn chấm điểm lệnh bên gọi đã bỏ cuộc).
  • Chuẩn có sẵn: CloudEvents (id, source, type, time và cách ánh xạ vào Kafka header).

3. Event và command là hai thứ khác nhau

Ý chính: event kể lại chuyện đã xảy ra và không ai trả lời; command yêu cầu một bên cụ thể làm việc và thường cần kết quả. Code gốc gửi cả hai vào cùng một topic ronin-wallet-transactions-dev, phân biệt bằng meta.type.

Event Command
Ví dụ FundTransferred CheckFraud
Ý nghĩa chuyện đã xảy ra, thì quá khứ, bất biến “hãy làm việc này”
Bên nhận bên gửi không biết, không quan tâm ai nghe một chủ sở hữu, có thể từ chối
Trả lời không ai trả lời thường cần kết quả

4. Thiết kế gốc: request-reply với Redis làm nơi ghép cặp

Ý chính: reply về một instance bất kỳ trong group ronin-wallet, nên Redis làm kho tương quan dùng chung: ai nhận reply thì ghi, instance đang chờ thì poll. Ý tưởng hợp lý, cách làm thì không.

sequenceDiagram
    participant U as Người dùng
    participant W1 as Wallet instance 1
    participant K as Kafka
    participant FD as Fraud-detection
    participant W2 as Wallet instance 2
    participant R as Redis
    U->>W1: POST /payments/sync
    W1->>K: COMMAND (message_id = m1)
    W1->>W1: sleep 5 ms, rồi poll Redis với backoff
    K->>FD: COMMAND m1
    FD->>K: RESULT (original_message_id = m1)
    K->>W2: RESULT m1 (consumer group ronin-wallet)
    W2->>R: SET wallet:m1 = result, TTL
    W1->>R: GET wallet:m1 (thấy kết quả)
    W1-->>U: 200 + kết quả
    W1-)R: DEL wallet:m1 (bất đồng bộ)

Khoá Redis là <service_id>:<original_message_id>. Vòng chờ, rút gọn từ KafkaConnector.sendSync:

Thread.sleep(5);    // wait for consumer receiving and processing (tuning)
int leftTime = cacheTimeout;
...
while (leftTime >= 0) {
    var response = getResponseFromCache(...);
    if (response != null) return response;
    var delay = (int) (initDelay * Math.pow(BACKOFF_MULTIPLIER, attempt++));
    leftTime -= delay;
    Thread.sleep(delay);
}
return null;

với cacheTimeout lấy từ spring.redis.timeout: 300000, initDelay = 20, hệ số 2.

5. Review: tám vấn đề

Ý chính: nặng nhất là chờ 5 phút trên thread servlet và timeout biến thành fail-open; còn lại là lỗi topic, key, xử lý lỗi gửi, dual write, serialize và mất reply.

5.1. Chờ 5 phút trên thread của servlet, và backoff không có trần

Ý chính: ngân sách chờ là 300 000 ms, và delay 20 ms × 2^n không có trần. Chính comment trong code thừa nhận “biz timeout should be different from cache infra timeout”.

Mô phỏng lại lịch poll (Java 21) cho ba hậu quả:

  1. Thread exhaustion (cạn thread): Tomcat mặc định 200 thread. Chỉ ~1 request/giây chờ 5,5 phút là sau hơn 3 phút hết thread, endpoint không liên quan cũng chết.
  2. Trễ gấp đôi: khoảng cách poll lớn dần, reply có ở 2,6 s thì 5,1 s mới được thấy.
  3. Khoảng mù cuối: lần poll cuối ở giây 163,8, rồi thread ngủ thêm 163,8 s và trả null mà không poll lại. Reply tới trong khoảng đó bị bỏ dù vẫn nằm trong Redis.
Lịch poll mô phỏng và chi tiết cấu hình Spring Boot 3.2
poll at ms: 5 25 65 145 305 625 1265 2545 5105 10225 20465 40945 81905 163825
returns null at ms: 327665 (polls=14)
reply ready at 700 ms   -> seen at 1265 ms
reply ready at 1300 ms  -> seen at 2545 ms
reply ready at 2600 ms  -> seen at 5105 ms
reply ready at 170000 ms -> seen at never (timeout 327665 ms)

Dự án dùng Spring Boot 3.2, nơi spring.redis.* đã đổi thành spring.data.redis.*. Vì vậy spring.redis.timeout không còn cấu hình client Redis; nó chỉ được @Value đọc làm ngân sách chờ.

5.2. Fail-open ngầm khi không có kết quả

Ý chính: người gọi không phân biệt được “không gian lận”, “gian lận” và “không biết”, vì mọi lỗi đều thành null.

KafkaMessage<FraudCheckResult> response = kafkaConnector.sendSync(transactionTopic, message);
return response.getPayload();
} catch (Exception e) {
    log.error("Failed to produce the message to topic: " + transactionTopic);
    return null;    // TODO: return the default value

5.3. Command và event chung topic

Ý chính: ngoài lý do ở mục 3, fraud-detection phải đọc cả dòng event (lưu lượng lớn) để lọc vài command, nên lag của event làm chậm command đang có người chờ.

5.4. Không có message key

Ý chính: kafkaTemplate.send(topic, request) không có key, nên hai giao dịch cùng tài khoản có thể rơi vào hai partition và bị xử lý lệch thứ tự. Dùng debit_account làm key.

Không key thì producer dùng sticky partitioner (dồn record vào một partition tới khi batch đầy). Chống gian lận lại cần thứ tự theo tài khoản. Khi dùng key, để ý hot key (một key nhận quá nhiều lưu lượng) của tài khoản merchant lớn.

5.5. send() bất đồng bộ, nên try/catch không bắt được lỗi broker

Ý chính: lỗi gửi nằm trong future, không ném ra ngay. Endpoint fire-and-forget có thể mất event mà log vẫn ghi “Produced a message”; endpoint đồng bộ gửi thất bại vẫn đứng chờ đủ 5 phút.

5.6. Dual write: event cho một giao dịch không có transaction

Ý chính: ghi DB rồi gửi Kafka mà không có transaction chung là dual write: một bên thành công, bên kia có thể thất bại. Lời giải chuẩn là transactional outbox (mục 7).

Endpoint /payments hiện chỉ tạo giao dịch “giả”, không có DB. Khi gắn DB thật, có hai kiểu hỏng:

  • Ghi DB xong, gửi Kafka lỗi: mất event, kế toán không bao giờ biết.
  • Gửi Kafka xong, DB rollback: event về một giao dịch không tồn tại.

5.7. Kryo không bắt buộc đăng ký class, và chi phí poll Redis

Ý chính: kryo.setRegistrationRequired(false) cho phép khởi tạo bất kỳ class nào trên classpath khi đọc, cùng họ lỗ hổng với Java deserialization. Dùng JSON với kiểu cố định, hoặc bắt buộc đăng ký class.

Giá trị ghi bằng writeClassAndObject nên tên class nằm trong dữ liệu; ai ghi được vào Redis có thể ép service khởi tạo class tuỳ ý. Định dạng cũng gắn chặt với cấu trúc class: rolling deploy đổi field là instance cũ/mới không đọc được của nhau.

Về tải: mỗi request đang chờ tạo tới 14 lệnh GET chỉ để hỏi “có chưa”. Cách không poll: BLPOP có timeout, Pub/Sub theo kênh của instance, hoặc keyspace notifications.

5.8. Auto-commit và lần ghi Redis không retry

Ý chính: consumer reply bật enable-auto-commit: true và pushResponseToCache không retry (// TODO: add retry logic), nên reply có thể mất. Mất reply đáng lo vì timeout đang là fail-open (5.2): một reply mất là một giao dịch không được kiểm tra.

Vì sao reply mất, và lỗi khoá service_id trong hợp đồng
  • Auto-commit commit offset theo chu kỳ, không gắn với việc ghi Redis xong.
  • Ghi Redis lỗi: error handler mặc định retry vài lần rồi bỏ record.
  • Process chết sau commit nhưng trước khi ghi Redis: reply mất.

Lỗi hợp đồng: khoá ghi dùng service_id trong reply, khoá đọc dùng service_id trong request. Nếu fraud-detection đặt service_id là tên chính nó (tự nhiên với trường “service gửi”), hai khoá không bao giờ khớp và mọi request đều timeout. Hợp đồng phải nói rõ: reply mang reply_to/correlation_id do bên gọi cấp, bên trả lời chỉ chép lại.

6. Các phương án thay thế

Ý chính: chờ reply mà không poll: giữ map correlationId → future, hoàn thành khi reply về (A, B). Đổi được bên kia hoặc sản phẩm thì HTTP có timeout (D) hay UX bất đồng bộ (E) còn đơn giản hơn.

Phương án Ý tưởng Ưu Nhược
A. ReplyingKafkaTemplate Spring gắn correlationId + replyTopic vào header, giữ map future Không poll, timeout chuẩn, ít code Mỗi instance phải nhận được reply của mình
B. Reply partition theo instance + map future Như A, tự viết bằng kafka-clients Hiểu rõ cơ chế, không cần Spring Tự quản lý ánh xạ instance → partition
C. Redis BLPOP thay cho poll Giữ kiến trúc gốc, chờ chặn có timeout Thay đổi nhỏ Vẫn chặn thread, Redis vẫn ở đường găng
D. HTTP/gRPC có timeout Fraud-detection mở API chấm điểm Đơn giản nhất, có sẵn circuit breaker, retry, tracing Phải sửa fraud-detection, coupling thời gian
E. UX bất đồng bộ Trả 202 + PENDING, đẩy kết quả qua push/webhook/polling Không chặn thread, chịu được fraud chậm Đổi luồng sản phẩm, thêm máy trạng thái

6.1. Phương án B: mình tự viết và chạy

Ý chính: mỗi instance sở hữu một partition của topic reply và giữ ConcurrentHashMap<correlationId, CompletableFuture>. Chạy trên cluster 3 broker: p99 23 ms, timeout 2 s là quyết định tường minh, không rò bộ nhớ.

  • Partition cố định theo instance (ví dụ ordinal của StatefulSet), đọc bằng assign(), không cần consumer group.
  • Command mang header correlation-id và reply-partition; fraud-detection chép lại correlation-id và gửi reply vào đúng partition.
Code phương án B, kết quả chạy và lỗi CompletionException

Phần lõi:

CompletableFuture<String> check(String txId, String debitAccount, long amount, Duration timeout) {
    String correlationId = UUID.randomUUID().toString();
    var future = new CompletableFuture<String>();
    pending.put(correlationId, future);
    var record = new ProducerRecord<>(COMMANDS, debitAccount, txId + ":" + amount); // key = tài khoản
    record.headers().add("correlation-id", correlationId.getBytes(UTF_8));
    record.headers().add("reply-partition", String.valueOf(replyPartition).getBytes(UTF_8));
    producer.send(record, (md, ex) -> { if (ex != null) future.completeExceptionally(ex); });
    return future.orTimeout(timeout.toMillis(), TimeUnit.MILLISECONDS)
                 .whenComplete((v, ex) -> pending.remove(correlationId));   // không rò map
}

private void listen() {                       // một thread cho mỗi instance
    try (var c = consumer(null)) {            // không group.id: tự assign partition
        var tp = new TopicPartition(REPLIES, replyPartition);
        c.assign(List.of(tp));
        c.seekToEnd(List.of(tp));
        while (running) {
            for (var r : c.poll(Duration.ofMillis(50))) {
                var f = pending.get(header(r, "correlation-id"));
                if (f != null) f.complete(r.value());   // reply trễ hoặc lạ: bỏ qua
            }
        }
    }
}

Bên gọi quyết định rõ ràng khi hết giờ:

String verdict = client.check("tx-1", "acc-1", 100_000, Duration.ofSeconds(2))
    .exceptionally(ex -> {
        Throwable cause = ex instanceof CompletionException ? ex.getCause() : ex;
        return cause instanceof TimeoutException ? "TIMEOUT->HOLD" : "ERROR->HOLD";
    })
    .join();

Kết quả trên cluster 3 broker KRaft (cp-kafka 7.5.3, kafka-clients 4.1.1, acks=all, laptop):

200 sequential checks: OK=180 REVIEW=20 p50=5 ms p99=23 ms max=26 ms
200 concurrent checks done in 60 ms, pending map size=0/0
slow responder: verdict=TIMEOUT->HOLD after 2004 ms, pending=0
late reply dropped, pending=0

Không poll, reply được thấy ngay khi về, reply trễ bị bỏ mà không rò bộ nhớ. Số đo trên máy cục bộ, không phải production.

6.2. Phương án A: ReplyingKafkaTemplate trong Spring Boot 3

Ý chính: Spring làm sẵn phần map future và header tương quan; phía fraud-detection chỉ cần @KafkaListener + @SendTo. Việc còn lại là chọn cách để reply về đúng instance.

Cấu hình ReplyingKafkaTemplate (chưa chạy, theo API Spring Kafka 3.x)
@Bean
ReplyingKafkaTemplate<String, FraudCheckCommand, FraudVerdict> fraudTemplate(
        ProducerFactory<String, FraudCheckCommand> pf,
        ConcurrentKafkaListenerContainerFactory<String, FraudVerdict> factory,
        @Value("${app.instance-id}") String instanceId) {
    var replies = factory.createContainer("fraud-check.replies");
    replies.getContainerProperties().setGroupId("wallet-replies-" + instanceId); // group riêng mỗi instance
    var template = new ReplyingKafkaTemplate<>(pf, replies);
    template.setDefaultReplyTimeout(Duration.ofSeconds(2));
    template.setSharedReplyTopic(true);   // instance nhận cả reply của instance khác và bỏ qua
    return template;
}

public FraudVerdict check(FraudCheckCommand cmd) throws Exception {
    var record = new ProducerRecord<String, FraudCheckCommand>("fraud-check.commands", cmd.debitAccount(), cmd);
    return fraudTemplate.sendAndReceive(record).get(2, TimeUnit.SECONDS).value();
}

Listener container factory phía fraud-detection cần có reply template; Spring tự chép header tương quan.

7. Transactional outbox: khi giao dịch thật được ghi DB

Ý chính: ghi dữ liệu nghiệp vụ và message cần gửi vào cùng DB trong một transaction, rồi một tiến trình khác (relay) chuyển outbox sang Kafka. Kết quả là at-least-once, nên consumer phải khử trùng theo id.

Ví dụ trên PostgreSQL:

CREATE TABLE outbox (
    id           uuid PRIMARY KEY,
    aggregate_id text        NOT NULL,     -- dùng làm message key, ví dụ debit_account
    topic        text        NOT NULL,
    payload      jsonb       NOT NULL,
    created_at   timestamptz NOT NULL DEFAULT now(),
    published_at timestamptz
);
CREATE INDEX outbox_unpublished ON outbox (created_at) WHERE published_at IS NULL;

-- trong transaction nghiệp vụ
BEGIN;
INSERT INTO wallet_transaction (...) VALUES (...);
INSERT INTO outbox (id, aggregate_id, topic, payload) VALUES (...);
COMMIT;

-- relay (chạy được nhiều bản song song)
SELECT id, aggregate_id, topic, payload FROM outbox
WHERE published_at IS NULL ORDER BY created_at LIMIT 100
FOR UPDATE SKIP LOCKED;
-- gửi Kafka, chờ ack, rồi:
UPDATE outbox SET published_at = now() WHERE id = ANY(?);
  • Relay có thể gửi xong rồi chết trước UPDATE, nên gửi trùng: consumer khử trùng theo id (xem Idempotency phần 2).
  • Thay relay polling được bằng CDC (change data capture: Debezium đọc WAL của PostgreSQL hoặc binlog của MySQL), so sánh ở khối dưới.
  • MySQL 8.0+ cũng có FOR UPDATE SKIP LOCKED.

Đọc thêm: dual write và outbox với Debezium; outbox không thay được saga khi nhiều service cùng phải đổi dữ liệu; và thiết kế phát hiện gian lận bất đồng bộ, detector đứng sau Kafka, ngoài đường thanh toán.

8. Kết luận: nên hay không?

Ý chính: không nên làm mặc định. Gọi đồng bộ qua Kafka thêm hai chặng broker, một consumer group mỗi phía và một kho tương quan: bạn nhận mọi nhược điểm của RPC mà không có ưu điểm của messaging.

Đề xuất, theo thứ tự ưu tiên:

  1. Sửa được fraud-detection: HTTP/gRPC, timeout 300 ms, circuit breaker, chính sách UNKNOWN rõ. Vẫn bắn event FundTransferred qua outbox để fraud-detection học và hậu kiểm.
  2. Không sửa được: phương án A/B, topic command riêng, key là tài khoản, timeout 1–2 s, không chờ trên thread servlet (hoặc virtual thread của Java 21, spring.threads.virtual.enabled=true), timeout → PENDING_REVIEW.
  3. Nghiệp vụ chấp nhận: trả 202, giao dịch PENDING, đẩy kết quả cho app. Bền nhất khi fraud-detection có thể mất nhiều giây.
Bảng so sánh: thiết kế gốc và đề xuất hỏng thế nào
Kiểu hỏng Thiết kế gốc Thiết kế đề xuất
Fraud chậm 10 s Thread treo, trả 200 rỗng sau 5,5 phút Timeout 2 s → PENDING_REVIEW
Fraud chết Mọi request treo, cạn thread pool Circuit breaker mở, áp chính sách UNKNOWN ngay
Reply mất (crash sau commit) Fail-open Timeout → PENDING_REVIEW, hậu kiểm bù
Gửi command thất bại Không ai biết, vẫn chờ Future hoàn thành bằng lỗi ngay
Reply trùng Ghi đè khoá Redis (vô hại) Future đã xong, reply thứ hai bị bỏ
Ghi DB xong, Kafka lỗi Mất event Outbox gửi lại

Bài tập

Bài 1: Sửa vòng chờ mà không đổi kiến trúc

Giữ Redis làm kho tương quan. Viết lại vòng chờ sao cho: ngân sách 1 500 ms, khoảng cách giữa hai lần kiểm tra không quá 50 ms, luôn kiểm tra lần cuối trước khi báo timeout, và không chiếm thread servlet quá ngân sách. Tính số lệnh Redis tối đa cho một request.

Lời giải Bài 1: BLPOP, hoặc poll có trần

Cách ít thay đổi nhất là bỏ poll, dùng chờ chặn có timeout: instance nhận reply làm RPUSH reply:<id> <value> rồi EXPIRE reply:<id> 10; instance chờ gọi BLPOP reply:<id> 1.5. Một lệnh Redis mỗi request, reply được thấy ngay, timeout chính xác.

Nếu buộc phải poll: delay min(10 × 2^n, 50) ms, deadline = start + 1500, vòng lặp while (now < deadline), sau vòng lặp GET thêm một lần. Số lệnh tối đa ≈ 4 (10, 20, 40 ms) + (1 500 − 70)/50 ≈ 29 + 1 ≈ 34 lệnh.

Thread vẫn bị giữ tối đa 1,5 s, nên giới hạn số request đồng thời của endpoint (bulkhead) hoặc chạy trên virtual thread.

Bài 2: Viết hợp đồng message cho fraud-check

Viết header và body cho command và reply, nói rõ ai đặt trường nào, và fraud-detection làm gì với command đã quá hạn.

Lời giải Bài 2: header, body và xử lý command quá hạn
  • Command (topic fraud-check.commands, key debit_account). Header do bên gọi đặt: ce_id (UUID), ce_type=wallet.fraud-check.requested.v1, correlation-id, reply-topic, reply-partition, deadline (epoch ms), traceparent. Body: transaction_id, hai tài khoản, amount (số nguyên, đơn vị nhỏ nhất), currency, created_at.
  • Reply (topic và partition lấy từ header của command). Header: ce_id mới, ce_type=fraud-check.completed.v1, correlation-id chép nguyên. Body: verdict (APPROVED|REJECTED|REVIEW), score, reasons[], model_version.
  • Command có deadline < now thì bỏ qua và tăng metric “expired”. Chấm điểm idempotent theo transaction_id để command gửi lại không bị đếm hai lần.

Ghi nhớ

  • Giải thích được vì sao request-reply qua Kafka “lấy nhược điểm của RPC mà mất ưu điểm của messaging”.
  • Kể được ba cách để reply về đúng instance và giá của từng cách.
  • Chỉ ra được chuỗi null → NPE → catch → 200 rỗng biến timeout thành fail-open, và cách mô hình UNKNOWN.
  • Biết vì sao try/catch quanh send() không bắt được lỗi broker.
  • Giải thích được dual write, outbox, và vì sao consumer vẫn phải khử trùng.

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

Junior

Event và command khác nhau thế nào?

Event kể điều đã xảy ra và không chờ ai trả lời; command yêu cầu một bên cụ thể làm việc và thường cần kết quả.

Event (FundTransferred) bất biến, bên gửi không biết ai nghe. Command (CheckFraud) có một chủ sở hữu và có thể bị từ chối. Vòng đời, chủ sở hữu và số consumer khác nhau nên thường để ở topic khác nhau.

Correlation id dùng để làm gì trong request-reply?

Để ghép reply với đúng request đang chờ.

Bên gọi sinh một id duy nhất, gửi kèm request (thường trong header), bên trả lời chép nguyên id đó vào reply. Bên gọi giữ map id → future (hoặc khoá trong kho dùng chung) và hoàn thành future khi reply có id khớp.

Mid

Nhiều instance cùng chờ reply qua Kafka, làm sao reply về đúng instance?

Ba cách: group riêng mỗi instance, partition reply riêng mỗi instance, hoặc group chung cộng kho tương quan dùng chung.

  1. Mỗi instance một consumer group riêng trên topic reply, nhận mọi reply và bỏ phần không phải của mình: đơn giản, tốn N lần đọc.
  2. Mỗi instance sở hữu một partition reply, request mang header reply-partition, instance đọc bằng assign(): hiệu quả, cần danh tính ổn định.
  3. Group chung và kho tương quan như Redis (ai nhận cũng ghi vào kho, instance chờ đọc từ kho): thêm một hệ thống vào đường găng.
Dual write là gì và outbox giải quyết nó thế nào?

Dual write là ghi vào DB và Kafka mà không có transaction chung; outbox ghi cả hai vào DB trong một transaction rồi relay gửi sang Kafka.

Không có transaction chung thì một bên có thể thành công còn bên kia thất bại. Với outbox, relay (polling hoặc CDC) đọc bảng outbox và gửi đi. Kết quả là at-least-once, consumer cần khử trùng theo id message.

Thread pool của servlet bị cạn vì chờ reply, bạn xử lý thế nào?

Đặt timeout nghiệp vụ ngắn, rồi thôi chặn thread nền tảng: trả async từ controller hoặc dùng virtual thread, thêm bulkhead và circuit breaker.

  • Trả CompletableFuture/DeferredResult từ controller (Spring MVC hỗ trợ xử lý bất đồng bộ), hoặc virtual thread (Java 21, spring.threads.virtual.enabled=true) để thread chờ rẻ.
  • Bulkhead giới hạn số request đồng thời của endpoint này để không kéo chết endpoint khác.
  • Circuit breaker khi bên kia lỗi liên tục.

Senior

Bạn có đồng ý gọi fraud-check đồng bộ qua Kafka không?

Không làm mặc định: nó thêm hai chặng broker, một kho tương quan và coupling thời gian, mà người dùng vẫn phải chờ.

  • Sửa được fraud-detection: gọi HTTP/gRPC với timeout và circuit breaker, vẫn bắn event qua outbox cho hậu kiểm.
  • Bên kia chỉ nói Kafka: ReplyingKafkaTemplate hoặc reply partition theo instance, topic command riêng, timeout 1–2 s, kết quả UNKNOWN có chính sách rõ.
  • Sản phẩm cho phép: chuyển sang UX bất đồng bộ.
Fraud-check timeout thì giao dịch đi đâu?

Đó là quyết định nghiệp vụ và phải viết ra; về kỹ thuật, kết quả phải có trạng thái thứ ba UNKNOWN.

Lựa chọn: fail-closed (từ chối), fail-open (cho qua), hoặc lai: cho qua dưới hạn mức hoặc với người dùng tin cậy, còn lại PENDING_REVIEW và kiểm tra bù khi fraud sống lại. Không bao giờ để timeout biến thành null hay “sạch”. Theo dõi tỉ lệ UNKNOWN như một chỉ số rủi ro.

Vì sao Kryo với setRegistrationRequired(false) là rủi ro?

Vì dữ liệu chứa tên class và Kryo khởi tạo bất kỳ class nào trên classpath khi đọc: cùng họ lỗ hổng với Java deserialization.

Ai ghi được vào Redis có thể ép service khởi tạo class tuỳ ý. Định dạng còn gắn chặt với cấu trúc class, nên rolling deploy đổi field là instance cũ/mới không đọc được của nhau. Dùng JSON với kiểu cố định, hoặc bắt buộc đăng ký class, và bảo vệ Redis bằng ACL/TLS.

Relay outbox gửi trùng thì sao, idempotent producer có giúp không?

Không giúp; consumer phải khử trùng theo id message.

Relay chết sau khi Kafka ack nhưng trước khi đánh dấu đã gửi thì lô đó được gửi lại. Idempotent producer chỉ khử trùng retry nội bộ của cùng một producer session (PID + sequence), không khử được hai lần send từ hai session. Transactional producer cũng không gộp được với transaction của DB. Dùng bảng processed-message với unique constraint, trong cùng transaction với tác dụng 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
request-reply /rɪˈkwest rɪˈplaɪ/ mô hình gửi yêu cầu và chờ trả lời “Request-reply over Kafka adds two broker hops to every call.”
correlation id /ˌkɒrəˈleɪʃn aɪ diː/ mã ghép cặp request và reply “The responder copies the correlation id into the reply header.”
fail-open /feɪl ˈəʊpən/ lỗi thì cho qua “Returning null on timeout made the fraud check fail open.”
fail-closed /feɪl kləʊzd/ lỗi thì chặn lại “Above the limit we fail closed and hold the payment for review.”
thread exhaustion /θred ɪɡˈzɔːstʃən/ cạn thread “A five-minute wait on servlet threads leads to thread exhaustion.”
dual write /ˈdjuːəl raɪt/ ghi hai hệ thống không có transaction chung “Writing to the database and Kafka separately is a dual write.”
transactional outbox /trænˈzækʃənl ˈaʊtbɒks/ bảng outbox ghi cùng transaction “We moved to a transactional outbox to stop losing events.”
change data capture /tʃeɪndʒ ˈdeɪtə ˈkæptʃə/ đọc thay đổi từ log của DB “Change data capture removes the polling load from the outbox table.”
temporal coupling /ˈtempərəl ˈkʌplɪŋ/ phụ thuộc về thời gian, hai bên phải cùng sống “A synchronous call over a broker still has temporal coupling.”
bulkhead /ˈbʌlkhed/ vách ngăn giới hạn tài nguyên “A bulkhead caps concurrent fraud checks so other endpoints survive.”

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.