Imagine uma loja virtual em dia de campanha. O cliente clica em "finalizar pedido" e a tela fica girando. Por trás do clique, o sistema grava o pedido, emite a nota, envia o e-mail de confirmação, avisa o estoque, atualiza o painel e ainda gera um PDF. Tudo isso acontece antes de a página responder. Se uma dessas etapas demora, o cliente espera. Se uma falha, o pedido inteiro pode se perder.
Esse é o retrato clássico de um sistema que faz tudo dentro da requisição do usuário. A saída é o processamento assíncrono: o sistema responde logo, guarda o trabalho pesado numa fila e deixa processos separados, os workers, executarem esse trabalho em segundo plano. Na Trilion, que desenvolve sites e sistemas desde 1995, esse é um dos primeiros caminhos que avaliamos quando uma aplicação começa a ficar lenta sem motivo aparente.
Neste artigo você vai entender o que são filas de tarefas e jobs em segundo plano, quais trabalhos devem sair da requisição, como lidar com falhas e repetições, como acompanhar os workers e como introduzir filas num sistema que já está em produção. Se, ao ler, você reconhecer o seu próprio sistema, o resumo da nossa frente de aplicações de alta performance mostra como trabalhamos esse tipo de projeto.
Processamento assíncrono: o que é e por que tirar trabalho da requisição
Processamento assíncrono é executar uma tarefa fora do momento em que o usuário a pediu: o sistema registra o pedido, responde de imediato e conclui o trabalho depois, em segundo plano, por outro processo.
O que é processamento assíncrono, em palavras simples
Numa requisição comum, o usuário pede e espera até que tudo termine. No modelo assíncrono, quem pede entrega um bilhete e recebe uma confirmação de recebimento. O bilhete vai para uma fila, e alguém, em outro lugar, cuida dele. A Wikipédia descreve as filas de mensagens como um padrão assíncrono, em que quem envia e quem recebe não precisam interagir com a fila ao mesmo tempo.
O que a requisição do usuário realmente precisa fazer
A requisição precisa validar o que chegou, gravar o essencial e devolver uma resposta. O restante raramente precisa acontecer antes da resposta. Mandar um e-mail, gerar um relatório ou recalcular um indicador pode esperar alguns segundos sem que o usuário perceba. Separar o que é indispensável agora do que pode ser feito depois é a decisão central deste artigo.
Por que o peso na requisição vira problema
Cada requisição ocupa um processo ou uma conexão do servidor enquanto espera. Quando o trabalho pesado fica dentro dela, poucos usuários simultâneos já esgotam essa capacidade. O sintoma é conhecido: telas que travam, tempos de espera longos e erros intermitentes em horário de pico. A documentação do RabbitMQ descreve esse cenário ao explicar que, em aplicações web, tarefas complexas não cabem no curto intervalo de uma requisição HTTP.
Quando o assíncrono não é a resposta
Nem tudo pode esperar. Se o usuário precisa do resultado para continuar, como a confirmação de que um pagamento foi aprovado, a resposta tem de ser imediata, ou a tela precisa comunicar que o resultado chegará depois. Também vale desconfiar de filas quando o gargalo está em outro lugar, como uma consulta mal escrita no banco de dados. Nesse caso, a fila apenas esconde o problema.
Comente abaixo: qual tarefa do seu sistema faz o usuário esperar sem necessidade?
Filas de tarefas e workers: como as peças se encaixam
Uma fila de tarefas funciona com 3 peças: quem cria o trabalho, a fila que o guarda e os workers que o executam. Entender o papel de cada uma evita decisões erradas de arquitetura.
Produtor, fila e worker
O produtor é a parte do sistema que cria a tarefa, em geral o próprio aplicativo web. A fila guarda a tarefa até que alguém a pegue. O worker é um processo dedicado que fica observando a fila e executa cada tarefa. A documentação do Celery, uma ferramenta de filas de tarefas muito usada, descreve o mecanismo assim: a fila distribui trabalho entre threads ou máquinas, e um cliente adiciona uma mensagem à fila para que o broker a entregue a um worker.
O que é um broker
Broker é o intermediário que recebe as mensagens e as entrega. Ele pode ser um serviço próprio de mensageria ou um banco de dados em memória usado para esse fim. A escolha depende do volume, da necessidade de garantias e da equipe que vai operar a solução. Para fins deste artigo, basta saber que o broker é quem protege o trabalho enquanto ele espera a vez.
Vários workers para o mesmo trabalho
Um dos grandes ganhos do modelo é a possibilidade de acrescentar workers conforme a demanda. Segundo a documentação do RabbitMQ, por padrão cada mensagem é entregue ao próximo consumidor da sequência, de modo que, com vários workers, cada um recebe aproximadamente a mesma quantidade de mensagens. A Wikipédia chama esse arranjo de padrão de consumidores concorrentes. Se a fila cresce, você aumenta os workers, sem mexer na parte que atende o usuário.
Tarefas agendadas e recorrentes
As mesmas peças servem para trabalhos com hora marcada. O Celery, por exemplo, permite executar uma tarefa num horário específico, repeti-la em intervalos fixos ou usar expressões no estilo crontab, com minuto, hora, dia da semana, dia do mês e mês do ano. É o caminho comum para fechamentos diários, limpezas periódicas e envio programado de relatórios.

