# Um Procfile do Heroku declara tipos de processo. Cada linha vira um serviço.

O Procfile do Heroku lista processos e comandos. Veja no que web, worker, o release phase e o Scheduler se transformam.

Canonical URL: https://unbroker.cloud/pt/blog/heroku-procfile-to-services
Published: 2026-11-13
Reviewed: 2026-11-13
Author: Timoteo Borgobello

## A resposta curta

Um Procfile do Heroku é um arquivo de texto que nomeia tipos de processo e o comando que cada um roda. `web` é o único que recebe HTTP, e precisa escutar em `$PORT`. `release` roda antes de um release novo entrar. Qualquer outro nome, inclusive `worker` e `clock`, é um tipo comum.

Para levar o app para contêineres, cada linha que fica no ar ganha o próprio serviço. O comando web vira um serviço HTTP que escuta na porta da plataforma e responde um health check. Uma linha worker vira um serviço sem HTTP de entrada. O release phase Heroku vira um comando de migração: não entra no build da imagem e não entra na subida de cada cópia. O Heroku Scheduler vira um job agendado, ou um processo clock que você deixa rodando quando o horário é crítico. Config vars viram variáveis de ambiente. Buildpacks viram um build gerenciado, ou um Dockerfile.

Este texto não copia preços do Heroku. Se você já decidiu sair, a mudança é [Migrar do Heroku](https://unbroker.cloud/pt/migrar/heroku). A comparação está na [página do Heroku](https://unbroker.cloud/alternatives/heroku). [Heroku vs Railway](https://unbroker.cloud/pt/comparar/heroku-vs-railway) fica com as outras comparações. Um repositório do Railway que traz railway.toml, em vez de um Procfile, está mapeado em [railway.toml, campo a campo](https://unbroker.cloud/pt/blog/railway-toml-to-services). Um repositório do Render que traz render.yaml está mapeado em [render.yaml, campo a campo](https://unbroker.cloud/pt/blog/render-yaml-to-services).

## O que um Procfile declara

O arquivo se chama sempre `Procfile`, sem extensão, e fica na raiz do app. `Procfile.txt` não vale. Em outra pasta, ele não roda. [O Procfile](https://devcenter.heroku.com/articles/procfile) é a fonte desta seção.

Cada linha tem esta forma:

```
<process type>: <command>
```

O tipo de processo é um nome alfanumérico, como `web`, `worker`, `urgentworker` ou `clock`. O comando é o que cada dyno desse tipo executa na subida. Cada dyno pertence a um tipo declarado.

Dois nomes são especiais. `web` é o único tipo que pode receber tráfego HTTP externo dos roteadores do Heroku. `release` é o comando do release phase. Nenhum outro tipo tem propriedades especiais. Uma linha `worker` é um nome que você escolheu, não um recurso da plataforma.

Um Procfile não é obrigatório para um app simples na maioria das linguagens que o Heroku suporta. A plataforma detecta a linguagem e cria um tipo `web` padrão. A mesma página recomenda um arquivo explícito quando você quer controlar os comandos. Se o app usa `heroku.yml` como manifesto de build, o Procfile não é necessário. A seção `run` usa o mesmo formato, exceto `release`.

O Heroku sobe um dyno `web` para você. Os outros tipos não sobem até você escalar. `heroku ps:scale worker=1` é o exemplo dessa página. Dá para escalar dois nomes de worker separados, por exemplo `worker=1` e `urgentworker=5`.

Estas linhas são as formas do artigo do Procfile e do de release phase, não um app de exemplo:

```
web: bundle exec rails server -p $PORT
worker: bundle exec rake jobs:work
release: python manage.py migrate
```

O comando pode citar config vars. A página aponta `$PORT` como a útil.

## O processo web e $PORT

O comando `web` é o servidor HTTP. Em apps Cedar, o dyno manager define `$PORT` para um dyno web, e o dyno precisa escutar nessa porta para receber pedidos. [Dyno Startup Behavior](https://devcenter.heroku.com/articles/dyno-startup-behavior) diz que um dyno web precisa se vincular ao `$PORT` atribuído em até 60 segundos depois da subida. Se não fizer isso, o dyno manager o encerra, e o erro é um R10 Boot Timeout. Os processos podem escutar em outras portas antes e depois. A mesma página diz que uma ferramenta de boot timeout pode aumentar o limite como medida temporária, e que essa ferramenta existe para apps Cedar e não para apps Fir.

Em apps Fir, um dyno web escuta IPv6 em `[::]:$PORT`, com o mesmo limite de 60 segundos.

No stack de contêiner, a ideia é a mesma. [Container Registry & Runtime](https://devcenter.heroku.com/articles/container-registry-and-runtime) diz que esse artigo vale para apps Cedar. O processo web precisa escutar HTTP na `$PORT` que o Heroku define. `EXPOSE` não vale em runtime. Só pedidos HTTP são suportados. `CMD` sempre roda num shell, então as config vars chegam ao processo. `ENTRYPOINT` é opcional. Uma instrução `HEALTHCHECK` não é suportada. O dyno manager verifica a saúde dos contêineres que estão rodando. Essa página não diz qual caminho o check pede.

Uma linha Rails passa a porta no comando: `web: bundle exec rails server -p $PORT`. Um processo que lê o ambiente por conta própria, como muitos servidores Node, ainda precisa escutar o valor que o Heroku definiu. Escutar numa porta fixa, ou só em `127.0.0.1`, não recebe o roteador.

## Workers

Uma linha worker do Procfile é um tipo de processo sem propriedades especiais. Ela não recebe HTTP. Não sobe quando você faz o deploy. Você escala. [Dynos](https://devcenter.heroku.com/articles/dynos) descreve dynos worker como o lugar habitual de jobs em segundo plano, filas e tarefas com horário, e diz que você pode ter mais de um tipo.

Uma linha `clock` é o mesmo tipo de declaração. O artigo do Procfile lista um clock como exemplo de processo singleton. Não é um segundo scheduler da plataforma. [Heroku Scheduler](https://devcenter.heroku.com/articles/scheduler) recomenda um processo clock próprio quando o horário é parte crítica do app, porque a execução do Scheduler não é garantida.

Numa plataforma de contêineres, as duas linhas são processos que ficam no ar e não recebem HTTP. Não são uma segunda rota do serviço web. A diferença entre um consumidor e um comando que começa e sai está em [Workers e tarefas cron](https://unbroker.cloud/pt/blog/background-workers-cron-jobs).

## O release phase

O release phase Heroku é o tipo de processo `release`. [Release Phase](https://devcenter.heroku.com/articles/release-phase) diz que ele roda tarefas antes de um release novo entrar. Os exemplos dessa página são envio de assets, preparo de cache e migrações de schema do banco.

O comando roda num dyno avulso sempre que um release novo é criado, exceto um release causado pelas config vars de um add-on. Estes eventos criam um release: um build que deu certo, uma mudança de config var que não é de add-on, uma promoção de pipeline, um rollback, um release pela API da plataforma e o provisionamento de um add-on. Um rollback está nessa lista, então o comando `release` roda de novo num rollback. Os dynos do app não sobem o release novo até o phase terminar com sucesso.

Se o comando sai com status diferente de zero, ou o dyno manager o encerra, o release novo não entra. O release atual continua. O Heroku manda um e-mail. O phase tem um timeout de uma hora, e esse limite não se estende. O Heroku marca como falho um release que continua pendente depois de 24 horas. Se o release veio de uma mudança de config var e o comando falha, o valor novo da config var permanece. `heroku releases:retry` tenta de novo um release falho sem um build novo.

O filesystem do dyno é efêmero. Arquivos gravados durante o phase não vão para a formação. A página diz para não usar o phase num trabalho que precise desse filesystem, e trata a compilação de assets como trabalho de build, não de release.

Vários eventos criam um release, então um comando de migração pode rodar quando o schema já está nessa versão. A página diz que o script precisa checar antes de migrar. Releases também podem se sobrepor, e a página recomenda um advisory lock para isso. Um script que embrulha várias tarefas precisa propagar uma saída diferente de zero. Se não propagar, o phase pode aparecer como sucesso só porque o wrapper começou. Como escrever a migração para um rollback de código ainda rodar está em [Migrações de banco de dados no deploy](https://unbroker.cloud/pt/blog/database-migrations-on-deploy).

## Heroku Scheduler e dynos avulsos

O Heroku Scheduler é um add-on. Não é uma linha do Procfile. O painel deixa você rodar um comando a cada 10 minutos, a cada hora ou todo dia, na hora que você escolher. Os horários diários estão em UTC. Dá para nomear um tipo de processo em vez de um comando, e o Heroku roda o comando desse tipo. Os jobs rodam como dynos avulsos e aparecem nos logs como `scheduler.X`.

A execução é esperada, não garantida. O artigo diz que um job pode, raramente, ser pulado ou rodar duas vezes. Um dyno iniciado pelo Scheduler não roda mais do que o intervalo. Um job a cada 10 minutos é encerrado depois de cerca de 10 minutos. O jitter pode fazer duas execuções do mesmo job se sobreporem por um momento. O artigo diz que qualquer coisa que leve mais do que alguns minutos deveria rodar num dyno worker, e que um horário crítico deveria ser um processo clock próprio.

Se o app faz deploy com Container Registry, a tarefa do Scheduler precisa estar na imagem `web`. Esse artigo diz que não há como escolher uma imagem que não seja web para a tarefa.

Dynos avulsos são o mecanismo que o Scheduler usa, e também o que o `heroku run` sobe. [One-Off Dynos](https://devcenter.heroku.com/articles/one-off-dynos) lista migrações, um console e scripts de uma vez como usos. Eles aparecem como o tipo de processo `run`. Nunca recebem HTTP. O filesystem é descartado quando você desconecta. Eles não reiniciam sozinhos, e não reiniciam depois de um release novo. Não são exatamente uma vez: a página diz que uma execução pode, raramente, ser pulada ou acontecer duas vezes.

A maioria dos dynos avulsos é reciclada a cada 24 horas, então a maioria pode rodar no máximo 24 horas. Apps Fir podem definir uma flag para pular esse reinício diário. Este texto não nomeia a flag. Uma sessão anexada tem um timeout de inatividade: uma hora na maioria dos dynos Cedar, 15 minutos em Shield Spaces e no Fir. Um dyno detached não tem conexão, então não tem timeout de conexão. O limite inicial de conexão, o tamanho do dyno e quantos dynos avulsos podem rodar juntos estão em seções seguintes dessa página. Este texto não repete a tabela de tamanhos.

Um comando que começa, faz o trabalho e sai tem esta forma. Um processo que fica no ar e espera uma fila é um worker. Depois da mudança, são serviços diferentes.

## Config vars e buildpacks

Config vars são a configuração que muda conforme o ambiente. [Configuration and Config Vars](https://devcenter.heroku.com/articles/config-vars) diz que elas são expostas ao código como variáveis de ambiente. Em Node, `process.env.DATABASE_URL` é o exemplo. Criar ou remover uma config var reinicia o app e cria um release novo. Os valores persistem entre deploys até você mudá-los.

Com buildpacks clássicos, as config vars existem no build e em runtime. Com Cloud Native Buildpacks, elas são só de runtime, a menos que você ative o recurso de laboratório Build Time Config Vars. A soma de chaves e valores não pode passar de 64 KB por app. As chaves devem ser alfanuméricas mais sublinhado, não devem começar com um dígito, não devem ter hífen, não devem começar com `__` e não devem começar com `HEROKU_` a menos que a plataforma as tenha definido.

[Buildpacks](https://devcenter.heroku.com/articles/buildpacks) são scripts que transformam o repositório em algo que um dyno consegue rodar. O conjunto do Heroku cobre Ruby, Python, Java, Clojure, Node.js, Scala, Go, PHP e .NET. Buildpacks clássicos, no Cedar, produzem um slug. Eles não são usados no Fir. Cloud Native Buildpacks produzem uma imagem OCI. Apps Fir usam esses por padrão. Apps Cedar usam buildpacks clássicos por padrão. Também dá para fazer deploy de imagens Docker no Cedar em vez de enviar código para um build de buildpack.

A passagem de Procfile para Dockerfile, no registry do próprio Heroku, é uma imagem por tipo de processo. `heroku container:push web` constrói a imagem `web`. Vários tipos usam `Dockerfile.web` e `Dockerfile.worker`, enviados com `heroku container:push --recursive`. O release phase é uma imagem chamada `release`, e você a libera junto com a imagem web: `heroku container:release web release`. A imagem web escuta em `$PORT`. A imagem worker não.

Esse registry é o caminho de contêiner de um fornecedor. O corte é o mesmo em qualquer plataforma de contêineres: o comando do Procfile vira o comando de subida do contêiner, e cada tipo que fica no ar vira o próprio serviço.

## O Procfile, linha por linha

| Linha | O que o Heroku faz | O que rodar no lugar |
| --- | --- | --- |
| `web: <command>` | O único tipo que recebe HTTP. O dyno web escuta em `$PORT` em 60 segundos. | Um serviço HTTP. Ele escuta na porta da plataforma e responde um health check. |
| `worker: <command>` | Sem propriedades especiais. Não sobe até você escalar. Não recebe HTTP. | Um serviço sem HTTP de entrada e sem URL pública. |
| `release: <command>` | Um dyno avulso antes do release novo. Uma saída diferente de zero deixa o release atual. Uma hora, sem estender. | Um comando de migração, fora do build da imagem e fora da subida de cada cópia. |
| `clock: <command>` | Um tipo comum. O artigo do Scheduler recomenda um clock quando o horário é crítico. | Um serviço de longa duração sem porta HTTP, no mesmo formato de um worker. |
| Heroku Scheduler | Não é uma linha do Procfile. A cada 10 minutos, a cada hora ou todo dia, como dyno avulso. Não é garantido. | Um job agendado: um comando que começa, roda e sai. Ou um clock, se o horário é crítico. |
| `heroku run` | Não é uma linha do Procfile. Um dyno avulso do tipo `run`. Nunca recebe HTTP. | Um comando avulso contra a imagem e as variáveis desse serviço. |
| Config vars | Variáveis de ambiente. Criar ou remover uma reinicia o app e cria um release. | Variáveis de ambiente no serviço. Fora do Git. |
| Buildpacks | Scripts que produzem um slug ou uma imagem OCI a partir do repositório. | Um build de framework gerenciado, ou um Dockerfile cujo comando de subida é o do processo. |

## Como funciona na Unbroker

<aside class="plan-box">
<p><strong>Na Unbroker.</strong> Um serviço por processo que fica no ar. O processo web escuta em <code>0.0.0.0</code> e <code>PORT</code>. Um worker é a categoria Worker: sem URL pública e sem HTTP de entrada. Workers, jobs agendados, comandos avulsos, comandos de migração e builds de Dockerfile exigem Pro.</p>
</aside>

[Projetos e serviços](https://docs.unbroker.cloud/concepts/projects) diz para usar mais de um serviço quando o app tem um processo web, uma API, um worker ou uma carga agendada separados. Cada serviço tem as próprias configurações, variáveis, recursos, domínios e histórico de deploy. Os docs não descrevem uma importação de Procfile. Você copia cada comando para o serviço que deve rodá-lo.

A linha web é um serviço de repositório que escuta. [Fazer deploy de uma aplicação Node.js](https://docs.unbroker.cloud/guides/deploy-nodejs) diz que o processo precisa escutar em `0.0.0.0` e na `PORT` recebida, não num localhost fixo. [Deployments](https://docs.unbroker.cloud/deployments/overview) diz que um health check que falha impede tratar essa revisão como live. No Pro, o [guia de Express](https://docs.unbroker.cloud/guides/deploy-express) diz para apontar o caminho do health check para a rota que você serve. A [tabela de planos](https://docs.unbroker.cloud/billing/plans) lista health checks avançados como indisponíveis no Free e disponíveis no Pro. Este texto não diz quanto tempo a subida pode levar.

A linha worker é outro serviço. No Cloud, adicione um serviço e selecione a categoria **Worker**. [Fazer deploy de um worker em segundo plano](https://docs.unbroker.cloud/guides/background-worker) diz para não criar um serviço web público só para um processo sem listener passar num health check HTTP. Um worker não tem URL pública. [Tipos de serviço](https://docs.unbroker.cloud/apps/services) diz que um worker não pode ser marcado como privado, porque já não tem Service nem URL pública, e que imagens, workers e qualquer serviço com volume persistente rodam sempre uma réplica. Workers de Dockerfile ainda rodam sem URL pública, sem serviço de entrada e sem sonda de readiness HTTP. Workers não estão no Free e estão no Pro.

A linha release é um passo de migração. O [guia de Django](https://docs.unbroker.cloud/guides/deploy-django) diz para rodar as migrações de banco uma vez, como um passo de release controlado, com as credenciais de runtime. Diz para evitar colocá-las no build da imagem e para evitar rodar migrações concorrentes em cada processo web. Infraestrutura como código mapeia um campo `preDeploy`. [A página de IaC](https://docs.unbroker.cloud/cli/infrastructure-as-code) diz que mudar os comandos pre-deploy reconstrói o serviço. Ela não diz quando `preDeploy` roda, nem o que um `preDeploy` que falhou faz com a versão que já está live. Comandos de migração exigem Pro. Um comando post-deploy é outro gancho: [Deployments](https://docs.unbroker.cloud/cli/deployments) diz que ele roda depois de o deployment estar live, por no máximo 10 minutos, e uma falha deixa o deployment live. O passo de release está em [Migrações de banco de dados no deploy](https://unbroker.cloud/pt/blog/database-migrations-on-deploy).

Os intervalos fixos do Scheduler viram um job agendado, e `heroku run` vira um comando avulso. A tabela de planos lista os dois como indisponíveis no Free e disponíveis no Pro. [Infrastructure API](https://docs.unbroker.cloud/api/infrastructure) lista e cria jobs em `GET` e `POST /apps/services/:id/jobs`, atualiza ou apaga um em `PUT` e `DELETE /apps/services/:id/jobs/:jobId`, e roda um agora em `POST /apps/services/:id/jobs/:jobId/run`. Um comando avulso é `POST /apps/services/:id/commands`. O guia de workers diz que um script que processa um item e sai usa um fluxo agendado ou avulso, não um worker de longa duração. Essas páginas não publicam a expressão do horário. A divisão operacional está em [Workers e tarefas cron](https://unbroker.cloud/pt/blog/background-workers-cron-jobs).

Config vars viram variáveis do serviço. [Variáveis de ambiente](https://docs.unbroker.cloud/deployments/environment-variables) diz que elas são entregues ao runtime e não entram no commit. Quando você adiciona ou edita uma, seleciona **Production**, **Preview** ou **All**. Uma variável do serviço substitui uma variável compartilhada do projeto com a mesma chave. Variáveis compartilhadas do projeto exigem Pro. A página de IaC lista adicionar, mudar ou remover uma variável do serviço como uma mudança que dispara deploy. [Configurar variáveis de ambiente e segredos](https://docs.unbroker.cloud/guides/environment-variables) diz para fazer redeploy para a revisão que está rodando usar o valor novo. Como escopo e previews funcionam está em [Variáveis de ambiente e segredos](https://unbroker.cloud/pt/blog/environment-variables-and-secrets).

Buildpacks viram um build de framework ou um Dockerfile. [Deploy from Git](https://docs.unbroker.cloud/deployments/git) diz que projetos de servidor, inclusive Bun, pnpm, Yarn e workspaces, usam Railpack por padrão, e que um Dockerfile do repositório é o build explícito. [Fazer deploy de um contêiner Docker](https://docs.unbroker.cloud/guides/deploy-docker) diz para escolher **Dockerfile** em **Build & deploy** e informar um caminho relativo ao diretório raiz. Deixe o diretório raiz vazio quando o Dockerfile precisa do repositório inteiro como contexto de build. O listener escuta em `0.0.0.0` e na porta de runtime. `EXPOSE` sozinho não publica uma porta. Numa imagem worker, `ENTRYPOINT` ou `CMD` é o comando de subida. A tabela de planos lista Node.js gerenciado como incluído no Free, outras receitas de framework como indisponíveis no Free, e builds de Dockerfile como indisponíveis no Free e disponíveis no Pro. O que o Free pode rodar está em [um plano de $0 para um backend pequeno](https://unbroker.cloud/pt/blog/free-backend-hosting).

O Free é um projeto, dois serviços e três pedidos de deploy por dia UTC. Cada serviço Free roda uma réplica, até 250m de CPU e 256 MiB, e dorme quando está ocioso. O Pro custa $25 por mês com $25 de crédito de uso. O crédito zera a cada ciclo de cobrança, não acumula e não tem valor em dinheiro. Se o uso elegível ficar abaixo do crédito, a cobrança mensal continua sendo o preço do plano. Se o uso elegível passar, só a diferença é somada. Esses termos estão em [preços](https://unbroker.cloud/pt/precos) e em [Plans](https://docs.unbroker.cloud/billing/plans).

## Checklist

1. Nomeie o arquivo `Procfile`, sem extensão, na raiz do app. Liste cada tipo de processo.
2. Trate `web` como o único processo HTTP. No Heroku ele escuta em `$PORT` em 60 segundos. Na Unbroker ele escuta em `0.0.0.0` e na `PORT` recebida.
3. Dê a cada worker o próprio serviço. Não deixe ele dentro do processo web. No Heroku ele não sobe até você escalar.
4. Tire `release` do build da imagem e da subida de cada réplica. No Heroku uma saída diferente de zero deixa o release atual, e o limite é uma hora.
5. Troque o Scheduler por um job agendado, ou por um processo clock se o horário é crítico. O Scheduler é a cada 10 minutos, a cada hora ou todo dia, e não é garantido.
6. Deixe `heroku run` como um comando avulso. Ele nunca recebe HTTP.
7. Copie as config vars para variáveis do serviço. Não faça commit delas. No Heroku, definir uma cria um release.
8. Escolha um build gerenciado ou um Dockerfile. Na Unbroker, builds de Dockerfile, workers, jobs agendados, comandos avulsos e comandos de migração exigem Pro.
9. Aponte o health check do serviço web para uma rota real no Pro. Não adicione uma URL pública só para um worker passar num check HTTP.

## Perguntas frequentes

### O que é um Procfile do Heroku?

Um arquivo de texto chamado Procfile, sem extensão, na raiz do app. Procfile.txt não vale. Cada linha é um tipo de processo, dois pontos e o comando que cada dyno desse tipo executa na subida. web é o único que recebe HTTP de fora. release é o comando do release phase. Nenhum outro nome tem propriedades especiais. A fonte é [o artigo do Procfile](https://devcenter.heroku.com/articles/procfile).

### Um worker do Procfile do Heroku recebe HTTP?

Não. Só o tipo web recebe HTTP externo dos roteadores do Heroku. Um worker é um tipo comum. O Heroku sobe um dyno web para você. Os outros, inclusive uma linha worker, não sobem até você escalar. A fonte é o mesmo artigo.

### O que acontece se o release phase do Heroku falha?

O release novo não entra, e o atual continua. Isso acontece se o comando sai com status diferente de zero, ou se o dyno manager o encerra. O phase tem um timeout de uma hora, e esse limite não se estende. Se o release veio de uma mudança de config var, o valor novo permanece mesmo quando o comando falha. Os dynos do app não sobem o release novo até o phase terminar bem. A fonte é [Release Phase](https://devcenter.heroku.com/articles/release-phase).

### O Heroku Scheduler é uma expressão cron?

Não. O painel oferece a cada 10 minutos, a cada hora ou todo dia. Cada job roda como dyno avulso. A execução é esperada, não garantida: um job pode, raramente, ser pulado ou rodar duas vezes. Uma execução é interrompida mais ou menos no fim do intervalo, então um job de 10 minutos acaba em cerca de 10 minutos, e duas execuções podem se sobrepor por um momento. Se o horário é crítico, esse artigo recomenda um processo clock próprio. A fonte é [Heroku Scheduler](https://devcenter.heroku.com/articles/scheduler).

### Como eu passo de um Procfile para um Dockerfile?

No container registry do Heroku, que esse artigo limita a apps Cedar, você monta uma imagem por tipo de processo. Dockerfile.web e Dockerfile.worker são os nomes documentados. O release phase é uma imagem chamada release. O processo web precisa escutar na $PORT que o Heroku define. EXPOSE não vale em runtime, e CMD roda num shell para as config vars entrarem. A fonte é [Container Registry & Runtime](https://devcenter.heroku.com/articles/container-registry-and-runtime). Na Unbroker, o Dockerfile é escolhido em Build & deploy, e builds de Dockerfile exigem Pro. Os passos estão em [Fazer deploy de um contêiner Docker](https://docs.unbroker.cloud/guides/deploy-docker).

### Para onde vão as config vars do Heroku?

São variáveis de ambiente. O Heroku as expõe ao processo, e criar ou remover uma reinicia o app e cria um release. Na Unbroker elas são variáveis do serviço, com escopo Production, Preview ou All. Mudar uma variável do serviço dispara um deploy. Não faça commit dos valores. As regras do Heroku estão em [Config Vars](https://devcenter.heroku.com/articles/config-vars). As da Unbroker, em [Variáveis de ambiente](https://docs.unbroker.cloud/deployments/environment-variables).

## Related reading

- [Migrar do Heroku](https://unbroker.cloud/pt/migrar/heroku)
- [Alternativa ao Heroku](https://unbroker.cloud/alternatives/heroku)
- [Heroku vs Railway](https://unbroker.cloud/pt/comparar/heroku-vs-railway)
- [Workers e tarefas cron](https://unbroker.cloud/pt/blog/background-workers-cron-jobs)
- [Migrações de banco de dados no deploy](https://unbroker.cloud/pt/blog/database-migrations-on-deploy)
- [Variáveis de ambiente e segredos](https://unbroker.cloud/pt/blog/environment-variables-and-secrets)
- [Tetos do plano Free](https://unbroker.cloud/pt/blog/free-backend-hosting)
- [railway.toml, campo a campo](https://unbroker.cloud/pt/blog/railway-toml-to-services)
- [render.yaml, campo a campo](https://unbroker.cloud/pt/blog/render-yaml-to-services)
- [Preços](https://unbroker.cloud/pt/precos)
