# Executores auto-hospedados são seguros para repositórios privados? As regras de proteção do GitHub, feitas para você

> Um executor auto-hospedado do GitHub Actions guarda o que os trabalhos anteriores deixaram e pode ser comprometido de vez por um trabalho mal-intencionado. A orientação do GitHub: um executor para um trabalho, uma máquina limpa, máquinas separadas para código em que você não confia. O Skipbox faz as três coisas na máquina dedicada da sua conta por $39 fixos por mês, com uma VM nova para cada trabalho quando você ativa Limpar a cada trabalho.

Um executor auto-hospedado é seguro para um repositório privado só depois que você acrescenta o que os executores hospedados pelo GitHub te dão e um executor auto-hospedado simples não tem: uma máquina limpa, um executor que aceita um trabalho e máquinas separadas para código em que você não confia. A [referência de segurança](https://docs.github.com/en/actions/reference/security/secure-use#hardening-for-self-hosted-runners) do GitHub diz que os executores auto-hospedados não têm garantia de rodar em máquinas virtuais limpas e efêmeras, e podem ser comprometidos de forma persistente por código não confiável em um workflow.

O Skipbox é um executor auto-hospedado com esse trabalho feito. Os seus trabalhos rodam em uma máquina que é só da sua conta, as credenciais dela são apagadas depois de cada trabalho, cada executor é registrado para um trabalho e o código de pessoas sem acesso de escrita roda em uma VM nova. Ative **Limpar a cada trabalho** e cada trabalho recebe uma VM nova. $39 fixos por mês, minutos ilimitados; troque uma linha de `runs-on`.

- GitHub: um executor auto-hospedado pode ser comprometido de forma persistente por um trabalho, e o pull request de um fork pode chegar aos secrets dele
- Skipbox: a máquina dedicada da sua conta, credenciais apagadas depois de cada trabalho, uma VM nova para o código de pessoas sem acesso de escrita
- Limpar a cada trabalho: cada trabalho em uma VM nova, excluída com o disco quando o trabalho termina

**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-self-hosted-runner-security-private-repositories-pt-br)

## Sobre o que o GitHub avisa

Tudo da referência de segurança do GitHub e da documentação de executores auto-hospedados dele:

- **A máquina lembra.** Um executor auto-hospedado não precisa de uma instância limpa para cada trabalho. O que um trabalho deixa (arquivos, processos, contêineres, tokens) fica lá para o próximo.
- **Os repositórios privados não estão isentos.** Qualquer pessoa que consiga fazer fork do repositório e abrir um pull request (em geral, quem tem acesso de leitura ao repositório) consegue comprometer o ambiente do executor auto-hospedado, inclusive obtendo acesso aos secrets e ao `GITHUB_TOKEN`.
- **Repositórios públicos.** Os executores auto-hospedados quase nunca devem ser usados em repositórios públicos, porque qualquer usuário pode abrir um pull request.
- **Um executor, muitos repositórios.** Um executor no nível da organização aceita trabalhos de todos os repositórios com permissão para usá-lo, então um comprometimento se espalha. Os grupos de executores limitam quais repositórios chegam a quais executores.
- **O que fica na máquina.** Chaves SSH, tokens de API e acesso de rede a serviços internos ou ao serviço de metadados de uma nuvem ficam todos ao alcance de um trabalho.
- **Excluir a máquina depois de um trabalho não basta sozinho.** Não há como garantir que um executor auto-hospedado rode só um trabalho. A solução do GitHub é um executor just-in-time, que executa no máximo um trabalho, iniciado em um ambiente limpo pela sua própria automação.
- **As configurações de aprovação não protegem o seu hardware.** Quando o workflow de um fork recebe permissão para rodar, código de workflow potencialmente malicioso e controlado pelo usuário roda automaticamente em um executor auto-hospedado.

## O que uma configuração segura exige

A orientação do GitHub, como trabalho:

