Estratégias para migração gradual de monólitos para microsserviços usando Event-Driven Architecture
Migrar monólitos para microsserviços exige balancear desacoplamento gradual via eventos e manutenção da consistência. Estratégias focadas em arquiteturas event-driven ajudam a decompor sistemas legados passo a passo, minimizando riscos operacionais.

Migrar um monólito para microsserviços é um desafio frequente nos projetos que mantenho, sobretudo em domínios complexos como gestão financeira de comércio exterior e sistemas de direitos autorais, onde a criticidade dos dados exige evitar interrupções e inconsistências. Nessas experiências, a migração nunca foi abrupta; precisei avançar por etapas que permitissem manter processos ativos, testar cada pedaço com rollback seguro e garantir que a troca da base de dados não impactasse relatórios fiscais ou contratos sensíveis.em uma quebra radical. A escolha pela arquitetura event-driven oferece uma opção de desacoplamento incremental, mas essa evolução demanda práticas rigorosas para manter o controle e evitar fragilidade técnica ou operacional. Isso inclui implementar padrões de idempotência, testes robustos de integração com brokers reais em ambiente controlado, monitoramento detalhado dos eventos em dashboards e estratégias claras de rollback. Na minha experiência, o maior desafio não está só no desacoplamento, mas em garantir que múltiplos serviços consumam eventos sem perda, duplicação ou inconsistência, exigindo auditoria e governança automatizadas que muitos projetos negligenciam, levando a complexidade oculta e falhas em produção.
Critérios para a escolha da estratégia de migração gradual via eventos
Antes de definir como migrar, sugiro ponderar estes critérios, em ordem de importância:
- Risco de impacto em produção: Como garantir que a nova arquitetura não interrompa funcionalidades críticas?
- Manutenção da consistência dos dados: Que modelo de consistência pode ser tolerado no domínio (consistência forte x eventual)?
- Complexidade do domínio e do código legado: Qual o custo de refatorar versus substituir módulos?
- Capacidade de monitoramento e rollback: Como identificar falhas sem comprometer o sistema?
- Capacidade de usar infraestrutura existente: O que o ambiente atual suporta em termos de mensagens, filas, serviços, etc.?
Com esses critérios em mente, descrevo três abordagens para decompor um monólito com foco em event-driven.
1. Extrair serviços via segmentação de domínio e evento de integração
Nesse caminho, começa-se identificando bounded contexts do monólito (por exemplo, módulos Administrativo, Comercial e Financeiro numa aplicação de comércio exterior). Cada contexto vira um microsserviço, e a comunicação entre eles passa a ser feita por eventos assíncronos que expressam mudanças relevantes de estado ou comandos.
O que essa opção cobra
- Requere um desenho claro dos limites da aplicação (DDD ajuda bastante).
- Precisa de uma infraestrutura para eventos (RabbitMQ, Kafka, etc.) no meu portfólio, uso RabbitMQ só em microsserviços como Agendora, não nos monólitos.
- Implica teste rigoroso de canal e idempotência: eu implemento padrões inbox para garantir que eventos sejam processados uma vez, independentemente de reenvios.
- É necessário implementar mecanismos de auditoria e idempotência para compensar a eventualidade e evitar inconsistência.
- Deve-se manter a base de dados de cada serviço com seu próprio modelo (database per service) para reduzir acoplamento, planejando estratégias de migração e sincronização de dados, como sincronização eventual via eventos ou processos de replicação, para garantir consistência durante a transição.
Quando usar
Vale para projetos onde é possível refatorar limites claros, onde o ambiente aceita infraestrutura dedicada e há equipe para garantir a operação dos brokers e testes de mensagens. Em sistemas sob medida porém monolíticos que não usam fila, essa abordagem adiciona complexidade operacional significativa, como a necessidade de gerenciar cluster de mensagens, garantir a idempotência e monitorar falhas no processamento assíncrono, custos que muitas vezes superam os benefícios em cenários com equipes reduzidas ou infraestrutura limitada.m produção, essa abordagem adiciona complexidade operacional que nem sempre compensa.
2. Implantar eventos locais de domínio para desacoplamento interno
Outra estratégia é aplicar event-driven dentro do monólito, desacoplando módulos por eventos de domínio disparados internamente (por exemplo via Mediator pattern ou Message Bus interno). Os eventos não saem da aplicação, mas ajudam a manter fronteiras limpas, reduzir acoplamento e preparar o terreno para futuras extrações.
O que essa opção cobra
- Requer disciplina de modelagem do domínio para que os eventos sejam expressivos, sem vazamento de abstrações.
- Depende da instrumentação e arquitetura do monólito (nós preferimos controllers finos e AppServices que retornam envelopes Result para controle explícito).
- Menor custo em infraestrutura, pois tudo roda no mesmo processo.
- Dá menos ganho em escalabilidade, mas reduz acoplamento temporal e facilita testes e extensão.
- Pode ser adotado junto com testes de integração robustos (WebApplicationFactory + Testcontainers).
Quando usar
Indicado quando o sistema é grande, mas não há infraestrutura para filas ou não se quer acelerar extracoes inicialmente. Essa camada de eventos locais pode servir para isolar responsabilidades e ilustrar decisões de negócio, criando um passo intermediário antes da migração completa.
3. Integrar por eventos externos entre monólitos e novos microsserviços
Este caminho considera manter o monólito e ir criando microsserviços isolados que se comunicam via eventos externos. O monólito continua escrevendo na base original, mas publica eventos para microsserviços consumidores.
O que essa opção cobra
- Necessita implementar eventos de integração e publicar em tópico ou broker;
- Exige concordância nos contratos de evento, normalmente por bases de código ou documentação forte;
- Pode demandar uma camada adaptadora para compatibilizar monólito e serviços novos;
- Testes de integração precisam garantir que a comunicação funcione entre os sistemas. Aqui, não uso teste de contrato com Pact porque, em monólitos modulados, a integração é feita internamente e um teste end-to-end com container real cobre a comunicação de ponta a ponta, incluindo banco e interfaces, reduzindo o risco de quebra por incompatibilidade. Embora testes de contrato sejam valiosos em ambientes com serviços desacoplados e deploys independentes, no contexto do meu portfólio eles não agregam diferencial relevante diante da integração completa e do controle forte sobre versões nas implantações.
- Carece de monitoramento em dashboards e alertas para detectar falhas nos eventos.
Quando usar
Seria a escolha para cenários que requerem coexistência prolongada do monólito, reduzindo riscos ao minimizar alteração do núcleo, desde que haja estratégias claras para sincronização e tolerância a inconsistências entre o monólito e os microsserviços, como uso de eventos compensatórios, versionamento de contratos e monitoramento constante para detectar e resolver divergências. Serve para prototipagem de serviços isolados que vão crescendo sem perturbar o legado. Por ter dependência operacional (broker) que não está presente em todos meus monólitos, essa alternativa só faz sentido em projetos que já ou podem suportar essa infraestrutura.
Quando usar cada uma dessas opções e limitações
Para sistemas onde o time é único e a base legada é um monólito modular com bounded contexts estabelecidos, prefiro começar pelo desacoplamento local (2), pois entrega isolamento sem precisar de broker e mantém o controle forte da consistência ao operar no mesmo contexto transacional, evitando a latência e a eventual inconsistência típicas de comunicação assíncrona entre serviços.
Se houver infraestrutura específica para mensagens e a empresa tem um time dedicado, vale partir para extração com eventos externos explicitando integrações (1 ou 3), mas cobrando investimento em testes, idempotência e monitoramento para os novos serviços.
Se o cenário impede qualquer mudança na infraestrutura e o risco de migração não pode ser absorvido, mantenha o monólito e invista em melhoria interna por eventos locais. Especialmente em setores altamente regulados, qualquer quebra deve ser evitada a todo custo.
Ilustração geral da decomposição incremental via eventos
flowchart TD
monolito[Monólito modular]
subgraph "Modulo Administrativo"
modAdm[Modulo Administrativo]
end
subgraph "Modulo Financeiro"
modFin[Modulo Financeiro]
end
subsistemaMicro["Microsserviço Novo"]
broker["Broker (RabbitMQ, Kafka)"]
modAdm -->|Evento interno| modFin
modFin -.->|Evento público| broker
broker -->|Consome evento| subsistemaMicro
Essa visão mostra como começa um evento interno entre módulos do monólito, depois pode-se adicionar um broker para eventos externos e migrar o subsistema para microsserviço próprio, incrementando o desacoplamento.
Considerar a migração gradual com event-driven architecture significa encarar um processo que evolui passo a passo, aplicando entrega contínua com deploys frequentes que detectam rapidamente falhas e usando testes de integração automatizados que cobrem cenários reais, reduzindo riscos e garantindo a estabilidade durante a transição. Um roadmap cuidadoso do domínio e do pipeline de deploy, além de testes integrados com containers e rollback definidos, são elementos tão importantes quanto a própria arquitetura.
Quem precisar enfrentar esse desafio pode começar de forma segura desdobrando eventos locais para organização interna, e só depois partir para eventos externos e extração real de microsserviços, alinhando processo, equipe e tecnologia.
Para saber mais sobre testes de integração contra bases reais e governança do pipeline recomendado, veja os posts e ADRs disponíveis neste blog, que tratam de testes, rollback e governança assistida por IA.
Para se aprofundar: Implementando idempotência e padrões inbox em arquiteturas event-driven. Neste texto, aprofundo o uso de padrões inbox e idempotência para assegurar o processamento único de eventos em arquiteturas event-driven, com foco prático na implementação em .NET e integração a test.
Para se aprofundar: Testes de integração com WebApplicationFactory e Testcontainers em ambientes event-driven. Testes de integração com WebApplicationFactory e Testcontainers são fundamentais para sistemas event-driven, garantindo que fluxos de eventos e integrações assíncronas funcionem corretamente, evitando.
Para se aprofundar: 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 ajuda.
Para se aprofundar: Governança e monitoramento de eventos para evitar inconsistências em microsserviços. Gerenciar eventos em microsserviços requer governança e monitoramento detalhados para evitar inconsistências como perda e duplicação. Compartilho práticas de auditoria automatizada, dashboards e alert.
Referências
- RabbitMQ Documentation: Documentação oficial do RabbitMQ, usado como broker para event-driven architecture.
- Apache Kafka Documentation: Documentação oficial do Kafka, plataforma de streaming de eventos mencionada para integração via eventos externos.
- Domain-Driven Design (DDD) - martinfowler.com: Explicação sobre bounded contexts, conceito usado para segmentação de domínios na migração gradual.
- Testcontainers Documentation: Ferramenta para testes de integração com containers reais, citada para garantir robustez no deploy e testes.
- Implementando padrões de CQRS e Event Sourcing com .NET e RabbitMQ: Tutorial do autor para implementação de padrões CQRS e Event Sourcing com RabbitMQ, relevante para event-driven architecture.
- Automatizando estratégias de rollback em pipelines CI/CD: Discussão sobre estratégias de rollback em pipelines de CI/CD, importante para reduzir riscos na migração gradual.
- Sistemas distribuídos: Conteúdo sobre fundamentos e desafios de sistemas distribuídos, base para entender event-driven e microsserviços.
Receba o resumo da semana
Um e-mail por semana com o que foi publicado. Sem spam, e você sai quando quiser.
Continue lendo
- Do e-mail copiado à mão ao funil num sistema só: cinco decisões e o que cada uma custouUma empresa de comércio exterior, que conduz processos de mudança para os clientes, recebia os pedidos de orçamento por e-mail, enviados por três plataformas de geração de leads. Alguém lia cada mensagem e copiava os dados à mão. Este texto conta cinco decisões que tomei ao construir o sistema que substituiu esse trabalho, e o que cada uma deixou pior.
- Governança e monitoramento de eventos para evitar inconsistências em microsserviçosGerenciar eventos em microsserviços requer governança e monitoramento detalhados para evitar inconsistências como perda e duplicação. Compartilho práticas de auditoria automatizada, dashboards e alertas baseados em minha experiência com sistemas event-driven.
- Event-driven interno: desacoplamento por eventos locais em monólitos moduladosEste 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.