Skip to main content

Esta versão do GitHub Enterprise será descontinuada em 2022-02-16. Nenhum lançamento de patch será feito, mesmo para questões críticas de segurança. Para obter melhor desempenho, melhorar a segurança e novos recursos, upgrade to the latest version of GitHub Enterprise. Para ajuda com a atualização, contact GitHub Enterprise support.

Contextos

Você pode acessar as informações de contexto nos fluxos de trabalho e nas ações.

Observação: Executores hospedados em GitHub não são atualmente compatíveis com GitHub Enterprise Server. Você pode ver mais informações sobre suporte futuro planejado no Itinerário público do GitHub.

Sobre os contextos

Os contextos são uma forma de acessar informações sobre execuções de fluxo de trabalho, ambientes dos executores, trabalhos e etapas. Cada contexto é um objeto que contém propriedades, que podem ser strings ou outros objetos.

Contexts, objects, and properties will vary significantly under different workflow run conditions. Por exemplo, o contexto matriz só é povoado para trabalhos em uma matrizmatriz de construção.

Você pode acessar contextos usando a sintaxe da expressão. Para obter mais informações, consulte "Expressões".

${{ <context> }}

Aviso: Ao criar fluxos de trabalho e ações, você sempre deve considerar se seu código pode executar entradas não confiáveis de possíveis invasores. Certos contextos devem ser tratados como entradas não confiáveis, uma vez que um invasor pode inserir seu próprio conteúdo malicioso. Para obter mais informações, consulte "Entender o risco de injeções de scripts".

Nome do contextoTipoDescrição
githubobjetoInformações sobre a execução do fluxo de trabalho. Para obter mais informações, consulte contexto github.
envobjetoContém variáveis de ambiente definidas em um fluxo de trabalho, trabalho ou etapa. Para obter mais informações, consulte o contexto env.
trabalhoobjetoInformações sobre o trabalho atualmente em execução. Para obter mais informações, consulte contexto trabalho.
stepsobjetoInformações sobre as etapas que foram executadas no trabalho atual. Para obter mais informações, consulte contexto etapas.
runnerobjetoInformações sobre o executor do trabalho atual. Para obter mais informações, consulte runner context.
secretsobjetoContém nomes e valores de segredos que estão disponíveis para a execução de um fluxo de trabalho. Para obter mais informações, consulte o contexto segredos.
strategyobjetoInformações sobre a estratégia de execução da matriz para o trabalho atual. Para obter mais informações, consulte o contexto estratégia.
matrixobjetoContém as propriedades da matriz definidas no fluxo de trabalho que se aplicam ao trabalho atual. Para obter mais informações, consulte o contexto matriz.
needsobjetoContém os resultados de todos os trabalhos que são definidos como uma dependência do trabalho atual. Para obter mais informações, consulte o contexto needs.

Como parte de uma expressão, você pode acessar informações de contexto usando uma das duas sintaxes.

  • Sintaxe de índice: github['sha'];
  • Sintaxe de propriedade de desreferência: github.sha

Para usar a sintaxe de propriedade de desreferência, o nome da propriedade deve:

  • começar com a-Z ou _;
  • ser seguido por a-Z 0-9 - ou _.

Determinar quando usar contextos

GitHub Actions inclui uma coleção de variáveis denominadas contextos e uma coleção similar de variáveis denominadas variáveis de ambiente padrão. Estas variáveis são destinadas a serem usadas em diferentes pontos do fluxo de trabalho:

  • Variáveis de ambiente padrão: Essas variáveis existem apenas no executor que está executando seu trabalho. Para obter mais informações, consulte "Variáveis de ambiente padrão".
  • Contextos: Você pode usar a maioria dos contextos em qualquer ponto do seu fluxo de trabalho, incluindo quando as variáveis de ambiente padrão estariam indisponíveis. Por exemplo, você pode usar contextos com expressões para realizar o processamento inicial antes que o trabalho seja encaminhado para um executor para execução. Isso permite que você use um contexto com a palavra-chave condicional if para determinar se uma etapa deve ser executada. Assim que o trabalho estiver em execução, você também poderá recuperar as variáveis de contexto do executor que está executando o trabalho, como runner.os. Para obter informações sobre onde você pode usar vários contextos dentro de um fluxo de trabalho, consulte "Disponibilidade de contexto".

