0

Outbox pattern trong .NET: đơn đã tạo mà email không được gửi

Sáng thứ Hai, chăm sóc khách hàng báo: cuối tuần có mấy chục đơn khách đặt thành công, tiền đã trừ, nhưng không có email xác nhận và kho cũng không hề nhận được yêu cầu xuất hàng. Đơn nằm trong database đàng hoàng. Lần theo log thì thấy đúng khoảng thời gian deploy hôm thứ Bảy, message queue khởi động lại mất ba phút. Ba phút đó, mọi đơn được tạo ra đều "biến mất" khỏi mắt các service khác.

Bài này so sánh ba cách một API gửi sự kiện "đơn vừa được tạo" sang hệ thống khác, xem mỗi cách mất gì khi có sự cố, và vì sao cuối cùng mình chọn outbox.

Cách 1: lưu DB xong thì gửi thẳng lên queue

db.Orders.Add(order);
await db.SaveChangesAsync(ct);

// Lưu xong rồi mới gửi: queue lỗi đúng lúc này thì sự kiện mất luôn
await bus.PublishAsync(new OrderCreated(order.Id, order.CustomerId), ct);

Đây là code của vụ sáng thứ Hai. Nó ghi vào hai nơi (database và queue) mà không có gì đảm bảo cả hai cùng thành công. Người ta gọi là dual write.

  • DB lưu xong, queue lỗi: đơn có, sự kiện không. Đúng vụ trên.
  • Đảo thứ tự, gửi queue trước rồi mới lưu DB: queue có sự kiện "đơn 1024 đã tạo", rồi DB lỗi, đơn không tồn tại. Service email gửi xác nhận cho một đơn ma.

Bọc try/catch cũng không cứu được. Process có thể chết đúng giữa hai dòng: deploy, OOM, máy bị restart.

Cách 2: bắn rồi quên

Phiên bản "tối ưu" hay gặp là đẩy việc gửi ra khỏi request cho response nhanh hơn:

await db.SaveChangesAsync(ct);

// Không await: request trả về ngay, việc gửi chạy "đâu đó" phía sau
_ = Task.Run(() => _notifier.SendOrderCreatedAsync(order.Id));

Cách này còn tệ hơn cách 1:

  • App restart hay deploy lúc task đang chạy thì việc mất sạch, không dấu vết.
  • Exception trong task không ai bắt, không ai log.
  • _notifier mà dùng DbContext hay service scoped khác thì chúng đã bị dispose khi request kết thúc, và task ném ObjectDisposedException lúc có lúc không. Chuyện service sống ngắn hơn việc dùng nó mình đã viết ở bài DI lifetime.

Fire-and-forget chỉ chấp nhận được cho việc mất cũng chẳng sao, kiểu ghi một dòng thống kê.

Cách 3: outbox

Ý tưởng: không gửi lên queue trong request nữa. Thay vào đó ghi sự kiện vào một bảng OutboxMessages ngay trong cùng transaction với đơn hàng. Một worker chạy nền đọc bảng đó ra và gửi đi. Đơn và sự kiện hoặc cùng có, hoặc cùng không, vì cùng nằm trong một transaction của database.

public class OutboxMessage
{
    public long Id { get; set; }
    public string Type { get; set; } = "";
    public string Payload { get; set; } = "";
    public DateTime CreatedAt { get; set; }
    public DateTime? ProcessedAt { get; set; }
    public int Attempts { get; set; }
}

Lúc tạo đơn:

await using var tx = await db.Database.BeginTransactionAsync(ct);

db.Orders.Add(order);
await db.SaveChangesAsync(ct); // lưu trước để có order.Id do database sinh ra

db.OutboxMessages.Add(new OutboxMessage
{
    Type = "OrderCreated",
    Payload = JsonSerializer.Serialize(new { order.Id, order.CustomerId, order.Total }),
    CreatedAt = DateTime.UtcNow
});
await db.SaveChangesAsync(ct);

await tx.CommitAsync(ct); // đơn và sự kiện cùng vào DB, hoặc không cái nào vào

Nếu DbContext đang bật retry khi lỗi kết nối (EnableRetryOnFailure), EF Core không cho tự mở transaction như trên mà phải bọc trong db.Database.CreateExecutionStrategy().ExecuteAsync(...). Lần đầu gặp lỗi này ai cũng bối rối, nên nhắc trước.

Worker gửi đi:

