# 문맥 참조

사용 가능한 속성, 액세스 방법 및 사용 예제를 포함하여 워크플로에서 GitHub Actions 사용할 수 있는 컨텍스트에 대한 정보를 찾습니다.

## 사용 가능한 컨텍스트

| 컨텍스트 이름    | 타입       | 설명                                                                                           |
| ---------- | -------- | -------------------------------------------------------------------------------------------- |
| `github`   | `object` | 워크플로 실행에 대한 정보입니다. 자세한 내용은 [`github`컨텍스트](#github-context)를 참조하세요.                           |
| `env`      | `object` | 워크플로, 작업 또는 단계에 설정된 변수를 포함합니다. 자세한 내용은 [`env`컨텍스트](#env-context)를 참조하세요.                     |
| `vars`     | `object` | 리포지토리, 조직 또는 환경 수준에서 설정된 변수를 포함합니다. 자세한 내용은 [`vars`컨텍스트](#vars-context)를 참조하세요.              |
| `job`      | `object` | 현재 실행 중인 작업에 대한 정보입니다. 자세한 내용은 [`job`컨텍스트](#job-context)를 참조하세요.                             |
| `jobs`     | `object` | 재사용 가능한 워크플로에만 해당하며, 재사용 가능한 워크플로의 작업 출력을 포함합니다. 자세한 내용은 [`jobs`컨텍스트](#jobs-context)를 참조하세요. |
| `steps`    | `object` | 현재 작업에서 실행된 단계에 대한 정보입니다. 자세한 내용은 [`steps`컨텍스트](#steps-context)를 참조하세요.                      |
| `runner`   | `object` | 현재 작업을 실행하는 실행기 정보입니다. 자세한 내용은 [`runner`컨텍스트](#runner-context)를 참조하세요.                       |
| `secrets`  | `object` | 워크플로 실행에 사용할 수 있는 비밀의 이름과 값을 포함합니다. 자세한 내용은 [`secrets`컨텍스트](#secrets-context)를 참조하세요.        |
| `strategy` | `object` | 현재 작업에 대한 행렬 실행 전략에 대한 정보. 자세한 내용은 [`strategy`컨텍스트](#strategy-context)를 참조하세요.               |
| `matrix`   | `object` | 현재 작업에 적용되는 워크플로에 정의된 행렬 속성을 포함합니다. 자세한 내용은 [`matrix`컨텍스트](#matrix-context)를 참조하세요.          |
| `needs`    | `object` | 현재 작업의 종속성으로 정의된 모든 작업의 ​​출력을 포함합니다. 자세한 내용은 [`needs`컨텍스트](#needs-context)를 참조하세요.           |
| `inputs`   | `object` | 재사용 가능하거나 수동으로 트리거되는 워크플로의 입력을 포함합니다. 자세한 내용은 [`inputs`컨텍스트](#inputs-context)를 참조하세요.        |

식의 일부로 두 구문 중 하나를 사용하여 컨텍스트 정보에 액세스할 수 있습니다.

* 인덱스 구문: `github['sha']`
* 속성 역참조 구문: `github.sha`

속성 역참조 구문을 사용하려면 속성 이름이 문자 또는 `_`로 시작하거나 영숫자 문자, `-` 또는 `_`만 포함해야 합니다.

존재하지 않는 속성을 역참조하려고 하면 빈 문자열로 평가됩니다.

### 컨텍스트를 사용할 시기 결정

GitHub Actions 에는 *컨텍스트* 라는 변수 컬렉션과 기본 변수라는 유사한 변수 컬렉션 *이 포함되어 있습니다*. 이러한 변수는 워크플로의 여러 지점에서 사용하기 위한 것입니다.

* **기본 환경 변수:** 이러한 환경 변수는 작업을 실행하는 실행기에서만 존재합니다. 자세한 내용은 [변수 참조](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/variables)을(를) 참조하세요.
* 컨텍스트: **기본 변수**를 사용할 수 없는 경우를 비롯한 대부분의 컨텍스트를 워크플로의 모든 지점에서 사용할 수 있습니다. 예를 들어 작업이 실행을 위해 실행기로 라우팅되기 전에 식과 함께 컨텍스트를 사용하여 초기 처리를 수행할 수 있습니다. 이렇게 하면 조건부 `if` 키워드가 포함된 컨텍스트를 사용하여 단계를 실행할지 여부를 결정할 수 있습니다. 작업이 실행되면 작업을 실행하는 실행기에서 컨텍스트 변수를 검색할 수도 있습니다(예시: `runner.os`). 워크플로 내에서 다양한 컨텍스트를 사용할 수 있는 위치에 대한 자세한 내용은 [컨텍스트 가용성](#context-availability)을 참조하세요.

다음 예시에서는 이러한 다양한 유형의 변수를 작업에서 함께 사용하는 방법을 보여 줍니다.

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

이 예시에서 `if` 문은 [`github.ref`](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/contexts#github-context) 컨텍스트를 검사하여 현재 분기 이름을 확인합니다. 이름이 `refs/heads/main`이면 후속 단계가 실행됩니다.
`if` 검사는 GitHub Actions에 의해 처리되며, 결과가 `true`일 경우에만 작업이 실행기로 전송됩니다. 작업이 실행기로 전송되면 단계가 실행되고 실행기의 [`$GITHUB_REF`](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/variables) 변수를 참조합니다.

### 컨텍스트 가용성

워크플로 실행 전체에서 다양한 컨텍스트를 사용할 수 있습니다. 예를 들어 `secrets` 컨텍스트는 작업 내의 특정 위치에서만 사용할 수 있습니다.

또한 일부 함수는 특정 위치에서만 사용할 수 있습니다. 예를 들어 `hashFiles` 함수는 아무 데서도 사용할 수 없습니다.

다음 표에는 워크플로 내에서 각 컨텍스트 및 특수 함수를 사용할 수 있는 위치에 대한 제한 사항이 나열되어 있습니다. 나열된 컨텍스트는 지정된 워크플로 키에 대해서만 사용할 수 있으며 다른 곳에는 사용할 수 없습니다. 아래에 나열되어 있지 않은 함수는 어디에서나 사용할 수 있습니다.

| 워크플로 키                                             | 컨텍스트                                                                              | 특수 함수                                            |
| -------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------ |
| `run-name`                                         | `github, inputs, vars`                                                            | None                                             |
| `concurrency`                                      | `github, inputs, vars`                                                            | None                                             |
| `env`                                              | `github, secrets, inputs, vars`                                                   | None                                             |
| `jobs.<job_id>.concurrency`                        | `github, needs, strategy, matrix, inputs, vars`                                   | None                                             |
| `jobs.<job_id>.container`                          | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |
| `jobs.<job_id>.container.credentials`              | `github, needs, strategy, matrix, env, vars, secrets, inputs`                     | None                                             |
| `jobs.<job_id>.container.env.<env_id>`             | `github, needs, strategy, matrix, job, runner, env, vars, secrets, inputs`        | None                                             |
| `jobs.<job_id>.container.image`                    | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |
| `jobs.<job_id>.continue-on-error`                  | `github, needs, strategy, vars, matrix, inputs`                                   | None                                             |
| `jobs.<job_id>.defaults.run`                       | `github, needs, strategy, matrix, env, vars, inputs`                              | None                                             |
| `jobs.<job_id>.env`                                | `github, needs, strategy, matrix, vars, secrets, inputs`                          | None                                             |
| `jobs.<job_id>.environment`                        | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |
| `jobs.<job_id>.environment.url`                    | `github, needs, strategy, matrix, job, runner, env, vars, steps, inputs`          | None                                             |
| `jobs.<job_id>.if`                                 | `github, needs, vars, inputs`                                                     | `always, cancelled, success, failure`            |
| `jobs.<job_id>.name`                               | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |
| `jobs.<job_id>.outputs.<output_id>`                | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | None                                             |
| `jobs.<job_id>.runs-on`                            | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |
| `jobs.<job_id>.secrets.<secrets_id>`               | `github, needs, strategy, matrix, secrets, inputs, vars`                          | None                                             |
| `jobs.<job_id>.services`                           | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |
| `jobs.<job_id>.services.<service_id>.credentials`  | `github, needs, strategy, matrix, env, vars, secrets, inputs`                     | None                                             |
| `jobs.<job_id>.services.<service_id>.env.<env_id>` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, inputs`        | None                                             |
| `jobs.<job_id>.steps.continue-on-error`            | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |
| `jobs.<job_id>.steps.env`                          | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |
| `jobs.<job_id>.steps.if`                           | `github, needs, strategy, matrix, job, runner, env, vars, steps, inputs`          | `always, cancelled, success, failure, hashFiles` |
| `jobs.<job_id>.steps.name`                         | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |
| `jobs.<job_id>.steps.run`                          | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |
| `jobs.<job_id>.steps.timeout-minutes`              | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |
| `jobs.<job_id>.steps.with`                         | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |
| `jobs.<job_id>.steps.working-directory`            | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |
| `jobs.<job_id>.strategy`                           | `github, needs, vars, inputs`                                                     | None                                             |
| `jobs.<job_id>.timeout-minutes`                    | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |
| `jobs.<job_id>.with.<with_id>`                     | `github, needs, strategy, matrix, inputs, vars`                                   | None                                             |
| `on.workflow_call.inputs.<inputs_id>.default`      | `github, inputs, vars`                                                            | None                                             |
| `on.workflow_call.outputs.<output_id>.value`       | `github, jobs, vars, inputs`                                                      | None                                             |

### 예시: 로그에 컨텍스트 정보 출력

디버깅을 위해 컨텍스트의 콘텐츠를 로그에 출력할 수 있습니다.
[
`toJSON` 함수](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/expressions#tojson)는 JSON 개체를 로그에 출력하는 데 필요합니다.

> \[!WARNING]
> 전체 `github` 컨텍스트를 사용할 때는 중요한 정보(예: `github.token`)가 포함된다는 점을 염두에 두어야 합니다. GitHub은(는) 비밀을 콘솔에 인쇄할 때 마스킹하지만 컨텍스트를 내보내거나 인쇄할 때는 주의해야 합니다.

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

## `github` 컨텍스트

`github` 컨텍스트에는 워크플로 실행 및 실행을 트리거한 이벤트에 대한 정보가 포함됩니다. 환경 변수에서 대부분의 `github` 컨텍스트 데이터를 읽을 수 있습니다. 환경 변수에 대한 자세한 내용은 [변수에 정보 저장](/ko/enterprise-server@3.22/actions/how-tos/write-workflows/choose-what-workflows-do/use-variables)을(를) 참조하세요.

> \[!WARNING]
> 전체 `github` 컨텍스트를 사용할 때는 중요한 정보(예: `github.token`)가 포함된다는 점을 염두에 두어야 합니다. GitHub은(는) 비밀을 콘솔에 인쇄할 때 마스킹하지만 컨텍스트를 내보내거나 인쇄할 때는 주의해야 합니다.
> \[!WARNING]
> 워크플로와 작업을 만들 때는 코드가 공격자의 신뢰할 수 없는 입력을 실행할 수 있는지 항상 고려해야 합니다. 특정 컨텍스트는 공격자가 자신의 악성 콘텐츠를 삽입할 수 있으므로 신뢰할 수 없는 입력으로 취급해야 합니다. 자세한 내용은 [안전 사용 참조](/ko/enterprise-server@3.22/actions/reference/security/secure-use#good-practices-for-mitigating-script-injection-attacks)을(를) 참조하세요.

| 속성 이름                                                                                                                                                                                                                                                                                                                                                          | 타입        | 설명                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `github`                                                                                                                                                                                                                                                                                                                                                       | `object`  | 워크플로의 모든 작업 또는 단계 중에 사용할 수 있는 최상위 컨텍스트입니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `github.action`                                                                                                                                                                                                                                                                                                                                                | `string`  | 현재 실행 중인 작업의 이름 또는 단계의 [`id`](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsid)입니다.                                                                                                                                                                                                                                                                                                                                                                                                          |
| GitHub는 특수 문자를 제거하고, 현재 단계에서 `__run` 없이 스크립트를 실행할 때 이름`id`을 사용합니다. 동일한 작업에서 동일한 동작을 두 번 이상 사용하는 경우 이름 앞에 밑줄이 있는 시퀀스 번호가 있는 접미사가 포함됩니다. 예를 들어 실행하는 첫 번째 스크립트에는 이름이 `__run`으로 지정되고 두 번째 스크립트의 이름은 `__run_2`로 지정됩니다. 마찬가지로 두 번째 `actions/checkout` 호출은 `actionscheckout2`입니다.                                                                                     |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `github.action_path`                                                                                                                                                                                                                                                                                                                                           | `string`  | 작업이 수행되는 경로입니다. 이 속성은 복합 작업에서만 지원됩니다. 이 경로를 사용하여 작업과 동일한 리포지토리에 있는 파일에 액세스할 수 있습니다(예: 해당 환경 변수 `cd "$GITHUB_ACTION_PATH"`를 사용하여 경로로 디렉터리를 변경). 환경 변수에 대한 자세한 내용은 [안전 사용 참조](/ko/enterprise-server@3.22/actions/reference/security/secure-use#use-an-intermediate-environment-variable)을 참조하세요.                                                                                                                                                                                                                                                   |
| `github.action_ref`                                                                                                                                                                                                                                                                                                                                            | `string`  | 작업을 실행하는 단계의 경우, 실행 중인 작업의 참조 식별자입니다. 예를 들어 `v2`입니다.<br><br>`run` 키워드를 사용하지 마세요. 이 컨텍스트를 복합 작업에서 작동하도록 하려면 복합 작업의 `env` 컨텍스트 내에서 참조합니다.                                                                                                                                                                                                                                                                                                                                                                                                          |
| `github.action_repository`                                                                                                                                                                                                                                                                                                                                     | `string`  | 작업을 실행하는 단계의 경우 작업의 소유자 및 리포지토리 이름입니다. 예를 들어 `actions/checkout`입니다.<br><br>`run` 키워드를 사용하지 마세요. 이 컨텍스트를 복합 작업에서 작동하도록 하려면 복합 작업의 `env` 컨텍스트 내에서 참조합니다.                                                                                                                                                                                                                                                                                                                                                                                           |
| `github.action_status`                                                                                                                                                                                                                                                                                                                                         | `string`  | 복합 작업의 경우 복합 작업의 현재 결과입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `github.actor`                                                                                                                                                                                                                                                                                                                                                 | `string`  | 처음 워크플로 실행을 트리거한 사용자의 사용자 이름입니다. 워크플로 실행이 다시 실행인 경우 이 값은 `github.triggering_actor`와 다를 수 있습니다. 다시 실행을 시작하는 행위자(`github.actor`)가 다른 권한을 갖고 있더라도 모든 워크플로 다시 실행은 `github.triggering_actor`의 권한을 사용합니다.                                                                                                                                                                                                                                                                                                                                              |
| `github.actor_id`                                                                                                                                                                                                                                                                                                                                              | `string`  | 최초로 워크플로 실행을 트리거한 사용자 또는 앱의 계정 ID입니다. 예를 들어 `1234567`입니다. 행위자 사용자 이름과는 다릅니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `github.api_url`                                                                                                                                                                                                                                                                                                                                               | `string`  | REST API의 GitHub URL입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `github.base_ref`                                                                                                                                                                                                                                                                                                                                              | `string`  | 워크플로 실행에서 풀 리퀘스트의 `base_ref` 또는 타겟 브랜치입니다. 이 속성은 워크플로 실행을 트리거하는 이벤트가 `pull_request` 또는 `pull_request_target`인 경우에만 사용할 수 있습니다.                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `github.env`                                                                                                                                                                                                                                                                                                                                                   | `string`  | 실행기에서 워크플로 명령의 환경 변수를 설정하는 파일의 경로입니다. 이 파일은 현재 단계에 고유하며 작업의 각 단계에 대해 다른 파일입니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 명령](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-commands#setting-an-environment-variable)을(를) 참조하세요.                                                                                                                                                                                                                                                                                             |
| `github.event`                                                                                                                                                                                                                                                                                                                                                 | `object`  | 전체 이벤트 웹후크 페이로드입니다. 이 컨텍스트를 사용하여 이벤트의 개별 속성에 액세스할 수 있습니다. 이 개체는 워크플로 실행을 트리거한 이벤트의 웹후크 페이로드와 동일하며 각 이벤트에 대해 다릅니다. 각 GitHub Actions 이벤트에 대한 웹후크는 [워크플로를 트리거하는 이벤트](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_call)로 연결됩니다. 예를 들어 [`push` 이벤트](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/events-that-trigger-workflows#push)에 의해 트리거되는 워크플로 실행의 경우 이 개체에는 [푸시 웹후크 페이로드](/ko/enterprise-server@3.22/webhooks/webhook-events-and-payloads#push)의 내용이 포함됩니다. |
| `github.event_name`                                                                                                                                                                                                                                                                                                                                            | `string`  | 워크플로 실행을 트리거한 이벤트의 이름입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `github.event_path`                                                                                                                                                                                                                                                                                                                                            | `string`  | 전체 이벤트 웹후크 페이로드가 포함된 실행기에서 파일의 경로입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `github.graphql_url`                                                                                                                                                                                                                                                                                                                                           | `string`  | GraphQL API의 GitHub URL입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `github.head_ref`                                                                                                                                                                                                                                                                                                                                              | `string`  | 워크플로 실행에서 끌어오기 요청의 `head_ref` 또는 소스 분기입니다. 이 속성은 워크플로 실행을 트리거하는 이벤트가 `pull_request` 또는 `pull_request_target`인 경우에만 사용할 수 있습니다.                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `github.job`                                                                                                                                                                                                                                                                                                                                                   | `string`  | 현재 작업의 [`job_id`](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_id)입니다. <br /> 참고: 이 컨텍스트 속성은 Actions 실행기에서 설정되며 작업의 실행 `steps` 내에서만 사용할 수 있습니다. 그렇지 않으면 이 속성의 값이 `null`이 됩니다.                                                                                                                                                                                                                                                                                                                      |
| `github.path`                                                                                                                                                                                                                                                                                                                                                  | `string`  | 워크플로 명령에서 시스템 `PATH` 변수를 설정하는 파일의 러너 경로입니다. 이 파일은 현재 단계에 고유하며 작업의 각 단계에 대해 다른 파일입니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 명령](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-commands#adding-a-system-path)을(를) 참조하세요.                                                                                                                                                                                                                                                                                                  |
| `github.ref`                                                                                                                                                                                                                                                                                                                                                   | `string`  | 워크플로 실행을 트리거한 분기 또는 태그의 완전한 형식 참조 입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `push`에 의해 트리거된 워크플로의 경우 푸시된 분기 또는 태그 참조입니다. 병합되지 않은 `pull_request`가 트리거한 워크플로의 경우, 이는 끌어오기 요청 병합 분기입니다. 끌어오기 요청이 병합된 경우 병합된 분기가 여기에 해당됩니다.                                                                                                                                                                                                                    |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `release`에 의해 트리거된 워크플로의 경우 생성된 릴리스 태그입니다. 다른 트리거의 경우 워크플로 실행을 트리거한 분기 또는 태그 참조입니다. 이벤트 유형에 대해 분기 또는 태그를 사용할 수 있는 경우에만 설정됩니다. 지정된 참조는 완전한 형식을 가집니다. 즉, 분기의 형식은 `refs/heads/<branch_name>`입니다. 병합되지 않은 경우를 제외하고 `pull_request_target` 끌어오기 요청 이벤트의 경우는 다음과 입니다 `refs/pull/<pr_number>/merge`.                                                                   |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `pull_request_target` 이벤트에는 베이스 분기의 `ref`가 있습니다. 태그의 경우에는 `refs/tags/<tag_name>`입니다. 예를 들어 `refs/heads/feature-branch-1`입니다. 끌어오기 요청 병합 분기에 대한 자세한 내용은 [끌어오기 요청](/ko/enterprise-server@3.22/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`  | 워크플로 실행을 트리거한 분기 또는 태그입니다. 해당 값은 GitHub에 표시된 분기 또는 태그 이름과 일치합니다. 예를 들어 `feature-branch-1`입니다.<br><br>병합되지 않은 끌어오기 요청의 경우 형식은 .입니다 `<pr_number>/merge`.                                                                                                                                                                                                                                                                                                                                                                                           |
| `github.ref_protected`                                                                                                                                                                                                                                                                                                                                         | `boolean` | 분기 보호가 워크플로 실행을 트리거한 ref에 대해 구성된 경우 `true`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `github.ref_type`                                                                                                                                                                                                                                                                                                                                              | `string`  | 워크플로 실행을 트리거한 ref의 형식입니다. 유효한 값은 `branch` 또는 `tag`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `github.repository`                                                                                                                                                                                                                                                                                                                                            | `string`  | 소유자 및 리포지토리 이름입니다. 예를 들어 `octocat/Hello-World`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `github.repository_id`                                                                                                                                                                                                                                                                                                                                         | `string`  | 리포지토리 ID. 예를 들어 `123456789`입니다. 리포지토리 이름과는 다릅니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `github.repository_owner`                                                                                                                                                                                                                                                                                                                                      | `string`  | 리포지토리 소유자의 사용자 이름입니다. 예를 들어 `octocat`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `github.repository_owner_id`                                                                                                                                                                                                                                                                                                                                   | `string`  | 리포지토리 소유자 계정 ID. 예를 들어 `1234567`입니다. 소유자의 이름과는 다른 값입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `github.repositoryUrl`                                                                                                                                                                                                                                                                                                                                         | `string`  | 리포지토리에 대한 Git URL입니다. 예를 들어 `git://github.com/octocat/hello-world.git`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `github.retention_days`                                                                                                                                                                                                                                                                                                                                        | `string`  | 워크플로 실행 로그 및 아티팩트가 유지되는 일 수입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `github.run_id`                                                                                                                                                                                                                                                                                                                                                | `string`  | 리포지토리 내에서 실행되는 각 워크플로의 고유한 숫자입니다. 워크플로 실행을 다시 실행하는 경우 이 숫자는 변경되지 않습니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `github.run_number`                                                                                                                                                                                                                                                                                                                                            | `string`  | 리포지토리에 있는 특정 워크플로의 실행마다 고유한 숫자입니다. 이 숫자는 워크플로의 첫 실행 시 1부터 시작하며 새 실행마다 증가합니다. 워크플로 실행을 다시 실행하는 경우 이 숫자는 변경되지 않습니다.                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `github.run_attempt`                                                                                                                                                                                                                                                                                                                                           | `string`  | 리포지토리 내 각 특정 워크플로 실행 시도의 고유한 번호입니다. 이 숫자는 워크플로의 실행의 첫 시도 시 1부터 시작하며 다시 실행할 때마다 증가합니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `github.secret_source`                                                                                                                                                                                                                                                                                                                                         | `string`  | 워크플로에 사용되는 비밀의 소스입니다. 가능한 값은 `None`, `Actions``Dependabot`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `github.server_url`                                                                                                                                                                                                                                                                                                                                            | `string`  | GitHub 서버의 URL입니다. 예시: `https://github.com`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `github.sha`                                                                                                                                                                                                                                                                                                                                                   | `string`  | 워크플로를 트리거한 커밋 SHA입니다. 이 커밋 SHA의 값은 워크플로를 트리거한 이벤트에 따라 달라집니다. 자세한 내용은 [워크플로를 트리거하는 이벤트](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/events-that-trigger-workflows)을(를) 참조하세요. 예를 들어 `ffac537e6cbbf934b08745a378932722df287a53`입니다.                                                                                                                                                                                                                                                                                         |
| `github.token`                                                                                                                                                                                                                                                                                                                                                 | `string`  | 리포지토리에 설치된 GitHub 앱을 대신하여 인증할 토큰입니다. 기능적으로 `GITHUB_TOKEN` 비밀과 동일합니다. 자세한 내용은 [워크플로에서 인증에 GITHUB\_TOKEN 사용](/ko/enterprise-server@3.22/actions/tutorials/authenticate-with-github_token)을(를) 참조하세요.  <br /> 참고: 이 컨텍스트 속성은 Actions 실행기에서 설정되며 작업의 실행 `steps` 내에서만 사용할 수 있습니다. 그렇지 않으면 이 속성의 값이 `null`이 됩니다.                                                                                                                                                                                                                                       |
| `github.triggering_actor`                                                                                                                                                                                                                                                                                                                                      | `string`  | 워크플로 실행을 시작한 사용자의 사용자 이름입니다. 워크플로 실행이 다시 실행인 경우 이 값은 `github.actor`와 다를 수 있습니다. 다시 실행을 시작하는 행위자(`github.triggering_actor`)가 다른 권한을 갖고 있더라도 모든 워크플로 다시 실행은 `github.actor`의 권한을 사용합니다.                                                                                                                                                                                                                                                                                                                                                             |
| `github.workflow`                                                                                                                                                                                                                                                                                                                                              | `string`  | 워크플로의 이름입니다. 워크플로 파일이 `name`을 지정하지 않으면 이 속성의 값은 리포지토리에 있는 워크플로 파일의 전체 경로입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `github.workflow_ref`                                                                                                                                                                                                                                                                                                                                          | `string`  | 워크플로의 참조 경로입니다. 예를 들어 `octocat/hello-world/.github/workflows/my-workflow.yml@refs/heads/my_branch`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `github.workflow_sha`                                                                                                                                                                                                                                                                                                                                          | `string`  | 워크플로 파일의 커밋 SHA입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `github.workspace`                                                                                                                                                                                                                                                                                                                                             | `string`  | 단계에 대한 실행기의 기본 작업 디렉터리 및 [`checkout`](https://github.com/actions/checkout) 작업을 사용할 때 리포지토리의 기본 위치입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                            |

### `github` 컨텍스트의 예시 콘텐츠

다음 예시 컨텍스트는 `push` 이벤트에 의해 트리거되는 워크플로 실행의 컨텍스트입니다. 이 예시의 `event` 개체는 [웹후크 페이로드`push`](/ko/enterprise-server@3.22/webhooks/webhook-events-and-payloads#push)의 내용과 동일하기 때문에 잘렸습니다.

> \[!NOTE]
> 이 컨텍스트는 예제일 뿐입니다. 컨텍스트의 내용은 실행 중인 워크플로에 따라 달라집니다. 컨텍스트, 개체 및 속성은 워크플로 실행 조건마다 크게 달라집니다.

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

### `github` 컨텍스트의 사용 예시

이 예시 워크플로는 `github.event_name` 이벤트에 의해 워크플로 실행이 트리거된 경우에만 `pull_request` 컨텍스트를 사용하여 작업을 실행합니다.

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

## `env` 컨텍스트

`env` 컨텍스트에는 워크플로, 작업 또는 단계에서 설정된 변수가 포함됩니다. 실행기 프로세스가 상속하는 변수는 포함되지 않습니다. 워크플로에서 변수를 설정하는 것에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#env)을(를) 참조하세요.

`env` 컨텍스트에 저장된 변수의 값을 검색하여 워크플로 파일에서 이러한 값을 사용할 수 있습니다. 워크플로 단계의 모든 키에서 `env` 컨텍스트를 사용할 수 있습니다. 단, `id` 및 `uses` 키는 제외됩니다. 단계 구문에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps)을(를) 참조하세요.

실행기 내에서 변수 값을 사용하려면 실행기 운영 체제의 일반 메서드를 사용하여 환경 변수를 읽습니다.

| 속성 이름            | 타입       | 설명                                                                                         |
| ---------------- | -------- | ------------------------------------------------------------------------------------------ |
| `env`            | `object` | 이 컨텍스트는 작업의 각 단계에 따라 변경됩니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 속성이 포함되어 있습니다. |
| `env.<env_name>` | `string` | 특정 환경 변수의 값입니다.                                                                            |

### `env` 컨텍스트의 예시 콘텐츠

`env` 컨텍스트의 내용은 변수 이름을 해당 값에 매핑한 것입니다. 컨텍스트의 내용은 워크플로 실행에서 사용되는 위치에 따라 변경됩니다. 이 예시에서 `env` 컨텍스트에는 두 개의 변수가 포함됩니다.

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

### `env` 컨텍스트의 사용 예시

이 예시 워크플로는 워크플로, 작업, 단계 수준의 `env` 컨텍스트에서 설정되는 변수를 보여줍니다. 그런 다음 `${{ env.VARIABLE-NAME }}` 구문을 사용하여 워크플로의 개별 단계 내에서 변수 값을 검색합니다.

둘 이상의 변수가 동일한 이름으로 정의되면 GitHub는 가장 구체적인 환경 변수를 사용합니다. 예를 들어 단계에 정의된 환경 변수는 단계가 실행되는 동안 동일한 이름의 작업 및 워크플로 환경 변수를 재정의합니다. 작업에 정의된 환경 변수는 작업이 실행되는 동안 동일한 이름의 워크플로 변수를 재정의합니다.

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

## `vars` 컨텍스트

`vars` 컨텍스트에는 조직, 리포지토리, 환경 수준에서 설정된 사용자 지정 구성 변수가 포함됩니다. 여러 워크플로에서 사용할 구성 변수를 정의하는 방법에 대한 자세한 내용은 [변수에 정보 저장](/ko/enterprise-server@3.22/actions/how-tos/write-workflows/choose-what-workflows-do/use-variables#defining-configuration-variables-for-multiple-workflows)을(를) 참조하세요.

### `vars` 컨텍스트의 예시 콘텐츠

`vars` 컨텍스트의 내용은 구성 변수 이름을 해당 값에 매핑한 것입니다.

```json
{
  "mascot": "Mona"
}
```

### `vars` 컨텍스트의 사용 예시

이 예시 워크플로에서는 `vars` 컨텍스트를 사용하여 리포지토리, 환경 또는 조직 수준에서 설정된 구성 변수를 자동으로 사용할 수 있는 방법을 보여 줍니다.

> \[!NOTE]
> 환경 수준의 구성 변수는 실행기에서 해당 환경을 선언한 후에 자동으로 사용할 수 있습니다.

구성 변수가 설정되지 않은 경우, 변수를 참조하는 컨텍스트는 빈 문자열을 반환합니다.

다음 예제는 워크플로 전체에서 `vars` 컨텍스트와 함께 구성 변수를 사용하는 방법을 나타냅니다. 다음 각각의 구성 변수는 리포지토리, 조직 또는 환경 수준에서 정의되었습니다.

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

## `job` 컨텍스트

`job` 컨텍스트에는 현재 실행 중인 작업에 대한 정보가 포함됩니다.

| 속성 이름                                                                                                                                                            | 타입       | 설명                                                                                                                                                                                           |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `job`                                                                                                                                                            | `object` | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 변경됩니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                               |
|                                                                                                                                                                  |          |                                                                                                                                                                                              |
| `job.container`                                                                                                                                                  | `object` | 작업의 컨테이너에 대한 정보입니다. 컨테이너에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idcontainer)을(를) 참조하세요.         |
| `job.container.id`                                                                                                                                               | `string` | 컨테이너의 ID입니다.                                                                                                                                                                                 |
| `job.container.network`                                                                                                                                          | `string` | 컨테이너 네트워크의 ID입니다. 실행기는 작업의 모든 컨테이너에서 사용하는 네트워크를 만듭니다.                                                                                                                                        |
| `job.services`                                                                                                                                                   | `object` | 작업에 대해 생성된 서비스 컨테이너들입니다. 서비스 컨테이너에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idservices)을(를) 참조하세요. |
| `job.services.<service_id>.id`                                                                                                                                   | `string` | 서비스 컨테이너의 ID입니다.                                                                                                                                                                             |
| `job.services.<service_id>.network`                                                                                                                              | `string` | 서비스 컨테이너 네트워크의 ID입니다. 실행기는 작업의 모든 컨테이너에서 사용하는 네트워크를 만듭니다.                                                                                                                                    |
| `job.services.<service_id>.ports`                                                                                                                                | `object` | 서비스 컨테이너의 노출된 포트입니다.                                                                                                                                                                         |
| `job.status`                                                                                                                                                     | `string` | 작업의 현재 상태입니다. 가능한 값은 `success`, `failure` 또는 `cancelled`입니다.                                                                                                                                 |
| `job.workflow_ref`                                                                                                                                               | `string` | 현재 작업을 정의하는 워크플로 파일의 전체 참조입니다. 예를 들어 `octo-org/octo-repo/.github/workflows/deploy.yml@refs/heads/main`입니다. 워크플로 파일에 직접 정의된 작업의 경우 다음과 같습니다 `github.workflow_ref`.                            |
| [워크플로 재사용](/ko/enterprise-server@3.22/actions/how-tos/reuse-automations/reuse-workflows)에 정의된 작업의 경우 재사용 가능한 워크플로 파일을 참조합니다. (사용할 수 없음 GitHub Enterprise Server) |          |                                                                                                                                                                                              |
| `job.workflow_sha`                                                                                                                                               | `string` | 현재 작업을 정의하는 워크플로 파일의 커밋 SHA입니다. (사용할 수 없음 GitHub Enterprise Server)                                                                                                                          |
| `job.workflow_repository`                                                                                                                                        | `string` |                                                                                                                                                                                              |
| `owner/repo` 현재 작업을 정의하는 워크플로 파일이 포함된 리포지토리입니다. 예를 들어 `octo-org/octo-repo`입니다. (사용할 수 없음 GitHub Enterprise Server)                                               |          |                                                                                                                                                                                              |
| `job.workflow_file_path`                                                                                                                                         | `string` | 리포지토리 루트를 기준으로 현재 작업을 정의하는 워크플로 파일의 파일 경로입니다. 예를 들어 `.github/workflows/deploy.yml`입니다. (사용할 수 없음 GitHub Enterprise Server)                                                                   |

### `job` 컨텍스트의 예시 콘텐츠

이 예시 `job` 컨텍스트는 매핑된 포트가 있는 PostgreSQL 서비스 컨테이너를 사용합니다. 작업에 사용되는 컨테이너 또는 서비스 컨테이너가 없으면 컨텍스트에 `job` 만 포함됩니다 `status`.
`check_run_id` 및 워크플로 ID 속성(`workflow_ref`, `workflow_sha`, `workflow_repository`, `workflow_file_path`)은 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"
    }
  }
}
```

### `job` 컨텍스트의 사용 예시

이 예시 워크플로는 PostgreSQL 서비스 컨테이너를 구성하고 서비스 컨테이너의 포트 5432를 호스트에서 임의로 선택된 사용 가능한 포트에 자동으로 매핑합니다.
`job` 컨텍스트는 호스트에 할당된 포트 수에 액세스하는 데 사용됩니다.

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

### 컨텍스트 워크플로 ID의 `job` 예제 사용

> \[!NOTE]
> `job.workflow_*`의 컨텍스트 속성은 GitHub Enterprise Server에서 사용할 수 없습니다.

이 예제 재사용 가능 워크플로는 호출자의 리포지토리가 아닌, `job.workflow_repository` 및 `job.workflow_sha`을 사용하여 자체 소스 코드를 체크아웃합니다. 이는 재사용 가능한 워크플로가 워크플로 정의와 공동 배치된 파일에 액세스해야 하는 경우에 유용합니다.

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

## `jobs` 컨텍스트

`jobs` 컨텍스트는 재사용 가능한 워크플로에서만 사용할 수 있으며 재사용 가능한 워크플로에 대한 출력을 설정하는 데만 사용할 수 있습니다. 자세한 내용은 [워크플로 재사용](/ko/enterprise-server@3.22/actions/how-tos/reuse-automations/reuse-workflows#using-outputs-from-a-reusable-workflow)을(를) 참조하세요.

| 속성 이름                                 | 타입       | 설명                                                                                                 |
| ------------------------------------- | -------- | -------------------------------------------------------------------------------------------------- |
| `jobs`                                | `object` | 이는 재사용 가능한 워크플로에서만 사용할 수 있으며 재사용 가능한 워크플로에 대한 출력을 설정하는 데만 사용할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다. |
| `jobs.<job_id>.result`                | `string` | 재사용 가능한 워크플로의 작업 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다.                  |
| `jobs.<job_id>.outputs`               | `object` | 재사용 가능한 워크플로 작업의 출력 집합입니다.                                                                         |
| `jobs.<job_id>.outputs.<output_name>` | `string` | 재사용 가능한 워크플로의 작업에 대한 특정 출력 값입니다.                                                                   |

### `jobs` 컨텍스트의 예시 콘텐츠

이 `jobs` 컨텍스트 예시는 재사용 가능한 워크플로 실행의 작업 결과와 출력을 포함합니다.

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

### `jobs` 컨텍스트의 사용 예시

이 재사용 가능한 워크플로 예시는 `jobs` 컨텍스트를 사용하여 재사용 가능한 워크플로에 대한 출력을 설정합니다. 출력이 단계에서 작업으로, 그 다음에는 `workflow_call` 트리거로 이동하는 방식을 주목하세요. 자세한 내용은 [워크플로 재사용](/ko/enterprise-server@3.22/actions/how-tos/reuse-automations/reuse-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
```

## `steps` 컨텍스트

`steps` 컨텍스트에는 지정되어 있고 이미 실행된 [`id`](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsid) 가 있는 현재 작업의 단계에 대한 정보가 포함됩니다.

| 속성 이름                                                                                                                                                                           | 타입       | 설명                                                                                                                                                                                            |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `steps`                                                                                                                                                                         | `object` | 이 컨텍스트는 작업의 각 단계에 따라 변경됩니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                     |
| `steps.<step_id>.outputs`                                                                                                                                                       | `object` | 단계에 대해 정의된 출력 집합입니다. 자세한 내용은 [메타데이터 구문 참조](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/metadata-syntax#outputs-for-docker-container-and-javascript-actions)을(를) 참조하세요. |
| `steps.<step_id>.conclusion`                                                                                                                                                    | `string` |                                                                                                                                                                                               |
| \[                                                                                                                                                                              |          |                                                                                                                                                                                               |
| `continue-on-error`                                                                                                                                                             |          |                                                                                                                                                                                               |
| ]\(/actions/reference/workflows-and-actions/workflow-syntax#jobsjob\_idstepscontinue-on-error)가 적용된 후 완료된 단계의 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다.  |          |                                                                                                                                                                                               |
| `continue-on-error` 단계가 실패하면 `outcome`은 `failure`이지만 최종 `conclusion`은 `success`입니다.                                                                                             |          |                                                                                                                                                                                               |
| `steps.<step_id>.outcome`                                                                                                                                                       | `string` |                                                                                                                                                                                               |
| \[                                                                                                                                                                              |          |                                                                                                                                                                                               |
| `continue-on-error`                                                                                                                                                             |          |                                                                                                                                                                                               |
| ]\(/actions/reference/workflows-and-actions/workflow-syntax#jobsjob\_idstepscontinue-on-error)가 적용되기 전 완료된 단계의 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다. |          |                                                                                                                                                                                               |
| `continue-on-error` 단계가 실패하면 `outcome`은 `failure`이지만 최종 `conclusion`은 `success`입니다.                                                                                             |          |                                                                                                                                                                                               |
| `steps.<step_id>.outputs.<output_name>`                                                                                                                                         | `string` | 특정 출력의 값입니다.                                                                                                                                                                                  |

### `steps` 컨텍스트의 예시 콘텐츠

이 예시 `steps` 컨텍스트는 지정된 [`id`](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsid)가 있는 두 개의 이전 단계를 보여줍니다. 첫 번째 단계에는 `id`이라는 `checkout`가, 두 번째 단계에는 `generate_number`가 있습니다.
`generate_number` 단계에는 이름이 `random_number`인 출력이 있습니다.

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

### `steps` 컨텍스트의 사용 예시

이 예시 워크플로는 한 단계에서 난수를 출력으로 생성하고, 이후 단계에서는 `steps` 컨텍스트를 사용하여 해당 출력의 값을 읽습니다.

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

## `runner` 컨텍스트

`runner` 컨텍스트에는 현재 작업을 실행하는 실행기 정보가 포함됩니다.

| 속성 이름                | 타입       | 설명                                                                                                                                                                                                             |
| -------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `runner`             | `object` | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 변경됩니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                                                                  |
| `runner.name`        | `string` | 작업을 실행하는 실행기의 이름입니다. 실행기 이름은 리포지토리의 실행기로 워크플로 실행 시 고유하지 않을 수 있으며 조직 수준에서 동일한 이름을 사용할 수 있습니다.                                                                                                                   |
| `runner.os`          | `string` | 작업을 실행하는 실행기의 운영 체제입니다. 가능한 값은 `Linux`, `Windows`, 또는 `macOS`입니다.                                                                                                                                              |
| `runner.arch`        | `string` | 작업을 실행하는 실행기의 아키텍처입니다. 가능한 값은 `X86`, `X64`, `ARM`, `ARM64`입니다.                                                                                                                                                 |
| `runner.temp`        | `string` | 실행기의 임시 디렉터리에 대한 경로입니다. 이 디렉터리는 각 작업의 시작과 끝에 비워집니다. 실행기 사용자 계정에 삭제 권한이 없는 경우 파일이 제거되지 않습니다.                                                                                                                    |
| `runner.tool_cache`  | `string` | GitHub에서 호스팅되는 실행기에 사전 설치된 도구가 들어 있는 디렉터리의 경로입니다. 자세한 내용은 [GitHub 호스팅 실행기](/ko/enterprise-server@3.22/actions/concepts/runners/github-hosted-runners#preinstalled-software-for-github-owned-images)을(를) 참조하세요. |
| `runner.debug`       | `string` | [디버그 로깅](/ko/enterprise-server@3.22/actions/how-tos/monitor-workflows/enable-debug-logging)을 사용하도록 설정한 경우에만 설정되며 항상 값이 `1`입니다. 사용자 고유의 작업 단계에서 추가 디버깅 또는 자세한 로깅을 사용하도록 설정하는 지표로 유용할 수 있습니다.                    |
| `runner.environment` | `string` | 작업을 실행하는 실행기의 환경입니다. 가능한 값은 GitHub에서 제공하는 GitHub 호스트형 실행기의 경우 `github-hosted`, 리포지토리 소유자가 구성한 자체 호스트형 실행기의 경우 `self-hosted`입니다.                                                                                |

### `runner` 컨텍스트의 예시 콘텐츠

다음 예제 컨텍스트는 Linux GitHub호스팅 실행기에서 가져옵니다.

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

### `runner` 컨텍스트의 사용 예시

이 예시 워크플로는 `runner` 컨텍스트를 사용하여 임시 디렉터리의 경로를 설정하여 로그를 작성하고, 워크플로가 실패하면 해당 로그를 아티팩트로 업로드합니다.

```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@v3
        with:
          name: Build failure logs
          path: ${{ runner.temp }}/build_logs
```

## `secrets` 컨텍스트

`secrets` 컨텍스트는 워크플로 실행에 사용할 수 있는 비밀의 이름과 값을 포함합니다. 보안상의 이유로 복합 작업에는 `secrets` 컨텍스트를 사용할 수 없습니다. 복합 작업에 비밀을 전달하려는 경우 명시적으로 입력을 통해 수행해야 합니다. 비밀에 대한 자세한 내용은 [GitHub Actions에서 비밀 사용](/ko/enterprise-server@3.22/actions/how-tos/write-workflows/choose-what-workflows-do/use-secrets)을(를) 참조하세요.

`GITHUB_TOKEN`은 모든 워크플로 실행에 대해 자동으로 만들어지고 항상 `secrets` 컨텍스트에 포함되는 비밀입니다. 자세한 내용은 [워크플로에서 인증에 GITHUB\_TOKEN 사용](/ko/enterprise-server@3.22/actions/tutorials/authenticate-with-github_token)을(를) 참조하세요.

> \[!WARNING]
> 워크플로 작업에서 비밀이 사용된 경우 GitHub은 로그에 출력된 비밀을 자동으로 수정합니다. 의도적으로 로그에 비밀을 출력하지 않아야 합니다.

| 속성 이름                   | 타입       | 설명                                                                                                                                                          |
| ----------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `secrets`               | `object` | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 동일합니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                              |
| `secrets.GITHUB_TOKEN`  | `string` | 각 워크플로 실행에 대해 자동으로 생성된 토큰입니다. 자세한 내용은 [워크플로에서 인증에 GITHUB\_TOKEN 사용](/ko/enterprise-server@3.22/actions/tutorials/authenticate-with-github_token)을(를) 참조하세요. |
| `secrets.<secret_name>` | `string` | 특정 비밀의 값입니다.                                                                                                                                                |

### `secrets` 컨텍스트의 예시 콘텐츠

`secrets` 컨텍스트의 다음 예시 콘텐츠는 자동 `GITHUB_TOKEN` 및 워크플로 실행에 사용할 수 있는 두 개의 다른 비밀을 보여줍니다.

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

### `secrets` 컨텍스트의 사용 예시

이 예제 워크플로는 [GitHub CLI](/ko/enterprise-server@3.22/actions/how-tos/write-workflows/choose-what-workflows-do/use-github-cli)를 사용하며, 이 경우 `GITHUB_TOKEN` 입력 매개 변수의 값으로 `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 }}
```

## `strategy` 컨텍스트

행렬이 있는 워크플로의 경우 `strategy` 컨텍스트에는 현재 작업에 대한 행렬 실행 전략에 대한 정보가 포함됩니다.

| 속성 이름                                                                                                                                                                                                             | 타입        | 설명                                                                                                                                                                                                                    |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `strategy`                                                                                                                                                                                                        | `object`  | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 변경됩니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                                |
| `strategy.fail-fast`                                                                                                                                                                                              | `boolean` | 이 값이 `true`로 평가되는 경우 행렬의 작업이 실패하면 진행 중인 모든 작업이 취소됩니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategyfail-fast)을(를) 참조하세요. |
| `strategy.job-index`                                                                                                                                                                                              | `number`  | 현재 작업의 행렬 인덱스입니다.                                                                                                                                                                                                     |
| **참고:** 이 숫자는 0부터 시작합니다. 행렬의 첫 번째 작업 인덱스는 `0`입니다.                                                                                                                                                                 |           |                                                                                                                                                                                                                       |
| `strategy.job-total`                                                                                                                                                                                              | `number`  | 행렬의 총 작업 수입니다.                                                                                                                                                                                                        |
| **참고:** 이 숫자는 0부터 시작하지 **않습니다**. 예를 들어 네 개의 작업이 있는 행렬의 경우 `job-total`의 값은 `4`입니다.                                                                                                                                 |           |                                                                                                                                                                                                                       |
| `strategy.max-parallel`                                                                                                                                                                                           | `number`  |                                                                                                                                                                                                                       |
| `matrix` 작업 전략을 사용할 때 동시에 실행할 수 있는 최대 작업 수입니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategymax-parallel)을(를) 참조하세요. |           |                                                                                                                                                                                                                       |

### `strategy` 컨텍스트의 예시 콘텐츠

`strategy` 컨텍스트의 다음 예시 콘텐츠는 4개의 작업이 있는 행렬에서 가져온 것이며 최종 작업에서 가져옵니다. 0부터 시작하는 `job-index` 숫자와 0부터 시작하지 않는 `job-total` 사이의 차이를 확인합니다.

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

### `strategy` 컨텍스트의 사용 예시

이 예시 워크플로에서는 `strategy.job-index` 속성을 사용하여 행렬의 각 작업에 대한 로그 파일의 고유한 이름을 설정합니다.

```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@v3
        with:
          name: Build log for job ${{ strategy.job-index }}
          path: test-job-${{ strategy.job-index }}.txt
```

## `matrix` 컨텍스트

행렬이 있는 워크플로의 경우 `matrix` 컨텍스트에는 현재 작업에 적용되는 워크플로 파일에 정의된 행렬 속성이 포함됩니다. 예를 들어 `os` 및 `node` 키와 함께 행렬을 구성하는 경우 `matrix` 컨텍스트 개체에는 현재 작업에 사용되는 값과 함께 `os` 및 `node` 속성이 포함됩니다.

`matrix` 컨텍스트에는 표준 속성이 없으며 워크플로 파일에 정의된 속성만 있습니다.

| 속성 이름                    | 타입       | 설명                                                                                                                                |
| ------------------------ | -------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `matrix`                 | `object` | 이 컨텍스트는 행렬의 작업 및 워크플로 실행의 각 작업에 대한 변경 내용에 대해서만 사용할 수 있습니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 속성이 포함되어 있습니다. |
| `matrix.<property_name>` | `string` | 행렬 속성의 값입니다.                                                                                                                      |

### `matrix` 컨텍스트의 예시 콘텐츠

`matrix` 컨텍스트의 다음 예시 콘텐츠는 워크플로에 정의된 `os` 행렬 속성과 `node` 행렬 속성이 있는 행렬의 작업에서 가져옵니다. 작업은 `ubuntu-latest` OS와 Node.js 버전 `16`의 매트릭스 조합을 실행합니다.

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

### `matrix` 컨텍스트의 사용 예시

이 예시 워크플로는 `os` 및 `node` 키와 함께 행렬을 만듭니다.
`matrix.os` 속성을 사용하여 각 작업에 대한 실행기 유형을 설정하고, `matrix.node` 속성을 사용하여 각 작업에 대한 Node.js 버전을 설정합니다.

```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@v7
        with:
          node-version: ${{ matrix.node }}
      - name: Output node version
        run: node --version
```

## `needs` 컨텍스트

`needs` 컨텍스트는 현재 작업의 직접적인 종속성으로 정의된 모든 작업으로부터의 출력을 포함합니다. 여기에는 암시적으로 종속된 작업(예시: 종속 작업의 종속 작업)이 포함되지 않는다는 점에 유의하세요. 작업 종속성 정의에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idneeds)을(를) 참조하세요.

| 속성 이름                                  | 타입       | 설명                                                                                                                                    |
| -------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `needs`                                | `object` | 이 컨텍스트는 종속 작업이 있는 워크플로 실행과 워크플로 실행의 각 작업에 대한 변경 내용에 대해서만 채워집니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다. |
| `needs.<job_id>`                       | `object` | 현재 작업이 의존하는 하나의 작업입니다.                                                                                                                |
| `needs.<job_id>.outputs`               | `object` | 현재 작업이 의존하는 작업의 출력 집합입니다.                                                                                                             |
| `needs.<job_id>.outputs.<output name>` | `string` | 현재 작업이 의존하는 작업에 대한 특정 출력의 값입니다.                                                                                                       |
| `needs.<job_id>.result`                | `string` | 현재 작업이 의존하는 작업의 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다.                                                      |

### `needs` 컨텍스트의 예시 콘텐츠

`needs` 컨텍스트의 다음 예시 콘텐츠는 현재 작업이 의존하는 두 가지 작업에 대한 정보를 보여줍니다.

```json
{
  "build": {
    "result": "success",
    "outputs": {
      "build_id": "123456"
    }
  },
  "deploy": {
    "result": "failure",
    "outputs": {}
  }
}
```

### `needs` 컨텍스트의 사용 예시

이 예시 워크플로에는 세 가지 작업, 즉 빌드를 수행하는 `build` 작업, `deploy` 작업이 필요한 `build` 작업, `debug` 및 `build` 작업이 모두 필요하고 워크플로에 오류가 있는 경우에만 실행되는 `deploy` 작업이 있습니다. 또한 `deploy` 작업은 `needs` 컨텍스트를 사용하여 `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"
```

## `inputs` 컨텍스트

`inputs` 컨텍스트에는 작업, 재사용 가능한 워크플로 또는 수동으로 트리거된 워크플로에 전달되는 입력 속성을 포함합니다. 재사용 가능한 워크플로의 경우 입력 이름 및 형식은 재사용 가능한 워크플로의 [`workflow_call` 이벤트 구성](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/events-that-trigger-workflows)에 정의되며, 입력 값은 재사용 가능한 워크플로를 호출하는 외부 워크플로의 [`jobs.<job_id>.with`](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idwith)에서 전달됩니다. 수동으로 트리거된 워크플로의 경우 입력은 워크플로의 [`workflow_dispatch` 이벤트 구성](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_dispatch)에 정의됩니다.

`inputs` 컨텍스트의 속성은 워크플로 파일에 정의되어 있습니다. 이 속성은 [재사용 가능한 워크플로](/ko/enterprise-server@3.22/actions/how-tos/reuse-automations/reuse-workflows) 또는 [`workflow_dispatch` 이벤트](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_dispatch)에 의해 트리거된 워크플로에서만 사용할 수 있습니다.

| 속성 이름                                     | 타입                       | 설명                                                                                                                                                                                                                                                                                                                                                        |
| ----------------------------------------- | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `inputs`                                  | `object`                 | 이 컨텍스트는 [재사용 가능한 워크플로](/ko/enterprise-server@3.22/actions/how-tos/reuse-automations/reuse-workflows) 또는 [`workflow_dispatch` 이벤트](/ko/enterprise-server@3.22/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_dispatch)에 의해 트리거된 워크플로에서만 사용할 수 있습니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 속성이 포함되어 있습니다. |
| `inputs.<name>`                           |                          |                                                                                                                                                                                                                                                                                                                                                           |
| `string`, `number`, `boolean` 또는 `choice` | 외부 워크플로에서 전달된 각 입력 값입니다. |                                                                                                                                                                                                                                                                                                                                                           |

### `inputs` 컨텍스트의 예시 콘텐츠

`inputs` 컨텍스트의 다음 예시 콘텐츠는 `build_id`, `deploy_target` 및 `perform_deploy` 입력을 정의한 워크플로에서 가져온 것입니다.

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

### 재사용 가능한 워크플로의 `inputs` 컨텍스트 사용 예시

이 예시에서 재사용 가능한 워크플로는 `inputs` 컨텍스트를 사용하여 호출자 워크플로에서 재사용 가능한 워크플로에 전달된 `build_id`, `deploy_target` 및 `perform_deploy` 입력의 값을 가져옵니다.

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

### 수동으로 트리거된 워크플로의 `inputs` 컨텍스트 사용 예시

`workflow_dispatch` 이벤트에서 트리거된 이 예시 워크플로는 `inputs` 컨텍스트를 사용하여 워크플로에 전달된 `build_id`, `deploy_target` 및 `perform_deploy` 입력의 값을 가져옵니다.

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

## 추가 참고 자료

* [컨텍스트](/ko/enterprise-server@3.22/actions/concepts/workflows-and-actions/contexts)