Microservicios Event-Driven
Implementa microservicios dirigidos por eventos con ejemplos funcionales de event sourcing, outbox transaccional y orquestación de sagas, además de selección de broker y guía de producción.
Visión General
Los microservicios event-driven se comunican a través de eventos en lugar de llamadas directas a una API. Un servicio publica lo que ocurrió; los consumidores interesados reaccionan a su propio ritmo, sin que el productor los conozca ni los espere. Ese desacoplamiento permite escalar de forma independiente y gana resiliencia — a costa de nuevos modos de fallo: publicar un evento que nunca llega, procesar el mismo evento dos veces, o dejar una transacción de negocio de varios pasos a medias.
Esta receta implementa los tres patrones que resuelven esos fallos: event sourcing para el modelo de escritura, el outbox transaccional para commits atómicos de “estado + evento”, y la orquestación de sagas para transacciones que cruzan servicios. El resto de la página cubre la selección de broker y las prácticas operativas que deciden si el sistema aguanta en producción.
Cuándo Usar
Usa este recurso cuando:
- Los servicios necesitan escalar de forma independiente sin acoplamiento síncrono. Funciones Dirigidas por Eventos cubre la versión serverless de este patrón.
- Un proceso de negocio abarca varios servicios y debe revertir limpiamente ante un fallo. El ejemplo de saga de abajo es la versión autoalojada; Orquestación Serverless muestra la alternativa gestionada.
- Necesitas commits atómicos de estado más evento. La sección de outbox implementa el mecanismo base; Outbox Transaccional profundiza en las estrategias de relay.
- Construyes pipelines de notificaciones, auditoría o analytics de alto throughput. Streaming de Eventos con Kafka es la receta dedicada a la mecánica del broker.
Solución
Event Sourcing (Python)
Event sourcing almacena el historial, no el estado actual. El agregado se reconstruye reproduciendo sus eventos, así que cada cambio queda auditado y el estado puede reconstruirse en cualquier punto del tiempo.
from dataclasses import dataclass
from typing import List
@dataclass
class Event:
aggregate_id: str
event_type: str
payload: dict
version: int
class OrderAggregate:
def __init__(self, order_id: str):
self.order_id = order_id
self.events: List[Event] = []
self.status = "pending"
def apply(self, event: Event):
if event.event_type == "order_placed":
self.status = "placed"
elif event.event_type == "payment_received":
self.status = "paid"
self.events.append(event)
def place_order(self, items: List[dict]):
event = Event(
aggregate_id=self.order_id,
event_type="order_placed",
payload={"items": items},
version=len(self.events) + 1
)
self.apply(event)
return event
Implementar Event Sourcing con CQRS en Python extiende esto a un event store persistente con proyecciones y snapshots.
Outbox Pattern (Node.js + Kafka)
No puedes commitear en la base de datos y publicar en el broker de forma atómica en un solo paso — una de las dos operaciones puede fallar y dejar el sistema inconsistente. El outbox lo resuelve: el evento se escribe en una tabla outbox dentro de la misma transacción, y un relay publica las entradas pendientes de forma asíncrona.
// Dentro de la misma transacción de base de datos:
await db.transaction(async (trx) => {
// 1. Actualizar datos de negocio
await trx('orders').insert({ id: orderId, status: 'placed' });
// 2. Escribir en tabla outbox (misma transacción)
await trx('outbox').insert({
topic: 'orders.events',
key: orderId,
payload: JSON.stringify({ event: 'order_placed', orderId, items })
});
});
// Proceso relay separado hace polling de outbox y publica a Kafka
const pending = await db('outbox').where('sent', false).limit(100);
for (const msg of pending) {
await kafka.producer.send({
topic: msg.topic,
messages: [{ key: msg.key, value: msg.payload }]
});
await db('outbox').where('id', msg.id).update({ sent: true });
}
Orquestación de Sagas (TypeScript)
Una saga divide una transacción distribuida en pasos locales, cada uno con una acción de compensación. Si un paso falla, el orquestador ejecuta las compensaciones de los pasos completados en orden inverso — el equivalente distribuido de un rollback.
interface SagaStep {
name: string;
execute: () => Promise<void>;
compensate: () => Promise<void>;
}
class OrderSaga {
private steps: SagaStep[] = [
{
name: 'reserve_inventory',
execute: () => inventoryService.reserve(order.items),
compensate: () => inventoryService.release(order.items)
},
{
name: 'process_payment',
execute: () => paymentService.charge(order.total),
compensate: () => paymentService.refund(order.total)
},
{
name: 'ship_order',
execute: () => shippingService.createLabel(order),
compensate: () => shippingService.cancelLabel(order)
}
];
async execute() {
const completed: SagaStep[] = [];
try {
for (const step of this.steps) {
await step.execute();
completed.push(step);
}
} catch (err) {
// Rollback de pasos completados en orden inverso
for (const step of completed.reverse()) {
await step.compensate();
}
throw new Error(`Saga falló en paso ${completed[0]?.name}`);
}
}
}
Explicación
Patrones principales:
| Patrón | Problema Resuelto | Compromiso |
|---|---|---|
| Event Sourcing | Audit trail; queries temporales | Complejo; requiere CQRS para lecturas |
| CQRS | Optimiza modelos de lectura/escritura por separado | Consistencia eventual; más código |
| Saga | Transacciones distribuidas sin locks | Rollback complejo; consistencia eventual |
| Outbox | Atómico “actualización de BD + publicación” | Requiere proceso relay |
| Idempotent Consumer | Manejar mensajes duplicados | Requiere claves únicas por mensaje |
Garantías de orden de mensajes:
- Kafka: orden solo dentro de una partición — usa el ID del agregado como clave de partición (el ID del pedido, no una clave aleatoria) para que los eventos relacionados caigan en la misma partición.
- RabbitMQ: orden por cola, pero solo con un único consumidor activo; consumidores en competencia procesan mensajes en paralelo y pueden reordenarlos.
- SQS: las colas estándar pueden reordenar; usa colas FIFO con un message group ID cuando el orden importa.
Variantes
| Broker | Orden | Entrega | Ideal Para |
|---|---|---|---|
| Kafka | Por partición | At-least-once | Alto throughput; replay |
| RabbitMQ | Por cola | At-least-once | Routing complejo; colas prioritarias |
| NATS | Por subject | At-most-once | Baja latencia; simplicidad |
| Pulsar | Global | Exactly-once | Geo-replicación; almacenamiento por capas |
Lo que funciona
- Diseña eventos como hechos, no comandos: “OrderPlaced” no “PlaceOrder”
- Incluye versiones de esquema: los eventos V1 deben ser legibles por consumidores V2
- Maneja duplicados con elegancia: haz los consumidores idempotentes (upsert, no insert)
- Monitorea las dead letter queues: los mensajes fallidos necesitan investigación, no descarte silencioso
- Mantén los payloads pequeños: referencia los datos grandes; no embebas blobs
Errores Comunes
- Espagueti event-driven: 50 microservicios suscritos al mismo evento crean un acoplamiento invisible
- Idempotencia ausente: procesar el mismo evento de pago dos veces cobra al cliente dos veces
- Cadenas síncronas de eventos: llamar APIs HTTP dentro de event handlers anula el propósito
- Sin manejo de dead letter: los mensajes fallidos desaparecen; pierdes eventos de negocio
- Suposiciones de orden incorrectas: asumir orden global cuando solo existe orden por partición
Manejo de Errores y Recuperación
- Elige la semántica de entrega a propósito. At-most-once pierde mensajes; at-least-once los duplica y exige consumidores idempotentes; exactly-once requiere productores y consumidores transaccionales y es lo más caro. Diseña para at-least-once salvo que tengas una razón concreta para no hacerlo.
- Reintentos acotados y luego dead-letter. Reintenta los fallos transitorios con backoff y un máximo de intentos, y después enruta el mensaje a una DLQ. Las alternativas son peores: bloquear la partición para siempre o descartar un evento de negocio en silencio.
- Alerta sobre la DLQ, no solo llénala. Una dead-letter queue que nadie vigila es pérdida de datos con pasos extra. Mide su profundidad y conéctala a las alertas de guardia.
- Pon timeouts a cada paso de la saga. Una saga que espera eternamente un paso muerto nunca compensa. Dale a cada paso una fecha límite y dispara la compensación al vencer, no solo ante un fallo explícito.
- Reproduce desde la última posición commiteada. Los consumidores que se recuperan de una caída retoman desde el último offset confirmado — por eso el offset se confirma solo tras procesar con éxito, nunca antes.
Rendimiento y Escalabilidad
- Particiona por clave de agregado. Los eventos del mismo agregado (ID de pedido, ID de cliente) comparten clave de partición, así el orden se mantiene por agregado mientras los consumidores escalan. Una clave caliente concentra la carga en una sola partición — vigila la distribución de claves.
- Escala consumidores por lag, no por CPU. El lag del consumidor es la señal real de backpressure: escala cuando crece, alerta cuando supera tu presupuesto de tiempo de procesamiento. El escalado por CPU reacciona cuando la cola ya está llena.
- Agrupa en lotes cuando puedas. El batching del productor cambia un poco de latencia por mucho throughput — ajusta
linger.msybatch.sizeen Kafka en lugar de enviar un registro por request. - Elige un formato de serialización una vez. JSON es depurable pero verboso; Avro y Protobuf necesitan un schema registry pero dan payloads compactos y compatibilidad forzada. El registry se paga solo a partir de un puñado de servicios.
Consideraciones de Seguridad
- Cifra en tránsito y autoriza con ACLs. TLS en todas partes, mTLS o SASL para autenticar productores y consumidores, ACLs por topic en lugar de credenciales de broker completo, y nada de acceso anónimo en producción.
- Trata los payloads como datos en riesgo. Los eventos con PII llevan cifrado a nivel de aplicación; los eventos que cruzan fronteras de confianza se firman (HMAC sobre cuerpo más headers) para que los consumidores rechacen mensajes alterados o reproducidos.
- Audita el plano de control. Las acciones administrativas del broker — crear topics, cambiar ACLs, reiniciar consumer groups — van a un log que sobreviva al broker. Quién tocó la fontanería importa más que cualquier mensaje individual.
Monitoreo y Observabilidad
- El lag del consumidor es la señal principal. Mide el lag por partición y alerta cuando el evento sin procesar más antiguo supera tu presupuesto de procesamiento — cinco minutos es un default razonable. Un pico de lag justo después de un despliegue suele significar que la nueva versión del consumidor es más lenta o está bloqueada.
- La profundidad de cola no es salud. Una cola puede estar llena y sana (un consumidor poniéndose al día tras una caída) o vacía y rota (un productor que dejó de publicar). Combina profundidad con tasa de consumo antes de sacar conclusiones.
- Propaga correlation IDs por los eventos. Pon un
correlation_iden los headers de cada evento al publicar y cópialo en los logs del consumidor — es la única forma de seguir un request a través del broker. - Vigila la profundidad de la DLQ y la tasa de error por consumidor. Ambas son indicadores tempranos de schema drift o de un mal despliegue, y cuestan menos que un incidente aguas abajo.
Despliegue y CI/CD
- Despliega consumidores antes que productores al cambiar el esquema. Los consumidores que entienden ambas versiones deben estar activos antes de que los productores empiecen a emitir el formato nuevo — si no, los consumidores viejos se rompen con campos desconocidos.
- Rota consumidores con drenado. Termina el mensaje en vuelo, confirma el offset y después sal. Matar un consumidor a mitad de lote es como se genera una ola de re-entregas en cada despliegue.
- Versiona los esquemas en el registry. Deja que el registry imponga las reglas de compatibilidad (backward cuando los consumidores despliegan primero) en lugar de coordinar versiones a mano.
Optimización de Costos
- Ajusta la retención primero. El costo de almacenamiento del broker lo marca la retención — fija TTLs por topic según tus necesidades reales de replay en lugar del default de “guardar todo”.
- Comprime los payloads. gzip o lz4 reduce el tamaño de mensajes JSON entre un 60 y un 80 %; en topics de alto volumen es la optimización más barata disponible.
- Escala a cero los consumidores no críticos fuera de horario. Los consumidores de reporting y analytics que toleran latencia no necesitan réplicas a las 3 AM.
Testing
- Test de contrato sobre el esquema, no sobre el broker. Las comprobaciones de compatibilidad del schema registry y los contract tests de consumidores detectan cambios que rompen eventos en CI, antes de que lo haga un despliegue.
- Tests de integración contra un broker real. Testcontainers con Kafka o RabbitMQ supera a cualquier mock para lo que involucre orden, offsets o rebalancing — los mocks no reproducen el comportamiento de los consumer groups.
- Tests de replay para agregados event-sourced. Captura un flujo de eventos de producción saneado, reprodúcelo en CI y verifica el estado reconstruido. Es exactamente el camino del que depende tu recuperación ante desastres.
Patrones Avanzados
- Competing consumers: varias instancias leen de la misma cola y cada mensaje lo procesa exactamente una de ellas — el patrón base de escalado horizontal para work queues.
- Request-reply sobre el broker: el solicitante envía un mensaje con una dirección
reply-toy un correlation ID; el respondedor publica la respuesta ahí. Pon siempre un timeout de respuesta — un respondedor silencioso es indistinguible de un request perdido. - Routing por topic: los topic exchanges de RabbitMQ enrutan por patrón —
orders.*.createdcoincide conorders.us.created,orders.#coincide con todo lo que cuelga deorders. Útil para repartir flujos de eventos regionales o por tipo. - Colas prioritarias: el
x-max-priorityde RabbitMQ deja que los mensajes urgentes se cuelen (limítalo alrededor de 10 — valores altos cuestan memoria). Kafka no tiene equivalente: prioriza con topics separados y consumidores dedicados.
Solución de Problemas
- Los mensajes se acumulan en una cola: comprueba primero que los consumidores estén conectados y sanos; después revisa el prefetch o el fetch — un prefetch sobredimensionado puede matar de hambre al resto de consumidores del grupo.
- Duplicados justo después de un despliegue: casi siempre es un problema de confirmación de offsets — consumidores matados antes de confirmar reprocesan el lote en vuelo. Haz los handlers idempotentes y confirma solo tras procesar.
- Un consumidor hace todo el trabajo: menos particiones que consumidores, o una clave caliente concentrando mensajes. Revisa la asignación de particiones y la distribución de claves antes de añadir réplicas.
- Los mensajes caen en la DLQ al instante: eso es schema mismatch o un bug del handler, no un fallo transitorio. Inspecciona el payload de la DLQ antes de asumir problemas del broker.
Véase También
- Implementar Event Sourcing con CQRS en Python — event store persistente, proyecciones y snapshots.
- Outbox Transaccional — estrategias de relay y garantías de entrega.
- Guía Completa de Sistemas Event-Driven — el análisis arquitectónico en profundidad detrás de estos patrones.
Preguntas frecuentes
¿Cuándo debo usar event sourcing en lugar del CRUD tradicional?
Event sourcing compensa cuando el historial tiene valor por sí mismo — requisitos de auditoría, queries temporales, reproducción de estado para depurar o reconstruir proyecciones. Para dominios CRUD simples añade un event store y maquinaria de replay que no necesitas.
¿Cómo manejo la evolución de esquema en los eventos?
Añade campos, nunca elimines. Usa un schema registry (Confluent, AWS Glue) con compatibilidad hacia atrás para que los consumidores nuevos lean eventos viejos, y mantén dos versiones legibles durante los despliegues.
¿Cuál es la diferencia entre sagas de coreografía y de orquestación?
Coreografía: cada servicio reacciona a eventos y emite los suyos — sin cerebro central, más desacoplado, más difícil de depurar. Orquestación: un coordinador llama a cada paso — más fácil de seguir y de probar, pero el coordinador pasa a ser otro componente que mantener vivo.
¿Cómo me aseguro de que un consumidor no procese el mismo evento dos veces?
Asume que lo hará — la entrega at-least-once convierte los duplicados en una certeza, así que haz el procesamiento idempotente. Guarda el ID del evento o una clave de deduplicación natural en la misma transacción que el cambio de estado y rechaza repeticiones; usar upsert en lugar de insert resuelve la mayor parte.
¿Con qué broker debería empezar?
Kafka si necesitas alto throughput, replay o muchos consumer groups independientes. RabbitMQ cuando la flexibilidad de routing pese más que el volumen bruto. Una cola gestionada (SQS, Pub/Sub) si prefieres no operar un broker — cambias funcionalidad por cero operaciones.
Recursos Relacionados
Event Streaming con Apache Kafka y Node.js
Construye sistemas event-driven escalables usando Apache Kafka con producers, consumers, consumer groups y semantica exactly-once para messaging asincrono confiable
RecipeTask Queues y RPC con RabbitMQ y AMQP
Distribuí tareas en segundo plano e implementá patrones request-reply con RabbitMQ usando durable queues, dead-letter exchanges y prefetch.
RecipeColas de mensajes fallidos (DLQ) en SQS, RabbitMQ y Kafka
Configura dead letter queues en SQS, RabbitMQ y Kafka: políticas de reenvío, límites de reintentos, mensajes tóxicos y replay seguro.
RecipeIdempotencia en Procesamiento de Mensajes
Hacé que el procesamiento de mensajes sea idempotente para que entregas duplicadas no generen side effects en sistemas event-driven.
GuideGuía Completa de Sistemas Event-Driven
Diseña backends event-driven: event sourcing, CQRS, sagas, outbox pattern, idempotency, eventual consistency y patrones de producción.
GuideArquitectura de Microservicios — Cuándo Usarla y Cuándo No
Guía práctica de microservicios: beneficios, trade-offs, patrones comunes y cuándo elegirlos sobre monolitos. Cubre estrategias de descomposición y complejidad operativa.