{"meta":{"title":"문맥 참조","intro":"사용 가능한 속성, 액세스 방법 및 사용 예제를 포함하여 워크플로에서 GitHub Actions 사용할 수 있는 컨텍스트에 대한 정보를 찾습니다.","product":"GitHub Actions","breadcrumbs":[{"href":"/ko/enterprise-cloud@latest/actions","title":"GitHub Actions"},{"href":"/ko/enterprise-cloud@latest/actions/reference","title":"참조"},{"href":"/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions","title":"워크플로 및 작업"},{"href":"/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/contexts","title":"컨텍스트"}],"documentType":"article"},"body":"# 문맥 참조\n\n사용 가능한 속성, 액세스 방법 및 사용 예제를 포함하여 워크플로에서 GitHub Actions 사용할 수 있는 컨텍스트에 대한 정보를 찾습니다.\n\n## 사용 가능한 컨텍스트\n\n| 컨텍스트 이름    | 타입       | 설명                                                                                           |\n| ---------- | -------- | -------------------------------------------------------------------------------------------- |\n| `github`   | `object` | 워크플로 실행에 대한 정보입니다. 자세한 내용은 [`github`컨텍스트](#github-context)를 참조하세요.                           |\n| `env`      | `object` | 워크플로, 작업 또는 단계에 설정된 변수를 포함합니다. 자세한 내용은 [`env`컨텍스트](#env-context)를 참조하세요.                     |\n| `vars`     | `object` | 리포지토리, 조직 또는 환경 수준에서 설정된 변수를 포함합니다. 자세한 내용은 [`vars`컨텍스트](#vars-context)를 참조하세요.              |\n| `job`      | `object` | 현재 실행 중인 작업에 대한 정보입니다. 자세한 내용은 [`job`컨텍스트](#job-context)를 참조하세요.                             |\n| `jobs`     | `object` | 재사용 가능한 워크플로에만 해당하며, 재사용 가능한 워크플로의 작업 출력을 포함합니다. 자세한 내용은 [`jobs`컨텍스트](#jobs-context)를 참조하세요. |\n| `steps`    | `object` | 현재 작업에서 실행된 단계에 대한 정보입니다. 자세한 내용은 [`steps`컨텍스트](#steps-context)를 참조하세요.                      |\n| `runner`   | `object` | 현재 작업을 실행하는 실행기 정보입니다. 자세한 내용은 [`runner`컨텍스트](#runner-context)를 참조하세요.                       |\n| `secrets`  | `object` | 워크플로 실행에 사용할 수 있는 비밀의 이름과 값을 포함합니다. 자세한 내용은 [`secrets`컨텍스트](#secrets-context)를 참조하세요.        |\n| `strategy` | `object` | 현재 작업에 대한 행렬 실행 전략에 대한 정보. 자세한 내용은 [`strategy`컨텍스트](#strategy-context)를 참조하세요.               |\n| `matrix`   | `object` | 현재 작업에 적용되는 워크플로에 정의된 행렬 속성을 포함합니다. 자세한 내용은 [`matrix`컨텍스트](#matrix-context)를 참조하세요.          |\n| `needs`    | `object` | 현재 작업의 종속성으로 정의된 모든 작업의 ​​출력을 포함합니다. 자세한 내용은 [`needs`컨텍스트](#needs-context)를 참조하세요.           |\n| `inputs`   | `object` | 재사용 가능하거나 수동으로 트리거되는 워크플로의 입력을 포함합니다. 자세한 내용은 [`inputs`컨텍스트](#inputs-context)를 참조하세요.        |\n\n식의 일부로 두 구문 중 하나를 사용하여 컨텍스트 정보에 액세스할 수 있습니다.\n\n* 인덱스 구문: `github['sha']`\n* 속성 역참조 구문: `github.sha`\n\n속성 역참조 구문을 사용하려면 속성 이름이 문자 또는 `_`로 시작하거나 영숫자 문자, `-` 또는 `_`만 포함해야 합니다.\n\n존재하지 않는 속성을 역참조하려고 하면 빈 문자열로 평가됩니다.\n\n### 컨텍스트를 사용할 시기 결정\n\nGitHub Actions 에는 *컨텍스트* 라는 변수 컬렉션과 기본 변수라는 유사한 변수 컬렉션 *이 포함되어 있습니다*. 이러한 변수는 워크플로의 여러 지점에서 사용하기 위한 것입니다.\n\n* **기본 환경 변수:** 이러한 환경 변수는 작업을 실행하는 실행기에서만 존재합니다. 자세한 내용은 [변수 참조](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/variables)을(를) 참조하세요.\n* 컨텍스트: **기본 변수**를 사용할 수 없는 경우를 비롯한 대부분의 컨텍스트를 워크플로의 모든 지점에서 사용할 수 있습니다. 예를 들어 작업이 실행을 위해 실행기로 라우팅되기 전에 식과 함께 컨텍스트를 사용하여 초기 처리를 수행할 수 있습니다. 이렇게 하면 조건부 `if` 키워드가 포함된 컨텍스트를 사용하여 단계를 실행할지 여부를 결정할 수 있습니다. 작업이 실행되면 작업을 실행하는 실행기에서 컨텍스트 변수를 검색할 수도 있습니다(예시: `runner.os`). 워크플로 내에서 다양한 컨텍스트를 사용할 수 있는 위치에 대한 자세한 내용은 [컨텍스트 가용성](#context-availability)을 참조하세요.\n\n다음 예시에서는 이러한 다양한 유형의 변수를 작업에서 함께 사용하는 방법을 보여 줍니다.\n\n```yaml copy\nname: CI\non: push\njobs:\n  prod-check:\n    if: ${{ github.ref == 'refs/heads/main' }}\n    runs-on: ubuntu-latest\n    steps:\n      - run: echo \"Deploying to production server on branch $GITHUB_REF\"\n```\n\n이 예시에서 `if` 문은 [`github.ref`](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/contexts#github-context) 컨텍스트를 검사하여 현재 분기 이름을 확인합니다. 이름이 `refs/heads/main`이면 후속 단계가 실행됩니다.\n`if` 검사는 GitHub Actions에 의해 처리되며, 결과가 `true`일 경우에만 작업이 실행기로 전송됩니다. 작업이 실행기로 전송되면 단계가 실행되고 실행기의 [`$GITHUB_REF`](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/variables) 변수를 참조합니다.\n\n### 컨텍스트 가용성\n\n워크플로 실행 전체에서 다양한 컨텍스트를 사용할 수 있습니다. 예를 들어 `secrets` 컨텍스트는 작업 내의 특정 위치에서만 사용할 수 있습니다.\n\n또한 일부 함수는 특정 위치에서만 사용할 수 있습니다. 예를 들어 `hashFiles` 함수는 아무 데서도 사용할 수 없습니다.\n\n다음 표에는 워크플로 내에서 각 컨텍스트 및 특수 함수를 사용할 수 있는 위치에 대한 제한 사항이 나열되어 있습니다. 나열된 컨텍스트는 지정된 워크플로 키에 대해서만 사용할 수 있으며 다른 곳에는 사용할 수 없습니다. 아래에 나열되어 있지 않은 함수는 어디에서나 사용할 수 있습니다.\n\n| 워크플로 키                                             | 컨텍스트                                                                              | 특수 함수                                            |\n| -------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------ |\n| `run-name`                                         | `github, inputs, vars`                                                            | None                                             |\n| `concurrency`                                      | `github, inputs, vars`                                                            | None                                             |\n| `env`                                              | `github, secrets, inputs, vars`                                                   | None                                             |\n| `jobs.<job_id>.concurrency`                        | `github, needs, strategy, matrix, inputs, vars`                                   | None                                             |\n| `jobs.<job_id>.container`                          | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |\n| `jobs.<job_id>.container.credentials`              | `github, needs, strategy, matrix, env, vars, secrets, inputs`                     | None                                             |\n| `jobs.<job_id>.container.env.<env_id>`             | `github, needs, strategy, matrix, job, runner, env, vars, secrets, inputs`        | None                                             |\n| `jobs.<job_id>.container.image`                    | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |\n| `jobs.<job_id>.continue-on-error`                  | `github, needs, strategy, vars, matrix, inputs`                                   | None                                             |\n| `jobs.<job_id>.defaults.run`                       | `github, needs, strategy, matrix, env, vars, inputs`                              | None                                             |\n| `jobs.<job_id>.env`                                | `github, needs, strategy, matrix, vars, secrets, inputs`                          | None                                             |\n| `jobs.<job_id>.environment`                        | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |\n| `jobs.<job_id>.environment.url`                    | `github, needs, strategy, matrix, job, runner, env, vars, steps, inputs`          | None                                             |\n| `jobs.<job_id>.if`                                 | `github, needs, vars, inputs`                                                     | `always, cancelled, success, failure`            |\n| `jobs.<job_id>.name`                               | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |\n| `jobs.<job_id>.outputs.<output_id>`                | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | None                                             |\n| `jobs.<job_id>.runs-on`                            | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |\n| `jobs.<job_id>.secrets.<secrets_id>`               | `github, needs, strategy, matrix, secrets, inputs, vars`                          | None                                             |\n| `jobs.<job_id>.services`                           | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |\n| `jobs.<job_id>.services.<service_id>.credentials`  | `github, needs, strategy, matrix, env, vars, secrets, inputs`                     | None                                             |\n| `jobs.<job_id>.services.<service_id>.env.<env_id>` | `github, needs, strategy, matrix, job, runner, env, vars, secrets, inputs`        | None                                             |\n| `jobs.<job_id>.steps.continue-on-error`            | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |\n| `jobs.<job_id>.steps.env`                          | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |\n| `jobs.<job_id>.steps.if`                           | `github, needs, strategy, matrix, job, runner, env, vars, steps, inputs`          | `always, cancelled, success, failure, hashFiles` |\n| `jobs.<job_id>.steps.name`                         | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |\n| `jobs.<job_id>.steps.run`                          | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |\n| `jobs.<job_id>.steps.timeout-minutes`              | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |\n| `jobs.<job_id>.steps.with`                         | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |\n| `jobs.<job_id>.steps.working-directory`            | `github, needs, strategy, matrix, job, runner, env, vars, secrets, steps, inputs` | `hashFiles`                                      |\n| `jobs.<job_id>.strategy`                           | `github, needs, vars, inputs`                                                     | None                                             |\n| `jobs.<job_id>.timeout-minutes`                    | `github, needs, strategy, matrix, vars, inputs`                                   | None                                             |\n| `jobs.<job_id>.with.<with_id>`                     | `github, needs, strategy, matrix, inputs, vars`                                   | None                                             |\n| `on.workflow_call.inputs.<inputs_id>.default`      | `github, inputs, vars`                                                            | None                                             |\n| `on.workflow_call.outputs.<output_id>.value`       | `github, jobs, vars, inputs`                                                      | None                                             |\n\n### 예시: 로그에 컨텍스트 정보 출력\n\n디버깅을 위해 컨텍스트의 콘텐츠를 로그에 출력할 수 있습니다.\n[\n`toJSON` 함수](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/expressions#tojson)는 JSON 개체를 로그에 출력하는 데 필요합니다.\n\n> \\[!WARNING]\n> 전체 `github` 컨텍스트를 사용할 때는 중요한 정보(예: `github.token`)가 포함된다는 점을 염두에 두어야 합니다. GitHub은(는) 비밀을 콘솔에 인쇄할 때 마스킹하지만 컨텍스트를 내보내거나 인쇄할 때는 주의해야 합니다.\n\n```yaml copy\nname: Context testing\non: push\n\njobs:\n  dump_contexts_to_log:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Dump GitHub context\n        env:\n          GITHUB_CONTEXT: ${{ toJson(github) }}\n        run: echo \"$GITHUB_CONTEXT\"\n      - name: Dump job context\n        env:\n          JOB_CONTEXT: ${{ toJson(job) }}\n        run: echo \"$JOB_CONTEXT\"\n      - name: Dump steps context\n        env:\n          STEPS_CONTEXT: ${{ toJson(steps) }}\n        run: echo \"$STEPS_CONTEXT\"\n      - name: Dump runner context\n        env:\n          RUNNER_CONTEXT: ${{ toJson(runner) }}\n        run: echo \"$RUNNER_CONTEXT\"\n      - name: Dump strategy context\n        env:\n          STRATEGY_CONTEXT: ${{ toJson(strategy) }}\n        run: echo \"$STRATEGY_CONTEXT\"\n      - name: Dump matrix context\n        env:\n          MATRIX_CONTEXT: ${{ toJson(matrix) }}\n        run: echo \"$MATRIX_CONTEXT\"\n```\n\n## `github` 컨텍스트\n\n`github` 컨텍스트에는 워크플로 실행 및 실행을 트리거한 이벤트에 대한 정보가 포함됩니다. 환경 변수에서 대부분의 `github` 컨텍스트 데이터를 읽을 수 있습니다. 환경 변수에 대한 자세한 내용은 [변수에 정보 저장](/ko/enterprise-cloud@latest/actions/how-tos/write-workflows/choose-what-workflows-do/use-variables)을(를) 참조하세요.\n\n> \\[!WARNING]\n> 전체 `github` 컨텍스트를 사용할 때는 중요한 정보(예: `github.token`)가 포함된다는 점을 염두에 두어야 합니다. GitHub은(는) 비밀을 콘솔에 인쇄할 때 마스킹하지만 컨텍스트를 내보내거나 인쇄할 때는 주의해야 합니다.\n> \\[!WARNING]\n> 워크플로와 작업을 만들 때는 코드가 공격자의 신뢰할 수 없는 입력을 실행할 수 있는지 항상 고려해야 합니다. 특정 컨텍스트는 공격자가 자신의 악성 콘텐츠를 삽입할 수 있으므로 신뢰할 수 없는 입력으로 취급해야 합니다. 자세한 내용은 [안전 사용 참조](/ko/enterprise-cloud@latest/actions/reference/security/secure-use#good-practices-for-mitigating-script-injection-attacks)을(를) 참조하세요.\n\n| 속성 이름                                                                                                                                                                                                                                                                                        | 타입        | 설명                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |\n| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `github`                                                                                                                                                                                                                                                                                     | `object`  | 워크플로의 모든 작업 또는 단계 중에 사용할 수 있는 최상위 컨텍스트입니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |\n| `github.action`                                                                                                                                                                                                                                                                              | `string`  | 현재 실행 중인 작업의 이름 또는 단계의 [`id`](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsid)입니다.                                                                                                                                                                                                                                                                                                                                                                                                            |\n| GitHub는 특수 문자를 제거하고, 현재 단계에서 `__run` 없이 스크립트를 실행할 때 이름`id`을 사용합니다. 동일한 작업에서 동일한 동작을 두 번 이상 사용하는 경우 이름 앞에 밑줄이 있는 시퀀스 번호가 있는 접미사가 포함됩니다. 예를 들어 실행하는 첫 번째 스크립트에는 이름이 `__run`으로 지정되고 두 번째 스크립트의 이름은 `__run_2`로 지정됩니다. 마찬가지로 두 번째 `actions/checkout` 호출은 `actionscheckout2`입니다.                   |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |\n| `github.action_path`                                                                                                                                                                                                                                                                         | `string`  | 작업이 수행되는 경로입니다. 이 속성은 복합 작업에서만 지원됩니다. 이 경로를 사용하여 작업과 동일한 리포지토리에 있는 파일에 액세스할 수 있습니다(예: 해당 환경 변수 `cd \"$GITHUB_ACTION_PATH\"`를 사용하여 경로로 디렉터리를 변경). 환경 변수에 대한 자세한 내용은 [안전 사용 참조](/ko/enterprise-cloud@latest/actions/reference/security/secure-use#use-an-intermediate-environment-variable)을 참조하세요.                                                                                                                                                                                                                                                     |\n| `github.action_ref`                                                                                                                                                                                                                                                                          | `string`  | 작업을 실행하는 단계의 경우, 실행 중인 작업의 참조 식별자입니다. 예를 들어 `v2`입니다.<br><br>`run` 키워드를 사용하지 마세요. 이 컨텍스트를 복합 작업에서 작동하도록 하려면 복합 작업의 `env` 컨텍스트 내에서 참조합니다.                                                                                                                                                                                                                                                                                                                                                                                                             |\n| `github.action_repository`                                                                                                                                                                                                                                                                   | `string`  | 작업을 실행하는 단계의 경우 작업의 소유자 및 리포지토리 이름입니다. 예를 들어 `actions/checkout`입니다.<br><br>`run` 키워드를 사용하지 마세요. 이 컨텍스트를 복합 작업에서 작동하도록 하려면 복합 작업의 `env` 컨텍스트 내에서 참조합니다.                                                                                                                                                                                                                                                                                                                                                                                              |\n| `github.action_status`                                                                                                                                                                                                                                                                       | `string`  | 복합 작업의 경우 복합 작업의 현재 결과입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |\n| `github.actor`                                                                                                                                                                                                                                                                               | `string`  | 처음 워크플로 실행을 트리거한 사용자의 사용자 이름입니다. 워크플로 실행이 다시 실행인 경우 이 값은 `github.triggering_actor`와 다를 수 있습니다. 다시 실행을 시작하는 행위자(`github.actor`)가 다른 권한을 갖고 있더라도 모든 워크플로 다시 실행은 `github.triggering_actor`의 권한을 사용합니다.                                                                                                                                                                                                                                                                                                                                                 |\n| `github.actor_id`                                                                                                                                                                                                                                                                            | `string`  | 최초로 워크플로 실행을 트리거한 사용자 또는 앱의 계정 ID입니다. 예를 들어 `1234567`입니다. 행위자 사용자 이름과는 다릅니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |\n| `github.api_url`                                                                                                                                                                                                                                                                             | `string`  | REST API의 GitHub URL입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |\n|                                                                                                                                                                                                                                                                                              |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |\n| `github.artifacts`                                                                                                                                                                                                                                                                           | `string`  | 현재 단계의 워크플로 아티팩트 식별 파일에 대한 실행기 경로입니다. 파일 또는 OCI 다이제스트 참조를 워크플로 아티팩트로 식별하기 위해 한 줄당 하나의 선언을 작성합니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 명령](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-commands#declaring-workflow-artifacts)을(를) 참조하세요.                                                                                                                                                                                                                                                                                |\n| `github.artifacts_list`                                                                                                                                                                                                                                                                      | `string`  | 현재 작업에 대한 집계된 워크플로 아티팩트 메타데이터를 JSON으로 포함하는 읽기 전용 파일의 실행기 경로입니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 명령](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-commands#reading-workflow-artifacts)을(를) 참조하세요.                                                                                                                                                                                                                                                                                                                   |\n|                                                                                                                                                                                                                                                                                              |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |\n| `github.base_ref`                                                                                                                                                                                                                                                                            | `string`  | 워크플로 실행에서 풀 리퀘스트의 `base_ref` 또는 타겟 브랜치입니다. 이 속성은 워크플로 실행을 트리거하는 이벤트가 `pull_request` 또는 `pull_request_target`인 경우에만 사용할 수 있습니다.                                                                                                                                                                                                                                                                                                                                                                                                                      |\n| `github.env`                                                                                                                                                                                                                                                                                 | `string`  | 실행기에서 워크플로 명령의 환경 변수를 설정하는 파일의 경로입니다. 이 파일은 현재 단계에 고유하며 작업의 각 단계에 대해 다른 파일입니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 명령](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-commands#setting-an-environment-variable)을(를) 참조하세요.                                                                                                                                                                                                                                                                                               |\n| `github.event`                                                                                                                                                                                                                                                                               | `object`  | 전체 이벤트 웹후크 페이로드입니다. 이 컨텍스트를 사용하여 이벤트의 개별 속성에 액세스할 수 있습니다. 이 개체는 워크플로 실행을 트리거한 이벤트의 웹후크 페이로드와 동일하며 각 이벤트에 대해 다릅니다. 각 GitHub Actions 이벤트에 대한 웹후크는 [워크플로를 트리거하는 이벤트](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_call)로 연결됩니다. 예를 들어 [`push` 이벤트](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/events-that-trigger-workflows#push)에 의해 트리거되는 워크플로 실행의 경우 이 개체에는 [푸시 웹후크 페이로드](/ko/enterprise-cloud@latest/webhooks/webhook-events-and-payloads#push)의 내용이 포함됩니다. |\n| `github.event_name`                                                                                                                                                                                                                                                                          | `string`  | 워크플로 실행을 트리거한 이벤트의 이름입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |\n| `github.event_path`                                                                                                                                                                                                                                                                          | `string`  | 전체 이벤트 웹후크 페이로드가 포함된 실행기에서 파일의 경로입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |\n| `github.graphql_url`                                                                                                                                                                                                                                                                         | `string`  | GraphQL API의 GitHub URL입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |\n| `github.head_ref`                                                                                                                                                                                                                                                                            | `string`  | 워크플로 실행에서 끌어오기 요청의 `head_ref` 또는 소스 분기입니다. 이 속성은 워크플로 실행을 트리거하는 이벤트가 `pull_request` 또는 `pull_request_target`인 경우에만 사용할 수 있습니다.                                                                                                                                                                                                                                                                                                                                                                                                                      |\n| `github.job`                                                                                                                                                                                                                                                                                 | `string`  | 현재 작업의 [`job_id`](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_id)입니다. <br /> 참고: 이 컨텍스트 속성은 Actions 실행기에서 설정되며 작업의 실행 `steps` 내에서만 사용할 수 있습니다. 그렇지 않으면 이 속성의 값이 `null`이 됩니다.                                                                                                                                                                                                                                                                                                                        |\n| `github.path`                                                                                                                                                                                                                                                                                | `string`  | 워크플로 명령에서 시스템 `PATH` 변수를 설정하는 파일의 러너 경로입니다. 이 파일은 현재 단계에 고유하며 작업의 각 단계에 대해 다른 파일입니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 명령](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-commands#adding-a-system-path)을(를) 참조하세요.                                                                                                                                                                                                                                                                                                    |\n| `github.ref`                                                                                                                                                                                                                                                                                 | `string`  | 워크플로 실행을 트리거한 분기 또는 태그의 완전한 형식 참조 입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |\n| `push`에 의해 트리거된 워크플로의 경우 푸시된 분기 또는 태그 참조입니다. 병합되지 않은 `pull_request`가 트리거한 워크플로의 경우, 이는 끌어오기 요청 병합 분기입니다. 끌어오기 요청이 병합된 경우 병합된 분기가 여기에 해당됩니다.                                                                                                                                                  |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |\n| `release`에 의해 트리거된 워크플로의 경우 생성된 릴리스 태그입니다. 다른 트리거의 경우 워크플로 실행을 트리거한 분기 또는 태그 참조입니다. 이벤트 유형에 대해 분기 또는 태그를 사용할 수 있는 경우에만 설정됩니다. 지정된 참조는 완전한 형식을 가집니다. 즉, 분기의 형식은 `refs/heads/<branch_name>`입니다. 병합되지 않은 경우를 제외하고 `pull_request_target` 끌어오기 요청 이벤트의 경우는 다음과 입니다 `refs/pull/<pr_number>/merge`. |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |\n| `pull_request_target` 이벤트에는 베이스 분기의 `ref`가 있습니다. 태그의 경우에는 `refs/tags/<tag_name>`입니다. 예를 들어 `refs/heads/feature-branch-1`입니다. 끌어오기 요청 병합 분기에 대한 자세한 내용은 [끌어오기 요청](/ko/enterprise-cloud@latest/pull-requests/reference/pull-requests#pull-request-refs-and-merge-branches)을 참조하세요.             |           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |\n| `github.ref_name`                                                                                                                                                                                                                                                                            | `string`  | 워크플로 실행을 트리거한 분기 또는 태그입니다. 해당 값은 GitHub에 표시된 분기 또는 태그 이름과 일치합니다. 예를 들어 `feature-branch-1`입니다.<br><br>병합되지 않은 끌어오기 요청의 경우 형식은 .입니다 `<pr_number>/merge`.                                                                                                                                                                                                                                                                                                                                                                                              |\n| `github.ref_protected`                                                                                                                                                                                                                                                                       | `boolean` | 분기 보호가 또는 [규칙 집합](/ko/enterprise-cloud@latest/repositories/configuring-branches-and-merges-in-your-repository/managing-rulesets/managing-rulesets-for-a-repository)이 워크플로 실행을 트리거한 ref에 대해 구성된 경우 `true`입니다.                                                                                                                                                                                                                                                                                                                                        |\n| `github.ref_type`                                                                                                                                                                                                                                                                            | `string`  | 워크플로 실행을 트리거한 ref의 형식입니다. 유효한 값은 `branch` 또는 `tag`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |\n| `github.repository`                                                                                                                                                                                                                                                                          | `string`  | 소유자 및 리포지토리 이름입니다. 예를 들어 `octocat/Hello-World`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |\n| `github.repository_id`                                                                                                                                                                                                                                                                       | `string`  | 리포지토리 ID. 예를 들어 `123456789`입니다. 리포지토리 이름과는 다릅니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |\n| `github.repository_owner`                                                                                                                                                                                                                                                                    | `string`  | 리포지토리 소유자의 사용자 이름입니다. 예를 들어 `octocat`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |\n| `github.repository_owner_id`                                                                                                                                                                                                                                                                 | `string`  | 리포지토리 소유자 계정 ID. 예를 들어 `1234567`입니다. 소유자의 이름과는 다른 값입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |\n| `github.repositoryUrl`                                                                                                                                                                                                                                                                       | `string`  | 리포지토리에 대한 Git URL입니다. 예를 들어 `git://github.com/octocat/hello-world.git`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |\n| `github.retention_days`                                                                                                                                                                                                                                                                      | `string`  | 워크플로 실행 로그 및 아티팩트가 유지되는 일 수입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |\n| `github.run_id`                                                                                                                                                                                                                                                                              | `string`  | 리포지토리 내에서 실행되는 각 워크플로의 고유한 숫자입니다. 워크플로 실행을 다시 실행하는 경우 이 숫자는 변경되지 않습니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |\n| `github.run_number`                                                                                                                                                                                                                                                                          | `string`  | 리포지토리에 있는 특정 워크플로의 실행마다 고유한 숫자입니다. 이 숫자는 워크플로의 첫 실행 시 1부터 시작하며 새 실행마다 증가합니다. 워크플로 실행을 다시 실행하는 경우 이 숫자는 변경되지 않습니다.                                                                                                                                                                                                                                                                                                                                                                                                                                   |\n| `github.run_attempt`                                                                                                                                                                                                                                                                         | `string`  | 리포지토리 내 각 특정 워크플로 실행 시도의 고유한 번호입니다. 이 숫자는 워크플로의 실행의 첫 시도 시 1부터 시작하며 다시 실행할 때마다 증가합니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |\n| `github.secret_source`                                                                                                                                                                                                                                                                       | `string`  | 워크플로에 사용되는 비밀의 소스입니다. 가능한 값은 `None`, `Actions`또는 `Codespaces``Dependabot`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |\n| `github.server_url`                                                                                                                                                                                                                                                                          | `string`  | GitHub 서버의 URL입니다. 예시: `https://github.com`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |\n| `github.sha`                                                                                                                                                                                                                                                                                 | `string`  | 워크플로를 트리거한 커밋 SHA입니다. 이 커밋 SHA의 값은 워크플로를 트리거한 이벤트에 따라 달라집니다. 자세한 내용은 [워크플로를 트리거하는 이벤트](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/events-that-trigger-workflows)을(를) 참조하세요. 예를 들어 `ffac537e6cbbf934b08745a378932722df287a53`입니다.                                                                                                                                                                                                                                                                                           |\n| `github.token`                                                                                                                                                                                                                                                                               | `string`  | 리포지토리에 설치된 GitHub 앱을 대신하여 인증할 토큰입니다. 기능적으로 `GITHUB_TOKEN` 비밀과 동일합니다. 자세한 내용은 [워크플로에서 인증에 GITHUB\\_TOKEN 사용](/ko/enterprise-cloud@latest/actions/tutorials/authenticate-with-github_token)을(를) 참조하세요.  <br /> 참고: 이 컨텍스트 속성은 Actions 실행기에서 설정되며 작업의 실행 `steps` 내에서만 사용할 수 있습니다. 그렇지 않으면 이 속성의 값이 `null`이 됩니다.                                                                                                                                                                                                                                         |\n| `github.triggering_actor`                                                                                                                                                                                                                                                                    | `string`  | 워크플로 실행을 시작한 사용자의 사용자 이름입니다. 워크플로 실행이 다시 실행인 경우 이 값은 `github.actor`와 다를 수 있습니다. 다시 실행을 시작하는 행위자(`github.triggering_actor`)가 다른 권한을 갖고 있더라도 모든 워크플로 다시 실행은 `github.actor`의 권한을 사용합니다.                                                                                                                                                                                                                                                                                                                                                                |\n| `github.workflow`                                                                                                                                                                                                                                                                            | `string`  | 워크플로의 이름입니다. 워크플로 파일이 `name`을 지정하지 않으면 이 속성의 값은 리포지토리에 있는 워크플로 파일의 전체 경로입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |\n| `github.workflow_ref`                                                                                                                                                                                                                                                                        | `string`  | 워크플로의 참조 경로입니다. 예를 들어 `octocat/hello-world/.github/workflows/my-workflow.yml@refs/heads/my_branch`입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                              |\n| `github.workflow_sha`                                                                                                                                                                                                                                                                        | `string`  | 워크플로 파일의 커밋 SHA입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |\n| `github.workspace`                                                                                                                                                                                                                                                                           | `string`  | 단계에 대한 실행기의 기본 작업 디렉터리 및 [`checkout`](https://github.com/actions/checkout) 작업을 사용할 때 리포지토리의 기본 위치입니다.                                                                                                                                                                                                                                                                                                                                                                                                                                               |\n\n### `github` 컨텍스트의 예시 콘텐츠\n\n다음 예시 컨텍스트는 `push` 이벤트에 의해 트리거되는 워크플로 실행의 컨텍스트입니다. 이 예시의 `event` 개체는 [웹후크 페이로드`push`](/ko/enterprise-cloud@latest/webhooks/webhook-events-and-payloads#push)의 내용과 동일하기 때문에 잘렸습니다.\n\n> \\[!NOTE]\n> 이 컨텍스트는 예제일 뿐입니다. 컨텍스트의 내용은 실행 중인 워크플로에 따라 달라집니다. 컨텍스트, 개체 및 속성은 워크플로 실행 조건마다 크게 달라집니다.\n\n```json\n{\n  \"token\": \"***\",\n  \"job\": \"dump_contexts_to_log\",\n  \"ref\": \"refs/heads/my_branch\",\n  \"sha\": \"c27d339ee6075c1f744c5d4b200f7901aad2c369\",\n  \"repository\": \"octocat/hello-world\",\n  \"repository_owner\": \"octocat\",\n  \"repositoryUrl\": \"git://github.com/octocat/hello-world.git\",\n  \"run_id\": \"1536140711\",\n  \"run_number\": \"314\",\n  \"retention_days\": \"90\",\n  \"run_attempt\": \"1\",\n  \"actor\": \"octocat\",\n  \"workflow\": \"Context testing\",\n  \"head_ref\": \"\",\n  \"base_ref\": \"\",\n  \"event_name\": \"push\",\n  \"event\": {\n    ...\n  },\n  \"server_url\": \"https://github.com\",\n  \"api_url\": \"https://api.github.com\",\n  \"graphql_url\": \"https://api.github.com/graphql\",\n  \"ref_name\": \"my_branch\",\n  \"ref_protected\": false,\n  \"ref_type\": \"branch\",\n  \"secret_source\": \"Actions\",\n  \"workspace\": \"/home/runner/work/hello-world/hello-world\",\n  \"action\": \"github_step\",\n  \"event_path\": \"/home/runner/work/_temp/_github_workflow/event.json\",\n  \"action_repository\": \"\",\n  \"action_ref\": \"\",\n  \"path\": \"/home/runner/work/_temp/_runner_file_commands/add_path_b037e7b5-1c88-48e2-bf78-eaaab5e02602\",\n  \"env\": \"/home/runner/work/_temp/_runner_file_commands/set_env_b037e7b5-1c88-48e2-bf78-eaaab5e02602\"\n}\n```\n\n### `github` 컨텍스트의 사용 예시\n\n이 예시 워크플로는 `github.event_name` 이벤트에 의해 워크플로 실행이 트리거된 경우에만 `pull_request` 컨텍스트를 사용하여 작업을 실행합니다.\n\n```yaml copy\nname: Run CI\non: [push, pull_request]\n\njobs:\n  normal_ci:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Run normal CI\n        run: echo \"Running normal CI\"\n\n  pull_request_ci:\n    runs-on: ubuntu-latest\n    if: ${{ github.event_name == 'pull_request' }}\n    steps:\n      - name: Run PR CI\n        run: echo \"Running PR only CI\"\n```\n\n## `env` 컨텍스트\n\n`env` 컨텍스트에는 워크플로, 작업 또는 단계에서 설정된 변수가 포함됩니다. 실행기 프로세스가 상속하는 변수는 포함되지 않습니다. 워크플로에서 변수를 설정하는 것에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#env)을(를) 참조하세요.\n\n`env` 컨텍스트에 저장된 변수의 값을 검색하여 워크플로 파일에서 이러한 값을 사용할 수 있습니다. 워크플로 단계의 모든 키에서 `env` 컨텍스트를 사용할 수 있습니다. 단, `id` 및 `uses` 키는 제외됩니다. 단계 구문에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps)을(를) 참조하세요.\n\n실행기 내에서 변수 값을 사용하려면 실행기 운영 체제의 일반 메서드를 사용하여 환경 변수를 읽습니다.\n\n| 속성 이름            | 타입       | 설명                                                                                         |\n| ---------------- | -------- | ------------------------------------------------------------------------------------------ |\n| `env`            | `object` | 이 컨텍스트는 작업의 각 단계에 따라 변경됩니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 속성이 포함되어 있습니다. |\n| `env.<env_name>` | `string` | 특정 환경 변수의 값입니다.                                                                            |\n\n### `env` 컨텍스트의 예시 콘텐츠\n\n`env` 컨텍스트의 내용은 변수 이름을 해당 값에 매핑한 것입니다. 컨텍스트의 내용은 워크플로 실행에서 사용되는 위치에 따라 변경됩니다. 이 예시에서 `env` 컨텍스트에는 두 개의 변수가 포함됩니다.\n\n```json\n{\n  \"first_name\": \"Mona\",\n  \"super_duper_var\": \"totally_awesome\"\n}\n```\n\n### `env` 컨텍스트의 사용 예시\n\n이 예시 워크플로는 워크플로, 작업, 단계 수준의 `env` 컨텍스트에서 설정되는 변수를 보여줍니다. 그런 다음 `${{ env.VARIABLE-NAME }}` 구문을 사용하여 워크플로의 개별 단계 내에서 변수 값을 검색합니다.\n\n둘 이상의 변수가 동일한 이름으로 정의되면 GitHub는 가장 구체적인 환경 변수를 사용합니다. 예를 들어 단계에 정의된 환경 변수는 단계가 실행되는 동안 동일한 이름의 작업 및 워크플로 환경 변수를 재정의합니다. 작업에 정의된 환경 변수는 작업이 실행되는 동안 동일한 이름의 워크플로 변수를 재정의합니다.\n\n```yaml copy\nname: Hi Mascot\non: push\nenv:\n  mascot: Mona\n  super_duper_var: totally_awesome\n\njobs:\n  windows_job:\n    runs-on: windows-latest\n    steps:\n      - run: echo 'Hi ${{ env.mascot }}'  # Hi Mona\n      - run: echo 'Hi ${{ env.mascot }}'  # Hi Octocat\n        env:\n          mascot: Octocat\n  linux_job:\n    runs-on: ubuntu-latest\n    env:\n      mascot: Tux\n    steps:\n      - run: echo 'Hi ${{ env.mascot }}'  # Hi Tux\n```\n\n## `vars` 컨텍스트\n\n`vars` 컨텍스트에는 조직, 리포지토리, 환경 수준에서 설정된 사용자 지정 구성 변수가 포함됩니다. 여러 워크플로에서 사용할 구성 변수를 정의하는 방법에 대한 자세한 내용은 [변수에 정보 저장](/ko/enterprise-cloud@latest/actions/how-tos/write-workflows/choose-what-workflows-do/use-variables#defining-configuration-variables-for-multiple-workflows)을(를) 참조하세요.\n\n### `vars` 컨텍스트의 예시 콘텐츠\n\n`vars` 컨텍스트의 내용은 구성 변수 이름을 해당 값에 매핑한 것입니다.\n\n```json\n{\n  \"mascot\": \"Mona\"\n}\n```\n\n### `vars` 컨텍스트의 사용 예시\n\n이 예시 워크플로에서는 `vars` 컨텍스트를 사용하여 리포지토리, 환경 또는 조직 수준에서 설정된 구성 변수를 자동으로 사용할 수 있는 방법을 보여 줍니다.\n\n> \\[!NOTE]\n> 환경 수준의 구성 변수는 실행기에서 해당 환경을 선언한 후에 자동으로 사용할 수 있습니다.\n\n구성 변수가 설정되지 않은 경우, 변수를 참조하는 컨텍스트는 빈 문자열을 반환합니다.\n\n다음 예제는 워크플로 전체에서 `vars` 컨텍스트와 함께 구성 변수를 사용하는 방법을 나타냅니다. 다음 각각의 구성 변수는 리포지토리, 조직 또는 환경 수준에서 정의되었습니다.\n\n```yaml copy\non:\n  workflow_dispatch:\nenv:\n  # Setting an environment variable with the value of a configuration variable\n  env_var: ${{ vars.ENV_CONTEXT_VAR }}\n\njobs:\n  display-variables:\n    name: ${{ vars.JOB_NAME }}\n    # You can use configuration variables with the `vars` context for dynamic jobs\n    if: ${{ vars.USE_VARIABLES == 'true' }}\n    runs-on: ${{ vars.RUNNER }}\n    environment: ${{ vars.ENVIRONMENT_STAGE }}\n    steps:\n    - name: Use variables\n      run: |\n        echo \"repository variable : $REPOSITORY_VAR\"\n        echo \"organization variable : $ORGANIZATION_VAR\"\n        echo \"overridden variable : $OVERRIDE_VAR\"\n        echo \"variable from shell environment : $env_var\"\n      env:\n        REPOSITORY_VAR: ${{ vars.REPOSITORY_VAR }}\n        ORGANIZATION_VAR: ${{ vars.ORGANIZATION_VAR }}\n        OVERRIDE_VAR: ${{ vars.OVERRIDE_VAR }}\n        \n    - name: ${{ vars.HELLO_WORLD_STEP }}\n      if: ${{ vars.HELLO_WORLD_ENABLED == 'true' }}\n      uses: actions/hello-world-javascript-action@main\n      with:\n        who-to-greet: ${{ vars.GREET_NAME }}\n```\n\n## `job` 컨텍스트\n\n`job` 컨텍스트에는 현재 실행 중인 작업에 대한 정보가 포함됩니다.\n\n| 속성 이름                                                                                                                                                             | 타입       | 설명                                                                                                                                                                                            |\n| ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `job`                                                                                                                                                             | `object` | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 변경됩니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                |\n|                                                                                                                                                                   |          |                                                                                                                                                                                               |\n| `job.check_run_id`                                                                                                                                                | `number` | 현재 작업의 확인 실행 ID입니다.                                                                                                                                                                           |\n|                                                                                                                                                                   |          |                                                                                                                                                                                               |\n| `job.container`                                                                                                                                                   | `object` | 작업의 컨테이너에 대한 정보입니다. 컨테이너에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idcontainer)을(를) 참조하세요.         |\n| `job.container.id`                                                                                                                                                | `string` | 컨테이너의 ID입니다.                                                                                                                                                                                  |\n| `job.container.network`                                                                                                                                           | `string` | 컨테이너 네트워크의 ID입니다. 실행기는 작업의 모든 컨테이너에서 사용하는 네트워크를 만듭니다.                                                                                                                                         |\n| `job.services`                                                                                                                                                    | `object` | 작업에 대해 생성된 서비스 컨테이너들입니다. 서비스 컨테이너에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idservices)을(를) 참조하세요. |\n| `job.services.<service_id>.id`                                                                                                                                    | `string` | 서비스 컨테이너의 ID입니다.                                                                                                                                                                              |\n| `job.services.<service_id>.network`                                                                                                                               | `string` | 서비스 컨테이너 네트워크의 ID입니다. 실행기는 작업의 모든 컨테이너에서 사용하는 네트워크를 만듭니다.                                                                                                                                     |\n| `job.services.<service_id>.ports`                                                                                                                                 | `object` | 서비스 컨테이너의 노출된 포트입니다.                                                                                                                                                                          |\n| `job.status`                                                                                                                                                      | `string` | 작업의 현재 상태입니다. 가능한 값은 `success`, `failure` 또는 `cancelled`입니다.                                                                                                                                  |\n| `job.workflow_ref`                                                                                                                                                | `string` | 현재 작업을 정의하는 워크플로 파일의 전체 참조입니다. 예를 들어 `octo-org/octo-repo/.github/workflows/deploy.yml@refs/heads/main`입니다. 워크플로 파일에 직접 정의된 작업의 경우 다음과 같습니다 `github.workflow_ref`.                             |\n| [워크플로 재사용](/ko/enterprise-cloud@latest/actions/how-tos/reuse-automations/reuse-workflows)에 정의된 작업의 경우 재사용 가능한 워크플로 파일을 참조합니다. (사용할 수 없음 GitHub Enterprise Server) |          |                                                                                                                                                                                               |\n| `job.workflow_sha`                                                                                                                                                | `string` | 현재 작업을 정의하는 워크플로 파일의 커밋 SHA입니다. (사용할 수 없음 GitHub Enterprise Server)                                                                                                                           |\n| `job.workflow_repository`                                                                                                                                         | `string` |                                                                                                                                                                                               |\n| `owner/repo` 현재 작업을 정의하는 워크플로 파일이 포함된 리포지토리입니다. 예를 들어 `octo-org/octo-repo`입니다. (사용할 수 없음 GitHub Enterprise Server)                                                |          |                                                                                                                                                                                               |\n| `job.workflow_file_path`                                                                                                                                          | `string` | 리포지토리 루트를 기준으로 현재 작업을 정의하는 워크플로 파일의 파일 경로입니다. 예를 들어 `.github/workflows/deploy.yml`입니다. (사용할 수 없음 GitHub Enterprise Server)                                                                    |\n\n### `job` 컨텍스트의 예시 콘텐츠\n\n이 예시 `job` 컨텍스트는 매핑된 포트가 있는 PostgreSQL 서비스 컨테이너를 사용합니다. 작업에 사용되는 컨테이너 또는 서비스 컨테이너가 없으면 컨텍스트에 `job` 만 포함됩니다 `status`.\n`check_run_id` 및 워크플로 ID 속성(`workflow_ref`, `workflow_sha`, `workflow_repository`, `workflow_file_path`)은 GitHub Enterprise Server에서 사용할 수 없습니다.\n\n```json\n{\n  \"status\": \"success\",\n  \"check_run_id\": 51725241954,\n  \"workflow_ref\": \"octo-org/octo-repo/.github/workflows/deploy.yml@refs/heads/main\",\n  \"workflow_sha\": \"abc123def456789abc123def456789abc123def4\",\n  \"workflow_repository\": \"octo-org/octo-repo\",\n  \"workflow_file_path\": \".github/workflows/deploy.yml\",\n  \"container\": {\n    \"network\": \"github_network_53269bd575974817b43f4733536b200c\"\n  },\n  \"services\": {\n    \"postgres\": {\n      \"id\": \"60972d9aa486605e66b0dad4abb638dc3d9116f566579e418166eedb8abb9105\",\n      \"ports\": {\n        \"5432\": \"49153\"\n      },\n      \"network\": \"github_network_53269bd575974817b43f4733536b200c\"\n    }\n  }\n}\n```\n\n### `job` 컨텍스트의 사용 예시\n\n이 예시 워크플로는 PostgreSQL 서비스 컨테이너를 구성하고 서비스 컨테이너의 포트 5432를 호스트에서 임의로 선택된 사용 가능한 포트에 자동으로 매핑합니다.\n`job` 컨텍스트는 호스트에 할당된 포트 수에 액세스하는 데 사용됩니다.\n\n```yaml copy\nname: PostgreSQL Service Example\non: push\njobs:\n  postgres-job:\n    runs-on: ubuntu-latest\n    services:\n      postgres:\n        image: postgres\n        env:\n          POSTGRES_PASSWORD: postgres\n        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5\n        ports:\n          # Maps TCP port 5432 in the service container to a randomly chosen available port on the host.\n          - 5432\n\n    steps:\n      - run: pg_isready -h localhost -p ${{ job.services.postgres.ports[5432] }}\n      - run: echo \"Run tests against Postgres\"\n```\n\n### 컨텍스트 워크플로 ID의 `job` 예제 사용\n\n> \\[!NOTE]\n> `job.workflow_*`의 컨텍스트 속성은 GitHub Enterprise Server에서 사용할 수 없습니다.\n\n이 예제 재사용 가능 워크플로는 호출자의 리포지토리가 아닌, `job.workflow_repository` 및 `job.workflow_sha`을 사용하여 자체 소스 코드를 체크아웃합니다. 이는 재사용 가능한 워크플로가 워크플로 정의와 공동 배치된 파일에 액세스해야 하는 경우에 유용합니다.\n\n```yaml copy\n# In a reusable workflow (e.g., octo-org/shared-workflows/.github/workflows/deploy.yml)\nname: Reusable deploy workflow\non:\n  workflow_call:\n\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v6\n        with:\n          repository: ${{ job.workflow_repository }}\n          ref: ${{ job.workflow_sha }}\n\n      - run: echo \"Deploying from ${{ job.workflow_ref }}\"\n      - run: echo \"Workflow file path is ${{ job.workflow_file_path }}\"\n```\n\n## `jobs` 컨텍스트\n\n`jobs` 컨텍스트는 재사용 가능한 워크플로에서만 사용할 수 있으며 재사용 가능한 워크플로에 대한 출력을 설정하는 데만 사용할 수 있습니다. 자세한 내용은 [워크플로 재사용](/ko/enterprise-cloud@latest/actions/how-tos/reuse-automations/reuse-workflows#using-outputs-from-a-reusable-workflow)을(를) 참조하세요.\n\n| 속성 이름                                 | 타입       | 설명                                                                                                 |\n| ------------------------------------- | -------- | -------------------------------------------------------------------------------------------------- |\n| `jobs`                                | `object` | 이는 재사용 가능한 워크플로에서만 사용할 수 있으며 재사용 가능한 워크플로에 대한 출력을 설정하는 데만 사용할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다. |\n| `jobs.<job_id>.result`                | `string` | 재사용 가능한 워크플로의 작업 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다.                  |\n| `jobs.<job_id>.outputs`               | `object` | 재사용 가능한 워크플로 작업의 출력 집합입니다.                                                                         |\n| `jobs.<job_id>.outputs.<output_name>` | `string` | 재사용 가능한 워크플로의 작업에 대한 특정 출력 값입니다.                                                                   |\n\n### `jobs` 컨텍스트의 예시 콘텐츠\n\n이 `jobs` 컨텍스트 예시는 재사용 가능한 워크플로 실행의 작업 결과와 출력을 포함합니다.\n\n```json\n{\n  \"example_job\": {\n    \"result\": \"success\",\n    \"outputs\": {\n      \"output1\": \"hello\",\n      \"output2\": \"world\"\n    }\n  }\n}\n```\n\n### `jobs` 컨텍스트의 사용 예시\n\n이 재사용 가능한 워크플로 예시는 `jobs` 컨텍스트를 사용하여 재사용 가능한 워크플로에 대한 출력을 설정합니다. 출력이 단계에서 작업으로, 그 다음에는 `workflow_call` 트리거로 이동하는 방식을 주목하세요. 자세한 내용은 [워크플로 재사용](/ko/enterprise-cloud@latest/actions/how-tos/reuse-automations/reuse-workflows#using-outputs-from-a-reusable-workflow)을(를) 참조하세요.\n\n```yaml copy\nname: Reusable workflow\n\non:\n  workflow_call:\n    # Map the workflow outputs to job outputs\n    outputs:\n      firstword:\n        description: \"The first output string\"\n        value: ${{ jobs.example_job.outputs.output1 }}\n      secondword:\n        description: \"The second output string\"\n        value: ${{ jobs.example_job.outputs.output2 }}\n\njobs:\n  example_job:\n    name: Generate output\n    runs-on: ubuntu-latest\n    # Map the job outputs to step outputs\n    outputs:\n      output1: ${{ steps.step1.outputs.firstword }}\n      output2: ${{ steps.step2.outputs.secondword }}\n    steps:\n      - id: step1\n        run: echo \"firstword=hello\" >> $GITHUB_OUTPUT\n      - id: step2\n        run: echo \"secondword=world\" >> $GITHUB_OUTPUT\n```\n\n## `steps` 컨텍스트\n\n`steps` 컨텍스트에는 지정되어 있고 이미 실행된 [`id`](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsid) 가 있는 현재 작업의 단계에 대한 정보가 포함됩니다.\n\n| 속성 이름                                                                                                                                                                           | 타입       | 설명                                                                                                                                                                                             |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `steps`                                                                                                                                                                         | `object` | 이 컨텍스트는 작업의 각 단계에 따라 변경됩니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                      |\n| `steps.<step_id>.outputs`                                                                                                                                                       | `object` | 단계에 대해 정의된 출력 집합입니다. 자세한 내용은 [메타데이터 구문 참조](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/metadata-syntax#outputs-for-docker-container-and-javascript-actions)을(를) 참조하세요. |\n| `steps.<step_id>.conclusion`                                                                                                                                                    | `string` |                                                                                                                                                                                                |\n| \\[                                                                                                                                                                              |          |                                                                                                                                                                                                |\n| `continue-on-error`                                                                                                                                                             |          |                                                                                                                                                                                                |\n| ]\\(/actions/reference/workflows-and-actions/workflow-syntax#jobsjob\\_idstepscontinue-on-error)가 적용된 후 완료된 단계의 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다.  |          |                                                                                                                                                                                                |\n| `continue-on-error` 단계가 실패하면 `outcome`은 `failure`이지만 최종 `conclusion`은 `success`입니다.                                                                                             |          |                                                                                                                                                                                                |\n| `steps.<step_id>.outcome`                                                                                                                                                       | `string` |                                                                                                                                                                                                |\n| \\[                                                                                                                                                                              |          |                                                                                                                                                                                                |\n| `continue-on-error`                                                                                                                                                             |          |                                                                                                                                                                                                |\n| ]\\(/actions/reference/workflows-and-actions/workflow-syntax#jobsjob\\_idstepscontinue-on-error)가 적용되기 전 완료된 단계의 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다. |          |                                                                                                                                                                                                |\n| `continue-on-error` 단계가 실패하면 `outcome`은 `failure`이지만 최종 `conclusion`은 `success`입니다.                                                                                             |          |                                                                                                                                                                                                |\n| `steps.<step_id>.outputs.<output_name>`                                                                                                                                         | `string` | 특정 출력의 값입니다.                                                                                                                                                                                   |\n\n### `steps` 컨텍스트의 예시 콘텐츠\n\n이 예시 `steps` 컨텍스트는 지정된 [`id`](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsid)가 있는 두 개의 이전 단계를 보여줍니다. 첫 번째 단계에는 `id`이라는 `checkout`가, 두 번째 단계에는 `generate_number`가 있습니다.\n`generate_number` 단계에는 이름이 `random_number`인 출력이 있습니다.\n\n```json\n{\n  \"checkout\": {\n    \"outputs\": {},\n    \"outcome\": \"success\",\n    \"conclusion\": \"success\"\n  },\n  \"generate_number\": {\n    \"outputs\": {\n      \"random_number\": \"1\"\n    },\n    \"outcome\": \"success\",\n    \"conclusion\": \"success\"\n  }\n}\n```\n\n### `steps` 컨텍스트의 사용 예시\n\n이 예시 워크플로는 한 단계에서 난수를 출력으로 생성하고, 이후 단계에서는 `steps` 컨텍스트를 사용하여 해당 출력의 값을 읽습니다.\n\n```yaml copy\nname: Generate random failure\non: push\njobs:\n  randomly-failing-job:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Generate 0 or 1\n        id: generate_number\n        run: echo \"random_number=$(($RANDOM % 2))\" >> $GITHUB_OUTPUT\n      - name: Pass or fail\n        run: |\n          if [[ ${{ steps.generate_number.outputs.random_number }} == 0 ]]; then exit 0; else exit 1; fi\n```\n\n## `runner` 컨텍스트\n\n`runner` 컨텍스트에는 현재 작업을 실행하는 실행기 정보가 포함됩니다.\n\n| 속성 이름                | 타입       | 설명                                                                                                                                                                                                              |\n| -------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `runner`             | `object` | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 변경됩니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                                                                   |\n| `runner.name`        | `string` | 작업을 실행하는 실행기의 이름입니다. 실행기 이름은 리포지토리의 실행기로 워크플로 실행 시 고유하지 않을 수 있으며 조직 수준에서 동일한 이름을 사용할 수 있습니다.                                                                                                                    |\n| `runner.os`          | `string` | 작업을 실행하는 실행기의 운영 체제입니다. 가능한 값은 `Linux`, `Windows`, 또는 `macOS`입니다.                                                                                                                                               |\n| `runner.arch`        | `string` | 작업을 실행하는 실행기의 아키텍처입니다. 가능한 값은 `X86`, `X64`, `ARM`, `ARM64`입니다.                                                                                                                                                  |\n| `runner.temp`        | `string` | 실행기의 임시 디렉터리에 대한 경로입니다. 이 디렉터리는 각 작업의 시작과 끝에 비워집니다. 실행기 사용자 계정에 삭제 권한이 없는 경우 파일이 제거되지 않습니다.                                                                                                                     |\n| `runner.tool_cache`  | `string` | GitHub에서 호스팅되는 실행기에 사전 설치된 도구가 들어 있는 디렉터리의 경로입니다. 자세한 내용은 [GitHub 호스팅 실행기](/ko/enterprise-cloud@latest/actions/concepts/runners/github-hosted-runners#preinstalled-software-for-github-owned-images)을(를) 참조하세요. |\n| `runner.debug`       | `string` | [디버그 로깅](/ko/enterprise-cloud@latest/actions/how-tos/monitor-workflows/enable-debug-logging)을 사용하도록 설정한 경우에만 설정되며 항상 값이 `1`입니다. 사용자 고유의 작업 단계에서 추가 디버깅 또는 자세한 로깅을 사용하도록 설정하는 지표로 유용할 수 있습니다.                    |\n| `runner.environment` | `string` | 작업을 실행하는 실행기의 환경입니다. 가능한 값은 GitHub에서 제공하는 GitHub 호스트형 실행기의 경우 `github-hosted`, 리포지토리 소유자가 구성한 자체 호스트형 실행기의 경우 `self-hosted`입니다.                                                                                 |\n\n### `runner` 컨텍스트의 예시 콘텐츠\n\n다음 예제 컨텍스트는 Linux GitHub호스팅 실행기에서 가져옵니다.\n\n```json\n{\n  \"os\": \"Linux\",\n  \"arch\": \"X64\",\n  \"name\": \"GitHub Actions 2\",\n  \"tool_cache\": \"/opt/hostedtoolcache\",\n  \"temp\": \"/home/runner/work/_temp\"\n}\n```\n\n### `runner` 컨텍스트의 사용 예시\n\n이 예시 워크플로는 `runner` 컨텍스트를 사용하여 임시 디렉터리의 경로를 설정하여 로그를 작성하고, 워크플로가 실패하면 해당 로그를 아티팩트로 업로드합니다.\n\n```yaml copy\nname: Build\non: push\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v6\n      - name: Build with logs\n        run: |\n          mkdir ${{ runner.temp }}/build_logs\n          echo \"Logs from building\" > ${{ runner.temp }}/build_logs/build.logs\n          exit 1\n      - name: Upload logs on fail\n        if: ${{ failure() }}\n        uses: actions/upload-artifact@v4\n        with:\n          name: Build failure logs\n          path: ${{ runner.temp }}/build_logs\n```\n\n## `secrets` 컨텍스트\n\n`secrets` 컨텍스트는 워크플로 실행에 사용할 수 있는 비밀의 이름과 값을 포함합니다. 보안상의 이유로 복합 작업에는 `secrets` 컨텍스트를 사용할 수 없습니다. 복합 작업에 비밀을 전달하려는 경우 명시적으로 입력을 통해 수행해야 합니다. 비밀에 대한 자세한 내용은 [GitHub Actions에서 비밀 사용](/ko/enterprise-cloud@latest/actions/how-tos/write-workflows/choose-what-workflows-do/use-secrets)을(를) 참조하세요.\n\n`GITHUB_TOKEN`은 모든 워크플로 실행에 대해 자동으로 만들어지고 항상 `secrets` 컨텍스트에 포함되는 비밀입니다. 자세한 내용은 [워크플로에서 인증에 GITHUB\\_TOKEN 사용](/ko/enterprise-cloud@latest/actions/tutorials/authenticate-with-github_token)을(를) 참조하세요.\n\n> \\[!WARNING]\n> 워크플로 작업에서 비밀이 사용된 경우 GitHub은 로그에 출력된 비밀을 자동으로 수정합니다. 의도적으로 로그에 비밀을 출력하지 않아야 합니다.\n\n| 속성 이름                   | 타입       | 설명                                                                                                                                                           |\n| ----------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `secrets`               | `object` | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 동일합니다. 작업의 모든 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                               |\n| `secrets.GITHUB_TOKEN`  | `string` | 각 워크플로 실행에 대해 자동으로 생성된 토큰입니다. 자세한 내용은 [워크플로에서 인증에 GITHUB\\_TOKEN 사용](/ko/enterprise-cloud@latest/actions/tutorials/authenticate-with-github_token)을(를) 참조하세요. |\n| `secrets.<secret_name>` | `string` | 특정 비밀의 값입니다.                                                                                                                                                 |\n\n### `secrets` 컨텍스트의 예시 콘텐츠\n\n`secrets` 컨텍스트의 다음 예시 콘텐츠는 자동 `GITHUB_TOKEN` 및 워크플로 실행에 사용할 수 있는 두 개의 다른 비밀을 보여줍니다.\n\n```json\n{\n  \"github_token\": \"***\",\n  \"NPM_TOKEN\": \"***\",\n  \"SUPERSECRET\": \"***\"\n}\n```\n\n### `secrets` 컨텍스트의 사용 예시\n\n이 예제 워크플로는 [GitHub CLI](/ko/enterprise-cloud@latest/actions/how-tos/write-workflows/choose-what-workflows-do/use-github-cli)를 사용하며, 이 경우 `GITHUB_TOKEN` 입력 매개 변수의 값으로 `GH_TOKEN`가 필요합니다.\n\n```yaml copy\nname: Open new issue\non: workflow_dispatch\n\njobs:\n  open-issue:\n    runs-on: ubuntu-latest\n    permissions:\n      contents: read\n      issues: write\n    steps:\n      - run: |\n          gh issue --repo ${{ github.repository }} \\\n            create --title \"Issue title\" --body \"Issue body\"\n        env:\n          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n```\n\n## `strategy` 컨텍스트\n\n행렬이 있는 워크플로의 경우 `strategy` 컨텍스트에는 현재 작업에 대한 행렬 실행 전략에 대한 정보가 포함됩니다.\n\n| 속성 이름                                                                                                                                                                                                              | 타입        | 설명                                                                                                                                                                                                                     |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `strategy`                                                                                                                                                                                                         | `object`  | 이 컨텍스트는 워크플로 실행의 각 작업에 대해 변경됩니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다.                                                                                                                 |\n| `strategy.fail-fast`                                                                                                                                                                                               | `boolean` | 이 값이 `true`로 평가되는 경우 행렬의 작업이 실패하면 진행 중인 모든 작업이 취소됩니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategyfail-fast)을(를) 참조하세요. |\n| `strategy.job-index`                                                                                                                                                                                               | `number`  | 현재 작업의 행렬 인덱스입니다.                                                                                                                                                                                                      |\n| **참고:** 이 숫자는 0부터 시작합니다. 행렬의 첫 번째 작업 인덱스는 `0`입니다.                                                                                                                                                                  |           |                                                                                                                                                                                                                        |\n| `strategy.job-total`                                                                                                                                                                                               | `number`  | 행렬의 총 작업 수입니다.                                                                                                                                                                                                         |\n| **참고:** 이 숫자는 0부터 시작하지 **않습니다**. 예를 들어 네 개의 작업이 있는 행렬의 경우 `job-total`의 값은 `4`입니다.                                                                                                                                  |           |                                                                                                                                                                                                                        |\n| `strategy.max-parallel`                                                                                                                                                                                            | `number`  |                                                                                                                                                                                                                        |\n| `matrix` 작업 전략을 사용할 때 동시에 실행할 수 있는 최대 작업 수입니다. 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategymax-parallel)을(를) 참조하세요. |           |                                                                                                                                                                                                                        |\n\n### `strategy` 컨텍스트의 예시 콘텐츠\n\n`strategy` 컨텍스트의 다음 예시 콘텐츠는 4개의 작업이 있는 행렬에서 가져온 것이며 최종 작업에서 가져옵니다. 0부터 시작하는 `job-index` 숫자와 0부터 시작하지 않는 `job-total` 사이의 차이를 확인합니다.\n\n```json\n{\n  \"fail-fast\": true,\n  \"job-index\": 3,\n  \"job-total\": 4,\n  \"max-parallel\": 4\n}\n```\n\n### `strategy` 컨텍스트의 사용 예시\n\n이 예시 워크플로에서는 `strategy.job-index` 속성을 사용하여 행렬의 각 작업에 대한 로그 파일의 고유한 이름을 설정합니다.\n\n```yaml copy\nname: Test strategy\non: push\n\njobs:\n  test:\n    runs-on: ubuntu-latest\n    strategy:\n      matrix:\n        test-group: [1, 2]\n        node: [14, 16]\n    steps:\n      - run: echo \"Mock test logs\" > test-job-${{ strategy.job-index }}.txt\n      - name: Upload logs\n        uses: actions/upload-artifact@v4\n        with:\n          name: Build log for job ${{ strategy.job-index }}\n          path: test-job-${{ strategy.job-index }}.txt\n```\n\n## `matrix` 컨텍스트\n\n행렬이 있는 워크플로의 경우 `matrix` 컨텍스트에는 현재 작업에 적용되는 워크플로 파일에 정의된 행렬 속성이 포함됩니다. 예를 들어 `os` 및 `node` 키와 함께 행렬을 구성하는 경우 `matrix` 컨텍스트 개체에는 현재 작업에 사용되는 값과 함께 `os` 및 `node` 속성이 포함됩니다.\n\n`matrix` 컨텍스트에는 표준 속성이 없으며 워크플로 파일에 정의된 속성만 있습니다.\n\n| 속성 이름                    | 타입       | 설명                                                                                                                                |\n| ------------------------ | -------- | --------------------------------------------------------------------------------------------------------------------------------- |\n| `matrix`                 | `object` | 이 컨텍스트는 행렬의 작업 및 워크플로 실행의 각 작업에 대한 변경 내용에 대해서만 사용할 수 있습니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 속성이 포함되어 있습니다. |\n| `matrix.<property_name>` | `string` | 행렬 속성의 값입니다.                                                                                                                      |\n\n### `matrix` 컨텍스트의 예시 콘텐츠\n\n`matrix` 컨텍스트의 다음 예시 콘텐츠는 워크플로에 정의된 `os` 행렬 속성과 `node` 행렬 속성이 있는 행렬의 작업에서 가져옵니다. 작업은 `ubuntu-latest` OS와 Node.js 버전 `16`의 매트릭스 조합을 실행합니다.\n\n```json\n{\n  \"os\": \"ubuntu-latest\",\n  \"node\": 16\n}\n```\n\n### `matrix` 컨텍스트의 사용 예시\n\n이 예시 워크플로는 `os` 및 `node` 키와 함께 행렬을 만듭니다.\n`matrix.os` 속성을 사용하여 각 작업에 대한 실행기 유형을 설정하고, `matrix.node` 속성을 사용하여 각 작업에 대한 Node.js 버전을 설정합니다.\n\n```yaml copy\nname: Test matrix\non: push\n\njobs:\n  build:\n    runs-on: ${{ matrix.os }}\n    strategy:\n      matrix:\n        os: [ubuntu-latest, windows-latest]\n        node: [14, 16]\n    steps:\n      - uses: actions/setup-node@v7\n        with:\n          node-version: ${{ matrix.node }}\n      - name: Output node version\n        run: node --version\n```\n\n## `needs` 컨텍스트\n\n`needs` 컨텍스트는 현재 작업의 직접적인 종속성으로 정의된 모든 작업으로부터의 출력을 포함합니다. 여기에는 암시적으로 종속된 작업(예시: 종속 작업의 종속 작업)이 포함되지 않는다는 점에 유의하세요. 작업 종속성 정의에 대한 자세한 내용은 [GitHub Actions에 대한 워크플로 구문](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idneeds)을(를) 참조하세요.\n\n| 속성 이름                                  | 타입       | 설명                                                                                                                                    |\n| -------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------- |\n| `needs`                                | `object` | 이 컨텍스트는 종속 작업이 있는 워크플로 실행과 워크플로 실행의 각 작업에 대한 변경 내용에 대해서만 채워집니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 모든 속성이 포함됩니다. |\n| `needs.<job_id>`                       | `object` | 현재 작업이 의존하는 하나의 작업입니다.                                                                                                                |\n| `needs.<job_id>.outputs`               | `object` | 현재 작업이 의존하는 작업의 출력 집합입니다.                                                                                                             |\n| `needs.<job_id>.outputs.<output name>` | `string` | 현재 작업이 의존하는 작업에 대한 특정 출력의 값입니다.                                                                                                       |\n| `needs.<job_id>.result`                | `string` | 현재 작업이 의존하는 작업의 결과입니다. 가능한 값은 `success`, `failure`, `cancelled` 또는 `skipped`입니다.                                                      |\n\n### `needs` 컨텍스트의 예시 콘텐츠\n\n`needs` 컨텍스트의 다음 예시 콘텐츠는 현재 작업이 의존하는 두 가지 작업에 대한 정보를 보여줍니다.\n\n```json\n{\n  \"build\": {\n    \"result\": \"success\",\n    \"outputs\": {\n      \"build_id\": \"123456\"\n    }\n  },\n  \"deploy\": {\n    \"result\": \"failure\",\n    \"outputs\": {}\n  }\n}\n```\n\n### `needs` 컨텍스트의 사용 예시\n\n이 예시 워크플로에는 세 가지 작업, 즉 빌드를 수행하는 `build` 작업, `deploy` 작업이 필요한 `build` 작업, `debug` 및 `build` 작업이 모두 필요하고 워크플로에 오류가 있는 경우에만 실행되는 `deploy` 작업이 있습니다. 또한 `deploy` 작업은 `needs` 컨텍스트를 사용하여 `build` 작업의 출력에 액세스합니다.\n\n```yaml copy\nname: Build and deploy\non: push\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n    outputs:\n      build_id: ${{ steps.build_step.outputs.build_id }}\n    steps:\n      - name: Build\n        id: build_step\n        run: echo \"build_id=$RANDOM\" >> $GITHUB_OUTPUT\n  deploy:\n    needs: build\n    runs-on: ubuntu-latest\n    steps:\n      - run: echo \"Deploying build ${{ needs.build.outputs.build_id }}\"\n  debug:\n    needs: [build, deploy]\n    runs-on: ubuntu-latest\n    if: ${{ failure() }}\n    steps:\n      - run: echo \"Failed to build and deploy\"\n```\n\n## `inputs` 컨텍스트\n\n`inputs` 컨텍스트에는 작업, 재사용 가능한 워크플로 또는 수동으로 트리거된 워크플로에 전달되는 입력 속성을 포함합니다. 재사용 가능한 워크플로의 경우 입력 이름 및 형식은 재사용 가능한 워크플로의 [`workflow_call` 이벤트 구성](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/events-that-trigger-workflows)에 정의되며, 입력 값은 재사용 가능한 워크플로를 호출하는 외부 워크플로의 [`jobs.<job_id>.with`](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idwith)에서 전달됩니다. 수동으로 트리거된 워크플로의 경우 입력은 워크플로의 [`workflow_dispatch` 이벤트 구성](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_dispatch)에 정의됩니다.\n\n`inputs` 컨텍스트의 속성은 워크플로 파일에 정의되어 있습니다. 이 속성은 [재사용 가능한 워크플로](/ko/enterprise-cloud@latest/actions/how-tos/reuse-automations/reuse-workflows) 또는 [`workflow_dispatch` 이벤트](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_dispatch)에 의해 트리거된 워크플로에서만 사용할 수 있습니다.\n\n| 속성 이름                                     | 타입                       | 설명                                                                                                                                                                                                                                                                                                                                                          |\n| ----------------------------------------- | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `inputs`                                  | `object`                 | 이 컨텍스트는 [재사용 가능한 워크플로](/ko/enterprise-cloud@latest/actions/how-tos/reuse-automations/reuse-workflows) 또는 [`workflow_dispatch` 이벤트](/ko/enterprise-cloud@latest/actions/reference/workflows-and-actions/events-that-trigger-workflows#workflow_dispatch)에 의해 트리거된 워크플로에서만 사용할 수 있습니다. 워크플로의 모든 작업 또는 단계에서 이 컨텍스트에 액세스할 수 있습니다. 이 개체에는 아래에 나열된 속성이 포함되어 있습니다. |\n| `inputs.<name>`                           |                          |                                                                                                                                                                                                                                                                                                                                                             |\n| `string`, `number`, `boolean` 또는 `choice` | 외부 워크플로에서 전달된 각 입력 값입니다. |                                                                                                                                                                                                                                                                                                                                                             |\n\n### `inputs` 컨텍스트의 예시 콘텐츠\n\n`inputs` 컨텍스트의 다음 예시 콘텐츠는 `build_id`, `deploy_target` 및 `perform_deploy` 입력을 정의한 워크플로에서 가져온 것입니다.\n\n```json\n{\n  \"build_id\": 123456768,\n  \"deploy_target\": \"deployment_sys_1a\",\n  \"perform_deploy\": true\n}\n```\n\n### 재사용 가능한 워크플로의 `inputs` 컨텍스트 사용 예시\n\n이 예시에서 재사용 가능한 워크플로는 `inputs` 컨텍스트를 사용하여 호출자 워크플로에서 재사용 가능한 워크플로에 전달된 `build_id`, `deploy_target` 및 `perform_deploy` 입력의 값을 가져옵니다.\n\n```yaml copy\nname: Reusable deploy workflow\non:\n  workflow_call:\n    inputs:\n      build_id:\n        required: true\n        type: number\n      deploy_target:\n        required: true\n        type: string\n      perform_deploy:\n        required: true\n        type: boolean\n\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    if: ${{ inputs.perform_deploy }}\n    steps:\n      - name: Deploy build to target\n        run: echo \"Deploying build:${{ inputs.build_id }} to target:${{ inputs.deploy_target }}\"\n```\n\n### 수동으로 트리거된 워크플로의 `inputs` 컨텍스트 사용 예시\n\n`workflow_dispatch` 이벤트에서 트리거된 이 예시 워크플로는 `inputs` 컨텍스트를 사용하여 워크플로에 전달된 `build_id`, `deploy_target` 및 `perform_deploy` 입력의 값을 가져옵니다.\n\n```yaml copy\non:\n  workflow_dispatch:\n    inputs:\n      build_id:\n        required: true\n        type: string\n      deploy_target:\n        required: true\n        type: string\n      perform_deploy:\n        required: true\n        type: boolean\n\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    if: ${{ inputs.perform_deploy }}\n    steps:\n      - name: Deploy build to target\n        run: echo \"Deploying build:${{ inputs.build_id }} to target:${{ inputs.deploy_target }}\"\n```\n\n## 추가 참고 자료\n\n* [컨텍스트](/ko/enterprise-cloud@latest/actions/concepts/workflows-and-actions/contexts)"}