Minutos de build
Os minutos de build são a unidade de faturação da computação de CI: o tempo que um runner passa a executar jobs, multiplicado por uma tarifa que depende do tamanho e do SO da máquina.
Última atualização: 11 de novembro de 2026
Os minutos de build são a unidade de faturação da computação de CI: o tempo que um runner de CI passa a executar jobs, normalmente contado por job, do início ao fim, e depois multiplicado por uma tarifa que depende do tamanho da máquina, do sistema operativo e da arquitetura. Um minuto de vCPU é um minuto de uma vCPU, pelo que um runner de 4 vCPU ocupado durante um minuto consome quatro.
Três regras que alteram a contagem
Arredondamento. O GitHub "rounds the minutes and partial minutes each job uses up to the nearest whole minute", ou seja, arredonda para cima, ao minuto inteiro, os minutos e as frações de minuto de cada job (preços dos runners de GitHub Actions). Outros fornecedores medem ao segundo. Dez jobs de 20 segundos cada são 10 minutos faturados com arredondamento por job, e cerca de 3,3 minutos com medição ao segundo.
Tamanho. Um runner maior tem uma tarifa por minuto mais alta, como os runners maiores do GitHub, ou consome minutos mais depressa através de um fator de custo ou de um multiplicador de tamanho, como no GitLab e no Bitbucket.
Utilização incluída. Os planos incluem utilização sob a forma de minutos, créditos ou um montante em dólares. O GitHub expressa-a agora como um montante monetário e não como um número de minutos (faturação do GitHub Actions), pelo que os runners maiores a esgotam mais depressa.
Como contam os fornecedores
| Fornecedor | Unidade | Como é contado o tempo de execução |
|---|---|---|
| GitHub Actions | Minutos, com preço por tamanho e SO | Cada job arredondado para cima, ao minuto inteiro |
| GitLab.com | Minutos de computação | Duração do job em segundos a dividir por 60, vezes o fator de custo |
| CircleCI | Créditos | Ao segundo, arredondado para cima ao crédito seguinte |
| Bitbucket Pipelines | Minutos de build | Duração do passo vezes o multiplicador de tamanho |
| Buildkite hosted agents | Minutos de vCPU | Ao segundo |
| CRACI | Minutos de vCPU | Ao segundo |
Para os preços de todos os fornecedores, consulte preços de runners de CI e, para as quotas gratuitas, minutos de CI gratuitos.
Como encontrar o seu próprio número
No GitHub, o relatório de utilização lista os minutos por repositório, workflow e tipo de runner. A calculadora de custos do GitHub Actions explica onde o encontrar e converte-o numa fatura mensal.
Windows e macOS
A documentação de preços do GitHub já não indica multiplicadores de minutos para Windows e macOS. Indica um preço por minuto para cada runner, e o custo de cada runner é descontado do mesmo montante incluído em dólares. Os preços padrão são $0.006 por minuto para Linux 2-core x64, $0.010 para Windows 2-core e $0.062 para macOS 3 ou 4-core, M1 ou Intel (GitHub Actions runner pricing). Um minuto de Windows custa cerca de 1,7 vezes um minuto de Linux, e um minuto de macOS cerca de 10 vezes.
Porque é que a minha fatura mostra mais minutos do que os meus builds demoraram?
Normalmente por causa dos jobs de matriz e do arredondamento, não da fila.
- Jobs de matriz. Uma matriz executa um job para cada combinação das suas variáveis: três versões em dois sistemas operativos são seis jobs (GitHub: executar variações de jobs). Cada job é faturado separadamente e, como correm em paralelo, o workflow termina muito antes de os minutos faturados se somarem.
- Arredondamento por job. O GitHub arredonda para cima os minutos faturáveis de cada job até ao minuto seguinte (ver o tempo de execução de um job). Seis jobs de matriz de 70 segundos cada correm 7 minutos no total e faturam 12.
- O tempo em fila não é faturado. O GitHub fatura o tempo em que um job é executado no runner (GitHub Actions runner pricing). Esperar por um runner torna um workflow mais lento, não mais caro.
O resumo do job mostra o tempo faturável de cada job, a forma mais rápida de ver para onde vão os minutos.
O mesmo job em três fornecedores
Um job de 4 minutos e 20 segundos num runner Linux x64 com 2 vCPU, a preços de tabela verificados a 2026-11-11:
| Fornecedor | Runner | Faturado como | Tarifa | Custo |
|---|---|---|---|---|
| GitHub Actions | Linux 2-core x64 | 5 minutos (arredondado para cima) | $0.006 por minuto | $0.030 |
| CircleCI | Docker medium, 2 vCPU | 44 créditos (43,3 arredondado) | 10 créditos por minuto a $0.0006 cada | $0.0264 |
| CRACI | size: 2 | 260 segundos | $0.004 por minuto ($0.002 por minuto de vCPU) | cerca de $0.0173 |
O CircleCI arredonda primeiro para o segundo seguinte e depois para o crédito seguinte, a $15 por 25 000 créditos (CircleCI credits). Como o arredondamento se aplica por job, a diferença cresce com o número de jobs curtos. A comparação cobre apenas computação: taxas do plano, utilização incluída, armazenamento e diferenças de memória ficam de fora.
CRACI
O CRACI cobra apenas os minutos de build: $0.002 por minuto de vCPU ($0.004 para um runner predefinido de 2 vCPU), medidos ao segundo, sem mensalidade e sem custo por SBOM. O ARM64 é faturado à mesma tarifa. Consulte os preços.
Se a sua utilização couber nos minutos incluídos num plano, o minuto mais barato é aquele que já pagou.