O exemplo a seguir demonstra como esses diferentes tipos de variáveis de ambiente podem ser usados juntos em um trabalho:

name: CI
on: push
jobs:
  prod-check:
    if: ${{ github.ref == 'refs/heads/main' }}
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploying to production server on branch $GITHUB_REF"

Neste exemplo, o comando if verifica o github.ref para determinar o nome do branch atual. Se o nome for refs/heads/main, as etapas subsequentes serão executadas. A verificação if é processada por GitHub Actions, e o trabalho é enviado apenas para o executor se o resultado for verdadeiro. Assim que o trabalho é enviado para o executor, a etapa é executada e refere-se à variável de ambiente $GITHUB_REF do executor.

Disponibilidade do contexto

Contextos diferentes estão disponíveis durante a execução de um fluxo de trabalho. Por exemplo, o contexto de segredos só pode ser usado em certos lugares dentro de um trabalho.

Além disso, algumas funções só podem ser utilizadas em determinados lugares. Por exemplo, a função hashFiles não está disponível em qualquer lugar.

A tabela a seguir indica onde cada contexto e função especial pode ser utilizado dentro de um fluxo de trabalho. A menos que esteja listado abaixo, uma função pode ser usada em qualquer lugar. | | Caminho | Contexto | Funções especiais | | --------------------------- | --------------------------- | --------------------------- | | concorrência | github | | | env | github, secrets | | | jobs.<job_id>.concurrency | github, needs, strategy, matrix | | | jobs.<job_id>.container | github, needs, strategy, matrix | | | jobs.<job_id>.container.credentials | github, needs, strategy, matrix, env, secrets | | | jobs.<job_id>.container.env.<env_id> | github, needs, strategy, matrix, job, runner, env, secrets | | | jobs.<job_id>.continue-on-error | github, needs, strategy, matrix | | | jobs.<job_id>.defaults.run | github, needs, strategy, matrix, env | | | jobs.<job_id>.env | github, needs, strategy, matrix, secrets | | | jobs.<job_id>.environment | github, needs, strategy, matrix | | | jobs.<job_id>.environment.url | github, needs, strategy, matrix, job, runner, env, steps | | | jobs.<job_id>.if | github, needs | always, cancelled, success, failure | | jobs.<job_id>.name | github, needs, strategy, matrix | | | jobs.<job_id>.outputs.<output_id> | github, needs, strategy, matrix, job, runner, env, secrets, steps | | | jobs.<job_id>.runs-on | github, needs, strategy, matrix | | | jobs.<job_id>.services | github, needs, strategy, matrix | | | jobs.<job_id>.services.<service_id>.credentials | github, needs, strategy, matrix, env, secrets | | | jobs.<job_id>.services.<service_id>.env.<env_id> | github, needs, strategy, matrix, job, runner, env, secrets | | | jobs.<job_id>.steps.continue-on-error | github, needs, strategy, matrix, job, runner, env, secrets, steps | hashFiles | | jobs.<job_id>.steps.env | github, needs, strategy, matrix, job, runner, env, secrets, steps | hashFiles | | jobs.<job_id>.steps.if | github, needs, strategy, matrix, job, runner, env, steps | always, cancelled, success, failure, hashFiles | | jobs.<job_id>.steps.name | github, needs, strategy, matrix, job, runner, env, secrets, steps | hashFiles | | jobs.<job_id>.steps.run | github, needs, strategy, matrix, job, runner, env, secrets, steps | hashFiles | | jobs.<job_id>.steps.timeout-minutes | github, needs, strategy, matrix, job, runner, env, secrets, steps | hashFiles | | jobs.<job_id>.steps.with | github, needs, strategy, matrix, job, runner, env, secrets, steps | hashFiles | | jobs.<job_id>.steps.working-directory | github, needs, strategy, matrix, job, runner, env, secrets, steps | hashFiles | | jobs.<job_id>.strategy | github, needs | | | jobs.<job_id>.timeout-minutes | github, needs, strategy, matrix | |

