Introducción
El dual write problem aparece cada vez que una aplicación necesita hacer dos escrituras en sistemas distintos —normalmente una base de datos y un broker de mensajes— y tratar esas dos operaciones como si fueran una sola. Si guardo el pedido en la base de datos y, a continuación, publico un evento en Azure Service Bus como una llamada separada, he creado una ventana de inconsistencia. Si la aplicación falla o la red se cae entre esas dos operaciones, el sistema termina en un estado que nadie planificó: el dato existe pero el evento nunca salió, o el evento se publicó pero el commit en la base de datos nunca ocurrió.
Este problema no es teórico. Ya he visto colas de eventos que anunciaban pedidos que en realidad no existían en la base de datos, porque la transacción local falló después de la publicación. Y he visto lo contrario: pedidos creados sin ningún evento de auditoría o notificación, porque la aplicación se cayó a mitad de camino antes de poder publicar. Este artículo es la segunda parte de la serie sobre arquitectura de eventos sin caos con C#, y aquí me centro específicamente en el Transactional Outbox Pattern: qué resuelve, cómo implementarlo en C# con PostgreSQL y cómo se aplica a un caso real de auditoría transaccional que publica en Azure Service Bus.
Requisitos previos
Para seguir los ejemplos, es útil tener conocimientos básicos de transacciones ACID en una base de datos relacional, Entity Framework Core o Npgsql, y cierta familiaridad con colas o tópicos de mensajería (Azure Service Bus, RabbitMQ o Kafka siguen el mismo razonamiento). El ejemplo de código completo forma parte del mismo laboratorio de eventos usado en el primer artículo de la serie, disponible en BlogSamples/Messaging/EventDriven/.
El problema de la doble escritura (dual write problem)
Cada vez que una operación de negocio necesita persistir un estado local y notificar ese estado a otro sistema, existen dos escrituras físicamente separadas: un COMMIT en la base de datos y una llamada de red al broker. Las bases de datos relacionales garantizan atomicidad dentro de sus propias transacciones, pero esa garantía no se extiende a un sistema externo. No existe una transacción distribuida real entre PostgreSQL y Azure Service Bus sin un protocolo como two-phase commit, que en la práctica casi ninguna mensajería moderna admite y que introduce una latencia y un acoplamiento que la mayoría de los equipos no quiere pagar.
El resultado es que cualquier combinación de «guardar y luego publicar» o «publicar y luego guardar» tiene una ventana en la que una de las dos operaciones puede fallar por sí sola:
- Si guardo en la base de datos y la aplicación se cae antes de publicar, el evento nunca existió y ningún consumidor será notificado.
- Si publico primero y el commit en la base de datos falla después, el consumidor recibe un evento sobre un dato que nunca se persistió.
⚠️ Atención: un reintento ingenuo no resuelve por sí solo el dual write problem. Si simplemente vuelvo a intentarlo tras un fallo, corro el riesgo de publicar el mismo evento dos veces o de no reconciliar nunca el estado cuando el fallo es definitivo (aplicación reiniciada, proceso muerto, despliegue en medio del flujo).
Por qué las transacciones de base de datos no lo resuelven solas
El intento de corrección más común es envolver las dos operaciones en una transacción y esperar que todo funcione. Eso no funciona porque la transacción de la base de datos solo controla los recursos que la propia base de datos gestiona. Una llamada HTTP o AMQP a Azure Service Bus no participa en el protocolo de commit de PostgreSQL ni de SQL Server. Si hago un INSERT en la base de datos, llamo al SDK de Service Bus dentro del mismo bloque try y después hago COMMIT, todavía existen escenarios de fallo:
- El
COMMITlocal puede tener éxito, pero la confirmación del broker nunca llega por un timeout de red: la aplicación no sabe si el mensaje se entregó o no. - El broker puede confirmar la entrega, pero el
COMMITposterior en la base de datos falla por un deadlock o una violación de constraint: el evento ya se publicó, pero el dato nunca quedó consistente.
Ese es exactamente el motivo por el que necesito convertir las dos operaciones en una única transacción local y tratar la publicación real como una etapa asíncrona y desacoplada.
La solución: Transactional Outbox Pattern
El Transactional Outbox Pattern resuelve el dual write problem eliminando la necesidad de una transacción distribuida. En lugar de publicar directamente en el broker, la aplicación graba el dato de negocio y el evento pretendido en una tabla de «bandeja de salida» (outbox) dentro de la misma transacción atómica de la base de datos. Como las dos escrituras ocurren en la misma base de datos y en la misma transacción local, son atómicas por definición: o se persisten las dos, o ninguna.
| |
📂 Código Fuente: El ejemplo completo de Outbox, Inbox y Saga está disponible en el repositorio de ejemplos del blog:
BlogSamples/Messaging/EventDriven/
Si CommitAsync tiene éxito, tengo la garantía de que el pedido y la intención de publicar el evento existen juntos en la base de datos. Si falla, ninguno de los dos se persistió. Ya no existe el escenario en el que uno se guardó y el otro no.
Consumo de los eventos: el publisher asíncrono
Guardar el evento en la tabla outbox resuelve la atomicidad, pero todavía falta el paso que efectivamente entrega el mensaje al broker. Esa responsabilidad recae en un proceso separado —generalmente un worker o BackgroundService— que lee los registros pendientes de la outbox y los publica en Azure Service Bus de forma asíncrona, marcando cada mensaje como publicado solo después de la confirmación del broker.
| |
⚠️ Observación: este bloque está simplificado para centrarse en la idea del flujo. En producción, la selección de los mensajes pendientes debe usar un mecanismo de lock/lease en la base de datos —por ejemplo
FOR UPDATE SKIP LOCKEDen PostgreSQL o un equivalente— para garantizar que varias instancias del worker no publiquen el mismo lote.
Este diseño crea una ventana de latencia entre el COMMIT local y la publicación real —normalmente de milisegundos a pocos segundos—, pero nunca pierde la garantía de atomicidad entre dato y evento. Si el worker se cae después de SendMessageAsync y antes de SaveChangesAsync, el mensaje puede publicarse de nuevo en la siguiente ejecución. Eso es lo esperado y se resuelve del lado del consumidor, no del publisher.

