Kafka virou sinônimo de arquitetura moderna. Se tem fila, tem Kafka. Se tem evento, tem Kafka. Se tem escala… bom, aí “precisa ter Kafka”.

Só tem um detalhe. Na maioria dos sistemas, não precisa. E pior… Às vezes, ele vira o problema.

O momento em que tudo começa

A decisão geralmente nasce assim: “Vamos desacoplar os serviços”. Faz sentido.

Aí alguém sugere: “Vamos usar Kafka”. Também faz sentido.

Até você perceber que resolveu um problema… Criando vários outros.

O caso mais comum (e mais caro)

Você tem algo simples: Criar usuário, Enviar email e Registrar log

Sem Kafka:

async function createUser(data) {
  const user = await db.insert(data);

  await sendWelcomeEmail(user);
  await logEvent('USER_CREATED', user);

  return user;
}

Funciona. É direto. E é fácil de debugar.

Agora com Kafka:

async function createUser(data) {
  const user = await db.insert(data);

  await kafkaProducer.send({
    topic: 'user_created',
    messages: [{ value: JSON.stringify(user) }]
  });

  return user;
}

E em outro serviço:

consumer.run({
  eachMessage: async ({ message }) => {
    const user = JSON.parse(message.value);

    await sendWelcomeEmail(user);
  }
});

Parece mais escalável. Mais “enterprise”. Mas agora você precisa lidar com coisas que antes não existiam.

A complexidade que ninguém te vende

Com Kafka, você não ganha só uma fila. Você ganha um ecossistema.  Agora você precisa entender:

• Partitions
• Offsets
• Consumer groups
• Retenção de mensagens
• Reprocessamento

E isso não é detalhe. É operação diária.

O clássico bug que aparece em produção

Você publica um evento. O consumer processa. Mas falha no meio. O que acontece?

Depende. Pode processar de novo. Pode perder a mensagem. Pode duplicar efeito.

Exemplo real:

consumer.run({
  eachMessage: async ({ message }) => {
    const order = JSON.parse(message.value);

    await chargeCustomer(order);
    await updateDatabase(order);
  }
});

Se falhar depois de chargeCustomer…

Você pode cobrar duas vezes. E agora? Bem-vindo ao mundo da idempotência.

Idempotência não é opcional

Com Kafka, você precisa garantir que seu sistema aguente reprocessamento. Exemplo de proteção:

async function chargeCustomer(order) {
  const exists = await db.findPayment(order.id);

  if (exists) return;

  await paymentGateway.charge(order);
}

Funciona. Mas agora você adicionou: Mais query, Mais lógica e Mais complexidade

Tudo isso para corrigir um problema que não existia antes.

Quando uma fila simples resolve

Na maioria dos casos, você não precisa de Kafka. Você precisa de algo assim:

import Queue from 'bull';

const queue = new Queue('email');

queue.add({ userId });

queue.process(async (job) => {
  await sendEmail(job.data.userId);
});

Simples, direto e menos moving parts. E resolve 90% dos casos.

O custo invisível do Kafka

Kafka não é só código. Você precisa de:

• Cluster
• Gerenciamento de brokers
• Monitoramento
• Tuning de performance

E quando dá problema…

Não é trivial. São Logs gigantes, Lag de consumer e Mensagens presas

E aí começa o clássico:

“Por que esse evento não foi processado?”

Boa sorte.

O efeito “overengineering”

Kafka é poderoso. Mas isso é uma armadilha. Porque você começa a usar pra tudo.

Evento simples vira stream, ação síncrona vira assíncrona e fluxo direto vira pipeline distribuído

E de repente: Seu sistema está mais difícil de entender do que de escalar.

Latência não é só performance

Com Kafka, você aceita latência. Você publica o evento. E… espera.

Para alguns casos, tudo bem. Para outros, não.

Exemplo:

await createOrder(order);

// espera evento processar

O usuário vê delay. Ou pior: Inconsistência.

Quando Kafka realmente faz sentido

Kafka brilha quando você tem:

• Altíssimo volume de eventos
• Processamento em tempo real
• Múltiplos consumidores independentes
• Necessidade de replay

Tipo: Tracking de eventos, Analytics em tempo real e Sistemas de streaming

Fora disso… Talvez seja exagero.

 

O sinal mais claro de uso errado

Se você precisa explicar Kafka pra todo novo dev do time… Provavelmente ele não era necessário.

Se debugging virou difícil… Provavelmente ele não era necessário.

Se seu sistema ficou mais lento pra evoluir… Provavelmente ele não era necessário.

O ponto que incomoda

Kafka resolve problemas reais. Mas também cria problemas reais.

E o erro não é usar Kafka. É usar antes da hora.

Por isso, você não precisa de Kafka para ter arquitetura moderna.

Você precisa de: simplicidade, clareza e controle

E, na maioria dos casos… Uma fila simples resolve.

Kafka é uma ferramenta excelente.

Mas, como toda ferramenta poderosa…

Ela cobra caro quando usada sem necessidade.