Pular para o conteúdo
Voltar para o Blog

Quando Não Usar Microsserviços: O Imposto Oculto da Complexidade Distribuída

Se existe uma decisão técnica capaz de consumir anos de energia de um time bom sem entregar velocidade para o negócio, essa decisão é fatiar um sistema cedo demais em dezenas de microsserviços.

Quem trabalha com engenharia de software há mais tempo já presenciou essa história de perto. Uma equipe enxuta, de 12 a 25 pessoas, sente a dor de manter um sistema antigo mal organizado e decide que a saída moderna é dividir tudo em 35 ou 40 microsserviços independentes, cada um com repositório próprio, esteira de deploy separada, banco isolado e dezenas de chamadas de rede síncronas no meio do caminho.

Um ano depois, os sintomas costumam aparecer todos juntos:

  • Mudanças simples ficam lentas: incluir um campo novo num fluxo comercial passa a exigir cinco Pull Requests coordenados e deploys em cascata entre vários repositórios.
  • Incidente vira investigação policial: quando uma venda falha no horário de pico, ninguém consegue reproduzir o fluxo inteiro na própria máquina sem subir meia nuvem local.
  • A conta de infraestrutura e observabilidade multiplica: mesmo sem grande salto de clientes, sobem a ociosidade somada de dezenas de containers, o tráfego entre zonas de disponibilidade e o custo de rastreamento distribuído.

Martin Fowler e Sam Newman, dois dos autores que mais documentaram arquiteturas distribuídas no mundo, repetem esse conselho há anos: quase nenhum sistema deveria nascer fatiado em microsserviços no dia zero.

1. Qual dor real os microsserviços nasceram para resolver?

Dividir um processo único em serviços separados na rede nunca deixou código mal escrito mais limpo nem chamada de função mais rápida. Dentro do mesmo processo em memória, chamar um método leva nanossegundos e não sofre queda de pacote. Quando colocamos rede no meio, saltamos para milissegundos, além de precisarmos lidar com timeouts, retentativas, duplicidade de mensagens e falhas parciais.

Gigantes de tecnologia adotaram microsserviços por uma questão de Lei de Conway em escala humana gigante: quando você tem centenas ou milhares de engenheiros publicando código na mesma hora, coordenar um único artefato vira fila organizacional. Já quando uma equipe de 15 ou 20 pessoas cuida de 40 microsserviços ao mesmo tempo, ela paga todo o pedágio operacional da distribuição sem colher o ganho de independência.

2. Os cinco custos invisíveis que aparecem na rotina

Sempre que participo dessa discussão de arquitetura com o time, gosto de colocar lado a lado o que muda na prática do dia a dia:

Ponto de atenção na rotinaMonólito Modular bem divididoDezenas de microsserviços prematuros
1. Consistência de dadosTransação ACID direta no banco (COMMIT / ROLLBACK)Consistência eventual, Sagas, Outbox e conciliação de estados parciais
2. Latência e redeChamada em memória sem custo de tráfegoSerialização JSON/gRPC, TLS, retentativas e tráfego pago entre zonas
3. Produtividade do desenvolvedorRefatoração segura validada pelo compilador em segundosContratos quebrados entre repositórios e versionamento cruzado
4. ObservabilidadeLogs estruturados e APM direto ao pontoTracing distribuído pesado atravessando dezenas de saltos
5. Conta de nuvem (FinOps)Recursos compartilhados escalando de forma uniformeFolga ociosa de CPU e RAM multiplicada por 30 ou 40 serviços

O caso público da equipe de monitoramento de áudio e vídeo do Amazon Prime Video ilustrou bem essa conta: ao trazer um fluxo hiperfragmentado de volta para um processo unificado bem estruturado, eles cortaram mais de 90% do custo de infraestrutura daquele pipeline enquanto aumentavam a capacidade de escala.

3. O caminho do meio que funciona muito bem: Monólito Modular

Evitar microsserviços precoces passa longe de defender código espaguete onde telas falam direto com tabelas de banco. Entre a "bola de lama" e a pulverização em 40 repositórios existe o Monólito Modular, abordagem que empresas como o Shopify levaram a escalas enormes com muita maturidade.

Na prática, o deploy continua simples e enxuto, mas por dentro o código respeita fronteiras rígidas de domínio:

  1. Módulos isolados de verdade: o módulo de Faturamento não acessa tabelas internas nem classes privadas de Estoque ou Cadastro; a conversa acontece apenas por interfaces claras de domínio, validadas automaticamente nos testes de arquitetura do CI/CD.
  2. Tabelas e schemas separados por contexto: mesmo rodando num único cluster de banco relacional no início, nenhum domínio faz JOIN atravessando tabelas privadas do vizinho, o que prepara o terreno caso algum módulo precise sair dali no futuro.
  3. Ambiente local leve e deploy rápido: qualquer pessoa do time roda o projeto inteiro na máquina em segundos, testa ponta a ponta e publica em poucos minutos.

Um aprendizado que nunca falhou por onde passei: se a equipe ainda não conseguiu manter fronteiras limpas dentro de um único repositório com ajuda do compilador, separar tudo na rede só vai gerar um monólito distribuído, onde basta um serviço engasgar para travar todos os outros.

4. Quando realmente compensa extrair um serviço separado

Com um Monólito Modular bem isolado, puxar um módulo para fora quando chega a hora leva dias, não semestres. Na minha experiência, essa extração se paga de verdade em três situações bem claras:

  1. Consumo de máquina muito diferente do resto: um motor pesado de processamento de imagem, IA, fila assíncrona de altíssima vazão ou cálculo intensivo que precisa escalar separado da API principal.
  2. Isolamento crítico de segurança ou disponibilidade: um cofre de pagamentos, integrador fiscal crítico ou coletor de eventos na ponta que precisa continuar de pé mesmo durante manutenção de outros módulos.
  3. Escala real de múltiplas squads independentes: quando a operação cresce para dezenas de engenheiros em domínios distintos que realmente precisam de ciclos de publicação independentes.

Projetar para a realidade dos próximos 18 meses, deixando as portas abertas para evoluir sem carregar peso morto hoje, quase sempre é o melhor conselho de arquitetura que podemos aplicar.


Referências e leituras verificáveis

Cesar Zanis / Tecnologia

Uma boa conversa merece continuar.

Compartilhe o artigo ou publique os slides nos seus Stories e no Feed.

WhatsApp ↗LinkedIn ↗X ↗
Cesar Zanis
Escrito por·Arquiteto de Software & Líder de Tecnologia

Cesar Zanis

15+ anos liderando arquitetura de software, banco de dados de missão crítica, FinOps e IA aplicada. Estruturou e escalou uma operação de engenharia do zero a mais de 20 desenvolvedores.

15+ anos de atuaçãoArquitetura & DadosCloud & FinOps0 → 20+ Devs

Gostou deste artigo?

Publico análises práticas sobre arquitetura de sistemas críticos, Cloud FinOps, dados, IA e liderança de engenharia diretamente no LinkedIn.

Continue Lendo

Leve esta análise adiante com dados e fontes

Os cards visuais deste artigo estão prontos logo acima para você compartilhar nos seus Stories, Feed, WhatsApp ou LinkedIn com a legenda e as fontes.