Sobre executores auto-hospedados

Você pode hospedar seus próprios executores e personalizar o ambiente usado para executar trabalhos nos seus fluxos de trabalho do GitHub Actions.

Neste artigo

Sobre executores auto-hospedados

Um executor auto-hospedado é um sistema que você implanta e gerencia para executar trabalhos do GitHub Actions em GitHub. Para saber mais sobre GitHub Actions, confira "Entendendo o GitHub Actions."

Os executores auto-hospedados oferecem mais controle de ferramentas de hardware, sistema operacional e software do que os executores hospedados no GitHub fornecem. Com os executores auto-hospedados, você pode criar configurações de hardware personalizadas de acordo com suas necessidades, com o poder de processamento ou a memória para executar trabalhos maiores, instalar programas de software disponíveis na sua rede local e escolher um sistema operacional não oferecido pelos executores hospedados no GitHub. Os executores auto-hospedados podem ser físicos, virtuais, em um contêiner, no local ou em uma nuvem.

Você pode adicionar runners auto-hospedados em vários níveis na hierarquia de gerenciamento:

  • Runners em nível de repositório são dedicados a um único repositório.
  • Executores no nível da organização podem processar trabalhos para vários repositórios em uma organização.
  • Runners de nível empresarial podem ser atribuídos a várias organizações em uma conta corporativa.

A sua máquina do executor conecta-se ao GitHub usando o aplicativo do executor auto-hospedado de GitHub Actions. O aplicativo de executor do GitHub Actions tem código aberto. Você pode contribuir e apresentar problemas no repositório do executor. Quando uma nova versão for lançada, o aplicativo do executor é atualizado automaticamente quando um trabalho é atribuído ao executor ou uma semana após o lançamento, caso o executor não tenha recebido nenhum trabalho.

Um executor auto-hospedado é automaticamente removido de GitHub se não se conectar a GitHub Actions por mais de 14 dias. Um executor auto-hospedado efêmero é removido automaticamente de GitHub se não estiver conectado a GitHub Actions por mais de 1 dia.

Para saber mais sobre como instalar e usar executores auto-hospedados, confira "Adicionar executores auto-hospedados" e "Usar os executores auto-hospedados em um fluxo de trabalho".

Diferenças entre executores auto-hospedados e hospedados pelo GitHub

Os executores hospedados no GitHub oferecem uma maneira mais rápida e mais simples de executar seus fluxos de trabalho, enquanto os executores auto-hospedados são uma maneira altamente configurável de executar fluxos de trabalho em seu próprio ambiente personalizado.

Executores hospedado em GitHub:

  • Receba atualizações automáticas do sistema operacional, pacotes e ferramentas pré-instalados e o aplicativo do executor auto-hospedado.
  • São gerenciados e mantidos por GitHub.
  • Fornecem uma instância limpa para cada execução de trabalho.
  • Use minutos grátis no seu plano GitHub, com taxas por minuto aplicadas após exceder os minutos grátis.

Executores auto-hospedados:

  • Receba atualizações automáticas apenas para o aplicativo do executor auto-hospedado, embora você possa desabilitar atualizações automáticas do executor. Para obter mais informações sobre como controlar as atualizações de software do executor em executores auto-hospedados, confira "Redimensionamento automático com executores auto-hospedados". Você é responsável por atualizar o sistema operacional e todos os outros softwares.
  • Podem usar serviços de nuvem ou máquinas locais pelos quais você já pagou.
  • São personalizáveis conforme seus requisitos de hardware, sistema operacional, software e segurança.
  • Não precisam ter uma instância limpa para cada execução de trabalho.
  • É grátis para usar com GitHub Actions, mas você é o responsável pelo custo de manter seus executores.

Requisitos para executores auto-hospedados

Você pode usar qualquer máquina como um executor auto-hospedado, desde que ela atenda a estes requisitos:

  • Você pode instalar e executar o aplicativo do executor auto-hospedado na máquina. Para obter mais informações, confira "Arquiteturas e sistemas operacionais compatíveis com executores auto-hospedados".
  • A máquina pode comunicar-se com GitHub Actions. Para obter mais informações, confira "Comunicação entre executores auto-hospedados e o GitHub".
  • A máquina tem recursos de hardware suficientes para o tipo de fluxos de trabalho que você planeja executar. O aplicativo do executor auto-hospedado requer apenas recursos mínimos.
  • Se você desejar executar fluxos de trabalho que usam ações do contêiner do Docker ou dos contêineres de serviço, você deverá usar uma máquina Linux e o Docker deve estar instalados.

