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

Tìm kiếm

System DesignMid17 phút đọc

Ước lượng back-of-the-envelope: con số phải thuộc và cách tính nhanh

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

Ước lượng là bước biến “hệ thống lớn” thành “100 lần ghi và 10K lần đọc mỗi giây, 50 TB trong 4 năm”. Bài này gom các con số cần thuộc, mẹo tính nhẩm, và làm lại bài URL shortener từng bước để thấy mỗi con số dẫn tới quyết định nào. Nên đọc trước quy trình phỏng vấn system design.

Sơ đồ tóm tắt:

flowchart LR
  A["Giả định và nói ra"] --> B["Quy về mỗi giây"]
  B --> C["Nhân hệ số đỉnh"]
  C --> D["Little's Law: thread, connection"]
  C --> E["Dung lượng, RAM, băng thông"]
  D --> F["Quyết định: server, cache, sharding"]
  E --> F

1. Ước lượng để làm gì

Ý chính: ước lượng để biết kích cỡ hệ thống, đánh giá thiết kế, tìm bottleneck, và quyết định những thứ đắt như sharding. Nó không cho con số đúng, nó cho bậc độ lớn đúng.

Bốn mục tiêu của bước ước lượng:

  • Định ra mục tiêu của thiết kế (cần chịu bao nhiêu QPS).
  • Đánh giá thiết kế (một database có chịu nổi không).
  • Tìm bottleneck tiềm năng (đọc, ghi, băng thông hay dung lượng).
  • Quyết định có cần partition hoặc sharding database không.

Nguyên tắc khi ước lượng:

  • Thực tế không ước lượng chính xác được. Mục tiêu là biết kích cỡ, không phải con số tới hàng đơn vị.
  • Dựa trên kinh nghiệm và hệ thống tham chiếu. Biết một PostgreSQL thường chịu bao nhiêu thì mới ước được cần mấy cái.
  • Chia nhỏ rồi cộng lại: tách theo từng loại thao tác, từng loại dữ liệu.
  • Nguyên tắc 80/20: 20% dữ liệu nhận 80% lượt đọc, nên cache 20% là đủ đỡ phần lớn tải.
  • Theo tài nguyên đang có: tài nguyên dư thì ước thừa khoảng 20%; tài nguyên eo hẹp thì chuẩn bị đường lui (fail-safe, phương án B).

2. Những con số phải thuộc

Ý chính: thuộc vài nhóm con số (thời gian, kích thước, availability, latency) là đủ để tính nhẩm mọi bài. Phần còn lại là phép nhân luỹ thừa 10.

Đại lượng Giá trị thật Dùng để tính nhẩm
Giây trong 1 ngày 86.400 10⁵
Giây trong 1 tháng ~2,6 triệu 2,5 × 10⁶
Giây trong 1 năm ~31,5 triệu 3 × 10⁷
1 triệu sự kiện/ngày 11,6/giây ~12/giây
1 tỉ sự kiện/ngày 11.600/giây ~12K/giây
Kiểu dữ liệu Kích thước
int 4 B
bigint/long, double 8 B
boolean 1 B
timestamp (PostgreSQL) 8 B
UUID 16 B
Ký tự UTF-8 1 B (ASCII) tới 4 B; chữ Việt có dấu thường 2–3 B
Availability Thời gian chết mỗi năm Mỗi tháng
99% ~3,65 ngày ~7,2 giờ
99,9% ~8,8 giờ ~43 phút
99,95% ~4,4 giờ ~22 phút
99,99% ~52 phút ~4,3 phút
99,999% ~5,3 phút ~26 giây
99,9999% ~31 giây ~2,6 giây

Đơn vị: K = 10³, M = 10⁶, G = 10⁹, T = 10¹², P = 10¹⁵. Mẹo của khoá học: M × K = G (một triệu bản ghi, mỗi bản ghi 1 KB, là 1 GB).

Latency và sức chịu tải: các con số tham khảo

Con số latency nên thuộc (bậc độ lớn, phần cứng hiện đại):