Exemplo: imprimir informações de contexto no registro

Você pode imprimir o conteúdo de contextos no registro para depuração. A função toJSON é necessária para imprimir objetos do JSON no registro.

Aviso: Ao usar todo o contexto do github, tenha em mente que ele inclui informações confidenciais, como github.token. GitHub oculta segredos quando eles são impressos no console, mas você deve ter cuidado ao exportar ou imprimir o contexto.

YAML
name: Context testing
on: push

jobs:
  dump_contexts_to_log:
    runs-on: ubuntu-latest
    steps:
      - name: Dump GitHub context
        id: github_context_step
        run: echo '${{ toJSON(github) }}'
      - name: Dump job context
        run: echo '${{ toJSON(job) }}'
      - name: Dump steps context
        run: echo '${{ toJSON(steps) }}'
      - name: Dump runner context
        run: echo '${{ toJSON(runner) }}'
      - name: Dump strategy context
        run: echo '${{ toJSON(strategy) }}'
      - name: Dump matrix context
        run: echo '${{ toJSON(matrix) }}'

Contexto github

O contexto github context contém informações sobre a execução do fluxo de trabalho e sobre o evento que a acionou. Você também pode ler a maioria dos dados do github em variáveis de ambiente. Para obter mais informações sobre as variáveis de ambiente, consulte "Usando variáveis de ambiente".

Aviso: Ao usar todo o contexto do github, tenha em mente que ele inclui informações confidenciais, como github.token. GitHub oculta segredos quando eles são impressos no console, mas você deve ter cuidado ao exportar ou imprimir o contexto.

Aviso: Ao criar fluxos de trabalho e ações, você sempre deve considerar se seu código pode executar entradas não confiáveis de possíveis invasores. Certos contextos devem ser tratados como entradas não confiáveis, uma vez que um invasor pode inserir seu próprio conteúdo malicioso. Para obter mais informações, consulte "Entender o risco de injeções de scripts".

Nome da propriedadeTipoDescrição
githubobjetoContexto de nível mais alto disponível em qualquer trabalho ou etapa de um fluxo de trabalho. Este objeto contém todas as propriedades listadas abaixo.
github.actionstringO nome da ação atualmente em execução ou o id de uma etapa. GitHub remove caracteres especiais e usa o nome __run quando a etapa atual executa um script sem um id. Se você usar a mesma ação mais de uma vez no mesmo trabalho, o nome incluirá um sufixo com o número da sequência com o sublinhado antes dele. Por exemplo, o primeiro script que você executar terá o nome __run e o segundo script será denominado __run_2. Da mesma forma, a segunda invocação de actions/checkout será actionscheckout2.
github.action_pathstringO caminho onde uma ação está localizada. Esta propriedade só é compatível com ações compostas. Você pode usar este caminho para acessar arquivos localizados no mesmo repositório da ação.
github.action_refstringPara uma etapa executando uma ação, este é o ref da ação que está sendo executada. Por exemplo, v2.
github.action_repositorystringPara uma etpa que executa uma ação, este é o nome do proprietário e do repositório da ação. Por exemplo, actions/checkout.
github.actorstringO nome de usuário que iniciou a execução do fluxo de trabalho.
github.api_urlstringA URL da API REST de GitHub.
github.base_refstringbase_ref ou branch alvo da pull request em uma execução de fluxo de trabalho. Esta propriedade só está disponível quando o evento que aciona a execução de um fluxo de trabalho for pull_request ou pull_request_target.
github.envstringCaminho no executor para o arquivo que define variáveis de ambiente dos comandos do fluxo de trabalho. Este arquivo é único para a etapa atual e é um arquivo diferente para cada etapa de um trabalho. Para obter mais informações, consulte "Comandos do fluxo de trabalho para GitHub Actions".
github.eventobjetoCarga de evento de webhook completa. Você pode acessar as propriedades individuais do evento usando este contexto. Este objeto é idêntico à carga do webhook do evento que acionou a execução do fluxo de trabalho e é diferente para cada evento. Os webhooks para cada evento de GitHub Actions que está vinculado em "Eventos que acionam fluxos de trabalho". Por exemplo, para uma execução do fluxo de trabalho acionada por um evento push, esse objeto contém o conteúdo da carga do webhook de push.
github.event_namestringNome do evento que acionou a execução do fluxo de trabalho.
github.event_pathstringO caminho para o arquivo no executor que contém a carga completa do webhook do evento.
github.graphql_urlstringA URL da API do GraphQL de GitHub.
github.head_refstringhead_ref ou branch de origem da pull request em uma execução de fluxo de trabalho. Esta propriedade só está disponível quando o evento que aciona a execução de um fluxo de trabalho for pull_request ou pull_request_target.
github.jobstringO job_id do trabalho atual.
github.refstringBranch ou ref tag que acionou a execução do fluxo de trabalho. Para branches, este é o formato refs/heads/<branch_name> e, para tags, é refs/tags/<tag_name>.
github.pathstringCaminho no executor no arquivo que define as variáveis do PATH do sistema a partir de comandos do fluxo de trabalho. Este arquivo é único para a etapa atual e é um arquivo diferente para cada etapa de um trabalho. Para obter mais informações, consulte "Comandos do fluxo de trabalho para GitHub Actions."

