Skip to main content
Publicamos actualizaciones para la documentación con frecuencia y es posible que aún se esté traduciendo esta página. Para obtener la información más reciente, consulta la documentación en inglés.
GitHub AE es una versión limitada en este momento.

Contextos

Puedes acceder a información de contexto en los flujos de trabajo y acciones.

Acerca de los contextos

Los contextos son una manera de acceder a información acerca de las ejecuciones de flujo de trabajo, variable, entornos del ejecutor, trabajos y pasos. Cada contexto es un objeto que contiene propiedades, que pueden ser cadenas u otros objetos.

Los contextos, objetos y propiedades variarán significativamente bajo las diferentes condiciones de ejecución de flujo de trabajo. Por ejemplo, el contexto matrix solo se rellena para los trabajos de una matriz.

Puedes acceder a los contextos utilizando la sintaxis de expresión. Para más información, vea "Expresiones".

${{ <context> }}

Advertencia: Cuando cree flujos de trabajo y acciones, siempre debe considerar si el código podría ejecutar entradas no confiables de atacantes potenciales. Se tratará a algunos contextos como una entrada no confiable, ya que un atacante podrían insertar su propio contenido malintencionado. Para más información, vea "Descripción del riesgo de las inyecciones de scripts".

Nombre del contextoTipoDescripción
githubobjectInformación sobre la ejecución del flujo de trabajo. Para más información, vea el contexto github.
envobjectContiene variables establecidas en un flujo de trabajo, trabajo o paso. Para más información, vea el contexto env.

Como parte de una expresión, puedes acceder a la información de contexto utilizando una de dos sintaxis.

  • Sintaxis de índice: github['sha']
  • Sintaxis de desreferenciación de propiedades: github.sha

Para usar la sintaxis de desreferencia de propiedades, el nombre de la propiedad debe comenzar con una letra o _ y solo puede incluir caracteres alfanuméricos, - o _.

Si intentas desreferenciar una propiedad inexistente, se evaluará como cadena vacía.

Determinar cuándo utilizar contextos

GitHub Actions incluye una colección de variables denominadas contextos y una colección de variables similar denominadas variables predeterminadas. Estas variables se pretenden utilizar en puntos diferentes del flujo de trabajo:

  • Variables de entorno predeterminadas: estas variables de entorno solo existen en el ejecutor que ejecuta el trabajo. Para obtener más información, consulte "Variables de entorno predeterminadas".
  • Contextos: puedes usar la mayoría de los contextos en cualquier punto del flujo de trabajo, incluido cuando las variables predeterminadas no estén disponibles. Por ejemplo, puede usar contextos con expresiones para realizar un procesamiento inicial antes de que el trabajo se enrute a un ejecutor para su ejecución; esto le permite utilizar un contexto con la palabra clave condicional if para determinar si se debería ejecutar un paso. Una vez que el trabajo esté en ejecución, también puede recuperar variables de contexto para el ejecutor que ejecuta el trabajo, como runner.os. Para más información sobre dónde puede usar varios contextos dentro de un flujo de trabajo, vea "Disponibilidad del contexto".

El siguiente ejemplo ilustra cómo estos tipos de variables diferentes pueden utilizarse juntas en un trabajo:

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"

En este ejemplo, la instrucción if comprueba el contexto github.ref para determinar el nombre de la rama actual; si el nombre es refs/heads/main, se ejecutan los pasos siguientes. GitHub Actions procesa la comprobación if y el trabajo solo se envía al ejecutor si el resultado es true. Una vez que el trabajo se envía al ejecutor, el paso se ejecuta y hace referencia a la variable $GITHUB_REF del ejecutor.

Disponibilidad de contexto

Hay diferentes contextos disponibles a lo largo de un ejecutor de flujo de trabajo. Por ejemplo, el contexto secrets solo se puede usar en determinados puntos de un trabajo.

Adicionalmente, algunas funcionalidades solo pueden utilizarse en algunos lugares. Por ejemplo, la función hashFiles no está disponible en todas partes.

La siguiente tabla indica si cada contexto y fución especial puede utilizarse dentro de un flujo de trabajo. A menos de que se liste a continuación, las funciones se pueden utilizar donde sea.

