Skip to main content
Publicamos atualizações frequentes em nossa documentação, e a tradução desta página ainda pode estar em andamento. Para obter as informações mais atualizadas, acesse a documentação em inglês.

Usando executores maiores

GitHub oferece executores maiores, com mais RAM e mais CPU.

O recurso de executor maiors está atualmente em versão beta para organizações e empresas usando os planos GitHub Team ou GitHub Enterprise Cloud, e está sujeito a alterações. Para solicitar acesso ao beta, visite a página de inscrição.

Visão geral dos executor maiors

Além dos executores hospedados GitHub padrão, o GitHub também oferece aos clientes de planos GitHub Team e GitHub Enterprise Cloud um intervalo de executor maiors com mais RAM e mais CPU. Esses executores são hospedados por GitHub e têm o aplicativo executor e outras ferramentas pré-instalados.

Quando executor maiors são habilitados para a organização, um grupo de executores padrão é criado automaticamente com um conjunto de quatro executor maior pré-configurados.

Ao adicionar um executor maior a uma organização, você está definindo um tipo de computador dentre uma seleção de especificações de hardware e imagens de sistema operacional disponíveis. GitHub criarão várias instâncias desse executor que são escaladas verticalmente para corresponder às demandas de trabalho da sua organização, com base nos limites de dimensionamento automático definidos.

Especificações de computador para executor maiors

Tamanho (vCPU)Memória (RAM)Armazenamento (SSD)
4 núcleos16 GB150 GB
8 núcleos32 GB300 GB
16 núcleos64 GB600 GB
32 núcleos128 GB1.200 GB
64 núcleos256 GB2.040 GB

Recursos adicionais para executor maior

Em comparação com o GitHub hospedado padrão, o executor maior têm os seguintes recursos adicionais:

  • Para executores do Ubuntu, a aceleração de hardware para as ferramentas do SDK do Android está habilitada. Isso torna a execução de testes do Android muito mais rápida e consome menos minutos. Para obter mais informações sobre a aceleração de hardware do Android, confira a documentação do Desenvolvedor do Android.

Para obter uma lista completa das ferramentas incluídas para cada sistema operacional executor, confira o repositório Imagens do executor GitHub Actions.

Visão geral de arquitetura de executor maiors

Os executor maiors são gerenciados no nível da organização, em que são organizados em grupos que podem conter várias instâncias do executor. Eles também podem ser criados no nível da empresa e compartilhados com as organizações na hierarquia. Depois de criar um grupo, você pode adicionar um executor ao grupo e atualizar seus fluxos de trabalho para direcionar o nome do grupo ou o rótulo atribuído a executor maior. Você também pode controlar quais repositórios têm permissão para enviar trabalhos ao grupo para processamento. Para obter mais informações sobre grupos, confira "Como controlar o acesso a executores maiores".

No diagrama a seguir, uma classe de executor hospedado nomeado ubuntu-20.04-16core foi definida com configuração personalizada de hardware e sistema operacional.

Diagrama que mostra um executor maior sendo usado por um fluxo de trabalho devido ao rótulo do executor.

  1. As instâncias desse executor são criadas e adicionadas automaticamente a um grupo chamado grp-ubuntu-20.04-16core.
  2. Os executores receberam o rótulo ubuntu-20.04-16core.
  3. Trabalhos de fluxo de trabalho usam o rótulo ubuntu-20.04-16core na chave runs-on deles para indicar o tipo de executor necessário para executar o trabalho.
  4. GitHub Actions verifica o grupo de executores para ver se o seu repositório está autorizado a enviar trabalhos ao executor.
  5. O trabalho é executado na próxima instância disponível do executor ubuntu-20.04-16core.

Autoscaling executor maiors

Seus executor maiors podem ser configurados para escalar automaticamente a fim de atender às suas necessidades. Quando os trabalhos são enviados para processamento, mais computadores podem ser provisionados automaticamente para executar os trabalhos até atingir um limite máximo predefinido. Cada computador gerencia apenas um trabalho por vez, portanto, essas configurações determinam efetivamente o número de trabalhos que podem ser executados simultaneamente.

Durante o processo de implantação do executor, você pode configurar a opção Max, que permite controlar seus custos definindo o número máximo de computadores paralelos criados neste conjunto. Um valor mais alto aqui pode ajudar a evitar que os fluxos de trabalho sejam bloqueados devido ao paralelismo.

