GH-200 GitHub Actions Exam Questions and Answers

Workflow files must be stored in the .github/workflows/ directory of the repository. This is the standard location for GitHub Actions workflow files, and workflows in this directory are automatically triggered by events defined in the file, such as pushes, pull requests, or other GitHub events.

Once the runner is properly configured and labeled, users should be informed to select the specific runner by identifying the label or group name when defining the runner in their workflows.

Adding a custom label (like custom-software) to the runner makes it easier for users to select the runner in their workflows by using the runs-on key, which allows them to choose this specific runner based on its label.

GitHub Marketplace is used to discover, share, and publish reusable automation, including GitHub Actions created by GitHub, vendors, and the community. Option C best describes this role. Marketplace does not exist only for billing, so option B is too narrow and incorrect. Option A is also wrong because Marketplace does not merely restrict third-party actions to public repositories; action usage is governed by repository, organization, or enterprise Actions policies. Option D is false because Marketplace does not bypass repository permissions or automatically deploy workflows into repositories. In exam terms, Marketplace is part of the automation reuse and action discovery domain: developers use it to find trusted or verified actions rather than building every integration manually. GitHub documents Marketplace as a place to publish and share actions with the community.

When troubleshooting a self-hosted runner, you can access the _diag folder located in the self-hosted runner ' s installation directory. This folder contains diagnostic logs that can help you identify the root cause of issues, such as connection problems.

The Actions tab on the main page of the repository is where you can find detailed information about the workflow runs, including step failures and build logs. You can review the status of each job and step within the workflow, see the failure messages, and access logs for debugging.

The GITHUB_TOKEN is automatically provided by GitHub in workflows and can be used to authenticate API requests to GitHub, including publishing packages to GitHub Packages.

The GITHUB_TOKEN is also used to authenticate API requests for actions like creating issues, commenting, or interacting with pull requests within the same repository.

Environment secrets are scoped to GitHub Actions environments and can be protected by environment protection rules. If an environment requires reviewers, a job that references that environment cannot access its environment secrets until the required approval is granted. This makes option A correct. Option B is incorrect because environment secrets are made available to jobs that reference the protected environment, not selectively to only one specific step by default. Option C is not the purpose of environment secrets; they are not specifically for connecting to GitHub Enterprise Server. Option D is also incorrect because GitHub environment secrets do not automatically pull from Azure Key Vault without additional integration or custom workflow logic. This topic covers environment protection, secrets, and deployment governance.

================

A workflow can be triggered by multiple events either by using array syntax, such as on: [push, pull_request], or by configuring each event separately when filters or activity types are needed. Option C is valid because both push and pull_request are supported workflow events. Option E is also valid because it configures two event triggers: push filtered to the main branch and release filtered to the created activity type. Option B is invalid because commit is not a GitHub Actions workflow event. Option A wrongly puts environments under on. Option D defines branch filters without an event. Option F uses initiate, which is not a valid event. GitHub documents both multiple-event array syntax and separate event configuration for filters.

For a composite action, commands are defined inside the runs.steps section of the action metadata file. When a specific command must execute from a particular folder, the correct key is working-directory, and it must be applied at the individual run step level. Option D is correct because it keeps using: " composite " at the runs level and applies working-directory: ${{ inputs.dir }} directly to the step that runs the script. Option A is incorrect because directory is not a valid GitHub Actions run-step key. Option B incorrectly places directory at the runs level. Option C uses the right keyword but places it at the wrong level. This tests composite action metadata syntax and correct step-level execution configuration.

The correct minimal syntax for declaring an output in GitHub Actions is by using the foo key under outputs, and associating it with a value (in this case, Some value). This is the simplest form to define an output in a workflow or action.

Documentation helps action consumers understand both what an action does and how to invoke it correctly. GitHub specifically recommends creating a README.md when publishing or sharing an action. Recommended content includes a detailed description of the action, required and optional inputs and outputs, secrets and environment variables used by the action, and an example showing how the action is referenced from a workflow. Therefore, documentation directly provides users with the action ' s description and practical usage examples. It does not automatically generate a README in the consuming repository or workflow, and documentation itself does not enable YAML autocomplete. Those capabilities are unrelated to ordinary action documentation. Clear documentation is especially important for reusable actions because consumers must understand expected inputs, outputs, permissions, and version references without inspecting the implementation source code.

================

The appropriate way to test a JavaScript action is to invoke that action from a GitHub Actions workflow and verify its behavior on an actual runner. GitHub ' s JavaScript-action documentation specifically demonstrates testing a newly created action by creating a workflow that references and executes it. This exercises the action ' s metadata, inputs, JavaScript entry point, runner behavior, outputs, and failure handling in the same environment where consumers will use it. @vercel/ncc or another bundler can package JavaScript and its dependencies into a distributable file, but bundling is not itself a functional test. A JavaScript action also does not need to be converted into a Docker container. Finally, actions/debug-javascript is not the documented mechanism for testing JavaScript actions. Therefore, option B provides the correct testing approach.

================

