Mensageria
Mensageria aparece em quase todo sistema de empresa grande, banco e fintech: é onde o sistema deixa de ser um request esperando outro. Também é onde mais aparecem bugs difíceis, porque mensagem duplica, atrasa e chega fora de ordem.
Fila ou tópico
- Fila (ponto a ponto): cada mensagem é processada por um consumidor. Trabalho a fazer: “gerar a nota fiscal do pedido 42”.
- Tópico (publish/subscribe): cada assinante recebe uma cópia. Fato que aconteceu: “pedido 42 foi criado”, e faturamento, estoque e e-mail reagem cada um do seu jeito.
Comando é imperativo e tem um dono (GerarNotaFiscal). Evento é passado e não sabe quem escuta (PedidoCriado).
Qual broker
| Kafka | RabbitMQ | Azure Service Bus | AWS SQS + SNS | |
|---|---|---|---|---|
| Modelo | log particionado e persistente | filas e exchanges | filas e tópicos gerenciados | fila (SQS) e fan-out (SNS) |
| Bom para | alto volume, streaming, reprocessar histórico | roteamento flexível, tarefas | ecossistema Azure, sessões, transações | ecossistema AWS, simplicidade |
| Ordem | garantida dentro da partição | por fila, com um consumidor | com sessions | FIFO opcional |
| Reprocessar | sim, voltando o offset | não, a mensagem sai da fila | não | não |
Nos bancos e fintechs brasileiros, Kafka domina. Em empresas na Azure, Service Bus. Saber o conceito vale mais que a ferramenta: os problemas são os mesmos.
As garantias de entrega
- At most once: pode perder, nunca duplica. Raramente aceitável.
- At least once: nunca perde, pode duplicar. O padrão na prática.
- Exactly once: só existe de ponta a ponta com muita cooperação. Na prática, at least once com consumidor idempotente.
Conclusão: todo consumidor tem que ser idempotente. Processar a mesma mensagem duas vezes não pode cobrar duas vezes. Ver Outbox e idempotência.
Kafka com Confluent.Kafka
Consumidor com commit manual, depois de processar:
var config = new ConsumerConfig
{
BootstrapServers = "localhost:9092",
GroupId = "faturamento",
EnableAutoCommit = false, // commit só depois de processar
AutoOffsetReset = AutoOffsetReset.Earliest
};
using var consumer = new ConsumerBuilder<string, string>(config).Build();
consumer.Subscribe("pedidos.criados");
while (!ct.IsCancellationRequested)
{
var resultado = consumer.Consume(ct);
await using var scope = scopes.CreateAsyncScope();
var handler = scope.ServiceProvider.GetRequiredService<PedidoCriadoHandler>();
await handler.HandleAsync(resultado.Message.Value, ct);
consumer.Commit(resultado); // se cair antes daqui, a mensagem volta: at least once
}
Pontos que caem em entrevista:
- A chave define a partição, e a ordem só é garantida dentro da partição. Use o id do agregado (
pedidoId) como chave para que os eventos do mesmo pedido cheguem em ordem. - Consumidores do mesmo grupo dividem as partições. Mais consumidores que partições é consumidor parado.
- Auto commit ligado confirma a mensagem antes do processamento terminar: se o processo cair, a mensagem se perde.
Falhas e dead letter
Mensagem que falha sempre (JSON inválido, dado que nunca vai passar na validação) não pode travar a fila para sempre.
- Retry com espera crescente para falha transitória (banco fora, timeout).
- Depois de N tentativas, mover para uma dead letter queue (DLQ) com o motivo.
- Alerta na DLQ e uma forma de reprocessar depois da correção.
Separe erro transitório (tenta de novo) de erro permanente (DLQ direto). Tentar dez vezes um JSON quebrado só atrasa a fila.
Bibliotecas
- Confluent.Kafka: o client oficial, mais baixo nível.
- MassTransit: abstrai RabbitMQ, Azure Service Bus, SQS e Kafka, com retry, outbox, sagas e testes. Atenção: a partir da versão 9 o MassTransit passou a ter licença comercial; a versão 8 continua open source.
- Wolverine e Brighter: alternativas open source com outbox embutido.
O que perguntam em entrevista
- Diferença entre fila e tópico, comando e evento.
- Como garantir ordem no Kafka.
- O que acontece se o consumidor cair no meio do processamento.
- Como evitar processar a mesma mensagem duas vezes.
- Kafka ou RabbitMQ para um caso específico, e por quê.