Usando executores maiores

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úcleos	16 GB	150 GB
8 núcleos	32 GB	300 GB
16 núcleos	64 GB	600 GB
32 núcleos	128 GB	1.200 GB
64 núcleos	256 GB	2.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.

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 no total em todos os executor maiors.

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

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. 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 .

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 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 em Configurações.

   1. Na barra lateral esquerda, clique em Ações e 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.

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

Como gerenciar o acesso aos seus executores

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.

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. Acesse a página principal do repositório ou da organização em que os grupos de executores estão localizados.
2. Clique em Configurações.
3. Na barra lateral esquerda, clique em Ações e depois em 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.