# Actions Runner Controller ou um serviço de executores gerenciado: qual para uma equipe pequena?

> O Actions Runner Controller (ARC) é software livre que você roda no seu próprio cluster Kubernetes: dois charts Helm, uma imagem de executor que você monta e uma reinstalação a cada atualização. Uma equipe pequena tem os mesmos minutos sem cobrança do GitHub com um executor gerenciado. O Skipbox é um deles, por $39 fixos por mês com minutos ilimitados: troque uma linha de runs-on.

Para uma equipe pequena, um serviço de executores gerenciado. O Actions Runner Controller (ARC) é um operador do Kubernetes: você roda um cluster, instala dois charts Helm, monta uma imagem de executor e reinstala tudo a cada atualização. O GitHub recomenda o ARC para organizações com infraestrutura Kubernetes e equipes com experiência em Kubernetes.

O Skipbox entrega aquilo para que o ARC serve, executores auto-hospedados cujos minutos o GitHub não cobra, sem nada para operar. Os seus trabalhos rodam em uma máquina que o Skipbox hospeda só para a sua conta, por $39 fixos por mês com minutos ilimitados. Troque uma linha de `runs-on`.

- ARC: um cluster Kubernetes, dois charts Helm, a sua própria imagem de executor e uma desinstalação e reinstalação a cada atualização
- Skipbox: instale um app do GitHub, troque o `runs-on`, e a máquina, a imagem e as atualizações ficam por nossa conta
- 20.000 minutos por mês em 4 vCPU: $222 no GitHub, $39 no Skipbox

**GitHub Actions a preço fixo, minutos ilimitados** O Skipbox roda os seus trabalhos do GitHub Actions na sua própria máquina dedicada: $39 por mês, não importa quantos minutos você rode. As camadas Docker e o cache de dependências ficam entre os trabalhos, então o próximo trabalho começa na hora.

Um executor de 4 vCPU, 20.000 minutos por mês: GitHub $222 → Skipbox $39. Você economiza $183 todo mês.

A mudança é uma linha: `runs-on: skipbox`.

