Pular para o conteúdo

Event-driven interno: desacoplamento por eventos locais em monólitos modulados

Este texto aprofunda um ponto do post sobre migração gradual de monólitos para microsserviços via event-driven architecture, detalhando como adotar eventos locais dentro do próprio monólito pode ajudar no desacoplamento entre módulos, simplificando evolução e testes.

5 min de leitura
Event-driven interno: desacoplamento por eventos locais em monólitos modulados

Event-driven interno em monólitos modulados: por que e como usar

No post Estratégias para migração gradual de monólitos para microsserviços usando Event-Driven Architecture citei a abordagem de aplicar event-driven internamente no monólito para desacoplar módulos por eventos de domínio disparados dentro da aplicação, mas sem detalhar. Aqui aprofundo esse ponto para quem quer melhorar a estrutura e facilidades do monólito sem dividir em microsserviços.

Event-driven interno significa que dentro do próprio monólito modular — por exemplo, com bounded contexts bem definidos no domínio — os módulos comunicam suas mudanças ou ações via eventos locais. Esses eventos não saem da aplicação por nenhum barramento externo nem broker; eles são instanciados e consumidos na mesma execução, mantendo a aplicação coesa porém com módulos menos acoplados.

Por que usar eventos locais no monólito?

Na minha experiência, em projetos que aplicam DDD com módulos independentes (bounded contexts), eventos locais habilitam um "contrato implícito" de comunicação que reduz dependências diretas entre módulos. Em vez de um serviço de domínio chamar métodos de outro módulo diretamente, ele dispara um evento indicando que algo aconteceu — e quem estiver interessado reage.

Esse padrão ajuda a:

  • Evitar chamadas diretas que criam dependências duras entre módulos na mesma execução.
  • Manter a fronteira entre domínios mais respeitada, usando eventos como tradução da intenção do negócio.
  • Facilitar testes unitários e de integração ao desacoplar ações e efeitos.
  • Preparar o terreno para um futuro desacoplamento externo, caso a migração para microsserviços seja desejada.

Prefiro usar eventos locais quando o time é pequeno, o sistema é um monólito modular e o deploy é único, pois o overhead e complexidade da mensageria externa não compensam.

Como modelar eventos locais de domínio

O eixo central é modelar eventos que expressem claramente uma mudança de estado ou uma ação significativa na linguagem do domínio, sem expor detalhes técnicos. Em DDD, esses eventos representam fatos ocorridos.

Eventos expressivos têm características que sugiro respeitar:

  • Nomes no passado, como PedidoCriado, UsuarioAtivado, PagamentoAutorizado.
  • Imutabilidade dos dados contidos.
  • Inclusão somente do necessário para o receptor compreender o impacto.
  • Não conter lógica de negócio, apenas dados.
  • Fazer parte da linguagem ubíqua entre os módulos.

Gosto de definir interfaces ou classes base para eventos locais dentro do projeto Domain, para garantir tipagem e facilitar roteamento local.

Implementação de event-driven interno no .NET

Na minha stack padrão com .NET 10 / ASP.NET Core 10, prefiro evitar bibliotecas externas para o event bus interno. Geralmente implemento um mediator simples, que pode ser uma abstração própria que recebe eventos e os encaminha para handlers registrados na injeção de dependência.

Exemplo ilustrativo:

// Evento de domínio
public record PedidoCriado(int PedidoId, DateTime DataCriacao);

// Interface do dispatcher
public interface IDomainEventDispatcher
{
    Task DispatchAsync<T>(T domainEvent) where T : notnull;
}

// Handler de evento
public interface IEventHandler<T> where T : notnull
{
    Task HandleAsync(T domainEvent);
}

O dispatcher encapsula a lista de handlers e invoca todos assincronamente. A vantagem é manter coesão no domínio e permitir que o receptor do evento execute lógica complementar (como envio de notificação, atualização de cache, ou computação eventual).

Usei essa abordagem em sistemas modulares como Planuz e sistema de comércio exterior para permitir comunicação indireta entre bounded contexts, preservando restrições de camada e limpeza na arquitetura.

Integração com testes

Outra vantagem que observei é nos testes de integração. Com eventos locais, é possível cobrir cenários complexos sem mocks excessivos, conferindo que o disparo do evento e a reação acontecem conforme esperado, tudo dentro do pipeline com WebApplicationFactory e Testcontainers.

Com o event-driven interno:

  • O teste pode disparar uma ação em um módulo.
  • Confirmar que os eventos foram disparados.
  • Confirmar que os handlers produtores andam em sincronia e atualizaram estado corretamente.

Isso traz maior confiança e clareza para evoluções no monólito, porque a responsabilidade fica explicita no evento, e não no encadeamento de chamadas entre módulos.

Quando não usar eventos locais?

Avalie se os eventos locais podem complicar fluxos simples e criar camadas desnecessárias. Em módulos fortemente integrados, chamadas diretas e sincronas podem ser mais claras e fáceis.

Não adote eventos locais para lógica crítica que exige garantia estrita de ordem ou transação distribuída dentro do monólito — prefiro manter essas funcionalidades localmente no aggregate ou serviço com padrões tradicionais de domínio.

Também não uso eventos locais para comunicação externa, webhook ou integração com outros sistemas, que têm requisitos próprios e demandam outro tipo de mensageria ou integração.

Benefícios para extensões futuras

Além do benefício imediato para modularidade e testes, eventos locais no monólito podem facilitar incluir novos consumidores internos — por exemplo, para registrar auditoria, emitir métricas, alimentar dashboards ou até preparar migração para microsserviços.

O design fica mais maleável: novos assinantes só precisam escutar o evento, o emissor não precisa modificar seu fluxo ou conhecer os consumidores. Isso encaixa na filosofia do Reactive Manifesto, onde a arquitetura orientada a mensagens traz flexibilização mesmo dentro do monólito.


Referências


Receba o resumo da semana

Um e-mail por semana com o que foi publicado. Sem spam, e você sai quando quiser.

Continue lendo

Receba o resumo da semana

Um e-mail por semana com o que foi publicado. Sem spam, e você sai quando quiser.

Blog do Felipe Marciano

Decisões de arquitetura, .NET e sistemas distribuídos, escritas por quem vive com as consequências delas.

© 2026 Felipe Marciano. Todos os direitos reservados. · v1.54.0