---
title: "Outbox pattern: ghi database và gửi message mà không mất đơn"
description: "Outbox pattern là gì: ghi đơn và event trong cùng một transaction, rồi relay gửi sau; demo PostgreSQL cho thấy dual-write làm mất message khi service restart."
canonical: "https://200lab.io/blog/outbox-pattern-la-gi"
published: "2026-11-16T02:00:16Z"
updated: "2026-11-16T02:00:16Z"
authors: ["Việt Trần"]
tags: ["Backend", "System Design"]
reading_minutes: 22
access: "public"
---

Giả sử bạn đang làm một hệ thống thương mại điện tử có service bán hàng và service kho tách rời, nhưng ngay sau khi lưu một đơn hàng vào database thì process bán hàng đột ngột restart trước khi kịp gửi message báo cho kho. Hệ quả là đơn hàng đã nằm trong database, nhưng phía kho không nhận được thông báo nào để soạn hàng cho khách.

**Outbox pattern (transactional outbox) là mẫu thiết kế ghi dữ liệu nghiệp vụ và message cần phát đi vào cùng một database transaction, sau đó dùng một tiến trình relay đọc bảng outbox để gửi tới message broker.**

Trong bài này, mình giải thích dual-write, transactional outbox, rồi chạy thử một chương trình Go kết nối PostgreSQL để xem số liệu của cả hai cách làm.

## Dual-write: đơn đã lưu, message sang kho lại mất

Khi một thao tác nghiệp vụ trong kiến trúc [microservices](/blog/microservices-la-gi) cần vừa lưu dữ liệu vào database vừa gửi message tới message broker như hai bước tách biệt, cách làm đó gọi là dual-write. Ở đây, transaction là một nhóm thao tác trên database chỉ hoàn tất cùng nhau qua bước commit, hoặc hủy bỏ cùng nhau qua bước rollback, đúng với tính atomicity trong [ACID](/blog/acid-la-gi). Còn broker là hệ thống trung gian nhận và chuyển tiếp message giữa các service, thường gặp dưới dạng [message queue](/blog/message-queue-la-gi).

