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

Tìm kiếm

System DesignSenior20 phút đọc

Case study: phát hiện gian lận với Kafka và Redis — topic, key, cửa sổ và hỏng hóc

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

Cụm bài Kafka: bài toán và pattern: 1. Số partition, message lớn, lag và tác vụ chạy lâu · 2. Dual write, exactly-once và thứ tự message · 3. Case study: phát hiện gian lận với Kafka và Redis

Một ví điện tử cỡ sàn crypto lớn có rất nhiều giao dịch mỗi phút, và cũng nhiều gian lận; luật cần bắt là “một tài khoản làm 100 giao dịch trong 5 phút thì báo động”. Thiết kế tổng quát (chấm điểm đồng bộ, API, fail-open, kế hoạch 45 phút) đã có ở case study phát hiện gian lận thanh toán; bài này chỉ đi sâu đường bất đồng bộ qua Kafka mà slide vẽ: topic và key, cửa sổ, đếm không trùng, hỏng hóc và scale. Slide chỉ đưa hai sơ đồ; số liệu và phần xử lý lỗi là mình tự làm.

1. Bài toán và yêu cầu

Ý chính: phát hiện nhanh tài khoản có tần suất giao dịch bất thường để giảm thiệt hại, mà không làm chậm hay làm hỏng luồng thanh toán.

  • Nhận mọi giao dịch của ví; tài khoản có ≥ 100 giao dịch trong bất kỳ 5 phút nào thì phát một “rule hit” cho đội rủi ro, service hành động (tạm khoá, xác thực thêm) và kho hồ sơ.
  • Thêm luật dạng “đếm/tổng trong cửa sổ” mà không viết lại hệ thống.

Yêu cầu phi chức năng (mình tự đặt số, vì slide chỉ ghi “phát hiện nhanh”):

Mục Mục tiêu
Độ trễ phát hiện p99 < 2 giây từ lúc giao dịch commit
Không bỏ sót mọi giao dịch đã commit đều được đếm (at-least-once)
Không đếm thừa giao lại không làm tăng số đếm
Ảnh hưởng tới thanh toán 0 ms thêm vào luồng thanh toán; detector chết không chặn thanh toán
Tải 100 triệu giao dịch/ngày, đỉnh gấp 10 trung bình

2. Ước lượng

Ý chính: tải nhỏ với Kafka; chỗ cần tính kỹ là số thao tác và bộ nhớ của Redis.

  • Trung bình: 100.000.000 / 86.400 ≈ 1.160 giao dịch/s.
  • Đỉnh: × 10 (thị trường biến động mạnh) ≈ 12.000/s; thiết kế cho 20.000/s để dư.
  • Băng thông Kafka: event ~300 B. 20.000 × 300 B = 6 MB/s vào. Mỗi ngày 100 triệu × 300 B = 30 GB, × RF 3 = 90 GB; giữ 7 ngày ≈ 630 GB trên cluster. Nhẹ.
  • Redis, số thao tác: mỗi event một lần gọi script Lua, tức 20.000 lệnh/s lúc đỉnh. Một node Redis chạy được vài chục nghìn script nhỏ mỗi giây; dùng Redis Cluster 3 shard để dư và có replica.
  • Redis, bộ nhớ: số phần tử nằm trong cửa sổ = tốc độ × độ dài cửa sổ = 20.000 × 300 s = 6 triệu phần tử lúc đỉnh. Mỗi phần tử sorted set ~100 B (member + score + chi phí skiplist và dict) ≈ 600 MB. Cộng ~1 triệu key tài khoản hoạt động × ~100 B = 100 MB. Tổng ~1 GB, thoải mái.
  • Partition: một detector gọi Redis tuần tự, round-trip ~0,5 ms, được ~2.000 event/s. 20.000 / 2.000 = 10, lấy 12, dư cho tăng trưởng thành 24 (chia đều cho 2, 3, 4, 6, 8, 12 instance).

