Como executar trabalhos em executores maiores

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 proprietário da organização para descobrir quais executores estão habilitados. O proprietário 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. Para obter mais informações, confira "Gerenciar executores maiores".

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@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

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

Você pode passar implicitamente um rótulo para a chave runs-on usando a sintaxe runs-on: LABEL. Como alternativa, você pode usar a chave labels, como mostrado no exemplo abaixo.

Neste exemplo, a chave runs-on envia o trabalho para qualquer executor disponível ao qual tenha sido atribuído o rótulo ubuntu-20.04-16core rótulo:

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

Qualquer pessoa com acesso de gravação a um repositório habilitado para ações pode descobrir os rótulos dos executores que estão disponíveis nesse repositório. Confira "Como executar trabalhos em executores maiores".

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@v4
      - uses: actions/setup-node@v4
        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 ]

Se você observar que os trabalhos direcionados aos seus executor maior estão atrasados ou não estão em execução, há vários fatores que podem estar causando isso.

• Configurações de simultaneidade: talvez você tenha atingido o limite máximo de simultaneidade. Para permitir que mais trabalhos sejam executados em paralelo, atualize as configurações de dimensionamento automático para um número maior. Para obter mais informações, confira "Gerenciar executores maiores".
• Permissões de repositório: verifique se você tem as permissões de repositório apropriadas habilitadas para seus executor maior. Por padrão, os executores corporativos não estão disponíveis no nível do repositório e devem ser habilitados manualmente por um administrador da organização. Para obter mais informações, confira "Gerenciar executores maiores".
• Informações de cobrança: você deve ter um cartão de crédito válido no arquivo para usar executor maior. Depois de adicionar um cartão de crédito à sua conta, pode levar até 10 minutos para habilitar o uso dos executor maior. Para obter mais informações, confira "Adicionar ou editar a forma de pagamento".
• Limite de gastos: o limite de gastos do GitHub Actions deve ser definido como um valor maior que zero. Para obter mais informações, confira "Gerenciando seu limite de gastos das GitHub Actions".
• Política de uso justo: GitHub tem uma política de uso justo que começa a limitar os trabalhos com base em vários fatores, como quantos trabalhos você está executando ou quantos trabalhos estão sendo executados em toda a GitHub Actions.
• Fila de trabalhos para atribuir tempo: a fila de trabalhos para atribuir tempo refere-se ao tempo entre uma solicitação de trabalho e a GitHub atribuir uma VM para executar o trabalho. Os executores hospedados pela GitHub padrão que utilizam rótulos de fluxo de trabalho YAML prescritos (como ubuntu-latest) estão sempre em um estado "quente". Com executores avançados, uma máquina quente pode não estar pronta para assumir um trabalho na primeira solicitação, pois os pools para essas máquinas são menores. Como resultado, a GitHub pode precisar criar uma nova VM, o que aumenta a fila para atribuir tempo. Quando um executor está em uso, as VMs estão prontas para as execuções de fluxo de trabalho subsequentes, reduzindo a fila para atribuir tempo para futuras execuções de fluxo de trabalho nas próximas 24 horas.