Microsoft GH-200 Dumps

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.

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 best way for an enterprise to control which GitHub Actions run is by creating a list of approved actions as an enterprise policy. This approach restricts workflows to only use the actions that are explicitly allowed, ensuring security and compliance within the organization.

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.

The first image shows a workflow trigger with an option for the test suite, and the chosen YAML configuration matches this interface. Specifically, the test suite input is defined with type: choice and includes the option value: functional, which aligns with the visible UI elements in the first image.

Using a tag is a best practice because tags are immutable and represent a fixed version of your action. By referencing tags, consumers of your action can be assured they are using a stable and specific version of the action, which helps in avoiding issues with breaking changes.

The commit SHA is another reliable way to specify a particular version of an action. By referencing a specific commit SHA, consumers can ensure they are using exactly the code that was written at that moment, avoiding the potential for changes in the future.

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

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

The workflow_dispatch event is used to manually trigger a workflow run in GitHub Actions. You can specify this event in the workflow file to allow users to manually trigger the workflow from the GitHub UI, often with optional input parameters.

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.

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

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.

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

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

Caching is ideal for files that change rarely, such as dependencies or build outputs, as it speeds up subsequent workflow runs by reusing previously cached files instead of re-downloading or rebuilding them.

Artifacts are used for persisting files produced during a job that need to be used in later jobs or after the workflow has ended, allowing them to be downloaded or referenced later.

A. Use the actions/setup-docker action

B. Authenticate to the GitHub Container Registry.

C. Build the container image.

D. Push the image to the GitHub Container Registry

E. Pull the image from the GitHub Container Registry.

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.

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.

A matrix strategy allows you to define different versions of a programming language (or any other environment setting) and run tests on each version simultaneously. This is particularly useful for testing code compatibility across different versions of a language.

A matrix strategy can also be used to test code on multiple operating systems (e.g., Windows, macOS, Linux) by defining these operating systems as matrix variables. This enables cross-platform testing within the same workflow.

GitHub ' s REST API provides a dedicated Download workflow run logs endpoint. The request uses the HTTP GET method and the path /repos/{owner}/{repo}/actions/runs/{run_id}/logs. GitHub responds with a redirect to an archive containing the log files for that workflow run. The endpoint requires the repository owner, repository name, and workflow run ID. For private repositories, the caller must authenticate with appropriate repository or Actions read permissions. A POST request is not used because retrieving logs is a read operation. The artifacts endpoint manages workflow artifacts rather than workflow execution logs. Therefore, option A exactly matches the current GitHub REST API endpoint documented for downloading the log archive associated with a workflow run.

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

The correct native GitHub Actions method for passing files between jobs in the same workflow is artifact storage. Workflow artifacts are designed to persist files produced by one job so they can be downloaded and used by another job later in the workflow. Job outputs are better suited for passing small values, strings, IDs, flags, or metadata between jobs, not full files. Caching is intended to speed up repeated workflow runs by reusing dependencies or build outputs; it is not the proper mechanism for transferring job-produced files. An external blob store can work architecturally, but it is not the native GitHub Actions method. Therefore, artifact storage is the best and most exam-aligned answer for passing files between jobs.

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.

A composite action allows you to bundle multiple steps into a single reusable action within a workflow. It is composed of multiple run steps or other actions and can be reused across workflows, making it the perfect choice for bundling a series of steps.

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.

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.

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.

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.

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

GitHub Actions routes jobs to self-hosted runners by using runner labels. Custom labels representing required capabilities, such as the operating-system version and Xcode version, can be created and assigned to the appropriate runner. The workflow then specifies those labels in runs-on. When multiple labels are supplied, GitHub requires an eligible runner to match all specified labels, so runs-on: [self-hosted, macos-10.15, xcode-11.2] targets the intended runner configuration. Runner groups are primarily an access-control and organizational mechanism and are not represented by the ${{ groups.* }} expression shown in option B. The Xcode/macOS versions in this exam scenario are historical, but the runner-label routing principle remains current. GitHub documentation confirms custom labels and cumulative runs-on label matching.

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

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.

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.

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

The workflow_run event is designed to trigger one workflow based on the execution or completion of another workflow. The deployment workflow can therefore specify the build workflow under on.workflow_run.workflows and use the completed activity type without changing the original build workflow. One important detail is that workflow_run fires when the specified workflow completes regardless of whether it succeeded or failed. If deployment must occur only after a successful build, the deployment job should additionally use a condition such as github.event.workflow_run.conclusion == ' success ' . workflow_dispatch is a manual trigger, repository_dispatch is normally used for externally generated custom events through the GitHub API, and workflow_exec is not a GitHub Actions workflow event. Therefore, workflow_run is the correct trigger.

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

The repository_dispatch event allows you to trigger a workflow in response to external activity. It is commonly used when you need to trigger a workflow from outside GitHub, such as from another system or service, by sending a request to the GitHub API. This event provides flexibility to integrate with various external systems and trigger workflows in a GitHub repository.

The action.yml file defines the inputs and outputs for a GitHub Action. This file contains metadata about the action, including the required inputs and outputs, as well as other configurations like the action ' s description, runs, and environment setup.

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.

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.

GitHub-hosted runners have a limit on the number of concurrent workflows (typically 20 for free-tier accounts and 5 for enterprise). If your organization needs to run more workflows simultaneously, you would need to use self-hosted runners to increase the available concurrency.

Self-hosted runners allow you to configure specialized hardware or software setups that are necessary for certain workflows. GitHub-hosted runners may not have access to custom hardware configurations like GPUs or other specialized resources, so self-hosted runners are required in such cases.

GITHUB_RUN_NUMBER is one of the default environment variables automatically created by GitHub for every workflow run. It contains a unique sequential number for each run of a particular workflow in a repository. When referenced from a shell command on a Linux runner, the correct environment-variable syntax is $GITHUB_RUN_NUMBER, making option A correct. GitHub also explains that default environment variables are not members of the env context, so ${{ env.GITHUB_RUN_NUMBER }} is not the appropriate workflow expression. The equivalent GitHub context property is ${{ github.run_number }}, but that exact expression is not one of the answer choices. The vars context is intended for configuration variables explicitly created by users or administrators. Therefore, among the supplied choices, $GITHUB_RUN_NUMBER is the documented valid reference.

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

The run keyword executes commands using the default shell unless a different shell is specified. Since the commands shown are Python statements, the step must define shell: python so GitHub Actions interprets the script using Python instead of Bash, PowerShell, or another default shell. Option D is therefore correct. Option A is invalid because with: is used to pass inputs to actions, not to define the interpreter for a run command. Option B would execute the text as Bash and fail because import os is not Bash syntax. Option C only changes the working directory and does not change the shell. This exam topic checks workflow syntax, shell selection, and step-level command execution.

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

Since the self-hosted runner is configured on a Linux VM and the script is written in PowerShell, you can invoke the script using the pwsh (PowerShell Core) shell in a run step in the workflow. This ensures that the script runs as-is on the Linux runner, as PowerShell Core (pwsh) is cross-platform and supports Linux.

The $GITHUB_OUTPUT file is used to pass data from one step to another in GitHub Actions. The echo command appends the key-value pair to this file, which sets the output variable (MY_OUTPUT) for the current step.