| A orientação do GitHub | Em um executor que você hospeda | No Skipbox |
|---|---|---|
| Um executor que aceita um trabalho | Chamar a API REST para uma configuração just-in-time antes de cada trabalho e iniciar o executor com ela | Cada executor é registrado just-in-time para um trabalho, com os rótulos desse trabalho, e removido depois |
| Um ambiente limpo para ele | Subir uma VM nova por trabalho e excluí-la, ou escrever uma limpeza em que você confie | Credenciais, processos, contêineres e arquivos de credenciais apagados depois de cada trabalho; uma VM nova por trabalho com Limpar a cada trabalho |
| O código de fora mantido à parte | Um segundo pool de máquinas para forks, e um roteamento que nunca os misture | O código de pessoas sem acesso de escrita sempre roda em uma VM nova |
| Pouco na máquina | Manter chaves, tokens e rotas da rede interna fora do host | Uma VM fora da sua rede, sem conexões de entrada |
| Acesso delimitado | Grupos de executores por repositório ou equipe | A sua máquina roda só os trabalhos da sua conta; em uma conta pessoal, cada executor é registrado no próprio repositório do trabalho |
| Patches | O sistema operacional, o Docker e o executor, no seu calendário | A imagem é atualizada para você, pelo menos uma vez por mês |

Feito à mão, isso é um autoscaler, um pipeline de imagens e um segundo pool de executores. No Skipbox, é o padrão.

## O que o Skipbox isola, exatamente

### A sua máquina própria

Cada plano, e o teste, dá à sua conta a VM dedicada. Ela roda só os trabalhos da sua conta, um por vez, e é mantida entre os trabalhos: as imagens e o cache de build do Docker, os caches de pacotes e as ferramentas instaladas ficam, e é por isso que o próximo trabalho é rápido.

Depois de cada trabalho, o Skipbox:

- apaga as credenciais do executor
- para todos os processos do usuário do executor e remove todos os contêineres
- apaga os arquivos de credenciais: `~/.docker/config.json`, `~/.npmrc`, `~/.git-credentials`, `~/.config/gh`, `~/.aws/credentials`, `~/.kube/config`, `~/.ssh/id_*`
- remove as credenciais do git no checkout e na configuração do git dos diretórios home, os hooks do checkout e os arquivos não rastreados dele
- verifica a máquina (disco, pacotes, Docker, o executor, DNS, processos e contêineres restantes) e a recria a partir da imagem se a verificação falhar

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. A máquina também é recriada quando você clica em **Redefinir máquina**, e quando a imagem é atualizada, pelo menos uma vez por mês.

Os trabalhos da sua conta dividem esse disco, e é isso que deixa os caches e o resultado do build prontos para o próximo trabalho. Para manter repositórios ou branches separados uns dos outros, ative Limpar a cada trabalho.

### Uma VM nova

Estes trabalhos rodam em uma VM nova que não rodou nenhum outro trabalho, excluída com o disco quando o trabalho termina:

- todos os trabalhos, quando **Limpar a cada trabalho** está ativado
- o código de pessoas sem acesso de escrita, como pull requests de forks
- os trabalhos que chegam enquanto todas as suas máquinas dedicadas estão ocupadas

Uma execução conta como da sua equipe quando o código dela é do próprio repositório e a pessoa que a iniciou tem acesso de escrita, de manutenção ou de administração. Todo o resto é tratado como código de fora: o pull request de um fork, um `pull_request_target` ou `workflow_run` iniciado a partir do código de um fork, um `issue_comment` de alguém sem acesso de escrita. A regra é a mesma em repositórios privados e públicos. Um trabalho de fora lê os seus caches e não pode alterá-los, e um que mesmo assim chegue à sua máquina dedicada falha antes de os steps dele rodarem; a máquina é então redefinida.

### Em volta da VM

- **Um trabalho por executor.** Cada executor é registrado just-in-time para um único trabalho. Um executor que continua registrado depois do trabalho é removido.
- **Nenhuma conexão de entrada.** Nada na internet consegue se conectar à VM de um trabalho.
- **Nenhum acesso ao seu código.** O app do Skipbox não consegue ler os seus repositórios; cada trabalho faz o checkout do seu código por conta própria, dentro da VM dele.
- **Nenhum outro cliente.** Nenhum trabalho de outra organização roda na sua máquina.

