GH-200 Questions and Answers

The simplest correct choice is a run step. A run step executes shell commands or scripts directly on the runner inside the current workflow job environment. It does not require packaging a JavaScript action, building a Docker container, publishing an image, or creating reusable action metadata. A JavaScript action is appropriate when you are building a reusable Node.js-based action. A Docker container action is useful when the execution environment must be packaged with dependencies, but it adds container overhead. A composite action is useful for reusable sequences of steps, but the question asks only for running a custom script inside the workflow environment. GitHub workflow syntax shows run steps as the native way to execute commands inside a job.

GitHub Enterprise Cloud can share actions and reusable workflows stored in an internal repository with workflows in other internal or private repositories. Access can be configured for repositories within the same organization or, where enterprise access is selected, repositories in organizations owned by the enterprise. Public repositories are deliberately excluded from this internal-action sharing model. GitHub explicitly states that actions and reusable workflows stored in internal repositories cannot be used by public repositories. The repository containing the action must also have its Actions Access setting configured appropriately; internal visibility alone does not automatically override that access control. Therefore, internal repositories and private repositories within the permitted organization or enterprise are the valid consumers, while both public-repository choices are incorrect.

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

A JavaScript action is identified in its action metadata file by the runs.using runtime value. In older exam-style content, this is commonly shown as node16; in current GitHub documentation, supported JavaScript runtimes have moved forward, but the principle remains the same: JavaScript actions declare a Node.js runtime under runs.using and specify the main JavaScript file under runs.main. Option A is not reliable because a repository can contain package.json without being a JavaScript action. Option B is unrelated because workflow files do not define the action type. Option C is naming-based and has no technical meaning. GitHub metadata syntax defines runs.using as the runtime for JavaScript actions.

When a workflow job targets an environment that has required reviewers, the job enters a waiting state until it is approved or rejected. GitHub Actions does not allow that waiting state to remain indefinitely. If the job is not approved within the allowed period, the workflow fails automatically. The correct duration is 30 days, making option C correct. Options A, B, and D do not match the GitHub Actions environment approval behavior. This is important for deployment governance because required reviewers can block access to protected environments and environment secrets, but pending approvals still have a maximum lifetime. This exam topic aligns with protected environments, deployment approvals, required reviewers, and workflow execution control.

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

The most common way to target a major release version of a GitHub Action is to reference a version tag such as @v3. This allows the workflow to use updates within that major version while avoiding automatic jumps to a newer major version that might introduce breaking changes. Option A references a commit SHA, which is the safest and most immutable method, but it is not the most common way to target a major release version. Option B is not a standard action version reference. Option D omits a version entirely, which is unsafe and not recommended because the action reference is incomplete. This topic maps to action versioning, marketplace action consumption, and reliable workflow maintenance.

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

Required reviewers is a protection rule where you can specify that certain individuals or teams must review and approve the workflow run before it can proceed. This is used to enforce approvals before certain steps or environments are accessed.

Wait timer is a protection rule that introduces a delay before a workflow can proceed to the next stage. This is useful for adding time-based constraints to the deployment process or ensuring that certain conditions are met before a workflow continues.

Searching the GitHub Marketplace for verified actions published by the cloud provider is the quickest and safest approach. Many cloud providers offer verified GitHub Actions that are maintained and optimized to interact with their services. These actions typically come with the correct configurations and best practices, allowing you to get started quickly without reinventing the wheel.

GitHub Actions provides the concurrency mechanism for preventing overlapping workflow runs or jobs that share the same concurrency group. A workflow can define a concurrency group associated with a deployment target so that only one matching deployment is running at a time. The deployment job should also reference the target GitHub environment, such as production, so GitHub can associate the job with that deployment environment and apply its deployment controls. GitHub ' s documentation specifically describes using concurrency to ensure that an environment has a maximum of one deployment in progress at a time. GitHub does not provide the mutex configuration described in options A, B, and F, and concurrency is not configured simply by assigning the numeric value 1. Therefore, specifying the concurrency scope together with the target environment is the appropriate solution.

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

GitHub Actions uses the special GITHUB_OUTPUT environment file to define output parameters for a workflow step. The required format is name=value, appended to the file. Therefore, writing action_color=purple to $GITHUB_OUTPUT correctly creates an output named action_color. The step should also have an id if another step needs to reference the value through the steps. < id > .outputs context. GITHUB_ENV serves a different purpose: it creates environment variables for subsequent steps in the same job. The add-mask workflow command masks sensitive values in logs, while debug writes diagnostic information. Neither defines an output parameter. GitHub ' s current workflow-command documentation explicitly identifies GITHUB_OUTPUT as the supported environment file for setting step outputs.

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

