{"id":12525,"date":"2026-09-15T09:57:22","date_gmt":"2026-09-15T09:57:22","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=12525"},"modified":"2026-09-15T09:57:22","modified_gmt":"2026-09-15T09:57:22","slug":"microsoft-az-400-practice-test-questions-and-exam-dumps-part-7-q121-140","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-az-400-practice-test-questions-and-exam-dumps-part-7-q121-140\/","title":{"rendered":"Microsoft AZ-400 Practice Test Questions and Exam Dumps Part 7 Q121-140"},"content":{"rendered":"

View Full Microsoft AZ-400 Exam Dumps<\/a> and Practice Test Dumps<\/b><\/p>\n

 <\/p>\n

Q121. Which Azure DevOps feature can require specific checks to pass before a deployment to an environment proceeds?<\/b><\/h3>\n

1)<\/b> Repository tags<\/span>
\n<\/span> 2)<\/b> Environment checks<\/span>
\n<\/span> 3)<\/b> Pipeline cache<\/span>
\n<\/span> 4)<\/b> Git aliases<\/span><\/p>\n

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

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

Environment checks allow organizations to control when a pipeline can deploy to a protected environment. Checks can evaluate conditions such as approvals, business rules, branch restrictions, or other configured requirements before deployment begins. This provides an additional control layer beyond simply defining a deployment stage in YAML. For example, a production environment can require approval from an authorized person or require a specific condition to be satisfied before the deployment continues. Environment checks are useful for protecting critical resources and ensuring that automated pipelines follow organizational governance and release-management requirements.<\/span><\/p>\n

Q122. Which Azure DevOps feature is used to connect a pipeline securely to an external Azure resource?<\/b><\/h3>\n

1)<\/b> Service connection<\/span>
\n<\/span> 2)<\/b> Work item<\/span>
\n<\/span> 3)<\/b> Pipeline artifact<\/span>
\n<\/span> 4)<\/b> Git tag<\/span><\/p>\n

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

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

A service connection provides a secure way for Azure DevOps pipelines to authenticate and interact with external services or resources. Examples include Azure subscriptions, container registries, Kubernetes clusters, and other supported services. Instead of placing credentials directly inside pipeline code, the connection stores and manages authentication information through Azure DevOps. Administrators can control which pipelines are authorized to use a service connection, helping reduce unauthorized access. Service connections should follow the principle of least privilege so that a pipeline receives only the permissions necessary for its intended operations. Proper authorization and credential management are important parts of securing CI\/CD processes.<\/span><\/p>\n

Q123. A team wants to prevent developers from merging code until all required reviewers approve a pull request. Which feature should be configured?<\/b><\/h3>\n

1)<\/b> Pipeline caching<\/span>
\n<\/span> 2)<\/b> Artifact retention<\/span>
\n<\/span> 3)<\/b> Branch policy<\/span>
\n<\/span> 4)<\/b> Deployment slot<\/span><\/p>\n

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

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

Branch policies can enforce requirements that must be satisfied before changes are merged into a protected branch. One common policy requires a specified number of reviewers to approve a pull request. Other policies can require successful builds, linked work items, resolved comments, or other conditions. These controls help maintain code quality and protect important branches such as main or production branches. Instead of relying on developers to follow the process manually, branch policies enforce the requirements consistently. This supports collaborative development while reducing the likelihood that unreviewed or unvalidated changes are introduced into critical code branches.<\/span><\/p>\n

Q124. Which Git operation creates a new commit that reverses the changes introduced by an earlier commit?<\/b><\/h3>\n

1)<\/b> Git reset<\/span>
\n<\/span> 2)<\/b> Git clone<\/span>
\n<\/span> 3)<\/b> Git fetch<\/span>
\n<\/span> 4)<\/b> Git revert<\/span><\/p>\n

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

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

