A Dor Real: O Microserviço que Vira Refém de Acoplamento Travestido de “Arquitetura Moderna”
O caos sempre começa igual: três serviços, dois bancos e um time empolgado com a ideia de que mensageria é sinônimo de escalabilidade. Resultado? Uma avalanche de filas desnecessárias, eventos irrelevantes e um acoplamento indireto tão forte que, quando um serviço cai, os outros começam a se comportar como gremlins pós-meia-noite.
**Mensageria sem propósito vira dívida técnica distribuída.**
O problema não é a tecnologia — é a falta de clareza sobre o que realmente deveria ser assíncrono, idempotente e desacoplado.
Como Resolver Sem Firula: Mensageria Só Entra Onde Há Valor de Negócio
Quer colocar Kafka, RabbitMQ ou SQS? Faça isso por motivos concretos:
- Processos que não precisam de resposta imediata.
- Cargas que variam muito e exigem buffering.
- Integrações entre bounded contexts isolados.
- Operações naturalmente event-driven.
Sem esses cenários, você não precisa de mensageria — precisa de um endpoint REST bem definido e uma boa modelagem.
Implementação de Sênior: Evento Real Num Microserviço Real
Aqui vai um exemplo prático com Kafka, simples e direto. É o tipo de implementação que resolve problema, não cria burocracia.
import { Kafka } from "kafkajs";
const kafka = new Kafka({ brokers: ["localhost:9092"] });
// Producer de evento de pedido criado
export async function publishOrderCreated(order) {
const producer = kafka.producer();
await producer.connect();
await producer.send({
topic: "order.created",
messages: [
{
key: String(order.id),
value: JSON.stringify(order),
},
],
});
await producer.disconnect();
}
// Consumer para atualização de estoque
export async function startStockConsumer() {
const consumer = kafka.consumer({ groupId: "stock-service" });
await consumer.connect();
await consumer.subscribe({ topic: "order.created", fromBeginning: false });
await consumer.run({
eachMessage: async ({ message }) => {
const event = JSON.parse(message.value.toString());
// lógica de estoque
console.log("Atualizando estoque para order:", event.id);
},
});
}
Isso é mensageria usada com propósito: um serviço cuida do fluxo do pedido; outro cuida de estoque. Sem dependência direta, sem idas e vindas HTTP, sem nó cego.
O Custo da Escolha: Mensageria Resolve, Mas Cobra
Mensageria funciona, mas não é grátis. Eis o preço:
- Observabilidade complica: você não vê mais uma call chain linear.
- Reprocessamento exige idempotência: se não fez, vai sofrer.
- Infra pesa: cluster Kafka não é “rodar um docker-compose e ser feliz”.
- Debug vira arqueologia: eventos viajam, atrasam, se perdem e ressurgem.
**Se seu problema é simples, mensageria é munição demais para o alvo errado.**
Direto das Trincheiras — 3 Dicas Rápidas
- Comece com um único tópico e um único produtor antes de espalhar eventos pelo sistema.
- Trate idempotência antes de escrever uma linha de consumer — é isso que separa sistemas resilientes de bombas-relógio.
- Escreva contratos de eventos como se fossem APIs: versão, schema, backward compatibility.
Fontes Relevantes
Nenhuma das fontes fornecidas é relacionada ao tema de mensageria, microserviços ou banco de dados e, portanto, foram filtradas conforme solicitado.
Obrigado por acompanhar essa reflexão até o fim!
Espero que esses pontos ajudem você a tomar decisões mais lúcidas no seu próximo projeto. Não deixe de conferir outros artigos aqui no blog, onde descascamos outros hypes da nossa área.
Valeu e até a próxima! 😉