3. API và mô hình dữ liệu

Ý chính: hai hợp đồng event (giao dịch vào, rule hit ra) và một cấu trúc state trong Redis là đủ; không cần API đồng bộ cho luồng chính.

Event giao dịch trên topic wallet.transactions, key = account_id:

{
  "event_id": "8f0c…",
  "transaction_id": "T3",
  "account_id": "A",
  "type": "TRANSFER_OUT",
  "amount": "10.00",
  "currency": "USDT",
  "occurred_at": 1712128559000
}

occurred_at là thời điểm commit lấy từ DB của ví (một nguồn đồng hồ), không phải đồng hồ của app server.

Rule hit trên topic fraud.rule-hits, key = account_id:

{
  "hit_id": "TX_VELOCITY_100_5M:A:1712128500000",
  "rule_id": "TX_VELOCITY_100_5M",
  "account_id": "A",
  "count": 100,
  "window_start": 1712128259000,
  "window_end": 1712128559000,
  "detected_at": 1712128559420
}

State trong Redis: một sorted set mỗi tài khoản, fraud:win:{A}, score = occurred_at, member = transaction_id. Đây đúng là bảng “A: Transactions (transaction_id, amount, timestamp)” trong slide, chỉ chọn cấu trúc Redis cho nó.

4. Vị trí của detector: sau Kafka, ngoài đường thanh toán

Ý chính: slide vẽ hai cách: ví gọi detector đồng bộ trước khi ghi giao dịch, hoặc ví ghi giao dịch rồi phát event để detector đọc qua Kafka. Luật đếm theo thời gian hợp với cách thứ hai; phần chấm điểm đồng bộ và fail-open đã phân tích ở case study tổng quát.

Với đường Kafka (slide 2): ví thực hiện giao dịch, ghi DB (TiDB), phát event vào Transaction Topic; Fraud Detector đọc, đếm trong Redis (Rule State), phát vào Rule Hit Topic. Thanh toán không phụ thuộc detector; đổi lại, giao dịch thứ 1 tới 100 đã đi trước khi phát hiện.

5. Thiết kế tổng thể

Ý chính: ví ghi giao dịch và outbox trong một transaction, CDC đẩy ra Kafka, detector đếm cửa sổ trượt trong Redis và phát rule hit cho các bên hành động.

flowchart LR
  U[User] -->|1 thanh toán| W[Wallet]
  W -->|2 giao dịch + outbox| DB[(Wallet DB TiDB)]
  DB -->|3 CDC| T[(wallet.transactions)]
  T -->|4 consume| D[Fraud Detector x N]
  D -->|5 Lua: đếm cửa sổ| R[(Rule State Redis)]
  D -->|6 alert| H[(fraud.rule-hits)]
  H --> A[Action service]
  H --> N[Cảnh báo đội rủi ro]
  A -->|cờ chặn| R
  W -.->|GET cờ chặn| R

Slide vẽ ví “emit” thẳng vào topic sau khi ghi DB, tức dual write: event mất thì gian lận lọt. Mình dùng outbox, với TiDB thì TiCDC đẩy ra Kafka (xem bài 2). Topic có 24 partition, group fraud-detector.

6. Deep dive: đếm cửa sổ trượt trong Redis

Ý chính: cửa sổ cố định (INCR theo phút) rẻ nhưng sai ở ranh giới và đếm trùng khi giao lại. Sorted set theo thời gian cho cửa sổ trượt chính xác và idempotent, đổi lại tốn bộ nhớ theo số giao dịch.

Cách đếm Cách làm Chính xác Idempotent khi giao lại Bộ nhớ mỗi tài khoản
Cửa sổ cố định INCR fraud:cnt:{A}:{phút/5} + EXPIRE sót ở ranh giới không 1 số
Bộ đếm trượt xấp xỉ 5 bucket 1 phút trong một hash, cộng lại gần đúng không 5 số
Log trượt (sorted set) ZADD từng giao dịch, xoá cũ, ZCOUNT đúng có số giao dịch trong 5 phút

