Escolhendo o executor para um trabalho

Visão geral

Use jobs.<job_id>.runs-on para definir o tipo de computador no qual o trabalho será executado.

• O computador de destino pode ser um executor hospedado por GitHub, executor maior ou um executor auto-hospedado. - Você pode direcionar executores com base nos rótulos atribuídos a eles, ou na associação de grupo ou em uma combinação deles.

• Você pode fornecer runs-on como:

  • uma única cadeia de caracteres
  • uma única variável que contém uma cadeia de caracteres
  • uma matriz de cadeias de caracteres, variáveis que contêm cadeias de caracteres ou uma combinação de ambas

• Se você especificar uma matriz de cadeias de caracteres ou variáveis, o fluxo de trabalho será executado em qualquer executor que corresponda a todos os valores runs-on especificados. Por exemplo, aqui o trabalho só será executado em um executor auto-hospedado que tenha os rótulos linux, x64 e gpu:

  runs-on: [self-hosted, linux, x64, gpu]
  

  Para obter mais informações, confira "Como escolher executores auto-hospedados".

• Você pode misturar cadeias de caracteres e variáveis em uma matriz. Por exemplo:

  on:
    workflow_dispatch:
      inputs:
        chosen-os:
          required: true
          type: choice
          options:
          - Ubuntu
          - macOS
  
  jobs:
    test:
      runs-on: [self-hosted, "${{ github.event.inputs.chosen-os }}"]
      steps:
      - run: echo Hello world!
  

• Se você quiser executar seu fluxo de trabalho em vários computadores, use jobs.<job_id>.strategy.

Escolhendo executores hospedados em GitHub

Se você usar um executor hospedado no GitHub, cada trabalho será executado em uma nova instância de uma imagem do executor especificada por runs-on.

Os tipos de executor disponíveis para GitHub são:

Imagem do executor	Rótulo de fluxo de trabalho YAML	Observações
Windows Server 2022	windows-latest ou windows-2022	Atualmente, o rótulo windows-latest usa a imagem do executor do Windows Server 2022.
Windows Server 2019	windows-2019	Nenhum
Ubuntu 22.04	ubuntu-latest ou ubuntu-22.04	Atualmente, o rótulo ubuntu-latest usa a imagem do executor do Ubuntu 22.04.
Ubuntu 20.04	ubuntu-20.04	Nenhuma
Ubuntu 18.04 [preterido]	ubuntu-18.04	Migre para ubuntu-20.04 ou ubuntu-22.04. Para saber mais, confira esta postagem no blog do GitHub.
macOS 13 Ventura [Beta]	macos-13 ou macos-13-xl	Nenhum
macOS 12 Monterey	macos-latest, macos-12, macos-latest-xl ou macos-12-xl	Atualmente, os rótulos dos fluxos de trabalho macos-latest e macos-latest-xl usam a imagem do executor do macOS 12. Para obter informações sobre os preços do executor macOS XL (12 núcleos) por minuto, confira "Sobre a cobrança de GitHub Actions".
macOS 11 Big Sur	macos-11	Nenhum

Exemplo: Especificar um sistema operacional

runs-on: ubuntu-latest

Para obter mais informações, confira "Sobre executores hospedados no GitHub".

Escolhendo executores auto-hospedados

Para especificar um executor auto-hospedado para seu trabalho, configure runs-on no arquivo de fluxo de trabalho com rótulos do executor auto-hospedado.

Todos os executores auto-hospedados têm o rótulo self-hosted. Se você só usar esse rótulo, isso selecionará qualquer executor auto-hospedado. Para selecionar os executores que atendem a determinados critérios, como sistema operacional ou arquitetura, recomendamos fornecer uma matriz de rótulos que começa com self-hosted (isso precisa ser listado primeiro) e, em seguida, inclui rótulos adicionais, conforme necessário. Quando você especificar uma matriz de rótulos, os trabalhos serão colocados na fila nos executores que têm todos os rótulos especificados.

Embora o rótulo self-hosted não seja necessário, recomendamos fortemente especificá-lo ao usar executores auto-hospedados para garantir que o seu trabalho não especifique acidentalmente nenhum executor atual ou futuro hospedado no GitHub.

Exemplo: Usando etiquetas para seleção do executor

runs-on: [self-hosted, linux]

Para obter mais informações, confira "Sobre executores auto-hospedados" e "Usar os executores auto-hospedados em um fluxo de trabalho."

Escolher executores em um grupo

Você pode usar runs-on para direcionar grupos de executores para que o trabalho seja executado em qualquer executor que seja membro desse grupo. Para um controle mais granular, você também pode combinar grupos de executores com rótulos.

Os grupos de executores só podem ter executor maiors ou executores auto-hospedados como membros.

Exemplo: 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

Exemplo: combinar grupos e rótulos

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