Skip to main content
We publish frequent updates to our documentation, and translation of this page may still be in progress. For the most current information, please visit the English documentation.

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 (GB)Armazenamento (SSD)
4 núcleos16 de RAM150 GB
8 núcleos32 de RAM300 GB
16 núcleos64 de RAM600 GB
32 núcleos128 de RAM1.200 GB
64 núcleos256 de RAM2.040 GB

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 aos executor maiors".

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 explicando executor maior

  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.

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 aos executor maiors".

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 "Taxas por minuto".

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.

Você também pode definir os rótulos que identificam o executor, que é o modo como seus fluxos de trabalho poderão enviar trabalhos aos executores para processamento (usando runs-on). 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 aos executor maiors".

  1. Na barra lateral da empresa, clique em Políticas. Guia Políticas na barra lateral da conta corporativa 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.

Você também pode definir os rótulos que identificam o executor, que é o modo como seus fluxos de trabalho poderão enviar trabalhos aos executores para processamento (usando runs-on). 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 aos executor maiors".

  1. No GitHub.com, navegue até a página principal da organização. 1. No nome da sua organização, clique em Configurações. Botão Configurações da organização 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

Usar vários rótulos

Você pode especificar vários rótulos que precisam ser correspondidos para que um trabalho seja executado em um executor. Um executor precisará corresponder a todos os rótulos para ser qualificado para executar o trabalho.

Neste exemplo, um executor precisará corresponder a todos os três rótulos para executar o trabalho:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on:
      labels: [ ubuntu-20.04-16core, gpu, qa ]
    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

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. Antes que o repositório chamado octo-repo possa usar os executores do grupo, primeiro você deve configurar o grupo no nível da empresa para permitir o acesso da organização octo-org; em seguida, você deve configurar o grupo no nível da organização para permitir o acesso de octo-repo:

Diagrama explicando os grupos de executor maior

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

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 aos executor maiors".