| Clave de flujo de trabajo | Context | Funciones especiales | | ---- | ------- | ----------------- | | concurrency | github, inputs | | | env | github, secrets, inputs | | | jobs.<job_id>.concurrency | github, needs, strategy, matrix, inputs | | | jobs.<job_id>.container | github, needs, strategy, matrix, env, secrets, inputs | | | jobs.<job_id>.container.credentials | github, needs, strategy, matrix, env, secrets, inputs | | | jobs.<job_id>.container.env.<env_id> | github, needs, strategy, matrix, job, runner, env, secrets, inputs | | | jobs.<job_id>.continue-on-error | github, needs, strategy, matrix, inputs | | | jobs.<job_id>.defaults.run | github, needs, strategy, matrix, env, inputs | | | jobs.<job_id>.env | github, needs, strategy, matrix, secrets, inputs | | | jobs.<job_id>.environment | github, needs, strategy, matrix, inputs | | | jobs.<job_id>.environment.url | github, needs, strategy, matrix, job, runner, env, steps, inputs | | | jobs.<job_id>.if | github, needs, inputs | always, cancelled, success, failure | | jobs.<job_id>.name | github, needs, strategy, matrix, inputs | | | jobs.<job_id>.outputs.<output_id> | github, needs, strategy, matrix, job, runner, env, secrets, steps, inputs | | | jobs.<job_id>.runs-on | github, needs, strategy, matrix, inputs | | | jobs.<job_id>.secrets.<secrets_id> | github, needs, secrets | | | jobs.<job_id>.services | github, needs, strategy, matrix, inputs | | | jobs.<job_id>.services.<service_id>.credentials | github, needs, strategy, matrix, env, secrets, inputs | | | jobs.<job_id>.services.<service_id>.env.<env_id> | github, needs, strategy, matrix, job, runner, env, secrets, inputs | | | 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 | | | jobs.<job_id>.timeout-minutes | github, needs, strategy, matrix, inputs | | | jobs.<job_id>.with.<with_id> | github, needs | | | on.workflow_call.inputs.<inputs_id>.default | github | | | on.workflow_call.outputs.<output_id>.value | github, jobs, inputs | |

Ejemplo: imprimir información de contexto a la bitácora

Puedes imprimir el contenido de los contextos a la bitácora para la depuración. La función toJSON es necesaria para imprimir objetos JSON en el registro.

Advertencia: Al usar todo el contexto de github, ten en cuenta que incluye información confidencial, como github.token. GitHub enmascara secretos cuando se imprimen en la consola, pero debes tener cuidado cuando exportes o imprimas el 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

El contexto github contiene información sobre la ejecución del flujo de trabajo y el evento que ha desencadenado la ejecución. También puede leer la mayoría de los datos del contexto github en variables de entorno. Para más información sobre las variables de entorno, vea "Uso de variables de entorno".

Advertencia: Al usar todo el contexto de github, ten en cuenta que incluye información confidencial, como github.token. GitHub enmascara secretos cuando se imprimen en la consola, pero debes tener cuidado cuando exportes o imprimas el contexto.

Advertencia: Cuando cree flujos de trabajo y acciones, siempre debe considerar si el código podría ejecutar entradas no confiables de atacantes potenciales. Se tratará a algunos contextos como una entrada no confiable, ya que un atacante podrían insertar su propio contenido malintencionado. Para más información, vea "Descripción del riesgo de las inyecciones de scripts".

Nombre de propiedadTipoDescripción
githubobjectEl contexto de nivel superior disponible durante cualquier trabajo o paso en un flujo de trabajo. Este objeto contiene todas las propiedades que se listan debajo.
github.actionstringNombre de la acción actualmente en ejecución de flujo, o bien el valor id de un paso. GitHub quita caracteres especiales y usa el nombre __run cuando el paso actual ejecuta un script sin id. Si utilizas la misma acción más de una vez en el mismo job, el nombre incluirá un sufijo con el número de secuencia con un guion bajo antes de este. Por ejemplo, el primer script que ejecute tendrá el nombre __run y el segundo el nombre __run_2. Del mismo modo, la segunda invocación de actions/checkout será actionscheckout2.
github.action_pathstringLa ruta donde se ubica una acción. Esta propiedad solo es compatible en las acciones compuestas. Puedes usar esta ruta de acceso para acceder a los archivos ubicados en el mismo repositorio que la acción, por ejemplo, cambiando los directorios a la ruta de acceso: cd ${{ github.action_path }} .
github.action_refstringEn el caso de un paso que ejecuta una acción, esta es la ref de la acción que se está ejecutando. Por ejemplo: v2.
github.action_repositorystringEn el caso de un paso que ejecuta una acción, este es el propietario y el nombre de repositorio de la acción. Por ejemplo: actions/checkout.
github.action_statusstringPara una acción compuesta, el resultado actual de la acción compuesta.
github.actorstringNombre del usuario que ha iniciado la ejecución del flujo de trabajo.

