Idempotency: bấm chuyển tiền hai lần, chỉ trừ một lần

Idempotency là gì: vì sao mạng chập chờn làm app thử lại và trừ tiền hai lần, và một chiếc khóa nhỏ giúp ngân hàng nhận ra yêu cầu đã làm rồi.

10 phút đọcTrung cấpEyeBlogs

Đọc bản tiếng Anh →

Sơ đồ trên nền tối với hai đường dọc: điện thoại bên trái, ngân hàng bên phải. Mũi tên thứ nhất từ điện thoại sang ngân hàng ghi "chuyển 500.000 đ, khóa 7f3a…"; ngân hàng ghi "trừ tiền, ghi nhớ khóa". Mũi tên trả lời "xong" là nét đứt, đứt giữa chừng ở dấu ✕ "mất sóng". Điện thoại "không biết tiền đã đi chưa" nên gửi lại với cùng khóa 7f3a…; ngân hàng ghi "khóa đã thấy: không trừ nữa" và trả lời "xong (kết quả đã lưu)".
Mục lục

Bạn đứng trong thang máy, mở app ngân hàng, chuyển 500.000 đồng cho bạn. Vòng tròn quay mãi, rồi hiện “Có lỗi xảy ra, vui lòng thử lại”. Tiền đã đi chưa? Bấm lại thì có bị trừ hai lần không? Không bấm thì bạn mình có nhận được không? Ai từng gặp cảnh này đều biết cảm giác đó.

Câu trả lời của các hệ thống thanh toán tử tế nằm trong một chữ hơi khó đọc: idempotency (tính lũy đẳng). Một thao tác là idempotent nếu làm một lần hay làm nhiều lần thì kết quả vẫn như nhau. Bấm nút gọi thang máy năm lần, thang vẫn chỉ đến một lần: nút đó idempotent. Chuyển tiền thì tự nhiên không như vậy, mỗi lần làm là một lần trừ tiền. Bài này kể vì sao mạng chập chờn biến lời khuyên “cứ thử lại” thành nguy hiểm, và một chiếc khóa idempotency nhỏ xíu giúp ngân hàng nhận ra “yêu cầu này tôi làm rồi”. Cuối bài có một đoạn code mô phỏng 10.000 lần chuyển tiền qua một đường mạng tồi.

Khi app báo lỗi, chuyện gì đã xảy ra?

Từ lúc bạn bấm “Chuyển” tới lúc màn hình báo thành công, yêu cầu phải đi qua sóng điện thoại, Internet, vài tầng máy chủ, rồi câu trả lời lại đi ngược về. Kỹ sư của Stripe, một công ty xử lý thanh toán lớn, chia các trường hợp hỏng hóc thành ba loại [1]:

  1. Yêu cầu chưa tới nơi. Mất sóng ngay khi gửi. Ngân hàng chưa nhận gì, tiền chưa đi. Thử lại là an toàn.
  2. Máy chủ hỏng giữa chừng. Ngân hàng nhận rồi, đang làm thì sập. Tiền đi hay chưa tùy cách hệ thống được viết, thường thì giao dịch dở dang được hủy toàn bộ.
  3. Việc đã xong, nhưng câu trả lời bị mất. Ngân hàng đã trừ tiền, đã chuyển cho bạn bè bạn, nhưng tin nhắn “xong” thất lạc trên đường về. App chờ mãi, hết giờ, báo lỗi.

Cái khó nằm ở chỗ: từ phía điện thoại, ba trường hợp này trông giống hệt nhau. Đều là chờ, rồi hết giờ, rồi không có câu trả lời. App không thể biết mình đang ở trường hợp 1 (nên gửi lại) hay trường hợp 3 (tuyệt đối không được làm lại).

Thử lại: cách chữa làm bệnh nặng thêm

Nếu app không thử lại, ở trường hợp 1 khách hàng chịu lỗi, phải tự bấm lại. Còn ở trường hợp 3, app báo lỗi trong khi tiền đã đi, và nếu khách bấm lại vì tưởng chưa chuyển, tiền đi lần nữa.

Nếu app tự thử lại vài lần, trường hợp 1 được cứu, nhưng trường hợp 3 thành tai họa có hệ thống: mỗi lần câu trả lời bị mất là một lần trừ tiền thừa.

Trong mô phỏng ở cuối bài, với một đường mạng làm mất 5% yêu cầu và 10% câu trả lời (những con số đặt ra để minh họa, mạng thật thường tốt hơn nhiều), kết quả của 10.000 lần bấm chuyển tiền là:

  • Không thử lại: 1.475 lần app báo lỗi. Trong đó 523 lần tiền thật sự chưa đi, còn 952 lần tiền đã đi mà app vẫn báo lỗi.
  • Tự thử lại tối đa 3 lần, không có khóa: app gần như không còn báo lỗi (29 lần), nhưng 1.004 người bị trừ tiền hai lần trở lên, khoảng một phần mười.