Thao tác Thời gian
Đọc L1 cache ~1 ns
Đọc RAM ~100 ns
Đọc ngẫu nhiên 4 KB từ SSD NVMe ~20–100 µs
Đọc tuần tự 1 MB từ SSD ~0,1–0,3 ms
Round trip trong cùng datacenter ~0,5 ms
Một lệnh GET Redis qua mạng nội bộ ~0,2–0,5 ms
Tra cứu theo primary key trên PostgreSQL (dữ liệu trong RAM) ~0,5–1 ms
Seek trên HDD ~5–10 ms
Round trip Việt Nam – Mỹ ~150–250 ms

Sức chịu tải của một node (thô, phải benchmark cho tải thật):

  • Một instance Spring Boot làm CRUD đơn giản: khoảng 1K–5K RPS, tuỳ CPU và độ nặng của logic.
  • PostgreSQL hoặc MySQL một node: đọc đơn giản theo index chục nghìn QPS; ghi có fsync mỗi commit vài nghìn TPS (group commit giúp nhiều).
  • Redis một node: khoảng 100K lệnh/giây với lệnh O(1); pipeline thì cao hơn nhiều.
  • Kafka một broker: hàng trăm MB/giây ghi tuần tự.

Từ đây có quy tắc nhanh: dưới vài nghìn TPS ghi thì một database chính với replica thường đủ; vượt mức đó, hoặc dữ liệu vượt vài TB, mới bàn tới sharding.

3. Mẹo tính nhanh

Ý chính: làm tròn, gom luỹ thừa 10, quy về “mỗi giây” trước, nhân hệ số đỉnh, và thiếu thông tin thì tự giả định rồi nói ra.

  • Viết đơn vị bên cạnh mọi con số. Nhầm KB với MB là lỗi phổ biến nhất.
  • Làm tròn về luỹ thừa của 2 hoặc 10. 86.400 thành 10⁵, 1,1 KB giữ nguyên hệ số rồi gom phần mũ.
  • Gom mũ: 10⁶ ÷ 10² × 10³ = 10^(6 − 2 + 3) = 10⁷.
  • Quy về thao tác mỗi giây (OPS) trước, rồi mới nhân ra dung lượng, băng thông.
  • Nhân hệ số đỉnh: tải giờ cao điểm thường gấp 2–3 lần trung bình, flash sale có thể gấp 10–100 lần.
  • Thiếu thì giả định: “mình giả định mỗi bản ghi 1 KB” rồi đi tiếp, không đứng chờ.

Quy tắc 72: thời gian để một đại lượng tăng gấp đôi ≈ 72 ÷ (tốc độ tăng theo %). Dữ liệu tăng 20%/năm thì khoảng 3,6 năm gấp đôi (tính chính xác là ~3,8 năm). Dùng để trả lời “dung lượng hiện tại đủ dùng bao lâu”.

4. Ví dụ mẫu: URL shortener

Ý chính: từ bốn con số (10 triệu lần ghi/ngày, đọc:ghi 100:1, mã ngắn tối đa 8 ký tự, giữ 4 năm) suy ra QPS, dung lượng, RAM cache, băng thông, và cả độ dài mã ngắn.

Câu hỏi và câu trả lời (giả định của đề):

  1. Trung bình bao nhiêu lần ghi mỗi ngày? 10 triệu.
  2. Tỉ lệ đọc:ghi? 100:1.
  3. Mã ngắn dài bao nhiêu? Tối đa 8 ký tự.
  4. Giữ link bao lâu? 4 năm.

Traffic. 10⁷ lần ghi/ngày ÷ 10⁵ giây = 10² = 100 TPS ghi. Đọc gấp 100 → 10K QPS đọc. Giờ cao điểm nhân 3: ~300 TPS ghi, ~30K QPS đọc.

Dung lượng một bản ghi. URL gốc 1 KB, mã ngắn 10 B, user_id 16 B, created_at, expires_at, updated_at mỗi cái 8 B → ~1,1 KB.