Dimensionar automaticamente os seus executores auto-hospedados

Você pode aumentar ou diminuir automaticamente o número de executores auto-hospedados no seu ambiente em resposta aos eventos que você receber. Para obter mais informações, confira "Redimensionamento automático com executores auto-hospedados".

Limites de uso

Existem alguns limites sobre o uso de GitHub Actions ao usar executores auto-hospedados. Estes limites estão sujeitos a mudanças.

  • Tempo de execução do trabalho - Cada trabalho em um fluxo de trabalho pode ser executado por até 5 dias de tempo de execução. Se um trabalho atingir esse limite, ele será encerrado e não será concluído. * Tempo de execução do fluxo de trabalho – Cada execução de fluxo de trabalho é limitada a 35 dias. Se a execução de um fluxo de trabalho atingir esse limite, a execução do fluxo de trabalho será cancelada. Esse período inclui a duração da execução e o tempo gasto em espera e aprovação.
  • Tempo da fila de trabalho - Cada trabalho para executores auto-hospedados que estiver na fila por pelo menos 24 horas será cancelado. O tempo real na fila pode chegar a 48 horas antes de ocorrer o cancelamento. Se um executor auto-hospedado não começar a executar a tarefa dentro deste limite, a tarefa será encerrada e não será concluída.
  • Solicitações de API - Você pode executar até 1.000 solicitações para a API do GitHub em uma hora em todas as ações dentro de um repositório. Se o número de solicitações for excedido, as chamadas à API adicionais falharão, o que poderá causar falha nos trabalhos.
  • Matriz de trabalho – Uma matriz de tarefas pode gerar 256 tarefas no máximo por execução do fluxo de trabalho. Esse limite se aplica a executores hospedados por GitHub e auto-hospedados.
  • Fila de execução de fluxo de trabalho – No máximo, 500 execuções de fluxo de trabalho podem ser colocadas na fila em um intervalo de dez segundos por repositório. Se a execução de um fluxo de trabalho atingir esse limite, a execução do fluxo de trabalho terminará e falhará em ser concluída.
  • Como registrar executores auto-hospedados – você pode ter no máximo 10.000 executores auto-hospedados em um grupo de corredores. Se esse limite for atingido, não será possível adicionar um novo executor.

Continuidade do fluxo de trabalho para executores auto-hospedados

Se os serviços de GitHub Actions estiverem temporariamente indisponíveis, a execução do fluxo de trabalho será descartada se não tiver sido enfileirada em 30 minutos após ser acionada. Por exemplo, se um fluxo de trabalho for acionado e os serviços de GitHub Actions não estiverem disponíveis por 31 minutos ou mais, a execução do fluxo de trabalho não será processada.

Arquiteturas e sistemas operacionais compatíveis com executores auto-hospedados

Os sistemas operacionais a seguir são compatíveis com o aplicativo de execução auto-hospedado.

Linux

  • Red Hat Enterprise Linux 8 ou posterior
  • CentOS 8 ou posterior
  • Oracle Linux 8 ou posterior
  • Fedora 29 ou versão posterior
  • Debian 10 ou versão posterior
  • Ubuntu 20.04 ou posterior
  • Linux Mint 20 ou posterior
  • openSUSE 15.2 ou posterior
  • SUSE Enterprise Linux (SLES) 15 SP2 ou posterior

Windows

  • Windows 10 64 bits
  • Windows 11 de 64 bits
  • Windows Server 2016 de 64 bits
  • Windows Server 2019 64-bit
  • Windows Server 2022 de 64 bits

macOS

  • macOS 11.0 (Big Sur) ou posterior

Arquiteturas

As seguintes arquiteturas de processador são compatíveis com o aplicativo do executor auto-hospedado.

  • x64 – Linux, macOS e Windows.
  • ARM64 – Linux, macOS, Windows (atualmente em versão prévia pública).
  • ARM32 – Linux.

Comunicação entre executores auto-hospedados e GitHub

O executor auto-hospedado conecta-se a GitHub para receber atividades de trabalho e fazer o download de novas versões do aplicativo do executor. O executor auto-hospedado usa uma sondagem longa HTTPS que abre uma conexão com o GitHub por 50 segundos. Se nenhuma resposta for recebida, ela atingirá o tempo limite e criará uma sondagem longa. O aplicativo deve estar rodando na máquina para aceitar e executar trabalhos do GitHub Actions.