Contenido de ejemplo del contexto github

El siguiente contexto de ejemplo procede de una ejecución de flujo de trabajo desencadenada por el evento push. El objeto event de este ejemplo se ha truncado porque es idéntico al contenido de la carga del webhook push.

Nota: Este contexto es solo un ejemplo. El contenido de un contexto depende del flujo de trabajo que estés ejecutando. Los contextos, objetos y propiedades variarán significativamente bajo las diferentes condiciones de ejecución de flujo de trabajo.

{
  "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"
}

Ejemplo de uso del contexto github

En este flujo de trabajo de ejemplo se usa el contexto github.event_name para ejecutar un trabajo solo si el evento pull_request ha desencadenado la ejecución del flujo de trabajo.

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

El contexto env contiene las variables que se han establecido en un flujo de trabajo, trabajo o paso. Para más información sobre cómo establecer variables en el flujo de trabajo, consulta "Sintaxis de flujo de trabajo para GitHub Actions".

La sintaxis del contexto env permite usar el valor de una variable en el archivo de flujo de trabajo. Puede usar el contexto env en el valor de cualquier clave de un paso, excepto para las claves id y uses. Para más información sobre la sintaxis de pasos, vea "Sintaxis de flujo de trabajo para GitHub Actions".

Si quieres usar el valor de una variable dentro de un ejecutor, usa el método normal del sistema operativo del ejecutor para leer las variables de entorno.

Nombre de propiedadTipoDescripción
envobjectEste contexto cambia para cada paso de un trabajo. Puedes acceder a este contexto desde cualquier paso de un trabajo. Este objeto contiene las propiedades que se listan a continuación.
env.<env_name>stringEl valor de una variable de entorno específica.

Contenido de ejemplo del contexto env

El contenido del contexto env es una asignación de nombres de variable a sus valores. El contenido del contexto puede cambiar dependiendo de dónde se utiliza en la ejecución de flujo de trabajo.

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

Ejemplo de uso del contexto env

En este flujo de trabajo de ejemplo se muestra cómo se puede configurar el contexto env en los niveles de flujo de trabajo, trabajo y pasos, así como el uso del contexto en los pasos.

Cuando se define más de una variable de entorno con el mismo nombre, GitHub utiliza la más específica. Por ejemplo, una variable de entorno definida en un paso anulará aquellas variables de entorno de los trabajos y flujos de trabajo con el mismo nombre, mientras ejecuta el paso. Una variable de entorno definida para un trabajo anulará aquella de un flujo de trabajo si tienen el mismo nombre, mientras se ejecuta el trabajo.

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 job

El contexto job contiene información sobre el trabajo actual en ejecución.

Nombre de propiedadTipoDescripción
jobobjectEste contexto cambia para cada trabajo de una ejecución de flujo de trabajo. Puedes acceder a este contexto desde cualquier paso de un trabajo. Este objeto contiene todas las propiedades que se listan debajo.
job.containerobjectInformación sobre el contenedor del trabajo. Para más información sobre los contenedores, vea "Sintaxis de flujo de trabajo para GitHub Actions".
job.container.idstringLa ID del contenedor.
job.container.networkstringLa ID de la red del contenedor. El ejecutor crea la red usada por todos los contenedores en un trabajo.
job.servicesobjectLos contenedores de servicios creados para un trabajo. Para más información sobre los contenedores de servicio, vea "Sintaxis de flujo de trabajo para GitHub Actions".
job.services.<service_id>.idstringLa ID del contenedor de servicio.
job.services.<service_id>.networkstringLa ID de la red de contenedor de servicio. El ejecutor crea la red usada por todos los contenedores en un trabajo.
job.services.<service_id>.portsobjectLos puertos expuestos del contenedor del servicio.
job.statusstringEstado actual del trabajo. Los valores posibles son success, failure o cancelled.

Contenido de ejemplo del contexto job

En este contexto job de ejemplo se usa un contenedor de servicio de PostgreSQL con puertos asignados. Si en un trabajo no se usan contenedores ni contenedores de servicio, el contexto job solo contiene la propiedad status.

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