Dung lượng 4 năm. 1,1 KB × 10⁷ × 400 ngày × 4 năm = (1,1 × 4 × 4) × 10^(3 + 7 + 2) = 17,6 × 10¹² = 17,6 TB. Slide làm tròn năm thành 400 ngày cho dễ nhân (con số thật là ~16 TB). Nhân hệ số nhân bản 3 → ~53 TB.

RAM cho cache. Áp 80/20 trên lượng link mới trong 1 ngày, TTL 1 ngày: 10⁷ × 1,1 KB × 0,2 = 0,22 × 10¹⁰ = 2,2 GB. Một node Redis dư sức.

Băng thông. Bỏ qua chiều ghi vì chỉ bằng 1% chiều đọc. Request GET khoảng 1 KB (không tính cookie, token): vào 10K × 1 KB = 10 MB/s. Slide tính chiều ra là 10K × (1 + 1,1) KB = 21 MB/s.

Độ dài mã (bổ sung). 4 năm cần 10⁷ × 365 × 4 ≈ 1,5 × 10¹⁰ mã. Với bảng chữ base62: 62⁶ ≈ 5,7 × 10¹⁰ (dư ~4 lần), 62⁷ ≈ 3,5 × 10¹² (dư ~240 lần). 7 ký tự là lựa chọn thoải mái, vẫn dưới giới hạn 8.

Đại lượng Kết quả
Ghi 100 TPS (đỉnh ~300)
Đọc 10K QPS (đỉnh ~30K)
Lưu trữ 4 năm ~17,6 TB, ×3 bản sao ≈ 53 TB
Cache ~2,2 GB
Băng thông vào / ra ~10 MB/s / ~15–21 MB/s
Độ dài mã 7 ký tự base62

5. Từ con số tới quyết định

Ý chính: con số chỉ có giá trị khi dẫn tới một quyết định: bao nhiêu server, có cần cache, có cần sharding. Nói luôn quyết định ngay sau mỗi phép tính.

Với URL shortener:

  • 30K QPS đọc ở đỉnh: một PostgreSQL không nên gánh trực tiếp. Cache Redis với tỉ lệ trúng 90% còn ~3K QPS xuống database, một primary với 1–2 replica đủ đọc.
  • 300 TPS ghi: một database chính dư sức, chưa cần sharding vì ghi.
  • 53 TB sau 4 năm: đây mới là lý do cân nhắc chia dữ liệu. Một node PostgreSQL vận hành thoải mái ở vài TB. Phương án: partition theo thời gian và xoá phần hết hạn, hoặc dùng kho key-value phân tán (Cassandra, DynamoDB) vì truy cập chỉ theo khoá.
  • Số server ứng dụng (Little’s Law): 30K QPS × 20 ms = 600 request cùng lúc. Mỗi instance Tomcat 200 thread, giữ dưới 50% → 100 request/instance → 6 instance, cộng dự phòng một node chết → 7–8 instance. Con số này vẫn là giả thuyết, cần kiểm lại bằng capacity test như trong Performance test.
Kích thước thread pool từ thời gian chờ và thời gian chạy

Hai công thức trong slide hiệu năng là hệ quả trực tiếp của Little’s Law cho một CPU:

  • Việc nặng CPU: số thread ≈ số core (+1 để bù lúc một thread bị page fault). Thêm thread chỉ tăng context switch.
  • Việc nặng I/O: số thread ≈ số core × (1 + thời gian chờ ÷ thời gian chạy CPU).

Ví dụ: máy 8 core, mỗi request chạy CPU 5 ms và chờ database, API khác 45 ms → 8 × (1 + 45/5) = 80 thread để giữ CPU bận. Nhiều hơn thì request chỉ xếp hàng trong RAM; ít hơn thì CPU rảnh trong khi request chờ.

Với virtual thread (Java 21), giới hạn số thread gần như biến mất, nhưng giới hạn chuyển sang tài nguyên phía sau: pool connection database vẫn tính bằng Little’s Law như ví dụ ở mục 3. Chi tiết ở bài ExecutorService và virtual thread.