A VM de um trabalho guarda os secrets do workflow e o token do GitHub para aquele trabalho, e o Skipbox os apaga quando o trabalho termina. [Como os trabalhos são mantidos separados](https://docs.skipbox.dev/pt-br/isolation) tem todos os detalhes.

## Quanto custa ao lado dos executores do GitHub

Os minutos auto-hospedados são grátis no GitHub, e os executores do Skipbox são executores auto-hospedados.

| 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 da computação incluída. Calcule os seus próprios minutos na [calculadora da página inicial](https://skipbox.dev/?ref=g-self-hosted-runner-security-private-repositories-pt-br#cost); sem login.

## Mudar é uma linha

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest, or self-hosted
    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.

Para uma VM nova a cada trabalho, ative **Limpar a cada trabalho** em Planos e cobrança.

## Teste em um repositório privado

O teste não pede cartão e dura 7 dias ou 3.000 minutos de trabalhos. Mova um trabalho para `runs-on: skipbox` e aposente o executor que você estava prestes a proteger.

## Perguntas frequentes

### Executores auto-hospedados são seguros para repositórios privados?

Só com o trabalho que os executores hospedados pelo GitHub fazem por você. A documentação do GitHub diz que um executor auto-hospedado não tem garantia de uma máquina limpa e efêmera e pode ser comprometido de forma persistente por código não confiável, e que, em um repositório privado, qualquer pessoa que consiga fazer fork dele e abrir um pull request pode chegar ao executor, aos secrets dele e ao GITHUB_TOKEN. O Skipbox fecha essas brechas para você: uma máquina que roda só os trabalhos da sua conta, credenciais apagadas depois de cada trabalho, um executor registrado para um trabalho e uma VM nova para o código de pessoas sem acesso de escrita.

### Como configurar um executor auto-hospedado do GitHub Actions com segurança, com uma VM nova por trabalho?

Registre cada executor just-in-time para um único trabalho, inicie-o em uma VM que não rodou nenhum outro trabalho, exclua a VM quando o trabalho terminar, mantenha os pull requests de pessoas de fora longe das máquinas que a sua equipe usa e encaminhe os logs do executor antes de a VM sumir. Isso é um autoscaler para construir e operar. No Skipbox é um interruptor: ative Limpar a cada trabalho e cada trabalho roda em uma VM nova, excluída com o disco depois. Troque o runs-on para skipbox para começar.

### O Skipbox roda cada trabalho em uma VM nova?

Com Limpar a cada trabalho ativado, sim: cada trabalho roda em uma VM nova que não rodou nenhum outro trabalho, excluída com o disco quando o trabalho termina. Sem isso, os trabalhos da sua equipe rodam na máquina dedicada da sua conta, mantida entre os trabalhos para as camadas Docker e os caches de pacotes ficarem; depois de cada trabalho, o Skipbox apaga as credenciais do executor, para os processos dele, remove todos os contêineres e apaga os arquivos de credenciais. O código de pessoas sem acesso de escrita, e os trabalhos que chegam enquanto as suas máquinas estão ocupadas, sempre recebem uma VM nova.

### O que um executor auto-hospedado guarda entre os trabalhos?

Tudo, a menos que você o limpe: arquivos, processos, contêineres, credenciais do Docker, chaves SSH e tokens que o último trabalho gravou. A documentação do GitHub diz que um executor auto-hospedado não precisa de uma instância limpa para cada trabalho. Em uma máquina dedicada do Skipbox, os caches e o seu checkout ficam, e as credenciais, os processos e os contêineres saem depois de cada trabalho; uma máquina que falha na verificação depois de um trabalho é recriada a partir de uma imagem limpa.

### Um pull request de um fork pode rodar no meu executor auto-hospedado?

Em um executor que você hospeda, sim, assim que a política de forks do repositório deixa os workflows deles rodarem: a documentação do GitHub avisa que o código de workflow controlado pelo usuário então roda na sua infraestrutura. No Skipbox, o pull request de um fork nunca roda na sua máquina dedicada. Ele roda em uma VM nova que pode ler os seus caches mas não pode alterá-los, e um trabalho de um fork que mesmo assim chegue à sua máquina dedicada falha antes de os steps dele rodarem.

### Executores auto-hospedados são seguros para repositórios públicos?

O GitHub diz que os executores auto-hospedados quase nunca devem ser usados em repositórios públicos, porque qualquer usuário pode abrir um pull request e comprometer a máquina. O Skipbox roda os trabalhos de repositórios públicos mantendo esses pull requests longe da sua máquina: o código de pessoas sem acesso de escrita roda em uma VM nova, excluída depois, e a sua máquina dedicada roda só o código da sua equipe.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/self-hosted-runner-security-private-repositories