The Git revert operation creates a new commit that reverses the changes introduced by a previous commit. This approach is especially useful when a change has already been shared with other developers or merged into a protected branch because it preserves the existing commit history. By creating a new commit, the repository maintains a clear record of both the original change and the subsequent correction. In contrast, operations that rewrite history can be more disruptive when used on shared branches. Git revert is therefore commonly used when teams need to safely undo a problematic change while maintaining traceability.<\/span><\/p>\n

Q125. Which Git feature allows a specific commit to be applied to another branch without merging the entire branch?<\/b><\/h3>\n

1)<\/b> Git cherry-pick<\/span>
\n<\/span> 2)<\/b> Git clone<\/span>
\n<\/span> 3)<\/b> Git stash<\/span>
\n<\/span> 4)<\/b> Git init<\/span><\/p>\n

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

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

Git cherry-pick allows a developer to apply the changes introduced by a specific commit to the current branch. This can be useful when a particular bug fix or improvement is needed in another release branch without bringing over all the changes from the original branch. For example, a critical production fix may be developed on one branch and then selectively applied to a maintenance branch. Teams should use cherry-pick carefully because it can create duplicate commits and may lead to conflicts if the branches have diverged significantly. Proper review and testing should still be performed after applying the selected commit.<\/span><\/p>\n

Q126. Which Azure DevOps feature can store pipeline definitions, scripts, and configuration together with application source code?<\/b><\/h3>\n

1)<\/b> Azure Monitor<\/span>
\n<\/span> 2)<\/b> Azure Repos<\/span>
\n<\/span> 3)<\/b> Azure Boards<\/span>
\n<\/span> 4)<\/b> Azure Test Plans<\/span><\/p>\n

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

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

Azure Repos provides Git repositories where teams can store application source code and related files, including YAML pipeline definitions, deployment scripts, infrastructure definitions, and configuration templates. Keeping these resources in source control provides version history and enables changes to be reviewed through pull requests. Pipeline-as-code practices also make CI\/CD definitions easier to reproduce and maintain because the pipeline configuration evolves alongside the application. Teams can use branches and policies to control changes to these files. Storing deployment-related code in the repository improves traceability and supports a more consistent infrastructure and application delivery process.<\/span><\/p>\n

Q127. Which pipeline feature allows the same YAML definition to be reused with different values for different scenarios?<\/b><\/h3>\n

1)<\/b> Pipeline parameters<\/span>
\n<\/span> 2)<\/b> Build agent<\/span>
\n<\/span> 3)<\/b> Artifact feed<\/span>
\n<\/span> 4)<\/b> Deployment history<\/span><\/p>\n

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

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

Pipeline parameters allow a YAML pipeline to accept configurable values and use those values when the pipeline is processed. This makes a pipeline more reusable because the same definition can support different environments, services, deployment options, or processing modes. Parameters can also influence which sections of the pipeline are included or executed. This differs from ordinary runtime variables because parameters are evaluated during template expansion and pipeline processing. Proper parameter design can reduce duplicate pipeline definitions while still providing flexibility. Teams should restrict sensitive information from parameters and use appropriate secret-management mechanisms for credentials and confidential values.<\/span><\/p>\n

Q128. Which feature is most appropriate for storing reusable YAML pipeline components?<\/b><\/h3>\n

1)<\/b> Deployment slot<\/span>
\n<\/span> 2)<\/b> Git tag<\/span>
\n<\/span> 3)<\/b> Pipeline template<\/span>
\n<\/span> 4)<\/b> Test result<\/span><\/p>\n

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

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

Pipeline templates allow teams to define reusable YAML components that can be included in multiple pipelines. Templates can contain common stages, jobs, steps, or configuration patterns, helping organizations avoid duplicating the same YAML across many projects. For example, a company can create a standard testing template and reuse it across multiple applications. Changes to centralized templates can also help maintain consistent CI\/CD practices, although teams should carefully manage template versions to avoid unexpected changes. Reusable templates are particularly valuable in larger DevOps environments where many teams need common build, security, testing, and deployment processes.<\/span><\/p>\n

