Cụm bài Tích hợp bên thứ ba: 1. Chọn nhà cung cấp, webhook và lớp chống ăn mòn · 2. Timeout, retry, circuit breaker và bulkhead
Một bên thứ ba chậm đi mười lần trong giờ cao điểm là đủ làm sập một hệ thống không phòng bị: thread bị giữ, retry ở mọi tầng nhân tải lên, và cả những API không liên quan cũng ngừng phục vụ. Bài này là phần “phòng thủ” khi gọi ra ngoài: timeout, retry, circuit breaker, bulkhead và fallback, mỗi thứ giải quyết gì và cấu hình thế nào trong Spring Boot 3. Phần chọn nhà cung cấp, kiểu tích hợp và webhook nằm ở phần 1.
1. Timeout: thứ đầu tiên phải có
Ý chính: không có timeout thì một lời gọi tới dịch vụ đang treo giữ thread mãi. Pool thread cạn dần và cả service ngừng phục vụ, kể cả API không liên quan.
Tomcat mặc định có 200 thread; bên thứ ba treo thì chúng bị giữ dần tới hết. Cần đặt riêng ba loại timeout:
| Timeout | Đo cái gì | Giá trị gợi ý |
|---|---|---|
| Connect timeout | thiết lập kết nối TCP (và bắt tay TLS) | 1–2 giây: 2 giây không kết nối được thì thường là không được |
| Read timeout (hoặc timeout cả request) | chờ phản hồi | p99 thực tế của bên thứ ba cộng biên độ, không phải “30 giây cho chắc” |
| Deadline (timeout tổng của thao tác) | mọi lần gọi, gồm cả retry | nằm trong cam kết của API mình, ví dụ 3 giây |
Ở tầng TCP, connect timeout, connection refused và connection reset khác nhau thế nào có ở Mạng máy tính cho backend.
Giữa các service nội bộ, gRPC có sẵn deadline lan truyền qua từng hop, nên service phía sau biết còn bao nhiêu thời gian; xem Giao tiếp đồng bộ: REST, gRPC, HTTP/2.
HttpClient http = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(1))
.build();
HttpRequest charge = HttpRequest.newBuilder(URI.create(base + "/charge"))
.timeout(Duration.ofSeconds(2)) // timeout cho request này
.header("Idempotency-Key", "order-42-attempt-1")
.POST(HttpRequest.BodyPublishers.ofString("{\"amount\":150000}"))
.build();
// Gọi endpoint chậm 3 giây với timeout 500 ms: HttpTimeoutException sau khoảng 501 ms (đã chạy thử, JDK 21)
Với Spring 6.1+ và RestClient, truyền timeout qua request factory (phác thảo, chưa chạy):
@Bean
RestClient paymentClient(RestClient.Builder builder) {
var jdk = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(1)).build();
var factory = new JdkClientHttpRequestFactory(jdk);
factory.setReadTimeout(Duration.ofSeconds(3));
return builder.baseUrl("https://pay.example.com").requestFactory(factory).build();
}
2. Retry: chỉ khi an toàn, có backoff và jitter
Ý chính: retry cứu được lỗi thoáng qua nhưng cũng biến sự cố nhỏ thành lớn. Chỉ retry khi lỗi đáng retry, gửi lại an toàn, và có chờ giãn cách.
Lỗi thoáng qua là lỗi tự hết sau ít giây (mạng chập, 503 khi bên kia deploy). Ba câu hỏi trước khi retry:
- Lỗi này có đáng retry không? Có: timeout, lỗi kết nối, 429, 502, 503, 504. Không: 400, 401, 403, 404, 422 (gửi lại y nguyên vẫn sai). 500 thì tuỳ, vì nhiều API trả 500 cho lỗi dữ liệu. Với 429, chờ theo header
Retry-Afternếu có; phía server sinh ra 429 thế nào ở Rate limiting: năm thuật toán và token bucket trên Redis. - Gửi lại có an toàn không? GET thì an toàn. POST tạo giao dịch chỉ an toàn khi bên kia hỗ trợ idempotency key: cùng key thì họ trả lại kết quả cũ thay vì tạo giao dịch thứ hai. Không có key thì timeout của lệnh chuyển tiền là trạng thái “không biết”: hỏi trạng thái trước khi gửi lại. Cách thiết kế key có ở bài idempotency.
- Chờ bao lâu giữa các lần? Exponential backoff (thời gian chờ nhân đôi sau mỗi lần) có trần, cộng jitter (chọn ngẫu nhiên thời gian chờ) để hàng nghìn client không retry cùng một lúc.
Ngược lại, phía mình nên deploy sao cho người gọi không thấy 503: readiness, graceful shutdown và rolling update ở Chiến lược deploy.
static Result callWithRetry(HttpClient http, HttpRequest req, int maxAttempts,
Duration base, Duration cap) throws Exception {
for (int attempt = 1; ; attempt++) {
try {
HttpResponse<String> r = http.send(req, HttpResponse.BodyHandlers.ofString());
boolean retryable = r.statusCode() == 429 || r.statusCode() >= 500;
if (!retryable || attempt == maxAttempts) return new Result(r.statusCode(), r.body());
} catch (HttpTimeoutException e) {
if (attempt == maxAttempts) throw e;
}
long ceiling = Math.min(cap.toMillis(), base.toMillis() * (1L << (attempt - 1)));
Thread.sleep(ThreadLocalRandom.current().nextLong(ceiling + 1)); // full jitter
}
}
Kết quả chạy thử vòng retry và những gì production cần thêm
Code Java trong bài (retry có jitter, circuit breaker tối giản) đã chạy thử với JDK 21 trên một server giả lập bằng com.sun.net.httpserver.
Server giả lập trả 503 cho hai lần đầu:
- Lần 1 lỗi, ngủ 60 ms (trần 100).
- Lần 2 lỗi, ngủ 133 ms (trần 200).
- Lần 3 thành công. Server nhận đúng một idempotency key cho cả ba lần.
Đây là bản tối giản để thấy cơ chế. Trong production thêm: tôn trọng header Retry-After của 429/503, deadline tổng, và metric số lần retry.
Retry ngay trong request hay đẩy vào queue tuỳ người dùng có cần kết quả ngay không.
Retry đồng bộ hay đẩy vào queue
3. Circuit breaker và bulkhead
Ý chính: khi bên thứ ba đã chết, circuit breaker ngừng gọi họ và từ chối ngay (fail fast) thay vì chờ timeout. Bulkhead giới hạn số lời gọi đồng thời tới từng bên, để một bên chậm không ăn hết tài nguyên chung.
Retry vào dịch vụ đã chết chỉ giữ thêm thread và làm bên kia khó hồi phục vì vẫn bị gọi dồn. Circuit breaker theo dõi tỉ lệ lỗi qua ba trạng thái:
- CLOSED (đóng mạch): cho gọi bình thường và đếm lỗi.
- OPEN (mở mạch): lỗi vượt ngưỡng thì từ chối ngay mọi lời gọi trong một khoảng thời gian.
- HALF_OPEN (nửa mở): hết thời gian chờ thì cho vài lời gọi thử; thành công thì đóng lại, thất bại thì mở tiếp.
Trong microservices, mọi lời gọi giữa service đều là “bên thứ ba” theo nghĩa này: một service chậm giữ thread của cả chuỗi phía trên, xem Microservices: khi nào tách và tìm ranh giới service.
stateDiagram-v2
[*] --> CLOSED
CLOSED --> OPEN: tỉ lệ lỗi vượt ngưỡng
OPEN --> HALF_OPEN: hết thời gian chờ
HALF_OPEN --> CLOSED: lời gọi thử thành công
HALF_OPEN --> OPEN: lời gọi thử thất bại
Circuit breaker tối giản bằng Java (đã chạy thử)
static final class Breaker {
enum State { CLOSED, OPEN, HALF_OPEN }
private State state = State.CLOSED; private int failures; private Instant openedAt;
private final int threshold; private final Duration openFor;
Breaker(int threshold, Duration openFor) { this.threshold = threshold; this.openFor = openFor; }
synchronized boolean allow() {
if (state == State.OPEN && Instant.now().isAfter(openedAt.plus(openFor))) state = State.HALF_OPEN;
return state != State.OPEN;
}
synchronized void success() { failures = 0; state = State.CLOSED; }
synchronized void failure() {
if (state == State.HALF_OPEN || ++failures >= threshold) { state = State.OPEN; openedAt = Instant.now(); }
}
}
// Ngưỡng 3: lỗi lần 1, 2 vẫn CLOSED, lần 3 chuyển OPEN, lần 4, 5 bị từ chối ngay;
// sau thời gian chờ thì HALF_OPEN, một lời gọi thử thành công thì CLOSED (đã chạy thử)
Bulkhead (vách ngăn, như các khoang kín trên tàu) giới hạn số lời gọi đồng thời tới từng bên thứ ba, bằng semaphore hoặc pool riêng. Nhà cung cấp SMS chậm chỉ chiếm tối đa 20 thread, không kéo theo luồng thanh toán. Với virtual thread (Java 21), thread không còn khan hiếm, nhưng bulkhead vẫn bảo vệ connection pool, bộ nhớ và chính bên thứ ba. Pool connection DB và pool của HTTP client (Apache HttpClient mặc định 5 connection mỗi host) mà bulkhead bảo vệ có ở Connection pool và HikariCP.
Trong Spring Boot 3, dùng Resilience4j thay vì tự viết.
Cấu hình Resilience4j trong Spring Boot 3 và thứ tự các lớp bọc
Cấu hình dưới đây là phác thảo, chưa chạy.
resilience4j:
circuitbreaker:
instances:
sms:
sliding-window-size: 50
failure-rate-threshold: 50 # phần trăm
slow-call-duration-threshold: 2s
slow-call-rate-threshold: 80
wait-duration-in-open-state: 30s
permitted-number-of-calls-in-half-open-state: 5
retry:
instances:
sms:
max-attempts: 3
wait-duration: 200ms
enable-exponential-backoff: true
enable-randomized-wait: true
bulkhead:
instances:
sms:
max-concurrent-calls: 20
@CircuitBreaker(name = "sms", fallbackMethod = "sendViaBackupProvider")
@Retry(name = "sms")
@Bulkhead(name = "sms")
public SmsResult send(OtpMessage m) { return primary.send(m); }
SmsResult sendViaBackupProvider(OtpMessage m, Throwable cause) { return backup.send(m); }
Bài tập
Bài 1: Review một client gọi nhà cung cấp SMS
Một service gửi OTP dùng new RestTemplate() không cấu hình; khi gọi lỗi thì vòng lặp for gửi lại tối đa 5 lần ngay lập tức; gateway phía trước cũng retry 3 lần; nhà cung cấp SMS không hỗ trợ idempotency key. Chỉ ra vấn đề và đề xuất sửa.
Lời giải bài 1
RestTemplatemặc định không có timeout: một lần nhà cung cấp treo là cạn thread. Đặt connect 1 giây, read theo p99 của họ (ví dụ 3 giây).- Retry ngay lập tức, không backoff, không jitter: dồn tải vào lúc họ đang yếu. Dùng backoff có trần và jitter, tối đa 2–3 lần.
- Retry ở hai tầng: 3 × 5 = 15 lời gọi cho một OTP. Bỏ retry ở gateway cho endpoint này.
- Không có idempotency key nên lần timeout có thể đã gửi tin, người dùng nhận nhiều OTP. Với OTP, gửi trùng ít hại hơn không gửi, nhưng nên giới hạn và chỉ retry khi lỗi kết nối (chắc chắn chưa gửi), không retry khi read timeout.
- Thêm circuit breaker với nhà cung cấp dự phòng làm fallback, bulkhead riêng cho SMS, và metric tỉ lệ gửi thành công.
Ghi nhớ
- Kể được ba loại timeout, mỗi loại đặt theo gì, và vì sao client mặc định của Java nguy hiểm.
- Biết lỗi nào retry, lỗi nào không, và khi nào gửi lại một POST là an toàn.
- Giải thích được vì sao cần jitter và vì sao retry ở nhiều tầng gây retry storm.
- Vẽ được ba trạng thái của circuit breaker và nói được bulkhead bảo vệ cái gì khi đã có virtual thread.
- Chọn được fallback cho thanh toán, tỉ giá, SMS và xuất hoá đơn.
Câu hỏi phỏng vấn
Junior
Vì sao mọi lời gọi ra ngoài phải có timeout?
Vì không có timeout, một dịch vụ đang treo giữ thread mãi, và pool thread cạn làm cả service ngừng phục vụ.
Pool thread của server có hạn (Tomcat mặc định 200), nên vài phút sau cả API không liên quan cũng chết. Đặt connect timeout ngắn (1–2 giây), read timeout theo p99 của bên kia, và deadline tổng cho cả các lần retry.
Lỗi nào nên retry, lỗi nào không?
Retry lỗi thoáng qua (timeout, lỗi kết nối, 429, 502, 503, 504); không retry lỗi do chính request (400, 401, 403, 404, 422).
Tôn trọng Retry-After nếu có. Lỗi do request thì gửi lại y nguyên vẫn sai. Và chỉ retry thao tác ghi khi chắc chắn idempotent, thường nhờ idempotency key.
Mid
Exponential backoff và jitter là gì, vì sao cần jitter?
Backoff tăng thời gian chờ theo cấp số nhân có trần; jitter chọn ngẫu nhiên thời gian chờ để các client không retry cùng lúc.
Backoff (100 ms, 200, 400…) cho bên kia thời gian hồi phục. Không có jitter, hàng nghìn client lỗi cùng lúc sẽ retry cùng lúc, tạo các đợt tải đồng bộ đập vào dịch vụ đang yếu. Full jitter (ngẫu nhiên từ 0 tới trần) trải đều tải tốt nhất.
Circuit breaker hoạt động thế nào?
Ba trạng thái: CLOSED đếm lỗi, OPEN từ chối ngay khi lỗi vượt ngưỡng, HALF_OPEN cho vài lời gọi thử để quyết định đóng lại hay mở tiếp.
CLOSED đếm lỗi thường theo tỉ lệ trong một cửa sổ trượt, gồm cả lời gọi chậm. OPEN giữ trong một khoảng thời gian, mọi lời gọi đi thẳng vào fallback. Lợi ích: fail fast thay vì chờ timeout, và bên kia có thời gian hồi phục.
Bulkhead là gì? Có virtual thread rồi thì còn cần không?
Bulkhead giới hạn số lời gọi đồng thời tới từng dependency; vẫn cần với virtual thread, vì tài nguyên khác ngoài thread vẫn hữu hạn.
Dùng semaphore hoặc pool riêng, để một nhà cung cấp chậm chỉ chiếm phần của nó, không ăn hết pool chung. Virtual thread làm thread rẻ, nhưng connection pool HTTP, bộ nhớ cho request đang chờ, quota và sức chịu của bên thứ ba vẫn có hạn. Thường dùng dạng semaphore thay vì thread pool riêng.
Senior
Một nhà cung cấp chậm đi 10 lần làm sập cả hệ thống của bạn. Phân tích và sửa.
Nguyên nhân là chuỗi: timeout dài giữ tài nguyên, retry nhiều tầng nhân tải, rồi sự cố lan sang cả hệ thống. Sửa bằng timeout, retry một tầng, circuit breaker, bulkhead và fallback.
Chuỗi thường gặp: không có timeout hoặc timeout quá dài, thread và connection pool bị giữ, retry ở nhiều tầng nhân tải, request của người dùng xếp hàng, health check cũng chậm, instance bị restart, tải dồn sang instance còn lại.
Sửa:
- Timeout theo p99 và deadline tổng.
- Retry ở một tầng với jitter và retry budget.
- Circuit breaker tính cả lời gọi chậm; bulkhead riêng cho nhà cung cấp đó.
- Fallback theo nghiệp vụ; đưa lời gọi không cần đồng bộ vào queue.
- Metric và cảnh báo latency theo từng nhà cung cấp.
Gọi API tạo giao dịch bị timeout. Bạn có gửi lại không?
Chỉ gửi lại khi có idempotency key; không có thì hỏi trạng thái trước, vì timeout nghĩa là “không biết”, bên kia có thể đã tạo giao dịch.
Có key thì gửi lại với cùng key, bên kia trả kết quả cũ thay vì tạo cái mới. Không có key thì không gửi lại mù: hỏi trạng thái theo mã tham chiếu của mình, đánh dấu bản ghi là UNKNOWN và để job đối soát giải quyết. Lỗi kết nối trước khi gửi được request (connect timeout) thì retry an toàn hơn read timeout.
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 |
|---|---|---|---|
| connect timeout | /kəˈnekt ˈtaɪm.aʊt/ | thời gian chờ kết nối | “We set a one-second connect timeout on every outbound client.” |
| exponential backoff | /ˌek.spoʊˈnen.ʃəl ˈbæk.ɔːf/ | chờ tăng theo cấp số nhân | “We retry with exponential backoff capped at two seconds.” |
| jitter | /ˈdʒɪt̬.ɚ/ | độ ngẫu nhiên thêm vào thời gian chờ | “Jitter spreads retries out so clients don’t hit the provider in lockstep.” |
| retry storm | /ˈriː.traɪ stɔːrm/ | bão retry | “Retrying at every layer turned a slowdown into a retry storm.” |
| idempotency key | /ˌaɪ.dəmˈpoʊ.tən.si kiː/ | khoá idempotent | “We resend the payment with the same idempotency key.” |
| circuit breaker | /ˈsɝː.kɪt ˈbreɪ.kɚ/ | cầu dao ngắt mạch | “The circuit breaker opens once half of the calls fail.” |
| bulkhead | /ˈbʌlk.hed/ | vách ngăn tài nguyên | “A bulkhead caps concurrent SMS calls at twenty.” |
| fallback | /ˈfɔːl.bæk/ | phương án dự phòng | “For SMS the fallback is a secondary provider.” |
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.