GitHub permits deletion of a workflow run after the run has completed. GitHub ' s current documentation also states that a workflow run may be deleted when it is more than two weeks old. Therefore, option A is a correct general statement and option C is incorrect because GitHub does not impose a 30-day minimum. Deleting a workflow run also does not require repository administrator access; GitHub specifies that write access to the repository is sufficient, which eliminates option D. Option B is too broad because an actively pending or queued workflow run is not generally treated the same as a completed run for immediate deletion. Removing a workflow run also removes its associated logs, which is relevant when managing workflow history or sensitive output. Therefore, option A is the correct selection.

================

In a Docker container action, the action.yml file includes the runs.using field, which is set to docker to specify that the action runs inside a Docker container. This is the key indicator that the action is a Docker container action.

The ::debug:: syntax is used to output debug messages in GitHub Actions workflows. This command will print the message " action successfully debugged " in the debug logs when the workflow runs.

GitHub workflow commands use the syntax ::command parameter=value::{message}. For an error annotation without file-location metadata, echo " ::error::There was an error " is valid because error is the workflow command and the text following the second :: is the message. GitHub also supports parameters such as file, line, and col, making option C valid for associating the error annotation with a specific source-code position. Option A incorrectly places the actual text in a message= parameter while leaving no message after the command separator. Option D also uses invalid workflow-command syntax because error=... is not the command format GitHub defines. Therefore, according to the current GitHub Actions workflow-command specification, the two valid commands are B and C.

================

Setting a debug message using ::debug:: command sends a message to the logs, helping with troubleshooting and providing insight into the workflow run.

Setting output parameters using ::set-output sends data from a job step to subsequent steps or jobs, which can be used later in the workflow.

A non-zero exit code is used to set the status of an action to " failed " in GitHub Actions. When the action ' s script or code exits with a non-zero status, it indicates failure, and GitHub will mark the action as failed.

GitHub Actions allows you to configure environment protection rules, where you can require specific users or teams to approve the deployment before the workflow proceeds to the next step. This ensures that the required reviewers approve the workflow before any sensitive actions (such as deployment) occur.

GitHub Actions uses the env key to define environment variables. The env mapping can be applied at the workflow, job, or individual step level. In option B, dbserver is defined directly beneath the step-level env key, making it available to that step ' s shell process. Because the example uses shell syntax appropriate to a Linux runner, $dbserver correctly references the environment variable from the run command. The variables and environment keys shown in options A and D are not valid substitutes for step-level env. Option C also uses an invalid list structure; env expects a mapping of variable names to values rather than name and value objects. Therefore, option B uses the supported GitHub Actions workflow syntax.

================

Creating workflow templates in the organization’s .github repository allows the organization to standardize workflows and make them easily reusable across multiple repositories. This ensures consistency and simplifies maintenance.

Creating reusable actions and workflows that can be called from other workflows helps modularize and standardize automation tasks. These reusable components can be maintained centrally and called from different workflows across repositories.

The core.warning() function from the @actions/core package is used to create a warning message in the workflow logs. This is an annotation type that informs users about issues that don ' t require failing the build but still need attention.

GitHub Actions supports the env key at three workflow syntax scopes: the workflow ' s top level, an individual job, and an individual step. A top-level env value is available to steps across all jobs in the workflow. jobs. < job_id > .env limits variables to the steps of one job, while jobs. < job_id > .steps[*].env limits them to a particular step. When the same variable name is defined at several levels, the most specific definition takes precedence while that scope executes. GitHub Actions does not define a generic stage scope, and defaults is used for default settings such as the shell or working directory rather than as another env scope. Likewise, runner level is not a workflow-file env scope. Therefore, step, top, and job levels are correct.

================

A Docker container action is ideal for custom actions that require specific environments or dependencies, such as Python. By creating a Docker container, you can define the environment with the necessary Python version and dependencies, and your Python code can run inside that container.

To target a specific self-hosted runner, the job must use runs-on with labels that match that runner. A self-hosted runner normally has the self-hosted label plus default labels and any custom labels you assign. Since the runner is labeled runner1, the workflow should specify both self-hosted and runner1: runs-on: [self-hosted, runner1]. GitHub Actions will then route the job only to a self-hosted runner matching all specified labels. Option A targets a different custom label. Option B is malformed and also mixes a self-hosted label with a GitHub-hosted runner label. Option D targets any self-hosted runner, not specifically runner1. GitHub documents that an array of runs-on labels requires a runner matching all listed labels.

GitHub Actions defines custom environment variables with the YAML env mapping. YAML mappings use a colon between each key and value, so MY_VARIABLE: my-value beneath env: is the correct syntax. The env key can appear at workflow, job, or step scope depending on how broadly the variable should be available. Options A, B, E, and F either use an unsupported key or the wrong assignment syntax. environment is associated with deployment environments when used in GitHub Actions workflow syntax; it is not the key for declaring ordinary environment variables. The vars context is used for configuration variables created through repository, organization, or environment settings, but var: is not the workflow syntax shown here. Therefore, option C correctly defines the requested custom environment variable.

================

