Publicado em
Como rodar scripts diários na nuvem pagando só pelos minutos?
Use um serviço de job agendado: você define o horário com uma expressão cron, a plataforma inicia o script, ele termina e você paga só o tempo em que rodou. Na Zenifra, um script de 2 minutos por dia no plano job-basic custa R$ 0,05 (R$ 0,049999998 exatos) por mês, em real e sem IOF; este guia compara o mesmo script no GitHub Actions, Cloudflare Workers, Google Cloud Run Jobs, AWS Lambda, Render e Railway, com as fontes oficiais lidas em 06/11/2026.
A resposta curta: o que muda quando você paga por minuto
Para rodar um script todo dia sem manter um servidor ligado, use um job agendado: a plataforma lê uma expressão cron, inicia o seu código no horário, espera ele terminar e cobra só pelo tempo de execução. Na Zenifra isso se chama Job agendado, é cobrado por minuto em real e pode partir de uma imagem Docker ou de um repositório do GitHub.
A diferença de custo para uma aplicação sempre ligada é grande quando o trabalho é curto. Um script de 2 minutos por dia roda 60 minutos no mês. No plano job-basic da Zenifra (0,5 vCPU e 512 MB), cada minuto custa R$ 0,0008333333, então o mês inteiro sai por R$ 0,05. Uma aplicação no plano Basic, com os mesmos 0,5 vCPU e 512 MB, custa R$ 29,90 por mês no contrato mensal porque fica ligada 24 horas por dia esperando o próximo horário.
Pagar por minuto não é exclusividade da Zenifra. GitHub Actions, Cloudflare Workers, Google Cloud Run, AWS Lambda, Render e Railway também cobram por uso, e alguns têm faixas gratuitas que zeram scripts pequenos. O que muda entre eles é a moeda, o limite de duração de cada execução, o menor intervalo entre execuções e o tipo de código aceito. As seções abaixo mostram esses limites e a conta de três cenários em cada plataforma, para você escolher com números e não com impressão.
Todos os preços em dólar foram lidos nas páginas oficiais em 06/11/2026 e convertidos pela PTAX de venda de 05/11/2026 (R$ 5,4621), com IOF de 3,5% sobre compras internacionais no cartão (Decreto 6.306/2007, art. 15-B, inciso VII, na redação do Decreto 12.499/2025). Os preços da Zenifra vêm do catálogo público de planos de Job, consultado no mesmo dia.
Que tarefas fazem sentido como job agendado
O critério é simples: a tarefa começa, faz um trabalho finito e termina. Se ela precisa ficar escutando requisições ou uma fila o tempo todo, é uma aplicação ou um worker contínuo, não um job. Se ela roda em horários conhecidos e sai com um código de saída, é um job, e pagar por minuto costuma ser a forma mais barata de hospedá-la.
Os casos mais comuns em times pequenos são os da lista abaixo. Em todos eles o padrão é o mesmo: ler a configuração de variáveis de ambiente, fazer o trabalho, registrar o resultado nos logs e encerrar com código 0 quando deu certo ou com outro código quando falhou, para que a plataforma marque a execução como falha e avise você.
- Backup lógico: exportar o banco com pg_dump ou mysqldump e enviar o arquivo para um armazenamento de objetos compatível com S3, como o Armazém da Zenifra, toda madrugada.
- Relatório: consultar o banco, gerar um CSV ou PDF com as vendas do dia anterior e enviar por e-mail ou para uma pasta compartilhada.
- Sincronização: buscar pedidos, estoque ou cadastros em uma API externa a cada hora e atualizar a sua base.
- Coleta de dados (scraping): visitar páginas públicas em horários fixos, extrair preços ou status e guardar o histórico, respeitando os termos de uso e o robots.txt de cada site.
- Envio de e-mails em lote: lembretes de vencimento, resumos semanais ou avisos de inatividade disparados em um horário definido.
- Manutenção: apagar sessões e arquivos temporários antigos, recalcular caches, gerar sitemaps ou chamar uma rota interna da sua aplicação que executa uma rotina.
Tarefas que precisam rodar mais de 60 minutos de uma vez, ou que dependem de reagir em segundos a um evento, pedem outra arquitetura: dividir o trabalho em partes menores, usar uma fila com um worker ou escolher uma plataforma com limite de duração maior. Essas trocas aparecem na comparação mais abaixo.
Como funcionam os Jobs agendados da Zenifra
Um Job agendado é um tipo de projeto na Zenifra. Você escolhe a origem da tarefa (uma imagem Docker ou um repositório do GitHub), escreve uma expressão cron de cinco campos e a Zenifra inicia a tarefa em cada horário. O horário é sempre interpretado em UTC, e o Console mostra os próximos horários de execução logo abaixo da expressão para você conferir antes de criar. Não existe opção de fuso horário: para 00:00 de Brasília (UTC−3), use 03:00 UTC.
As regras de execução são explícitas na documentação. Cada Job roda no máximo uma execução por vez: se o próximo horário chegar com a anterior ainda em andamento, esse horário é pulado, sem fila. Uma execução que não termina em 60 minutos é encerrada como Tempo limite excedido. Não há nova tentativa automática: se falhar, a próxima execução acontece no próximo horário. Código de saída 0 significa Concluída; qualquer outro código significa Falhou.
Cada execução fica registrada no card Execuções da página do projeto, com horário agendado, status, duração e minutos cobrados. Em Ver logs você lê o que a tarefa escreveu, inclusive depois que ela termina, falha ou é cancelada; a Zenifra guarda os últimos 50 KB de log de cada execução. No plano job-premium, Ver métricas mostra CPU e memória de cada execução. Todo Job nasce com alertas por e-mail ligados: o dono da organização recebe um aviso quando uma execução falha, estoura a memória do plano ou passa dos 60 minutos, com no máximo um e-mail por hora enquanto as falhas continuarem.
Com origem no GitHub, a Zenifra faz o build do código no runtime escolhido (Node.js, Python, Bun, Go, Java ou PHP) e usa o resultado em todas as execuções. O tempo de build não é cobrado, e um build novo vale para as próximas execuções sem interromper a que está rodando. Pelo Console, a imagem Docker precisa ser pública e o comando é o padrão da própria imagem; imagem privada e comando ou argumentos personalizados ficam disponíveis pela API.
| Plano | vCPU | Memória | Armazenamento efêmero | Preço por minuto | 60 minutos de execução | Métricas por execução |
|---|---|---|---|---|---|---|
| job-starter | 0,1 | 128 MB | 1 GB | R$ 0,0001666666 | R$ 0,009999996 | Não |
| job-basic | 0,5 | 512 MB | 5 GB | R$ 0,0008333333 | R$ 0,049999998 | Não |
| job-premium | 1 | 1 GB | 5 GB | R$ 0,0018333333 | R$ 0,109999998 | Sim |
O catálogo publica o preço em centavos de real (0,01666666, 0,08333333 e 0,18333333 centavos por minuto); a tabela mostra os mesmos valores em reais, sem arredondamento. Os três planos têm até 60 minutos por execução, agendamento em UTC, logs de cada execução e armazenamento persistente opcional, cobrado à parte por GB-hora. O guia de planos recomenda o job-starter para chamadas curtas e scripts shell, o job-basic para scripts Node.js ou Python com dependências e acesso a banco, e o job-premium para relatórios, exportações e backups lógicos.
Como os minutos viram valor na fatura
A cobrança considera o início e o fim reais da tarefa. O tempo de preparação, como o download da imagem, não entra na conta, e uma execução que nunca chegou a iniciar não gera cobrança. A duração é arredondada para o minuto cheio seguinte, com mínimo de 1 minuto e máximo de 60, e o valor de cada execução é guardado exato, sem arredondar para cima: uma execução que custa R$ 0,0005 é cobrada como R$ 0,0005.
Execuções que falharam, foram canceladas depois de iniciar ou excederam o tempo limite cobram o tempo efetivamente usado. Quando você cancela uma execução pelo Console, a Zenifra dá até 30 segundos para a tarefa encerrar de forma graciosa, e esses segundos de encerramento não são cobrados: a conta vai só até o momento em que você confirmou o cancelamento.
No fechamento do ciclo, o total das execuções é descontado primeiro do saldo da organização; o que faltar é cobrado no cartão em centavos inteiros, e a fração de centavo que sobrar passa para o ciclo seguinte. Por isso um Job de R$ 0,05 por mês não vira uma cobrança arredondada de R$ 0,05 a cada ciclo. A organização pode pagar por PIX, boleto ou cartão, sempre em real, então não há câmbio nem IOF.
| Duração real da execução | Minutos cobrados | Valor no job-basic |
|---|---|---|
| 1 segundo | 1 | R$ 0,0008333333 |
| 59 segundos | 1 | R$ 0,0008333333 |
| 70 segundos | 2 | R$ 0,0016666666 |
| 60 minutos | 60 | R$ 0,05 |
O card Custo do ciclo atual soma os valores das execuções concluídas no ciclo, com a quantidade de execuções e de minutos. Na data de cobrança, a lista de execuções, o custo, os logs e as métricas exibidos recomeçam do zero; os registros ficam guardados internamente por até 90 dias. O armazenamento efêmero de cada execução não tem cobrança extra, mas é apagado no fim; só o armazenamento persistente, quando ativado, é cobrado por GB-hora enquanto o projeto existir, mesmo pausado.
GitHub Actions, Cloudflare, Cloud Run, Lambda, Render e Railway: os limites de cada um
Antes do preço, vale olhar o que cada serviço aceita, porque um limite de duração ou de memória elimina uma opção antes de qualquer conta. A tabela resume as páginas oficiais de preço e de limites lidas em 06/11/2026. Os valores estão em dólar; a conversão para real aparece na próxima seção.
GitHub Actions e Render executam um processo comum, como um script Python ou Node.js, e aceitam imagens de contêiner. Cloud Run Jobs executa uma imagem de contêiner. AWS Lambda executa uma função em um runtime gerenciado ou a partir de uma imagem, com memória de 128 MB a 10.240 MB e CPU proporcional à memória. Cloudflare Workers executa código no runtime dos Workers, com 128 MB de memória por isolate, e cobra principalmente tempo de CPU, não o tempo de relógio.
| Serviço | Como cobra | Uso incluído sem custo | Duração máxima por execução | Agendamento |
|---|---|---|---|---|
| GitHub Actions (runner Linux de 2 núcleos) | US$ 0,006 por minuto em repositório privado, com cada job arredondado para o minuto cheio | Repositórios públicos não pagam runners padrão; o plano Free inclui US$ 12 de uso por mês (2.000 minutos Linux) | 6 horas por job | Cron POSIX em UTC, com fuso IANA opcional; intervalo mínimo de 5 minutos; pode atrasar em horários de pico, e jobs na fila podem ser descartados |
| Cloudflare Workers com Cron Triggers | Plano Paid com mínimo de US$ 5 por mês; acima do incluído, US$ 0,02 por milhão de ms de CPU e US$ 0,30 por milhão de requisições | Paid: 10 milhões de requisições e 30 milhões de ms de CPU por mês; Free: 5 Cron Triggers e 10 ms de CPU por invocação | 15 minutos de CPU para intervalos de 1 hora ou mais; 30 segundos para intervalos menores | Até 250 Cron Triggers por conta no Paid |
| Google Cloud Run Jobs com Cloud Scheduler | US$ 0,000018 por vCPU-segundo e US$ 0,000002 por GiB-segundo (us-central1), em frações de 100 ms; Scheduler a US$ 0,10 por job a cada 31 dias | 240.000 vCPU-segundos e 450.000 GiB-segundos por mês por conta de faturamento; 3 jobs do Scheduler por conta | 10 minutos por padrão, configurável até 168 horas | O horário fica no Cloud Scheduler, cobrado por job |
| AWS Lambda com EventBridge Scheduler | US$ 0,0000166667 por GB-segundo e US$ 0,20 por milhão de requisições; Scheduler a US$ 1,00 por milhão de invocações | 1 milhão de requisições e 400.000 GB-segundos por mês; 14 milhões de invocações do Scheduler | 15 minutos (900 segundos) | O horário fica no EventBridge Scheduler |
| Render Cron Jobs (0.5c-512mb) | US$ 0,00016 por minuto, proporcional por segundo; mínimo de US$ 1 por mês por cron job | Não há uso gratuito para cron jobs | 12 horas | Cron em UTC; no máximo uma execução ativa por vez |
| Railway (serviço com cron) | Por uso: US$ 0,000463 por vCPU-minuto e US$ 0,000231 por GB-minuto de RAM; Hobby US$ 5 por mês, que viram crédito de uso | Plano Free com US$ 1 de crédito por mês | Não encerra a execução sozinho; se a anterior ainda estiver ativa, a próxima é pulada | Cron em UTC, com pelo menos 5 minutos entre execuções |
| Zenifra Jobs agendados (job-basic) | R$ 0,0008333333 por minuto, arredondado para o minuto cheio, em real | Não há uso gratuito; cobra só os minutos executados | 60 minutos | Cron de cinco campos em UTC; uma execução por vez; sem nova tentativa automática |
Dois detalhes pesam na escolha. No GitHub Actions, a própria documentação avisa que o evento schedule pode atrasar em períodos de carga alta, principalmente no início de cada hora, e que alguns jobs na fila podem ser descartados; em repositório público, workflows agendados são desativados depois de 60 dias sem atividade. Por outro lado, o GitHub aceita fuso horário IANA no cron, o que a Zenifra, o Render e o Railway não oferecem.
Os preços do Cloud Run usados aqui são os de us-central1 (Iowa), a região de referência da tabela; a página mostra que outras regiões, como São Paulo (southamerica-east1), têm faixa de preço própria. No Lambda, o valor por GB-segundo é o do exemplo da página de preços; outras regiões também têm preço diferente.
- GitHub: cobrança do GitHub Actions
- GitHub: preço por minuto dos runners
- GitHub: evento schedule
- GitHub: limites do Actions
- Cloudflare: preços do Workers
- Cloudflare: limites do Workers
- Google Cloud: preços do Cloud Run
- Google Cloud: tempo limite de tarefas
- Google Cloud: preços do Cloud Scheduler
- AWS: preços do Lambda
- AWS: limites do Lambda
- AWS: preços do EventBridge
- Render: cron jobs
- Render: preços
- Railway: cron jobs
- Railway: planos e preços
Quanto custa cada cenário em cada plataforma
Os três cenários usam um mês de 30 dias. Cenário A: um script de 2 minutos uma vez por dia (30 execuções, 60 minutos no mês). Cenário B: um script de 15 minutos a cada hora (720 execuções, 10.800 minutos). Cenário C: um script de 1 hora por dia (30 execuções, 1.800 minutos). Para comparar recursos parecidos, usamos 0,5 vCPU e 512 MB onde o serviço permite escolher, 1 vCPU e 512 MiB no Cloud Run e 512 MB no Lambda. No Cloudflare, supomos o pior caso: o script usa CPU o tempo inteiro.
Os valores em real usam a PTAX de 05/11/2026 (R$ 5,4621) e IOF de 3,5%. Quando a faixa gratuita cobre o cenário, o custo aparece como zero, mas lembre que essa faixa é por conta e é dividida com tudo o que você já roda nela.
| Plataforma e configuração | A: 2 min por dia | B: 15 min por hora | C: 1 h por dia |
|---|---|---|---|
| Zenifra job-basic (0,5 vCPU, 512 MB) | R$ 0,05 | R$ 8,99999964 | R$ 1,50 (R$ 1,49999994 exatos), em duas execuções de 30 min |
| Zenifra job-starter (0,1 vCPU, 128 MB) | R$ 0,009999996 | R$ 1,79999928 | R$ 0,30 (R$ 0,29999988 exatos), em duas execuções de 30 min |
| GitHub Actions, repositório privado, plano Free | US$ 0 (US$ 0,36 dentro dos US$ 12 incluídos) | US$ 52,80 além do incluído = R$ 298,49 | US$ 0 (US$ 10,80 dentro dos US$ 12 incluídos) |
| Cloudflare Workers Paid, CPU o tempo todo | US$ 5,00 = R$ 28,27 | US$ 17,36 = R$ 98,14 | Não cabe: máximo de 15 min por execução |
| Cloud Run Jobs, 1 vCPU e 512 MiB, us-central1 | US$ 0 (faixa gratuita) | US$ 7,34 = R$ 41,52 | US$ 0 (faixa gratuita) |
| AWS Lambda, 512 MB, com EventBridge Scheduler | US$ 0 (faixa gratuita) | US$ 0 na faixa gratuita; US$ 5,40 = R$ 30,53 sem ela | Não cabe: máximo de 15 min por invocação |
| Render Cron Job 0.5c-512mb | US$ 1,00 (mínimo) = R$ 5,65 | US$ 1,73 = R$ 9,77 | US$ 1,00 (mínimo) = R$ 5,65 |
| Railway Hobby, 0,5 vCPU e 0,5 GB em uso | US$ 5,00 de assinatura (uso de US$ 0,02) = R$ 28,27 | US$ 5,00 de assinatura (uso de US$ 3,75) = R$ 28,27 | US$ 5,00 de assinatura (uso de US$ 0,62) = R$ 28,27 |
Leitura honesta da tabela: se o script já vive em um repositório público, o GitHub Actions roda os cenários sem custo, desde que você aceite atrasos no horário. Se você já tem conta na AWS ou no Google Cloud e a faixa gratuita está livre, os cenários A e C saem a zero no Cloud Run, e o A também no Lambda. O Render é barato para cenários com muito uso, mas cobra o mínimo de US$ 1 por cron job; o Railway faz sentido quando a assinatura de US$ 5 já paga outros serviços seus.
Na Zenifra, os três cenários ficam abaixo de R$ 9 por mês no job-basic e abaixo de R$ 2 no job-starter, sem faixa gratuita para acompanhar, sem cartão internacional e sem variação de câmbio. O cenário B é onde a diferença aparece: 10.800 minutos custam R$ 9,00 (R$ 8,99999964 exatos) no job-basic, contra R$ 41,52 no Cloud Run depois da faixa gratuita e R$ 298,49 no GitHub Actions privado.
O cenário C mostra o limite da Zenifra. Uma execução tem no máximo 60 minutos, então um script que leva 1 hora fica no limite e pode ser encerrado como Tempo limite excedido. O caminho seguro é dividir o trabalho em duas execuções de 30 minutos, com o mesmo custo total; se a tarefa precisa de várias horas seguidas, Cloud Run Jobs (até 168 horas), Render (12 horas) ou GitHub Actions (6 horas) atendem melhor.
Passo a passo: criar um Job pelo Console ou pela CLI
O fluxo abaixo é o da documentação de Jobs agendados. Antes de começar, tenha a referência completa de uma imagem Docker pública, com registro e tag ou digest (por exemplo, docker.io/library/alpine:3.20), ou um repositório no GitHub com o comando que executa a tarefa. Nos dois casos, a tarefa precisa terminar sozinha: uma imagem de servidor web, que fica esperando requisições, sempre acaba em Tempo limite excedido.
- 1. No menu do Console, clique em Criar projeto e escolha Job agendado.
- 2. Escolha o plano. Cada plano mostra vCPU, memória, armazenamento e o preço por minuto.
- 3. Em Informações Básicas, dê um nome ao projeto.
- 4. Em Configurar Job agendado, escolha a Origem da tarefa: Imagem Docker (informe a Imagem da tarefa) ou Repositório GitHub (escolha repositório, Branch, Runtime, Versão, Diretório raiz e Comando da tarefa).
- 5. Preencha a Expressão cron, em UTC, e confira os Próximos horários de execução (UTC) que o Console mostra logo abaixo.
- 6. Defina o Armazenamento da tarefa. Se a tarefa precisa guardar arquivos de uma execução para outra, ative Manter dados entre execuções e informe o Diretório persistente, por exemplo /data.
- 7. Em Variáveis de Ambiente, adicione chaves, endereços e senhas que a tarefa usa.
- 8. Confira o Resumo de Custos e clique em Criar Job.
zenifra plans --type jobs
zenifra create project --name nightly-report --plan job-basic --payment-mode per_minute --config @examples/job-project.json
zenifra project runs --project <project-id>
zenifra project runs logs --project <project-id> --run <run-id>O Console não pede porta, domínio nem instâncias, porque um Job roda, termina e espera o próximo horário. Com origem no GitHub, o primeiro build acontece na criação e o Job começa a executar nos horários depois que ele termina; o Modo de deploy define se os builds seguintes são manuais, a cada push na branch, por tag ou por release.
Pela CLI, consulte os planos com zenifra plans --type jobs e crie o Job a partir de um arquivo de configuração: zenifra create project --name nightly-report --plan job-basic --payment-mode per_minute --config @examples/job-project.json. Depois, acompanhe com zenifra project runs --project <project-id>, leia os logs de uma execução com zenifra project runs logs --project <project-id> --run <run-id> e cancele com zenifra project runs cancel. A CLI aceita só a origem por imagem; para GitHub, imagem privada ou comando personalizado, use a API de Jobs agendados.
Exemplo: script Python diário e expressões cron em UTC
O repositório público de exemplos da Zenifra tem Jobs prontos em Node.js, Bun e Python. O exemplo em Python é um verificador de disponibilidade que usa só a biblioteca padrão: lê as URLs de uma variável de ambiente, faz as requisições com tempo limite e novas tentativas, guarda o estado entre execuções no diretório persistente e define o código de saída conforme o resultado. Ele também trata o sinal de encerramento, para terminar de forma limpa quando uma execução é cancelada ou pausada.
Para publicá-lo, crie um Job com origem Repositório GitHub e preencha os campos como no README do exemplo. Rodar localmente antes é o teste mais barato que existe: com TARGET_URLS=https://example.com python -m uptime_job você vê os mesmos logs que vai ler depois em Ver logs.
- Diretório raiz: python (ou . se a pasta for a raiz do repositório)
- Runtime: Python, versão 3.11 ou mais recente
- Comando da tarefa: python -m uptime_job
- Variável de ambiente: TARGET_URLS com as URLs a verificar
| Quando executar | Horário de Brasília | Expressão cron (UTC) |
|---|---|---|
| Todo dia à meia-noite | 00:00 | 0 3 * * * |
| Todo dia às 6 da manhã | 06:00 | 0 9 * * * |
| De segunda a sexta às 9:30 | 09:30 | 30 12 * * 1-5 |
| A cada 15 minutos | Qualquer hora | */15 * * * * |
| Todo dia 1º do mês às 3 da manhã | 03:00 | 0 6 1 * * |
A expressão aceita valores, *, listas com vírgula, intervalos com hífen, passos com barra, nomes de mês e de dia da semana em inglês (jan, mon) e ? no dia do mês ou no dia da semana. O dia da semana vai de 0 (domingo) a 6; 7, L, W, # e H não são aceitos. No Repositório GitHub, a Zenifra executa o Comando da tarefa diretamente para que o processo receba o aviso de encerramento; em comandos com | ou ||, esse aviso não chega, então prefira chamar um script.
Boas práticas para jobs confiáveis
Idempotência vem primeiro. Como a Zenifra não repete uma execução que falhou e pula horários quando a anterior ainda está rodando, o script precisa produzir o mesmo resultado se rodar duas vezes sobre os mesmos dados, e precisa conseguir retomar o que ficou para trás. Na prática: grave um marcador do último item processado (no banco ou no diretório persistente), use chaves únicas para não inserir o mesmo registro duas vezes e nomeie arquivos de backup pela data, para que uma segunda execução substitua o arquivo em vez de duplicá-lo.
Defina tempo limite em tudo o que sai da máquina. Uma chamada HTTP sem timeout pode prender a execução até os 60 minutos e virar Tempo limite excedido, cobrando a hora inteira. Coloque timeouts curtos nas requisições e no banco, e faça poucas novas tentativas dentro do próprio script, com espera crescente entre elas, só para erros temporários como 429, 503 ou queda de conexão. Erros definitivos, como credencial inválida, devem encerrar o script com código diferente de zero para disparar o alerta por e-mail.
Segredos ficam em variáveis de ambiente, nunca no código nem na imagem. Senhas de banco, chaves de API e tokens entram em Variáveis de Ambiente no Console; a mudança vale a partir da próxima execução, sem rebuild. Dê a cada chave só a permissão necessária: o exemplo da documentação que pausa os projetos de um time usa uma chave de API com Visualizar projeto e Parar projeto, e nada além disso.
Escreva logs úteis e curtos. A Zenifra guarda os últimos 50 KB de cada execução, então registre início, quantidade processada, erros com contexto e fim, em vez de imprimir cada linha de dados. Comece no menor plano em que a tarefa termina sem faltar memória e observe: logs que param de repente sem mensagem indicam falta de memória; uma execução longa e presa na CPU pode terminar em menos minutos, e custar menos, num plano maior.
Quando usar um worker contínuo em vez de um job agendado?
Use um worker contínuo quando a tarefa precisa reagir a eventos a qualquer momento, como processar uma fila assim que uma mensagem chega, e use um job agendado quando o trabalho acontece em horários conhecidos. O guia de planos da Zenifra diz isso de forma direta: um worker que precisa ficar escutando uma fila o tempo todo deve ser um projeto HTTP ou usar Filas.
A conta ajuda a decidir. O preço por minuto do job-basic, R$ 0,0008333333, equivale a R$ 0,049999998 por hora de execução, praticamente o mesmo valor por hora do plano Basic de aplicação (R$ 0,05 por hora, com 0,5 vCPU e 512 MB). Enquanto o script roda só uma fração do dia, o Job sai mais barato porque não paga as horas paradas. Se ele passaria a rodar quase o dia inteiro, um worker no plano Basic com contrato mensal (R$ 29,90) ou no Static (R$ 5,90, com 0,1 vCPU e 128 MB) fica mais previsível.
Onde hospedar um worker em Python com cobrança por hora no Brasil?
Na Zenifra, um worker em Python roda como projeto HTTP privado, sem rota pública, com cobrança por hora em real: a partir de R$ 0,05 por hora no plano Basic (0,5 vCPU, 512 MB), segundo o catálogo público; o Static é para sites estáticos. Na cobrança por hora, o total de horas do projeto no ciclo é arredondado para cima, para a hora cheia, e o projeto pausado não cobra processamento.
A documentação tem um exemplo completo: um worker que consome mensagens de uma Fila Valkey gerenciada com BLPOP, publicado a partir de um repositório Git com runtime Python 3.13, Comando Start python worker.py, Exposição Privado - sem rota pública e a variável VALKEY_URL com a conexão da Fila. Para mensagens que não podem se perder se o worker parar no meio, a própria documentação recomenda Streams com consumer groups.
Quanto custa o Job agendado mais barato da Zenifra?
O job-starter, com 0,1 vCPU e 128 MB, custa R$ 0,0001666666 por minuto de execução, e só os minutos executados são cobrados; não há mensalidade nem uso gratuito incluído.
Na prática, o custo de entrada é pequeno: os 60 minutos que o cenário A usa no job-starter em um mês inteiro custam R$ 0,009999996, menos de um centavo. O cadastro pede CPF ou CNPJ, celular e endereço no Brasil, e o pagamento pode ser feito por PIX, boleto ou cartão, em real.
Posso usar o horário de Brasília no cron?
Não diretamente: na Zenifra a expressão cron é sempre interpretada em UTC, então você converte o horário. Brasília está em UTC−3, logo 00:00 de Brasília é 03:00 UTC (0 3 * * *) e 18:00 de Brasília é 21:00 UTC (0 21 * * *).
O Console mostra os Próximos horários de execução em UTC antes de você criar o Job, o que evita erro de conversão. Render e Railway também usam UTC. O GitHub Actions é a exceção entre os serviços comparados: aceita um fuso IANA opcional no agendamento.
O que acontece se o script falhar ou passar de 60 minutos?
A execução aparece como Falhou (código de saída diferente de zero) ou Tempo limite excedido (mais de 60 minutos), é cobrada pelo tempo usado e não é repetida: a próxima execução acontece no próximo horário. O dono da organização recebe um e-mail de alerta, com no máximo um por hora enquanto as falhas continuarem.
Se a falha foi por memória, a lista de execuções mostra Sem memória: a execução atingiu o limite de memória do plano. Abra Ver logs para achar a mensagem de erro; se a tarefa chega perto dos 60 minutos com frequência, divida o trabalho em partes menores ou use um plano maior, que pode terminar a mesma tarefa em menos minutos.