Observação: no momento, não há suporte para os executores hospedados no GitHub no GitHub Enterprise Server. Você pode ver mais informações sobre o suporte futuro planejado no GitHub public roadmap.
Sobre os contextos
Os contextos são uma forma de acessar informações sobre execuções de fluxo de trabalho, variáveis, ambientes dos executores, trabalhos e etapas. Cada contexto é um objeto que contém propriedades, que podem ser cadeia de caracteres ou outros objetos.
Os contextos, objetos e propriedades variarão significativamente em diferentes condições de execução do fluxo de trabalho. Por exemplo, o contexto matrix
só é preenchido para trabalhos em uma matriz.
Você pode acessar contextos usando a sintaxe da expressão. Para obter mais informações, confira "Expressões".
${{ <context> }}
Aviso: ao criar fluxos de trabalho e ações, você sempre deve considerar se o 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, confira "Fortalecimento de segurança para o GitHub Actions".
Nome do contexto | Tipo | Descrição |
---|---|---|
github | object | Informações sobre a execução do fluxo de trabalho. Para obter mais informações, confira Contexto github . |
env | object | Contém variáveis definidas em um fluxo de trabalho, um trabalho ou uma etapa. Para obter mais informações, confira Contexto env . |
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 desreferência de propriedade:
github.sha
Para usar a sintaxe de desreferência de propriedade, o nome da propriedade deve começar com uma letra _
ou e conter apenas caracteres alfanuméricos, -
ou _
.
Se você tentar desreferenciar uma propriedade inexistente, ela será avaliada como uma cadeia de caracteres vazia.
Determinar quando usar contextos
O GitHub Actions inclui uma coleção de variáveis chamadas contextos e outra coleção semelhante de variáveis chamadas variáveis 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 de ambiente existem apenas no executor que está executando seu trabalho. Para obter mais informações, confira "Variáveis".
- Contextos: você pode usar a maioria dos contextos em qualquer ponto do fluxo de trabalho, inclusive quando as variáveis padrão não estão disponíveis. Por exemplo, você pode usar contextos com expressões para executar 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
if
condicional para determinar se uma etapa deve ser executada. Depois que o trabalho estiver em execução, você também poderá recuperar variáveis de contexto do executor que está executando o trabalho, comorunner.os
. Para obter detalhes sobre quando usar vários contextos em um fluxo de trabalho, confira "Contextos".
O seguinte exemplo demonstra como esses diferentes tipos de variáveis 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, a instrução if
verifica o contexto github.ref
para determinar o nome do branch atual. Se o nome for refs/heads/main
, as etapas seguintes serão executadas. A verificação if
é processada pelo GitHub Actions, e o trabalho só será enviado ao executor se o resultado for true
. Depois que o trabalho é enviado para o executor, a etapa é executada e refere-se à variável $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 secrets
só pode ser usado em alguns lugares 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 todos os lugares.
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.
| Chave de fluxo de trabalho | Contexto | Funções especiais |
| ---- | ------- | ----------------- | | concurrency
| github, inputs
| Nenhuma | | env
| github, secrets, inputs
| Nenhuma | | jobs.<job_id>.concurrency
| github, needs, strategy, matrix, inputs
| Nenhuma | | jobs.<job_id>.container
| github, needs, strategy, matrix, env, secrets, inputs
| Nenhuma | | jobs.<job_id>.container.credentials
| github, needs, strategy, matrix, env, secrets, inputs
| Nenhuma | | jobs.<job_id>.container.env.<env_id>
| github, needs, strategy, matrix, job, runner, env, secrets, inputs
| Nenhuma | | jobs.<job_id>.continue-on-error
| github, needs, strategy, matrix, inputs
| Nenhuma | | jobs.<job_id>.defaults.run
| github, needs, strategy, matrix, env, inputs
| Nenhuma | | jobs.<job_id>.env
| github, needs, strategy, matrix, secrets, inputs
| Nenhuma | | jobs.<job_id>.environment
| github, needs, strategy, matrix, inputs
| Nenhuma | | jobs.<job_id>.environment.url
| github, needs, strategy, matrix, job, runner, env, steps, inputs
| Nenhuma | | jobs.<job_id>.if
| github, needs, inputs
| always, cancelled, success, failure
| | jobs.<job_id>.name
| github, needs, strategy, matrix, inputs
| Nenhuma | | jobs.<job_id>.outputs.<output_id>
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| Nenhuma | | jobs.<job_id>.runs-on
| github, needs, strategy, matrix, inputs
| Nenhuma | | jobs.<job_id>.secrets.<secrets_id>
| github, needs, strategy, matrix, secrets, inputs
| Nenhuma | | jobs.<job_id>.services
| github, needs, strategy, matrix, inputs
| Nenhuma | | jobs.<job_id>.services.<service_id>.credentials
| github, needs, strategy, matrix, env, secrets, inputs
| Nenhuma | | jobs.<job_id>.services.<service_id>.env.<env_id>
| github, needs, strategy, matrix, job, runner, env, secrets, inputs
| Nenhuma | | jobs.<job_id>.steps.continue-on-error
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| hashFiles
| | jobs.<job_id>.steps.env
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| hashFiles
| | jobs.<job_id>.steps.if
| github, needs, strategy, matrix, job, runner, env, steps, inputs
| always, cancelled, success, failure, hashFiles
| | jobs.<job_id>.steps.name
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| hashFiles
| | jobs.<job_id>.steps.run
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| hashFiles
| | jobs.<job_id>.steps.timeout-minutes
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| hashFiles
| | jobs.<job_id>.steps.with
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| hashFiles
| | jobs.<job_id>.steps.working-directory
| github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs
| hashFiles
| | jobs.<job_id>.strategy
| github, needs, inputs
| Nenhuma | | jobs.<job_id>.timeout-minutes
| github, needs, strategy, matrix, inputs
| Nenhuma | | jobs.<job_id>.with.<with_id>
| github, needs, strategy, matrix, inputs
| Nenhuma | | on.workflow_call.inputs.<inputs_id>.default
| github, inputs
| Nenhuma | | on.workflow_call.outputs.<output_id>.value
| github, jobs, inputs
| Nenhuma |
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 JSON no log.
Aviso: ao usar todo o contexto github
, lembre-se de 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.
name: Context testing
on: push
jobs:
dump_contexts_to_log:
runs-on: ubuntu-latest
steps:
- name: Dump GitHub context
env:
GITHUB_CONTEXT: ${{ toJson(github) }}
run: echo '$GITHUB_CONTEXT'
- name: Dump job context
env:
JOB_CONTEXT: ${{ toJson(job) }}
run: echo '$JOB_CONTEXT'
- name: Dump steps context
env:
STEPS_CONTEXT: ${{ toJson(steps) }}
run: echo '$STEPS_CONTEXT'
- name: Dump runner context
env:
RUNNER_CONTEXT: ${{ toJson(runner) }}
run: echo '$RUNNER_CONTEXT'
- name: Dump strategy context
env:
STRATEGY_CONTEXT: ${{ toJson(strategy) }}
run: echo '$STRATEGY_CONTEXT'
- name: Dump matrix context
env:
MATRIX_CONTEXT: ${{ toJson(matrix) }}
run: echo '$MATRIX_CONTEXT'
Contexto github
O contexto github
contém informações sobre a execução de fluxo de trabalho e sobre o evento que a disparou. Leia também a maioria dos dados de contexto github
em variáveis de ambiente. Para obter mais informações sobre variáveis de ambiente, confira "Variáveis".
Aviso: ao usar todo o contexto github
, lembre-se de 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 o 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, confira "Fortalecimento de segurança para o GitHub Actions".
Nome da propriedade | Type | Descrição |
---|---|---|
github | object | Contexto 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.action | string | O nome da ação atualmente em execução ou a id de uma etapa. O GitHub remove caracteres especiais ou usa o nome __run quando a etapa atual executa um script sem uma 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á chamado __run_2 . Da mesma forma, a segunda invocação de actions/checkout será actionscheckout2 . |
github.action_path | string | O caminho onde uma ação está localizada. Esta propriedade só é compatível com ações compostas. Você pode usar esse caminho para acessar arquivos localizados no mesmo repositório que a ação, por exemplo, alterando diretórios para o caminho: cd ${{ github.action_path }} . |
github.action_ref | string | Para uma etapa executando uma ação, este é o ref da ação que está sendo executada. Por exemplo, v2 . |
github.action_repository | string | Para 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.action_status | string | Para uma ação composta, o resultado atual da ação composta. |
github.actor | string | O nome do usuário que disparou a execução inicial do fluxo de trabalho. Se a execução do fluxo de trabalho for executada novamente, esse valor poderá ser diferente de github.triggering_actor . Qualquer nova execução de fluxo de trabalho usará os privilégios de github.actor , mesmo que o ator que inicie a nova execução (github.triggering_actor ) tenha privilégios diferentes. |
Exemplo de conteúdo do contexto github
O contexto a seguir foi obtido de uma execução de fluxo de trabalho disparada pelo evento push
. O objeto event
deste exemplo foi truncado porque é idêntico ao conteúdo da carga do webhook push
.
Observação: esse contexto é apenas um exemplo. O conteúdo de um contexto depende do fluxo de trabalho que você está executando. Os contextos, objetos e propriedades variarão significativamente em diferentes condições de execução do fluxo de trabalho.
{
"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 exemplo de fluxo de trabalho usa o contexto github.event_name
para executar um trabalho somente se a execução de fluxo de trabalho foi disparada pelo evento pull_request
.
name: Run CI
on: [push, pull_request]
jobs:
normal_ci:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Run normal CI
run: ./run-tests
pull_request_ci:
runs-on: ubuntu-latest
if: ${{ github.event_name == 'pull_request' }}
steps:
- uses: actions/checkout@v3
- name: Run PR CI
run: ./run-additional-pr-ci
Contexto env
O contexto env
contém variáveis que foram definidas em um fluxo de trabalho, um trabalho ou uma etapa. Para obter mais informações sobre como definir variáveis em seu fluxo de trabalho, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".
A sintaxe do contexto env
permite que você use o valor de uma variável no arquivo de fluxo de trabalho. Use o contexto env
no valor de qualquer chave em uma etapa, exceto nas chaves id
e uses
. Para obter mais informações sobre a sintaxe da etapa, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".
Se você deseja utilizar o valor de uma variável dentro de um executor, use o método normal do sistema operacional do executor para ler as variáveis de ambiente.
Nome da propriedade | Type | Descrição |
---|---|---|
env | object | Esse 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> | string | O valor de uma variável de ambiente específica. |
Exemplo de conteúdo do contexto env
O conteúdo do contexto env
é um mapeamento de nomes de variáveis para os respectivos 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, no trabalho e nos níveis de etapas, além de mostrar como usar o contexto em etapas.
Quando mais de uma variável de ambiente é definida com o mesmo nome, GitHub usa a variável mais específica. Por exemplo, uma variável de ambiente definida em uma etapa substituirá as variáveis de ambiente do trabalho e do fluxo de trabalho que tenham o mesmo nome enquanto a etapa é executada. Uma variável de ambiente definida para um trabalho substituirá uma variável de fluxo de trabalho com o mesmo nome enquanto o trabalho é executado.
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 job
O contexto job
contém informações sobre o trabalho atualmente em execução.
Nome da propriedade | Type | Descrição |
---|---|---|
job | object | Esse 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.container | object | Informações sobre o contêiner do trabalho. Para obter mais informações sobre contêineres, confira "Sintaxe de fluxo de trabalho para o GitHub Actions". |
job.container.id | string | O ID do contêiner. |
job.container.network | string | O ID da rede do contêiner. O executor cria a rede usada por todos os contêineres em um trabalho. |
job.services | object | Contêineres de serviços criados para um trabalho. Para obter mais informações sobre contêineres de serviço, confira "Sintaxe de fluxo de trabalho para o GitHub Actions". |
job.services.<service_id>.id | string | O ID do contêiner de serviço. |
job.services.<service_id>.network | string | O 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>.ports | object | As portas expostas do contêiner de serviço. |
job.status | string | O estado atual do trabalho. Os valores possíveis são success , failure , ou cancelled . |
Exemplo de conteúdo do contexto job
Este exemplo de contexto job
usa um contêiner de serviço do PostgreSQL com as portas mapeadas. Se nenhum contêiner ou contêiner de serviço for usado em um trabalho, o contexto job
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 job
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.
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@v3
- run: pg_isready -h localhost -p ${{ job.services.postgres.ports[5432] }}
- run: ./run-tests
Contexto jobs
O contexto jobs
só está disponível em fluxos de trabalho reutilizáveis e só pode ser usado para definir as saídas de um fluxo de trabalho reutilizável. Para obter mais informações, confira "Reutilizar fluxos de trabalho".
Nome da propriedade | Type | Descrição |
---|---|---|
jobs | object | Isso só está disponível em fluxos de trabalho reutilizáveis e só pode ser usado para definir as saídas de um fluxo de trabalho reutilizável. Este objeto contém todas as propriedades listadas abaixo. |
jobs.<job_id>.result | string | O resultado de um trabalho no fluxo de trabalho reutilizável. Os valores possíveis são success , failure , cancelled ou skipped . |
jobs.<job_id>.outputs | object | O conjunto de saídas de um trabalho em um fluxo de trabalho reutilizável. |
jobs.<job_id>.outputs.<output_name> | string | O valor de uma saída específica para um trabalho em um fluxo de trabalho reutilizável. |
Exemplo de conteúdo do contexto jobs
O contexto jobs
deste exemplo contém o resultado e as saídas de um trabalho de uma execução de fluxo de trabalho reutilizável.
{
"example_job": {
"result": "success",
"outputs": {
"output1": "hello",
"output2": "world"
}
}
}
Exemplo de uso do contexto jobs
Este exemplo de fluxo de trabalho reutilizável usa o contexto jobs
para definir saídas para o fluxo de trabalho reutilizável. Observe como as saídas fluem das etapas para o trabalho e, em seguida, para o gatilho workflow_call
. Para obter mais informações, confira "Reutilizar fluxos de trabalho".
name: Reusable workflow
on:
workflow_call:
# Map the workflow outputs to job outputs
outputs:
firstword:
description: "The first output string"
value: ${{ jobs.example_job.outputs.output1 }}
secondword:
description: "The second output string"
value: ${{ jobs.example_job.outputs.output2 }}
jobs:
example_job:
name: Generate output
runs-on: ubuntu-latest
# Map the job outputs to step outputs
outputs:
output1: ${{ steps.step1.outputs.firstword }}
output2: ${{ steps.step2.outputs.secondword }}
steps:
- id: step1
run: echo "::set-output name=firstword::hello"
- id: step2
run: echo "::set-output name=secondword::world"
Contexto steps
O contexto steps
contém informações sobre as etapas do trabalho atual que têm uma id
especificada e que já foram executadas.
Nome da propriedade | Type | Descrição |
---|---|---|
steps | object | Esse 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>.outputs | object | Conjunto de saídas definidas para a etapa. Para obter mais informações, confira "Sintaxe de metadados para o GitHub Actions". |
steps.<step_id>.conclusion | string | O resultado de uma etapa concluída após a aplicação de continue-on-error . Os valores possíveis são success , failure , cancelled ou skipped . Quando uma etapa continue-on-error falha, o outcome é failure , mas a conclusion final é success . |
steps.<step_id>.outcome | string | O resultado de uma etapa concluída antes da aplicação de continue-on-error . Os valores possíveis são success , failure , cancelled ou skipped . Quando uma etapa continue-on-error falha, o outcome é failure , mas a conclusion final é success . |
steps.<step_id>.outputs.<output_name> | string | Valor de uma saída específica. |
Exemplo de conteúdo do contexto steps
Este exemplo de contexto steps
mostra duas etapas anteriores que tinham uma id
especificada. A primeira etapa tinha a id
chamada checkout
, e a segunda, generate_number
. A etapa generate_number
tinha uma saída chamada random_number
.
{
"checkout": {
"outputs": {},
"outcome": "success",
"conclusion": "success"
},
"generate_number": {
"outputs": {
"random_number": "1"
},
"outcome": "success",
"conclusion": "success"
}
}
Exemplo de uso do contexto steps
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 steps
para ler o valor dessa saída.
name: Generate random failure
on: push
jobs:
randomly-failing-job:
runs-on: ubuntu-latest
steps:
- id: checkout
uses: actions/checkout@v3
- 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 runner
O contexto runner
contém informações sobre o executor que está executando o trabalho atual.
Nome da propriedade | Type | Descrição |
---|---|---|
runner | object | Esse contexto altera cada trabalho em uma execução de fluxo de trabalho. Este objeto contém todas as propriedades listadas abaixo. |
runner.name | string | O nome do executor que executa a tarefa. |
runner.os | string | O sistema operacional do executor que está executando o trabalho. Os valores possíveis são Linux , Windows , ou macOS . |
runner.arch | string | A arquitetura do executor que está executando o trabalho. Os valores possíveis são X86 , X64 , ARM ou ARM64 . |
runner.temp | string | O 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_cache | string | O caminho para o diretório que contém ferramentas pré-instaladas para executores hospedados em GitHub. Para obter mais informações, confira "Sobre executores hospedados no GitHub". |
runner.debug | string | Isso será definido somente se o log de depuração estiver habilitado e sempre tiver o valor de 1 . Pode ser útil como um indicador para habilitar a depuração adicional ou o log detalhado em suas etapas de trabalho. |
Exemplo de conteúdo do contexto runner
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 runner
Este exemplo de fluxo de trabalho usa o contexto runner
para definir o caminho para o diretório temporário e gravar registros e se, o fluxo de trabalho falhar, ele carregará os logs como artefatos.
name: Build
on: push
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- 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@v3
with:
name: Build failure logs
path: ${{ runner.temp }}/build_logs
Contexto secrets
O contexto secrets
contém nomes e os valores de segredos que estão disponíveis para a execução de um fluxo de trabalho. O contexto secrets
não está disponível para ações compostas por motivos de segurança. Para aprovar um segredo para uma ação composta, é necessário fazê-lo explicitamente como uma entrada. Para obter mais informações sobre segredos, confira "Segredos criptografados".
GITHUB_TOKEN
é um segredo que é criado automaticamente para cada execução de fluxo de trabalho e é sempre incluído no contexto secrets
. Para obter mais informações, confira "Autenticação automática de token".
Aviso: o GitHub elimina de modo automático os segredos impressos no log, mas você deve evitar imprimir segredos no log intencionalmente.
Nome da propriedade | Type | Descrição |
---|---|---|
secrets | object | Esse 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_TOKEN | string | Token criado automaticamente para cada execução do fluxo de trabalho. Para obter mais informações, confira "Autenticação automática de token". |
secrets.<secret_name> | string | O valor de um segredo específico. |
Exemplo de conteúdo do contexto secrets
O exemplo de conteúdo do contexto secrets
mostra o GITHUB_TOKEN
automático, assim como outros dois segredos disponíveis para a execução de fluxo de trabalho.
{
"github_token": "***",
"NPM_TOKEN": "***",
"SUPERSECRET": "***"
}
Exemplo de uso do contexto secrets
Este exemplo de fluxo de trabalho usa a ação do rotulador, que requer o GITHUB_TOKEN
como o valor para o parâmetro de entrada repo-token
:
name: Pull request labeler
on: [ pull_request_target ]
permissions:
contents: read
pull-requests: write
jobs:
triage:
runs-on: ubuntu-latest
steps:
- uses: actions/labeler@v4
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
Contexto strategy
Para fluxos de trabalho com uma matriz, o contexto strategy
contém informações sobre a estratégia de execução da matriz para o trabalho atual.
Nome da propriedade | Type | Descrição |
---|---|---|
strategy | object | Esse 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-fast | boolean | Quando true , todos os trabalhos em andamento são cancelados em caso de falha em qualquer trabalho em uma matriz. Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions". |
strategy.job-index | number | O índice do trabalho atual na matriz. Observação: esse número é um número baseado em zero. O primeiro índice do trabalho na matriz é 0 . |
strategy.job-total | number | O número total de trabalhos na matriz. Observação: esse número não é um número baseado em zero. Por exemplo, para uma matriz com quatro trabalhos, o valor de job-total é 4 . |
strategy.max-parallel | number | O número máximo de trabalhos que podem ser executados simultaneamente quando uma estratégia de trabalho matrix é usada. Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions". |
Exemplo de conteúdo do contexto strategy
O exemplo de conteúdo a seguir do contexto strategy
é de uma matriz com quatro trabalhos e foi obtida do trabalho final. Observe a diferença entre o número job-index
baseado em zero e job-total
, que não é baseado em zero.
{
"fail-fast": true,
"job-index": 3,
"job-total": 4,
"max-parallel": 4
}
Exemplo de uso do contexto strategy
Este exemplo de fluxo de trabalho usa a propriedade strategy.job-index
para definir um nome exclusivo para um arquivo de log para cada trabalho em uma matriz.
name: Test matrix
on: push
jobs:
test:
runs-on: ubuntu-latest
strategy:
matrix:
test-group: [1, 2]
node: [14, 16]
steps:
- uses: actions/checkout@v3
- run: npm test > test-job-${{ strategy.job-index }}.txt
- name: Upload logs
uses: actions/upload-artifact@v3
with:
name: Build log for job ${{ strategy.job-index }}
path: test-job-${{ strategy.job-index }}.txt
Contexto matrix
Para fluxos de trabalho com uma matriz, o contexto matrix
contém as propriedades definidas no arquivo de fluxo de trabalho que se aplicam ao trabalho atual. Por exemplo, se você configurar uma matriz com as chaves os
e node
, o objeto de contexto matrix
incluirá as propriedades os
e node
com os valores que estão sendo usados para o trabalho atual.
Não há propriedades padrão no contexto matrix
, apenas aquelas que são definidas no arquivo de fluxo de trabalho.
Nome da propriedade | Type | Descrição |
---|---|---|
matrix | object | Esse contexto só está disponível para trabalhos em uma matriz e em 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> | string | O valor da propriedade de uma matriz. |
Exemplo de conteúdo do contexto matrix
O exemplo a seguir do contexto matrix
é de um trabalho em uma matriz que tem as propriedades de matriz os
e node
definidas no fluxo de trabalho. O trabalho executa a combinação de matriz de um sistema operacional ubuntu-latest
e o Node.js versão 16
.
{
"os": "ubuntu-latest",
"node": 16
}
Exemplo de uso do contexto matrix
Este exemplo de fluxo de trabalho cria uma matriz com as chaves os
e node
. Ele usa a propriedade matrix.os
para definir o tipo de executor de cada trabalho e a propriedade matrix.node
para definir a versão do Node.js de cada trabalho.
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@v3
- uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node }}
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm test
Contexto needs
O contexto needs
contém as saídas de todos os trabalhos definidos como uma dependência direta do trabalho atual. Observe que isso não inclui trabalhos implicitamente dependentes (por exemplo, trabalhos dependentes de outro dependente). Para obter mais informações sobre como definir as dependências do trabalho, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".
Nome da propriedade | Type | Descrição |
---|---|---|
needs | object | Esse 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> | object | Um único trabalho do qual o trabalho atual depende. |
needs.<job_id>.outputs | object | O conjunto de saídas de um trabalho do qual o trabalho atual depende. |
needs.<job_id>.outputs.<output name> | string | O valor de uma saída específica para um trabalho do qual o trabalho atual depende. |
needs.<job_id>.result | string | O resultado de um trabalho do qual depende o trabalho atual. Os valores possíveis são success , failure , cancelled ou skipped . |
Exemplo de conteúdo do contexto needs
O exemplo de conteúdo a seguir do contexto needs
mostra informações de 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
Este exemplo de fluxo de trabalho tem três trabalhos: um trabalho build
que faz um build, um trabalho deploy
que exige o trabalho build
e um trabalho debug
que exige os trabalhos build
e deploy
e que será executado somente se houver uma falha no fluxo de trabalho. O trabalho deploy
também usa o contexto needs
para acessar uma saída do trabalho build
.
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@v3
- 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@v3
- run: ./deploy --build ${{ needs.build.outputs.build_id }}
debug:
needs: [build, deploy]
runs-on: ubuntu-latest
if: ${{ failure() }}
steps:
- uses: actions/checkout@v3
- run: ./debug
Contexto inputs
O contexto inputs
contém propriedades de entrada aprovadas para uma ação, para um fluxo de trabalho reutilizável ou para um fluxo de trabalho disparado manualmente. Para fluxos de trabalho reutilizáveis, os nomes e tipos de entrada são definidos na configuração de evento de workflow_call
de um fluxo de trabalho reutilizável e os valores de entrada são passados via jobs.<job_id>.with
em um fluxo de trabalho externo que chama o fluxo de trabalho reutilizável. Para fluxos de trabalho disparados manualmente, as entradas são definidas na configuração de evento de workflow_dispatch
de um fluxo de trabalho.
As propriedades no contexto inputs
são definidas no arquivo de fluxo de trabalho. Eles estão disponíveis apenas em um fluxo de trabalho reutilizável ou em um fluxo de trabalho acionado pelo workflow_dispatch
evento
Nome da propriedade | Type | Descrição |
---|---|---|
inputs | object | Esse contexto só está disponível em um fluxo de trabalho reutilizável ou em um fluxo de trabalho disparado pelo evento de workflow_dispatch . 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. |
inputs.<name> | string ou number ou boolean ou choice | Cada valor de entrada é passado de um fluxo de trabalho externo. |
Exemplo de conteúdo do contexto inputs
O conteúdo de exemplo a seguir do contexto inputs
é de um fluxo de trabalho que definiu as entradas build_id
, deploy_target
e perform_deploy
.
{
"build_id": 123456768,
"deploy_target": "deployment_sys_1a",
"perform_deploy": true
}
Exemplo de uso do contexto inputs
em um fluxo de trabalho reutilizável
Este exemplo de fluxo de trabalho reutilizável usa o contexto inputs
para obter os valores e as entradas build_id
, deploy_target
e perform_deploy
que foram transmitidas para o fluxo de trabalho reutilizável do fluxo de trabalho chamador.
name: Reusable deploy workflow
on:
workflow_call:
inputs:
build_id:
required: true
type: number
deploy_target:
required: true
type: string
perform_deploy:
required: true
type: boolean
jobs:
deploy:
runs-on: ubuntu-latest
if: ${{ inputs.perform_deploy }}
steps:
- name: Deploy build to target
run: deploy --build ${{ inputs.build_id }} --target ${{ inputs.deploy_target }}
Exemplo de uso do contexto inputs
em um fluxo de trabalho acionado manualmente
Este exemplo de fluxo de trabalho disparado por um evento de workflow_dispatch
usa o contexto inputs
para obter os valores de entrada de build_id
, deploy_target
e perform_deploy
que foram passadas para o fluxo de trabalho.
on:
workflow_dispatch:
inputs:
build_id:
required: true
type: string
deploy_target:
required: true
type: string
perform_deploy:
required: true
type: boolean
jobs:
deploy:
runs-on: ubuntu-latest
if: ${{ inputs.perform_deploy }}
steps:
- name: Deploy build to target
run: deploy --build ${{ inputs.build_id }} --target ${{ inputs.deploy_target }}