Microservices ở Quy Mô Lớn — Thiết Kế và Vận Hành
Bạn đã chia service, setup CI/CD, deploy độc lập — microservices “theo sách” hoàn toàn. Rồi một đêm production sập, và bạn không biết bắt đầu debug từ đâu vì không có gì log lại toàn bộ flow giữa 20 service.
Bài này giải thích tại sao microservices quy mô lớn thất bại theo những cách không ai nói trước — và những pattern thực sự giải quyết được vấn đề đó.
Uber từng vận hành 2,200 microservices và phải consolidate lại. Không phải vì microservices sai — mà vì họ thiếu đúng những thứ bài này sẽ nói đến.
Choreography trông gọn — nhưng ẩn đi mọi thứ quan trọng
Khi mới thiết kế microservices, choreography có vẻ lý tưởng: service A emit event, service B lắng nghe và xử lý, không cần ai điều phối. Mọi thứ loose coupled, deploy độc lập.
Vấn đề nằm ở chỗ: không có ai biết toàn bộ flow đang xảy ra như thế nào.
Thử tưởng tượng: PaymentService emit payment.completed. InventoryService lắng nghe và trừ tồn kho. NotificationService lắng nghe và gửi email xác nhận. Chạy tốt — cho đến khi InventoryService có bug, consume event 2 lần, trừ tồn kho 2 lần. Bạn mất 3 ngày debug vì không có một chỗ nào show toàn bộ chain.
Implicit flow = invisible flow. Đây không phải lỗi của choreography — đây là trade-off bạn phải biết trước khi chọn nó. Ở quy mô nhỏ, choreography ổn. Ở quy mô lớn với nhiều team, bạn cần visibility.
Vấn đề gốc rễ: Distributed State không thể atomic như bạn nghĩ
Giả sử bạn muốn đảm bảo: “Khi tạo Order thành công, phải emit event order.created lên Kafka.” Nghe đơn giản — nhưng thực ra đây là bài toán dual-write không có giải pháp hoàn hảo.
Two-Phase Commit (2PC) là cách truyền thống: coordinator hỏi tất cả participants “bạn có thể commit không?” (Phase 1), rồi ra lệnh commit nếu tất cả đồng ý (Phase 2). Nhưng nếu coordinator crash sau Phase 1 — tất cả participants giữ exclusive lock và không ai biết có nên commit không. Hệ thống treo.
MySQL XA (implementation của 2PC) chậm hơn transaction thường 10 lần. Với 100 services chạy song song, 0.999^100 ≈ 90% — nghĩa là 10% transaction sẽ fail chỉ do reliability của protocol. Đây là constraint vật lý, không phải lỗi thiết kế của bạn.
Outbox Pattern + Saga Orchestration: Giải pháp thực sự
Outbox Pattern giải quyết dual-write bằng cách không dùng 2 write operations — mà gộp cả 2 vào 1 local transaction:
BEGIN; INSERT INTO orders (id, status) VALUES (123, 'created'); INSERT INTO outbox (event_type, payload) VALUES ('order.created', '{"id":123}');COMMIT;
Một CDC tool (như Debezium) đọc binlog của database và relay event từ bảng outbox lên Kafka. Nếu service crash sau COMMIT — CDC tool replay lại từ binlog. Nếu crash trước COMMIT — không có gì được write. Atomic by design, không cần 2PC.
Thay vì phải gọi bưu điện ngay sau khi ký hợp đồng, để thư vào hòm thư nhà (outbox table) rồi để bưu tá lấy sau — outbox đảm bảo thư luôn đi nếu hợp đồng đã ký.
Saga Orchestration giải quyết multi-service coordination. Thay vì event chain ẩn, có một Saga Orchestrator tường minh:
OrderSaga: → PlaceOrder (OrderService) → ProcessPayment (PaymentService) → ReserveInventory (InventoryService) → SendConfirmation (NotificationService)Nếu PaymentService fail: → Cancel reservation (compensating) → Restore order status (compensating)
Mỗi step là local transaction. Compensating transactions xử lý rollback. Bạn thấy được toàn bộ flow — và biết chính xác step nào fail.
CQRS + Event Sourcing: Khi Read và Write cần sống riêng
Một misconception phổ biến: “CQRS = over-engineering.” Thực ra, CQRS chỉ là nhận ra rằng read pattern và write pattern rất khác nhau.
Write cần ACID, normalized data, conflict detection. Read cần denormalized views, fast query, multiple formats cho nhiều client. Khi dùng cùng một model cho cả hai — bạn compromise cả hai.
CQRS tách Command Model (write-optimized, normalized) và Query Model (read-optimized, denormalized). Chúng được sync qua event stream. Khi OrderService write một Order, nó emit event — Query Model consume event và rebuild read view.
Event Sourcing đi xa hơn: thay vì lưu state hiện tại, bạn lưu từng event đã xảy ra:
OrderCreated → PaymentProcessed → InventoryReserved → OrderShipped
State hiện tại = projection từ toàn bộ event log. Giống são kê ngân hàng — không lưu “số dư hiện tại” mà lưu từng giao dịch; số dư = tổng tất cả transactions và bạn có thể biết số dư tại bất kỳ thời điểm nào trong quá khứ.
Lo ngại về event log unbounded? Snapshot — định kỳ tạo snapshot của state tại một thời điểm, replay chỉ từ snapshot đó trở đi.
Conway’s Law: Kiến trúc của bạn phản chiếu tổ chức của bạn
Uber giai đoạn đầu có 2,200 microservices. Rồi họ tăng lên 5,000+. Và phải consolidate lại. Không phải vì microservices sai — mà vì số lượng team communication tăng theo O(n²): với 100 team, bạn có ~5,000 cặp communication tiềm năng.
Conway’s Law không phải observation thú vị — đây là hard constraint. Nếu 3 team cùng build 1 compiler, bạn sẽ nhận được compiler 3 pass. Ranh giới team tự nhiên trở thành ranh giới module. Thiết kế microservices ngược với team structure sẽ tạo O(n²) coordination overhead.
Bounded Context giải quyết: mỗi service có một vocabulary riêng nhất quán. “Order” trong OrderService có nghĩa khác với “Order” trong ShippingService — và đó là điều bình thường. Bạn không cần thống nhất toàn bộ domain model, chỉ cần rõ ràng ranh giới.
Mỗi Bounded Context = 1 team. Mỗi team sở hữu hoàn toàn service của mình. Conway’s Law trở thành asset thay vì liability.
Service Mesh + Observability: Nhìn thấy để kiểm soát
Retry là tính năng tốt — cho đến khi nó tạo ra cascade failure. Service A retry 3 lần → gọi Service B. Service B retry 3 lần → gọi Service C. Kết quả: 9 requests đồng thời vào Service C thay vì 1. Service C crash. Domino effect bắt đầu.
Uber đo được: 100ms latency tăng thêm = 1% revenue drop. Circuit breaker phải open trước khi cascade xảy ra — không phải sau.
Service Mesh (Istio, Linkerd) xử lý cross-cutting concerns ở infrastructure layer: retry policy, circuit breaking, mTLS, load balancing — mà không cần từng service tự implement. Team tập trung vào business logic, không phải networking code.
Distributed Tracing là thứ bạn ước mình có trong đêm production sập đó. Mỗi request mang một trace-id duy nhất — mỗi service log trace-id vào span của mình. Bạn thấy được toàn bộ journey của một request: từ API Gateway → AuthService → OrderService → PaymentService, với latency của từng hop. OpenTelemetry là standard mở hiện được hầu hết platform hỗ trợ.
Giống barcode tracking của bưu điện — mỗi bưu cục scan barcode, bạn biết package đang ở đâu mọi lúc và mất bao lâu ở từng điểm.
Tổng Kết
Ba insight quan trọng nhất từ bài này:
1. Choreography ẩn complexity, không loại bỏ nó. Ở quy mô lớn, bạn cần Saga Orchestration để có visibility và control.
2. Distributed state không thể atomic theo cách truyền thống. Outbox Pattern + CDC là giải pháp production-grade — không cần 2PC.
3. Conway’s Law là constraint thiết kế, không phải observation. Align service boundary với team boundary, dùng Bounded Context để giữ vocabulary nhất quán.
Microservices ở quy mô lớn không thất bại vì thiếu service — mà vì thiếu pattern đúng ở tầng coordination, state management, và observability.
Bài tiếp theo sẽ đi sâu vào Circuit Breaker, Bulkhead, và Rate Limiting — ba pattern giữ cho hệ thống đứng vững khi một phần của nó bắt đầu fail.


Để lại một bình luận