[Começar meu teste grátis de 7 dias](https://app.skipbox.dev/sign-in?ref=g-actions-runner-controller-vs-managed-runners-pt-br)

## O que você opera quando roda o ARC

Segundo a [documentação do ARC](https://docs.github.com/en/actions/concepts/runners/actions-runner-controller) do GitHub:

| Peça | O que ela exige |
|---|---|
| Um cluster Kubernetes | O primeiro pré-requisito do ARC, com o Helm 3. O GitHub recomenda rodar as cargas de produção isoladas, porque usar um cluster Kubernetes compartilhado para elas pode ser um risco de segurança |
| O controlador | O chart Helm `gha-runner-scale-set-controller`: o pod do gerenciador do controlador, os papéis dele e as definições de recursos personalizados do ARC |
| Um runner scale set | O chart Helm `gha-runner-scale-set`, uma vez para cada tipo de executor: um pod listener que espera os trabalhos e um pod de executor criado para cada trabalho |
| Autenticação | Um GitHub App ou um token de acesso pessoal (clássico), guardado como secret do Kubernetes |
| A imagem do executor | A imagem do GitHub traz o mínimo de pacotes necessário. Para qualquer coisa a mais, você monta e publica a sua |
| Um modo de contêiner | Os trabalhos que usam contêineres precisam do `dind` (um contêiner Docker-in-Docker privilegiado em cada pod de executor) ou do `kubernetes` (volumes persistentes ou hooks de ciclo de vida e, por padrão, um trabalho sem `container:` falha) |
| Limites de escala | `minRunners` e `maxRunners` por scale set. O ARC não tem agenda para eles: um cron job seu é que os altera |
| Logs e métricas | O GitHub recomenda coletar e guardar os logs do controlador, dos listeners e dos executores antes da produção; as métricas vêm no formato do Prometheus |

Cada pod de executor é excluído quando o trabalho dele termina, então as imagens que ele baixou e os pacotes que ele instalou vão junto. Mantê-los entre os trabalhos é um armazenamento que você mesmo projeta e provisiona.

## Quanto ele custa em trabalho

O ARC é software livre, e o GitHub não cobra nada pelos minutos de executores auto-hospedados. O custo são os nós do cluster todo mês, e estas horas:

- **Atualizar é reinstalar.** O Helm não consegue atualizar as definições de recursos personalizados do ARC. Os [passos de atualização](https://docs.github.com/en/actions/how-tos/manage-runners/use-actions-runner-controller/deploy-runner-scale-sets#upgrading-arc) do GitHub: desinstalar todos os runner scale sets, esperar a limpeza, desinstalar o ARC, remover as CRDs se tiverem mudado, instalar de novo. Sem um segundo cluster, nenhum executor pega trabalhos enquanto você faz isso.
- **O executor fica desatualizado.** O GitHub para de entregar trabalhos a um executor que esteja mais de 63 dias atrás de uma versão nova. Com uma imagem sua, recriá-la a tempo é tarefa sua.
- **O cluster é seu para depurar.** O [escopo de suporte do ARC](https://docs.github.com/en/actions/concepts/runners/support-for-arc) do GitHub deixa de fora a configuração e a rede do Kubernetes, a criação de imagens com Docker-in-Docker, o armazenamento e os volumes persistentes, as políticas do cluster e o cache de imagens. Ele recomenda uma equipe com conhecimento avançado em orquestração de contêineres.
- **O próprio Kubernetes.** Atualizações dos nós, escala automática dos nós por baixo dos executores e a fatura dos nós parados entre um push e outro.

Uma equipe pequena não tem um engenheiro de plataforma para gastar nisso. As horas saem do trabalho no produto.

## Quanto custam os executores do GitHub se você ficar

O motivo de as equipes olharem para o ARC é a fatura por minuto. Aqui está essa fatura contra um plano do Skipbox:

| Minutos por mês (4 vCPU) | GitHub | Skipbox S | Você economiza todo mês |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Sempre ligado | $500,40 | $39 | **$461,40** |

Os valores do GitHub são a fatura no GitHub Team depois do uso incluído. Calcule os seus próprios minutos na [calculadora da página inicial](https://skipbox.dev/?ref=g-actions-runner-controller-vs-managed-runners-pt-br#cost); sem login.

## Skipbox: os executores, sem o cluster

| | ARC | Skipbox |
|---|---|---|
| Para começar | Um cluster, Helm, dois charts, um secret, uma imagem | Instalar um app do GitHub, trocar o `runs-on` |
| Fatura do GitHub pelos minutos | Nenhuma | Nenhuma: os executores do Skipbox são executores auto-hospedados |
| Custo mensal | Os nós do cluster, por tamanho e por horas | $39, $79 ou $149, fixo |
| Docker nos trabalhos | Docker-in-Docker privilegiado, ou o modo Kubernetes | O Docker roda na VM, como no `ubuntu-latest` |
| Caches entre os trabalhos | Vão embora com o pod, a menos que você monte armazenamento para eles | Ficam no disco da sua máquina |
| Atualizações | Desinstalar e reinstalar | Feitas por nós |
| Quando um executor quebra | Você lê os logs do controlador e do listener | Verificado depois de cada trabalho; uma máquina que falha é recriada automaticamente |

- **Um preço fixo.** 4 vCPU e 16 GB por $39 por mês, 8 vCPU por $79, 16 vCPU por $149. Minutos ilimitados, sem cobrança por uso. Adicione planos para rodar mais trabalhos ao mesmo tempo; os trabalhos além das suas máquinas esperam a vez.
- **A sua máquina dedicada, sempre aquecida.** Imagens, camadas e cache de build do Docker, caches de pacotes e o cache de ferramentas ficam entre os trabalhos: pelo menos 7× o cache que o GitHub dá a um repositório. Um pod de executor que começa vazio baixa tudo de novo.
- **Um executor para cada trabalho.** O Skipbox registra um executor just-in-time para um trabalho quando o trabalho entra na fila, e o remove depois. Sem listener, sem scale set, sem `maxRunners`.
- **Sempre em dia.** O executor, o Ubuntu 24.04, o Docker, o Node 22 e o Python 3.12 são atualizados pelo Skipbox.

## Mudar é uma linha

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest, or your scale set's name
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test
```

1. Entre no Skipbox com o GitHub.
2. Instale o app do Skipbox no GitHub e escolha os seus repositórios.
3. Troque o `runs-on` e faça push.

Os trabalhos Linux rodam sem mudanças, em repositórios públicos e privados.

## Segurança

- A máquina é só da sua conta; nenhum trabalho de outra empresa roda nela.
- Depois de cada trabalho, as credenciais, os processos e os contêineres do executor e os arquivos de credenciais como o `~/.npmrc` são apagados. A partir de 13 de novembro de 2026, o seu checkout e a saída de build dele (o `target/` do Cargo) ficam na sua máquina dedicada para os próximos trabalhos; Limpar a cada trabalho dá a cada trabalho uma máquina nova.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma VM nova, excluída depois. [Como os trabalhos ficam separados](https://docs.skipbox.dev/pt-br/isolation).

## Teste antes de montar um cluster

O teste não pede cartão e dura 7 dias ou 3.000 minutos de trabalhos. Mova um trabalho para `runs-on: skipbox` hoje, antes de montar um cluster para ele.

## Perguntas frequentes

### Actions Runner Controller ou um serviço de executores gerenciado: qual para uma equipe pequena?

Um serviço de executores gerenciado. O Actions Runner Controller (ARC) é um operador do Kubernetes: você roda o cluster, instala os dois charts Helm dele, monta a imagem do executor e o reinstala a cada atualização. O GitHub o recomenda para organizações com infraestrutura Kubernetes e equipes com experiência em Kubernetes. O Skipbox dá a uma equipe pequena os mesmos minutos auto-hospedados sem cobrança, sem nada para operar: $39 fixos por mês por uma máquina de 4 vCPU, minutos ilimitados, uma linha de runs-on.

### O Actions Runner Controller é difícil de manter para uma equipe pequena?

É uma plataforma Kubernetes para manter de pé. Você precisa de um cluster, do Helm, de um GitHub App ou token guardado como secret do Kubernetes, de um modo de contêiner para os trabalhos que usam Docker, da sua própria imagem de executor com as ferramentas que os seus trabalhos esperam e da coleta de logs do controlador, dos listeners e dos executores. A documentação do GitHub recomenda uma equipe com conhecimento avançado em orquestração de contêineres. No Skipbox nada disso existe: você instala um app do GitHub e troca o runs-on.

### Quanto custa o Actions Runner Controller?

O ARC em si é grátis, e o GitHub não cobra nada pelos minutos de executores auto-hospedados. Você paga todo mês pelo cluster Kubernetes e pelos nós dele, e pelas horas gastas instalando, atualizando e depurando. O Skipbox junta a máquina e o trabalho em um preço fixo: $39, $79 ou $149 por mês por 4, 8 ou 16 vCPU, com minutos ilimitados.

### Como se atualiza o Actions Runner Controller?

Reinstalando. O Helm não consegue atualizar as definições de recursos personalizados (CRDs) do ARC, então os passos do GitHub são: desinstalar todos os runner scale sets, esperar a limpeza, desinstalar o ARC, remover as CRDs se tiverem mudado e instalar de novo. O executor dentro da sua imagem também precisa ficar em dia: o GitHub para de entregar trabalhos a um executor mais de 63 dias atrás de uma versão nova. No Skipbox, o executor e a imagem são atualizados por você.

### Preciso de Kubernetes para escalar automaticamente os executores do GitHub Actions?

Não. O ARC é a resposta do GitHub com Kubernetes, e a documentação do GitHub também descreve como montar o seu próprio escalador a partir do cliente de scale sets ou de webhooks. Um executor gerenciado não precisa de nada disso. O Skipbox registra um executor para cada trabalho assim que ele entra na fila; os seus planos definem quantos trabalhos rodam ao mesmo tempo, e o resto espera a vez.

### Os builds Docker funcionam sem Docker-in-Docker no Skipbox?

Sim. Cada máquina do Skipbox é uma VM com Docker instalado, então docker build, docker run, contêineres de serviço e trabalhos em contêiner funcionam como no ubuntu-latest. No ARC você escolhe antes um modo de contêiner: Docker-in-Docker, que roda um contêiner privilegiado, ou o modo Kubernetes, em que um trabalho sem contêiner falha por padrão.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/actions-runner-controller-vs-managed-runners