Quais tarefas devem sair da requisição
Devem ir para a fila as tarefas que demoram, que dependem de serviços externos ou que o usuário não precisa ver concluídas para seguir. Um critério claro evita filas desnecessárias.
Os candidatos mais comuns
Alguns trabalhos costumam ser enviados a jobs em segundo plano:
- E-mails e notificações: confirmações, avisos de status e mensagens para vários destinatários.
- Arquivos pesados: redimensionar imagens, converter vídeos e gerar PDFs.
- Relatórios e exportações: consolidar grandes volumes de dados e entregar o arquivo depois.
- Integrações externas: enviar dados a outro sistema por API, tolerando lentidão ou instabilidade do outro lado.
- Recálculos e sincronizações: atualizar totais, índices de busca e painéis.
A documentação do Amazon SQS cita exemplos do mesmo tipo: separar as requisições ao vivo do usuário do trabalho intensivo em segundo plano, como no caso de quem envia um vídeo ou uma imagem e o sistema a redimensiona ou codifica depois.
Teste rápido para decidir
Faça 4 perguntas sobre cada tarefa. O usuário precisa do resultado para o próximo passo? A tarefa pode falhar sem derrubar o pedido? Ela leva mais do que uma fração de segundo? Depende de um serviço que não controlamos? Se o resultado não é necessário agora e a tarefa é lenta ou depende de terceiros, ela é uma boa candidata à fila.
O que fica de fora da fila
Validações, gravação do dado principal e verificações de segurança continuam dentro da requisição. A regra prática: a requisição garante que o pedido foi aceito com consistência, e a fila cuida do que decorre dele. Isso mantém a experiência previsível e facilita a leitura do sistema por quem for dar manutenção.
Como informar o usuário sobre o que ainda está em andamento
Quando o resultado chega depois, a interface precisa dizer isso com clareza. Mensagens como "estamos preparando o seu relatório" e um aviso por e-mail ou na própria tela, quando ele estiver pronto, evitam repetição de cliques e chamados de suporte. Esse cuidado de projeto faz parte do trabalho, não é um detalhe de acabamento.
Compartilhe com quem cuida do seu sistema: quais 3 tarefas poderiam sair da requisição ainda este mês?
Falhas, repetições e idempotência: o que a fila não resolve sozinha
Uma fila bem projetada assume que tarefas vão falhar e que algumas vão rodar mais de uma vez. O sistema precisa estar preparado para isso, e a ideia-chave é a idempotência.
Por que uma tarefa pode rodar duas vezes
Muitos sistemas de fila garantem entrega "pelo menos uma vez". A documentação do Amazon SQS afirma que as filas padrão asseguram entrega ao menos uma vez, mas que mais de uma cópia da mensagem pode ser entregue, e que as mensagens podem chegar fora de ordem. O guia de boas práticas do Sidekiq faz o mesmo alerta: uma tarefa já concluída pode ser executada de novo.
O que é idempotência
Uma tarefa idempotente produz o mesmo resultado final mesmo que seja executada 2 ou mais vezes. Cobrar um cliente duas vezes porque o job rodou duas vezes é o exemplo clássico do que não pode acontecer. Para evitar isso, registre que a operação já foi feita e confira esse registro antes de agir, por exemplo com um identificador único por pedido.
Confirmação de conclusão e reentrega
No RabbitMQ, o worker envia uma confirmação, chamada ack, ao terminar a tarefa. Se ele morrer antes de confirmar, a mensagem volta para a fila e é entregue a outro worker. É uma proteção valiosa, mas é também a razão de a mesma tarefa poder reaparecer. Por isso a documentação do Sidekiq sugere envolver as alterações em uma transação de banco de dados ou escrever o código de modo que ele tolere repetições.
Fila de mensagens com falha
Tarefas que falham sempre não podem ficar tentando para sempre. O Amazon SQS oferece as filas de mensagens não entregues, as dead-letter queues, para onde vão as mensagens que não foram processadas com sucesso depois de um número configurável de tentativas. Isolar essas mensagens permite examinar o conteúdo, ler os logs de exceção e descobrir por que o processamento falhou, sem travar o restante do fluxo.
Durabilidade: o que acontece se a fila reiniciar
A documentação do RabbitMQ explica que tornar a fila e as mensagens duráveis ajuda a sobreviver a uma reinicialização do serviço, e ressalta que a persistência não é uma garantia absoluta. Para proteção mais forte, o produtor pode usar confirmações de publicação. A conclusão prática: defina com o negócio quanto de perda é tolerável e escolha a configuração a partir disso.

