Skip to main content

Esta versión de GitHub Enterprise Server se discontinuará el 2024-03-07. No se realizarán lanzamientos de patch, ni siquiera para problemas de seguridad críticos. Para obtener rendimiento mejorado, seguridad mejorada y nuevas características, actualice a la versión más reciente de GitHub Enterprise Server. Para obtener ayuda con la actualización, póngase en contacto con el soporte técnico de GitHub Enterprise.

Contextos

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

Nota: Actualmente los ejecutores hospedados en GitHub no se admiten en GitHub Enterprise Server. Puede ver más información sobre la compatibilidad futura planeada en GitHub public roadmap.

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 obtener 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 obtener más información, vea «Fortalecimiento de seguridad para GitHub Actions».

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.
varsobjectContiene variables establecidas en los niveles de repositorio, organización o entorno. Para más información, vea el contexto vars.
jobobjectInformación sobre el trabajo actualmente en ejecución. Para más información, vea el contexto job.
jobsobjectSolo para flujos de trabajo reutilizables, contiene salidas de trabajos del flujo de trabajo reutilizable. Para más información, vea el contexto jobs.
stepsobjectInformación sobre los pasos que se han ejecutado en el job actual. Para más información, vea el contexto steps.
runnerobjectInformación sobre el ejecutor que está realizando el trabajo actual. Para más información, vea el contexto runner.
secretsobjectContiene los nombres y valores de los secretos que se encuentran disponibles para una ejecución de flujo de trabajo. Para más información, vea el contexto secrets.
strategyobjectInformación sobre la estrategia de ejecución de la matriz para el trabajo actual. Para más información, vea el contexto strategy.
matrixobjectContiene las propiedades de la matriz que se definen en el flujo de trabajo que aplica al trabajo actual. Para más información, vea el contexto matrix.
needsobjectContiene las salidas de todos los trabajos que se definen como una dependencia del trabajo actual. Para más información, vea el contexto needs.
inputsobjectContiene las entradas de un flujo de trabajo reutilizable o manualmente desencadenado . Para más información, vea el contexto inputs.

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, vea «variables».
  • 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 trabajoContextFunciones especiales
run-namegithub, inputs, varsNinguno
envgithub, secrets, inputs, varsNinguno
jobs.<job_id>.concurrencygithub, needs, strategy, matrix, inputs, varsNinguno
jobs.<job_id>.containergithub, needs, strategy, matrix, vars, inputsNinguno
jobs.<job_id>.container.credentialsgithub, needs, strategy, matrix, env, vars, secrets, inputsNinguno
jobs.<job_id>.container.env.<env_id>github, needs, strategy, matrix, job, runner, env, vars, secrets, inputsNinguno
jobs.<job_id>.container.imagegithub, needs, strategy, matrix, vars, inputsNinguno
jobs.<job_id>.continue-on-errorgithub, needs, strategy, vars, matrix, inputsNinguno
jobs.<job_id>.defaults.rungithub, needs, strategy, matrix, env, vars, inputsNinguno
jobs.<job_id>.envgithub, needs, strategy, matrix, vars, secrets, inputsNinguno
jobs.<job_id>.environmentgithub, needs, strategy, matrix, vars, inputsNinguno
jobs.<job_id>.environment.urlgithub, needs, strategy, matrix, job, runner, env, vars, steps, inputsNinguno
jobs.<job_id>.ifgithub, needs, vars, inputsalways, cancelled, success, failure
jobs.<job_id>.namegithub, needs, strategy, matrix, vars, inputsNinguno
jobs.<job_id>.outputs.<output_id>github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputsNinguno
jobs.<job_id>.runs-ongithub, needs, strategy, matrix, vars, inputsNinguno
jobs.<job_id>.secrets.<secrets_id>github, needs, strategy, matrix, secrets, inputs, varsNinguno
jobs.<job_id>.servicesgithub, needs, strategy, matrix, vars, inputsNinguno
jobs.<job_id>.services.<service_id>.credentialsgithub, needs, strategy, matrix, env, vars, secrets, inputsNinguno
jobs.<job_id>.services.<service_id>.env.<env_id>github, needs, strategy, matrix, job, runner, env, vars, secrets, inputsNinguno
jobs.<job_id>.steps.continue-on-errorgithub, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputshashFiles
jobs.<job_id>.steps.envgithub, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputshashFiles
jobs.<job_id>.steps.ifgithub, needs, strategy, matrix, job, runner, env, vars, steps, inputsalways, cancelled, success, failure, hashFiles
jobs.<job_id>.steps.namegithub, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputshashFiles
jobs.<job_id>.steps.rungithub, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputshashFiles
jobs.<job_id>.steps.timeout-minutesgithub, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputshashFiles
jobs.<job_id>.steps.withgithub, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputshashFiles
jobs.<job_id>.steps.working-directorygithub, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputshashFiles
jobs.<job_id>.strategygithub, needs, vars, inputsNinguno
jobs.<job_id>.timeout-minutesgithub, needs, strategy, matrix, vars, inputsNinguno
jobs.<job_id>.with.<with_id>github, needs, strategy, matrix, inputs, varsNinguno
on.workflow_call.inputs.<inputs_id>.defaultgithub, inputs, varsNinguno
on.workflow_call.outputs.<output_id>.valuegithub, jobs, vars, inputsNinguno

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

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 obtener más información sobre cómo usar variables de entorno, consulte "variables."

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 obtener más información, vea «Fortalecimiento de seguridad para GitHub Actions».