Exemplo de conteúdo do contexto github

O contexto a seguir é de um fluxo de trabalho executado pelo evento push. O objeto evento neste exemplo foi truncado porque é idêntico ao conteúdo da carga do webhook de push.

Note: This context is an example only. The contents of a context depends on the workflow that you are running. Contexts, objects, and properties will vary significantly under different workflow run conditions.

{
  "token": "***",
  "job": "dump_contexts_to_log",
  "ref": "refs/heads/my_branch",
  "sha": "c27d339ee6075c1f744c5d4b200f7901aad2c369",
  "repository": "octocat/hello-world",
  "repository_owner": "octocat",
  "repositoryUrl": "git://github.com/octocat/hello-world.git",
  "run_id": "1536140711",
  "run_number": "314",
  "retention_days": "90",
  "run_attempt": "1",
  "actor": "octocat",
  "workflow": "Context testing",
  "head_ref": "",
  "base_ref": "",
  "event_name": "push",
  "event": {
    ...
  },
  "server_url": "https://github.com",
  "api_url": "https://api.github.com",
  "graphql_url": "https://api.github.com/graphql",
  "ref_name": "my_branch",
  "ref_protected": false,
  "ref_type": "branch",
  "secret_source": "Actions",
  "workspace": "/home/runner/work/hello-world/hello-world",
  "action": "github_step",
  "event_path": "/home/runner/work/_temp/_github_workflow/event.json",
  "action_repository": "",
  "action_ref": "",
  "path": "/home/runner/work/_temp/_runner_file_commands/add_path_b037e7b5-1c88-48e2-bf78-eaaab5e02602",
  "env": "/home/runner/work/_temp/_runner_file_commands/set_env_b037e7b5-1c88-48e2-bf78-eaaab5e02602"
}

Exemplo de uso do contexto github

Este fluxo de trabalho de exemplo usa o contexto github.event_name para executar um trabalho somente se a execução do fluxo de trabalho for acionada pelo evento pull_request.

YAML
name: Run CI
on: [push, pull_request]

jobs:
  normal_ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run normal CI
        run: ./run-tests

  pull_request_ci:
    runs-on: ubuntu-latest
    if: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v2
      - name: Run PR CI
        run: ./run-additional-pr-ci

Contexto env

O contexto env contém variáveis de ambiente que foram definidas em um fluxo de trabalho, trabalho ou etapa. Para obter mais informações sobre como configurar variáveis de ambiente em seu fluxo de trabalho, consulte "Sintaxe do fluxo de trabalho para GitHub Actions".

A sintaxe de contexto env permite que você use o valor de uma variável de ambiente no seu arquivo de fluxo de trabalho. Você pode usar o contexto env no valor de qualquer chave em uma etapa, exceto para as chaves id e uses. Para obter mais informações sobre a sintaxe da etapa, consulte "Sintaxe do fluxo de trabalho para o GitHub Actions".