Networking for executor maiors

Por padrão, os executor maiors recebem um endereço IP dinâmico que é alterado para cada trabalho executado. Opcionalmente, os clientes de GitHub Enterprise Cloud podem configurar os executor maiors deles para receber um endereço IP estático do pool de endereços IP do GitHub. Quando habilitadas, as instâncias de executor maior receberão um endereço de um intervalo exclusivo para o executor, permitindo que você use esse intervalo para configurar uma lista de permissões de firewall. Você pode usar até dez intervalos de endereços IP estáticos para os executor maiors criados no nível da empresa. Além disso, você pode usar até dez intervalos de endereços IP estáticos para os executor maiors criados no nível da organização, para cada organização na empresa.

Observação: se os executores não forem usados por mais de 30 dias, os intervalos de endereços IP deles serão removidos automaticamente e não poderão ser recuperados.

Planejamento para executor maiors

Criar um grupo de executores

Os grupos de executores são usados para coletar conjuntos de máquinas virtuais e criar um limite de segurança ao redor delas. Em seguida, você pode decidir quais organizações ou repositórios têm permissão para executar trabalhos nesses conjuntos de computadores. Durante o processo de implantação de executor maior, o executor pode ser adicionado a um grupo existente ou, caso contrário, ele ingressará em um grupo padrão. Você pode criar um grupo seguindo as etapas em "Como controlar o acesso a executores maiores".

Noções básicas sobre cobrança

Observação: os executor maiors não usam minutos de direito incluídos e não são gratuitos para repositórios públicos.

Em comparação com os executores hospedados GitHub padrão, os executor maiors são cobrados de maneira diferente. Para obter mais informações, confira "Sobre a cobrança das GitHub Actions".

Como adicionar um executor maior a uma empresa

Você pode adicionar os executor maiors a uma empresa, em que eles podem ser atribuídos a várias organizações. Então, os administradores da organização poderão controlar quais repositórios podem usar os executores. Para adicionar um executor maior a uma empresa, você deve ser o proprietário da empresa.

Você pode escolher um sistema operacional e uma configuração de hardware na lista de opções disponíveis. Quando novas instâncias desse executor forem implantadas por meio do dimensionamento automático, elas usarão o mesmo sistema operacional e a mesma configuração de hardware que você definiu aqui.

Novos executores são atribuídos automaticamente ao grupo padrão, ou você pode escolher em qual grupo os executores devem ingressar durante o processo de criação dos executores. Além disso, você pode modificar a associação ao grupo do executor depois de registrá-lo. Para obter mais informações, confira "Como controlar o acesso a executores maiores".

  1. No canto superior direito do GitHub.com, clique na foto do seu perfil e em Suas empresas.

  2. Na lista de empresas, clique na empresa que você deseja visualizar.

  3. Na barra lateral da empresa, clique em Políticas. 1. Em " Políticas", clique em Actions. 1. Clique na guia Executores. 1. Clique em Novo executor e clique em Novo executor hospedado no GitHub .

  4. Preencha os detalhes obrigatórios para configurar seu novo executor:

    • Nome: insira um nome para seu novo executor. Para facilitar a identificação, esse campo deve indicar o hardware e configuração operacional, como ubuntu-20.04-16core.
    • Imagem do executor: escolha um sistema operacional entre as opções disponíveis. Depois de selecionar um sistema operacional, você poderá escolher uma versão específica.
    • Tamanho do executor: escolha uma configuração de hardware na lista suspensa de opções disponíveis.
    • Dimensionamento automático: escolha o número máximo de executores que podem estar ativos a qualquer momento.
    • Grupo do executor: escolha o grupo do qual seu executor será membro. Esse grupo hospedará várias instâncias do seu executor, à medida que elas escalarem verticalmente para atender à demanda.
    • Rede: somente para dados GitHub Enterprise Cloud: escolha se um intervalo de endereços IP estáticos será atribuído a instâncias de executor maior. Você pode usar até 10 endereços IP estáticos no total.
  5. Clique em Criar executor.

  6. Para permitir que as organizações acessem seus executor maiors, especifique a lista de organizações que podem usá-los. Para obter mais informações, confira "Como gerenciar o acesso aos seus executores".

Como adicionar um executor maior a uma organização

