[Microsoft] Microsoft - GH-200 Exam Dumps & Study Guide

Free [Microsoft] Microsoft - GH-200 Practice Questions Preview

• Question 1

  How should you print a debug message in your workflow?

  • A. echo "::debug::Set variable myVariable to true"
  • B. echo "Set variable MyVariable to true" >> $DEBUG_MESSAGE
  • C. echo "::add-mask::Set variable myVariable to true"
  • D. echo "debug_message=Set variable myVariable to true" >> &GITHUB_OUTPUT

  Correct Answer: A

  Explanation:

  I agree with the suggested answer A. GitHub Actions utilizes specific workflow commands formatted as strings echoed to stdout to interact with the runner, and the ::debug:: prefix is the standard syntax for emitting debug-level logs.

  Reason

  Option A is correct because echo "::debug::{message}" is the official toolkit command for printing a debug message. These messages are hidden by default and only appear in the log when step debug logging is enabled by setting the secret ACTIONS_STEP_DEBUG to true.

  Why the other options are not as suitable

  • Option B is incorrect because $DEBUG_MESSAGE is not a standard environment variable or valid file descriptor for capturing debug output in GitHub Actions.
  • Option C is incorrect because ::add-mask:: is used to obfuscate sensitive information in logs, replacing the specified string with asterisks rather than marking it as a debug message.
  • Option D is incorrect because it uses the syntax for environment files (specifically $GITHUB_OUTPUT) which is intended for passing data between steps, not for emitting log messages.

  Citations

  • https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-a-debug-message

• Question 2

  As a developer, you are designing a workflow and need to communicate with the runner machine to set environment variables, output values used by other actions, add debug messages to the output logs, and other tasks. Which of the following options should you use?

  • A. composite run step
  • B. enable debug logging
  • C. self-hosted runners
  • D. environment variables
  • E. workflow commands

  Correct Answer: E

  Explanation:

  I agree with the suggested answer Option E. Workflow commands are the primary mechanism for a GitHub Actions runner to receive specific instructions from action code or scripts during execution, enabling dynamic updates to the environment and log output.

  Reason

  Option E is correct because workflow commands use a specific string syntax (e.g., echo "::command parameter::value") that the runner machine parses to perform tasks like setting environment variables, defining output parameters, masking secrets, and emitting debug messages directly into the logs.

  Why the other options are not as suitable

  • Option A is incorrect because a composite run step is a way to bundle multiple workflow steps into a single action, but it still requires workflow commands to communicate specific state changes back to the runner.
  • Option B is incorrect because enabling debug logging is a configuration setting (usually via a secret or variable) that reveals existing debug messages; it is not the mechanism used by the developer to create those messages or set variables.
  • Option C is incorrect because self-hosted runners are the infrastructure where jobs run, not the communication protocol used within the scripts.
  • Option D is incorrect because environment variables are the result of a configuration or command, but to dynamically set them for future steps during runtime, one must use a workflow command to write to the $GITHUB_ENV file.

  Citations

  • https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions

• Question 3

  When should you use the GITHUB_TOKEN in a workflow?

  • A. when you want to make authenticated calls to the GitHub API
  • B. when you want to connect to the runner via SSH
  • C. when you want to access repository-level secrets
  • D. when you want to call an action from the marketplace

  Correct Answer: A

  Explanation:

  I agree with the suggested answer A. The GITHUB_TOKEN is a special secret automatically generated by GitHub for each workflow run to facilitate secure authentication with the GitHub API without requiring manual secret management.

  Reason

  Option A is correct because the GITHUB_TOKEN is designed specifically to allow a workflow to perform authenticated operations on the repository, such as creating pull request comments, managing issues, or triggering further GitHub API endpoints, based on the permissions defined in the workflow's permissions key.

  Why the other options are not as suitable

  • Option B is incorrect because connecting to a runner via SSH (typically for debugging) requires specific runner configuration or third-party actions and usually involves SSH keys, not the repository's installation token.
  • Option C is incorrect because repository-level secrets are accessed using the secrets context (e.g., ${{ secrets.YOUR_SECRET }}); the GITHUB_TOKEN is itself a specific entry within that context, but it is used for API authentication rather than acting as a gateway to other secrets.
  • Option D is incorrect because calling an action from the GitHub Marketplace only requires referencing the action in your YAML syntax (e.g., uses: actions/checkout@v4); while the action itself might use the GITHUB_TOKEN internally to perform tasks, the token is not required simply to invoke or download the action.

  Citations

  • https://docs.github.com/en/actions/security-guides/automatic-token-authentication

