Toda aplicação chega a um ponto em que alguma operação demora demais para acontecer dentro da requisição do usuário. Gerar relatório, processar vídeo, enviar mil e-mails, integrar com um sistema lento. A solução é conhecida — tirar isso do caminho síncrono — e a escolha da ferramenta costuma ser feita pelo que o time já ouviu falar.
Vale separar as duas famílias, porque elas resolvem problemas diferentes e a confusão entre elas produz arquitetura cara.
O que o assíncrono resolve
Quatro problemas concretos:
Latência percebida. A requisição responde "recebido" em milissegundos e o trabalho pesado acontece depois. O usuário não espera.
Absorção de pico. Se chegam dez mil pedidos em um minuto e o sistema processa cem por segundo, a fila acumula e o processamento acontece no ritmo possível. Sem fila, metade das requisições falha.
Desacoplamento. O produtor não precisa saber quem consome, nem se o consumidor está no ar. Se o serviço de e-mail cair, as mensagens esperam em vez de se perderem.
Retentativa. Falhou? Tenta de novo, com espera crescente, sem o usuário envolvido.
As duas famílias
| Exemplos | RabbitMQ, SQS, Redis | Kafka, Redpanda |
|---|---|---|
| Modelo | mensagem é consumida e some | evento é gravado e fica |
| Quem lê | um consumidor por mensagem | vários, independentes |
| Ordem | por fila, com limites | garantida por partição |
| Reprocessar | não, depois de consumida | sim, voltando no histórico |
| Operação | mais simples | mais complexa |
Fila de trabalho
A mensagem é uma tarefa. Alguém a pega, executa e ela desaparece. É o modelo natural para "faça isso": enviar e-mail, gerar PDF, processar imagem, chamar uma integração.
Ganha quando: o trabalho tem dono único, não precisa ser reprocessado depois, e você quer roteamento flexível — uma mensagem indo para filas diferentes conforme o tipo.
É o que a maioria dos sistemas precisa, e é bem mais simples de operar.
Log de eventos
O evento é um fato que aconteceu — "pedido criado", "pagamento aprovado" — gravado em sequência e retido por um período. Vários consumidores leem o mesmo fluxo independentemente, cada um no seu ritmo, cada um marcando até onde leu.
Ganha quando:
- Vários sistemas precisam reagir ao mesmo acontecimento, sem o produtor saber quem são.
- É preciso reprocessar o histórico — um consumidor novo que precisa ver os eventos dos últimos 30 dias, ou um bug corrigido que exige reprocessar.
- O volume é muito alto e sustentado.
- A ordem dos eventos de uma mesma entidade importa.
O reprocessamento é a característica que não tem substituto. Em fila de trabalho, mensagem consumida se foi.
Qual escolher
A pergunta que decide: é uma tarefa para alguém fazer, ou um fato para vários saberem?
Tarefa → fila. Fato → log de eventos.
E uma recomendação prática: Kafka é desproporcional para a maioria dos casos. Ele é excelente e exige operação séria — partições, replicação, retenção, grupos de consumidores, rebalanceamento. Adotá-lo para enviar e-mail assíncrono é pagar complexidade sem receber benefício. Se o seu caso é fila de trabalho, use fila de trabalho.
Os modos de falha que todo assíncrono tem
É aqui que mora o trabalho real, independentemente da ferramenta.
Entrega duplicada
Praticamente todo sistema de mensageria garante entrega ao menos uma vez, não exatamente uma vez. A mensagem pode chegar duas vezes — o consumidor processou e caiu antes de confirmar, então ela volta.
A consequência é dura e inevitável: o consumidor precisa ser idempotente. Processar a mesma mensagem duas vezes não pode cobrar duas vezes nem duplicar registro.
O padrão usual é cada mensagem carregar um identificador único, e o consumidor registrar o que já processou antes de agir. Não é opcional — é a diferença entre um sistema correto e um que cobra o cliente em duplicidade de vez em quando.
A mensagem envenenada
Uma mensagem que sempre falha ao ser processada — dado inválido, bug, referência quebrada. Ela volta para a fila, falha de novo, volta, e trava o processamento das que vieram depois.
A solução é a fila de descarte: depois de N tentativas, a mensagem sai do caminho e vai para uma fila separada, onde alguém investiga.
E o item que falta na maioria das implantações: alerta na fila de descarte. Mensagem que falha em silêncio é o bug mais difícil dessa arquitetura, porque nada aparece quebrado — só deixa de acontecer.
O consumidor que não acompanha
A fila cresce mais rápido do que é consumida. Se ninguém monitora, ela cresce até estourar memória ou disco do broker, e aí a falha deixa de ser de atraso e passa a ser de indisponibilidade.
A métrica que importa é o atraso do consumidor — quantas mensagens ou quanto tempo de defasagem existe. É o indicador número um de saúde de qualquer sistema assíncrono, e é também a melhor métrica para escalar consumidores automaticamente.
Ordem
Fila com vários consumidores em paralelo não garante ordem. Se "criar usuário" e "atualizar usuário" são processadas simultaneamente, a segunda pode chegar primeiro.
As saídas: particionar por chave, de modo que tudo de uma mesma entidade vá para a mesma partição e seja processado em sequência; ou desenhar os consumidores para tolerar ordem arbitrária, o que costuma ser mais robusto.
Perda em caso de falha
Mensagem só em memória some quando o broker reinicia. Para trabalho que não pode ser perdido, é preciso persistência habilitada, confirmação de gravação pelo produtor e replicação do broker. Cada um desses custa latência — é uma troca consciente, não um padrão a aceitar sem olhar.
O que você precisa monitorar
- Atraso do consumidor, por grupo. A métrica principal.
- Tamanho e idade da mensagem mais antiga na fila.
- Fila de descarte, com alerta em qualquer mensagem nova.
- Taxa de erro de processamento.
- Disponibilidade e espaço em disco do broker.
- Taxa de produção contra taxa de consumo — a divergência antecede o acúmulo.
Erros comuns
- Escolher log de eventos quando o caso é fila de trabalho.
- Consumidor sem idempotência, processando duplicata.
- Nenhuma fila de descarte, com mensagem envenenada travando o processamento.
- Fila de descarte sem alerta — falha silenciosa.
- Não monitorar o atraso do consumidor.
- Esperar ordem garantida com consumidores em paralelo.
- Mensagem sem persistência em trabalho que não pode ser perdido.
- Usar o banco de dados como fila sem cuidado com concorrência.
- Mensagem carregando dado demais, em vez de referência.
- Nenhuma versão no formato da mensagem, quebrando consumidor antigo no deploy.
- Broker sem backup nem plano de recuperação.
O penúltimo item merece nota: mudança de formato de mensagem precisa seguir o padrão de expandir e contrair, igual a esquema de banco. Produtor novo publicando formato que o consumidor antigo não entende é um incidente assíncrono — aparece depois, na fila de descarte.
O desenho que funciona
Para a maioria dos casos:
- Fila de trabalho para tarefas, com retentativa e espera crescente.
- Fila de descarte configurada, com alerta.
- Consumidores idempotentes, com identificador único por mensagem.
- Mensagem enxuta, carregando referência em vez de todo o dado.
- Formato versionado, com compatibilidade para trás.
- Atraso monitorado, com escala automática de consumidores quando faz sentido.
- Log de eventos acrescentado depois, só se houver necessidade de múltiplos consumidores independentes ou de reprocessar histórico.
Onde a Solvefy/Cloud entra
Implantamos e operamos a camada assíncrona com os modos de falha resolvidos desde o desenho: escolha entre fila de trabalho e log de eventos conforme o caso real, idempotência nos consumidores, fila de descarte com alerta, formato de mensagem versionado, monitoramento de atraso e escala por tamanho de fila — além de backup e plano de recuperação do broker, que costuma ser esquecido. Trabalhamos com RabbitMQ, Redis e Kafka, em infraestrutura própria ou gerenciada.
Sua fila cresce e ninguém percebe? Diagnóstico gratuito, sem compromisso, em solvefy.cloud.
Solvefy/Cloud — Infraestrutura que cresce com você.