GitHub self-hosted runners maintain diagnostic information locally in the _diag directory beneath the runner installation directory. The runner application creates Runner_*.log files containing information about startup, connectivity, registration, updates, and general runner activity. Job-specific execution details are written to Worker_*.log files in the same diagnostic directory. These logs are therefore the primary source when investigating intermittent connection or execution problems. GitHub ' s troubleshooting documentation explicitly directs administrators to inspect the _diag directory and also provides connectivity-check scripts for diagnosing communication failures. The other options describe mechanisms that are not the documented standard procedure: there is no general repository-settings feature for downloading the runner ' s local diagnostic archive, and the suggested generic --debug and DEBUG=true mechanisms are not the prescribed runner troubleshooting method.

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

A composite action is identified by its action metadata file. In action.yml or action.yaml, the runs section must define using: " composite " . This tells GitHub Actions that the action is a composite action made from one or more reusable workflow steps. Option A is incorrect because Dockerfile and package.json files do not identify a composite action; they are usually associated with Docker or JavaScript-based projects. Option C is wrong because repository naming has no technical meaning in action classification. Option D is also wrong because an init.sh file is merely a script and does not define the action type. GitHub’s metadata syntax states that composite actions require runs.using to be set to composite.

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.

GitHub ' s current documentation states that when an organization uses an IP allow list with GitHub Actions, the appropriate choices are self-hosted runners or GitHub-hosted larger runners configured with static IP address ranges. A self-hosted runner has an address controlled by the organization, so its IP address or range can be explicitly added to the allow list. Larger GitHub-hosted runners can likewise be configured with predictable static IP ranges. Standard GitHub-hosted runners normally use dynamically assigned addresses from large shared ranges, and GitHub specifically recommends against relying on those ranges for this scenario. Marketplace action availability itself is not controlled by adding generic Actions IP ranges as option A suggests. Therefore, the solutions consistent with current GitHub Enterprise Cloud guidance are larger runners with static addresses and self-hosted runners with known addresses.

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

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.

The correct syntax for referencing a versioned action is owner/repository@ref. Therefore, to use version v1 of actions/javascript-action, the workflow step must use actions/javascript-action@v1. The @v1 portion is the ref, which can represent a tag, branch, or commit SHA depending on how the action publisher releases the action. Option A incorrectly treats the version as part of the repository path. Option B invents a separate version: key, which is not how action versions are selected. Option C changes the repository name and does not specify a ref. In GitHub Actions syntax, uses selects an action, and version selection is part of the action reference itself. GitHub examples use the uses: owner/action-name@ref form.

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.

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

A workflow becomes reusable when its on configuration includes the workflow_call event. This event declares that the workflow can be invoked by another workflow rather than only being started by ordinary repository events. Inputs and secrets can also be defined beneath workflow_call so the caller can provide values to the reusable workflow. workflow_run has a different purpose: it starts a workflow in response to another workflow running or completing. pull_request responds to pull-request activity, while check_run responds to GitHub Checks activity. GitHub ' s official reusable workflow documentation explicitly states that a reusable workflow must contain on: workflow_call. Therefore, workflow_call is the required keyword when defining a workflow intended to be called from other workflows.

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

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 Actions supports the use of service containers, which allows you to spin up a PostgreSQL database (or any other service) in a Docker container during your workflow. You can pull a PostgreSQL image from Docker Hub, and the container will automatically be available to your workflow job. This method requires no additional infrastructure and is easy to configure and maintain, as you simply define the container in the workflow file.

Using a commit hash is the safest method because it references a specific point in time in the repository’s history. This ensures that the action is locked to that exact version and will not be affected by any future changes or modifications to the codebase. Even if the action is updated later, your workflow will continue using the specific commit you referenced.

GitHub officially defines three major custom-action types: JavaScript actions, Docker container actions, and composite actions. There is no separate native Python action type. A Docker container action is appropriate when the implementation is written in Python because the container can package the Python runtime, application code, dependencies, and required operating-system components together. GitHub states that Docker container actions can use any base Docker image and therefore any programming language. This provides a predictable execution environment independent of the software preinstalled on the runner. JavaScript actions specifically execute packaged JavaScript using a supported Node.js runtime. Composite actions primarily combine multiple workflow steps and commands. For a self-contained custom action implemented in Python with its runtime and dependencies packaged alongside it, the Docker container action is the correct choice.

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

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.

