{"id":18951,"date":"2026-09-22T11:00:34","date_gmt":"2026-09-22T11:00:34","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18951"},"modified":"2026-09-22T11:00:34","modified_gmt":"2026-09-22T11:00:34","slug":"microsoft-gh-200-practice-test-questions-and-exam-dumps-part8-q141-160","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-gh-200-practice-test-questions-and-exam-dumps-part8-q141-160\/","title":{"rendered":"Microsoft GH-200 Practice Test Questions and Exam Dumps Part8 Q141-160"},"content":{"rendered":"

View Full <\/b>Microsoft GH-200 Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/h2>\n

 <\/p>\n

Question 141<\/b><\/h3>\n

Which GitHub feature automates dependency vulnerability alerts?<\/b><\/p>\n

    \n
  1. Dependabot alerts<\/span><\/li>\n
  2. Release notes<\/span><\/li>\n
  3. Repository topics<\/span><\/li>\n
  4. Project views<\/span><\/li>\n<\/ol>\n

    Correct Answer: 1<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    Dependabot alerts notify repository maintainers when dependencies are associated with known security vulnerabilities. GitHub uses dependency information and security advisory data to identify potentially affected packages and versions. These alerts help teams investigate vulnerable dependencies and determine whether updates or other mitigations are needed. Dependabot alerts are related to dependency security but are distinct from Dependabot version updates, which can create pull requests for newer dependency versions. Teams can use both capabilities together to monitor dependency health and automate appropriate update workflows.<\/span><\/p>\n

    Question 142<\/b><\/h3>\n

    Which GitHub security feature blocks some secrets before they reach a repository?<\/b><\/p>\n

      \n
    1. Code scanning<\/span><\/li>\n
    2. Push protection<\/span><\/li>\n
    3. Dependency review<\/span><\/li>\n
    4. Branch visualization<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      Secret scanning push protection can help prevent supported secrets from being pushed to repositories. When a detected secret matches supported patterns, GitHub can block the push and require the contributor to address the issue before continuing. This provides an earlier security control than discovering the secret after it has already entered repository history. Push protection works alongside secret scanning, which identifies exposed credentials through repository analysis and alerts. Teams should still rotate credentials if a secret has been exposed because preventing future exposure does not automatically invalidate an already compromised credential.<\/span><\/p>\n

      Question 143<\/b><\/h3>\n

      Which GitHub security tool analyzes source code for vulnerabilities?<\/b><\/p>\n

        \n
      1. Secret scanning<\/span><\/li>\n
      2. Dependabot<\/span><\/li>\n
      3. CodeQL<\/span><\/li>\n
      4. Dependency graph<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3<\/b><\/p>\n

        Explanation:<\/b><\/p>\n

        CodeQL is GitHub’s semantic code analysis technology used to identify security vulnerabilities and other coding problems. It represents source code in a queryable form and applies security queries to detect patterns associated with known classes of weaknesses. CodeQL analysis can be integrated with GitHub code scanning so findings appear as security alerts. It is different from secret scanning, which focuses on exposed credentials, and Dependabot, which focuses on dependencies. CodeQL can therefore provide source-code-level analysis as part of a broader application security program.<\/span><\/p>\n

        Question 144<\/b><\/h3>\n

        Which GitHub feature maps project dependencies automatically?<\/b><\/p>\n

          \n
        1. Dependency graph<\/span><\/li>\n
        2. Package dashboard<\/span><\/li>\n
        3. Repository map<\/span><\/li>\n
        4. Build inventory<\/span><\/li>\n<\/ol>\n

          Correct Answer: 4<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          GitHub’s dependency graph identifies dependencies used by supported repositories and represents relationships between projects and their packages. This information can support security features such as Dependabot alerts and dependency review. The dependency graph can derive dependency information from supported manifest and lock files. Maintaining accurate dependency files is therefore important for obtaining useful dependency visibility. The graph is not simply a list of files in a repository; it provides structured information about packages and their relationships to the project.<\/span><\/p>\n

          Question 145<\/b><\/h3>\n

          Which GitHub feature creates automated pull requests for dependency updates?<\/b><\/p>\n

            \n
          1. Dependabot version updates<\/span><\/li>\n
          2. Code scanning<\/span><\/li>\n
          3. Secret scanning<\/span><\/li>\n
          4. Repository rulesets<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            Dependabot version updates can automatically create pull requests that update project dependencies according to configured schedules and package ecosystems. The configuration is maintained in .github\/dependabot.yml, where repositories can specify directories, package managers, and update frequency. Automated update pull requests allow teams to review dependency changes using their normal development workflow. Dependabot version updates differ from Dependabot security alerts, which notify maintainers about known vulnerabilities. Teams can configure update behavior to balance maintenance frequency with the review and testing capacity of the project.<\/span><\/p>\n

            Question 146<\/b><\/h3>\n

            Which GitHub Actions permission permits writing repository contents?<\/b><\/p>\n

              \n
            1. contents: write<\/span><\/li>\n
            2. repository: modify<\/span><\/li>\n
            3. source: write<\/span><\/li>\n
            4. files: update<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              The contents: write permission grants a GitHub Actions workflow write access to repository contents through the associated GITHUB_TOKEN, where supported. This can be necessary for automation that creates commits, modifies repository files, or performs certain Git operations through GitHub APIs. Write permissions should not be granted unless they are actually required. Workflows that only need to read source files can normally use contents: read. Restricting permissions follows the principle of least privilege and reduces potential impact if a workflow or one of its dependencies is compromised.<\/span><\/p>\n

              Question 147<\/b><\/h3>\n

              Which GitHub Actions permission controls pull request modifications?<\/b><\/p>\n

                \n
              1. reviews: write<\/span><\/li>\n
              2. pull-requests: write<\/span><\/li>\n
              3. requests: modify<\/span><\/li>\n
              4. merge: write<\/span><\/li>\n<\/ol>\n

                Correct Answer: 2<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                The pull-requests: write permission allows a GitHub Actions workflow to perform supported write operations involving pull requests through its token. This can be useful for automation that comments on pull requests, modifies supported pull request metadata, or performs other permitted operations. Permissions are configured using the workflow or job-level permissions setting. Granting only the required permission is preferable to broad access. The exact operation still depends on GitHub’s supported token capabilities and repository policies, so workflows should be tested with the minimum permissions necessary.<\/span><\/p>\n

                Question 148<\/b><\/h3>\n

                Which GitHub Actions feature reuses a workflow across repositories?<\/b><\/p>\n

                  \n
                1. Reusable workflow<\/span><\/li>\n
                2. Repository template<\/span><\/li>\n
                3. Issue template<\/span><\/li>\n
                4. Workflow copy<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 1<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  Reusable workflows allow common GitHub Actions processes to be centralized and invoked by other workflows. A reusable workflow can define inputs, secrets, and outputs, allowing calling repositories to provide configuration while sharing standardized automation. Organizations can use this model for common CI, security, compliance, or deployment processes. Reusable workflows reduce duplicated YAML and make centralized improvements easier to distribute. Access controls should be considered when reusable workflows perform privileged operations, particularly when they can deploy software or access protected environments.<\/span><\/p>\n

                  Question 149<\/b><\/h3>\n

                  Which GitHub Actions feature packages multiple steps into one reusable action?<\/b><\/p>\n

                    \n
                  1. Composite action<\/span><\/li>\n
                  2. Workflow bundle<\/span><\/li>\n
                  3. Step collection<\/span><\/li>\n
                  4. Command package<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    A composite action packages multiple workflow steps into a reusable action. It is defined using an action.yml or action.yaml metadata file and can contain commands or other supported steps. Composite actions are useful when the same sequence of operations needs to appear in several workflows. They differ from reusable workflows because reusable workflows can contain jobs and workflow-level structure, while composite actions primarily encapsulate reusable step logic. Properly designed composite actions can reduce duplication and provide a consistent interface for repeated automation tasks.<\/span><\/p>\n

                    Question 150<\/b><\/h3>\n

                    Which GitHub Actions feature downloads source code into a runner?<\/b><\/p>\n

                      \n
                    1. actions\/checkout<\/span><\/li>\n
                    2. actions\/fetch-source<\/span><\/li>\n
                    3. github\/source-loader<\/span><\/li>\n
                    4. repository\/download<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      The actions\/checkout action retrieves repository content onto the GitHub Actions runner so subsequent workflow steps can work with the source files. It is commonly one of the first steps in build and test workflows. The action supports configuration for aspects such as branches, tags, fetch depth, and submodules. Workflow authors should select checkout settings according to their requirements because shallow or full history can affect commands that depend on Git history. Once source code is available on the runner, build tools and scripts can process it normally.<\/span><\/p>\n

                      Question 151<\/b><\/h3>\n

                      Which GitHub Actions setting controls checkout history depth?<\/b><\/p>\n

                        \n
                      1. fetch-depth<\/span><\/li>\n
                      2. history-size<\/span><\/li>\n
                      3. clone-depth<\/span><\/li>\n
                      4. git-depth<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        The fetch-depth input of the checkout action controls how much Git history is retrieved. A value of one provides a shallow checkout containing the latest commit, while setting the value to zero retrieves the full history. Shallow checkouts can reduce download time and storage requirements, but some operations such as historical comparisons, version calculations, or certain Git-based tools may require more history. Choosing the appropriate depth therefore depends on the workflow’s needs. Full history should be requested when later steps depend on information from earlier commits.<\/span><\/p>\n

                        Question 152<\/b><\/h3>\n

                        Which GitHub Actions feature enables dependency caching through an action?<\/b><\/p>\n

                          \n
                        1. actions\/cache<\/span><\/li>\n
                        2. actions\/store<\/span><\/li>\n
                        3. actions\/dependency-save<\/span><\/li>\n
                        4. github\/cache-files<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          GitHub provides the actions\/cache action for saving and restoring files between workflow runs. It is commonly used for package-manager dependencies and other reusable build data. The workflow specifies a cache key and typically a path representing the data to cache. When a matching key is found, the workflow can restore the cached content and avoid repeating expensive downloads or setup operations. Cache usage should be designed around stable dependency identifiers so changes to important inputs can produce a new cache rather than incorrectly reusing outdated content.<\/span><\/p>\n

                          Question 153<\/b><\/h3>\n

                          Which GitHub Actions feature uploads generated files from a workflow?<\/b><\/p>\n

                            \n
                          1. actions\/upload-artifact<\/span><\/li>\n
                          2. actions\/save-files<\/span><\/li>\n
                          3. actions\/publish-output<\/span><\/li>\n
                          4. github\/store-artifact<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 3<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            The actions\/upload-artifact action uploads files and directories as workflow artifacts. Artifacts can preserve build outputs, test reports, coverage files, logs, and other generated data after the workflow finishes. Later jobs or users can download these artifacts according to the repository’s configured access and retention rules. Artifact storage is useful when separate jobs need to exchange files because each job can execute on a different runner. It is distinct from caching, which is primarily designed to accelerate repeated operations rather than preserve workflow outputs for inspection or later processing.<\/span><\/p>\n

                            Question 154<\/b><\/h3>\n

                            Which GitHub Actions feature retrieves previously uploaded artifacts?<\/b><\/p>\n

                              \n
                            1. actions\/download-artifact<\/span><\/li>\n
                            2. actions\/fetch-artifact<\/span><\/li>\n
                            3. actions\/restore-output<\/span><\/li>\n
                            4. github\/download-files<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 4<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              The actions\/download-artifact action retrieves artifacts that were previously uploaded by a workflow. A later job can use it to obtain build packages, reports, test results, or other generated files. This is particularly useful when workflows separate compilation, testing, and deployment into different jobs. Since jobs may use separate runner machines, artifact transfer provides a controlled way to move generated files between those execution environments. Artifact names and workflow configuration should be managed carefully so downstream jobs retrieve the intended files.<\/span><\/p>\n

                              Question 155<\/b><\/h3>\n

                              Which GitHub Actions feature authenticates access to external cloud resources without long-lived secrets?<\/b><\/p>\n

                                \n
                              1. OIDC<\/span><\/li>\n
                              2. Webhooks<\/span><\/li>\n
                              3. Git tags<\/span><\/li>\n
                              4. Repository topics<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                OpenID Connect allows GitHub Actions workflows to request short-lived identity tokens that can be exchanged for temporary credentials with supported cloud providers. This can eliminate the need to store long-lived cloud access keys as repository secrets. The cloud provider can establish trust conditions based on claims from the GitHub-issued identity token, such as repository or environment information. This model supports more controlled authentication for deployment workflows. Administrators should configure the trust relationship carefully so only intended repositories, branches, environments, or workflows can obtain the requested cloud permissions.<\/span><\/p>\n

                                Question 156<\/b><\/h3>\n

                                Which GitHub Actions setting restricts workflow token permissions?<\/b><\/p>\n

                                  \n
                                1. permissions<\/span><\/li>\n
                                2. access-policy<\/span><\/li>\n
                                3. token-scope<\/span><\/li>\n
                                4. security-level<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  The permissions setting controls the access granted to the GITHUB_TOKEN used by GitHub Actions. Permissions can be configured at the workflow or individual job level, allowing automation to receive only the capabilities it needs. For example, a workflow may require read access to repository contents but no permission to modify pull requests or packages. Restricting token permissions supports the principle of least privilege. Job-level permissions can provide additional granularity when different stages of a workflow require different levels of GitHub access.<\/span><\/p>\n

                                  Question 157<\/b><\/h3>\n

                                  Which GitHub Actions feature controls simultaneous workflow runs?<\/b><\/p>\n

                                    \n
                                  1. Concurrency<\/span><\/li>\n
                                  2. Parallel-jobs<\/span><\/li>\n
                                  3. Run-control<\/span><\/li>\n
                                  4. Execution-policy<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    The concurrency feature controls how workflow runs or jobs are grouped and executed simultaneously. A concurrency group can prevent multiple runs of the same type from progressing at once and can optionally cancel an earlier in-progress run when a newer run begins. This is useful for deployment workflows where overlapping deployments could cause conflicts. It can also reduce unnecessary resource consumption for rapidly changing branches. Concurrency configuration should match the workflow’s operational requirements because some tasks should be allowed to finish rather than being canceled.<\/span><\/p>\n

                                    Question 158<\/b><\/h3>\n

                                    Which GitHub Actions feature defines a dependency between jobs?<\/b><\/p>\n

                                      \n
                                    1. needs<\/span><\/li>\n
                                    2. requires<\/span><\/li>\n
                                    3. depends-on<\/span><\/li>\n
                                    4. after-job<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 4<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      The needs keyword establishes job dependencies in GitHub Actions. A job that specifies another job in needs waits for the required job to complete before beginning, subject to workflow conditions. Dependencies can also expose outputs and results through the needs context. This allows workflows to represent stages such as build followed by testing and then deployment. Without explicit dependencies, independent jobs may execute concurrently. Defining dependencies carefully can improve workflow efficiency while ensuring that sensitive or downstream operations do not start before their prerequisites are completed.<\/span><\/p>\n

                                      Question 159<\/b><\/h3>\n

                                      Which GitHub Actions feature can require human approval before deployment?<\/b><\/p>\n

                                        \n
                                      1. Protected environments<\/span><\/li>\n
                                      2. Runner labels<\/span><\/li>\n
                                      3. Matrix variables<\/span><\/li>\n
                                      4. Artifact storage<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 2<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        GitHub environments can be configured with protection rules that require designated reviewers to approve deployment jobs before they proceed. This provides an additional control for sensitive environments such as production. A workflow associates a deployment job with the environment, and GitHub evaluates the environment’s configured protection requirements before allowing the job to continue. Environment protection can be combined with environment-specific secrets and other repository controls. This creates a separation between automated deployment execution and human authorization for selected deployment stages.<\/span><\/p>\n

                                        Question 160<\/b><\/h3>\n

                                        Which GitHub Actions trigger starts a workflow after another workflow completes?<\/b><\/p>\n

                                          \n
                                        1. workflow_after<\/span><\/li>\n
                                        2. workflow_run<\/span><\/li>\n
                                        3. workflow_complete<\/span><\/li>\n
                                        4. workflow_chain<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          The workflow_run event allows a GitHub Actions workflow to respond to activity associated with another workflow run. It can be configured for supported activity types, including completion-related events. This enables multi-workflow automation where one workflow performs a build or validation process and another handles subsequent tasks. The triggering workflow’s information can be examined by the responding workflow to determine what happened. This differs from workflow_call, which is designed for directly invoking a reusable workflow as part of another workflow’s execution.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Microsoft GH-200 Exam Dumps and Practice Test Dumps   Question 141 Which GitHub feature automates dependency vulnerability alerts? Dependabot alerts Release notes Repository topics Project views Correct Answer: 1 Explanation: Dependabot alerts notify repository maintainers when dependencies are associated with known security vulnerabilities. GitHub uses dependency information and security advisory data to identify […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18951"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=18951"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18951\/revisions"}],"predecessor-version":[{"id":18952,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18951\/revisions\/18952"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18951"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18951"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18951"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}