A conexão entre os executores auto-hospedados e o GitHub é feita por HTTPS (porta 443).

Como o executor auto-hospedado abre uma conexão com GitHub, você não precisa permitir que GitHub faça conexões de entrada com o executor auto-hospedado.

Você deve garantir que a máquina tenha acesso adequado à rede com velocidades de upload e download de pelo menos 70 quilobits por segundo para a comunicação com os hosts de GitHub listados abaixo. Alguns hosts são necessários para operações essenciais de executores, enquanto outros hosts só são necessários para certas funcionalidades.

Você pode usar a API REST para obter metainformações sobre a GitHub, incluindo os endereços IP dos serviços da GitHub. Para obter mais informações sobre os domínios e endereços IP usados, consulte "Pontos de extremidade da API REST para metadados".

Note

Alguns dos domínios listados são configurados por meio de registros CNAME. Alguns firewalls podem exigir que você adicione regras de maneira recursiva para todos os registros CNAME. Observe que os registros CNAME poderão mudar no futuro e que apenas os domínios listados permanecerão constantes.

Necessário para operações essenciais:

Shell
github.com
api.github.com
*.actions.githubusercontent.com

Necessário para baixar as ações:

Shell
codeload.github.com
ghcr.io
*.actions.githubusercontent.com

Necessário para upload/download de caches e artefatos de fluxo de trabalho:

Shell
results-receiver.actions.githubusercontent.com
*.blob.core.windows.net

Necessário para as atualizações de versão do executor:

Shell
objects.githubusercontent.com
objects-origin.githubusercontent.com
github-releases.githubusercontent.com
github-registry-files.githubusercontent.com

Necessário para recuperar tokens OIDC:

Shell
*.actions.githubusercontent.com

Necessário para baixar ou publicar pacotes ou contêineres em pacotes do GitHub:

Shell
*.pkg.github.com
ghcr.io

Necessário para o Git Large File Storage

Shell
github-cloud.githubusercontent.com
github-cloud.s3.amazonaws.com

Necessário para trabalhos das Dependabot updates

Shell
dependabot-actions.githubapp.com

Além disso, seu fluxo de trabalho pode exigir acesso a outros recursos de rede.

Se você usar uma lista de endereços IP permitida para a sua a sua organização ou conta corporativa do GitHub, você deverá adicionar o endereço IP do executor auto-hospedado à lista de permissões. Para obter mais informações, confira "Como gerenciar endereços IP permitidos para sua organização" ou "Como impor políticas para configurações de segurança na sua empresa" na documentação do GitHub Enterprise Cloud.

Você também pode usar executores auto-hospedados com um servidor proxy. Para obter mais informações, confira "Usar um servidor proxy com os executores auto-hospedados".

Para saber mais sobre como solucionar problemas comuns de conectividade de rede, confira "Monitorar e solucionar problemas de executores auto-hospedados".

Segurança dos executores auto-hospedados

Recomendamos que você use apenas executores auto-hospedados com repositórios privados. Isso acontece porque as bifurcações do seu repositório público podem executar código perigoso em seu computador de executor auto-hospedado criando uma solicitação de pull que executa o código em um fluxo de trabalho.

Este não é um problema com executores hospedados no GitHub, pois cada executor hospedado no GitHub é sempre uma máquina virtual limpa e isolada, que é destruída no final da execução do trabalho.

Os fluxos de trabalho não confiáveis no seu executor auto-hospedado representam riscos de segurança significativos para seu ambiente de rede e máquina, especialmente se sua máquina persistir no ambiente entre os trabalhos. Alguns dos riscos incluem:

  • Programas maliciosos em execução na máquina.
  • Sair do sandbox do executor da máquina.
  • Expor acesso ao ambiente de rede da máquina.
  • Dados persistentes, indesejados ou perigosos na máquina.

Para saber mais sobre proteção de segurança para executores auto-hospedados, confira "Fortalecimento de segurança para o GitHub Actions".

Como restringir o uso de executores auto-hospedados

Proprietários de organizaçõespodem escolher que repositórios têm permissão para criar executores auto-hospedados no nível do repositório. .

Para obter mais informações, confira "Desabilitar ou limitar o GitHub Actions para sua organização".