Ví dụ lỗi ranh giới: kẻ gian làm 60 giao dịch lúc 10:04 và 60 giao dịch lúc 10:06. Hai cửa sổ cố định [10:00, 10:05) và [10:05, 10:10) mỗi bên chỉ thấy 60, không báo. Cửa sổ trượt 5 phút kết thúc lúc 10:06 thấy 120.

Script Lua chạy nguyên tử trong Redis, một round-trip cho mỗi event:

-- KEYS[1] = fraud:win:{A}
-- ARGV[1] = occurred_at (ms), ARGV[2] = transaction_id
-- ARGV[3] = window (300000), ARGV[4] = độ trễ cho phép (60000)
local ts, win, late = tonumber(ARGV[1]), tonumber(ARGV[3]), tonumber(ARGV[4])
redis.call('ZADD', KEYS[1], ts, ARGV[2])                      -- trùng member: không tăng
redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ts - win - late)
redis.call('PEXPIRE', KEYS[1], win + late)
return redis.call('ZCOUNT', KEYS[1], ts - win, ts)            -- số giao dịch trong 5 phút tới ts

Detector gọi script, nếu kết quả ≥ 100 thì phát rule hit. Dấu {A} trong key là hash tag của Redis Cluster, để mọi key của một tài khoản nằm cùng shard nếu sau này cần nhiều key. Khác với bộ đếm trong case study tổng quát (dùng giờ hệ thống lúc chấm điểm đồng bộ), ở đây score là event time lấy từ event Kafka, vì detector có thể chạy trễ.

Event time, event đến muộn và luật tính tổng tiền
  • Event time chứ không phải processing time: đếm theo occurred_at. Khi consumer lag 2 phút rồi đuổi kịp, các giao dịch vẫn rơi đúng cửa sổ của chúng. Đếm theo giờ xử lý thì lag làm 300 giao dịch trải 15 phút trông như dồn trong 5 phút: báo động giả.
  • Event đến muộn: sorted set sắp theo score nên event muộn tự vào đúng chỗ. ZCOUNT tính cửa sổ kết thúc tại chính event đó. Phần xoá chỉ xoá thứ cũ hơn ts − window − late, nên event muộn tối đa 60 giây vẫn có đủ hàng xóm để đếm. Event muộn hơn nữa thì đếm thiếu; thêm metric cho chúng.
  • Thứ tự trong partition gần như là thứ tự commit (outbox và key theo tài khoản), nên event muộn chủ yếu đến từ CDC chậm, hiếm.
  • Luật tổng tiền (“rút > 10.000 USD trong 1 giờ”): member là transaction_id, lưu số tiền vào một hash fraud:amt:{A} (field = transaction_id), hoặc mã hoá member thành T3|10.00. Script lấy ZRANGEBYSCORE trong cửa sổ và cộng: O(n) với n là số giao dịch trong cửa sổ, vẫn nhỏ. Nếu n có thể rất lớn, dùng bucket theo phút cho tổng (chấp nhận xấp xỉ) và giữ dedupe bằng một set transaction_id có TTL.
  • Nhiều luật: mỗi luật một cửa sổ riêng thì nhiều key; gộp các luật cùng loại sự kiện dùng chung một log trượt dài nhất, mỗi luật ZCOUNT với độ dài của mình.

7. Deep dive: Kafka và rule hit

Ý chính: key theo tài khoản cho thứ tự và tránh tranh chấp; at-least-once với phép đếm idempotent cho “không sót, không thừa”; rule hit cần chống bão cảnh báo.

  • Key = account_id: một tài khoản chỉ do một detector xử lý tại một thời điểm, nên không có hai instance cùng sửa một sorted set.
  • Bão cảnh báo: tài khoản đã vượt ngưỡng sẽ vượt tiếp với mỗi giao dịch sau. Chỉ phát một rule hit mỗi tài khoản mỗi luật trong 5 phút: SET fraud:hit:{A}:TX_VELOCITY NX PX 300000.