Giao thức HTTP, ngôn ngữ chung của web, đã cảnh báo đúng điều này. Tiêu chuẩn RFC 9110 nói một số kiểu yêu cầu (như đọc dữ liệu, PUT để ghi đè, DELETE để xóa) là idempotent nên có thể tự động thử lại khi mất kết nối, còn với kiểu khác (như POST, kiểu thường dùng để tạo giao dịch mới) thì phía gửi không nên tự thử lại trừ khi có cách biết chắc yêu cầu gốc chưa được thực hiện [3]. Xóa một tệp hai lần thì tệp vẫn chỉ mất một lần. Tạo giao dịch hai lần thì có hai giao dịch.

Khóa idempotency: đánh số mỗi lần bấm

Cách giải quyết rất đơn giản. Ngay lúc bạn bấm “Chuyển”, app sinh ra một chuỗi ngẫu nhiên dài, ví dụ 7f3a9c1e-…, gọi là khóa idempotency, và gửi kèm yêu cầu. Khi phải thử lại, app gửi đúng chiếc khóa đó, không sinh khóa mới.

Phía ngân hàng giữ một cuốn sổ: khóa nào đã thấy, kết quả lần trước là gì.

  • Gặp khóa mới: làm bình thường, trừ tiền, rồi ghi khóa cùng kết quả vào sổ.
  • Gặp khóa đã có trong sổ: không làm lại, chỉ trả lại đúng kết quả đã ghi.

Như sơ đồ đầu bài: câu “xong” lần đầu bị mất, app gửi lại cùng khóa 7f3a…, ngân hàng tra sổ, thấy rồi, trả “xong” mà không trừ thêm đồng nào. Từ đó, thử lại bao nhiêu lần cũng được. Chuyển tiền tự nó không idempotent, nhưng “chuyển tiền kèm khóa” thì idempotent.

Trong cùng mô phỏng, khi app thử lại với khóa: 9.998 trên 10.000 người bị trừ đúng một lần, không ai bị trừ hai lần. Vẫn còn 32 lần app báo lỗi (cả ba lần gửi đều trục trặc), nhưng giờ chuyện đó không còn đáng sợ: chỉ cần gửi lại sau, vẫn với khóa cũ, là biết chắc kết quả mà không lo trừ thừa.

Một chi tiết quan trọng: khóa gắn với một lần bấm, không phải với một số tiền hay một người nhận. Nếu bạn cố ý chuyển 500.000 đồng cho cùng một người hai lần trong ngày, đó là hai lần bấm, hai khóa, hai giao dịch hợp lệ. Hệ thống không đoán ý bạn; nó chỉ nhận ra cùng một yêu cầu được gửi lại.

Ai đang dùng khóa idempotency?

  • Stripe. Mọi yêu cầu POST tới API của Stripe đều nhận khóa qua header Idempotency-Key. Stripe khuyên dùng UUID phiên bản 4 (một chuỗi ngẫu nhiên đủ dài để gần như không bao giờ trùng), khóa dài tối đa 255 ký tự, và không nên dùng thông tin cá nhân như email làm khóa. Stripe lưu mã trạng thái và nội dung câu trả lời đầu tiên; thử lại cùng khóa nhận lại đúng câu trả lời đó, kể cả khi đó là lỗi. Khóa có thể bị xóa khi đã cũ ít nhất 24 giờ. Nếu gửi lại cùng khóa mà tham số khác đi, Stripe báo lỗi để tránh dùng nhầm [2].
  • Một bản nháp tiêu chuẩn của IETF, tổ chức soạn các tiêu chuẩn Internet, mô tả header Idempotency-Key để các API khác dùng chung một cách [4]. Bản nháp khuyên dùng UUID làm khóa; yêu cầu gửi lại khi yêu cầu gốc đang chạy dở thì trả lỗi xung đột (mã 409); dùng lại khóa cho nội dung khác thì trả mã 422. Bản nháp này hiện đã hết hạn và chưa thành tiêu chuẩn chính thức, nhưng cách làm thì đã phổ biến.
  • Các hệ thống thanh toán, đặt hàng, gửi tin nhắn nói chung. Cái tên có thể khác (“mã tham chiếu yêu cầu”, “request ID”, “mã giao dịch phía khách”), ý tưởng là một: người gửi tự đánh số yêu cầu để người nhận lọc trùng.