Nombre de propiedadTypeDescripció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.

No lo utilice en el contexto run. Para que este contexto funcione con acciones compuestas, haga referencia a él dentro del contexto env de la acción compuesta.
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.

No lo utilice en el contexto run. Para que este contexto funcione con acciones compuestas, haga referencia a él dentro del contexto env de la acción compuesta.
github.action_statusstringPara una acción compuesta, el resultado actual de la acción compuesta.
github.actorstringNombre del usuario que ha desencadenado la ejecución inicial del flujo de trabajo. Si la ejecución del flujo de trabajo es una repetición, este valor puede ser distinto de github.triggering_actor. Cualquier repetición de la ejecución de flujo de trabajo usará los privilegios de github.actor, incluso si el actor que inicia la repetición (github.triggering_actor) tiene otros privilegios.
github.api_urlstringURL de la API REST de GitHub.
github.base_refstringbase_ref o rama de destino de la solicitud de incorporación de cambios en una ejecución de flujo de trabajo. Esta propiedad solo está disponible cuando el evento que desencadena una ejecución de flujo de trabajo es pull_request o pull_request_target.
github.envstringRuta en el ejecutor del archivo que configura las variables de entorno desde los comandos del flujo de trabajo. Este archivo es único para el paso actual y es un archivo diferente para cada paso en un job. Para obtener más información, vea «Comandos de flujo de trabajo para Acciones de GitHub».
github.eventobjectCarga de webhook del evento completo. "Puedes acceder a propiedades individuales del evento que utiliza este contexto. El objeto es idéntico a la carga útil de webhook del evento que activó la ejecución de flujo de trabajo y es diferente para cada evento. Los webhooks de cada evento GitHub Actions están vinculados en "Eventos que desencadenan flujos de trabajo". Por ejemplo, para una ejecución de flujo de trabajo desencadenada por el evento push, este objeto contiene el contenido de la carga del webhook de inserción.
github.event_namestringNombre del evento que activó la ejecución del flujo de trabajo.
github.event_pathstringRuta al archivo en el ejecutor que contiene toda la carga útil del webhook del evento.
github.graphql_urlstringURL de la API de GraphQL de GitHub.
github.head_refstringhead_ref o rama de origen de la solicitud de incorporación de cambios en una ejecución de flujo de trabajo. Esta propiedad solo está disponible cuando el evento que desencadena una ejecución de flujo de trabajo es pull_request o pull_request_target.
github.jobstringValor job_id del trabajo actual.
Nota: El ejecutor de acciones establece esta propiedad del contexto, la que solo está disponible dentro de los steps de ejecución de un trabajo. De lo contrario, el valor de esta propiedad será null.
github.pathstringRuta de acceso en el ejecutor al archivo que establece las variables PATH del sistema desde los comandos del flujo de trabajo. Este archivo es único para el paso actual y es un archivo diferente para cada paso en un job. Para obtener más información, vea «Comandos de flujo de trabajo para Acciones de GitHub».
github.refstringReferencia de formato completo de la rama o etiqueta que desencadenó la ejecución del flujo de trabajo. En el caso de los flujos de trabajo desencadenados por push, se trata de la rama o la etiqueta ref que se insertó. En el caso de los flujos de trabajo desencadenados por pull_request, se trata de la rama de combinación de solicitudes de incorporación de cambios. En el caso de los flujos de trabajo desencadenados por release, se trata de la etiqueta de versión creada. Para otros desencadenadores, se trata de la rama o la etiqueta ref que desencadenó la ejecución del flujo de trabajo. Esto solo se configura si una rama o etiqueta se encuentra disponible para el tipo de evento. La etiqueta ref especificada tiene el formato completo, lo que significa que para las ramas el formato es refs/heads/<branch_name>, para las solicitudes de incorporación de cambios es refs/pull/<pr_number>/mergey para las etiquetas es refs/tags/<tag_name>. Por ejemplo, refs/heads/feature-branch-1.
github.ref_namestringNombre de referencia corto de la rama o etiqueta que desencadenó la ejecución del flujo de trabajo. Este valor coincide con el nombre de la rama o etiqueta que se muestra en GitHub. Por ejemplo, feature-branch-1.