Ejemplo de uso del contexto job

Este flujo de trabajo de ejemplo configura un contenedor de servicio de PostgreSQL y, automáticamente, mapea el puerto 5432 en el contenedor de servicio a un puerto disponible elegido aleatoriamente en el host. El contexto job se usa para acceder al número del puerto que se ha asignado en el 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 jobs

El jobs contexto solo está disponible en flujos de trabajo reutilizables y solo se puede usar para establecer salidas para un flujo de trabajo reutilizable. Para más información, vea "Reutilización de flujos de trabajo".

Nombre de propiedadTipoDescripción
jobsobjectEsto solo está disponible en flujos de trabajo reutilizables y solo se puede usar para establecer salidas para un flujo de trabajo reutilizable. Este objeto contiene todas las propiedades que se listan debajo.
jobs.<job_id>.resultstringEl resultado de un trabajo en el flujo de trabajo reutilizable. Los valores posibles son success, failure, cancelled o skipped.
jobs.<job_id>.outputsobjectConjunto de salidas de un trabajo en un flujo de trabajo reutilizable.
jobs.<job_id>.outputs.<output_name>stringEl valor de una salida específica para un trabajo en un flujo de trabajo reutilizable.

Contenido de ejemplo del contexto jobs

Este contexto jobs de ejemplo contiene el resultado y las salidas de un trabajo a partir de una ejecución de flujo de trabajo reutilizable.

{
  "example_job": {
    "result": "success",
    "outputs": {
      "output1": "hello",
      "output2": "world"
    }
  }
}

Ejemplo de uso del contexto jobs

Este flujo de trabajo reutilizable de ejemplo usa el contexto jobs para establecer salidas para el flujo de trabajo reutilizable. Observa cómo las salidas fluyen desde los pasos hasta el trabajo y, a continuación, al desencadenador workflow_call. Para más información, vea "Reutilización de flujos de trabajo".

YAML
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

El contexto steps contiene información sobre los pasos del trabajo actual en los que se ha especificado id y ya se han ejecutado.

Nombre de propiedadTipoDescripción
stepsobjectEste contexto cambia para cada paso de un trabajo. Puedes acceder a este contexto desde cualquier paso de un trabajo. Este objeto contiene todas las propiedades que se listan debajo.
steps.<step_id>.outputsobjectEl conjunto de salidas definido para el paso. Para más información, vea "Sintaxis de metadatos para GitHub Actions".
steps.<step_id>.conclusionstringEl resultado de un paso completado después de aplicar continue-on-error. Los valores posibles son success, failure, cancelled o skipped. Cuando se produce un error en un paso continue-on-error, outcome es failure, pero el valor conclusion final es success.
steps.<step_id>.outcomestringEl resultado de un paso completado antes de aplicar continue-on-error. Los valores posibles son success, failure, cancelled o skipped. Cuando se produce un error en un paso continue-on-error, outcome es failure, pero el valor conclusion final es success.
steps.<step_id>.outputs.<output_name>stringEl valor de un resultado específico.

Contenido de ejemplo del contexto steps

En este contexto steps de ejemplo se muestran dos pasos anteriores en los que se ha especificado id. El primer paso tenía el id denominado checkout, el segundo generate_number. El paso generate_number tenía una salida denominada random_number.

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

Ejemplo de uso del contexto steps

En este flujo de trabajo de ejemplo se genera un número aleatorio como salida en un paso y, en un paso posterior se usa el contexto steps para leer el valor de esa salida.

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 runner

El contexto runner contiene información sobre el ejecutor que ejecuta el trabajo actual.

Nombre de propiedadTipoDescripción
runnerobjectEste contexto cambia para cada trabajo de una ejecución de flujo de trabajo. Este objeto contiene todas las propiedades que se listan debajo.
runner.namestringEl nombre del ejecutor que ejecuta el job.
runner.osstringEl sistema operativo del ejecutor que ejecuta el trabajo. Los valores posibles son Linux, Windows o macOS.
runner.archstringLa arquitectura del ejecutor que ejecuta el job. Los valores posibles son X86, X64, ARM o ARM64.
runner.tempstringLa ruta a un directorio temporal en el ejecutor. Este directorio se vacía al inicio y al final de cada job. Nota que los archivos no se eliminarán si la cuenta de usuario del ejecutor no tiene permisos para borrarlos.
runner.tool_cachestringDebes instalar el software requerido en tus ejecutores auto-hospedados. Para obtener más información sobre los ejecutores autohospedados, vea "Hospedaje de sus propios ejecutores".
runner.debugstringEsto solo se establece si el registro de depuración está habilitado y siempre tiene el valor de 1. Puede ser útil como indicador para habilitar la depuración adicional o el registro detallado en tus propios pasos de trabajo.