Q129. What is the primary benefit of using a pipeline cache for dependencies?<\/b><\/h3>\n

1)<\/b> It permanently replaces source control<\/span>
\n<\/span> 2)<\/b> It can reduce build time by reusing previously downloaded dependencies<\/span>
\n<\/span> 3)<\/b> It automatically approves production deployments<\/span>
\n<\/span> 4)<\/b> It removes the need for testing<\/span><\/p>\n

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

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

Pipeline caching can improve build performance by storing dependencies or other reusable data so that later pipeline runs do not always need to download or recreate the same content. For projects with large dependency sets, repeatedly retrieving packages can consume significant time. A cache can allow subsequent builds to reuse previously stored content when the cache key indicates that the dependencies are still applicable. Caching should not be confused with artifact storage because cached data is primarily intended to improve execution performance. Teams should also ensure that cache keys change appropriately when dependency definitions change so stale content is not reused incorrectly.<\/span><\/p>\n

Q130. Which practice helps ensure that production receives the exact artifact that was tested earlier?<\/b><\/h3>\n

1)<\/b> Rebuild the application separately for production<\/span>
\n<\/span> 2)<\/b> Change source code after testing<\/span>
\n<\/span> 3)<\/b> Build once and deploy the same artifact<\/span>
\n<\/span> 4)<\/b> Skip integration testing<\/span><\/p>\n

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

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

The build-once-and-deploy approach creates an artifact one time and then promotes that same artifact through testing, staging, and production environments. This reduces the risk that production receives a different build from the one that was validated earlier. Rebuilding the application separately for each environment can introduce differences caused by dependencies, build tools, source changes, or configuration. Using the same immutable artifact improves traceability because teams can identify exactly what was tested and deployed. Environment-specific settings should generally be supplied separately from the application artifact. This practice supports reliable continuous delivery and stronger software supply-chain control.<\/span><\/p>\n

Q131. Which Azure DevOps feature can trigger a pipeline when another pipeline successfully completes?<\/b><\/h3>\n

1)<\/b> Pipeline resource trigger<\/span>
\n<\/span> 2)<\/b> Agent demand<\/span>
\n<\/span> 3)<\/b> Secure file<\/span>
\n<\/span> 4)<\/b> Branch comment<\/span><\/p>\n

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

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

A pipeline resource trigger allows one Azure Pipeline to respond to the completion of another pipeline. This is useful when delivery processes are organized into multiple pipelines with dependencies between them. For example, a build pipeline can produce a validated artifact, and a downstream deployment pipeline can automatically start after the build completes successfully. Pipeline resources can also provide information about the source pipeline and its associated artifacts. This approach helps teams create modular CI\/CD workflows instead of placing every operation into one large pipeline. Appropriate permissions and conditions should still be configured to ensure that downstream deployments occur safely.<\/span><\/p>\n

Q132. Which YAML capability is useful when a pipeline must execute different stages depending on the branch?<\/b><\/h3>\n

1)<\/b> Conditions<\/span>
\n<\/span> 2)<\/b> Artifact retention<\/span>
\n<\/span> 3)<\/b> Service hooks<\/span>
\n<\/span> 4)<\/b> Secure files<\/span><\/p>\n

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

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

YAML conditions allow pipeline stages, jobs, or steps to execute only when specified criteria are met. Branch-based conditions are useful when teams want different workflows for different branches. For example, changes to a development branch may trigger testing deployments, while changes to the main branch may be eligible for production deployment after required checks. Conditions can evaluate predefined variables and the results of previous pipeline activities. This provides flexibility without requiring separate pipeline definitions for every branch. Teams should design conditions carefully and ensure that important production protections are enforced through appropriate approvals and environment controls.<\/span><\/p>\n

Q133. Which Azure service can centralize secrets and cryptographic keys used by applications and pipelines?<\/b><\/h3>\n

