Sintaxe de fluxo de trabalho para o GitHub Actions

Sobre sintaxe YAML para fluxos de trabalho

Arquivos de fluxo de trabalho usam sintaxe YAML e devem ter uma extensão de arquivo .yml ou .yaml. If you're new to YAML and want to learn more, see "Learn YAML in Y minutes."

Você deve armazenar os arquivos de fluxo de trabalho no diretório .github/workflows do seu repositório.

name

Nome do fluxo de trabalho. O GitHub exibe os nomes dos fluxos de trabalho na página de ações do repositório. Se você omitir o nome, o GitHub irá defini-lo como o caminho do arquivo do fluxo de trabalho relativo à raiz do repositório.

on

Obrigatório. O nome do evento de GitHub que aciona o fluxo de trabalho. Você pode fornecer uma única string de evento, um array de eventos, um array de types (tipos) de eventos ou um map (mapa) de configuração de eventos que programe um fluxo de trabalho ou restrinja a execução do fluxo de trabalho a alterações em determinados arquivos, tags ou branches. Para obter uma lista de eventos disponíveis, consulte "Eventos que acionam fluxos de trabalho".

Example: Using a single event

# Triggered when code is pushed to any branch in a repository
on: push

Example: Using a list of events

# Triggers the workflow on push or pull request events
on: [push, pull_request]

Example: Using multiple events with activity types or configuration

Se você precisar especificar tipos de atividade ou configuração para um evento, você deve configurar cada evento separadamente. Você deve anexar dois pontos (:) a todos os eventos, incluindo eventos sem configuração.

on:
  # Trigger the workflow on push or pull request,
  # but only for the main branch
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
  # Also trigger on page_build, as well as release created events
  page_build:
  release:
    types: # This configuration does not affect the page_build event above
      - created

on.<event_name>.types

Seleciona os tipos de atividades que acionarão a execução de um fluxo de trabalho. A maioria dos eventos GitHub são acionados por mais de um tipo de atividade. Por exemplo, o evento para o recurso release (versão) é acionado quando uma versão é published (publicada), unpublished (a publicação é cancelada), created (criada), edited (editada), deleted (excluída) ou prereleased (versão prévia). A palavra-chave types (tipos) permite que você limite a atividade que faz com que o fluxo de trabalho seja executado. Quando somente um tipo de atividade aciona um evento de webhook, a palavra-chave types (tipos) é desnecessária.

É possível usar um array de types (tipos) de evento. Para obter mais informações sobre cada evento e seus tipos de atividades, consulte "Eventos que acionam fluxos de trabalho".

# Aciona o fluxo de trabalho na atividade de pull request
on:
  release:
    # Usa apenas a palavra-chave types (tipos) para limitar os tipos de atividades que acionam o fluxo de trabalho.
    types: [published, created, edited]

on.<push|pull_request>.<branches|tags>

Ao usar os eventos push e pull_request, é possível configurar um fluxo de trabalho para ser executado em branches ou tags específicos. Para um evento de pull_request, são avaliados apenas os branches e tags na base. Se você definir apenas tags ou branches, o fluxo de trabalho não será executado para eventos que afetam o Git ref indefinido.

As palavras-chave branches, branches-ignore, tags e tags-ignore aceitam padrões glob que usam os caracteres curinga * e ** para coincidir com mais de um nome de branch ou tag. Para obter mais informações, consulte a "Folha de consulta de filtro padrão".

Example: Including branches and tags