En el caso de las solicitudes de incorporación de cambios, el formato es <pr_number>/merge.
github.ref_protectedbooleantrue si las protecciones de rama están configurados para la referencia que desencadenó la ejecución del flujo de trabajo.
github.ref_typestringEl tipo de ref que activó la ejecución de flujo de trabajo. Los valores válidos son branch y tag.
github.repositorystringNombre del propietario y del repositorio. Por ejemplo: octocat/Hello-World.
github.repository_ownerstringNombre de usuario del propietario del repositorio. Por ejemplo, octocat.
github.repositoryUrlstringURL de Git al repositorio. Por ejemplo: git://github.com/octocat/hello-world.git.
github.retention_daysstringNúmero de días que se conservan los registros y artefactos de ejecución del flujo de trabajo.
github.run_idstringUn número único para cada ejecución de flujo de trabajo dentro de un repositorio. Este número no cambia si vuelves a ejecutar el flujo de trabajo.
github.run_numberstringUn número único para cada ejecución de un flujo de trabajo particular en un repositorio. Este número comienza por 1 para la primera ejecución del flujo de trabajo y aumenta con cada nueva ejecución. Este número no cambia si vuelves a ejecutar el flujo de trabajo.
github.run_attemptstringNúmero único para cada intento de una ejecución de flujo de trabajo concreta en un repositorio. Este número comienza en 1 para el primer intento de ejecución del flujo de trabajo e incrementa con cada re-ejecución.
github.secret_sourcestringEl origen de un secreto utilizado en un flujo de trabajo. Los valores posibles son None, Actions, o Dependabot.
github.server_urlstringURL del servidor de GitHub. Por ejemplo: https://github.com.
github.shastringEl SHA de confirmación que activó el flujo de trabajo. El valor de este SHA de confirmación depende del evento que activó el flujo de trabajo. Para obtener más información, vea «Eventos que desencadenan flujos de trabajo». Por ejemplo, ffac537e6cbbf934b08745a378932722df287a53.
github.tokenstringUn token para autenticarse en nombre de la aplicación de GitHub instalada en el repositorio. Esto es funcionalmente equivalente al secreto GITHUB_TOKEN. Para obtener más información, vea «Autenticación automática de tokens».
Nota: El ejecutor de acciones establece esta propiedad del contexto, la que solo está disponible dentro de los steps de ejecución de un trabajo. De lo contrario, el valor de esta propiedad será null.
github.triggering_actorstringNombre de usuario del usuario que inició la ejecución del flujo de trabajo. Si la ejecución del flujo de trabajo es una repetición, este valor puede ser distinto de github.actor. Todas las repeticiones de ejecución de flujo de trabajo usarán los privilegios de github.actor, incluso si el actor que inicia la repetición de la ejecución (github.triggering_actor) tiene otros privilegios.
github.workflowstringNombre del flujo de trabajo. Si el archivo de flujo de trabajo no especifica name, el valor de esta propiedad es la ruta completa del archivo del flujo de trabajo en el repositorio.
github.workspacestringDirectorio de trabajo predeterminado en el ejecutor para los pasos y ubicación predeterminada del repositorio al usar la acción checkout.

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@v4
      - name: Run normal CI
        run: ./run-tests

  pull_request_ci:
    runs-on: ubuntu-latest
    if: ${{ github.event_name == 'pull_request' }}
    steps:
      - uses: actions/checkout@v4
      - 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. No contiene variables heredadas por el proceso del ejecutor. Para obtener más información sobre la configuración de variables en su flujo de trabajo, consulte "Sintaxis del flujo de trabajo para Acciones de GitHub".