Se você desejar usar o valor de uma variável de ambiente dentro de um executor, use o método normal do sistema operacional do executor para ler as variáveis de ambiente.

Nome da propriedadeTipoDescrição
envobjetoEsse contexto altera cada etapa em um trabalho. Você pode acessar esse contexto em qualquer etapa de um trabalho. Este objeto contém as propriedades listadas abaixo.
env.<env_name>stringO valor de uma variável de ambiente específica.

Conteúdo do exemplo do contexto env

O conteúdo do contexto env é um mapeamento de nomes de variáveis de ambiente com os seus valores. O conteúdo do contexto pode mudar dependendo de onde é usado na execução do fluxo de trabalho.

{
  "first_name": "Mona",
  "super_duper_var": "totally_awesome"
}

Exemplo de uso do contexto env

Este exemplo de fluxo de trabalho mostra como o contexto env pode ser configurado no fluxo de trabalho, níveis de trabalho e de etapas, bem como usar o contexto em etapas.

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.

YAML
name: Hi Mascot
on: push
env:
  mascot: Mona
  super_duper_var: totally_awesome

jobs:
  windows_job:
    runs-on: windows-latest
    steps:
      - run: echo 'Hi ${{ env.mascot }}'  # Hi Mona
      - run: echo 'Hi ${{ env.mascot }}'  # Hi Octocat
        env:
          mascot: Octocat
  linux_job:
    runs-on: ubuntu-latest
    env:
      mascot: Tux
    steps:
      - run: echo 'Hi ${{ env.mascot }}'  # Hi Tux

Contexto trabalho

O contexto job (trabalho) contém informações sobre o trabalho atualmente em execução.

Nome da propriedadeTipoDescrição
trabalhoobjetoEsse contexto altera cada trabalho em uma execução de fluxo de trabalho. Você pode acessar esse contexto em qualquer etapa de um trabalho. Este objeto contém todas as propriedades listadas abaixo.
job.containerobjetoInformações sobre o contêiner do trabalho. Para obter mais informações sobre contêineres, consulte "Sintaxe de fluxo de trabalho para o GitHub Actions".
job.container.idstringO ID do contêiner.
job.container.networkstringO ID da rede do contêiner. O executor cria a rede usada por todos os contêineres em um trabalho.
job.servicesobjetoContêineres de serviços criados para um trabalho. Para obter mais informações sobre contêineres de serviço, consulte "Sintaxe de fluxo de trabalho para o GitHub Actions".
job.services.<service_id>.idstringO ID do contêiner de serviço.
job.services.<service_id>.networkstringO ID da rede de contêiner de serviço. O executor cria a rede usada por todos os contêineres em um trabalho.
job.services.<service_id>.portsobjetoAs portas expostas do contêiner de serviço.
job.statusstringStatus atual do trabalho. Possíveis valores são success, failure ou cancelled.

Exemplo de conteúdo do contexto trabalho

Este exemplo contexto do job usa um contêiner de serviço do PostgreSQL com portas mapeadas. Se não houver contêineres ou contêineres de serviço usados em um trabalho, o contexto trabalho só conterá a propriedade status.

{
  "status": "success",
  "container": {
    "network": "github_network_53269bd575974817b43f4733536b200c"
  },
  "services": {
    "postgres": {
      "id": "60972d9aa486605e66b0dad4abb638dc3d9116f566579e418166eedb8abb9105",
      "ports": {
        "5432": "49153"
      },
      "network": "github_network_53269bd575974817b43f4733536b200c"
    }
  }
}

Exemplo de uso do contexto trabalho

Este exemplo de fluxo de trabalho configura um contêiner de serviço do PostgreSQL e mapeia automaticamente a porta 5432 do recipiente de serviço com uma porta disponível escolhida aleatoriamente no host. O contexto job é usado para acessar o número da porta atribuída no host.

YAML
name: PostgreSQL Service Example
on: push
jobs:
  postgres-job:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres
        env:
          POSTGRES_PASSWORD: postgres
        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
        ports:
          # Maps TCP port 5432 in the service container to a randomly chosen available port on the host.
          - 5432

    steps:
      - uses: actions/checkout@v2
      - run: pg_isready -h localhost -p ${{ job.services.postgres.ports[5432] }}
      - run: ./run-tests