Você pode adicionar um executor maior a uma organização em que os administradores poderão controlar quais repositórios podem usá-lo.

Você pode escolher um sistema operacional e uma configuração de hardware na lista de opções disponíveis. Quando novas instâncias desse executor forem implantadas por meio do dimensionamento automático, elas usarão o mesmo sistema operacional e a mesma configuração de hardware que você definiu aqui.

Novos executores são atribuídos automaticamente ao grupo padrão, ou você pode escolher em qual grupo os executores devem ingressar durante o processo de criação dos executores. Além disso, você pode modificar a associação ao grupo do executor depois de registrá-lo. Para obter mais informações, confira "Como controlar o acesso a executores maiores".

  1. No GitHub.com, navegue até a página principal da organização. 1. No nome da sua organização, clique Configurações. Caso não consiga ver a guia "Configurações", selecione o menu suspenso , clique em Configurações.

    Captura de tela da barra de navegação horizontal para uma organização. A guia "Configurações" está contornada em laranja escuro. 1. Na barra lateral esquerda, clique em Ações e depois em Executores. 1. Clique em Novo executor e clique em Novo executor hospedado no GitHub .

  2. Preencha os detalhes obrigatórios para configurar seu novo executor:

    • Nome: insira um nome para seu novo executor. Para facilitar a identificação, esse campo deve indicar o hardware e configuração operacional, como ubuntu-20.04-16core.
    • Imagem do executor: escolha um sistema operacional entre as opções disponíveis. Depois de selecionar um sistema operacional, você poderá escolher uma versão específica.
    • Tamanho do executor: escolha uma configuração de hardware na lista suspensa de opções disponíveis.
    • Dimensionamento automático: escolha o número máximo de executores que podem estar ativos a qualquer momento.
    • Grupo do executor: escolha o grupo do qual seu executor será membro. Esse grupo hospedará várias instâncias do seu executor, à medida que elas escalarem verticalmente para atender à demanda.
    • Rede: somente para dados GitHub Enterprise Cloud: escolha se um intervalo de endereços IP estáticos será atribuído a instâncias de executor maior. Você pode usar até 10 endereços IP estáticos no total.
  3. Clique em Criar executor.

  4. Para permitir que os repositórios acessem seus executor maiors, adicione-os à lista de repositórios que podem usá-los. Para obter mais informações, confira "Como gerenciar o acesso aos seus executores".

Como executar trabalhos em seu executor

Depois que o tipo de executor for definido, você poderá atualizar os arquivos YAML de fluxo de trabalho para enviar trabalhos às instâncias de executor recém-criadas para processamento. Você pode usar grupos de executores ou rótulos para definir onde seus trabalhos são executados.

Observação: quando você adiciona um executor maior, ele recebe automaticamente rótulos padrão que correspondem ao nome e ao sistema operacional do executor. Você não pode adicionar rótulos personalizados a executor maior, mas pode usar os rótulos padrão ou o grupo do executor para enviar trabalhos a tipos específicos de executores.

Somente contas de proprietário ou administrador podem ver as configurações do executor. Usuários não administrativos podem entrar em contato com o administrador da organização para descobrir quais executores estão habilitados. O administrador da sua organização pode criar novos executores e grupos de executores, bem como configurar permissões para especificar quais repositórios podem acessar um grupo de executores.

Usar grupos para controlar onde os trabalhos são executados

Neste exemplo, os executores do Ubuntu foram adicionados a um grupo chamado ubuntu-runners. A chave runs-on envia o trabalho para qualquer executor disponível no grupo ubuntu-runners:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on: 
      group: ubuntu-runners
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

Usar rótulos para controlar onde os trabalhos são executados

Neste exemplo, um grupo de executores é preenchido com executores Ubuntu de 16 núcleos, que também receberam o rótulo ubuntu-20.04-16core. A chave runs-on envia o trabalho para qualquer executor disponível com um rótulo correspondente:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on:
      labels: ubuntu-20.04-16core
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

Usar rótulos e grupos para controlar onde os trabalhos são executados

Quando você combina grupos e rótulos, o executor deve atender aos dois requisitos para ser qualificado para executar o trabalho.

Neste exemplo, um grupo de executores chamado ubuntu-runners é preenchido com executores do Ubuntu, que também receberam o rótulo ubuntu-20.04-16core. A chave runs-on combina group e labels para que o trabalho seja roteado para qualquer executor disponível dentro do grupo que também tenha um rótulo correspondente:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on:
      group: ubuntu-runners
      labels: ubuntu-20.04-16core
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