Những câu hỏi khi thiết kế

Ý tưởng thì đơn giản, làm đúng thì có vài chỗ dễ trượt.

  • Ghi sổ và trừ tiền phải đi cùng nhau. Nếu ngân hàng trừ tiền xong rồi mới ghi khóa, và sập đúng ở giữa, lần thử lại sẽ không thấy khóa và trừ lần nữa. Cách an toàn là ghi khóa và trừ tiền trong cùng một giao dịch cơ sở dữ liệu: hoặc cả hai cùng xảy ra, hoặc không cái nào.
  • Hai lần gửi tới cùng lúc. App thử lại trong khi lần đầu còn đang xử lý. Nếu cả hai cùng tra sổ, cùng không thấy khóa, cả hai cùng trừ tiền. Phải khóa theo khóa idempotency (chỉ một yêu cầu được xử lý một khóa tại một thời điểm), yêu cầu đến sau thì báo “đang xử lý, thử lại sau”, đúng như mã 409 ở trên.
  • Giữ sổ bao lâu? Sổ không thể lớn mãi. Stripe chọn tối thiểu 24 giờ. Thời hạn phải dài hơn khoảng thời gian app còn có thể thử lại, kể cả khi người dùng tắt app rồi mở lại hôm sau.
  • Khóa chỉ có nghĩa với một người. Hai khách hàng tình cờ gửi cùng một khóa không được dính vào nhau, nên sổ thường tra theo cặp (tài khoản, khóa).
  • Thử lại cho khéo. Nếu cả triệu điện thoại cùng thử lại ngay lập tức khi máy chủ vừa trục trặc, chúng sẽ đè sập máy chủ lần nữa. Stripe khuyên chờ lâu dần sau mỗi lần thất bại (tỉ lệ với 2n2^n, nn là số lần đã thất bại) và cộng thêm một chút thời gian ngẫu nhiên để các máy không thử lại cùng một lúc [1]. Đây cũng là lý do các hệ thống lớn đặt bộ giới hạn tốc độ trước cửa.

Nếu hệ thống chia dữ liệu cho nhiều máy, sổ khóa cũng phải được chia theo cùng cách để mọi lần thử lại của một khóa tìm tới đúng một chỗ, ví dụ bằng consistent hashing. Còn để chắc yêu cầu thực sự đến từ app của bạn chứ không phải kẻ gian gửi lại, cần thêm một lớp khác: chữ ký số và token.

Tự tay mô phỏng: 10.000 lần chuyển tiền qua mạng tồi

Đoạn Python dưới đây giả lập một ngân hàng và 10.000 lần bấm chuyển tiền. Mỗi lần gửi, yêu cầu có 5% khả năng mất trên đường đi; nếu tới nơi, ngân hàng trừ tiền, rồi câu trả lời có 10% khả năng mất trên đường về. Nó so ba cách làm: không thử lại, thử lại tối đa 3 lần không có khóa, và thử lại với khóa idempotency, rồi đếm mỗi giao dịch bị trừ bao nhiêu lần. Nó cũng vẽ sơ đồ đầu bài. Chỉ cần cài matplotlib.