Contexto etapas

O contexto etapas contém informações sobre as etapas do trabalho atual que possuem um id especificado e já executado.

Nome da propriedadeTipoDescrição
stepsobjetoEsse contexto altera cada etapa em um trabalho. Você pode acessar esse contexto em qualquer etapa de um trabalho. Este objeto contém todas as propriedades listadas abaixo.
steps.<step_id>.outputsobjetoConjunto de saídas definidas para a etapa. Para obter mais informações, consulte "Sintaxe de metadados para o GitHub Actions".
steps.<step_id>.conclusionstringO resultado de uma etapa concluída após continue-on-error ser aplicado. Os valores possíveis são: sucesso, falha, canceladoou ignorado. Quando ocorre uma falha na etapa de continue-on-error, o resultado será falha, mas a conclusão final será sucesso.
steps.<step_id>.outcomestringO resultado de uma etapa concluída antes de continue-on-error ser aplicado. Os valores possíveis são: sucesso, falha, canceladoou ignorado. Quando ocorre uma falha na etapa de continue-on-error, o resultado será falha, mas a conclusão final será sucesso.
steps.<step_id>.outputs.<output_name>stringValor de uma saída específica.

Exemplo de conteúdo do contexto etapas

Este exemplo passo contexto mostra duas etapas anteriores que tinham um id especificado. O id da primeira etapa era denominado checkout e o segundo, generate_number. A etapa generate_number tinha uma saída denominada random_number.

{
  "checkout": {
    "outputs": {},
    "outcome": "success",
    "conclusion": "success"
  },
  "generate_number": {
    "outputs": {
      "random_number": "1"
    },
    "outcome": "success",
    "conclusion": "success"
  }
}

Exemplo de uso do contexto de etapas

Este exemplo de fluxo de trabalho gera um número aleatório como saída em uma etapa e uma etapa posterior usa o contexto etapas para ler o valor dessa saída.

YAML
name: Generate random failure
on: push
jobs:
  randomly-failing-job:
    runs-on: ubuntu-latest
    steps:
      - id: checkout
        uses: actions/checkout@v2
      - name: Generate 0 or 1
        id: generate_number
        run:  echo "::set-output name=random_number::$(($RANDOM % 2))"
      - name: Pass or fail
        run: |
          if [[ ${{ steps.generate_number.outputs.random_number }} == 0 ]]; then exit 0; else exit 1; fi

Contexto do executor

O contexto do executor contém informações sobre o executor que está executando o trabalho atual.

Nome da propriedadeTipoDescrição
runnerobjetoEsse contexto altera cada trabalho em uma execução de fluxo de trabalho. Este objeto contém todas as propriedades listadas abaixo.
runner.namestringO nome do executor que executa a tarefa.
runner.osstringO sistema operacional do executor que está executando o trabalho. Os valores possíveis são: Linux, Windows ou macOS.
runner.tempstringO caminho para um diretório temporário no executor. Este diretório é esvaziado no início e no final de cada trabalho. Observe que os arquivos não serão removidos se a conta de usuário do executor não tiver permissão para excluí-los.
runner.tool_cachestringO caminho para o diretório que contém ferramentas pré-instaladas para executores hospedados em GitHub. For more information, see "About GitHub-hosted runners".

Exemplo de conteúdo do contexto do executor

O contexto de exemplo a seguir é de um executor do Linux hospedado em GitHub.

{
  "os": "Linux",
  "arch": "X64",
  "name": "GitHub Actions 2",
  "tool_cache": "/opt/hostedtoolcache",
  "temp": "/home/runner/work/_temp"
}

Exemplo de uso do contexto do contexto do executor

Este exemplo de fluxo de trabalho usa o contexto executor para definir o caminho para o diretório temporário e gravar registros e se, o fluxo de trabalho falhar, ele irá fazer o uplad dos registros como artefatos.

YAML
name: Build
on: push

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build with logs
        run: |
          mkdir ${{ runner.temp }}/build_logs
          ./build.sh --log-path ${{ runner.temp }}/build_logs
      - name: Upload logs on fail
        if: ${{ failure() }}
        uses: actions/upload-artifact@v2
        with:
          name: Build failure logs
          path: ${{ runner.temp }}/build_logs