• Question 4

  In which of the following scenarios should you use self-hosted runners? (Each correct answer presents a complete solution. Choose two.)

  • A. when the workflow jobs must be run on Windows 10
  • B. when jobs must run for longer than 6 hours
  • C. when a workflow job needs to install software from the local network
  • D. when GitHub Actions minutes must be used for the workflow runs
  • E. when you want to use macOS runners

  Correct Answer: BC

  Explanation:

  I agree with the suggested answer BC. GitHub-hosted runners have specific hard limits regarding job execution time and network isolation that only self-hosted runners can bypass.

  Reason

  Option B is correct because GitHub-hosted runners have a maximum job execution time of 6 hours. If a job requires more time, a self-hosted runner must be used as it does not have this specific timeout. Option C is correct because self-hosted runners can be placed within a private virtual network or local environment, allowing them to access internal resources, software repositories, or databases that are not reachable from the public internet where GitHub-hosted runners operate.

  Why the other options are not as suitable

  • Option A is incorrect because while GitHub-hosted runners typically use Windows Server images, they are sufficient for most Windows-based tasks; while Windows 10 specifically isn't a default hosted OS, the certification context prioritizes the definitive technical blockers in B and C.
  • Option D is incorrect because self-hosted runners are free to use and do not consume GitHub Actions minutes; using them for the purpose of consuming minutes is a misunderstanding of how billing works.
  • Option E is incorrect because GitHub provides macOS runners as part of its hosted fleet, so a self-hosted runner is not strictly required just to access the macOS operating system.

  Citations

  • https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/about-self-hosted-runners
  • https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/usage-limits-billing-and-administration

• Question 5

  As a developer, you need to leverage Redis in your workflow. What is the best way to use Redis on a self-hosted Linux runner without affecting future workflow runs?

  • A. Install Redis on the hosted runner image and place it in a runner group. Specify label: in your job to target the runner group.
  • B. Set up Redis on a separate machine and reference that instance from your job.
  • C. Specify container: and services: in your job definition to leverage a Redis service container.
  • D. Add a run step to your workflow, which dynamically installs and configures Redis as part of your job.

  Correct Answer: C

  Explanation:

  I agree with the suggested answer C. Using service containers is the standard GitHub Actions best practice for managing transient dependencies like Redis on self-hosted runners, as it ensures environmental isolation and automatic lifecycle management.

  Reason

  Option C is correct because the services: keyword in a GitHub Actions workflow allows you to spin up a Docker container (like redis) for the duration of a job. Since it is a container, it remains isolated from the host runner's operating system, and GitHub automatically stops and removes the container when the job finishes, ensuring no side effects or leftover processes persist for future runs.

  Why the other options are not as suitable

  • Option A is incorrect because installing Redis directly onto the self-hosted runner image makes the installation persistent. This could lead to port conflicts, resource exhaustion, or state leakage between different workflow runs on the same machine.
  • Option B is incorrect because while a separate machine provides isolation, it introduces significant administrative overhead, network latency, and complexity in managing the external lifecycle of that Redis instance.
  • Option D is incorrect because dynamically installing and configuring Redis via a run step is inefficient and requires custom cleanup logic to ensure the service is stopped and uninstalled, failing the requirement of not affecting future runs if the cleanup step fails or is skipped.

  Citations

  • https://docs.github.com/en/actions/using-containerized-services/about-service-containers
  • https://docs.github.com/en/actions/using-containerized-services/creating-redis-service-containers

• Question 6

  You installed specific software on a Linux self-hosted runner. You have users with workflows that need to be able to select the runner based on the identified custom software. Which steps should you perform to prepare the runner and your users to run these workflows? (Each correct answer presents part of the solution. Choose two.)

  • A. Configure the webhook and network to enable GitHub to trigger workflow.
  • B. Create the group custom-software-on-linux and move the runner into the group.
  • C. Inform users to identify the runner with the labels custom-software and linux.
  • D. Add the label linux to the runner.
  • E. Inform users to identify the runner based on the group.
  • F. Add the label custom-software to the runner.

  Correct Answer: CF

  Explanation:

  I agree with the suggested answer CF. In GitHub Actions, labels are the standard mechanism for routing jobs to specific self-hosted runners based on their capabilities or installed software.

  Reason

  Option F is correct because adding a custom label (like custom-software) to the runner is the technical step required to identify its unique capabilities to the GitHub Actions service. Option C is correct because users must be informed to update their workflow's runs-on property to include both the custom-software label and the linux label to ensure the job is routed to the correct machine.

  Why the other options are not as suitable

  • Option A is incorrect because webhooks and network configurations are foundational for connectivity but do not provide a mechanism for selecting specific runners based on software.
  • Option B is incorrect because runner groups are primarily used for security and access control (limiting which repositories can use a runner) rather than specific job routing based on software.
  • Option D is incorrect because self-hosted runners automatically receive the linux and self-hosted labels upon registration, so manual addition is redundant.
  • Option E is incorrect because while a job can target a group, labels are the intended and more granular way to identify specific environmental requirements like custom software.

  Citations

  • https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/using-labels-with-self-hosted-runners
  • https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/managing-access-to-self-hosted-runners-using-groups

