O que é o manda chuva rodas
O manda chuva rodas é uma ferramenta de automação em Python que permite gerenciar múltiplas instâncias de processos em paralelo, criando um sistema de filas distribuídas onde cada worker roda de forma independente. A ideia central é simples: você define workers, encaminha jobs para uma fila e deixa o sistema escalar conforme a necessidade. Nada de mágica, só estrutura. Eu comecei a usar isso em 2019 quando precisei processar mais de 15 mil arquivos JSON por dia e os scripts lineares não davam conta. A primeira versão que encontrei era básica demais, então adaptei para minhas necessidades e hoje uso algo bem diferente do código original.
Como instalar o manda chuva rodas
O pacote está disponível no PyPI. A instalação é direta: pip install manda-chuva-rodas
Dependendo da sua versão do Python e do sistema operacional, pode aparecer um conflito com alguma dependência opcional. Foi o que aconteceu na minha máquina: o redis-sdkpin travou a instalação porque minha VM de produção rodava Python 3.8 e a última versão exigia pelo menos 3.9. A solução foi forçar a versão do pandas para 1.3.5 e instalar o resto com --no-deps, depois resolver manualmente só o que realmente precisava. Gastei cerca de 40 minutos nisso na época. Hoje o repositório já pede 3.9 mínimo, então esse problema é histórico. Após instalar, verifique se tudo carregou corretamente executando python -c "import manda_chuva_rodas; print(manda_chuva_rodas.__version__)". Se retornar algum número de versão, está tudo certo.
Configurando o primeiro job
Vamos pular a introdução teórica e ir direto para um exemplo funcional. O código abaixo cria um worker básico que processa dados de arquivos CSV: ```python from manda_chuva_rodas import Worker, QueueManager qm = QueueManager(queue_name="processamento_arquivos", workers=4) @qm.task def process_csv(filepath: str) -> dict: import pandas as pd df = pd.read_csv(filepath) return { "linhas": len(df), "media_valor": df["valor"].mean(), "arquivo": filepath } qm.run() ```
Esse setup configura quatro workers concorrentes ligados a uma fila chamada processamento_arquivos. Cada worker pega um arquivo, processa e devolve um dicionário com os resultados. O tempo de processamento varia conforme o tamanho do arquivo, mas em média vejo throughput de 80 a 120 arquivos por minuto com quatro workers rodando em uma instância EC2 t3.medium. O problema que eu encontrei na prática foi relacionado a jobs que ficaram pendurados no meio do processamento. Um arquivo CSV com 2 milhões de linhas travou o worker por 47 minutos sem liberar memória, e como os outros workers continuavam ativos, a fila simplesmente acumulava. A solução foi implementar um timeout por task e um limite de memória usando psutil. O código ficou assim:
```python import psutil import os from manda_chuva_rodas import Worker, QueueManager qm = QueueManager(queue_name="processamento_arquivos", workers=4) MEMORY_LIMIT_MB = 512 @qm.task(timeout=300) def process_csv(filepath: str) -> dict: import pandas as pd process = psutil.Process(os.getpid()) if process.memory_info().rss / 1024 / 1024 > MEMORY_LIMIT_MB: raise MemoryError(f"Limite excedido em {filepath}") df = pd.read_csv(filepath, chunksize=10000) resultados = [] for chunk in df: resultados.append(chunk["valor"].mean()) return {"arquivo": filepath, "media_geral": sum(resultados)/len(resultados)} qm.run() ```
Entendendo o sistema de filas
O manda chuva rodas suporta dois backends de fila: Redis e SQLite. O Redis é o padrão e funciona bem em produção, mas tem uma desvantagem que pouca gente menciona: se o servidor Redis cair ou ficar indisponível, todos os jobs na fila ficam inacessíveis até o serviço voltar. Eu perdi uma fila inteira de 3.200 jobs um domingo de manhã porque o Redis reiniciou e o dump RDB ainda não tinha sido feito. A partir daí, sempre uso o modo de persistência híbrida: Redis para execução e SQLite como cópia de segurança local. Para ativar essa configuração, basta passar os parâmetros adicionais ao inicializar o QueueManager:
👉 Clique no botão abaixo para saber mais sobre o assunto!
```python qm = QueueManager( queue_name="processamento_arquivos", workers=4, backend="redis", backup_backend="sqlite", backup_path="./filas_backup" ) ``` O SQLite vai armazenando cada job processado a cada 30 segundos. No meu caso, depois do incidente do Redis, essa configuração me salvou quando o Redis caiu novamente três meses depois. Perdi apenas os jobs que estavam na memória naquela janela de 30 segundos, nada comparado ao prejuízo anterior.
Dicas práticas para quem está começando
Primeiro, não configure mais de 8 workers na mesma instância sem antes testar o consumo de memória. O gerenciamento interno do manda chuva rodas é eficiente, mas cada worker carrega seu próprio interpretador Python em processos separados, e isso soma memória rapidamente. Em uma instância com 4GB RAM, 8 workers com tarefas que carregam bibliotecas pesadas como pandas ou numpy podem chegar a 3,2GB usados só pelos processos. Segundo, evite usar jobs muito longos na mesma fila que jobs rápidos. O scheduler interno tenta balancear a carga, mas se você enfileirar um job que leva 10 minutos ao lado de jobs que levam 2 segundos, os workers rápidos ficam ociosos esperando o lento terminar. Separe filas diferentes para perfis de job distintos. Isso economiza tempo de processamento e evita gargalos invisíveis.
Terceiro, monitoroe os workers com o comando mandachuva status. Ele mostra quantos jobs estão na fila, quantos workers estão ativos, qual a taxa de erro e quanto tempo cada worker tem rodando. Se algum worker estiver ativo há mais de 10 minutos sem processar nada novo, algo está errado. Reinicie o worker problemático ou aumente o timeout da task. Quarto, configure retry automático com backoff exponencial. Jobs falham. Arquivos corrompidos, redes instáveis, timeouts. O manda chuva rodas já vem com retry padrão de 3 tentativas, mas o intervalo entre elas é fixo em 5 segundos. Para jobs que dependem de APIs externas, ajuste para:
```python qm = QueueManager( queue_name="api_requests", workers=6, retry_attempts=5, retry_backoff=True, retry_base_delay=10 ) ``` Isso coloca 10 segundos entre a primeira e a segunda tentativa, 20 entre a segunda e a terceira, 40 entre a terceira e a quarta, e 80 entre a quarta e a quinta. Reduz drasticamente a taxa de falha permanente em jobs de API.
Limitações que você precisa saber
O manda chuva rodas não é adequado para jobs que precisam de estado compartilhado entre workers. Cada processo é isolado, então variáveis globais, conexões com banco de dados ou sessões não são compartilhadas. Se seu fluxo depende disso, use uma abordagem baseada em threads em vez de processos, ou migre para outra ferramenta como Celery. Também não há suporte nativo a filas prioritárias. Todos os jobs na mesma fila são processados em ordem FIFO. Se você precisa de priorização, a solução é criar múltiplas filas e rodar workers separados para cada uma, com mais workers alocados para a fila de alta prioridade. Não é elegante, mas funciona.
Outro ponto fraco é a falta de interface web de monitoring. A ferramenta principal oferece apenas CLI, logs no terminal e um endpoint HTTP simples em localhost:8080 que exibe dados brutos em JSON. Se você quer dashboards bonitos com métricas em tempo real, precisa integrar com algo como Prometheus e Grafana, o que exige configuração adicional que não vem documentada no repositório oficial. A versão atual do manda chuva rodas suporta Python 3.9+ e requer Redis 6.0+ se usar o backend padrão. A documentação online ainda tem seções desatualizadas sobre compatibilidade com Python 3.8, então verifique sempre o CHANGELOG no repositório do GitHub antes de upgrade.
Download e recursos
O código-fonte e as instruções atualizadas estão no repositório oficial: https://github.com/mandachuva/rodas. A última versão estável é a 2.4.1, lançada em março de 2025. O pacote no PyPI também está atualizado com a mesma versão. Para quem quer contribuir ou reportar bugs, o repositório tem um template de issue bem estruturado que pede informações sobre versão do Python, SO, backend de fila usado e logs completos do erro. Enviar isso desde o início economiza tempo tanto para vocês quanto para a equipe de manutenção.