Bài tập

Bài 1: Ước lượng luồng vị trí tài xế

Đề (tự đặt): ứng dụng giao đồ ăn có 500K tài xế online ở giờ cao điểm, mỗi tài xế gửi vị trí 4 giây một lần (vĩ độ, kinh độ, thời điểm, id tài xế). Tính QPS ghi, băng thông vào, và dung lượng nếu giữ lịch sử 30 ngày. Có nên ghi thẳng vào PostgreSQL không?

Lời giải bài 1
  • QPS ghi: 5 × 10⁵ ÷ 4 = 125K lần ghi/giây ở đỉnh.
  • Kích thước một bản ghi: lat, lng 8 B mỗi cái, thời điểm 8 B, id 8 B → 32 B dữ liệu; gói tin thực tế với header khoảng 200 B.
  • Băng thông vào: 125K × 200 B = 25 MB/s.
  • Lịch sử 30 ngày: giả định tải trung bình bằng 1/3 đỉnh → ~40K/giây × 10⁵ giây × 30 ngày × 32 B ≈ 3,5–4 TB dữ liệu thô, chưa tính index và bản sao.

Quyết định: 125K lần ghi/giây vượt xa một PostgreSQL. Tách hai nhu cầu: vị trí hiện tại chỉ cần bản mới nhất, để trong Redis (GEO hoặc hash theo tài xế) và ghi đè; lịch sử đi qua Kafka rồi ghi theo lô vào kho phân tích (ClickHouse, object storage). Database giao dịch chỉ nhận sự kiện có nghĩa nghiệp vụ như “đã lấy hàng”.

Bài 2: Dung lượng còn đủ bao lâu

Đề (tự đặt): database đang dùng 4 TB trên ổ 10 TB, dữ liệu tăng 25%/năm. Khi nào chạm 80% ổ?

Lời giải bài 2

Ngưỡng 80% là 8 TB, tức gấp đôi hiện tại. Quy tắc 72: 72 ÷ 25 ≈ 2,9 năm. Tính chính xác: ln 2 ÷ ln 1,25 ≈ 3,1 năm. Kết luận: có khoảng hai năm rưỡi để lên kế hoạch, vì chuyển dữ liệu (partition, archive, đổi ổ) cũng mất vài tháng.

Bài 3: Kích thước pool connection

Đề (tự đặt): service nhận 1.500 request/giây ở đỉnh, mỗi request chạy 2 query, mỗi query p50 = 4 ms, p99 = 40 ms. Pool connection bao nhiêu là hợp lý cho mỗi instance nếu chạy 6 instance?

Lời giải bài 3
  • λ = 1.500 × 2 = 3.000 query/giây toàn cụm.
  • Theo p50: L = 3.000 × 0,004 = 12 connection bận cùng lúc. Theo thời điểm xấu (p99): 3.000 × 0,04 = 120.
  • Chia 6 instance: 2 tới 20 connection mỗi instance. Chọn khoảng 10–15, kèm timeout lấy connection ngắn (vài trăm ms) để lỗi nhanh khi database chậm thay vì treo hết thread.
  • Kiểm tra phía database: 6 × 15 = 90 connection, dưới max_connections mặc định 100 của PostgreSQL nhưng sát; thêm instance thì cần PgBouncer.

Ghi nhớ

  • Tính nhẩm được 10 triệu/ngày ra bao nhiêu mỗi giây, và nhớ nhân hệ số đỉnh.
  • Đọc được bảng số 9: 99,9% và 99,99% tương ứng bao nhiêu phút chết mỗi năm.
  • Dùng Little’s Law để ra số connection, thread hoặc server từ QPS và latency.
  • Làm lại bài URL shortener: QPS, dung lượng, cache, băng thông, độ dài mã.
  • Nói được mỗi con số dẫn tới quyết định gì (cache, replica, sharding, số instance).

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

Junior