• Question 7

  You need to trigger a workflow using the GitHub API for activity that happens outside of GitHub. Which workflow event do you use?

  • A. workflow_run
  • B. deployment
  • C. check_suite
  • D. repository_dispatch

  Correct Answer: D

  Explanation:

  I agree with the suggested answer D. The repository_dispatch event is the standard mechanism for triggering GitHub Actions workflows from external systems via the GitHub REST API, allowing for custom event types to be passed in the request body.

  Reason

  Option D is correct because repository_dispatch allows you to send a POST request to a specific GitHub repository's /dispatches endpoint. This is specifically designed for integration with third-party tools or external activity that occurs outside of the GitHub ecosystem, enabling those tools to kick off internal automation.

  Why the other options are not as suitable

  • Option A is incorrect because workflow_run is triggered only when a workflow is requested or completed, meaning it depends on internal GitHub Actions activity rather than external API calls.
  • Option B is incorrect because deployment is triggered by the creation of a deployment via the API or UI, which is a specific state-based event rather than a general-purpose trigger for external activity.
  • Option C is incorrect because check_suite is triggered by events related to code quality checks and status reports from integrated GitHub Apps, not for arbitrary external triggers.

  Citations

  • https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#repository_dispatch
  • https://docs.github.com/en/rest/repos/repos#create-a-repository-dispatch-event

• Question 8

  In which locations can actions be referenced by workflows? (Each correct answer presents a complete solution. Choose three.)

  • A. an .action extension file in the repository
  • B. a published Docker container image on Docker Hub
  • C. a public NPM registry
  • D. the runs-on: keyword of a workflow file
  • E. the repository’s Secrets settings page
  • F. a separate public repository
  • G. the same repository as the workflow

  Correct Answer: BFG

  Explanation:

  I agree with the suggested answer BFG. These locations align with the official GitHub Actions documentation regarding where a workflow can reference an action for execution.

  Reason

  Option B is correct because GitHub Actions allows you to reference a Docker container image directly from a registry like Docker Hub using the docker:// prefix. Option F is correct because actions are frequently shared via public repositories on GitHub, referenced by the path {owner}/{repo}@{ref}. Option G is correct because local actions can be referenced using a relative path within the same repository, typically located in the .github/actions directory.

  Why the other options are not as suitable

  • Option A is incorrect because there is no such thing as an .action extension file; actions are defined by an action.yml or action.yaml file.
  • Option C is incorrect because while NPM is used for JavaScript dependencies, GitHub Actions cannot be referenced directly as a package from the public NPM registry; they must be in a repository or container image.
  • Option D is incorrect because the runs-on keyword specifies the type of runner (e.g., ubuntu-latest) to execute the job, not the location of the action itself.
  • Option E is incorrect because the Secrets settings page is used for storing encrypted environment variables and credentials, not for referencing or hosting GitHub Actions logic.

  Citations

  • https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsuses
  • https://docs.github.com/en/actions/creating-actions/about-custom-actions

• Question 9

  Scheduled workflows run on the:

  • A. specified commit and branch from the workflow YAML file.
  • B. latest commit from the branch named schedule.
  • C. latest commit and branch on which the workflow was triggered.
  • D. latest commit from the branch named main.
  • E. latest commit on the default or base branch.

  Correct Answer: E

  Explanation:

  I agree with the suggested answer E. In GitHub Actions, scheduled workflows are specifically restricted to running on the latest commit of the repository's default branch.

  Reason

  Option E is correct because GitHub documentation specifies that the schedule event triggers a workflow run on the latest commit of the default or base branch (typically main or master). Even if the workflow file exists on other branches, the scheduler only considers the version and the context of the default branch.

  Why the other options are not as suitable

  • Option A is incorrect because the schedule trigger does not support manual overrides for specific commits or branches within the YAML syntax.
  • Option B is incorrect because there is no specialized branch name requirement like schedule for these tasks to function.
  • Option C is incorrect because a scheduled event is not triggered by a specific developer action on a feature branch; it is a system-level event that defaults to the main repository context.
  • Option D is incorrect because while main is the common default branch name, the rule applies to whatever branch is technically designated as the default branch in the repository settings, which could be named differently (e.g., master or develop).

  Citations

  • https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#schedule

• Question 10

  Custom environment variables can be defined at multiple levels within a workflow file including: (Each answer presents a complete solution. Choose three.)

  • A. top level.
  • B. step level.
  • C. default level.
  • D. runner level.
  • E. job level.
  • F. stage level.

  Correct Answer: ABE

  Explanation:

  I agree with the suggested answer ABE. GitHub Actions allows for environment variable scoping at the workflow (top), job, and step levels, which matches the ABE selection.

  Reason

  Top level (Option A) defines variables using the env key at the root of the workflow file, making them available to all jobs and steps. Job level (Option E) defines variables within a specific job block, making them accessible to all steps within that job. Step level (Option B) defines variables within an individual step, limiting their scope specifically to that action or shell command.

  Why the other options are not as suitable

  • Option C is incorrect because there is no default level for custom environment variables; while there are defaults for shell or working directory settings, environment variables are explicitly scoped to workflow, job, or step.
  • Option D is incorrect because runner level refers to variables set on the self-hosted runner machine's OS or via the runner environment, but they are not defined 'within a workflow file' using the standard YAML syntax for custom variables. Option F is incorrect because stage level is terminology used in Azure Pipelines or other CI/CD tools; GitHub Actions uses jobs rather than stages as the primary organizational unit.

  Citations

  • https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/variables