Cấu hình consumer và producer của detector
  • Một chủ cho mỗi key: script Lua đã nguyên tử, nên dù hai instance cùng chạm một key cũng không hỏng dữ liệu; một chủ cho mỗi key vẫn giữ thứ tự và dễ lý giải hơn.
  • Commit: tắt auto-commit, commit sau khi gọi Redis và (nếu có) gửi rule hit thành công. Crash giữa chừng thì xử lý lại, an toàn nhờ ZADD.
  • Gọi Redis theo lô: với mỗi batch từ poll(), pipeline các lời gọi script của nhiều tài khoản khác nhau để giảm round-trip; thứ tự trong cùng tài khoản vẫn giữ vì pipeline gửi theo thứ tự.
  • Producer rule hit: acks=all, idempotence bật.
  • Group riêng cho mỗi bên đọc rule hit: action service, cảnh báo, kho hồ sơ, để một bên chậm không kéo bên khác.

8. Hỏng hóc và cách sống sót

Ý chính: detector không giữ state cục bộ, Redis chỉ là bản tính được từ log Kafka, nên hầu hết sự cố hồi phục bằng cách đọc lại.

Sự cố Hậu quả Xử lý
Detector crash, rebalance xử lý lại vài event ZADD idempotent; rebalance nhanh vì không có state cục bộ
Lag tăng (đỉnh, Redis chậm) phát hiện trễ cảnh báo khi lag theo thời gian > 30 giây; scale tới 24 consumer
Redis failover sang replica mất vài lệnh ghi cuối (replication bất đồng bộ), đếm thiếu một chút chấp nhận, hoặc replay ngắn (dòng dưới)
Mất toàn bộ Redis mất toàn bộ cửa sổ dựng Redis mới, reset offset group về now − 6 phút (--to-datetime), replay; ZADD bỏ trùng
Ví mất event gian lận lọt outbox + CDC thay cho emit trực tiếp
Tài khoản bot làm 10.000 giao dịch/5 phút sorted set 10.000 phần tử, một partition nặng hơn vẫn nhỏ; cờ chặn dừng giao dịch sau rule hit đầu
Detector chết hẳn không phát hiện, thanh toán vẫn chạy cảnh báo vận hành; đó là cái giá đã chọn ở mục 4

Ý chính: stream processor có sẵn cửa sổ theo event time, state cục bộ và exactly-once Kafka → Kafka; Redis thì linh hoạt hơn cho luật động và cho ví đọc đồng bộ.

builder.stream("wallet.transactions", Consumed.with(Serdes.String(), txSerde))
  .groupByKey()
  .windowedBy(SlidingWindows.ofTimeDifferenceAndGrace(Duration.ofMinutes(5), Duration.ofMinutes(1)))
  .count()
  .toStream()
  .filter((windowedAccount, count) -> count >= 100)
  .map((w, count) -> KeyValue.pair(w.key(), RuleHit.of(w, count)))
  .to("fraud.rule-hits");

10. Scale detector và đổi số partition

Ý chính: detector không giữ state nên scale chỉ là thêm consumer, tới đúng số partition. Vì state nằm ở Redis theo account_id chứ không theo partition, ngay cả việc tăng partition cũng không làm hỏng phép đếm.

  • Thêm consumer: tối đa 24 consumer có việc (bằng số partition). Dùng CooperativeStickyAssignor và group.instance.id (static membership) để deploy cuốn chiếu không dừng cả group.
  • Tăng partition: key A có thể chuyển sang partition khác. Với state ngoài, consumer mới vẫn đọc đúng sorted set fraud:win:{A}; chỉ cần tránh lúc chuyển hai consumer cùng xử lý A (script Lua đã nguyên tử nên vẫn đúng). Với Kafka Streams, state cục bộ chia theo partition, nên tăng partition đầu vào buộc phải reset ứng dụng hoặc repartition.
  • Giám sát: lag theo thời gian của group fraud-detector là chỉ số chính, vì lag chính là độ trễ phát hiện. Thêm p99 latency của script Lua và số event bị bỏ vì quá muộn.