1 triệu request mỗi ngày là bao nhiêu request mỗi giây?

Khoảng 12 request/giây, vì một ngày có ~86.400 ≈ 10⁵ giây.

Đó là trung bình; giờ cao điểm thường gấp 2–3 lần, nên thiết kế cho khoảng 30–40 RPS.

Availability 99,99% nghĩa là được chết bao lâu?

Khoảng 52 phút mỗi năm, hay 4,3 phút mỗi tháng.

Đủ ngắn để không thể khôi phục bằng tay: cần failover tự động và triển khai không downtime.

Mid

Little’s Law là gì và bạn dùng nó thế nào?

L = λ × W: số request đang xử lý bằng tốc độ đến nhân thời gian xử lý. Mình dùng để ra kích thước pool connection, số thread và số server.

Ví dụ 3.000 query/giây, mỗi query 5 ms → 15 connection bận. Hệ quả quan trọng: latency tăng 10 lần thì cần gấp 10 lần connection, đó là cách một database chậm làm cạn pool của cả cụm ứng dụng.

Mã ngắn của URL shortener nên dài bao nhiêu ký tự?

7 ký tự base62: 62⁷ ≈ 3,5 nghìn tỉ mã, dư khoảng 240 lần so với 15 tỉ link trong 4 năm.

6 ký tự (~57 tỉ) vẫn đủ nhưng chỉ dư ~4 lần, dễ đụng trần nếu tải tăng hoặc dùng sinh ngẫu nhiên (va chạm tăng khi không gian đầy dần).

Senior

Bạn ước lượng xong 30K QPS đọc. Tiếp theo bạn ra quyết định gì?

Đặt cache trước database và tính lại tải còn xuống database, rồi mới chọn số replica và số instance ứng dụng.

Với tỉ lệ trúng cache 90%, database chỉ nhận ~3K QPS, một primary và 1–2 replica là đủ. Số instance ứng dụng tính bằng Little’s Law từ latency mục tiêu, cộng dự phòng một vùng sập.

Khi nào nên ước lượng thừa, khi nào nên ước lượng sát?

Ước thừa cho thứ khó đổi (khoá shard, schema, độ dài ID), ước sát cho thứ dễ thêm (instance stateless, node cache).

Thứ khó đổi mà ước thiếu thì phải di chuyển dữ liệu lúc đang chạy, rất đắt. Thứ dễ thêm thì autoscale lo, ước thừa chỉ tốn tiền.

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
back-of-the-envelope /bæk əv ði ˈen.və.loʊp/ ước lượng nhanh trên giấy nháp “Let me do a quick back-of-the-envelope estimate.”
order of magnitude /ˈɔːr.dɚ əv ˈmæɡ.nə.tuːd/ bậc độ lớn “I only need the right order of magnitude here.”
peak traffic /piːk ˈtræf.ɪk/ tải đỉnh “I’ll assume peak traffic is three times the average.”
read-to-write ratio /riːd tə raɪt ˈreɪ.ʃi.oʊ/ tỉ lệ đọc:ghi “With a 100 to 1 read-to-write ratio, reads dominate.”
replication factor /ˌrep.ləˈkeɪ.ʃən ˈfæk.tɚ/ số bản sao “With a replication factor of three, we need about 50 terabytes.”
headroom /ˈhed.ruːm/ khoảng dư “Seven characters give us plenty of headroom.”
capacity planning /kəˈpæs.ə.t̬i ˈplæn.ɪŋ/ lập kế hoạch dung lượng “Capacity planning tells us when we’ll need to partition.”
throughput /ˈθruː.pʊt/ lưu lượng xử lý “The write throughput is only a hundred per second.”
round up /raʊnd ʌp/ làm tròn lên “I’ll round a day up to ten to the fifth seconds.”
rule of thumb /ruːl əv θʌm/ quy tắc kinh nghiệm “As a rule of thumb, one Redis node handles about 100K ops per second.”

Ghi chép dựa trên khoá System Design (Ronin Engineer), viết lại theo cách hiểu của mình.