# Contextos de referencia Busque información sobre los contextos disponibles en GitHub Actions los flujos de trabajo, incluidas las propiedades disponibles, los métodos de acceso y los ejemplos de uso. ## Contextos disponibles | Nombre de contexto | Tipo | Descripción | | ------------------ | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `github` | `object` | Información sobre la ejecución del flujo de trabajo. Para más información, vea [el contexto `github`](#github-context). | | `env` | `object` | Contiene variables establecidas en un flujo de trabajo, trabajo o paso. Para más información, vea [el contexto `env`](#env-context). | | `vars` | `object` | Contiene variables establecidas a nivel de repositorio, organización o entorno. Para más información, vea [el contexto `vars`](#vars-context). | | `job` | `object` | Información sobre el trabajo que se está ejecutando actualmente. Para más información, vea [el contexto `job`](#job-context). | | `jobs` | `object` | Solo para flujos de trabajo reutilizables, contiene salidas de trabajos del flujo de trabajo reutilizable. Para más información, vea [el contexto `jobs`](#jobs-context). | | `steps` | `object` | Información sobre los pasos que se han ejecutado en la tarea actual. Para más información, vea [el contexto `steps`](#steps-context). | | `runner` | `object` | Información sobre el ejecutor que está realizando el trabajo actual. Para más información, vea [el contexto `runner`](#runner-context). | | `secrets` | `object` | Contiene 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`](#secrets-context). | | `strategy` | `object` | Información sobre la estrategia para la ejecución matricial del trabajo actual. Para más información, vea [el contexto `strategy`](#strategy-context). | | `matrix` | `object` | Contiene las propiedades de matriz definidas en el flujo de trabajo que se aplican al trabajo actual. Para más información, vea [el contexto `matrix`](#matrix-context). | | `needs` | `object` | Contiene los resultados de todos los trabajos que se definen como dependencias del trabajo actual. Para más información, vea [el contexto `needs`](#needs-context). | | `inputs` | `object` | Contiene las entradas de un flujo de trabajo reutilizable o desencadenado manualmente. Para más información, vea [el contexto `inputs`](#inputs-context). | 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 similar de variables *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 más información, consulta [Referencia de variables](/es/actions/reference/variables-reference#default-environment-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 desde el ejecutor que está ejecutando el trabajo, como `runner.os`. Para más información sobre dónde puedes usar varios contextos dentro de un flujo de trabajo, consulta [Disponibilidad del contexto](#context-availability). El siguiente ejemplo ilustra cómo estos tipos de variables diferentes pueden utilizarse juntas en un trabajo: ```yaml copy 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`](/es/actions/learn-github-actions/contexts#github-context) para determinar el nombre de la rama actual; si el nombre es `refs/heads/main`, se ejecutan los pasos siguientes. La `if` comprobación se procesa mediante GitHub Actionsy 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`](/es/actions/reference/variables-reference#default-environment-variables) del ejecutor. ### Disponibilidad de contexto Hay diferentes contextos disponibles a lo largo de una ejecución 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 las restricciones en las que puede utilizarse cada contexto y función especial dentro de un flujo de trabajo. Los contextos enumerados solo están disponibles para la clave de flujo de trabajo indicada y es posible que no se usen en ningún otro lugar. A menos de que se liste a continuación, las funciones se pueden utilizar donde sea. | Clave de flujo de trabajo | Context | Funciones especiales | | -------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------ | | `run-name` | `github, inputs, vars` | Ninguno | | `concurrency` | `github, inputs, vars` | Ninguno | | `env` | `github, secrets, inputs, vars` | Ninguno | | `jobs..concurrency` | `github, needs, strategy, matrix, inputs, vars` | Ninguno | | `jobs..container` | `github, needs, strategy, matrix, vars, inputs` | Ninguno | | `jobs..container.credentials` | `github, needs, strategy, matrix, env, vars, secrets, inputs` | Ninguno | | `jobs..container.env.` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, inputs` | Ninguno | | `jobs..container.image` | `github, needs, strategy, matrix, vars, inputs` | Ninguno | | `jobs..continue-on-error` | `github, needs, strategy, vars, matrix, inputs` | Ninguno | | `jobs..defaults.run` | `github, needs, strategy, matrix, env, vars, inputs` | Ninguno | | `jobs..env` | `github, needs, strategy, matrix, vars, secrets, inputs` | Ninguno | | `jobs..environment` | `github, needs, strategy, matrix, vars, inputs` | Ninguno | | `jobs..environment.url` | `github, needs, strategy, matrix, job, runner, env, vars, steps, inputs` | Ninguno | | `jobs..if` | `github, needs, vars, inputs` | `always, cancelled, success, failure` | | `jobs..name` | `github, needs, strategy, matrix, vars, inputs` | Ninguno | | `jobs..outputs.` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | Ninguno | | `jobs..runs-on` | `github, needs, strategy, matrix, vars, inputs` | Ninguno | | `jobs..secrets.` | `github, needs, strategy, matrix, secrets, inputs, vars` | Ninguno | | `jobs..services` | `github, needs, strategy, matrix, vars, inputs` | Ninguno | | `jobs..services..credentials` | `github, needs, strategy, matrix, env, vars, secrets, inputs` | Ninguno | | `jobs..services..env.` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, inputs` | Ninguno | | `jobs..steps.continue-on-error` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles` | | `jobs..steps.env` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles` | | `jobs..steps.if` | `github, needs, strategy, matrix, job, runner, env, vars, steps, inputs` | `always, cancelled, success, failure, hashFiles` | | `jobs..steps.name` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles` | | `jobs..steps.run` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles` | | `jobs..steps.timeout-minutes` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles` | | `jobs..steps.with` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles` | | `jobs..steps.working-directory` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles` | | `jobs..strategy` | `github, needs, vars, inputs` | Ninguno | | `jobs..timeout-minutes` | `github, needs, strategy, matrix, vars, inputs` | Ninguno | | `jobs..with.` | `github, needs, strategy, matrix, inputs, vars` | Ninguno | | `on.workflow_call.inputs..default` | `github, inputs, vars` | Ninguno | | `on.workflow_call.outputs..value` | `github, jobs, vars, inputs` | Ninguno | ### Ejemplo: imprimir información de contexto al registro Puedes imprimir el contenido de los contextos a la bitácora para la depuración. La función [`toJSON`](/es/actions/learn-github-actions/expressions#tojson) es necesaria para imprimir objetos JSON en el registro. > \[!WARNING] > 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 copy 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. Puedes leer la mayoría de los datos del contexto de `github` en variables de entorno. Para obtener más información sobre cómo usar variables de entorno, consulta [Almacenamiento de información en variables](/es/actions/learn-github-actions/variables). > \[!WARNING] > 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. > \[!WARNING] > Al crear flujos de trabajo y acciones, siempre debe tener en cuenta si el código podría ejecutar una entrada de posibles atacantes que no es de confianza. 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, consulta [Referencia de uso seguro](/es/actions/security-guides/security-hardening-for-github-actions#understanding-the-risk-of-script-injections). | Nombre de propiedad | Tipo | Descripción | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `github` | `object` | El 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.action` | `string` | Nombre de la acción actualmente en ejecución, o bien el [`id`](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsid) 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_path` | `string` | La ruta donde se ubica una acción. Esta propiedad solo es compatible en las acciones compuestas. Puede 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 (mediante la variable de entorno correspondiente): `cd "$GITHUB_ACTION_PATH"`. Para obtener más información sobre las variables de entorno, consulte [Referencia de uso seguro](/es/actions/reference/security/secure-use#use-an-intermediate-environment-variable). | | `github.action_ref` | `string` | En 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 use en la palabra clave `run`. Para que este contexto funcione con acciones compuestas, haga referencia a él dentro del contexto `env` de la acción compuesta. | | `github.action_repository` | `string` | En 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 use en la palabra clave `run`. Para que este contexto funcione con acciones compuestas, haga referencia a él dentro del contexto `env` de la acción compuesta. | | `github.action_status` | `string` | Para una acción compuesta, el resultado actual de la acción compuesta. | | `github.actor` | `string` | Nombre de usuario del usuario que activó 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`. 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.actor_id` | `string` | El id. de cuenta de la persona o aplicación que desencadenó la ejecución inicial del flujo de trabajo. Por ejemplo, `1234567`. Ten en cuenta que es diferente del nombre de usuario del actor. | | `github.api_url` | `string` | Dirección URL de la GitHub API REST. | | `github.base_ref` | `string` | | | `base_ref` o rama 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.env` | `string` | La ruta en el ejecutor del archivo que configura las variables de ambiente 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 más información, consulta [Comandos de flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-commands-for-github-actions#setting-an-environment-variable). | | `github.event` | `object` | La carga de webhook del evento completo. Puedes acceder a propiedades individuales del evento usando este contexto. El objeto es idéntico al payload del webhook del evento que activó la ejecución del flujo de trabajo, y es diferente para cada evento. Los webhooks de cada GitHub Actions evento están vinculados en [Eventos que desencadenan flujos de trabajo](/es/actions/using-workflows/events-that-trigger-workflows). Por ejemplo, para una ejecución de flujo de trabajo desencadenada por el evento [`push`](/es/actions/using-workflows/events-that-trigger-workflows#push), este objeto contiene el contenido de la [carga del webhook de inserción](/es/webhooks-and-events/webhooks/webhook-events-and-payloads#push). | | `github.event_name` | `string` | El nombre del evento que activó la ejecución del flujo de trabajo. | | `github.event_path` | `string` | La ruta al archivo en el ejecutor que contiene toda la carga útil del webhook del evento. | | `github.graphql_url` | `string` | La dirección URL de la API de GitHub GraphQL. | | `github.head_ref` | `string` | | | `head_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.job` | `string` | El [`job_id`](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_id) del trabajo actual.
Nota: El ejecutor de acciones establece esta propiedad del contexto, y solo está disponible dentro de la ejecución `steps` de un trabajo. De lo contrario, el valor de esta propiedad será `null`. | | `github.path` | `string` | Ruta 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 más información, consulta [Comandos de flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-commands-for-github-actions#adding-a-system-path). | | `github.ref` | `string` | Referencia 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` que no se fusionaron, esta es la rama de fusión del pull request. Si la solicitud de incorporación de cambios fue fusionada, esta es la rama en la que se fusionó. En el caso de los flujos de trabajo desencadenados por `release`, se trata de la etiqueta de versión creada. Para otros desencadenadores, esta es la referencia de rama o etiqueta 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/`. Para los eventos de solicitud de incorporación de cambios que no se mezclaron, con la excepción de `pull_request_target`, es `refs/pull//merge`. | | `pull_request_target` eventos tienen el valor del `ref` de la rama base. Para las etiquetas, es `refs/tags/`. Por ejemplo, `refs/heads/feature-branch-1`. Para obtener más información sobre las ramas de combinación de pull requests, consulte [Acerca de las solicitudes de incorporación de cambios](/es/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests#pull-request-refs-and-merge-branches). | | | | `github.ref_name` | `string` | Nombre 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`.

Para las solicitudes de incorporación de cambios que no se fusionaron, el formato es `/merge`. | | `github.ref_protected` | `boolean` | `true` si las protecciones de rama o [los conjuntos de reglas](/es/repositories/configuring-branches-and-merges-in-your-repository/managing-rulesets/managing-rulesets-for-a-repository) están configurados para la referencia que desencadenó la ejecución del flujo de trabajo. | | `github.ref_type` | `string` | El tipo de ref que activó la ejecución de flujo de trabajo. Los valores válidos son `branch` y `tag`. | | `github.repository` | `string` | El nombre del repositorio y del propietario. Por ejemplo, `octocat/Hello-World`. | | `github.repository_id` | `string` | El id. del repositorio. Por ejemplo, `123456789`. Ten en cuenta que esto es diferente del nombre del repositorio. | | `github.repository_owner` | `string` | Nombre de usuario del propietario del repositorio. Por ejemplo, `octocat`. | | `github.repository_owner_id` | `string` | Id. de cuenta del propietario del repositorio. Por ejemplo, `1234567`. Tenga en cuenta que es diferente del nombre del propietario. | | `github.repositoryUrl` | `string` | URL de Git para el repositorio. Por ejemplo, `git://github.com/octocat/hello-world.git`. | | `github.retention_days` | `string` | Número de días que se conservan los registros y artefactos de ejecución del flujo de trabajo. | | `github.run_id` | `string` | Un 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_number` | `string` | Un 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_attempt` | `string` | Número único para cada intento de ejecución de un flujo de trabajo particular 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_source` | `string` | El origen de un secreto utilizado en un flujo de trabajo. Los valores posibles son `None`, `Actions`, `Codespaces`o `Dependabot`. | | `github.server_url` | `string` | URL del servidor de GitHub. Por ejemplo: `https://github.com`. | | `github.sha` | `string` | El 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 más información, consulta [Eventos que desencadenan flujos de trabajo](/es/actions/using-workflows/events-that-trigger-workflows). Por ejemplo, `ffac537e6cbbf934b08745a378932722df287a53`. | | `github.token` | `string` | Token para autenticar en nombre de la aplicación de GitHub instalada en el repositorio. Esto es funcionalmente equivalente al secreto `GITHUB_TOKEN`. Para más información, consulta [Uso de GITHUB\_TOKEN para la autenticación en flujos de trabajo](/es/actions/security-guides/automatic-token-authentication).
Nota: El ejecutor de acciones establece esta propiedad del contexto, y solo está disponible dentro de la ejecución `steps` de un trabajo. De lo contrario, el valor de esta propiedad será `null`. | | `github.triggering_actor` | `string` | Nombre 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.workflow` | `string` | El nombre 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.workflow_ref` | `string` | La ruta de acceso de referencia al flujo de trabajo. Por ejemplo, `octocat/hello-world/.github/workflows/my-workflow.yml@refs/heads/my_branch`. | | `github.workflow_sha` | `string` | El SHA de confirmación para el archivo de flujo de trabajo. | | `github.workspace` | `string` | Directorio de trabajo predeterminado en el ejecutor para los pasos y la ubicación predeterminada del repositorio al usar la acción [`checkout`](https://github.com/actions/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`](/es/webhooks-and-events/webhooks/webhook-events-and-payloads#push). > \[!NOTE] > 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. ```json { "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 copy name: Run CI on: [push, pull_request] jobs: normal_ci: runs-on: ubuntu-latest steps: - name: Run normal CI run: echo "Running normal CI" pull_request_ci: runs-on: ubuntu-latest if: ${{ github.event_name == 'pull_request' }} steps: - name: Run PR CI run: echo "Running PR only 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, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-syntax-for-github-actions#env). 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, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idsteps). 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 propiedad | Tipo | Descripción | | ------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `env` | `object` | Este 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.` | `string` | El 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. ```json { "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 copy 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` 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 [Almacenamiento de información en variables](/es/actions/learn-github-actions/variables#defining-variables-for-multiple-workflows). ### Contenido de ejemplo del contexto `vars` El contenido del contexto `vars` es un mapeo de nombres de variables de configuración a sus valores. ```json { "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`. > \[!NOTE] > Las variables de configuración en el nivel de entorno están disponibles automáticamente después de que el ejecutor declare su entorno. 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 copy 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 propiedad | Tipo | Descripción | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `job` | `object` | Este contexto cambia para cada trabajo en cada ejecución del 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.check_run_id` | `number` | Identificador de ejecución de comprobación del trabajo actual. | | | | | | `job.container` | `object` | Información sobre el contenedor del trabajo. Para obtener más información sobre contenedores, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idcontainer). | | `job.container.id` | `string` | La ID del contenedor. | | `job.container.network` | `string` | La ID de la red del contenedor. El ejecutor crea la red usada por todos los contenedores en un trabajo. | | `job.services` | `object` | Los contenedores de servicios creados para una tarea. Para obtener más información sobre los contenedores de servicio, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idservices). | | `job.services..id` | `string` | La ID del contenedor de servicio. | | `job.services..network` | `string` | El ID de la red de contenedores de servicios. El ejecutor crea la red usada por todos los contenedores en un trabajo. | | `job.services..ports` | `object` | Los puertos expuestos del contenedor de servicio. | | `job.status` | `string` | Estado actual del trabajo. Los valores posibles son `success`, `failure` o `cancelled`. | | `job.workflow_ref` | `string` | Referencia completa del archivo de flujo de trabajo que define el trabajo actual. Por ejemplo, `octo-org/octo-repo/.github/workflows/deploy.yml@refs/heads/main`. En el caso de los trabajos definidos directamente en un archivo de flujo de trabajo, esto es lo mismo que `github.workflow_ref`. En el caso de los trabajos definidos en un [Reutilización de flujos de trabajo](/es/actions/using-workflows/reusing-workflows), esto hace referencia al archivo de flujo de trabajo reutilizable. (no disponible en GitHub Enterprise Server) | | `job.workflow_sha` | `string` | SHA de confirmación del archivo de flujo de trabajo que define el trabajo actual. (no disponible en GitHub Enterprise Server) | | `job.workflow_repository` | `string` | | | `owner/repo` del repositorio que contiene el archivo de flujo de trabajo que define el trabajo actual. Por ejemplo, `octo-org/octo-repo`. (no disponible en GitHub Enterprise Server) | | | | `job.workflow_file_path` | `string` | La ruta del archivo de flujo de trabajo que define el trabajo actual, relativa a la raíz del repositorio. Por ejemplo, `.github/workflows/deploy.yml`. (no disponible en GitHub Enterprise Server) | ### Contenido de ejemplo del contexto `job` En este contexto `job` de ejemplo se usa un contenedor de servicio de PostgreSQL con puertos asignados. Si no hay contenedores o contenedores de servicio usados en un trabajo, el `job` contexto solo contiene `status`. Las propiedades de identidad del flujo de trabajo (`workflow_ref`, `workflow_sha`, `workflow_repository`, `workflow_file_path`) y `check_run_id` no están disponibles en GitHub Enterprise Server. ```json { "status": "success", "check_run_id": 51725241954, "workflow_ref": "octo-org/octo-repo/.github/workflows/deploy.yml@refs/heads/main", "workflow_sha": "abc123def456789abc123def456789abc123def4", "workflow_repository": "octo-org/octo-repo", "workflow_file_path": ".github/workflows/deploy.yml", "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 copy 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: - run: pg_isready -h localhost -p ${{ job.services.postgres.ports[5432] }} - run: echo "Run tests against Postgres" ``` ### Ejemplo de uso de la identidad de contexto del flujo de trabajo de `job` > \[!NOTE] > Las `job.workflow_*` propiedades de contexto no están disponibles en GitHub Enterprise Server. Este flujo de trabajo reutilizable de ejemplo usa `job.workflow_repository` y `job.workflow_sha` para comprobar su propio código fuente, en lugar del repositorio del autor de la llamada. Esto resulta útil cuando un flujo de trabajo reutilizable necesita tener acceso a archivos ubicados conjuntamente con la definición del flujo de trabajo. ```yaml copy # In a reusable workflow (e.g., octo-org/shared-workflows/.github/workflows/deploy.yml) name: Reusable deploy workflow on: workflow_call: jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v6 with: repository: ${{ job.workflow_repository }} ref: ${{ job.workflow_sha }} - run: echo "Deploying from ${{ job.workflow_ref }}" - run: echo "Workflow file path is ${{ job.workflow_file_path }}" ``` ## 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, consulta [Reutilización de flujos de trabajo](/es/actions/using-workflows/reusing-workflows#using-outputs-from-a-reusable-workflow). | Nombre de propiedad | Tipo | Descripción | | ------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `jobs` | `object` | Esto 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..result` | `string` | El resultado de un trabajo en el flujo de trabajo reutilizable. Los valores posibles son `success`, `failure`, `cancelled` o `skipped`. | | `jobs..outputs` | `object` | Conjunto de salidas de un trabajo en un flujo de trabajo reutilizable. | | `jobs..outputs.` | `string` | El 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. ```json { "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, consulta [Reutilización de flujos de trabajo](/es/actions/using-workflows/reusing-workflows#using-outputs-from-a-reusable-workflow). ```yaml copy 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`](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsid) y ya se han ejecutado. | Nombre de propiedad | Tipo | Descripción | | --------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `steps` | `object` | Este 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..outputs` | `object` | El conjunto de salidas definido para el paso. Para más información, consulta [Guía de referencia de la sintaxis de metadatos](/es/actions/creating-actions/metadata-syntax-for-github-actions#outputs-for-docker-container-and-javascript-actions). | | `steps..conclusion` | `string` | El resultado de un paso completado después de aplicar [`continue-on-error`](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepscontinue-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..outcome` | `string` | El resultado de un paso completado antes de aplicar [`continue-on-error`](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepscontinue-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..outputs.` | `string` | El 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`](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsid). El primer paso tenía el `id` denominado `checkout`, el segundo `generate_number`. El paso `generate_number` tenía una salida denominada `random_number`. ```json { "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 copy name: Generate random failure on: push jobs: randomly-failing-job: runs-on: ubuntu-latest steps: - 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 corredor que está ejecutando el trabajo actual. | Nombre de propiedad | Tipo | Descripción | | -------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `runner` | `object` | Este contexto cambia para cada trabajo en cada ejecución del flujo de trabajo. Este objeto contiene todas las propiedades que se listan debajo. | | `runner.name` | `string` | El 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.os` | `string` | El sistema operativo del ejecutor que ejecuta el trabajo. Los valores posibles son `Linux`, `Windows` o `macOS`. | | `runner.arch` | `string` | La arquitectura del ejecutor que ejecuta el job. Los valores posibles son `X86`, `X64`, `ARM` o `ARM64`. | | `runner.temp` | `string` | La 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_cache` | `string` | La ruta al directorio que contiene las herramientas preinstaladas para los ejecutores hospedados en GitHub. Para más información, consulta [Ejecutores hospedados en GitHub](/es/actions/using-github-hosted-runners/about-github-hosted-runners#supported-software). | | `runner.debug` | `string` | Esto solo se establece si el [registro de depuración](/es/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging) 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. | | `runner.environment` | `string` | El entorno del ejecutor que ejecuta el trabajo. Los valores posibles son: `github-hosted` para los ejecutores hospedados en GitHub proporcionados por GitHub y `self-hosted` para los ejecutores de prueba interna configurados por el propietario del repositorio. | ### Contenido de ejemplo del contexto `runner` El siguiente contexto de ejemplo procede de un ejecutor hospedado en Linux GitHub. ```json { "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 copy name: Build on: push jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v6 - name: Build with logs run: | mkdir ${{ runner.temp }}/build_logs echo "Logs from building" > ${{ runner.temp }}/build_logs/build.logs exit 1 - name: Upload logs on fail if: ${{ failure() }} uses: actions/upload-artifact@v4 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, consulta [Uso de secretos en Acciones de GitHub](/es/actions/security-guides/using-secrets-in-github-actions). `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, consulta [Uso de GITHUB\_TOKEN para la autenticación en flujos de trabajo](/es/actions/security-guides/automatic-token-authentication). > \[!WARNING] > Si se ha usado un secreto en un trabajo de flujo de trabajo, GitHub redacta automáticamente los secretos impresos en el registro. Debe evitar imprimir secretos en el registro intencionadamente. | Nombre de propiedad | Tipo | Descripción | | ----------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `secrets` | `object` | Este contexto es el mismo para cada tarea en una ejecución de un 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_TOKEN` | `string` | Token creado automáticamente para cada ejecución de flujo de trabajo. Para más información, consulta [Uso de GITHUB\_TOKEN para la autenticación en flujos de trabajo](/es/actions/security-guides/automatic-token-authentication). | | `secrets.` | `string` | El 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. ```json { "github_token": "***", "NPM_TOKEN": "***", "SUPERSECRET": "***" } ``` ### Ejemplo de uso del contexto `secrets` En este flujo de trabajo de ejemplo se usa la [CLI de GitHub](/es/actions/using-workflows/using-github-cli-in-workflows), que necesita `GITHUB_TOKEN` como valor para el parámetro de entrada `GH_TOKEN`: ```yaml copy name: Open new issue on: workflow_dispatch jobs: open-issue: runs-on: ubuntu-latest permissions: contents: read issues: write steps: - run: | gh issue --repo ${{ github.repository }} \ create --title "Issue title" --body "Issue body" env: GH_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 propiedad | Tipo | Descripción | | ----------------------------------------------------------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `strategy` | `object` | Este contexto cambia para cada trabajo en cada ejecución del flujo de trabajo. Puedes acceder al contexto desde cualquier tarea o paso en un flujo de trabajo. Este objeto contiene todas las propiedades que se listan debajo. | | `strategy.fail-fast` | `boolean` | Cuando esto se evalúa como `true`, todos los trabajos en curso se cancelan si algún trabajo en una matriz falla. Para más información, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategyfail-fast). | | `strategy.job-index` | `number` | El í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-total` | `number` | El 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-parallel` | `number` | El número máximo de trabajos que se pueden ejecutar simultáneamente al usar una estrategia de trabajo `matrix`. Para más información, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymax-parallel). | ### 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. ```json { "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 copy name: Test strategy on: push jobs: test: runs-on: ubuntu-latest strategy: matrix: test-group: [1, 2] node: [14, 16] steps: - run: echo "Mock test logs" > test-job-${{ strategy.job-index }}.txt - name: Upload logs uses: actions/upload-artifact@v4 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 propiedad | Tipo | Descripción | | ------------------------ | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `matrix` | `object` | Este contexto solo está disponible para los trabajos de una matriz y cambia para cada trabajo en la ejecución de un flujo de trabajo. Puedes acceder al contexto desde cualquier tarea o paso en un flujo de trabajo. Este objeto contiene las propiedades que se listan a continuación. | | `matrix.` | `string` | El 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. La tarea consiste en ejecutar la combinación matricial de un sistema operativo `ubuntu-latest` y la versión `16` de Node.js. ```json { "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 copy name: Test matrix on: push jobs: build: runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, windows-latest] node: [14, 16] steps: - uses: actions/setup-node@v4 with: node-version: ${{ matrix.node }} - name: Output node version run: node --version ``` ## Contexto `needs` El contexto `needs` contiene los resultados 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, consulta [Sintaxis del flujo de trabajo para Acciones de GitHub](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idneeds). | Nombre de propiedad | Tipo | Descripción | | -------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `needs` | `object` | Este 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 al contexto desde cualquier tarea o paso en un flujo de trabajo. Este objeto contiene todas las propiedades que se listan debajo. | | `needs.` | `object` | Una única tarea de la cual depende la tarea actual. | | `needs..outputs` | `object` | El conjunto de resultados de una tarea de la cual depende la tarea actual. | | `needs..outputs.` | `string` | El valor de un resultado específico para una tarea de la cual depende la tarea actual. | | `needs..result` | `string` | El resultado de un trabajo del cual depende el trabajo 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. ```json { "build": { "result": "success", "outputs": { "build_id": "123456" } }, "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 copy name: Build and deploy on: push jobs: build: runs-on: ubuntu-latest outputs: build_id: ${{ steps.build_step.outputs.build_id }} steps: - name: Build id: build_step run: echo "build_id=$RANDOM" >> $GITHUB_OUTPUT deploy: needs: build runs-on: ubuntu-latest steps: - run: echo "Deploying build ${{ needs.build.outputs.build_id }}" debug: needs: [build, deploy] runs-on: ubuntu-latest if: ${{ failure() }} steps: - run: echo "Failed to build and deploy" ``` ## Contexto `inputs` El contexto `inputs` contiene las propiedades de entrada pasadas a una acción, a un flujo de trabajo reutilizable o a un flujo de trabajo desencadenado manualmente. Para flujos de trabajo reutilizables, los nombres y tipos de entrada se definen en la [configuración del evento `workflow_call`](/es/actions/using-workflows/events-that-trigger-workflows#workflow-reuse-events) de un flujo de trabajo reutilizable y los valores de entrada se pasan desde [`jobs..with`](/es/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idwith) 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_dispatch`configuración del evento](/es/actions/using-workflows/events-that-trigger-workflows#workflow_dispatch) 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](/es/actions/using-workflows/reusing-workflows) o en un flujo de trabajo desencadenado por el [evento `workflow_dispatch`](/es/actions/using-workflows/events-that-trigger-workflows#workflow_dispatch) | Nombre de propiedad | Tipo | Descripción | | ------------------------------------------ | -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `inputs` | `object` | Este contexto solo está disponible en un [flujo de trabajo reutilizable](/es/actions/using-workflows/reusing-workflows) o en un flujo de trabajo desencadenado por el [`workflow_dispatch`evento](/es/actions/using-workflows/events-that-trigger-workflows#workflow_dispatch). Puedes acceder al contexto desde cualquier tarea o paso en un flujo de trabajo. Este objeto contiene las propiedades que se listan a continuación. | | `inputs.` | | | | `string` o `number` o `boolean` o `choice` | Cada valor de entrada que se transfiere 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`. ```json { "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 copy 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: echo "Deploying build:${{ inputs.build_id }} to 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 evento`workflow_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 copy 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: echo "Deploying build:${{ inputs.build_id }} to target:${{ inputs.deploy_target }}" ``` ## Información adicional * [Contextos](/es/actions/concepts/workflows-and-actions/contexts)