Kế hoạch trình bày 45 phút cho cả bài toán có ở case study tổng quát; khi được hỏi sâu phần Kafka, mình dùng mục 6–9 của bài này.

Bài tập

Bài 1: Thêm luật “rút nhiều tiền”

Thêm luật: tổng số tiền rút của một tài khoản vượt 10.000 USD trong 1 giờ thì báo động. Tải rút tiền đỉnh 2.000/s. Thiết kế state, tính bộ nhớ Redis, và nói luật mới có cần topic mới không.

Lời giải Bài 1
  • Topic: không cần topic mới; detector lọc type = WITHDRAW trên wallet.transactions. Nếu muốn tách deploy, tạo consumer group riêng fraud-withdraw đọc cùng topic.
  • State: sorted set fraud:wd:{A} (score = occurred_at, member = transaction_id) và hash fraud:wdamt:{A} (field = transaction_id, value = số tiền quy USD). Script: ZADD, HSET, xoá phần tử cũ hơn 1 giờ + 1 phút ở cả hai, rồi cộng số tiền trong cửa sổ.
  • Bộ nhớ: 2.000/s × 3.600 s = 7,2 triệu phần tử lúc đỉnh kéo dài, × ~(100 + 80) B ≈ 1,3 GB. Chấp nhận được, nhưng cộng O(n) mỗi event có thể chậm với tài khoản nhiều giao dịch.
  • Tối ưu: giữ thêm một tổng chạy fraud:wdsum:{A}; khi thêm thì cộng, khi xoá phần tử hết hạn thì trừ đúng số tiền của chúng (lấy từ hash trước khi xoá). Mỗi event chỉ chạm phần tử mới và phần tử hết hạn, không cộng lại cả cửa sổ.
  • Idempotent: chỉ cộng tổng khi ZADD trả 1 (member mới), nhờ vậy giao lại không cộng thừa.

Ghi nhớ

  • Ước lượng được tải Kafka và bộ nhớ Redis cho 100 triệu giao dịch/ngày, có phép tính.
  • Giải thích được vì sao cửa sổ cố định bỏ sót và đếm thừa, còn sorted set thì không.
  • Giải thích được vì sao detector không state scale dễ, và vì sao tăng partition không hỏng phép đếm trong Redis.
  • Biết thứ tự “gửi rule hit rồi mới đặt cờ” và vì sao.
  • Kể được cách hồi phục khi mất Redis bằng replay từ Kafka.

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

Junior

Vì sao chọn account_id làm key của topic giao dịch?

Để mọi giao dịch của một tài khoản vào cùng partition, giữ thứ tự và chỉ một detector xử lý tài khoản đó tại một thời điểm.

Nhờ vậy không có hai instance cùng sửa state của một tài khoản. Phân bố tải vẫn đều vì có hàng triệu tài khoản.

Cửa sổ cố định và cửa sổ trượt khác nhau thế nào?

Cửa sổ cố định chia thời gian thành ô liền kề (10:00–10:05, 10:05–10:10); cửa sổ trượt luôn nhìn 5 phút tính lùi từ mỗi event.

Cửa sổ cố định bỏ sót chuỗi giao dịch vắt qua ranh giới hai ô; cửa sổ trượt thì không, đổi lại phải nhớ từng giao dịch.

Mid

Tăng partition của topic giao dịch thì phép đếm có bị hỏng không?