Puedes recuperar los valores de las variables almacenadas en el contexto env y usar estos valores en el archivo de flujo de trabajo. Puedes usar el contexto env en cualquier clave de un paso de flujo de trabajo, excepto en el caso de las claves id y uses. Para obtener más información sobre la sintaxis del paso, consulte "Sintaxis del flujo de trabajo para Acciones de GitHub".

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 propiedadTypeDescripció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. En este ejemplo, el contexto env contiene dos variables.

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

Ejemplo de uso del contexto env

En este flujo de trabajo de ejemplo se muestran las variables que se establecen en el contexto env en los niveles de flujo de trabajo, trabajo y paso. A continuación, la sintaxis ${{ env.VARIABLE-NAME }} se usa para recuperar valores de variable dentro de los pasos individuales del flujo de trabajo.

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 vars

Nota: Las variables de configuración para GitHub Actions están en versión beta y están sujetas a cambios.

El contexto vars contiene variables de configuración personalizadas establecidas en los niveles de organización, repositorio y entorno. Para más información sobre cómo definir variables de configuración para su uso en varios flujos de trabajo, consulta "variables".

Contenido de ejemplo del contexto vars

El contenido del contexto vars es una asignación de nombres de variable de configuración a sus valores.

{
  "mascot": "Mona"
}

Ejemplo de uso del contexto vars

En este flujo de trabajo de ejemplo se muestra cómo las variables de configuración establecidas en los niveles de repositorio, entorno u organización están disponibles automáticamente mediante el contexto vars.

Si no se ha establecido una variable de configuración, el valor devuelto de un contexto que hace referencia a la variable será una cadena vacía.

En los ejemplos siguientes, se muestra el uso de variables de configuración con el contexto vars en un flujo de trabajo. Cada una de las siguientes variables de configuración se han definido en los niveles de repositorio, organización o entorno.

YAML
on:
  workflow_dispatch:
env:
  # Setting an environment variable with the value of a configuration variable
  env_var: ${{ vars.ENV_CONTEXT_VAR }}

jobs:
  display-variables:
    name: ${{ vars.JOB_NAME }}
    # You can use configuration variables with the `vars` context for dynamic jobs
    if: ${{ vars.USE_VARIABLES == 'true' }}
    runs-on: ${{ vars.RUNNER }}
    environment: ${{ vars.ENVIRONMENT_STAGE }}
    steps:
    - name: Use variables
      run: |
        echo "repository variable : $REPOSITORY_VAR"
        echo "organization variable : $ORGANIZATION_VAR"
        echo "overridden variable : $OVERRIDE_VAR"
        echo "variable from shell environment : $env_var"
      env:
        REPOSITORY_VAR: ${{ vars.REPOSITORY_VAR }}
        ORGANIZATION_VAR: ${{ vars.ORGANIZATION_VAR }}
        OVERRIDE_VAR: ${{ vars.OVERRIDE_VAR }}
        
    - name: ${{ vars.HELLO_WORLD_STEP }}
      if: ${{ vars.HELLO_WORLD_ENABLED == 'true' }}
      uses: actions/hello-world-javascript-action@main
      with:
        who-to-greet: ${{ vars.GREET_NAME }}