Contenido de ejemplo del contexto runner

El siguiente contexto de ejemplo es de un ejecutor Linux hospedado en GitHub.

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

Ejemplo de uso del contexto runner

En este flujo de trabajo de ejemplo se usa el contexto runner a fin de configurar la ruta al directorio temporal para escribir registros y, si se produce un error en el flujo de trabajo, los carga como artefacto.

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 secrets

El contexto secrets contiene los nombres y valores de los secretos disponibles para una ejecución de flujo de trabajo. El contexto secrets no está disponible para acciones compuestas debido a motivos de seguridad. Si deseas pasar un secreto a una acción compuesta, debes hacerlo explícitamente como entrada. Para más información sobre los secretos, vea "Secretos cifrados".

GITHUB_TOKEN es un secreto que se crea automáticamente para cada ejecución de flujo de trabajo y siempre se incluye en el contexto secrets. Para más información, vea "Autenticación de token automática".

Advertencia: GitHub censura automáticamente los secretos impresos en el registro, pero debe evitar imprimirlos en el registro de manera intencionada.

Nombre de propiedadTipoDescripción
secretsobjectEste contexto es el mismo para cada job en una ejecución de flujo de trabajo. Puedes acceder a este contexto desde cualquier paso de un trabajo. Este objeto contiene todas las propiedades que se listan debajo.
secrets.GITHUB_TOKENstringToken creado automáticamente para cada ejecución de flujo de trabajo. Para más información, vea "Autenticación de token automática".
secrets.<secret_name>stringEl valor de un secreto específico.

Contenido de ejemplo del contexto secrets

En el contenido de ejemplo siguiente del contexto secrets se muestra el valor GITHUB_TOKEN automático, así como otros dos secretos disponibles para la ejecución del flujo de trabajo.

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

Ejemplo de uso del contexto secrets

En este flujo de trabajo de ejemplo se usa la acción del etiquetador, que necesita GITHUB_TOKEN como valor para el parámetro de entrada repo-token:

YAML
name: Pull request labeler
on: [ pull_request_target ]

permissions:
  contents: read
  pull-requests: write

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

Contexto strategy

Para los flujos de trabajo con una matriz, el contexto strategy contiene información sobre la estrategia de ejecución de matrices para el trabajo actual.

Nombre de propiedadTipoDescripción
strategyobjectEste contexto cambia para cada trabajo de una ejecución de flujo de trabajo. Puedes acceder a este contexto desde cualquier job o paso en un flujo de trabajo. Este objeto contiene todas las propiedades que se listan debajo.
strategy.fail-fastbooleanCuando es true, todos los trabajos en curso se cancelan si se produce un error en algún trabajo de una matriz. Para más información, vea "Sintaxis de flujo de trabajo para GitHub Actions".
strategy.job-indexnumberEl índice del trabajo actual en la matriz. Nota: Este número es un número de base cero. El índice del primer trabajo en la matriz es 0.
strategy.job-totalnumberEl número total de trabajos en la matriz. Nota: Este número no es un número de base cero. Por ejemplo, para una matriz con cuatro trabajos, el valor de job-total es 4.
strategy.max-parallelnumberEl número máximo de trabajos que se pueden ejecutar simultáneamente al usar una estrategia de trabajo matrix. Para más información, vea "Sintaxis de flujo de trabajo para GitHub Actions".

Contenido de ejemplo del contexto strategy

El contenido de ejemplo siguiente del contexto strategy procede de una matriz con cuatro trabajos y se toma del trabajo final. Observe la diferencia entre el número job-index de base cero y job-total, que no es de base cero.

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

Ejemplo de uso del contexto strategy

En este flujo de trabajo de ejemplo se usa la propiedad strategy.job-index a fin de establecer un nombre único para un archivo de registro para cada trabajo de una matriz.

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 matrix

Para los flujos de trabajo con una matriz, el contexto matrix contiene las propiedades de matriz definidas en el archivo de flujo de trabajo que se aplican al trabajo actual. Por ejemplo, si configuras una matriz con las claves os y node, el objeto de contexto matrix incluye las propiedades os y node con los valores que se usan para el trabajo actual.

