Executores auto-hospedados são seguros para repositórios privados? As regras de proteção do GitHub, feitas para você
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 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.
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 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; sem login.
Mudar é uma linha
jobs:
build:
runs-on: skipbox # was ubuntu-latest, or self-hosted
steps:
- uses: actions/checkout@v4
- run: npm ci && npm test
- Entre no Skipbox com o GitHub.
- Instale o app do Skipbox no GitHub e escolha os seus repositórios.
- Troque o
runs-one 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 19 de novembro de 2026