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 avançado ou um executor auto-hospedado.
-
Você pode direcionar os executores com base nos rótulos atribuídos a eles, ou na associação de grupo ou uma combinação deles.
-
Você pode fornecer
runs-oncomo:- Uma única string
- 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
- um par de
key: valueusando as chavesgroupoulabels
-
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-onespecificados. Por exemplo, aqui o trabalho só será executado em um executor auto-hospedado que tenha os rótuloslinux,x64egpu: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, "${{ 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.
Observação
As aspas não são obrigatórias em sequências simples, como self-hosted, mas são obrigatórias para expressões como "${{ inputs.chosen-os }}".
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.
O valor para runs-on, quando você estiver usando um executor hospedado do GitHub, é um rótulo de runner ou o nome de um grupo de executores. Os rótulos dos executores hospedados do GitHub padrão são mostrados nas tabelas a seguir.
Para saber mais, confira Executores hospedados no GitHub.
Executores padrão para repositórios públicos hospedados em GitHub
Para repositórios públicos, os trabalhos que usam os rótulos de fluxo de trabalho mostrados na tabela abaixo serão executados com as especificações associadas. Com exceção dos executores de CPU única, cada executor hospedado por GitHub é uma nova máquina virtual (VM) hospedada por GitHub. Processos de CPU única são hospedados em um contêiner em uma VM compartilhada—consulte Referência de executores hospedados pelo GitHub. O uso dos executores padrões hospedados por GitHub é gratuito e ilimitado em repositórios públicos.
| Máquina virtual/contêiner | Processador (CPU) | Memória (RAM) | Armazenamento (SSD) | Arquitetura | Rótulo do fluxo de trabalho |
|---|---|---|---|---|---|
| Linux | 1 | 5 GB | 14 GB | x64 |
ubuntu-slim
|
| Linux | 4 | 16 GB | 14 GB | x64 |
|
Executores padrão hospedados no GitHub para repositórios internos e repositórios privados
Para repositórios privados do internos e , os trabalhos que usam os rótulos de fluxo de trabalho mostrados na tabela abaixo serão executados em máquinas virtuais com as especificações associadas. Esses executores usam a alocação de minutos gratuitos da sua conta GitHub e, em seguida, são cobrados pelas taxas por minuto. Confira Precificação do executor de ações.
| Máquina virtual | Processador (CPU) | Memória (RAM) | Armazenamento (SSD) | Arquitetura | Rótulo do fluxo de trabalho |
|---|---|---|---|---|---|
| Linux | 1 | 5 GB | 14 GB | x64 |
ubuntu-slim
|
| Linux | 2 | 8 GB | 14 GB | x64 |
|
Observação
Os executores do macOS não estão disponíveis em subdomínios do GHE.com, como octocorp.ghe.com.
Além dos executores hospedados da GitHub, o GitHub oferece aos clientes em GitHub Team e GitHub Enterprise Cloud planeja uma variedade de máquinas virtuais gerenciadas com recursos avançados - por exemplo, mais núcleos e espaço em disco, máquinas com GPU e máquinas com ARM. Para saber mais, confira Executores avançados.
Observação
As imagens do executor -latest são as imagens estáveis mais recentes fornecidas pelo GitHub e talvez não seja a versão mais recente do sistema operacional disponível do fornecedor do sistema operacional.
Aviso
As imagens beta e preteridas são fornecidas “no estado em que se encontram”, “com todas as falhas” e “conforme disponível” e são excluídas do contrato de nível de serviço e da garantia. As imagens beta podem não ser cobertas pelo atendimento ao cliente.
Exemplo: Especificar um sistema operacional
runs-on: ubuntu-latest
Para saber mais, confira Executores hospedados no GitHub.
Escolhendo executores auto-hospedados
Para especificar um executor auto-hospedado para uma tarefa, configure runs-on no arquivo do fluxo de trabalho utilizando rótulos do executor auto-hospedado.
Os executores auto-hospedados podem ter o rótulo self-hosted. Ao configurar um corredor auto-hospedado, por padrão, incluiremos o rótulo self-hosted. Você pode passar o sinalizador --no-default-labels para impedir que o rótulo auto-hospedado seja aplicado. Rótulos podem ser usados para criar opções de segmentação para os executores, como sistema operacional ou arquitetura. Recomendamos fornecer uma matriz de rótulos que comece com self-hosted (isso deve ser listado primeiro) e depois inclua rótulos adicionais, conforme necessário. Quando você especifica um array de rótulos, os trabalhos serão enfileirados em executores que possuem todos os rótulos que você especificou.
Observação
Actions Runner Controller não dá suporte ao self-hosted rótulo.
Exemplo: Usando etiquetas para seleção do executor
runs-on: [self-hosted, linux]
Para saber mais, confira 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 avançados 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@v5
- uses: actions/setup-node@v4
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-24.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-24.04-16core
steps:
- uses: actions/checkout@v5
- uses: actions/setup-node@v4
with:
node-version: '14'
- run: npm install -g bats
- run: bats -v
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 ]