Skipbox

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:

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.

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
  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 19 de novembro de 2026

CI/CD mais rápido com um cache sempre aquecido

Seu executor aquecido a preço fixo

Nós hospedamos. Você muda uma linha. 1/12 do custo do GitHub com uso total. Preço fixo, então rode o dia todo. 7× o espaço de cache do GitHub.

  • Sem cartão
  • Entrar com o GitHub
  • Cancele quando quiser