Os padrões definidos nos branches e tags são avaliados relativamente ao nome do Git ref. Por exemplo, definir o padrão mona/octocat nos branches corresponde ao Git ref refs/heads/mona/octocat. O padrão releases/** corresponderá ao Git ref refs/heads/releases/10.

on:
  push:
    # Sequence of patterns matched against refs/heads
    branches:    
      # Push events on main branch
      - main
      # Push events to branches matching refs/heads/mona/octocat
      - 'mona/octocat'
      # Push events to branches matching refs/heads/releases/10
      - 'releases/**'
    # Sequence of patterns matched against refs/tags
    tags:        
      - v1             # Push events to v1 tag
      - v1.*           # Push events to v1.0, v1.1, and v1.9 tags

Example: Ignoring branches and tags

Sempre que um padrão corresponde ao padrão branches-ignore ou tags-ignore, o fluxo de trabalho não será executado. Os padrões definidos em branches-ignore e tags-ignore são avaliados relativamente ao nome do Git ref. Por exemplo, definir o padrão mona/octocat nos branches corresponde ao Git ref refs/heads/mona/octocat. O padrão releases/**-alpha em branches corresponderá ao Git ref refs/releases/beta/3-alpha.

em:
  push:
    # Sequência de padrões que correspondem a refs/heads
    branches-ignore:
      # Push de eventos para branches que correspondem a refs/heads/mona/octocat
      - 'mona/octocat'
      # Push de eventos para branches que correspondem a refs/heads/releases/beta/3-alpha
      - 'releases/**-alpha'
    # Sequência de padrões que correspondem a refs/tags
    tags-ignore:
      - v1.*           # Push events to tags v1.0, v1.1, and v1.9

Excluir branches e tags

Você pode usar dois tipos de filtros para impedir a execução de um fluxo de trabalho em pushes e pull requests para tags e branches.

• branches ou branches-ignore - não é possível usar os dois filtros branches e branches-ignore para o mesmo evento em um fluxo de trabalho. Use o filtro branches quando você precisa filtrar branches para correspondências positivas e excluir branches. Use o filtro branches-ignore quando você só precisa excluir nomes de branches.
• tags ou tags-ignore - não é possível usar os dois filtros tags e tags-ignore para o mesmo evento em um fluxo de trabalho. Use o filtro tags quando você precisa filtrar tags para correspondências positivas e excluir tags. Use o filtro tags-ignore quando você só precisa excluir nomes de tags.

Example: Using positive and negative patterns

Você pode excluir tags e branches usando o caractere !. A ordem de definição dos padrões é importante.

• Um padrão negativo (precedido por !) depois de uma correspondência positiva excluirá o Git ref.
• Um padrão positivo correspondente após uma correspondência negativa incluirá a Git ref novamente.

O fluxo de trabalho a seguir será executado em pushes para releases/10 ou releases/beta/mona, mas não em releases/10-alpha ou releases/beta/3-alpha, pois o padrão negativo !releases/**-alpha está na sequência do padrão positivo.

on:
  push:
    branches:    
      - 'releases/**'
      - '!releases/**-alpha'

on.<push|pull_request>.paths

Ao usar os eventos push e pull_request, é possível configurar um fluxo de trabalho para ser executado quando pelo menos um arquivo não corresponde a paths-ignore ou pelo menos um arquivo modificado corresponde ao paths configurado. Flitros de caminho não são avaliados em pushes para tags.

As palavras-chave paths-ignore e paths aceitam padrões glob que usam os caracteres curinga * e ** para coincidir com mais de um nome de caminho. Para obter mais informações, consulte a "Folha de consulta de filtro padrão".

Example: Ignoring paths

Quando todos os caminhos de nome correspondem a padrões em paths-ignore, o fluxo de trabalho não será executado. O GitHub avalia os padrões definidos em paths-ignore com relação ao nome do caminho. Um fluxo de trabalho com o seguinte filtro de caminho só será executado em eventos push que tiverem pelo menos um arquivo fora do diretório docs na raiz do repositório.

on:
  push:
    paths-ignore:
      - 'docs/**'

Example: Including paths

Se pelo menos um caminho corresponder a um padrão no filtro paths, o fluxo de trabalho será executado. Para acionar uma compilação sempre que você fizer push de um arquivo JavaScript, você pode usar um padrão curinga.

on:
  push:
    paths:
      - '**.js'

Excluir caminhos

Você pode excluir caminhos com dois tipos de filtros. Não é possível usar ambos os filtros para o mesmo evento em um fluxo de trabalho.

• paths-ignore - use o filtro paths-ignore quando você precisa somente excluir nomes de caminhos.
• paths - use o filtro paths quando você precisa filtrar caminhos para correspondências positivas e excluir caminhos.

Example: Using positive and negative patterns

Você pode excluir paths usando o caractere !. A ordem de definição dos padrões é importante:

• Um padrão negativo (precedido por !) depois de uma correspondência positiva excluirá o caminho.
• Um padrão positivo correspondente após uma correspondência negativa incluirá o caminho novamente.

Este exemplo é executado sempre que o evento push inclui um arquivo no diretório sub-project ou seus subdiretórios, a menos que o arquivo esteja no diretório sub-project/docs. Por exemplo, um push que alterou sub-project/index.js ou sub-project/src/index.js acionará uma execução de fluxo de trabalho, mas um push que altere somentesub-project/docs/readme.md não acionará.

on:
  push:
    paths:
      - 'sub-project/**'
      - '!sub-project/docs/**'

Comparações Git diff

O filtro determina se um fluxo de trabalho deve ser executado avaliando os arquivos alterados e comparando-os à lista de paths-ignore ou paths. Se não houver arquivos alterados, o fluxo de trabalho não será executado.

O GitHub gera a lista de arquivos alterados usando diffs de dois pontos para pushes e diffs de três pontos para pull requests:

• Pull requests: diffs de três pontos são uma comparação entre a versão mais recente do branch de tópico e o commit onde o branch de tópico foi sincronizado pela última vez com o branch de base.
• Pushes para branches existentes: um diff de dois pontos compara os SHAs head e base, um com o outro.
• Pushes para novos branches: um diff de dois pontos compara o principal do ancestral do commit mais extenso que foi feito push.

Para obter mais informações, consulte "Sobre comparação de branches em pull requests".

on.schedule

É possível programar um fluxo de trabalho para ser executado em horários de UTC específicos usando a sintaxe de cron POSIX. Fluxos de trabalho agendados executados no último commit no branch padrão ou branch de base. O intervalo mais curto que você pode executar fluxos de trabalho programados é uma vez a cada 5 minutos.

This example triggers the workflow every day at 5:30 and 17:30 UTC:

on:
  schedule:
    # * is a special character in YAML so you have to quote this string
    - cron:  '30 5,17 * * *'

Para obter mais informações sobre a sintaxe cron, consulte "Eventos que acionam fluxos de trabalho".

permissões

Você pode modificar as permissões padrão concedidas ao GITHUB_TOKEN, adicionando ou removendo o acesso conforme necessário, para que você permita apenas o acesso mínimo necessário. Para obter mais informações, consulte "Autenticação em um fluxo de trabalho".

Você pode usar as permissões de `como uma chave de nível superior, para aplicar a todos os trabalhos do fluxo de trabalho ou em trabalhos específicos. Ao adicionar a chave daspermissõesem um trabalho específico, todas as ações e comandos de execução dentro desse trabalho que usam oGITHUB_TOKEN ganham os direitos de acesso que você especificar. Para obter mais informações, consulte [jobs.<job_id>.permissions`](#jobsjob_idpermissions).

Available scopes and access values:

permissions:
  actions: read|write|none
  checks: read|write|none
  contents: read|write|none
  deployments: read|write|none
  issues: read|write|none
  packages: read|write|none
  pull-requests: read|write|none
  repository-projects: read|write|none
  security-events: read|write|none
  statuses: read|write|none

If you specify the access for any of these scopes, all of those that are not specified are set to none.

You can use the following syntax to define read or write access for all of the available scopes:

permissions: read-all|write-all

You can use the permissions key to add and remove read permissions for forked repositories, but typically you can't grant write access. The exception to this behavior is where an admin user has selected the Send write tokens to workflows from pull requests option in the GitHub Actions settings. For more information, see "Disabling or limiting GitHub Actions for a repository."

Exemplo

Este exemplo mostra as permissões que estão sendo definidas para o GITHUB_TOKEN que será aplicado a todos os trabalhos do fluxo de trabalho. É concedido acesso de leitura a todas as permissões.

name: "My workflow"

on: [ push ]

permissions: read-all

jobs:
  ...

env

Um mapa das variáveis de ambiente que estão disponíveis para as etapas de todos os trabalhos do fluxo de trabalho. Também é possível definir variáveis de ambiente que estão disponíveis apenas para as etapas de um único trabalho ou para uma única etapa. Para obter mais informações, consulte jobs.<job_id>.env e jobs.<job_id>.steps[*].env.

Quando mais de uma variável de ambiente é definida com o mesmo nome, GitHub usa a variável de ambiente mais específica. Por exemplo, uma variável de ambiente definida em uma etapa substituirá variáveis de trabalho e de fluxo de trabalho pelo mesmo nome enquanto a etapa é executada. Uma variável definida para um trabalho substituirá uma variável de fluxo de trabalho com o mesmo nome, enquanto o trabalho é executado.

Exemplo

env:
  SERVER: production

padrões

Um mapa das configurações-padrão que serão aplicadas a todos os trabalhos do fluxo de trabalho. Você também pode definir as configurações-padrão disponíveis para um trabalho. Para obter mais informações, consulte jobs.<job_id>.defaults.

Quando mais de uma configuração padrão é definida com o mesmo nome, GitHub usa a configuração padrão mais específica. Por exemplo, uma configuração padrão definida em uma tarefa irá substituir uma configuração padrão que tem o mesmo nome definido em um fluxo de trabalho.

defaults.run

Você pode fornecer opções-padrão de shell e working-directory para todas as etapas de executar em um fluxo de trabalho. Você também pode definir as configurações-padrão para execução apenas disponíveis para um trabalho. Para obter mais informações, consulte jobs.<job_id>.defaults.run. Você não pode usar contextos ou expressões nesta palavra-chave.

Quando mais de uma configuração padrão é definida com o mesmo nome, GitHub usa a configuração padrão mais específica. Por exemplo, uma configuração padrão definida em uma tarefa irá substituir uma configuração padrão que tem o mesmo nome definido em um fluxo de trabalho.

Exemplo

defaults:
  run:
    shell: bash
    working-directory: scripts

concorrência

A moeda garante que apenas um único trabalho ou fluxo de trabalho que usa o mesmo grupo de concorrência seja executado de cada vez. Um grupo de concorrência pode ser qualquer string ou expressão. A expressão só pode usar o contexto github. Para obter mais informações sobre expressões, consulte "Sintaxe de contexto e expressão para GitHub Actions".

Você também pode especificar concorrência no nível do trabalho. Para obter mais informações, consulte jobs.<job_id>.concurrency.

When a concurrent job or workflow is queued, if another job or workflow using the same concurrency group in the repository is in progress, the queued job or workflow will be pending. Any previously pending job or workflow in the concurrency group will be canceled. To also cancel any currently running job or workflow in the same concurrency group, specify cancel-in-progress: true.

Examples: Using concurrency and the default behavior

concurrency: staging_environment

concurrency: ci-${{ github.ref }}

Example: Using concurrency to cancel any in-progress job or run

concurrency: 
  group: ${{ github.head_ref }}
  cancel-in-progress: true

jobs

A execução de um fluxo de trabalho consiste em um ou mais trabalhos. Por padrão, os trabalhos são executados paralelamente. Para executar trabalhos sequencialmente, você pode definir dependências em outros trabalhos usando a palavra-chave jobs.<job_id>.needs.

Cada trabalho é executado em um ambiente de executor especificado por runs-on.

Você pode executar quantos trabalhos desejar, desde que esteja dentro dos limites de uso do fluxo de trabalho. Para obter mais informações, consulte "Limites de uso e cobrança" para executores hospedados em GitHub e "Sobre executores auto-hospedados" para limites de uso de executores auto-hospedados.

Se você precisar encontrar o identificador exclusivo de um trabalho e execução em um fluxo de trabalho, você poderá usar a API GitHub. Para obter mais informações, consulte "Trabalhos do fluxo de trabalho".

jobs.<job_id>

Cada trabalho deve ter um id associado. A chave job_id é uma string, e seu valor é um mapa dos dados de configuração do trabalho. Você deve substituir <job_id> por uma string exclusiva para o objeto jobs. <job_id> deve começar por uma letra ou _, além de conter somente caracteres alfanuméricos, - ou _.

Exemplo

jobs:
  meu_primeiro_trabalho:
    name: meu primeiro trabalho
  meu_segundo_trabalho:
    name: meu segundo trabalho

jobs.<job_id>.name

Nome do trabalho no GitHub.

jobs.<job_id>.needs

Identifica todos os trabalhos a serem concluídos com êxito antes da execução deste trabalho. Esse código pode ser uma string ou array de strings. Se houver falha em um trabalho, todos os trabalhos que dependem dele serão ignorados, a menos que os trabalhos usem uma expressão condicional que faça o trabalho continuar.

Example: Requiring dependent jobs to be successful

jobs:
  job1:
  job2:
    needs: job1
  job3:
    needs: [job1, job2]

Neste exemplo, job1 deve ser concluído com êxito antes do início de job2, e job3 aguarda a conclusão de job1 e job2.

Os trabalhos neste exemplo são executados sequencialmente:

1. job1
2. job2
3. job3

Example: Not requiring dependent jobs to be successful

jobs:
  job1:
  job2:
    needs: job1
  job3:
    if: always()
    needs: [job1, job2]

Neste exemplo, job3 usa a expressão condicional always() para que ela sempre seja executada depois de job1 e job2 terem sido concluídos, independentemente de terem sido bem sucedidos. Para obter mais informações, consulte "sintaxe de contexto e expressão".

jobs.<job_id>.runs-on

Obrigatório. O tipo de máquina na qual se executa o trabalho. A máquina pode ser ou um executor hospedado em GitHub ou um executor auto-hospedado.

Runners hospedados no GitHub

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

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

Exemplo

runs-on: ubuntu-latest

Para obter mais informações, consulte "Ambientes virtuais para executores hospedados em GitHub".

Executores auto-hospedados

Para especificar um executor auto-hospedado para o seu trabalho, configure runs-on no seu arquivo de fluxo de trabalho com etiquetas de executores auto-hospedados.

Todos os executores auto-hospedados possuem a etiqueta self-hosted e você pode selecionar qualquer runner auto-hospedado fornecendo apenas a etiqueta self-hosted. Como alternativa, você pode usar self-hosted em um array com etiquetas adicionais, como etiquetas para um sistema operacional específico ou arquitetura do sistema, para selecionar apenas os executores de tipos que você especificar.

Exemplo

runs-on: [self-hosted, linux]

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

jobs.<job_id>.permissions

Você pode modificar as permissões padrão concedidas ao GITHUB_TOKEN, adicionando ou removendo o acesso conforme necessário, para que você permita apenas o acesso mínimo necessário. Para obter mais informações, consulte "Autenticação em um fluxo de trabalho".

Ao especificar a permissão de uma definição de trabalho, você pode configurar um conjunto diferente de permissões para o GITHUB_TOKEN para cada trabalho, se necessário. Como alternativa, você pode especificar as permissões para todas as tarefas do fluxo de trabalho. Para informações sobre como definir permissões no nível do fluxo de trabalho, consulte permissões.

Available scopes and access values:

permissions:
  actions: read|write|none
  checks: read|write|none
  contents: read|write|none
  deployments: read|write|none
  issues: read|write|none
  packages: read|write|none
  pull-requests: read|write|none
  repository-projects: read|write|none
  security-events: read|write|none
  statuses: read|write|none

If you specify the access for any of these scopes, all of those that are not specified are set to none.

You can use the following syntax to define read or write access for all of the available scopes:

permissions: read-all|write-all

You can use the permissions key to add and remove read permissions for forked repositories, but typically you can't grant write access. The exception to this behavior is where an admin user has selected the Send write tokens to workflows from pull requests option in the GitHub Actions settings. For more information, see "Disabling or limiting GitHub Actions for a repository."

Exemplo

Este exemplo mostra as permissões que estão sendo definidas para o GITHUB_TOKEN que só se aplicará ao trabalho denominado stale. O acesso de gravação é concedido para os escopos dos problemas e pull-requests. Todos os outros escopos não terão acesso.

jobs:
  stale:
    runs-on: ubuntu-latest

    permissions:
      issues: write
      pull-requests: write

    steps:
      - uses: actions/stale@v3

jobs.<job_id>.environment

O ambiente ao qual o trabalho faz referência. Todas as regras de proteção do ambiente têm de ser aprovadas para que um trabalho que faça referência ao ambiente seja enviado a um executor. Para obter mais informações, consulte "Ambientes".

Você pode fornecer o ambiente apenas como o nome do ambiente, ou como um objeto de ambiente com o nome e url. A URL é mapeada com environment_url na API de implantações. Para obter mais informações sobre a API de implantações, consulte "Implantações".

Exemplo de uso de um único nome de ambiente

ambiente: staging_environment

Exemplo de uso de nome de ambiente e URL

environment:
  name: production_environment
  url: https://github.com

A URL pode ser uma expressão e pode usar qualquer contexto, exceto o contexto de segredos. Para obter mais informações sobre expressões, consulte "Sintaxe de contexto e expressão para GitHub Actions".

Exemplo

environment:
  name: production_environment
  url: ${{ steps.step_id.outputs.url_output }}

jobs.<job_id>.concurrency

A moeda garante que apenas um único trabalho ou fluxo de trabalho que usa o mesmo grupo de concorrência seja executado de cada vez. Um grupo de concorrência pode ser qualquer string ou expressão. A expressão pode usar qualquer contexto, exceto para o contexto de segredos. Para obter mais informações sobre expressões, consulte "Sintaxe de contexto e expressão para GitHub Actions".

Você também pode especificar concorrência no nível do fluxo de trabalho. Para obter mais informações, consulte concorrência.

When a concurrent job or workflow is queued, if another job or workflow using the same concurrency group in the repository is in progress, the queued job or workflow will be pending. Any previously pending job or workflow in the concurrency group will be canceled. To also cancel any currently running job or workflow in the same concurrency group, specify cancel-in-progress: true.

Examples: Using concurrency and the default behavior

concurrency: staging_environment

concurrency: ci-${{ github.ref }}

Example: Using concurrency to cancel any in-progress job or run

concurrency: 
  group: ${{ github.head_ref }}
  cancel-in-progress: true

jobs.<job_id>.outputs

Um mapa de saídas para um trabalho. As saídas de trabalho estão disponíveis para todos os trabalhos downstream que dependem deste trabalho. Para obter mais informações sobre a definição de dependências de trabalhos, consulte jobs.<job_id>.needs.

As saídas de trabalho são strings e saídas de trabalho que contêm expressões são avaliadas no executor ao final de cada trabalho. As saídas que contêm segredos são eliminadas no executor e não são enviadas para GitHub Actions.

Para usar as saídas de trabalho em um trabalho dependente, você poderá usar o contexto needs. Para obter mais informações, consulte "Contexto e sintaxe de expressão para GitHub Actions".

Exemplo

jobs:
  job1:
    runs-on: ubuntu-latest
    # Map a step output to a job output
    outputs:
      output1: ${{ steps.step1.outputs.test }}
      output2: ${{ steps.step2.outputs.test }}
    steps:
      - id: step1
        run: echo "::set-output name=test::hello"
      - id: step2
        run: echo "::set-output name=test::world"
  job2:
    runs-on: ubuntu-latest
    needs: job1
    steps:
      - run: echo ${{needs.job1.outputs.output1}} ${{needs.job1.outputs.output2}}

jobs.<job_id>.env

Um map (mapa) das variáveis de ambiente que estão disponíveis para todos as etapas do trabalho. Também é possível definir variáveis de ambiente para todo o fluxo de trabalho ou uma etapa individual. Para obter mais informações, consulte env e jobs.<job_id>.steps[*].env.

Quando mais de uma variável de ambiente é definida com o mesmo nome, GitHub usa a variável de ambiente mais específica. Por exemplo, uma variável de ambiente definida em uma etapa substituirá variáveis de trabalho e de fluxo de trabalho pelo mesmo nome enquanto a etapa é executada. Uma variável definida para um trabalho substituirá uma variável de fluxo de trabalho com o mesmo nome, enquanto o trabalho é executado.

Exemplo

jobs:
  job1:
    env:
      FIRST_NAME: Mona

jobs.<job_id>.defaults

Um mapa com as configurações- padrão que serão aplicadas a todas as etapas do trabalho. Você também pode definir as configurações-padrão para todo o fluxo de trabalho. Para obter mais informações, consulte padrão.

Quando mais de uma configuração padrão é definida com o mesmo nome, GitHub usa a configuração padrão mais específica. Por exemplo, uma configuração padrão definida em uma tarefa irá substituir uma configuração padrão que tem o mesmo nome definido em um fluxo de trabalho.

jobs.<job_id>.defaults.run

Forneça o shell e working-directory para todas as etapas do trabalho executar. Não são permitidos contexto e expressão nesta seção.

Você pode fornecer as opções-padrão de shell e working-directory para todas as etapas de execução de um trabalho. Você também pode definir as configurações-padrão para execução para todo o fluxo de trabalho. Para obter mais informações, consulte jobs.defaults.run. Você não pode usar contextos ou expressões nesta palavra-chave.

Quando mais de uma configuração padrão é definida com o mesmo nome, GitHub usa a configuração padrão mais específica. Por exemplo, uma configuração padrão definida em uma tarefa irá substituir uma configuração padrão que tem o mesmo nome definido em um fluxo de trabalho.

Exemplo

jobs:
  job1:
    runs-on: ubuntu-latest
    defaults:
      run:
        shell: bash
        working-directory: scripts

jobs.<job_id>.if

Você pode usar a condicional if (se) para evitar que um trabalho seja executado a não ser que determinada condição seja atendida. Você pode usar qualquer contexto e expressão compatível para criar uma condicional.

When you use expressions in an if conditional, you may omit the expression syntax (${{ }}) because GitHub automatically evaluates the if conditional as an expression, unless the expression contains any operators. If the expression contains any operators, the expression must be contained within ${{ }} to explicitly mark it for evaluation. Para obter mais informações, consulte "Contexto e sintaxe de expressão para GitHub Actions".

jobs.<job_id>.steps

Trabalhos contêm sequências de tarefas chamadas steps. As etapas podem executar comandos, executar trabalhos de configuração ou executar ações no seu repositório, em repositórios públicos, ou ações publicadas em registros do Docker. Nem todas as etapas executam ações, mas todas as ações são executadas como etapas. Cada etapa é executada em seu próprio processo no ambiente do executor, tendo acesso ao espaço de trabalho e ao sistema de arquivos. Como as etapas são executadas em seus próprios processos, as alterações nas variáveis de ambiente não são preservadas entre as etapas. O GitHub fornece etapas integradas para configurar e concluir trabalhos.

Você pode executar quantas etapas quiser, desde que esteja dentro dos limites de uso do fluxo de trabalho. Para obter mais informações, consulte "Limites de uso e cobrança" para executores hospedados em GitHub e "Sobre executores auto-hospedados" para limites de uso de executores auto-hospedados.

Exemplo

name: Greeting from Mona

on: push

jobs:
  my-job:
    name: My Job
    runs-on: ubuntu-latest
    steps:
      - name: Print a greeting
        env:
          MY_VAR: Hi there! My name is
          FIRST_NAME: Mona
          MIDDLE_NAME: The
          LAST_NAME: Octocat
        run: |
          echo $MY_VAR $FIRST_NAME $MIDDLE_NAME $LAST_NAME.

jobs.<job_id>.steps[*].id

Identificador exclusivo da etapa. Você pode usar id para fazer referência à etapa em contextos. Para obter mais informações, consulte "Contexto e sintaxe de expressão para GitHub Actions".

jobs.<job_id>.steps[*].if

Você pode usar a condicional if (se) para evitar que uma etapa trabalho seja executada a não ser que determinada condição seja atendida. Você pode usar qualquer contexto e expressão compatível para criar uma condicional.

When you use expressions in an if conditional, you may omit the expression syntax (${{ }}) because GitHub automatically evaluates the if conditional as an expression, unless the expression contains any operators. If the expression contains any operators, the expression must be contained within ${{ }} to explicitly mark it for evaluation. Para obter mais informações, consulte "Contexto e sintaxe de expressão para GitHub Actions".

Example: Using contexts

Essa etapa somente é executada quando o tipo de evento é uma pull_request e a ação do evento é unassigned (não atribuída).

steps:
 - name: My first step
   if: ${{ github.event_name == 'pull_request' && github.event.action == 'unassigned' }}
   run: echo This event is a pull request that had an assignee removed.

Example: Using status check functions

A função my backup step (minha etapa de backup) somente é executada quando houver falha em uma etapa anterior do trabalho. Para obter mais informações, consulte "Contexto e sintaxe de expressão para GitHub Actions".

steps:
  - name: My first step
    uses: monacorp/action-name@main
  - name: My backup step
    if: ${{ failure() }}
    uses: actions/heroku@1.0.0

jobs.<job_id>.steps[*].name

Nome da etapa no GitHub.

jobs.<job_id>.steps[*].uses

Seleciona uma ação para executar como parte de uma etapa no trabalho. A ação é uma unidade reutilizável de código. Você pode usar uma ação definida no mesmo repositório que o fluxo de trabalho, um repositório público ou em uma imagem publicada de contêiner Docker.

É altamente recomendável incluir a versão da ação que você está usando ao especificar um número de tag Docker, SHA ou ref do Git. Se você não especificar uma versão, ela poderá interromper seus fluxos de trabalho ou causar um comportamento inesperado quando o proprietário da ação publicar uma atualização.

• Usar o commit SHA de uma versão de ação lançada é a maneira mais garantida de obter estabilidade e segurança.
• Usar a versão principal da ação permite receber correções importantes e patches de segurança sem perder a compatibilidade. Fazer isso também garante o funcionamento contínuo do fluxo de trabalho.
• Usar o branch-padrão de uma ação pode ser conveniente, mas se alguém lançar uma nova versão principal com uma mudança significativa, seu fluxo de trabalho poderá ter problemas.

Algumas ações requerem entradas que devem ser definidas com a palavra-chave with (com). Revise o arquivo README da ação para determinar as entradas obrigatórias.

Ações são arquivos JavaScript ou contêineres Docker. Se a ação em uso for um contêiner do Docker, você deverá executar o trabalho em um ambiente do Linux. Para obter mais detalhes, consulte runs-on.

Example: Using versioned actions

steps:    
  # Reference a specific commit
  - uses: actions/setup-node@c46424eee26de4078d34105d3de3cc4992202b1e
  # Reference the major version of a release
  - uses: actions/setup-node@v1
  # Reference a minor version of a release
  - uses: actions/setup-node@v1.2
  # Reference a branch
  - uses: actions/setup-node@main

Example: Using a public action

{owner}/{repo}@{ref}

Você pode especificar um branch, ref ou SHA em um repositório público GitHub.

jobs:
  my_first_job:
    steps:
      - name: My first step
        # Uses the default branch of a public repository
        uses: actions/heroku@1.0.0
      - name: My second step
        # Uses a specific version tag of a public repository
        uses: actions/aws@v2.0.1

Example: Using a public action in a subdirectory

{owner}/{repo}/{path}@{ref}

Subdiretório em um repositório público do GitHub em um branch, ref ou SHA específico.

jobs:
  my_first_job:
    steps:
      - name: My first step
        uses: actions/aws/ec2@main

Example: Using an action in the same repository as the workflow

./path/to/dir

Caminho para o diretório que contém a ação no repositório do seu fluxo de trabalho. Você deve reservar seu repositório antes de usar a ação.

jobs:
  my_first_job:
    steps:
      - name: Check out repository
        uses: actions/checkout@v2
      - name: Use local my-action
        uses: ./.github/actions/my-action

Example: Using a Docker Hub action

docker://{image}:{tag}

Imagem Docker publicada no Docker Hub.

empregos:
  my_first_job:
    passos:
      - nome: Meu primeiro passo
        usa: docker://alpine:3.8

Example: Using the GitHub Package Registry Container registry

docker://{host}/{image}:{tag}

Uma imagem Docker em GitHub Package Registry Container registry.

jobs:
  meu_primeiro_trabalho:
    steps:
      - name: minha primeira etapa
        uses: docker://ghcr.io/OWNER/IMAGE_NAME

Example: Using a Docker public registry action

docker://{host}/{image}:{tag}

Imagem Docker em um registro público. Este exemplo usa o Registro de Contêiner do Google em gcr.io.

jobs:
  meu_primeiro_trabalho:
    steps:
      - name: minha primeira etapa
        uses: docker://gcr.io/cloud-builders/gradle

Example: Using an action inside a different private repository than the workflow

Seu fluxo de trabalho deve fazer checkout no repositório privado e referenciar a ação localmente. Gere um token de acesso pessoal e adicione o token como um segredo criptografado. Para obter mais informações, consulte "Criar um token de acesso pessoal" e "Segredos criptografados".

Substitua PERSONAL_ACCESS_TOKEN no exemplo pelo nome do seu segredo.

jobs:
  my_first_job:
    steps:
      - name: Check out repository
        uses: actions/checkout@v2
        with:
          repository: octocat/my-private-repo
          ref: v1.0
          token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
          path: ./.github/actions/my-private-repo
      - name: Run my action
        uses: ./.github/actions/my-private-repo/my-action

jobs.<job_id>.steps[*].run

Executa programas de linha de comando usando o shell do sistema operacional. Se você não informar um name, o nome da etapa será configurado por padrão como o texto indicado no comando run.

Por padrão, os comandos run usam shells de não login. Você pode escolher um shell diferente e personalizar o shell usado para executar comandos. Para obter mais informações, consulte "Usar um shell específico".

Cada palavra-chave run representa um novo processo e shell no ambiente do executor. Quando você fornece comandos de várias linhas, cada linha será executada no mesmo shell. Por exemplo:

• Um comando de linha única:

  - name: Install Dependencies
    run: npm install
  

• Um comando de várias linhas:

  - name: Clean install dependencies and build
    run: |
      npm ci
      npm run build
  

Com a palavra-chave working-directory (diretório de trabalho), é possível especificar o diretório de trabalho de onde o comando será executado.

- name: Clean temp directory
  run: rm -rf *
  working-directory: ./temp

Usar um shell específico

Você pode anular as configurações padrão de shell no sistema operacional do executor usando a palavra-chave shell. É possível usar palavras-chave integradas a shell ou definir um conjunto personalizado de opções de shell.

Example: Running a script using bash

steps:
  - name: Display the path
    run: echo $PATH
    shell: bash

Example: Running a script using Windows cmd

steps:
  - name: Display the path
    run: echo %PATH%
    shell: cmd

Example: Running a script using PowerShell Core

steps:
  - name: Display the path
    run: echo ${env:PATH}
    shell: pwsh

Exemplo: Usar o PowerShell Desktop para executar um script

steps:
  - name: Display the path
    run: echo ${env:PATH}
    shell: powershell

Example: Running a python script

steps:
  - name: Display the path
    run: |
      import os
      print(os.environ['PATH'])
    shell: python

Shell personalizado

Você pode usar o valor shell em um string modelo usando command […options] {0} [..more_options]. O GitHub interpreta a primeira palavra da string delimitada por um espaço em branco como o comando e insere o nome do arquivo para o script temporário em {0}.

Por exemplo:

steps:
  - name: Display the environment variables and their values
    run: |
      print %ENV
    shell: perl {0}

O comando usado, perl neste exemplo, deve ser instalado no executor.

Para informações sobre o software incluído nos executores hospedados no GitHub, consulte "Especificações para os executores hospedados no GitHub."

Preferências de ação de erro e códigos de saída

Para palavras-chave de shell integradas, fornecemos os seguintes padrões usados por executores hospedados no GitHub. Você deve seguir estas diretrizes quando executar scripts shell.

• bash/sh:

  • Comportamento de falha rápido que usa set -eo pipefail: Padrão para bash e shell embutido. Também é o padrão quando você não der opção em plataformas que não sejam Windows.
  • Você pode cancelar o fail-fast e assumir o controle fornecendo uma string de modelo para as opções do shell. Por exemplo, bash {0}.
  • Shells do tipo sh saem com o código de saída do último comando executado em um script, que também é o comportamento padrão das ações. O executor relatará o status da etapa como falha/êxito com base nesse código de saída.

• powershell/pwsh

  • Comportamento fail-fast quando possível. Para shell integrado pwsh e powershell, precederemos $ErrorActionPreference = 'stop' para conteúdos de script.
  • Vincularemos if ((Test-Path -LiteralPath variable:\LASTEXITCODE)) { exit $LASTEXITCODE } a scripts powershell para que os status da ação reflitam o código de saída mais recente do script.
  • Os usuários podem sempre optar por não usar o shell integrado e fornecer uma opção personalizada, como: pwsh -File {0} ou powershell -Command "& '{0}'", dependendo da situação.

• cmd

  • Parece não haver uma forma de optar totalmente por um comportamento fail-fast que não seja gravar seu script para verificar cada código de erro e reagir de acordo. Como não podemos fornecer esse comportamento por padrão, você precisa gravá-lo em seu script.
  • cmd.exe sairá com o nível de erro do último programa que executou e retornará o código de erro para o executor. Este comportamento é internamente consistente o padrão de comportamento anterior sh e pwsh, e é o padrão cmd.exe; portanto, ele fica intacto.

jobs.<job_id>.steps[*].with

Um map (mapa) dos parâmetros de entrada definidos pela ação. Cada parâmetro de entrada é um par chave/valor. Parâmetros de entrada são definidos como variáveis de ambiente. A variável é precedida por INPUT_ e convertida em letras maiúsculas.

Exemplo

Define os três parâmetros de entrada (first_name, middle_name e last_name) definidos pela ação hello_world. Essas variáveis de entrada estarão acessíveis para a ação hello-world como variáveis de ambiente INPUT_FIRST_NAME, INPUT_MIDDLE_NAME e INPUT_LAST_NAME.

jobs:
  my_first_job:
    steps:
      - name: My first step
        uses: actions/hello_world@main
        with:
          first_name: Mona
          middle_name: The
          last_name: Octocat      

jobs.<job_id>.steps[*].with.args

Uma string que define as entradas para um contêiner Docker. O GitHub entrega os args ao ENTRYPOINT do contêiner quando o contêiner inicia. Um array de strings não é compatível com esse parâmetro.

Exemplo

steps:
  - name: Explain why this job ran
    uses: monacorp/action-name@main
    with:
      entrypoint: /bin/echo
      args: The ${{ github.event_name }} event triggered this step.

args são usados em substituição à instrução CMD em um Dockerfile. Se você usar CMD no Dockerfile, use as diretrizes ordenadas por preferência:

1. Documente os argumentos necessários no README das ações e omita-os da instrução CMD.
2. Use padrões que permitam o uso da ação sem especificação de args.
3. Se a ação expõe um sinalizador --help ou similar, use isso como padrão para que a ação se documente automaticamente.

jobs.<job_id>.steps[*].with.entrypoint

Anula o ENTRYPOINT Docker no Dockerfile ou define-o caso ainda não tenha sido especificado. Diferentemente da instrução Docker ENTRYPOINT que tem um formulário shell e exec, a palavra-chave entrypoint aceita apena uma única string que define o executável.

Exemplo

steps:
  - name: Run a custom command
    uses: monacorp/action-name@main
    with:
      entrypoint: /a/different/executable

A palavra-chave entrypoint é para ser usada com ações de contêiner Docker, mas você também pode usá-la com ações JavaScript que não definem nenhuma entrada.

jobs.<job_id>.steps[*].env

Define variáveis de ambiente para etapas a serem usadas no ambiente do executor. Também é possível definir variáveis de ambiente para todo o fluxo de trabalho ou para um trabalho. Para obter mais informações, consulte env e jobs.<job_id>.env.

Quando mais de uma variável de ambiente é definida com o mesmo nome, GitHub usa a variável de ambiente mais específica. Por exemplo, uma variável de ambiente definida em uma etapa substituirá variáveis de trabalho e de fluxo de trabalho pelo mesmo nome enquanto a etapa é executada. Uma variável definida para um trabalho substituirá uma variável de fluxo de trabalho com o mesmo nome, enquanto o trabalho é executado.

Ações públicas podem especificar variáveis de ambiente esperadas no arquivo LEIAME. Se você está configurando um segredo em uma variável de ambiente, use o contexto secrets. Para obter mais informações, consulte "Usar variáveis de ambientee "Sintaxe de contexto e expressão para GitHub Actions".

Exemplo

steps:
 - name: minha primeira ação
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    FIRST_NAME: Mona
    LAST_NAME: Octocat

jobs.<job_id>.steps[*].continue-on-error

Impede a falha de um trabalho se uma etapa não funcionar. Defina true (verdadeiro) para permitir que um trabalho aconteça quando essa etapa falhar.

jobs.<job_id>.steps[*].timeout-minutes

Número máximo de minutos para executar a etapa antes de interromper o processo.

jobs.<job_id>.timeout-minutes

Número máximo de minutos para permitir a execução de um trabalho o antes que o GitHub o cancele automaticamente. Padrão: 360

jobs.<job_id>.strategy

Estratégias criam matrizes de compilação para os trabalhos. Você pode definir variações diferentes variações nas quais executar os trabalhos.

jobs.<job_id>.strategy.matrix

Você pode definir uma matriz de diferentes configurações de trabalho. Uma matriz permite que você crie vários trabalhos que realizam a substituição de variável em uma definição de trabalho único. Por exemplo, você pode usar uma matriz para criar trabalhos para mais de uma versão compatível de uma linguagem de programação, sistema operacional ou ferramenta. Uma matriz reutiliza a configuração do trabalho e cria trabalho para cada matriz que você configurar.

Uma matriz de tarefas pode gerar 256 tarefas no máximo por execução do fluxo de trabalho. Este limite também se aplica a executores auto-hospedados.

Cada opção que você define na matriz tem uma chave e um valor. As chaves que você define tornam-se propriedades no contexto da matriz e você pode fazer referência à propriedade em outras áreas do seu arquivo de fluxo de trabalho. Por exemplo, se você definir a chave os que contém um array de sistemas operacionais, você poderá usar a propriedade matrix.os como o valor da palavra-chave runs-on para criar um trabalho para cada sistema operacional. Para obter mais informações, consulte "Contexto e sintaxe de expressão para GitHub Actions".

A ordem que você define uma matriz importa. A primeira opção que você definir será a primeira que será executada no seu fluxo de trabalho.

Example: Running multiple versions of Node.js

Você pode especificar uma matriz ao fornecer um array para as opções de configuração. Por exemplo, se o executor for compatível com as versões 10, 12 e 14 do Node.js versões, você poderá especificar um array dessas versões na matriz.

Este exemplo cria uma matriz de três trabalhos, definindo a chave nó para um array de três versões do Node.js. Para usar a matriz, o exemplo define a propriedade do contexto matrix.node como o valor do parâmetro setup-node de entrada da ação node-version. Como resultado, três trabalhos serão executados, cada uma usando uma versão diferente do Node.js.

strategy:
  matrix:
    node: [10, 12, 14]
steps:
  # Configures the node version used on GitHub-hosted runners
  - uses: actions/setup-node@v2
    with:
      # The Node.js version to configure
      node-version: ${{ matrix.node }}

A ação setup-node ` é a forma recomendada de configurar uma versão do Node.js ao usar executores hospedados em GitHub. Para obter mais informações, consulte a ação [setup-node`](https://github.com/actions/setup-node).

Example: Running with multiple operating systems

Você pode criar uma matriz para executar fluxos de trabalho em mais de um sistema operacional do executor. Você também pode especificar mais de uma configuração da matriz. Este exemplo cria uma matriz de 6 trabalhos:

• 2 sistemas operacionais especificados na array os
• 3 versões do Node.js especificadas na array do nó

Ao definir uma matriz de sistemas operacionais, você deve definir o valor de runs-on para a propriedade de contexto de matrix.os que você definiu.

runs-on: ${{ matrix.os }}
strategy:
  matrix:
    os: [ubuntu-18.04, ubuntu-20.04]
    node: [10, 12, 14]
steps:
  - uses: actions/setup-node@v2
    with:
      node-version: ${{ matrix.node }}

Para encontrar opções de configuração compatíveis com executores hospedados em GitHub, consulte "Ambientes virtuais para executores hospedados em GitHub."

Example: Including additional values into combinations

Você pode adicionar opções de configurações para um trabalho de matriz de compilação existente. Por exemplo, se você quer usar uma versão específica do npm quando o trabalho que usa o windows-latest e a versão 8 do nó é executado, você pode usar incluir para especificar a opção adicional.

runs-on: ${{ matrix.os }}
strategy:
  matrix:
    os: [macos-latest, windows-latest, ubuntu-18.04]
    node: [8, 10, 12, 14]
    include:
      # includes a new variable of npm with a value of 6
      # for the matrix leg matching the os and version
      - os: windows-latest
        node: 8
        npm: 6

Example: Including new combinations

Você pode usar incluir para adicionar novos trabalhos a uma matriz de criação. Qualquer configuração sem correspondência de incluir será adicionadas à matriz. Por exemplo, se você quiser usar a versão 14 do nó para compilar em vários sistemas operacionais, mas quiser uma tarefa experimental extra usando o node 15 no Ubuntu, você poderá usar incluir para especificar essa tarefa adicional.

runs-on: ${{ matrix.os }}
strategy:
  matrix:
    node: [14]
    os: [macos-latest, windows-latest, ubuntu-18.04]
    include:
      - node: 15
        os: ubuntu-18.04
        experimental: true

Example: Excluding configurations from a matrix

Você pode remover uma configuração específica definida na matriz de compilação usando a opção exclude (excluir). exclude remove um trabalho definido pela matriz de compilação. O número de trabalhos é o produto cruzado do número de sistemas operacionais (os) incluídos nos arrays fornecidos por você, menos quaisquer subtrações (exclude).

runs-on: ${{ matrix.os }}
strategy:
  matrix:
    os: [macos-latest, windows-latest, ubuntu-18.04]
    node: [8, 10, 12, 14]
    exclude:
      # excludes node 8 on macOS
      - os: macos-latest
        node: 8

Usando variáveis de ambiente em uma matriz

Você pode adicionar variáveis de ambiente personalizadas para cada combinação de testes usando a chave include. Em seguida, você pode se referir às variáveis de ambiente personalizadas em um passo posterior.

Neste exemplo, as entradas da matriz de node-version são configuradas para usar valores diferentes para as variáveis de ambiente do site e dos centros de dados. Em seguida, a etapa de Echo site details usa env: ${{ matrix.env }} para referir-se às variáveis personalizadas:

name: Node.js CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
       include:
         - node-version: 10.x
           site: "prod"
           datacenter: "site-a"
         - node-version: 12.x
           site: "dev"
           datacenter: "site-b"
    steps:
      - name: Echo site details
        env:
          SITE: ${{ matrix.site }}
          DATACENTER: ${{ matrix.datacenter }}
        run: echo $SITE $DATACENTER

jobs.<job_id>.strategy.fail-fast

Quando definido como true, o GitHub cancela todos os trabalhos em andamento em caso de falha de algum trabalho de matrix. Padrão: true

jobs.<job_id>.strategy.max-parallel

Número máximo de trabalhos que podem ser executados simultaneamente ao usar uma estratégia de trabalho de matrix. Por padrão, o GitHub maximizará o número de trabalhos executados em paralelo dependendo dos executores disponíveis nas máquinas virtuais hospedadas no GitHub.

strategy:
  max-parallel: 2

jobs.<job_id>.continue-on-error

Impede que ocorra falha na execução de um fluxo de trabalho quando ocorrer uma falha em um trabalho. Defina como verdadeiro para permitir que uma execução de um fluxo de trabalho passe quando este trabalho falhar.

Example: Preventing a specific failing matrix job from failing a workflow run

Você pode permitir que as tarefas específicas em uma matriz de tarefas falhem sem que ocorra falha na execução do fluxo de trabalho. Por exemplo, se você deseja permitir apenas um trabalho experimental com o nó definido como 15 sem falhar a execução do fluxo de trabalho.

runs-on: ${{ matrix.os }}
continue-on-error: ${{ matrix.experimental }}
strategy:
  fail-fast: false
  matrix:
    node: [13, 14]
    os: [macos-latest, ubuntu-18.04]
    experimental: [false]
    include:
      - node: 15
        os: ubuntu-18.04
        experimental: true

jobs.<job_id>.container

Contêiner para executar qualquer etapa em um trabalho que ainda não tenha especificado um contêiner. Se você tiver etapas que usam ações de script e de contêiner, as ações de contêiner serão executadas como contêineres irmãos na mesma rede e com as mesmas montagens de volume.

Se você não definir um container, todas as etapas serão executadas diretamente no host especificado por runs-on, a menos que uma etapa se refira a uma ação configurada para execução em um contêiner.

Exemplo

jobs:
  my_job:
    container:
      image: node:14.16
      env:
        NODE_ENV: development
      ports:
        - 80
      volumes:
        - my_docker_volume:/volume_mount
      options: --cpus 1

Ao especificar somente uma imagem de contêiner, você pode omitir a palavra-chave image.

jobs:
  my_job:
    container: node:14.16

jobs.<job_id>.container.image

Imagem Docker a ser usada como contêiner para executar a ação. O valor pode ser o nome da imagem do Docker Hub ou um nome do registro.

jobs.<job_id>.container.credentials

Se o container registry da imagem exigir autenticação para fazer pull da imagem, você pode usar as credenciais para definir um mapa do nome de usuário e senha. As credenciais são os mesmos valores que você forneceria para o comando login do docker.

Exemplo

container:
  image: ghcr.io/owner/image
  credentials:
     username: ${{ github.actor }}
     password: ${{ secrets.ghcr_token }}

jobs.<job_id>.container.env

Define um mapa das variáveis de ambiente no contêiner.

jobs.<job_id>.container.ports

Define um array de portas para expor no contêiner.

jobs.<job_id>.container.volumes

Define um array de volumes para uso do contêiner. É possível usar volumes para compartilhar dados entre serviços ou outras etapas em um trabalho. Você pode especificar volumes de nome Docker, volumes Docker anônimos ou vincular montagens no host.

Para especificar um volume, especifique o caminho de origem e destino:

<source>:<destinationPath>.

<source> é um nome de volume ou caminho absoluto na máquina host, e <destinationPath> é um caminho absoluto no contêiner.

Exemplo

volumes:
  - my_docker_volume:/volume_mount
  - /data/my_data
  - /source/directory:/destination/directory

jobs.<job_id>.container.options

Opções adicionais de recursos do contêiner Docker. Para obter uma lista de opções, consulte "opções docker create".

jobs.<job_id>.services

Usado para hospedar contêineres de serviço para um trabalho em um fluxo de trabalho. Contêineres de serviço são úteis para a criação de bancos de dados ou serviços armazenamento em cache como o Redis. O executor cria automaticamente uma rede do Docker e gerencia o ciclo de vida dos contêineres do serviço.

Se você configurar seu trabalho para ser executado em um contêiner, ou a sua etapa usar ações ao contêiner, você não precisará mapear as portas para acessar o serviço ou a ação. O Docker expõe automaticamente todas as portas entre os contêineres da mesma rede de ponte definida pelo usuário. Você pode fazer referência ao contêiner de serviço diretamente pelo seu nome de host. O nome do host é mapeado automaticamente com o nome da etiqueta que você configurar para o serviço no fluxo de trabalho.

Se você configurar a tarefa para executar diretamente na máquina do executor e sua etapa não usar uma ação de contêiner, você deverá mapear todas as portas de contêiner de serviço do Docker necessárias para o host do Docker (a máquina do executor). Você pode acessar o contêiner de serviço usando host local e a porta mapeada.

Para obter mais informações sobre as diferenças entre os contêineres de serviço de rede, consulte "Sobre contêineres de serviço".

Example: Using localhost

Este exemplo cria dois serviços: nginx e redis. Ao especificar a porta do host do Docker mas não a porta do contêiner, a porta do contêiner será atribuída aleatoriamente a uma porta livre. O GitHub define a porta de contêiner atribuída no contexto ${{job.services.<service_name>.ports}}. Neste exemplo, você pode acessar as portas do contêiner de serviço usando os contextos ${{ job.services.nginx.ports['8080'] }} e ${{ job.services.redis.ports['6379'] }}.

serviços:
  nginx:
    imagem: nginx
    # Mapeia a porta 8080 no host do Docker com a porta 80 no contêiner nginx
    portas:
      - 8080:80
  redis:
    imagem: redis
    # Mapeia a porta  port 6379 TCP no host do Docker com uma porta livre aleatória no contêiner Redis
    portas:
      - 6379/tcp

jobs.<job_id>.services.<service_id>.image

Imagem Docker a ser usada como contêiner de serviço para executar a ação. O valor pode ser o nome da imagem do Docker Hub ou um nome do registro.

jobs.<job_id>.services.<service_id>.credentials

Se o container registry da imagem exigir autenticação para fazer pull da imagem, você pode usar as credenciais para definir um mapa do nome de usuário e senha. As credenciais são os mesmos valores que você forneceria para o comando login do docker.

Exemplo

services:
  myservice1:
    image: ghcr.io/owner/myservice1
    credentials:
      username: ${{ github.actor }}
      password: ${{ secrets.ghcr_token }}
  myservice2:
    image: dockerhub_org/myservice2
    credentials:
      username: ${{ secrets.DOCKER_USER }}
      password: ${{ secrets.DOCKER_PASSWORD }}

jobs.<job_id>.services.<service_id>.env

Define um maá das variáveis de ambiente no contêiner do serviço.

jobs.<job_id>.services.<service_id>.ports

Define um array de portas para expor no contêiner de serviço.

jobs.<job_id>.services.<service_id>.volumes

Define um array de volumes para uso do contêiner de serviço. É possível usar volumes para compartilhar dados entre serviços ou outras etapas em um trabalho. Você pode especificar volumes de nome Docker, volumes Docker anônimos ou vincular montagens no host.

Para especificar um volume, especifique o caminho de origem e destino:

<source>:<destinationPath>.

<source> é um nome de volume ou caminho absoluto na máquina host, e <destinationPath> é um caminho absoluto no contêiner.

Exemplo

volumes:
  - my_docker_volume:/volume_mount
  - /data/my_data
  - /source/directory:/destination/directory

jobs.<job_id>.services.<service_id>.options

Opções adicionais de recursos do contêiner Docker. Para obter uma lista de opções, consulte "opções docker create".

Folha de consulta de filtro padrão

Você pode usar caracteres especiais nos filtros de caminhos, branches e tags.

• *: Corresponde a zero ou mais caracteres, mas não Corresponde ao caractere /. Por exemplo, Octo* corresponde a Octocat.
• **: Corresponde a zero ou mais de qualquer caractere.
• ?: Corresponde a zero ou a um único caractere. Por exemplo, Octoc?t corresponde a Octocat.
• +: Corresponde a um ou mais dos caracteres anteriores.
• [] Corresponde a um caractere listado entre colchetes ou incluído nos intervalos. Os intervalos só podem incluir valores de a-z, A-Z, e 0-9. Por exemplo, o intervalo[0-9a-z] corresponde a qualquer letra maiúscula ou minúscula. Por exemplo, [CB]at corresponde a Cat ou Bat e [1-2]00 corresponde a 100 e 200.
• ! No início de um padrão faz com que ele anule padrões positivos anteriores. Não tem nenhum significado especial caso não seja o primeiro caractere.

Os caracteres *, [ e ! são caracteres especiais em YAML. Se você iniciar um padrão com *, [ ou !, você deverá colocá-lo entre aspas.

# Válido
- '**/README.md'

# Inválido - Cria um erro de análise que
# impede que o seu fluxo de trabalho seja executado.
- **/README.md

Para obter mais informações sobre a sintaxe de filtros de branches, tags e caminhos, consulte "on.<push|pull_request>.<branches|tags>" e "on.<push|pull_request>.paths".

Padrões para corresponder branches e tags

Padrões para corresponder a caminhos de arquivos

Padrões de caminhos devem corresponder ao caminho completo e iniciar a partir da raiz do repositório.