Caso real: auditoría transaccional en un sistema de gestión de inventario
Un ejemplo concreto de este patrón en producción es la outbox de auditoría de un sistema de gestión de inventario, que publica eventos en Azure Service Bus con semántica at-least-once. El publisher reclama los mensajes disponibles mediante un lease SQL —un mecanismo equivalente al SKIP LOCKED del ejemplo anterior, pero implementado como un lock optimista con timeout de lease—, envía el sobre versionado al tópico configurado y solo marca el mensaje como Published después de la confirmación del broker.
Este flujo refuerza un punto central del Transactional Outbox Pattern: la responsabilidad del publisher termina en la confirmación de entrega. Nunca asume que un mensaje enviado una vez llegará con garantía exactamente una vez al otro lado. Por eso, las obligaciones relevantes se trasladan al consumidor.
⚠️ Atención: el Transactional Outbox resuelve la inconsistencia entre la transacción local y la publicación de la intención del evento, pero no crea una transacción distribuida entre la base de datos de la aplicación y cualquier sistema externo que el consumidor toque después. Cuando el consumidor llama a otra API, graba en otra base de datos o envía un correo, la consistencia real pasa a ser un problema de idempotencia, reintento y compensación, no de atomicidad global.
Obligaciones del consumidor: idempotencia y orden
Como la entrega es at-least-once, todo consumidor de una outbox transaccional necesita tratar la duplicidad como una parte normal del flujo, no como una excepción:
- Idempotencia por
MessageId. El consumidor debe mantener una Inbox o una constraint equivalente por(consumer, messageId)antes de aplicar cualquier efecto secundario. Si el mismo mensaje llega dos veces, el segundo procesamiento debe reconocerse y descartarse sin repetir la acción de negocio. - PeekLock sin auto-complete. Procesar en modo
PeekLockconAutoCompleteMessagesdeshabilitado es obligatorio. El mensaje solo debe completarse después de que la persistencia local o el efecto externo estén confirmados, nunca antes. - Los duplicados son esperados, no un bug. Si la API publica en Service Bus y falla antes de marcar el mensaje como
Published, el mismo mensaje puede reenviarse con el mismoMessageId. El consumidor debe estar preparado para ello desde el diseño inicial. SessionIdpara ordenar por agregado. Cuando la subscription exige procesamiento secuencial, usarSessionIdcomo clave de orden por agregado —con el formatoDomain:EntityType:EntityId— garantiza que los eventos del mismo pedido, por ejemplo, se procesen en el orden correcto sin bloquear otros agregados.- DLQ solo tras agotar los intentos. Enviar a la Dead Letter Queue solo después de agotar los intentos del consumidor, registrando el error de forma sanitizada, sin payload sensible en el log.
- Reintentos desacoplados entre outbox y consumidor. La outbox controla la publicación; el consumidor controla su propio procesamiento. Mezclar esas dos políticas de reintento crea un acoplamiento innecesario y dificulta diagnosticar qué lado está fallando.
| |
ℹ️ Información: el par Outbox (productor) + Inbox (consumidor) reduce el problema a un modelo tratable: la outbox preserva la intención del evento y la inbox evita que el mismo efecto secundario se aplique más de una vez.
Cómo saber si necesitas el Outbox Pattern
El Transactional Outbox Pattern resuelve un problema específico: la consistencia entre una escritura local y una notificación externa. No es necesario en todas partes.
| Situación | Recomendación |
|---|---|
| Operación única, síncrona, sin sistema externo dependiente | mantener una transacción simple de base de datos |
| Persistir un dato y notificar a otro servicio/dominio de forma confiable | usar Transactional Outbox |
| Solo rendimiento de escritura, sin preocupación por consistencia distribuida | no es el problema que resuelve el Outbox |
| Auditoría, replicación de eventos o integración asíncrona entre sistemas | Outbox es la base recomendada |
Consejos y Buenas Prácticas
- Graba el dato de negocio y el registro de la outbox siempre en la misma transacción local, nunca en llamadas separadas, aunque parezcan cercanas en el tiempo.
- Marca el mensaje como publicado solo después de la confirmación del broker, nunca antes ni de forma optimista.
- Usa un
MessageIdestable (generalmente el ID del propio registro de la outbox) para permitir la deduplicación en el consumidor. - Trata la duplicidad de mensajes como un comportamiento esperado del sistema, no como un bug que eliminar.
- Separa la política de reintento del publisher de la política de reintento del consumidor; cada uno tiene fallos y responsabilidades distintos.
- Usa
SKIP LOCKEDo un lease optimista en el publisher para permitir varias instancias del worker sin duplicar trabajo. - Nunca pongas payload sensible en logs de error ni de DLQ; sanitízalo antes de registrarlo.
Resumen Objetivo
- Dual write problem — ocurre cuando una aplicación graba en una base de datos y publica en un broker como dos operaciones separadas, sin garantía de atomicidad entre ellas.
- Transactional Outbox Pattern — graba el dato de negocio y el evento pretendido en la misma transacción local, eliminando la inconsistencia entre las dos escrituras.
- Semántica at-least-once — el publisher garantiza que el mensaje no se pierde, pero puede entregarse más de una vez al consumidor.
- MessageId — clave que usa el consumidor para la deduplicación mediante el patrón Inbox, con una constraint por
(consumer, messageId). - PeekLock sin auto-complete — modo de procesamiento que solo confirma el mensaje después de que el efecto secundario se haya persistido.
- SessionId — clave de orden por agregado (
Domain:EntityType:EntityId) usada cuando la subscription exige procesamiento secuencial. - Azure Service Bus — broker usado en el caso real del sistema de gestión de inventario para publicar eventos de auditoría a partir de la outbox transaccional.
Lee También
- Arquitectura de eventos sin caos con C#: guía práctica
- Worker y BackgroundService: alto volumen
- Cuello de Botella en Bases de Datos: Mensajería y Paginación
- Arquitectura de Software: GoF, Patrones y Microservicios
Referencias
- Transactional Outbox Pattern — microservices.io — descripción canónica del patrón y del problema de dual write.
- Azure Service Bus messaging documentation — documentación oficial de tópicos, subscriptions y sesiones.
- Azure Service Bus PeekLock y AutoComplete — comportamiento de los locks y de la confirmación de mensajes.
- PostgreSQL SKIP LOCKED — locking optimista para publishers concurrentes.
- Entity Framework Core Transactions — documentación oficial de transacciones en EF Core.

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.