Filas e processamento assíncrono: tirando o peso da requisição do usuário

Aplicações de alta performance · Artigo

Filas e processamento assíncrono: tirando o peso da requisição do usuário

Falar no WhatsApp
Resposta direta

Processamento assíncrono é executar uma tarefa fora do momento em que o usuário a pediu. O sistema registra o pedido, responde de imediato, guarda o trabalho pesado numa fila e deixa workers concluírem a tarefa em segundo plano, sem travar a tela.

Pontos-chave

O que você leva deste artigo

  1. Processamento assíncrono: o que é e por que tirar trabalho da requisiçãoProcessamento 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, po…Ir para a seção
  2. Filas de tarefas e workers: como as peças se encaixamUma 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.Ir para a seção
  3. Quais tarefas devem sair da requisiçãoDevem 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.Ir para a seção
  4. Falhas, repetições e idempotência: o que a fila não resolve sozinhaUma 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.Ir para a seção
  5. Como dimensionar e acompanhar workers e filasUma 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.Ir para a seção
  6. Passo a passo para introduzir filas num sistema que já está no arIntroduzir 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.Ir para a seção

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.

Imagem ilustrativa: computação e IA

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.

Imagem ilustrativa: dados em óculos

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

  1. Mapear: liste o que acontece dentro de cada requisição e quanto tempo cada trecho consome.
  2. Escolher: selecione uma tarefa lenta, importante e que o usuário não precisa ver concluída na hora.
  3. Tornar idempotente: garanta que repetir a tarefa não duplique cobranças, e-mails ou registros.
  4. Enfileirar: troque a execução direta por um envio à fila, passando apenas identificadores e não objetos inteiros.
  5. Medir: acompanhe tamanho da fila, tempo de espera e falhas desde o primeiro dia.
  6. 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.

Perguntas frequentes

O que é processamento assíncrono?

É executar uma tarefa fora do momento do pedido do usuário. O sistema responde logo, coloca o trabalho pesado numa fila e um worker o conclui depois, em segundo plano. Quem envia e quem recebe não precisam interagir ao mesmo tempo.

O que é um worker?

Worker é um processo dedicado que observa a fila de tarefas e executa cada trabalho que chega. É possível ter vários workers em paralelo e aumentar a quantidade conforme a demanda, sem alterar a parte do sistema que atende o usuário.

Quais tarefas devem ir para uma fila?

As que demoram, dependem de serviços externos ou não precisam estar concluídas para o usuário seguir: e-mails, conversão de arquivos, relatórios, integrações e recálculos. Validações e gravação do dado principal continuam dentro da requisição.

O que é idempotência e por que importa nas filas?

Uma tarefa idempotente gera o mesmo resultado final mesmo executada 2 ou mais vezes. Importa porque muitas filas entregam a mensagem pelo menos uma vez, então repetições acontecem e não podem duplicar cobranças ou registros.

O que fazer com tarefas que falham sempre?

Defina um limite de tentativas e envie o que continuar falhando para uma fila separada, de mensagens com falha. Assim a equipe examina o conteúdo e os logs, descobre a causa e evita que o erro trave o restante do fluxo.

Uma fila resolve qualquer sistema lento?

Não. A fila ajuda quando o peso vem de trabalho que pode esperar. Se a lentidão vem de uma consulta mal escrita no banco de dados ou de leituras repetidas, o caminho passa por revisar consultas ou usar cache.

Método

Como a Trilion conduz um projeto de alta performance

Do briefing à operação, em 5 etapas e com tudo por escrito. A proposta vem depois do briefing e o valor depende de escopo, integrações, volume e prazo.

  1. Briefing em 3 passos

    Você conta o que precisa construir; nós devolvemos perguntas e um caminho possível.

  2. Desenho por escrito

    Diagnóstico dos gargalos, metas de desempenho, arquitetura e plano de testes, antes de qualquer alteração.

  3. Construção em fatias

    Mudanças pequenas e medidas, com comparação antes e depois em cada fatia.

  4. Testes e homologação

    Casos do dia a dia da sua operação, com plano de retorno antes de publicar.

  5. Operação e evolução

    Acompanhamento combinado na proposta e ajustes guiados por indicadores.

Vamos deixar o seu sistema à altura da sua operação

Conte o que precisa resolver. A Trilion responde com uma proposta escrita, depois do briefing, e leva o projeto do código à operação.

Falar no WhatsApp
Blog da Trilion · Inteligência artificial

Continue aprendendo sobre IA

Artigos do blog da Trilion que aprofundam os temas deste texto. Arraste, use as setas ou o teclado.

WhatsApp
WhatsApp

Converse com a Trilion

Diga-nos o seu nome, e a conversa abre em seguida