1)<\/b> Azure Boards<\/span>
\n<\/span> 2)<\/b> Azure Key Vault<\/span>
\n<\/span> 3)<\/b> Azure Repos<\/span>
\n<\/span> 4)<\/b> Azure Test Plans<\/span><\/p>\n

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

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

Azure Key Vault provides secure management of secrets, keys, and certificates. Applications and DevOps pipelines can retrieve required secrets without storing sensitive values directly in source code or pipeline YAML. Access to Key Vault can be controlled through identities and permissions, helping organizations follow least-privilege principles. Key Vault is particularly useful when multiple applications or environments need secure access to shared credentials or certificates. Integrating Key Vault into CI\/CD processes reduces the risk of exposing secrets through source control or configuration files. Organizations should also monitor access and regularly review permissions to maintain a strong security posture.<\/span><\/p>\n

Q134. Which practice helps detect vulnerable third-party libraries before an application is released?<\/b><\/h3>\n

1)<\/b> Dependency scanning<\/span>
\n<\/span> 2)<\/b> Git cloning<\/span>
\n<\/span> 3)<\/b> Branch deletion<\/span>
\n<\/span> 4)<\/b> Manual deployment<\/span><\/p>\n

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

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

Dependency scanning examines application dependencies and package versions to identify known security vulnerabilities. Modern applications often rely on many third-party libraries, and a vulnerability in one dependency can introduce risk into the application. Adding dependency scanning to the CI\/CD workflow allows teams to identify problems earlier, before vulnerable software reaches production. Depending on the tools and configuration, scans may compare dependency versions against vulnerability databases and generate alerts or fail builds when defined severity thresholds are exceeded. This supports the DevSecOps principle of integrating security activities into development and delivery rather than waiting until after deployment.<\/span><\/p>\n

Q135. Which Azure DevOps capability provides a historical record of deployments to an environment?<\/b><\/h3>\n

1)<\/b> Pipeline cache<\/span>
\n<\/span> 2)<\/b> Environment deployment history<\/span>
\n<\/span> 3)<\/b> Git stash<\/span>
\n<\/span> 4)<\/b> Repository fork<\/span><\/p>\n

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

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

Environment deployment history provides information about deployments performed against an Azure DevOps environment. Teams can use this information to determine what was deployed, when the deployment occurred, and which pipeline execution was associated with it. Deployment history improves traceability and can help during troubleshooting, auditing, and incident investigation. For example, if an application begins failing after a recent release, engineers can review deployment records to identify the relevant change and pipeline run. Maintaining this history supports accountability and provides useful operational context for teams responsible for managing application releases across development, testing, staging, and production environments.<\/span><\/p>\n

Q136. Which strategy helps reduce the risk of accidentally exposing secrets in pipeline logs?<\/b><\/h3>\n

1)<\/b> Print every variable for troubleshooting<\/span>
\n<\/span> 2)<\/b> Store passwords in source code<\/span>
\n<\/span> 3)<\/b> Use secret variables and avoid logging their values<\/span>
\n<\/span> 4)<\/b> Commit credentials to the repository<\/span><\/p>\n

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

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

Secret variables and dedicated secret-management services help prevent sensitive information from being exposed through source code or pipeline configuration. Pipeline tasks should avoid printing passwords, tokens, connection strings, or other confidential values to logs. Even when a platform provides masking capabilities, teams should not intentionally echo secrets during troubleshooting because masking is not a substitute for secure practices. Access should also be restricted to only the identities and pipelines that require the secret. Combining secure storage, least-privilege permissions, and careful logging practices significantly reduces the chance that credentials will be accidentally disclosed during automated builds and deployments.<\/span><\/p>\n

Q137. Which Azure DevOps feature allows teams to manage work items such as bugs, tasks, and user stories?<\/b><\/h3>\n

1)<\/b> Azure Boards<\/span>
\n<\/span> 2)<\/b> Azure Repos<\/span>
\n<\/span> 3)<\/b> Azure Artifacts<\/span>
\n<\/span> 4)<\/b> Azure Monitor<\/span><\/p>\n

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

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