Usar nomes exclusivos para grupos de executores

GitHub Actions exige que os nomes de grupos de executores precisem ser exclusivos no nível da organização. Isso significa que uma organização não poderá mais criar um grupo de executores com o mesmo nome que um na empresa. Além disso, os usuários verão uma faixa de aviso em qualquer grupo de executores que compartilhem o mesmo nome de um grupo na empresa, sugerindo que o grupo da organização deve ser renomeado.

Para evitar ambiguidade, um fluxo de trabalho falhará se houver grupos de executores duplicados na organização e na empresa. Para resolver isso, você pode renomear um dos grupos de executores na organização ou na empresa ou atualizar o arquivo de fluxo de trabalho para adicionar um prefixo ao nome do grupo de executores:

  • org/ ou organization/
  • ent/ ou enterprise/

Exemplo: usar prefixos para diferenciar grupos de executores

Por exemplo, se você tiver um grupo de executores chamado my-group na organização e outro chamado my-group na empresa, poderá atualizar seu arquivo de fluxo de trabalho para usar org/my-group ou ent/my-group para diferenciar os dois.

Usando org/:

runs-on:
  group: org/my-group
  labels: [ self-hosted, label-1 ]

Usando ent/:

runs-on:
  group: ent/my-group
  labels: [ self-hosted, label-1 ]

Como gerenciar o acesso aos seus executores

Observação: antes que seus fluxos de trabalho possam enviar trabalhos para os executor maiors, primeiro você deve configurar permissões para o grupo de executores. Confira as seções a seguir para obter mais informações.

Os grupos de executores são usados para controlar quais repositórios podem executar trabalhos em seus executor maiors. Você deve conceder acesso ao grupo de cada nível da hierarquia de gerenciamento, dependendo de onde definiu os executor maior:

  • Executores no nível da empresa: configure o grupo de executores para conceder acesso a todas as organizações necessárias. Além disso, para cada organização, você deve configurar o grupo para especificar quais repositórios têm acesso permitido.
  • Executores no nível da organização: configure o grupo de executores especificando quais repositórios têm acesso permitido.

Por exemplo, o diagrama a seguir tem um grupo de executores chamado grp-ubuntu-20.04-16core no nível da empresa. Para que o repositório chamado octo-repo use os executores do grupo, primeiro, você precisa configurar o grupo no nível da empresa para permitir o acesso da organização octo-org. Em seguida, você precisará configurar o grupo no nível da organização para permitir o acesso por meio de octo-repo.

Diagrama que mostra um bloqueio entre um grupo de executores no nível empresarial e uma organização e entre a organização e dois repositórios pertencentes à organização.

Como permitir que os repositórios acessem um grupo de executores

Este procedimento demonstra como configurar permissões de grupo nos níveis da empresa e da organização:

  1. Navegue até onde seus grupos de executores estão localizados:

    • Em uma organização:

      1. Navegue até a página principal e clique em Configurações.
    • Se estiver usando um grupo de classe empresarial:

      1. No canto superior direito do GitHub.com, clique na foto do seu perfil e em Suas empresas.

      2. Na lista de empresas, clique na empresa que você deseja visualizar.

  2. Navegue até as configurações "Grupos de executor":

    • Em uma organização:

      1. Na barra lateral esquerda, clique em Ações e depois em Grupos de executores.
    • Se estiver usando um grupo de classe empresarial:

      1. Na barra lateral da empresa, clique em Políticas. 1. Em " Políticas", clique em Actions. 1. Clique na guia Grupos de executores. 1. Na lista de grupos, clique no grupo de executores que deseja configurar.
  • Para os grupos de executores de uma empresa: em Acesso da organização, modifique quais organizações podem acessar o grupo de executores.
  • Para os grupos de executores de uma organização: em Acesso do repositório, modifique quais repositórios podem acessar o grupo de executores.

Aviso:

Se você estiver usando um intervalo de IP fixo, a recomendação será usar apenas executor maior com repositórios particulares. Bifurcações do seu repositório podem executar códigos perigosos em seu executor maior criando uma solicitação de pull que executa o código em um fluxo de trabalho.

Para obter mais informações, confira "Como controlar o acesso a executores maiores".