public class OutboxPublisher(
    IServiceScopeFactory scopeFactory,
    IMessageBus bus, // lớp bọc quanh RabbitMQ, Azure Service Bus... mà bạn đang dùng
    ILogger<OutboxPublisher> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await using var scope = scopeFactory.CreateAsyncScope();
            var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();

            var batch = await db.OutboxMessages
                .Where(m => m.ProcessedAt == null)
                .OrderBy(m => m.Id)
                .Take(20)
                .ToListAsync(stoppingToken);

            foreach (var msg in batch)
            {
                try
                {
                    await bus.PublishAsync(msg.Type, msg.Payload, stoppingToken);
                    msg.ProcessedAt = DateTime.UtcNow;
                }
                catch (Exception ex) when (ex is not OperationCanceledException)
                {
                    msg.Attempts++;
                    logger.LogWarning(ex, "Gửi outbox message {Id} thất bại lần {Attempts}", msg.Id, msg.Attempts);
                    break; // dừng lô này để giữ thứ tự, vòng sau thử lại
                }
            }

            // Đã gửi rồi thì cố lưu dấu kể cả khi app đang tắt, đỡ gửi lại lần nữa
            await db.SaveChangesAsync(CancellationToken.None);

            if (batch.Count == 0)
                await Task.Delay(TimeSpan.FromSeconds(2), stoppingToken);
        }
    }
}

Queue chết ba phút như sáng thứ Hai? Message nằm yên trong bảng, queue sống lại thì worker gửi bù. Không mất đơn nào.

Đổi lại có hai điều phải chấp nhận. Một là trễ: sự kiện đi sau vài giây chứ không tức thì. Hai là có thể gửi trùng: worker gửi xong nhưng chết trước khi kịp lưu ProcessedAt, khởi động lại sẽ gửi message đó lần nữa. Outbox cho bạn "ít nhất một lần", không phải "đúng một lần", nên bên nhận phải xử lý trùng được: lưu id sự kiện đã xử lý, gặp lại thì bỏ qua. Chuyện xử lý trùng mình viết kỹ ở bài về concurrency và idempotency trong series.

Chạy nhiều instance thì nhiều worker cùng đọc một bảng. Trên SQL Server, cách hay dùng là lấy lô bằng WITH (UPDLOCK, READPAST, ROWLOCK) bên trong một transaction, để mỗi worker bỏ qua những dòng worker khác đang giữ.

Tắt app cho đàng hoàng

Worker nào cũng phải tôn trọng stoppingToken. Khi app nhận lệnh dừng (deploy, scale down, container nhận SIGTERM), host huỷ token này và chờ các BackgroundService kết thúc, mặc định tối đa 30 giây (HostOptions.ShutdownTimeout). Worker ở trên dừng vòng lặp ngay khi token bị huỷ, và nhờ outbox nên việc dở dang cũng không mất: message chưa đánh dấu sẽ được gửi ở lần chạy sau.

Nếu chạy trên Kubernetes, nhớ để thời gian chờ của pod (terminationGracePeriodSeconds) dài hơn thời gian app cần để tắt, không thì app bị giết trước khi kịp dọn dẹp.

Khi nào dùng thư viện thay vì tự viết

Outbox tự viết như trên đủ cho một hai loại sự kiện. Khi hệ thống có nhiều loại message, cần retry có backoff, cần dead-letter, mình cân nhắc các thư viện messaging có sẵn outbox tích hợp với EF Core, như MassTransit. Còn việc chạy theo lịch (gửi báo cáo 7 giờ sáng, dọn dữ liệu cũ mỗi đêm) thì Hangfire hoặc Quartz.NET làm tốt hơn một vòng while tự chế. Trước khi chọn, đọc kỹ giấy phép của phiên bản bạn định dùng.


Thử ngay: tìm trong solution những chỗ SaveChangesAsync xong là gọi ngay một service bên ngoài (queue, email, webhook), và những chỗ có _ = Task.Run(. Mỗi chỗ là một câu hỏi: nếu process chết đúng giữa hai dòng đó thì chuyện gì xảy ra?

Bài sau là caching và chuyện cache hết hạn một lượt kéo sập DB. Bạn đang gửi sự kiện giữa các service kiểu gì, đã từng mất message chưa? Comment cho mình biết với.

P.S. Outbox tự viết, outbox của thư viện, hay chưa cần gì cả: mỗi lựa chọn đều có cái giá riêng. Trước khi chốt, mình hay cho AI "vặn hỏi" lại kế hoạch bằng skill architecture-advisor trong PrimeKit, bộ skill mình tự làm. Skill hỏi lại từng câu một để làm rõ yêu cầu thật (mất bao nhiêu message thì chấp nhận được, trễ bao lâu thì được), rồi đưa lời khuyên thẳng: nên làm gì, nên tránh gì, có phương án nào đỡ tốn hơn không. Cài bằng npx @lovehlmmm/primekit init, rồi gõ /pk:architecture-advisor kèm mô tả bài toán. Skill chỉ tư vấn, không viết code hộ bạn, và quyết định cuối cùng vẫn là của bạn.


All rights reserved

Viblo
Hãy đăng ký một tài khoản Viblo để nhận được nhiều bài viết thú vị hơn.
Đăng kí