Contexto job

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

Nombre de propiedadTypeDescripció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 obtener más información sobre contenedores, consulte "Sintaxis del flujo de trabajo para Acciones de GitHub".
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 obtener más información sobre los contenedores de servicio, consulte "Sintaxis del flujo de trabajo para Acciones de GitHub".
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@v4
      - 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 obtener más información, vea «Reutilización de flujos de trabajo».

Nombre de propiedadTypeDescripció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 obtener 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 "firstword=hello" >> $GITHUB_OUTPUT
      - id: step2
        run: echo "secondword=world" >> $GITHUB_OUTPUT

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 propiedadTypeDescripció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 obtener más información, vea «Sintaxis de metadatos para Acciones de GitHub».
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@v4
      - name: Generate 0 or 1
        id: generate_number
        run:  echo "random_number=$(($RANDOM % 2))" >> $GITHUB_OUTPUT
      - 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 propiedadTypeDescripció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. Este nombre puede no ser único en una ejecución de flujo de trabajo como ejecutores en el repositorio y los niveles de organización podrían usar el mismo nombre.
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_cachestringLa ruta al directorio que contiene las herramientas preinstaladas para los ejecutores hospedados en GitHub. Para más información, consulta "Utilizar los ejecutores hospedados en GitHub".
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@v4
      - 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

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 obtener más información sobre secretos, consulte "Uso de secretos en Acciones de GitHub".

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 obtener más información, vea «Autenticación automática de tokens».

Advertencia: si se usó un secreto en el trabajo, GitHub redacta automáticamente los secretos impresos en el registro. Debe evitar imprimir secretos en el registro intencionadamente.

Nombre de propiedadTypeDescripció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 obtener más información, vea «Autenticación automática de tokens».
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 ]

jobs:
  triage:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/labeler@v4
        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 propiedadTypeDescripció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 esto calcula hasta true, todos los trabajos en curso se cancelan si se produce un error en algún trabajo de una matriz. Para obtener más información, vea «Sintaxis del flujo de trabajo para Acciones de GitHub».
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 obtener más información, vea «Sintaxis del flujo de trabajo para Acciones de GitHub».

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@v4
      - 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 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 propiedadTypeDescripció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@v4
      - uses: actions/setup-node@v3
        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 cómo definir dependencias de trabajo, consulte "Sintaxis del flujo de trabajo para Acciones de GitHub."

Nombre de propiedadTypeDescripció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@v4
      - name: Build
        id: build_step
        run: |
          ./build
          echo "build_id=$BUILD_ID" >> $GITHUB_OUTPUT
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: ./deploy --build ${{ needs.build.outputs.build_id }}
  debug:
    needs: [build, deploy]
    runs-on: ubuntu-latest
    if: ${{ failure() }}
    steps:
      - uses: actions/checkout@v4
      - run: ./debug

Contexto inputs

El contexto inputs contiene propiedades de entrada pasadas a una acción,, a un flujo de trabajo reutilizable o a un flujo de trabajo manualmente desencadenado. En el caso de los flujos de trabajo reutilizables, 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. En el caso de los flujos de trabajo manualmente desencadenados, las entradas se define en la workflow_dispatchconfiguración del evento de un flujo de trabajo.

Las propiedades en el contexto inputs están definidas en el archivo de flujo de trabajo. Solo están disponibles en un flujo de trabajo reutilizable o en un flujo de trabajo desencadenado por el evento workflow_dispatch

Nombre de propiedadTypeDescripción
inputsobjectEste contexto solo está disponible en un flujo de trabajo reutilizable o en un flujo de trabajo desencadenado por el workflow_dispatchevento . 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 o number o boolean o choiceCada 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 }}

Ejemplo del uso del contexto inputs en un flujo de trabajo manualmente desencadenado

En este flujo de trabajo de ejemplo desencadenado por un eventoworkflow_dispatch, 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.

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