idempotency.py
import random
import uuid
import matplotlib.pyplot as plt
plt.rcParams.update({"figure.facecolor": "#16181c", "axes.facecolor": "#16181c", "text.color": "#d4d7dc",
"axes.edgecolor": "#2a2e35", "xtick.color": "#878d97", "ytick.color": "#878d97", "font.size": 12})
random.seed(2026)
LOST_REQUEST = 0.05 # 5% yêu cầu mất trên đường đi, server không hề nhận được
LOST_REPLY = 0.10 # 10% server đã chuyển tiền xong nhưng câu trả lời mất trên đường về
MAX_TRIES = 3 # ứng dụng thử lại tối đa 3 lần khi chờ quá lâu
class Bank:
def __init__(self, use_key):
self.use_key = use_key
self.done = {} # khóa idempotency → kết quả đã trả lần đầu
self.debits = {} # mã giao dịch của người dùng → số lần đã trừ tiền
def transfer(self, payment_id, key):
if self.use_key and key in self.done:
return self.done[key] # đã làm rồi: trả lại đúng kết quả cũ, không trừ tiền lần nữa
self.debits[payment_id] = self.debits.get(payment_id, 0) + 1
result = "ok"
if self.use_key:
self.done[key] = result
return result
def run(retry, use_key, n=10_000):
bank = Bank(use_key)
unsure = 0 # người dùng thấy "lỗi" nhưng tiền có thể đã bị trừ
for pid in range(n):
key = str(uuid.UUID(int=random.getrandbits(128))) # một khóa cho MỘT lần bấm chuyển tiền
for attempt in range(MAX_TRIES if retry else 1):
if random.random() < LOST_REQUEST:
continue # yêu cầu mất, chờ hết giờ
bank.transfer(pid, key)
if random.random() < LOST_REPLY:
continue # tiền đã chuyển, nhưng app không biết
break
else:
unsure += 1
counts = [bank.debits.get(pid, 0) for pid in range(n)]
return {"không bị trừ": counts.count(0), "trừ đúng 1 lần": counts.count(1),
"trừ 2 lần trở lên": sum(c >= 2 for c in counts), "app báo lỗi": unsure}
policies = {"không thử lại": run(False, False), "thử lại,\nkhông có khóa": run(True, False),
"thử lại\n+ khóa idempotency": run(True, True)}
for name, r in policies.items():
print(f"{name.replace(chr(10), ' '):<28}", " ".join(f"{k}: {v:>5}" for k, v in r.items()))
# Hình 1: kết cục của 10.000 lần bấm chuyển tiền, theo ba cách làm.
fig, ax = plt.subplots(figsize=(10, 5))
names = list(policies)
parts = [("trừ đúng 1 lần", "#8fa9c9"), ("trừ 2 lần trở lên", "#c98f8f"), ("không bị trừ", "#4a4e57")]
bottom = [0] * len(names)
for label, color in parts:
vals = [policies[n][label] for n in names]
ax.bar(names, vals, bottom=bottom, color=color, label=label, width=0.55)
for i, v in enumerate(vals):
if v > 250:
ax.text(i, bottom[i] + v / 2, f"{v:,}".replace(",", "."), ha="center", va="center", color="#16181c", fontsize=11)
bottom = [b + v for b, v in zip(bottom, vals)]
for i, n in enumerate(names):
ax.text(i, 10_150, f"app báo lỗi: {policies[n]['app báo lỗi']:,}".replace(",", "."), ha="center", color="#a4a9b2", fontsize=10)
ax.set_ylim(0, 10_800)
ax.set_ylabel("số lần bấm chuyển tiền (trên 10.000)", color="#a4a9b2")
ax.set_title("Mạng chập chờn: thử lại có khóa thì không ai bị trừ tiền hai lần", color="#d4d7dc", fontsize=12)
ax.legend(frameon=False, labelcolor="#a4a9b2", fontsize=10, ncol=3, loc="upper center", bbox_to_anchor=(0.5, -0.16))
ax.grid(axis="y", color="#22262c")
ax.set_axisbelow(True)
fig.savefig("ba-cach-thu-lai.png", dpi=150, bbox_inches="tight")
# Hình 2 (ảnh đầu bài): câu trả lời bị mất, app gửi lại CÙNG khóa, ngân hàng không trừ lần hai.
fig, ax = plt.subplots(figsize=(10, 5.6))
ax.set_xlim(-0.5, 10.5)
ax.set_ylim(-0.3, 10.6)
ax.axis("off")
for x, name in [(1.5, "điện thoại"), (8.5, "ngân hàng")]:
ax.text(x, 10.1, name, ha="center", color="#d4d7dc", fontsize=13)
ax.plot([x, x], [0, 9.6], color="#2a2e35", lw=2)
steps = [ # (y bắt đầu, chiều: 1 = đi, -1 = về, chữ, màu, có bị mất giữa đường không)
(8.8, 1, "chuyển 500.000 đ · khóa 7f3a…", "#8fa9c9", False),
(6.9, -1, "xong", "#4a4e57", True),
(4.4, 1, "chờ lâu quá, gửi lại · khóa 7f3a…", "#8fa9c9", False),
(2.5, -1, "xong (kết quả đã lưu)", "#8fa9c9", False),
]
for y, d, label, color, lost in steps:
x0, x1 = (1.5, 8.5) if d == 1 else (8.5, 1.5)
if lost:
ax.annotate("", xy=(5.0, y - 0.6), xytext=(x0, y), arrowprops=dict(arrowstyle="-", color=color, lw=2, ls="--"))
ax.text(5.0, y - 0.6, "✕", ha="center", va="center", color="#c98f8f", fontsize=22)
ax.text(5.0, y - 1.25, "mất sóng", ha="center", color="#c98f8f", fontsize=11)
else:
ax.annotate("", xy=(x1, y - 1.2), xytext=(x0, y), arrowprops=dict(arrowstyle="-|>", color=color, lw=2))
xm = (x0 + 5.0) / 2 if lost else (x0 + x1) / 2 # giữa đoạn thật sự được vẽ
ym = y - (0.3 if lost else 0.6)
ax.text(xm, ym + 0.35, label, ha="center", color="#d4d7dc", fontsize=11,
rotation=-d * 9.7, rotation_mode="anchor")
ax.text(8.75, 7.55, "trừ tiền,\nghi nhớ khóa", ha="left", va="center", color="#8fa9c9", fontsize=10.5)
ax.text(8.75, 3.15, "khóa đã thấy:\nkhông trừ nữa", ha="left", va="center", color="#8fa9c9", fontsize=10.5)
ax.text(1.25, 4.9, "không biết\ntiền đã đi chưa", ha="right", va="center", color="#a4a9b2", fontsize=10.5)
fig.savefig("gui-lai-cung-khoa.png", dpi=150, bbox_inches="tight")
không thử lại không bị trừ: 523 trừ đúng 1 lần: 9477 trừ 2 lần trở lên: 0 app báo lỗi: 1475
thử lại, không có khóa không bị trừ: 1 trừ đúng 1 lần: 8995 trừ 2 lần trở lên: 1004 app báo lỗi: 29
thử lại + khóa idempotency không bị trừ: 2 trừ đúng 1 lần: 9998 trừ 2 lần trở lên: 0 app báo lỗi: 32
Biểu đồ ba cột chồng, mỗi cột là 10.000 lần bấm chuyển tiền. Cột không thử lại: 9.477 trừ đúng 1 lần, 523 không bị trừ, app báo lỗi 1.475 lần. Cột thử lại không có khóa: 8.995 trừ đúng 1 lần, 1.004 trừ 2 lần trở lên (phần màu đỏ), app báo lỗi 29 lần. Cột thử lại với khóa idempotency: 9.998 trừ đúng 1 lần, không ai bị trừ hai lần, app báo lỗi 32 lần.
Hình 1. Kết cục của 10.000 lần bấm chuyển tiền qua một đường mạng mất 5% yêu cầu và 10% câu trả lời (số liệu minh họa). Thử lại không có khóa làm khoảng một phần mười bị trừ tiền hai lần; thử lại với khóa thì không ai.