Không, vì state nằm trong Redis theo account_id, không gắn với partition; consumer mới nhận key vẫn đọc đúng sorted set.

Nếu đếm bằng state cục bộ của Kafka Streams thì khác: state chia theo partition, tăng partition đầu vào phải reset hoặc repartition. Dù sao cũng nên cấp dư partition từ đầu để tránh việc này.

Consumer crash và Kafka giao lại event. Số đếm có bị sai không?

Không, nếu đếm bằng sorted set với member là transaction_id: thêm lại cùng member không tăng số phần tử.

Với INCR thì sai. Cách chung là chọn thao tác idempotent tự nhiên hoặc dedupe theo id trước khi cộng.

Tài khoản đã vượt ngưỡng, mỗi giao dịch sau lại vượt tiếp. Làm sao không gửi 1.000 cảnh báo?

Chỉ phát một rule hit mỗi tài khoản mỗi luật trong một khoảng, bằng cờ SET NX PX trong Redis, và bên nhận dedupe theo hit_id.

Gửi rule hit trước, đặt cờ sau; ngược lại crash giữa hai bước làm mất cảnh báo.

Senior

Redis mất sạch dữ liệu. Hệ thống hồi phục thế nào?

Dựng Redis mới, reset offset của group về khoảng 6 phút trước và đọc lại; phép đếm idempotent nên đọc lại không đếm thừa.

State của detector chỉ phụ thuộc 5 phút gần nhất trong log, còn topic giữ 7 ngày, nên Redis không cần backup. Trong lúc replay, phát hiện trễ vài phút; cờ chặn đã có thì nằm ở dữ liệu riêng cần backup hoặc dựng lại từ topic rule hit.

Vì sao đếm theo event time thay vì thời điểm consumer xử lý?

Vì khi consumer lag rồi đuổi kịp, đếm theo giờ xử lý sẽ dồn giao dịch của 15 phút vào 5 phút và báo động giả.

Event time lấy từ thời điểm commit ở DB của ví (một nguồn đồng hồ). Cần thêm độ trễ cho phép cho event đến muộn và metric đếm event bị bỏ vì quá muộn.

Bạn có dùng Kafka Streams thay Redis không?

Có thể: Streams có sẵn sliding window, state cục bộ và exactly-once Kafka sang Kafka. Mình chọn theo việc luật thay đổi thường xuyên đến đâu và ai cần đọc state.

Luật ít, cố định, tải lớn: Streams. Nhiều luật do đội rủi ro chỉnh, ví cần đọc cờ đồng bộ: Redis. Streams cần standby replica để rebalance không phải khôi phục state lâu.

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
fraud detection /frɔːd dɪˈtekʃn/ phát hiện gian lận “Fraud detection runs asynchronously off the transaction stream.”
rule hit /ruːl hɪt/ một lần luật bị vi phạm “Every rule hit goes to a dedicated topic.”
sliding window /ˈslaɪdɪŋ ˈwɪndəʊ/ cửa sổ trượt “A sliding window catches bursts that straddle two fixed windows.”
fixed window /fɪkst ˈwɪndəʊ/ cửa sổ cố định “Fixed windows are cheap but miss boundary bursts.”
sorted set /ˈsɔːtɪd set/ tập có sắp xếp của Redis “We keep one sorted set per account, scored by event time.”
event time /ɪˈvent taɪm/ thời điểm sự kiện xảy ra “We count by event time, so consumer lag doesn’t cause false alerts.”
late event /leɪt ɪˈvent/ sự kiện đến muộn “We allow one minute of lateness.”
alert storm /əˈlɜːt stɔːm/ bão cảnh báo “A per-account cooldown prevents an alert storm.”
fail-open /feɪl ˈəʊpən/ lỗi thì cho qua “Small payments fail open if the flag lookup times out.”
replay /ˌriːˈpleɪ/ đọc lại từ log “If Redis is lost, we replay the last six minutes from Kafka.”

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.