contexto segredos

O contexto segredos contém os nomes e valores de segredos disponíveis para a execução de um fluxo de trabalho. O contexto segredos não está disponível para ações compostas. Para obter mais informações sobre segredos, consulte "Segredos criptografados".

GITHUB_TOKEN é um segredo que é criado automaticamente para cada execução de fluxo de trabalho, e é sempre incluído no contexto segredos. Para obter mais informações, consulte "Autenticação automática de tokens".

Aviso: GitHub elimina automaticamente os segredos impressos no registro, mas você deve evitar a impressão intencional de segredos no log.

Nome da propriedadeTipoDescrição
secretsobjetoEsse contexto é o mesmo para cada trabalho em uma execução do fluxo de trabalho. Você pode acessar esse contexto em qualquer etapa de um trabalho. Este objeto contém todas as propriedades listadas abaixo.
secrets.GITHUB_TOKENstringToken criado automaticamente para cada execução do fluxo de trabalho. Para obter mais informações, consulte "Autenticação automática de tokens".
secrets.<secret_name>stringO valor de um segredo específico.

Exemplo de conteúdo do contexto segredo

O conteúdo de exemplo do contexto dos segredos mostra o GITHUB_TOKEN automático, assim como outros dois segredos disponíveis para a execução do fluxo de trabalho.

{
  "github_token": "***",
  "NPM_TOKEN": "***",
  "SUPERSECRET": "***"
}

Exemplo de uso do contexto dos segredos

Este exemplo de fluxo de trabalho usa a ação etiquetadora, que exige o GITHUB_TOKEN como o valor para o parâmetro de entrada do token:

YAML
name: Pull request labeler
on: [ pull_request_target ]

jobs:
  triage:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/labeler@v2
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}

Contexto estratégia

Para fluxos de trabalho com uma matriz de compilação, o contexto estratégia contém informações sobre a estratégia de execução da matriz para o trabalho atual.

Nome da propriedadeTipoDescrição
strategyobjetoEsse contexto altera cada trabalho em uma execução de fluxo de trabalho. Você pode acessar este contexto a partir de qualquer trabalho ou etapa em um fluxo de trabalho. Este objeto contém todas as propriedades listadas abaixo.
strategy.fail-faststringQuando verdadeiro, todos os trabalhos em andamento são cancelados se qualquer trabalho em uma matriz de compilação falhar. Para obter mais informações, consulte "Sintaxe de fluxo de trabalho para o GitHub Actions".
strategy.job-indexstringO índice do trabalho atual na matriz de compilação. Observação: Este número é um número baseado em zero. O primeiro índice do trabalho na matriz de compilação é 0.
strategy.job-totalstringO número total de trabalhos na matriz de construção. Observação: Este número não é um número baseado em zero. Por exemplo, para uma matriz de construção com quatro trabalhos, o valor de job-total de é 4.
strategy.max-parallelstringNúmero máximo de trabalhos que podem ser executados simultaneamente ao usar uma estratégia de trabalho de matrix. Para obter mais informações, consulte "Sintaxe de fluxo de trabalho para o GitHub Actions".

Exemplo de conteúdo do contexto estratégia

O conteúdo de exemplo a seguir do contexto estratégia é de uma matriz de construção com quatro trabalhos, e é tirada do trabalho final. Observe a diferença entre o número de job-index baseado em zero e o total de job-job que não é baseado em zero.

{
  "fail-fast": true,
  "job-index": 3,
  "job-total": 4,
  "max-parallel": 4
}

Exemplo de uso do contexto estratégia

Esse exemplo de fluxo de trabalho usa a propriedade strategy.job-index para definir um nome exclusivo para um arquivo de registro para cada trabalho em uma matriz de criação.

YAML
name: Test matrix
on: push

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        test-group: [1, 2]
        node: [14, 16]
    steps:
      - uses: actions/checkout@v2
      - run: npm test > test-job-${{ strategy.job-index }}.txt
      - name: Upload logs
        uses: actions/upload-artifact@v2
        with:
          name: Build log for job ${{ strategy.job-index }}
          path: test-job-${{ strategy.job-index }}.txt