Con số khớp với tính tay. Một lần gửi thành công trọn vẹn với xác suất 0,95×0,9=0,8550{,}95 \times 0{,}9 = 0{,}855, nên không thử lại thì khoảng 14,5% lần bấm báo lỗi (mô phỏng: 14,75%). Trong đó phần lớn là câu trả lời bị mất, tức tiền đã đi: chính là 952 người “báo lỗi mà vẫn mất tiền”. Khi thử lại không có khóa, mỗi lần câu trả lời bị mất đều sinh ra một lần trừ thừa, nên số người bị trừ hai lần xấp xỉ tỉ lệ mất câu trả lời, 10%.

Bạn có thể tăng LOST_REPLY lên 0.3 để mô phỏng một mạng rất tệ, hoặc tăng MAX_TRIES lên 5, và thấy cột giữa ngày càng đỏ, còn cột phải vẫn không có một vệt đỏ nào.

Hỏi lại thì không sao, làm lại mới có chuyện

Mạng sẽ luôn chập chờn, máy chủ sẽ luôn có lúc sập. Idempotency không ngăn những chuyện đó. Nó làm một việc khiêm tốn hơn: biến câu hỏi đáng sợ “làm lại có sao không?” thành câu hỏi vô hại “việc này xong chưa?”. Nhờ một chuỗi ký tự ngẫu nhiên sinh ra lúc bạn bấm nút, ngân hàng có thể trả lời câu hỏi đó bao nhiêu lần cũng được mà không trừ thêm một đồng. Lần tới app báo lỗi khi chuyển tiền, nếu đó là một app tử tế, bạn có thể yên tâm bấm lại.

Vẽ minh họa hình học miễn phí cho học sinh và giáo viên: EyeViz.

Phát video: Video: Idempotency: bấm chuyển tiền hai lần, chỉ trừ một lần
Video: Idempotency: bấm chuyển tiền hai lần, chỉ trừ một lần

Tài liệu tham khảo

  1. [1]Brandur Leach. Designing robust and predictable APIs with idempotency. Stripe Blog, 2017.
  2. [2]Stripe. Idempotent requests (API reference). Stripe Docs, 2026.
  3. [3]Roy Fielding, Mark Nottingham và Julian Reschke (biên tập). RFC 9110: HTTP Semantics, mục 9.2.2 Idempotent Methods. IETF, 2022.
  4. [4]Jayadeba Jena và Sanjay Dalal. The Idempotency-Key HTTP Header Field (draft-ietf-httpapi-idempotency-key-header-07). IETF, bản nháp (Internet-Draft), 2025.