The correct manual trigger for a GitHub Actions workflow is workflow_dispatch. Defining workflow_dispatch under the on key enables the workflow to be started manually from the GitHub UI, GitHub CLI, or API. Inputs are optional but valid; they allow the user to provide values when manually starting the workflow, so option A is also correct. A schedule trigger is for cron-based automatic execution, not manual execution. workflow_call is used to make a workflow reusable by another workflow; it does not create the manual “Run workflow” button. Therefore, A and C are the correct selections. GitHub’s documentation confirms that manual workflows require workflow_dispatch and can include custom inputs.

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.

The correct syntax includes specifying the job (example-job), the runner (ubuntu-latest), and the necessary step (npm install -g bats) within the workflow. This ensures that the package is installed properly during the execution of the job.

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.

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

GitHub Actions supports organization-level secrets with repository access policies. When the same secret must be centrally managed but made available only to particular repositories, an organization owner can create an organization secret and configure its Repository access policy for selected repositories. This avoids creating and maintaining separate copies of the secret in every repository while still enforcing scope restrictions. Environment secrets are created for environments within individual repositories, so there is no organization-level environment secret matching option B. GitHub repositories also do not provide a general Share secret option like option D. External secret-management systems can be integrated with GitHub Actions, but they are unnecessary for this requirement. Therefore, an organization secret restricted to selected repositories is the direct GitHub-supported solution.

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

Documentation is critical when distributing custom GitHub Actions because users need to understand what the action does and how to use it correctly. A good README or marketplace description explains the action’s purpose, required inputs, outputs, permissions, and expected behavior. This directly supports option B. Documentation should also include practical usage examples, such as a workflow snippet showing the uses: syntax and required with: inputs, which supports option C. Option A is incorrect because documentation does not create a README inside the consuming workflow; the action author provides documentation in the action repository. Option D is also incorrect because documentation does not automatically generate workflow auto-completion. This topic tests custom action publishing and usability best practices.

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

The runs-on keyword allows you to specify the operating system and other labels for the runner. By specifying self-hosted, windows, and x64, you are targeting a self-hosted Windows runner that matches these criteria, which aligns with the custom configuration of your self-hosted runner.

GitHub recommends versioning actions with stable references so consumers can deliberately select the code they want to execute. A full commit SHA is the most reliable and secure reference because it identifies one immutable Git commit; GitHub specifically identifies a full SHA as the safest option for stability and security. Tags are also a standard action-release mechanism. Action authors commonly create semantic-version tags such as v1.0.1 and maintain a major-version tag such as v1 so consumers can receive compatible fixes. By contrast, consuming an action directly from its default branch can introduce unexpected changes whenever that branch moves. An organization or repository name identifies where the action lives but does not by itself provide version stability. Therefore, commit SHA and tag are the two appropriate choices.

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

For a Docker container action to run in a GitHub Actions workflow, the runner must have Docker installed. The runs-on attribute of the job should specify an environment that supports Docker, typically a Linux environment (e.g., ubuntu-latest), since Docker is widely supported and commonly used in Linux-based environments.

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.

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.

The simplest official GitHub Actions action type for running shell commands or shell scripts is a composite action. Composite actions allow an action author to combine one or more run steps and reusable workflow commands in an action.yml file without needing to package a Docker image or write a JavaScript action. Option B is correct because it directly supports shell-based automation. Option A is heavier because Docker container actions require a container image or Dockerfile. Option D is used when the action logic is written in JavaScript and executed with Node.js. Option C is incorrect because “Bash script action” is not an official GitHub Actions action type. This topic checks custom action types and reuse patterns.

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.

The best approach is to use a service container for Redis. Service containers provide temporary supporting services for a workflow job, such as databases, caches, and message brokers, without permanently changing the runner. This is exactly what is needed when Redis is required only during workflow execution and should not affect future jobs on the self-hosted Linux runner. Option A installs Redis directly during the job and can introduce dependency, cleanup, and configuration risk. Option C requires separate infrastructure, which is unnecessary. Option D is incorrect because installing Redis into the runner image makes the runner stateful and harder to maintain. GitHub Actions workflow syntax supports jobs. < job_id > .services for service containers.