Contexto matriz

Para fluxos de trabalho com uma matriz de construção, o contexto matriz contém as propriedades definidas no arquivo do fluxo de trabalho que se aplicam ao trabalho atual. Por exemplo, se você configurar uma matriz de construção com as chaves os e , o objeto do contexto matriz irá incluir as propriedades os e com os valores usados para o trabalho atual.

Não há propriedades padrão no contexto matriz, apenas as que são definidas no arquivo do fluxo de trabalho.

Nome da propriedadeTipoDescrição
matrixobjetoEsse contexto só está disponível para trabalhos em uma matriz de compilação e alterações para cada trabalho na execução de um fluxo de trabalho. Você pode acessar este contexto a partir de qualquer trabalho ou etapa em um fluxo de trabalho. Este objeto contém as propriedades listadas abaixo.
matrix.<property_name>stringO valor da propriedade de uma matriz.

Exemplo de conteúdo do contexto matriz

O exemplo a seguir do contexto matriz é de um trabalho em uma matriz de construção que tem as propriedades de matriz os e definidas no fluxo de trabalho. O trabalho está executando a combinação matriz de um ubuntu-latest OS e do Node.js versão 16.

{
  "os": "ubuntu-latest",
  "node": 16
}

Exemplo de uso do contexto matriz

Este exemplo de fluxo de trabalho cria uma matriz de compilação com as chaves os e nós. Ele usa a propriedade matriz.os para definir o tipo de executor para cada trabalho e usa a propriedade matrix.node para definir a versão do Node.js para cada trabalho.

YAML
name: Test matrix
on: push

jobs:
  build:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        node: [14, 16]
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node }}
      - name: Install dependencies
        run: npm ci
      - name: Run tests
        run: npm test

Contexto needs

O contexto needs contém saídas de todos os trabalhos definidos como uma dependência do trabalho atual. Para obter mais informações sobre a definição de dependências de trabalho, consulte "Sintaxe de fluxo de trabalho para GitHub Actions".

Nome da propriedadeTipoDescrição
needsobjetoEsse contexto só é preenchido para execuções de fluxo de trabalho com funções dependentes e as alterações para cada trabalho em uma execução de fluxo de trabalho. Você pode acessar este contexto a partir de qualquer trabalho ou etapa em um fluxo de trabalho. Este objeto contém todas as propriedades listadas abaixo.
needs.<job_id>objetoUm único trabalho do qual o trabalho atual depende.
needs.<job_id>.outputsobjetoO conjunto de saídas de um trabalho do qual o trabalho atual depende.
needs.<job_id>.outputs.<output name>stringO valor de uma saída específica para um trabalho do qual o trabalho atual depende.
needs.<job_id>.resultstringO resultado de um trabalho do qual depende o trabalho atual. Os valores possíveis são: sucesso, falha, canceladoou ignorado.

Exemplo de conteúdo do contexto needs

O conteúdo de exemplo a seguir do contexto needs mostra informações para dois trabalhos dos quais o trabalho atual depende.

{
  "build": {
    "result": "success",
    "outputs": {
      "build_id": "ABC123"
    }
  },
  "deploy": {
    "result": "failure",
    "outputs": {}
  }
}

Exemplo de uso do contexto needs

This example workflow has three jobs: a build job that does a build, a deploy job that requires the build job, and a debug job that requires both the build and deploy jobs and runs only if there is a failure in the workflow. The deploy job also uses the needs context to access an output from the build job.

YAML
name: Build and deploy
on: push

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      build_id: ${{ steps.build_step.outputs.build_id }}
    steps:
      - uses: actions/checkout@v2
      - name: Build
        id: build_step
        run: |
          ./build
          echo "::set-output name=build_id::$BUILD_ID" 
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - run: ./deploy --build ${{ needs.build.outputs.build_id }}
  debug:
    needs: [build, deploy]
    runs-on: ubuntu-latest
    if: ${{ failure() }}
    steps:
      - uses: actions/checkout@v2
      - run: ./debug