The pull_request event supports activity-type filtering, including the labeled activity, so a workflow can respond when a label is added to a pull request. The branches filter limits execution according to the pull request ' s target or base branch, while the paths filter limits execution according to changed files. GitHub also states that when branch and path filters are both configured, both conditions must be satisfied . Therefore, a pull request targeting releases, containing a change beneath apps/**, and receiving a label matches option C. pull_request_review concerns review activity rather than labeling, and pull_request_label is not a GitHub Actions workflow event. Option B also uses filters that do not accurately represent the stated exact branch and folder requirement.

================

GitHub environments provide deployment protection controls such as required reviewers. First, the Production environment should be created in the repository ' s Settings > Environments configuration, where the VMOps team can be configured as required reviewers. This makes option C correct; the environment is not created as an organization-level environment as described by option B. Second, the deployment job must reference the Production environment. GitHub applies the environment ' s protection rules to jobs that reference that environment, so the deployment remains in a waiting state until an authorized reviewer approves it. GitHub environments are logical deployment-control resources; individual VMs do not need to be added to an environment, nor is an environment “owned” by a team. Therefore, options A and C together implement the required production approval gate.

================

GitHub-hosted runners automatically handle patching, meaning they will be kept up to date with the latest security updates and software patches for both the runner environment and the underlying operating system.

GitHub-hosted runners support Linux, Windows, and macOS, giving you flexibility to run workflows on different operating systems without needing to manage your own self-hosted runners.

GitHub secrets are defined at different levels: organization, repository, and sometimes at the workflow level. If a secret is defined at both the organization level and the repository level, the repository-level secret will take precedence. So, if the value of the secret differs between these levels, the workflow will use the value from the repository level instead of the organization level.

Scheduled GitHub Actions workflows use the schedule event beneath the workflow ' s on key. Each schedule is represented by a cron entry, which makes option A the valid structure. GitHub scheduled workflows use POSIX-style five-field cron syntax, and scheduled execution is interpreted in UTC by default. In the expression 45 7 * * 3,6, 45 represents minute 45, 7 represents 07:00 UTC, the two asterisks allow every day of the month and every month, and 3,6 specifies Wednesday and Saturday. Consequently, the workflow is scheduled for 07:45 UTC on both requested weekdays. Options B and D incorrectly place cron directly beneath on, while option C does not use the required schedule list containing a cron entry.

================

If a workflow depends on an external service that is down, disabling the workflow temporarily will prevent it from running and sending requests to the service, thus avoiding failed requests or unnecessary retries.

If a workflow is causing a negative impact on external services by generating too many requests or incorrect data due to a bug, temporarily disabling the workflow will stop this behavior while the issue is fixed.

The provided event trigger block specifies two types of events:

For issues: the workflow triggers on opened or edited issues.

For issue_comment: the workflow triggers when an issue comment is created.

This configuration ensures the workflow will run when either an issue is opened or edited, or an issue comment is created.

The most secure option listed is to use OIDC-based integration to obtain short-lived credentials from an external secrets manager or cloud provider. This avoids storing long-lived sensitive values directly in workflow YAML, repository text, or regular environment variables. Options A, B, and C are insecure because they expose or persist sensitive information in places that can be read, logged, committed, or mismanaged. With OIDC, the workflow requests a token from GitHub’s OIDC provider and exchanges it with the trusted external provider for a short-lived credential. This reduces secret sprawl and supports stronger authorization controls. GitHub documents OIDC as a way to avoid duplicating long-lived cloud credentials as GitHub secrets and to use short-lived access tokens instead.

Read access is sufficient to retrieve workflow artifacts from a repository. GitHub ' s Actions artifact API documentation states that anyone with read access to the repository can retrieve an artifact. For private repositories, authentication is still required, and token-based access must provide the necessary repository or Actions read permission, but the user ' s repository role does not need to be Write, Maintain, or Admin. Those higher roles grant additional repository-management capabilities that are unnecessary for simply downloading artifacts. Triage also provides more issue and pull-request management capabilities than basic Read, but it is not the minimum required repository role for artifact access. Therefore, following the principle of least privilege, Read is the lowest permission among the listed choices that supports downloading GitHub Actions workflow artifacts.

================

The GITHUB_ACTOR environment variable indicates the name of the person or app that initiated the workflow. This variable is automatically provided by GitHub in the workflow and can be used to identify the user or application triggering the workflow.

First, the dataset should be encrypted before being stored. This ensures that the data is protected when stored in a repository.

The encrypted dataset can be stored in a GitHub secret, ensuring it is securely kept and not exposed publicly.

The encryption key needed to decrypt the dataset should also be stored in a GitHub secret to maintain security during the workflow, allowing access only when needed.

GitHub Actions on GitHub Enterprise Server often requires an internet connection, especially for accessing actions from the GitHub Marketplace or third-party actions unless they are manually synced to the server.

To use third-party actions on GitHub Enterprise Server, GitHub Connect can be used to establish a connection between the server and GitHub.com, enabling access to third-party actions.

Third-party actions can also be manually synchronized to the GitHub Enterprise Server, making them available for use in workflows.