Hệ phân tán: nhiều cỗ máy phải cư xử như một
Làm sao nhiều máy, máy nào cũng có thể hỏng, mạng có thể mất tin, vẫn chạy như một: lỗi từng phần, đồng hồ Lamport, đồng thuận đa số, MapReduce.
Ban biên tập OpenER
Cập nhật 18/11/2026 · 19 phút đọc · CC BY 4.0
Chiều 20/10/2025 theo giờ Việt Nam, rất nhiều người trên thế giới mở những ứng dụng quen thuộc — nhắn tin, trò chơi trực tuyến, camera chuông cửa — và thấy chúng đứng hình, dù điện thoại của họ chẳng hỏng gì. Nguyên nhân nằm trong các trung tâm dữ liệu của Amazon Web Services (AWS) ở bang Virginia, Mỹ: một lỗi tranh chấp (race condition) hiếm gặp giữa hai tiến trình tự động cùng cập nhật bản ghi tên miền (DNS) đã để lại một bản ghi trống cho DynamoDB, dịch vụ cơ sở dữ liệu mà nhiều dịch vụ khác dựa vào. Sự cố lan ra hàng loạt dịch vụ và kéo dài hơn mười bốn tiếng.
Leslie Lamport, một trong những người đặt nền cho ngành này, từng viết trong một thư điện tử năm 1987, đại ý: hệ phân tán là hệ mà ở đó, một chiếc máy tính bạn thậm chí không biết là có tồn tại bị hỏng cũng đủ làm máy của chính bạn không dùng được.
Điều đáng ngạc nhiên hơn là chiều ngược lại: ngày thường, trong các trung tâm dữ liệu ấy lúc nào cũng có máy hỏng, ổ đĩa chết, cáp đứt — vậy mà bạn vẫn xem video, chuyển tiền, nhắn tin như không có gì. Một hệ phân tán (distributed system) là nhiều máy tính nối với nhau qua mạng, phối hợp để trông như một hệ thống duy nhất. Môn Hệ phân tán học cách làm cho điều đó đúng, kể cả khi máy hỏng và mạng mất tin.
Trước khi có hệ phân tán
Thời máy tính lớn, mỗi tổ chức có một cỗ máy: một bộ nhớ, một đồng hồ, và chỉ hai trạng thái — đang chạy hoặc đã dừng. Nó hỏng thì ai cũng biết, mọi người cùng chờ sửa. Ba điều tưởng hiển nhiên ấy chính là thứ hệ phân tán đánh mất. Ngành này lớn lên từng bước:
- Nối các máy lại — thập niên 1970. ARPANET, mà bài Mạng máy tính đã kể, cho các máy nói chuyện với nhau; việc tìm đường trong nó đã là một thuật toán phân tán. Ngày 27/10/1980, phần cứng trục trặc làm rơi bit trong số thứ tự của một tin cập nhật đường đi: tin số 44 sinh thêm hai bản mang số 40 và 8. Theo luật so sánh của mạng, 44 mới hơn 40, 40 mới hơn 8, còn 8 lại mới hơn 44 — ba bản đuổi nhau mãi, và ARPANET gần như tê liệt mấy tiếng đồng hồ.
- Lý thuyết về thời gian và về lỗi — 1978 đến 1985. Năm 1978, Lamport chỉ ra rằng trên nhiều máy, "việc nào xảy ra trước" phải được định nghĩa lại. Năm 1982, ông cùng Robert Shostak và Marshall Pease công bố bài toán các vị tướng Byzantine (Byzantine generals problem): thống nhất khi có máy không chỉ hỏng mà còn nói dối. Năm 1985, Michael Fischer, Nancy Lynch và Michael Paterson chứng minh định lý FLP: nếu độ trễ của mạng không có giới hạn, không thuật toán tất định nào bảo đảm luôn đi tới thống nhất, dù chỉ một máy có thể chết.
- Đồng thuận dùng được — 1988 đến 1998. Brian Oki và Barbara Liskov ở MIT (1988), và Lamport với thuật toán Paxos (viết năm 1989), độc lập tìm ra cách cho một nhóm máy thống nhất dù vài máy hỏng. Lamport kể Paxos như chuyện về quốc hội tưởng tượng trên một hòn đảo Hy Lạp cổ; người phản biện không mặn mà, và tới năm 1998 bài mới được đăng. Lamport nhận Giải Turing năm 2013.
- Hàng nghìn máy rẻ tiền — 2003 đến 2006. Google công bố hệ thống file GFS (2003) và mô hình MapReduce (2004): dùng hàng nghìn máy thường, coi hỏng hóc là chuyện thường ngày — bài Nguyên lý hệ thống máy tính đã kể. Năm 2006, bản mã nguồn mở Hadoop đưa cách làm này tới mọi công ty.
- Đồng thuận cho mọi người — 2014. Diego Ongaro và John Ousterhout ở Stanford công bố Raft, thuật toán đồng thuận lấy dễ hiểu làm mục tiêu số một. Ngày nay Raft chạy trong etcd — nơi Kubernetes giữ trạng thái của cả cụm máy — và trong nhiều cơ sở dữ liệu phân tán.
Đặt cạnh nhau:
Một máy làm tất cả | Hệ phân tán | |
|---|---|---|
Khi hỏng | Dừng hẳn, ai cũng biết | Hỏng một phần; không chắc máy kia chết hay chỉ chậm |
Thời gian | Một đồng hồ, thứ tự rõ ràng | Mỗi máy một đồng hồ, lệch nhau |
Trao đổi dữ liệu | Đọc ghi bộ nhớ chung | Gửi tin qua mạng: có thể mất, chậm, tới hai lần |
Lớn thêm | Mua máy to hơn, tới một giới hạn | Thêm máy |
Chịu lỗi | Máy hỏng là dịch vụ dừng | Vài máy hỏng, dịch vụ vẫn chạy |
Độ khó | Dễ hiểu, dễ gỡ lỗi | Lỗi hiếm, khó tái hiện |
Ngày nay, nhiều nơi vẫn sống tốt ở cột bên trái. Một homestay nhỏ ở Đà Lạt nhận đặt phòng qua trang web riêng chạy trên đúng một máy chủ thuê; máy chủ trục trặc thì khách gọi điện, chủ nhà ghi vào sổ. Đó thường là lựa chọn đúng: đơn giản, rẻ, ai cũng hiểu. Chuyện chỉ đổi khi chủ nhà đăng phòng lên thêm vài trang đặt phòng lớn. Giờ mỗi trang giữ một bản lịch phòng riêng, cứ một lúc mới đồng bộ với nhau; hai khách trên hai trang cùng đặt phòng trống cuối cùng của đêm thứ Bảy thì ai được ở, ai nhận lời xin lỗi? Đó là cánh cửa bước vào hệ phân tán.
Môn này trả lời câu hỏi gì
Môn Hệ phân tán trả lời câu hỏi: làm sao để nhiều máy, nối nhau qua một mạng có thể mất tin, máy nào cũng có thể hỏng bất cứ lúc nào, vẫn cư xử như một hệ thống duy nhất — đúng, luôn sẵn sàng, và đủ nhanh?
Vì sao cần học? Vì gần như mọi dịch vụ đông người dùng hôm nay — ngân hàng số, thương mại điện tử, nhắn tin, đám mây — đều là hệ phân tán. Và vì lỗi của hệ phân tán thuộc loại khó chịu nhất: chỉ hiện ra khi một máy chậm đúng lúc, một tin tới muộn đúng nhịp. Người đã học môn này nhìn một bản thiết kế và hỏi ngay: tin này mất thì sao, máy này chết giữa chừng thì sao?
Năm ý tưởng cốt lõi
1. Lỗi từng phần: chậm hay chết, không ai biết chắc
Trên một máy, gọi một hàm thì hoặc có kết quả, hoặc báo lỗi. Gửi yêu cầu sang máy khác thì có thêm khả năng thứ ba: im lặng. Yêu cầu có thể đã mất; máy kia có thể đã làm xong nhưng câu trả lời bị mất; hoặc máy kia chỉ đang chậm. Nhìn từ phía người gửi, ba trường hợp giống hệt nhau. Đó là lỗi từng phần (partial failure): một phần hệ thống hỏng, phần còn lại vẫn chạy, và không máy nào thấy toàn cảnh.
Hãy nghĩ tới chuyện hẹn bạn đi cà phê qua tin nhắn khi sóng chập chờn. Bạn nhắn "7 giờ nhé", bạn kia trả lời "OK". Nhưng bạn kia không biết tin "OK" đã tới chưa — nếu chưa, có khi bạn sẽ không đi. Thế là bạn nhắn tiếp "nhận được rồi", và giờ tới lượt bạn không biết tin đó đã tới chưa. Thêm bao nhiêu tin xác nhận cũng vậy: người gửi tin cuối luôn không chắc. Đây là bài toán hai vị tướng (two generals problem), xuất hiện năm 1975 và được Jim Gray đặt tên năm 1978: qua một kênh có thể mất tin, không giao thức nào bảo đảm hai bên chắc chắn đã thống nhất.
Hệ thống thật sống chung với điều đó bằng ba thói quen:
- Hết thời gian chờ (timeout): chờ đủ lâu thì coi như hỏng — chấp nhận có lúc đoán nhầm máy chậm là máy chết.
- Thử lại (retry): gửi lại yêu cầu — nghĩa là một yêu cầu có thể được làm hai lần. Ứng dụng đặt đồ ăn quay mãi, bạn bấm "Đặt" lần nữa, và có thể nhận hai suất cơm.
- Lũy đẳng (idempotent): vì thế yêu cầu quan trọng mang theo một mã riêng; máy chủ thấy mã đã gặp thì trả lại kết quả cũ thay vì làm lại. Gửi một lần hay mười lần, kết quả như nhau.
2. Thời gian và thứ tự: đồng hồ của Lamport
Mỗi máy có một đồng hồ thạch anh riêng, không hai cái nào chạy giống hệt nhau; chỉnh giờ qua giao thức NTP rồi vẫn lệch một chút. Nghe vô hại — cho tới khi bạn gộp nhật ký của nhiều máy để tìm lỗi, và thấy kho trừ hàng trước khi đơn hàng được nhận.
Ý của Lamport năm 1978: thứ ta thật sự cần không phải giờ chính xác, mà là quan hệ "xảy ra trước" (happened-before) — việc nào có thể đã ảnh hưởng tới việc nào. Trên một máy, việc làm trước xảy ra trước việc làm sau; giữa hai máy, gửi một tin xảy ra trước nhận tin đó. Ông đề xuất đồng hồ logic (logical clock): mỗi máy giữ một bộ đếm, tăng 1 mỗi khi làm một việc, và gửi kèm bộ đếm trong mỗi tin; khi nhận tin, máy nhận nâng bộ đếm lên ít nhất bằng con số trong tin rồi mới tăng 1.
Thử với ba máy chủ của một cửa hàng trực tuyến: A nhận đơn, B quản lý kho, C lo giao hàng. Đồng hồ của B chậm 2 giây, của C nhanh 1 giây:
nhat_ky = []
class May:
def __init__(self, ten, lech):
self.ten, self.lech, self.L = ten, lech, 0 # lech: đồng hồ máy nhanh (+) hay chậm (-) mấy giây
def ghi(self, gio_that, viec, L_trong_thu=0):
self.L = max(self.L, L_trong_thu) + 1 # luật của Lamport
nhat_ky.append((round(gio_that + self.lech, 1), self.L, self.ten, viec))
return self.L # gửi kèm con số này trong thư
A, B, C = May("A", 0.0), May("B", -2.0), May("C", +1.0)
thu = A.ghi(30.0, "nhận đơn hàng, báo B")
thu = B.ghi(30.3, "trừ kho, báo C", thu)
C.ghi(30.5, "xếp lịch giao hàng", thu)
A.ghi(30.8, "gửi email cho khách")
print("Theo đồng hồ của từng máy:")
for gio, L, ten, viec in sorted(nhat_ky):
print(f" 10:00:{gio:04.1f} {ten} {viec}")
print("Theo nhãn Lamport:")
for gio, L, ten, viec in sorted(nhat_ky, key=lambda d: (d[1], d[2])):
print(f" L={L} {ten} {viec}")Theo đồng hồ của từng máy:
10:00:28.3 B trừ kho, báo C
10:00:30.0 A nhận đơn hàng, báo B
10:00:30.8 A gửi email cho khách
10:00:31.5 C xếp lịch giao hàng
Theo nhãn Lamport:
L=1 A nhận đơn hàng, báo B
L=2 A gửi email cho khách
L=2 B trừ kho, báo C
L=3 C xếp lịch giao hàngXếp theo giờ máy, B trừ kho lúc 28,3 giây — trước cả lúc A nhận đơn — một thứ tự không thể có, vì B chỉ trừ kho khi A báo. Nhãn Lamport giữ đúng quan hệ nhân quả: nhận đơn (1), trừ kho (2), xếp lịch giao (3). Hai việc cùng nhãn 2 — A gửi email, B trừ kho — không liên quan tới nhau, xếp việc nào trước cũng không sai. Muốn biết chắc hai việc có "đồng thời" hay không, người ta dùng đồng hồ vector (vector clock): mỗi máy giữ một bộ đếm cho từng máy trong hệ thống.
Cũng có hệ thống chọn đường khác: Spanner, cơ sở dữ liệu toàn cầu của Google (2012), đặt đồng hồ nguyên tử và máy thu GPS trong trung tâm dữ liệu để biết sai số của đồng hồ — cỡ vài mili giây — rồi chờ hết khoảng sai số đó trước khi xác nhận giao dịch.
3. Nhân bản và đồng thuận: vì sao cần đa số
Dữ liệu quan trọng được nhân bản (replication) ra nhiều máy — bài Hệ cơ sở dữ liệu đã nói vì sao, kèm định lý CAP. Ở đây ta hỏi câu nằm bên dưới: khi các bản sao nhận lệnh ghi theo thứ tự khác nhau, hay một bản đang mất kết nối đúng lúc có lệnh ghi, làm sao chúng đồng ý với nhau về giá trị đúng? Đó là bài toán đồng thuận (consensus).
Mẹo cốt lõi của Paxos và Raft là đa số (majority quorum): lệnh ghi chỉ được coi là xong khi quá nửa số bản sao đã nhận. Lý do là một sự thật nhỏ của tổ hợp: hai nhóm quá nửa bất kỳ luôn có ít nhất một máy chung, nên nhóm đa số nào sau này cũng có ít nhất một máy biết về lệnh ghi đó. Kiểm bằng máy:
from itertools import combinations
def thu(N):
da_so = N // 2 + 1
nhom = [set(c) for c in combinations(range(N), da_so)]
giao_nhau = all(a & b for a in nhom for b in nhom)
print(f"{N} bản sao: đa số = {da_so}, hai nhóm đa số bất kỳ luôn chung máy: {giao_nhau}, "
f"chịu được {N - da_so} máy hỏng")
for N in range(3, 8):
thu(N)
# Nếu chỉ cần 2 trong 5 máy đồng ý là đủ?
nho = [set(c) for c in combinations(range(5), 2)]
print("Hai nhóm 2 máy bất kỳ luôn chung máy:", all(a & b for a in nho for b in nho))3 bản sao: đa số = 2, hai nhóm đa số bất kỳ luôn chung máy: True, chịu được 1 máy hỏng
4 bản sao: đa số = 3, hai nhóm đa số bất kỳ luôn chung máy: True, chịu được 1 máy hỏng
5 bản sao: đa số = 3, hai nhóm đa số bất kỳ luôn chung máy: True, chịu được 2 máy hỏng
6 bản sao: đa số = 4, hai nhóm đa số bất kỳ luôn chung máy: True, chịu được 2 máy hỏng
7 bản sao: đa số = 4, hai nhóm đa số bất kỳ luôn chung máy: True, chịu được 3 máy hỏng
Hai nhóm 2 máy bất kỳ luôn chung máy: FalseNăm bản sao cần 3 máy đồng ý, nên hỏng 2 máy vẫn đủ 3 để chạy tiếp; hỏng máy thứ ba thì hệ thống dừng lại chờ, chứ không trả lời sai. Tổng quát: 2f + 1 bản sao chịu được f máy hỏng. Máy thứ sáu không giúp gì thêm, nên các cụm đồng thuận gần như luôn có số máy lẻ: 3, 5, 7.
Dòng cuối cho thấy vì sao không được "tiết kiệm" bằng nhóm nhỏ: hai nhóm 2 máy có thể không chung máy nào. Khi mạng chia cụm làm đôi, mỗi nửa tưởng mình là chủ và ghi những giá trị khác nhau — não chia đôi (split brain). Với luật đa số, chỉ nửa có từ 3 máy trở lên được tiếp tục.
Raft gói ý đó thành một quy trình dễ theo. Các máy bầu ra một lãnh đạo (leader); mọi lệnh ghi đi qua lãnh đạo, được chép vào nhật ký (log) của các máy theo cùng thứ tự, và được xác nhận khi đa số đã chép. Lãnh đạo im lặng quá lâu thì một máy khác tự ứng cử cho nhiệm kỳ (term) mới; mỗi máy chờ một khoảng ngẫu nhiên trước khi ứng cử, để hiếm khi hai máy tranh cử cùng lúc.
Nếu máy còn có thể nói dối — bị chiếm quyền, hay hỏng kiểu kỳ quặc — thì đa số chưa đủ: theo bài báo năm 1982, khi tin nhắn không có chữ ký, cần ít nhất 3f + 1 máy để chịu được f máy "phản bội". Bitcoin (2008) giải một biến thể của bài toán này trong một mạng mở, ai cũng tham gia được.
4. MapReduce: chia việc cho nghìn máy, hỏng thì làm lại
Đếm từ trong vài trang văn bản thì một máy làm trong chớp mắt; trên hàng tỷ trang web thì một máy làm rất lâu. MapReduce chia việc thành hai bước, người lập trình chỉ viết hai hàm:
- map: mỗi máy đọc phần dữ liệu nằm sẵn trên ổ đĩa của chính nó và nhả ra các cặp (từ, 1);
- reduce: mọi cặp của cùng một từ được gom về một máy, máy đó cộng lại.
Ở giữa, hệ thống tự xáo trộn (shuffle): chọn máy reduce cho từng từ bằng một hàm băm, rồi chuyển các cặp tới đó. Mô phỏng với vài câu ca dao, tục ngữ chia cho ba "máy":
import zlib
from collections import defaultdict
van_ban = [
"Một cây làm chẳng nên non, ba cây chụm lại nên hòn núi cao",
"Nhiễu điều phủ lấy giá gương, người trong một nước phải thương nhau cùng",
"Bầu ơi thương lấy bí cùng, tuy rằng khác giống nhưng chung một giàn",
"Một con ngựa đau, cả tàu bỏ cỏ",
"Lá lành đùm lá rách",
"Góp gió thành bão",
]
SO_REDUCE = 2
def map_(dong): # chạy trên máy giữ đoạn văn bản
return [(tu, 1) for tu in dong.lower().replace(",", "").split()]
def reduce_(tu, cac_so): # chạy trên máy được giao từ này
return tu, sum(cac_so)
# Bộ điều phối chia 6 dòng thành 3 việc map cho 3 máy; máy 2 hỏng giữa chừng.
viec = {1: van_ban[0:2], 2: van_ban[2:4], 3: van_ban[4:6]}
may_song = {1: True, 2: False, 3: True}
ket_qua_map = {}
for so, cac_dong in viec.items():
may = so if may_song[so] else 3 # máy hỏng thì giao lại việc cho máy 3
ket_qua_map[so] = [cap for dong in cac_dong for cap in map_(dong)]
print(f"việc map {so}: máy {may} làm, ra {len(ket_qua_map[so])} cặp (từ, 1)")
# Xáo trộn (shuffle): mỗi từ về đúng một máy reduce, chọn bằng hàm băm.
nhom = [defaultdict(list) for _ in range(SO_REDUCE)]
for cap_list in ket_qua_map.values():
for tu, so in cap_list:
nhom[zlib.crc32(tu.encode()) % SO_REDUCE][tu].append(so)
dem = dict(reduce_(tu, ds) for g in nhom for tu, ds in g.items())
print({tu: n for tu, n in dem.items() if n >= 2})việc map 1: máy 1 làm, ra 28 cặp (từ, 1)
việc map 2: máy 3 làm, ra 22 cặp (từ, 1)
việc map 3: máy 3 làm, ra 9 cặp (từ, 1)
{'lấy': 2, 'một': 4, 'cây': 2, 'nên': 2, 'thương': 2, 'cùng': 2, 'lá': 2}Phần đáng giá nhất của MapReduce không nằm ở việc chia nhỏ cho nhanh — chuyện của bài Tính toán song song — mà ở cách nó chịu lỗi. Hàm map chỉ đọc đầu vào, không sửa gì bên ngoài, nên làm lại bao nhiêu lần cũng ra cùng kết quả: máy 2 chết thì bộ điều phối giao việc cho máy 3, và kết quả cuối không khác một chữ. Người viết map_ và reduce_ không phải viết dòng nào về máy hỏng hay dữ liệu nằm ở đâu. Ý tưởng "mang tính toán tới chỗ dữ liệu, hỏng thì làm lại" sống tiếp trong Hadoop và Spark.
5. Những đánh đổi không tránh được
Hệ phân tán không có lời giải hoàn hảo, chỉ có những đánh đổi phải chọn cho tỉnh táo:
- An toàn hay tiến triển. Định lý FLP nói không thể bảo đảm cả hai trong mọi tình huống của mạng. Paxos và Raft chọn không bao giờ trả lời sai — tính an toàn (safety); còn việc chắc chắn đi tới kết quả — tính tiến triển (liveness) — chỉ được bảo đảm khi mạng đủ êm. Mạng loạn thì hệ thống có thể đứng chờ, nhưng không làm hỏng dữ liệu.
- Nhất quán hay nhanh. Muốn mọi bản sao luôn khớp, mỗi lệnh ghi phải chờ tin đi và về giữa các máy. Hà Nội cách TP.HCM khoảng 1.140 km theo đường chim bay, ánh sáng trong cáp quang đi khoảng 200.000 km mỗi giây (cách tính như bài Vật lý); giữ hai bản sao ở hai thành phố luôn khớp thì mỗi lệnh ghi tốn thêm ít nhất khoảng 11 mili giây, không công nghệ nào rút ngắn được. Nhiều hệ thống vì thế cho các bản sao lệch nhau một lúc — vừa đổi ảnh đại diện, tải lại trang vẫn thấy ảnh cũ — miễn là bạn luôn đọc lại được điều chính mình vừa ghi.
- Phân tán hay không. Mỗi máy thêm vào là thêm một thứ có thể hỏng. Lời khuyên đầu tiên của người làm lâu năm thường là: một máy còn gánh được thì đừng phân tán — như trang web homestay ở trên.
Thiết kế phân tán đúng hay sai rất khó thấy bằng mắt, nên các công ty lớn kiểm chúng bằng phương pháp hình thức — AWS dùng chính TLA+ của Lamport — và bằng cách cố tình giết máy, cắt mạng khi thử nghiệm.
Hệ phân tán nằm ở đâu trong chồng tầng
Trong chồng tầng của bài Từ electron đến ứng dụng, hệ phân tán nằm trên hệ điều hành và mạng máy tính của từng máy, dưới các ứng dụng đám mây. Nó dùng tiến trình, socket, gói tin để dựng lên những thứ trông như của một máy — kho dữ liệu, hàng đợi, ổ khóa — nhưng trải trên hàng trăm máy. Kubernetes làm cho cả cụm máy việc hệ điều hành làm cho một máy: xếp chương trình chạy ở đâu, khởi động lại chương trình đã chết.
Đưa lên
Một dịch vụ cư xử như một máy duy nhất và đáng tin — kho dữ liệu, nhật ký, ổ khóa, hệ thống file — kèm một lời hứa rõ ràng về độ nhất quán: đọc lúc nào thì thấy được những gì.
Giấu đi
Dữ liệu nằm ở máy nào, có mấy bản sao, máy nào vừa chết, lãnh đạo nào vừa được bầu lại, tin nào đã phải gửi lại, và đồng hồ các máy lệch nhau bao nhiêu.
Học trước và học sau
· 6 mônHệ điều hành
Operating Systems
Tiến trình, luồng, khóa, điều kiện tranh chấp. Hệ phân tán là chuyện đồng thời của hệ điều hành, chỉ khác là không còn bộ nhớ chung và có thêm máy hỏng. Nên học trước.
Mạng máy tính
Computer Networks
Gói tin, TCP, độ trễ — tầng ngay bên dưới, nơi tin có thể mất hoặc tới chậm. Nên học trước.
Hệ cơ sở dữ liệu
Database Systems
Giao dịch, nhân bản, phân mảnh, định lý CAP. Cơ sở dữ liệu phân tán là nơi thuật toán đồng thuận được dùng nhiều nhất.
Nguyên lý hệ thống máy tính
Principles of Computer Systems
Nguyên lý thiết kế chung cho hệ thống lớn — trừu tượng, đặt tên, dư thừa, lập luận đầu cuối, độ sẵn sàng.
Tính toán song song
Parallel Computing
Nhiều bộ xử lý cùng làm một việc cho nhanh. Song song lo tốc độ, phân tán lo máy hỏng và mạng không tin cậy.
Phương pháp hình thức
Formal Methods for Software Engineering
Đặc tả bằng TLA+ và kiểm tra mô hình — tìm lỗi giao thức trước khi nó lộ ra trên nghìn máy.
Xem chủ đề trên OpenER: Formal Methods for Software Engineering
Ứng dụng thật và nghề nghiệp
- Kỹ sư phần mềm phía máy chủ (backend): gọi dịch vụ khác qua mạng, đặt thời gian chờ, thử lại an toàn, dùng hàng đợi tin nhắn.
- Kỹ sư hạ tầng và đám mây: vận hành Kubernetes, etcd, kho lưu trữ phân tán — xây chính những dịch vụ người khác thuê.
- Kỹ sư bảo đảm độ tin cậy (site reliability engineer — SRE): theo dõi hệ thống, trực sự cố, viết báo cáo sau sự cố như bản AWS công bố năm 2025.
- Kỹ sư dữ liệu và cơ sở dữ liệu phân tán: Spark, Kafka, Spanner, CockroachDB, TiDB — nơi MapReduce, Raft và đồng hồ là code thật.
Học xong làm được gì, bắt đầu từ đâu
Sau môn này bạn có thể:
- giải thích vì sao "không có trả lời" không có nghĩa là "chưa được làm", và thiết kế API thử lại được mà không làm hai lần;
- dùng đồng hồ logic để sắp đúng thứ tự sự kiện từ nhật ký của nhiều máy;
- giải thích Raft — bầu lãnh đạo, chép nhật ký, vì sao cần đa số — và tự cài một bản chạy được;
- viết một chương trình kiểu MapReduce và chỉ ra nó chịu lỗi thế nào;
- đọc một bản thiết kế hay báo cáo sự cố và chỉ ra chỗ nó ngầm giả định mạng không bao giờ mất tin.
Nên biết trước: hệ điều hành ở mức luồng, khóa, điều kiện tranh chấp; mạng máy tính ở mức TCP, socket; lập trình đủ vững để gỡ lỗi chương trình nhiều luồng.
Bắt đầu trên OpenER: trang chủ đề Distributed Systems có các khóa học đã chọn lọc, và hướng dẫn học gợi ý thứ tự đi qua chúng. Khóa chính là MIT 6.5840 Distributed Systems (trước đây là 6.824) của Robert Morris và Frans Kaashoek: đọc các bài báo kinh điển như MapReduce, Raft, Spanner, kèm chuỗi lab bằng Go — lab đầu tiên là tự viết MapReduce, các lab sau xây Raft và một kho khóa–giá trị (key-value store) chịu lỗi. Muốn vào nhẹ hơn, xem tám bài giảng của Martin Kleppmann trong môn Concurrent and Distributed Systems ở Đại học Cambridge, có video và ghi chú kèm bài tập. Môn 15-440 của Carnegie Mellon nghiêng về dự án hệ thống; khóa của Rajiv Misra (IIT Patna) trên NPTEL bổ sung thuật toán kinh điển.
Lời khuyên cho môn này: tự tay làm hỏng hệ thống của mình. Chạy ba tiến trình gửi tin cho nhau, rồi tắt ngang một tiến trình, làm mất vài tin, cho một đồng hồ chạy nhanh. Lỗi hệ phân tán chỉ lộ ra khi có thứ hỏng — tốt nhất là trên máy bạn, trước khi người dùng gặp.
Tài liệu tham khảo
- Maarten van Steen, Andrew S. Tanenbaum — Distributed Systems, bản thứ 4 (2023); bản số tải miễn phí trên trang distributed-systems.net.
- Martin Kleppmann — Designing Data-Intensive Applications, O'Reilly, 2017.
- MIT 6.5840 Distributed Systems — lịch học, ghi chú và lab tại pdos.csail.mit.edu/6.824.
- Leslie Lamport — "Time, Clocks, and the Ordering of Events in a Distributed System", Communications of the ACM, 1978.
- Leslie Lamport, Robert Shostak, Marshall Pease — "The Byzantine Generals Problem", ACM TOPLAS, 1982.
- Michael J. Fischer, Nancy A. Lynch, Michael S. Paterson — "Impossibility of Distributed Consensus with One Faulty Process", Journal of the ACM, 1985.
- Leslie Lamport — "Paxos Made Simple", ACM SIGACT News, 2001.
- Diego Ongaro, John Ousterhout — "In Search of an Understandable Consensus Algorithm", USENIX ATC 2014; trang raft.github.io.
- Jeffrey Dean, Sanjay Ghemawat — "MapReduce: Simplified Data Processing on Large Clusters", OSDI 2004.
- AWS — báo cáo sự cố DynamoDB tháng 10/2025 (aws.amazon.com/message/101925); Eric Rosen — RFC 789 về sự cố ARPANET năm 1980.