Vấn đề nằm ở chỗ database và broker là hai hệ thống độc lập nên việc ghi vào cả hai theo hai bước rời rạc dễ dẫn đến lệch dữ liệu. Theo AWS Prescriptive Guidance trong tài liệu [Transactional outbox pattern](https://docs.aws.amazon.com/prescriptive-guidance/latest/cloud-design-patterns/transactional-outbox.html), nếu bước cập nhật database thành công nhưng bước gửi event thất bại, các service phía sau sẽ không biết có thay đổi mới.

Ngược lại, theo AWS Prescriptive Guidance, nếu bước cập nhật database gặp lỗi và bị rollback nhưng event vẫn được gửi đi, service phía sau sẽ xử lý trên dữ liệu không tồn tại. Dù bạn chọn gửi message trước hay sau khi commit database, rủi ro rớt network hoặc crash process ở giữa hai bước đều có thể xảy ra.

Nếu gửi message ngay trong lúc transaction đang mở, chúng ta cũng chưa biết bước commit cuối cùng có thành công hay không. Còn nếu đợi commit xong mới gửi message qua network như ví dụ đầu bài, một cú restart đúng lúc sẽ làm mất dấu việc cần thông báo cho kho.

![Dù commit trước hay gửi message trước, dual-write vẫn có một điểm hỏng giữa hai bước](https://assets.200lab.io/sha256/61/61d03e51c9e8aa6c76153137224a2e58cc6636d41b45e46001a57ab4e9a1f53a/generations/c6455915fb000283f6582c3eec1c0d0314373d2c96a6ed2e6d83eac150012d30)

## Transactional outbox ghi event trong cùng một transaction

Để tránh cảnh ghi hai nơi rời rạc, chúng ta có thể gom việc lưu đơn và việc ghi nhận event vào chung một database. Theo pattern [Transactional outbox](https://microservices.io/patterns/data/transactional-outbox.html) trên trang microservices.io của Chris Richardson, service sẽ lưu message vào một bảng outbox ngay trong cùng transaction cập nhật dữ liệu nghiệp vụ.

Outbox ở đây đơn giản là một bảng nằm trong cùng database với bảng đơn hàng, đóng vai trò như khay chứa các message chờ được gửi đi. Sau đó, một process riêng biệt gọi là message relay sẽ đọc các dòng trong bảng outbox này và gửi chúng tới message broker.

![Đơn và event nằm chung một transaction; relay gửi sau, consumer kho tự chống trùng](https://assets.200lab.io/sha256/c7/c775250c67cace31771a922513dd01013697ae4da37616801894576690d2de5c/generations/f60c6421740f9e05553455b63608bc39856dd5ce9c7e2f5c7b0aa697fb571ba6)

Cách tiếp cận này giúp chúng ta không phải dùng giao thức two-phase commit (2PC) nối giữa database và message broker. Việc kéo một transaction trải rộng trên hai hệ thống khác nhau thường khó dùng hoặc không khả thi trong thực tế, bạn có thể đọc thêm bài [distributed transaction](/blog/distributed-transaction-la-gi) để rõ hơn.

Theo cách diễn giải từ tài liệu của Chris Richardson, nếu transaction commit thành công thì cả đơn hàng lẫn dòng outbox đều đã nằm trong database, nên relay còn dữ liệu để gửi đi sau đó. Ngược lại, nếu có lỗi khiến transaction bị rollback, cả đơn hàng và dòng outbox đều không được lưu lại.

Chúng ta sẽ thấy rõ tính chất này ở trường hợp đơn hàng lỗi `ORD-FAIL` trong phần chạy thử bên dưới, khi database không để sót lại dòng rác nào. Nhờ gom chung vào một local transaction trên [PostgreSQL](/blog/postgresql-la-gi), trạng thái của đơn hàng và trạng thái chờ gửi message đi cùng nhau.

## Relay gửi sau, consumer cần chống trùng

Khi dữ liệu đã nằm trong bảng outbox, nhiệm vụ tiếp theo thuộc về message relay (gọi tắt là relay). Process này định kỳ quét các dòng chưa gửi trong bảng outbox, publish chúng lên broker, rồi mới cập nhật trạng thái dòng đó thành đã gửi.

Tuy nhiên, cả tài liệu của Chris Richardson lẫn AWS Prescriptive Guidance đều chỉ ra rằng relay có thể gửi một message nhiều hơn một lần. Ví dụ, relay vừa publish message lên broker xong thì bị crash ngay trước khi kịp đánh dấu dòng outbox đó là đã gửi trong database.

Khi relay khởi động lại, nó kiểm tra bảng outbox và thấy dòng kia vẫn mang trạng thái chưa gửi nên sẽ thực hiện publish lại lần nữa. Kiểu giao nhận mà message được gửi ít nhất một lần và có thể bị lặp lại như vậy được gọi là at-least-once, chứ không phải chỉ gửi đúng một lần.

Lúc này, trách nhiệm xử lý bản sao thuộc về consumer, tức là service đọc message từ broker để thực hiện công việc tiếp theo như soạn hàng ở kho. Bạn cần thiết kế [idempotent consumer](/blog/idempotent-consumer-la-gi), nghĩa là dù có nhận cùng một message nhiều lần thì kết quả xử lý cuối cùng vẫn giữ nguyên như khi nhận một lần.

Cách phổ biến để làm idempotent là consumer lưu lại ID của các event đã xử lý vào database và bỏ qua nếu gặp lại ID cũ. Trong chương trình chạy thử sắp tới, bạn sẽ thấy broker nhận tới 4 message do event `evt-ORD-2` bị gửi hai lần, nhưng kho vẫn bỏ qua được 1 bản trùng để đóng gói đúng 3 đơn.

## Chạy thử trên PostgreSQL: dual-write và outbox

Để thấy rõ sự khác biệt giữa hai cách làm, mình có chuẩn bị một chương trình Go và chạy thật trên PostgreSQL 17.11. Các con số bên dưới là kết quả thu được từ lần chạy chương trình demo này trên máy, không phải số đo từ hệ thống production.

Trong bài test này, phần broker được giả lập bằng một bảng trong cùng database để tiện quan sát, chứ không dựng [Kafka](/blog/kafka-la-gi) hay Amazon SQS thật, còn tình huống crash được mô phỏng ngay trong code bằng cách dừng ngang bước tiếp theo thay vì kill hệ điều hành.

Kịch bản của chúng ta xoay quanh ba đơn hàng minh họa gồm `ORD-1` đặt 2 áo `TEE-NAVY`, `ORD-2` đặt 1 quần `JEAN-32`, và `ORD-3` đặt 3 nón `CAP-BEIGE`. Chúng ta thử xem đoạn code dưới đây nha:

```go
// compare_outbox.go compares a dual-write path (order commit then publish)
// with a transactional outbox path against a real PostgreSQL database.
//
// The broker is a table in the same cluster used only as a stand-in queue.
// Crash points are explicit skips in this process, not OS kills.
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"

	"github.com/jackc/pgx/v5"
)

type Order struct {
	ID  string
	SKU string
	Qty int
}

func main() {
	ctx := context.Background()
	dsn := os.Getenv("OUTBOX_DSN")
	if dsn == "" {
		dsn = "postgres://box@127.0.0.1:55432/outbox_demo?sslmode=disable"
	}
	conn, err := pgx.Connect(ctx, dsn)
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close(ctx)

	orders := []Order{
		{ID: "ORD-1", SKU: "TEE-NAVY", Qty: 2},
		{ID: "ORD-2", SKU: "JEAN-32", Qty: 1},
		{ID: "ORD-3", SKU: "CAP-BEIGE", Qty: 3},
	}

	fmt.Println("PostgreSQL:", mustVersion(ctx, conn))
	fmt.Println("Scenario: 3 new orders should notify the warehouse.")
	fmt.Println("Crash is simulated in-process (skip the next step), not an OS kill.")
	fmt.Println()

	runDualWrite(ctx, conn, orders)
	fmt.Println()
	runOutbox(ctx, conn, orders)
}

func mustVersion(ctx context.Context, conn *pgx.Conn) string {
	var v string
	if err := conn.QueryRow(ctx, "SELECT version()").Scan(&v); err != nil {
		log.Fatal(err)
	}
	return v
}

func reset(ctx context.Context, conn *pgx.Conn, schema string) {
	_, err := conn.Exec(ctx, `DROP SCHEMA IF EXISTS `+schema+` CASCADE; CREATE SCHEMA `+schema)
	if err != nil {
		log.Fatal(err)
	}
	_, err = conn.Exec(ctx, `
		CREATE TABLE `+schema+`.orders (
			id TEXT PRIMARY KEY,
			sku TEXT NOT NULL,
			qty INT NOT NULL,
			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE TABLE `+schema+`.broker (
			seq BIGSERIAL PRIMARY KEY,
			event_id TEXT NOT NULL,
			payload JSONB NOT NULL,
			enqueued_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE TABLE `+schema+`.outbox (
			id TEXT PRIMARY KEY,
			event_type TEXT NOT NULL,
			payload JSONB NOT NULL,
			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
			published_at TIMESTAMPTZ
		);
		CREATE TABLE `+schema+`.warehouse_inbox (
			event_id TEXT PRIMARY KEY,
			order_id TEXT NOT NULL,
			sku TEXT NOT NULL,
			qty INT NOT NULL,
			received_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
	`)
	if err != nil {
		log.Fatal(err)
	}
}

func count(ctx context.Context, conn *pgx.Conn, q string) int {
	var n int
	if err := conn.QueryRow(ctx, q).Scan(&n); err != nil {
		log.Fatal(err)
	}
	return n
}

func ids(ctx context.Context, conn *pgx.Conn, q string) string {
	rows, err := conn.Query(ctx, q)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	var out []string
	for rows.Next() {
		var s string
		if err := rows.Scan(&s); err != nil {
			log.Fatal(err)
		}
		out = append(out, s)
	}
	if err := rows.Err(); err != nil {
		log.Fatal(err)
	}
	if len(out) == 0 {
		return "(none)"
	}
	s := out[0]
	for i := 1; i < len(out); i++ {
		s += ", " + out[i]
	}
	return s
}

func payload(o Order) []byte {
	b, err := json.Marshal(map[string]any{
		"order_id": o.ID, "sku": o.SKU, "qty": o.Qty,
	})
	if err != nil {
		log.Fatal(err)
	}
	return b
}

func publishBroker(ctx context.Context, conn *pgx.Conn, schema, eventID string, body []byte) {
	_, err := conn.Exec(ctx,
		`INSERT INTO `+schema+`.broker (event_id, payload) VALUES ($1, $2)`,
		eventID, body)
	if err != nil {
		log.Fatal(err)
	}
}

func consume(ctx context.Context, conn *pgx.Conn, schema string) (applied, skipped int) {
	rows, err := conn.Query(ctx, `SELECT event_id, payload FROM `+schema+`.broker ORDER BY seq`)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	type ev struct {
		EventID string
		Payload []byte
	}
	var list []ev
	for rows.Next() {
		var e ev
		if err := rows.Scan(&e.EventID, &e.Payload); err != nil {
			log.Fatal(err)
		}
		list = append(list, e)
	}
	if err := rows.Err(); err != nil {
		log.Fatal(err)
	}
	for _, e := range list {
		var m struct {
			OrderID string `json:"order_id"`
			SKU     string `json:"sku"`
			Qty     int    `json:"qty"`
		}
		if err := json.Unmarshal(e.Payload, &m); err != nil {
			log.Fatal(err)
		}
		tag, err := conn.Exec(ctx, `
			INSERT INTO `+schema+`.warehouse_inbox (event_id, order_id, sku, qty)
			VALUES ($1, $2, $3, $4)
			ON CONFLICT (event_id) DO NOTHING`,
			e.EventID, m.OrderID, m.SKU, m.Qty)
		if err != nil {
			log.Fatal(err)
		}
		if tag.RowsAffected() == 1 {
			applied++
		} else {
			skipped++
		}
	}
	return applied, skipped
}

func runDualWrite(ctx context.Context, conn *pgx.Conn, orders []Order) {
	const schema = "dual"
	reset(ctx, conn, schema)
	fmt.Println("=== Path A: dual-write (commit order, then publish) ===")

	for _, o := range orders {
		tx, err := conn.Begin(ctx)
		if err != nil {
			log.Fatal(err)
		}
		_, err = tx.Exec(ctx,
			`INSERT INTO dual.orders (id, sku, qty) VALUES ($1, $2, $3)`,
			o.ID, o.SKU, o.Qty)
		if err != nil {
			_ = tx.Rollback(ctx)
			log.Fatal(err)
		}
		if err := tx.Commit(ctx); err != nil {
			log.Fatal(err)
		}
		// Simulate a crash after ORD-2 is committed but before publish.
		if o.ID == "ORD-2" {
			fmt.Println("crash after commit of ORD-2, before publish; process restarts")
			continue
		}
		publishBroker(ctx, conn, schema, "evt-"+o.ID, payload(o))
		fmt.Println("committed and published", o.ID)
	}

	applied, skipped := consume(ctx, conn, schema)
	fmt.Printf("orders in DB: %d [%s]\n",
		count(ctx, conn, `SELECT count(*) FROM dual.orders`),
		ids(ctx, conn, `SELECT id FROM dual.orders ORDER BY id`))
	fmt.Printf("messages on broker: %d [%s]\n",
		count(ctx, conn, `SELECT count(*) FROM dual.broker`),
		ids(ctx, conn, `SELECT event_id FROM dual.broker ORDER BY seq`))
	fmt.Printf("warehouse applied: %d, skipped duplicates: %d, packed orders: [%s]\n",
		applied, skipped,
		ids(ctx, conn, `SELECT order_id FROM dual.warehouse_inbox ORDER BY order_id`))
	fmt.Println("After restart there is no outbox row for ORD-2, so the warehouse never sees it.")
}

func runOutbox(ctx context.Context, conn *pgx.Conn, orders []Order) {
	const schema = "obx"
	reset(ctx, conn, schema)
	fmt.Println("=== Path B: transactional outbox (order + outbox in one transaction) ===")

	for _, o := range orders {
		tx, err := conn.Begin(ctx)
		if err != nil {
			log.Fatal(err)
		}
		_, err = tx.Exec(ctx,
			`INSERT INTO obx.orders (id, sku, qty) VALUES ($1, $2, $3)`,
			o.ID, o.SKU, o.Qty)
		if err != nil {
			_ = tx.Rollback(ctx)
			log.Fatal(err)
		}
		eventID := "evt-" + o.ID
		_, err = tx.Exec(ctx, `
			INSERT INTO obx.outbox (id, event_type, payload)
			VALUES ($1, 'order.created', $2)`, eventID, payload(o))
		if err != nil {
			_ = tx.Rollback(ctx)
			log.Fatal(err)
		}
		if err := tx.Commit(ctx); err != nil {
			log.Fatal(err)
		}
		fmt.Println("committed order+outbox", o.ID)
	}

	// Also show a rolled-back attempt leaves neither order nor outbox row.
	tx, err := conn.Begin(ctx)
	if err != nil {
		log.Fatal(err)
	}
	_, err = tx.Exec(ctx, `INSERT INTO obx.orders (id, sku, qty) VALUES ('ORD-FAIL', 'X', 1)`)
	if err != nil {
		_ = tx.Rollback(ctx)
		log.Fatal(err)
	}
	_, err = tx.Exec(ctx, `
		INSERT INTO obx.outbox (id, event_type, payload)
		VALUES ('evt-ORD-FAIL', 'order.created', '{"order_id":"ORD-FAIL"}')`)
	if err != nil {
		_ = tx.Rollback(ctx)
		log.Fatal(err)
	}
	if err := tx.Rollback(ctx); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("rolled back ORD-FAIL; leftover orders=%d outbox=%d\n",
		count(ctx, conn, `SELECT count(*) FROM obx.orders WHERE id='ORD-FAIL'`),
		count(ctx, conn, `SELECT count(*) FROM obx.outbox WHERE id='evt-ORD-FAIL'`))

	relay := func(label string, crashAfterEvent string) {
		rows, err := conn.Query(ctx, `
			SELECT id, payload FROM obx.outbox
			WHERE published_at IS NULL
			ORDER BY created_at, id`)
		if err != nil {
			log.Fatal(err)
		}
		type row struct {
			ID      string
			Payload []byte
		}
		var list []row
		for rows.Next() {
			var r row
			if err := rows.Scan(&r.ID, &r.Payload); err != nil {
				log.Fatal(err)
			}
			list = append(list, r)
		}
		rows.Close()
		if err := rows.Err(); err != nil {
			log.Fatal(err)
		}
		fmt.Printf("relay %s: unpublished outbox rows=%d\n", label, len(list))
		for _, r := range list {
			publishBroker(ctx, conn, "obx", r.ID, r.Payload)
			if r.ID == crashAfterEvent {
				fmt.Println("crash after publish of", r.ID, "before marking published_at; relay restarts")
				return
			}
			_, err := conn.Exec(ctx, `UPDATE obx.outbox SET published_at = now() WHERE id=$1`, r.ID)
			if err != nil {
				log.Fatal(err)
			}
			fmt.Println("published and marked", r.ID)
		}
	}

	relay("first pass", "evt-ORD-2")
	relay("after restart", "")

	applied, skipped := consume(ctx, conn, "obx")
	fmt.Printf("orders in DB: %d [%s]\n",
		count(ctx, conn, `SELECT count(*) FROM obx.orders`),
		ids(ctx, conn, `SELECT id FROM obx.orders ORDER BY id`))
	fmt.Printf("outbox rows: %d, still unpublished: %d\n",
		count(ctx, conn, `SELECT count(*) FROM obx.outbox`),
		count(ctx, conn, `SELECT count(*) FROM obx.outbox WHERE published_at IS NULL`))
	fmt.Printf("messages on broker: %d [%s]\n",
		count(ctx, conn, `SELECT count(*) FROM obx.broker`),
		ids(ctx, conn, `SELECT event_id FROM obx.broker ORDER BY seq`))
	fmt.Printf("warehouse applied: %d, skipped duplicates: %d, packed orders: [%s]\n",
		applied, skipped,
		ids(ctx, conn, `SELECT order_id FROM obx.warehouse_inbox ORDER BY order_id`))
}
```

```text
PostgreSQL: PostgreSQL 17.11 on x86_64-pc-linux-gnu, compiled by gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0, 64-bit
Scenario: 3 new orders should notify the warehouse.
Crash is simulated in-process (skip the next step), not an OS kill.

=== Path A: dual-write (commit order, then publish) ===
committed and published ORD-1
crash after commit of ORD-2, before publish; process restarts
committed and published ORD-3
orders in DB: 3 [ORD-1, ORD-2, ORD-3]
messages on broker: 2 [evt-ORD-1, evt-ORD-3]
warehouse applied: 2, skipped duplicates: 0, packed orders: [ORD-1, ORD-3]
After restart there is no outbox row for ORD-2, so the warehouse never sees it.

=== Path B: transactional outbox (order + outbox in one transaction) ===
committed order+outbox ORD-1
committed order+outbox ORD-2
committed order+outbox ORD-3
rolled back ORD-FAIL; leftover orders=0 outbox=0
relay first pass: unpublished outbox rows=3
published and marked evt-ORD-1
crash after publish of evt-ORD-2 before marking published_at; relay restarts
relay after restart: unpublished outbox rows=2
published and marked evt-ORD-2
published and marked evt-ORD-3
orders in DB: 3 [ORD-1, ORD-2, ORD-3]
outbox rows: 3, still unpublished: 0
messages on broker: 4 [evt-ORD-1, evt-ORD-2, evt-ORD-2, evt-ORD-3]
warehouse applied: 3, skipped duplicates: 1, packed orders: [ORD-1, ORD-2, ORD-3]
```

Bạn có thể bấm nút Tới ở khung dưới đây để đi qua từng bước, xem dual-write mất `ORD-2` khi crash, còn outbox gửi lại `evt-ORD-2` và kho bỏ qua bản trùng.

Ở nhánh A dùng dual-write, chương trình thực hiện commit đơn hàng vào database trước rồi mới gọi hàm publish message lên broker. Với đơn `ORD-1` và `ORD-3`, cả hai bước đều diễn ra bình thường nên message `evt-ORD-1` và `evt-ORD-3` có mặt trên broker.

Riêng ở đơn `ORD-2`, chương trình mô phỏng việc process bị crash ngay sau khi commit đơn vào database nhưng trước khi kịp publish message. Khi process restart và chạy tiếp, bảng đơn hàng trong database ghi nhận đủ 3 đơn là `ORD-1`, `ORD-2` và `ORD-3`.

Thế nhưng trên broker lúc này chỉ có 2 message là `evt-ORD-1` và `evt-ORD-3`, thiếu mất `evt-ORD-2`. Phía kho sau khi đọc từ broker chỉ áp dụng được 2 message, số bản trùng bị bỏ qua là 0, và danh sách đóng gói chỉ có `ORD-1` cùng `ORD-3`.

Vì nhánh A không hề lưu bảng outbox, sau khi process restart thì hệ thống không có chỗ nào để tìm lại thông tin message chưa gửi của `ORD-2`. Kết quả là đơn `ORD-2` nằm im trong bảng đơn hàng mà phía kho không hề hay biết để soạn hàng.

Sang nhánh B dùng transactional outbox, chương trình ghi cả đơn hàng và dòng outbox vào chung một transaction cho cả ba đơn `ORD-1`, `ORD-2` và `ORD-3`. Mình cũng thử chèn thêm một đơn `ORD-FAIL` bị rollback giữa chừng để kiểm tra, và kết quả là số đơn còn sót lại bằng 0, số dòng outbox của nó cũng bằng 0.

Tiếp theo, ở lượt chạy đầu tiên của relay, nó nhìn thấy 3 dòng outbox chưa gửi trong database. Relay publish xong `evt-ORD-1` và đánh dấu đã gửi thành công, nhưng đến `evt-ORD-2` thì nó vừa publish lên broker xong đã bị crash trước khi kịp cập nhật cột `published_at`.

Khi relay restart và chạy lượt thứ hai, nó kiểm tra bảng outbox và thấy vẫn còn 2 dòng chưa được đánh dấu là `evt-ORD-2` và `evt-ORD-3`. Do đó, relay tiến hành publish cả `evt-ORD-2` lẫn `evt-ORD-3` lên broker rồi cập nhật trạng thái đã gửi cho cả hai.

Khép lại nhánh B, database có 3 đơn hàng, bảng outbox có 3 dòng đã gửi và 0 dòng chưa gửi, còn trên broker có tổng cộng 4 message. Danh sách trên broker gồm một bản `evt-ORD-1`, một bản `evt-ORD-3` và hai bản `evt-ORD-2`, trong đó bản `evt-ORD-2` thứ hai xuất hiện do relay gửi lại sau khi restart.

Phía consumer của kho nhờ dùng lệnh `INSERT ... ON CONFLICT (event_id) DO NOTHING` nên đã áp dụng 3 message, bỏ qua 1 bản trùng và đóng gói đủ 3 đơn `ORD-1`, `ORD-2`, `ORD-3`. Như bạn thấy, outbox giúp message không bị thất lạc sau cú restart trong kịch bản này, nhưng không có nghĩa là tổng số lần gửi sẽ ít đi hay chỉ gửi đúng một lần.

![Dual-write mất ORD-2 sau crash; outbox gửi trùng evt-ORD-2 nhưng kho bỏ bản trùng và đóng gói đủ 3 đơn](https://assets.200lab.io/sha256/11/11b41c1b36944dabf9e60ed9210d886a9cd5fdaaae232e05bb41e7006c18e66a/generations/5c684b5b340b68cc4cb5b98d846c0f14c390b0f08b68d646e88f94cd3287bc92)

## Khi outbox một mình chưa đủ

Qua ví dụ trên, bảng outbox giải quyết tốt bài toán đồng bộ giữa việc cập nhật database của một service và việc phát sự kiện ra ngoài. Tuy nhiên, nếu một luồng nghiệp vụ dài cần đi qua nhiều service và cập nhật nhiều database khác nhau, một bảng outbox ở một nơi chưa thể thay thế cho cơ chế điều phối cả chuỗi.

Giả sử sau khi kho soạn hàng xong lại phát sinh bước trừ tiền hoặc hoàn tiền khi hết hàng, chúng ta sẽ cần một cách quản lý trạng thái xuyên suốt các bước đó. Trong tài liệu của AWS Prescriptive Guidance, họ gợi ý xem xét dùng saga orchestration khi một giao dịch nghiệp vụ trải qua nhiều data store khác nhau.

Ở đây, saga là một chuỗi các local transaction ở từng service, trong đó nếu một bước thất bại thì hệ thống sẽ chạy các bước bù trừ để hoàn tác những gì đã làm trước đó. Nếu muốn đào sâu về cách thiết kế luồng điều phối này, bạn có thể đọc tiếp bài [saga pattern](/blog/saga-pattern-la-gi) trên blog nhé.

Bên cạnh cách dùng một process relay chạy câu lệnh `SELECT` để quét bảng outbox như trong code demo, tài liệu AWS còn nhắc tới biến thể dùng CDC, viết tắt của Change Data Capture. Kỹ thuật CDC sẽ đọc trực tiếp luồng thay đổi từ log của database để đẩy message đi, nhưng trong phạm vi bài này mình chỉ chạy bảng outbox trên PostgreSQL chứ không demo CDC.

## Sai lầm hay gặp khi làm outbox

Khi tự tay triển khai transactional outbox vào dự án, có một số điểm dễ gây nhầm lẫn mà anh em backend mới làm quen hay vấp phải. Lỗi đầu tiên là vô tình tách việc lưu đơn hàng và việc `INSERT` vào bảng outbox ra thành hai transaction riêng biệt trong code.

Nếu làm vậy, chúng ta thực chất lại quay về bài toán dual-write ban đầu, chỉ khác là ghi vào hai bảng thay vì ghi vào database và broker. Một sơ suất khác là viết xong phần ghi vào bảng outbox nhưng quên cấu hình cho process relay tự động chạy lại sau khi gặp sự cố crash.

Khi đó, các dòng event cứ nằm chờ mãi trong bảng outbox mà không có ai đẩy sang broker cho các service phía sau. Một lỗi khác là cho relay xóa hoặc đánh dấu đã gửi dòng outbox trước khi broker xác nhận đã nhận message thành công.

Nếu bước gửi lên broker ngay sau đó bị lỗi network, dòng outbox đã mang trạng thái đã gửi nên relay không gửi lại nữa và message bị mất. Ngoài ra, việc bỏ qua bước kiểm tra trùng lặp ở phía consumer cũng rất phổ biến vì nghĩ rằng có bảng outbox rồi thì mỗi đơn chỉ sinh ra đúng một message.

Như số liệu ở nhánh B đã chỉ ra, việc kỳ vọng outbox mang lại khả năng gửi đúng một lần là không khớp với cách hoạt động của relay khi có sự cố giữa chừng. Consumer không có cơ chế chống trùng theo `event_id` sẽ dễ dẫn đến cảnh kho đóng gói hai lần cho cùng một đơn hàng `ORD-2`.

Vì vậy, khi tự dựng và kiểm tra cơ chế outbox trên môi trường test, bạn nên chủ động giả lập các kịch bản restart ngắt quãng giống như bài chạy thử vừa rồi. Hãy đối chiếu kỹ bốn con số gồm tổng số đơn trong database, số dòng trong bảng outbox, tổng số message đến được broker, và số dòng mà consumer thực sự áp dụng để xem luồng xử lý đã khớp nhau hay chưa.

Mình chọn transactional outbox kết hợp consumer chống trùng khi cần đồng bộ việc ghi database và phát message tại một service để tránh mất sự kiện như đơn `ORD-2` ở nhánh dual-write, dù broker có thể nhận 4 message cho 3 đơn khi relay restart. Còn khi giao dịch nghiệp vụ cần cập nhật qua nhiều data store của nhiều service khác nhau thì mình kết hợp thêm saga theo gợi ý từ AWS Prescriptive Guidance thay vì chỉ dựa vào một bảng outbox đơn lẻ.

Nếu bạn muốn tìm hiểu thêm về cách hoạt động của transaction trong database cũng như cách phối hợp dữ liệu với các service bên ngoài, bạn có thể tham khảo khóa học bên dưới.

![Xử lý timeout, retry và crash - idempotency, outbox, lease và reconciliation](https://assets.200lab.io/sha256/67/67aa4f766e03fb56a4815d59537554fbcd2e7d582b432f8a936b8c0111acd369/generations/4135c1b2f597d8f855233c833c32afdd5deb862e01d37dbadff1bdc2edd80626)

- [Xử lý timeout, retry và crash - idempotency, outbox, lease và reconciliation](https://200lab.io/courses/xu-ly-timeout-retry-va-crash-idempotency-outbox-lease-va-reconciliation.md)

## Đọc thêm

- [Kiến trúc hướng sự kiện (event-driven)](/blog/kien-truc-huong-su-kien) để hiểu bức tranh tổng thể khi các service giao tiếp qua event.
- [Idempotent Consumer: chống xử lý trùng message](/blog/idempotent-consumer-la-gi) để nắm cách thiết kế consumer an toàn trước cơ chế gửi at-least-once của relay.
- [Saga pattern là gì](/blog/saga-pattern-la-gi) khi bạn cần điều phối chuỗi giao dịch trải qua nhiều service và nhiều database.
- [Transaction và isolation level](/blog/transaction-isolation-level-la-gi) để nắm vững cách database cô lập dữ liệu khi ghi đơn hàng cùng bảng outbox.

## Đọc thêm

- [Retry với backoff và jitter: gọi lại API lỗi mà không làm sập server](https://200lab.io/blog/retry-la-gi.md): Retry là gì: gọi lại khi lỗi tạm dễ thành thundering herd; exponential backoff chưa đủ, cần jitter để lệch nhịp và đo đỉnh request theo giây.
- [Distributed lock là gì, vì sao lock Redis vẫn để dữ liệu bị ghi đè](https://200lab.io/blog/distributed-lock-la-gi.md): Distributed lock giúp nhiều instance không chạy trùng một việc. Redis SET NX chặn được chạy cùng lúc, nhưng lock hết hạn giữa chừng thì cần thêm fencing token.
- [Rate limiting là gì? So sánh Fixed Window, Sliding Window, Token Bucket](https://200lab.io/blog/rate-limiting-la-gi.md): Rate limiting kiểm soát tần suất request và trả về mã HTTP 429 khi vượt ngưỡng. Xem so sánh 3 thuật toán cùng cách chọn key và đặt limiter.
- [CRDT là gì? Cách đồng bộ dữ liệu khi nhiều người cùng sửa](https://200lab.io/blog/crdt-la-gi.md): CRDT giúp đồng bộ dữ liệu khi nhiều người cùng chỉnh sửa lúc mất mạng. Các thay đổi được kết hợp ra sao, và xung đột được xử lý thế nào?
- [Composite index là gì? Thứ tự cột và EXPLAIN trên MySQL, PostgreSQL](https://200lab.io/blog/composite-index-la-gi.md): Composite index là gì, vì sao tạo index rồi mà query vẫn Seq Scan? Cùng thử trên PostgreSQL, MySQL để nắm quy tắc đặt cột bằng trước, cột khoảng sau.
- [Mọi bài viết chủ đề Backend](https://200lab.io/blog/tags/backend.md)

Toàn bộ nội dung: https://200lab.io/llms.txt