Azure Boards provides tools for planning, tracking, and managing development work. Teams can create and organize work items such as user stories, tasks, bugs, features, and epics. Boards can support different development approaches, including Scrum and Kanban-style workflows. Work items can also be connected with commits, pull requests, builds, and deployments to improve traceability. This connection helps teams understand how planned work progresses through development and delivery. Azure Boards therefore supports the collaboration and planning side of DevOps while integrating with other Azure DevOps services used for source control, automation, testing, and deployment.<\/span><\/p>\n

Q138. Which metric measures how long it takes for a code change to move from its initial commit until it is successfully deployed?<\/b><\/h3>\n

1)<\/b> Deployment frequency<\/span>
\n<\/span> 2)<\/b> Lead time for changes<\/span>
\n<\/span> 3)<\/b> Change failure rate<\/span>
\n<\/span> 4)<\/b> Availability percentage<\/span><\/p>\n

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

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

Lead time for changes measures the time required for a code change to move through the delivery process, typically from commit or development completion until deployment. A shorter lead time can indicate an efficient delivery process, provided that quality and reliability remain strong. Teams can analyze lead time to identify bottlenecks such as lengthy reviews, slow testing, manual approvals, or inefficient deployment processes. This metric is useful for understanding delivery performance and identifying opportunities for improvement. However, teams should avoid optimizing lead time at the expense of security, testing, stability, or other important quality requirements.<\/span><\/p>\n

Q139. What is the main purpose of using Infrastructure as Code in a DevOps environment?<\/b><\/h3>\n

1)<\/b> To manually configure every server<\/span>
\n<\/span> 2)<\/b> To eliminate version control<\/span>
\n<\/span> 3)<\/b> To define and provision infrastructure through repeatable code<\/span>
\n<\/span> 4)<\/b> To replace application testing<\/span><\/p>\n

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

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

Infrastructure as Code, or IaC, represents infrastructure configuration through machine-readable definitions that can be version controlled and deployed repeatedly. Instead of manually configuring resources, teams can define networks, virtual machines, storage, permissions, and other infrastructure components through tools such as Bicep or Terraform. IaC improves consistency and reduces configuration errors because environments can be created using standardized definitions. It also provides change history and supports automated infrastructure deployment through CI\/CD pipelines. Teams can review infrastructure changes through source control and apply testing or policy checks before changes are introduced into important environments.<\/span><\/p>\n

Q140. Which practice helps an organization continuously improve its DevOps delivery process?<\/b><\/h3>\n

1)<\/b> Ignore deployment failures<\/span>
\n<\/span> 2)<\/b> Remove monitoring<\/span>
\n<\/span> 3)<\/b> Avoid collecting feedback<\/span>
\n<\/span> 4)<\/b> Analyze delivery results and implement improvements<\/span><\/p>\n

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

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

Continuous improvement involves regularly examining development and delivery processes, identifying bottlenecks or recurring problems, and implementing measurable improvements. Teams can use feedback from developers, operations staff, customers, monitoring systems, testing results, and delivery metrics to determine where improvements are needed. For example, a team may discover that lengthy manual approvals are delaying releases and then evaluate whether automation or better risk controls can improve the process. Continuous improvement should be treated as an ongoing activity rather than a one-time project. It helps organizations make DevOps practices more efficient, reliable, secure, and responsive over time.<\/span><\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

View Full Microsoft AZ-400 Exam Dumps and Practice Test Dumps   Q121. Which Azure DevOps feature can require specific checks to pass before a deployment to an environment proceeds? 1) Repository tags 2) Environment checks 3) Pipeline cache 4) Git aliases Correct Answer: 2) Explanation: Environment checks allow organizations to control when a pipeline can […]<\/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\/12525"}],"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=12525"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/12525\/revisions"}],"predecessor-version":[{"id":12536,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/12525\/revisions\/12536"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=12525"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=12525"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=12525"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}