Como dimensionar e acompanhar workers e filas
Uma fila saudável tem workers suficientes para esvaziá-la no ritmo da demanda e sinais de alerta antes que o atraso chegue ao usuário. Medir é parte do projeto, não um extra.
Os 4 sinais que mais dizem sobre a saúde da fila
Acompanhe regularmente estes indicadores:
- Tamanho da fila: quantas tarefas esperam a vez; crescimento contínuo indica workers insuficientes.
- Tempo de espera: quanto a tarefa mais antiga aguarda antes de ser pega.
- Tempo de execução: quanto cada tipo de tarefa leva depois de iniciada.
- Taxa de falhas: quantas tarefas terminam em erro ou vão para a fila de mensagens com falha.
O SQS expõe, por exemplo, a métrica ApproximateAgeOfOldestMessage, que mostra a idade da mensagem mais antiga. É o tipo de dado que a observabilidade do sistema precisa reunir; falamos dela no artigo sobre observabilidade, logs, métricas e rastreamento.
Distribuição justa entre workers
Quando as tarefas têm durações muito diferentes, a divisão automática pode deixar um worker sobrecarregado e outros ociosos. O RabbitMQ descreve a configuração de prefetch igual a 1, que impede o envio de uma nova mensagem a um worker até que ele confirme a anterior. O tutorial também alerta que, se todos os workers estiverem ocupados, a fila pode encher, o que reforça a necessidade de monitorar.
Separar filas por prioridade e por tipo
Misturar o envio de um e-mail simples com a geração de um relatório de 20 minutos na mesma fila cria atrasos injustos. Uma prática comum é criar filas distintas, com workers próprios, para tarefas urgentes e para tarefas longas. Assim, o aviso ao cliente não espera atrás de uma exportação gigante.
Quando aumentar workers resolve e quando não resolve
Acrescentar workers ajuda quando o gargalo é a capacidade de processamento. Não ajuda quando todos dependem do mesmo recurso limitado, como um banco de dados com poucas conexões. O Sidekiq recomenda projetar tarefas para rodar em paralelo e limitar conexões com um pool quando o recurso é restrito. Esse é um bom momento para revisar também o desempenho do banco de dados.
Passo a passo para introduzir filas num sistema que já está no ar
Introduzir filas em um sistema existente funciona melhor em passos pequenos, começando por uma única tarefa de baixo risco e ampliando a partir do que se aprende.
Um roteiro em 6 etapas
- Mapear: liste o que acontece dentro de cada requisição e quanto tempo cada trecho consome.
- Escolher: selecione uma tarefa lenta, importante e que o usuário não precisa ver concluída na hora.
- Tornar idempotente: garanta que repetir a tarefa não duplique cobranças, e-mails ou registros.
- Enfileirar: troque a execução direta por um envio à fila, passando apenas identificadores e não objetos inteiros.
- Medir: acompanhe tamanho da fila, tempo de espera e falhas desde o primeiro dia.
- Repetir: só então migre a próxima tarefa, com o aprendizado da anterior.
A orientação de passar identificadores em vez de objetos aparece nas boas práticas do Sidekiq: objetos podem não ser serializados corretamente e podem mudar enquanto a tarefa espera na fila. Busque o registro dentro do worker, no momento de executar.
Cuidados com o que já existe
Sistemas antigos têm dependências escondidas: uma rotina que assume que o e-mail já foi enviado ou um relatório que lê um dado ainda não gravado. Antes de mover qualquer trabalho para o segundo plano, revise essas dependências. Em projetos de modernização, esse levantamento costuma ser a parte mais valiosa; veja também como tratamos o código legado sem parar a operação.
Integrações e filas andam juntas
Quando o sistema conversa com outros sistemas, a fila protege os dois lados: se o destino ficar fora do ar, o envio espera e tenta de novo. A Wikipédia observa que o remetente não precisa esperar se o destinatário caiu. Para o desenho dessas conexões, vale conhecer a frente de integração de sistemas.
Quando a fila vira mensageria de eventos
Com o tempo, algumas empresas passam de filas de tarefas para uma arquitetura em que diferentes partes do sistema reagem a eventos publicados. É um passo maior, com outros custos de operação. Explicamos os critérios no artigo sobre Kafka, RabbitMQ e mensageria.
Cache e fila: aliados, não substitutos
Filas tiram trabalho da requisição; o cache evita refazer trabalho já feito. Os dois resolvem problemas diferentes e costumam aparecer juntos. Se a lentidão vem de leituras repetidas, comece pelo cache; se vem de trabalho pesado após o pedido, a fila é o caminho.
Erros comuns ao adotar processamento assíncrono
Os erros mais frequentes não estão na ferramenta escolhida, e sim na ausência de desenho: tarefas sem idempotência, fila sem monitoramento e expectativa de que a fila cure qualquer lentidão.
Checklist antes de colocar uma fila em produção
- A tarefa pode ser repetida sem causar dano?
- Existe limite de tentativas e um destino para o que falha sempre?
- Alguém é avisado quando a fila cresce além do normal?
- A interface informa ao usuário que o resultado virá depois?
- Há workers suficientes para o pico, e um plano para aumentá-los?
- Os dados passados à tarefa são mínimos, como identificadores?
Fila sem dono vira problema escondido
Uma fila que ninguém acompanha acumula tarefas atrasadas em silêncio, e o primeiro a perceber costuma ser o cliente. Defina quem observa os indicadores, quais limites disparam alerta e o que fazer quando disparam. Essa rotina é tão importante quanto o código.
Confiar na ordem das mensagens
Em muitos sistemas de fila, a ordem de chegada não é garantida de forma estrita. O SQS, por exemplo, tenta preservar a ordem nas filas padrão, mas avisa que as mensagens podem chegar fora dela. Se a ordem importa para o negócio, o desenho precisa levar isso em conta desde o início.
Antes de escalar tudo, teste
Depois de montar a fila, simule picos para ver como ela se comporta. Um teste de carga mostra o tamanho que a fila atinge, quanto os workers aguentam e onde surge o próximo gargalo, antes que o pico verdadeiro chegue.
Conclusão
Tirar o peso da requisição do usuário é uma das mudanças de maior alcance em uma aplicação lenta: a resposta fica rápida, o trabalho pesado ganha um lugar próprio e o sistema passa a absorver picos sem travar a tela.
Vimos que o processamento assíncrono depende de 3 peças, produtor, fila e workers, e de 3 cuidados: idempotência, tratamento de falhas e monitoramento. Sem eles, a fila apenas muda o problema de lugar. Com eles, o sistema ganha previsibilidade e espaço para crescer.
Se o seu sistema trava em horários de pico, faz o usuário esperar por tarefas que poderiam rodar depois ou integra outros sistemas de forma frágil, podemos avaliar o cenário com você. Monte o seu briefing na página da frente de aplicações de alta performance ou em /desenvolvimento/orcamento. A proposta é escrita depois do briefing, e o valor depende de escopo, integrações, volume e prazo. Para entender o panorama maior, leia também escalabilidade de sistemas.
Se este texto ajudou, envie-o a quem decide sobre o seu sistema e comece a conversa pelo que hoje faz o usuário esperar.
Sobre este texto
Este artigo foi redigido pela equipe da Trilion a partir da documentação pública de ferramentas de filas e mensageria e de publicações de referência, consultadas em 07/11/2026. Os nomes de tecnologias aparecem apenas como exemplo factual, sem recomendação. Não há promessa de ganho de desempenho, pois ele depende do sistema, da infraestrutura e do volume de cada empresa.
- RabbitMQ, Work Queues: https://www.rabbitmq.com/tutorials/tutorial-two-python (consulta em 07/11/2026)
- Celery, Introduction: https://docs.celeryq.dev/en/stable/getting-started/introduction.html (consulta em 07/11/2026)
- Amazon SQS, filas padrão: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html (consulta em 07/11/2026)
- Amazon SQS, filas de mensagens não entregues: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html (consulta em 07/11/2026)
- Sidekiq, Best Practices: https://github.com/sidekiq/sidekiq/wiki/Best-Practices (consulta em 07/11/2026)
- Wikipédia, Message queue: https://en.wikipedia.org/wiki/Message_queue (consulta em 07/11/2026)