No hay propiedades estándar en el contexto matrix, solo las definidas en el archivo de flujo de trabajo.

Nombre de propiedadTipoDescripción
matrixobjectEste contexto solo está disponible para los trabajos de una matriz y cambia para cada trabajo en una ejecución de flujo de trabajo. Puedes acceder a este contexto desde cualquier job o paso en un flujo de trabajo. Este objeto contiene las propiedades que se listan a continuación.
matrix.<property_name>stringEl valor de una propiedad de matriz.

Contenido de ejemplo del contexto matrix

El contenido de ejemplo siguiente del contexto matrix procede de un trabajo de una matriz que tiene las propiedades de matriz os y node definidas en el flujo de trabajo. El trabajo ejecuta la combinación de matriz de un sistema operativo ubuntu-latest y la versión 16 de Node.js.

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

Ejemplo de uso del contexto matrix

Este flujo de trabajo de ejemplo crea una matriz con las claves os y node. Usa la propiedad matrix.os para establecer el tipo de ejecutor para cada trabajo y la propiedad matrix.node a fin de establecer la versión de Node.js para cada trabajo.

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

El contexto needs contiene salidas de todos los trabajos que se definen como una dependencia directa del trabajo actual. Ten en cuenta que esto no incluye trabajos dependientes implícitamente (por ejemplo, trabajos dependientes de un trabajo dependiente). Para más información sobre la definición de dependencias de trabajos, vea "Sintaxis de flujo de trabajo para GitHub Actions".

Nombre de propiedadTipoDescripción
needsobjectEste contexto solo se llena con ejecuciones de flujo de trabajo que tienen jobs dependientes y cambios para cada job en una ejecución de flujo de trabajo. Puedes acceder a este contexto desde cualquier job o paso en un flujo de trabajo. Este objeto contiene todas las propiedades que se listan debajo.
needs.<job_id>objectUn solo job del cual depende el job actual.
needs.<job_id>.outputsobjectEl conjunto de resultados de un job del cual depende el job actual.
needs.<job_id>.outputs.<output name>stringEl valor de un resultado específico para un job del cual depende el job actual.
needs.<job_id>.resultstringEl resultado de un job del cual depende el job actual. Los valores posibles son success, failure, cancelled o skipped.

Contenido de ejemplo del contexto needs

En el contenido de ejemplo siguiente del contexto needs se muestra información para dos trabajos de los que depende el trabajo actual.

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

Ejemplo de uso del contexto needs

Este flujo de trabajo de ejemplo tiene tres trabajos: un trabajo build que realiza una compilación, un trabajo deploy que necesita el trabajo build y un trabajo debug que necesita los trabajos build y deploy, y que solo se ejecuta si se produce un error en el flujo de trabajo. El trabajo deploy también usa el contexto needs para acceder a una salida del trabajo build.

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

Contexto inputs

El contexto inputs contiene propiedades de entrada pasadas a una acción o, a un flujo de trabajo reutilizable . Los tipos y nombres de entrada están definidos en la workflow_callconfiguración del evento de un flujo de trabajo reutilizable y los valores de entrada se pasan desde jobs.<job_id>.with en un flujo de trabajo externo que llama al flujo de trabajo reutilizable.

No hay propiedades estándar en el contexto inputs, solo las definidas en el archivo de flujo de trabajo.

Nombre de propiedadTipoDescripción
inputsobjectEste contexto solo está disponible en un flujo de trabajo reutilizable. Puedes acceder a este contexto desde cualquier job o paso en un flujo de trabajo. Este objeto contiene las propiedades que se listan a continuación.
inputs.<name>string, number o booleanCada valor de entrada que pasa desde un flujo de trabajo externo.

Contenido de ejemplo del contexto inputs

El contenido de ejemplo siguiente del contexto inputs proviene de un flujo de trabajo que tiene definidas las entradas build_id, deploy_target y perform_deploy.

{
  "build_id": 123456768,
  "deploy_target": "deployment_sys_1a",
  "perform_deploy": true
}

Ejemplo de uso del contexto inputs en un flujo de trabajo reutilizable

En este flujo de trabajo reutilizable de ejemplo, se usa el contexto inputs para obtener los valores de las entradas build_id, deploy_target y perform_deploy que se pasaron al flujo de trabajo reutilizable desde el flujo de trabajo del autor de la llamada.

YAML
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 }}