Fundamentos para uma prática sólida de EDA

Eventos devem representar mudanças de estado relevantes no domínio, não meras ações a serem executadas. A abordagem orientada a eventos desacopla produtores e consumidores, facilitando escalabilidade e resiliência em ambientes distribuídos. Princípios-chave que guiam minha prática:

• Contratos de eventos bem definidos: cada evento tem tipo, timestamp, versão e payload claro.
• Idempotência por design: consumidores devem processar eventos de forma segura mesmo que ocorram duplicatas.
• Guarda de evolução de esquema: suporte a versionamento e compatibilidade retro/adiantada.
• Entrega e observabilidade: entender o ritmo de eventos, atrasos e falhas de processamento.

Como regra prática, prefiro começar com uma definição simples de domínio: eventos de domínio (Domain Events) para mudanças significativas, e eventos de integração (Integration Events) para comunicações entre serviços, mantendo a semântica clara entre eles.

Padrões de comunicação de eventos

A escolha entre pub/sub, filas ou streaming impacta a latência, a consistência e o grau de acoplamento. Em prática, eu aplico:

• Pub/Sub com tópicos para fan-out: múltiplos consumidores podem reagir a um único evento.
• Fan-in para agregação de eventos correlacionados antes de avançar com ações subsequentes.
• Streaming de eventos para reprojetar o tempo de processamento e oferecer replay de histórico.
• Contratos de eventos e versionamento: manter compatibilidade, com a possibilidade de evoluir o payload sem quebrar consumidores existentes.

Normalmente uso brokers que suportam tópicos e retenção de mensagens, como opções de streaming para eventos de alto volume e durabilidade garantida, mantendo a responsabilidade de entrega entre produtores e consumidores distribuída de maneira eficiente.

Observabilidade e resiliência no pipeline de eventos

Sem visibilidade, até o melhor design falha na prática. Em minha stack, foco em:

• Tracing distribuído e correlação de eventos com IDs de rastreamento para seguir o fluxo entre produtores e consumidores.
• Logs estruturados e métricas: taxa de eventos processados, latência, erros e retries.
• Dead-letter queues (DLQ) para falhas persistentes, evitando perda de eventos e facilitando retrabalho controlado.
• Retries com backoff exponencial e limites de tentativas para evitar sobrecarga de sistemas downstream.
• Idempotência em consumidores e replay seguro de eventos para recuperação após falhas.

Nunca subestimo a importância de um observability plane bem definido antes de ir para produção. Ele guía decisões de engenharia, saneamento de falhas e planejamento de capacidade.

Práticas de implementação e governança

• Versionamento de esquemas de eventos: manter compatibilidade para consumidores antigos e permitir evolução controlada.
• Contrato de eventos e testes: contratos entre produtores e consumidores com testes de integração/consumidor.
• Schema registry simples: validar payloads na fronteira entre serviços para evitar eventos malformados.
• Estratégias de idempotência: uso de keys de idempotência para evitar duplicação na publicação ou no processamento.
• Testes end-to-end com cenários de falha: simular atrasos, duplicação e DLQ para validar resiliência.
• Governança de mudanças: planos de rollout com canários para assegurar que mudanças em eventos não quebrem consumidores.

Quando bem aplicado, esse conjunto reduz ruídos operacionais, aumenta a confiabilidade e facilita a evolução da arquitetura ao longo de ciclos de produto.

Exemplo mínimo de EventBus em TypeScript

// Representa um domínio de evento simples
interface DomainEvent { type: string; payload: any; }
type Handler = (evt: DomainEvent) => void;

class EventBus {
  private handlers: { [type: string]: Handler[] } = {};

  subscribe(type: string, h: Handler) {
    if (!this.handlers[type]) this.handlers[type] = [];
    this.handlers[type].push(h);
  }

  publish(evt: DomainEvent) {
    const hs = this.handlers[evt.type] || [];
    for (const h of hs) {
      try { h(evt); } catch (err) { /* log de falha no consumidor */ }
    }
  }
}

// Exemplo de uso
const bus = new EventBus();
bus.subscribe('order.created', (e) => console.log('order.created ->', e.payload));
bus.publish({ type: 'order.created', payload: { id: 123, amount: 49.9 } });