You save $69.98
AZ-400 Premium Bundle
- Premium File 398 Questions & Answers
- Last Update: Nov 11, 2026
- Training Course 27 Lectures
- Study Guide 784 Pages
You save $69.98
A deployment engineer cannot demonstrate that the package approved in preproduction is the exact one installed in production.
Which risk most directly follows if the team leaves this problem unresolved?
A new production build may incorporate an untested dependency or compiler result. The failure follows from the described gap because artifact promotion ensures deployment stages share tested bytes rather than rebuilding from potentially changing source or packages. Mitigate it by choosing to publish an immutable versioned build artifact once and promote the same artifact through environments.
This risk is associated with GitHub Actions versus Azure Pipelines: Both GitHub Actions and Azure Pipelines can automate CI/CD, but repository integration and governance capabilities determine the appropriate fit. The present scenario instead leaves the immutable pipeline artifact requirement unresolved, which creates this more direct risk: a new production build may incorporate an untested dependency or compiler result.
That consequence is characteristic of Date-based versioning: Calendar-based versions express release timing, but do not automatically convey semantic API compatibility. The present scenario instead leaves the immutable pipeline artifact requirement unresolved, which creates this more direct risk: a new production build may incorporate an untested dependency or compiler result.
That is a credible failure of GitHub Packages access: Package registry operations are authorized separately from ordinary repository read access, and permissions must match publish or consume operations. The present scenario instead leaves the immutable pipeline artifact requirement unresolved, which creates this more direct risk: a new production build may incorporate an untested dependency or compiler result.
A SaaS service sees identical defects re-opened after releases, while sprint metrics treat them as unrelated new tickets.
Which observation most directly confirms the required DevOps control is effective?
Repeated defects lead to updated regression tests and documented follow-up changes visible from their work items. This shows that the control was implemented as intended: define a feedback loop that links production defects to work items, root-cause labels, tests and retrospective improvements. It matters because tying operational feedback to original code and acceptance criteria exposes recurring failure patterns and supports process improvement.
That result would verify Cross-team workflow handoffs, where the relevant control is model explicit states, owners and handoff criteria for each work stage in Azure Boards or GitHub Projects.
This observation would support Wiki and process diagrams, where the relevant control is maintain reviewed Markdown documentation and Mermaid diagrams alongside the service delivery workflow.
Such evidence would establish Azure Boards GitHub traceability, where the relevant control is connect Azure Boards with GitHub and associate pull requests and commits with the corresponding work items.
A public API package introduces a breaking interface change but the team publishes it as a small patch update.
What is the most appropriate action for this DevOps team?
Apply semantic versioning and increase the major version for breaking public compatibility changes. SemVer communicates compatibility intent by distinguishing major breaks, compatible additions and backward-compatible fixes. A useful check is that a breaking update increments its major version and consumers intentionally opt into the new contract.
This would instead address Package vulnerability response: Traceable package metadata and dependency scanning link vulnerabilities to actual consumers and enable controlled remediation.
This is designed for Dependency lockfile reproducibility: A lockfile records the resolved dependency graph to make repeated builds use the same versions rather than current registry selection.
This would instead address Feature flag dark launch: Feature flags decouple delivery of code from exposure of functionality, allowing targeted enablement and rapid disablement.
A development leader wants to compare pull requests awaiting review against bugs still open in the sprint.
What is the most appropriate action for this DevOps team?
Define repeatable work item queries and dashboards filtered by state, type, age and team. Consistent query definitions produce comparable operational metrics from the underlying tracked work rather than manual snapshots. A useful check is that a saved dashboard correctly lists aging blocked work with matching criteria and updates as records change.
That intervention fits Mean time to restore: Recovery duration captures actual service impact better than activity counts and can guide investment in incident response.
This is designed for Deployment frequency and failure rate: Delivery speed without failure consequences is incomplete; balanced flow and stability indicators reveal unhealthy tradeoffs.
That intervention fits Webhooks for event integration: Event subscriptions push relevant changes to a receiver; delivery validation and idempotency are necessary for dependable automation.
A public repository held an access token in historic commits even after the current file was cleaned up.
Which observation most directly confirms the required DevOps control is effective?
The exposed token no longer authenticates and approved history-remediation checks find no accessible sensitive object. This shows that the control was implemented as intended: revoke and rotate the exposed credential immediately, remove sensitive history using an approved rewrite and coordinate downstream cleanup. It matters because deleting a current file does not remove earlier Git objects or copies; invalidating the credential is the immediate security control.
Such evidence would establish Feature branching with reviews, where the relevant control is use short-lived feature branches and protected pull requests with required reviewers and checks.
That result would verify Signed annotated release tags, where the relevant control is create protected annotated or signed release tags linked to immutable build and artifact identifiers.
This observation would support Recover one commit safely, where the relevant control is use git revert to create a compensating commit on shared history rather than forcibly resetting the published branch.
A GitHub application consumes outdated open-source libraries but no team owns remediation when advisories are published.
What is the most appropriate action for this DevOps team?
Enable Dependabot alerts and security updates, then validate proposed fixes in CI with clear ownership. Dependency scanning connects known advisories to manifest and lockfile versions and can propose reviewed updates. A useful check is that affected dependencies generate alerts or remediation pull requests and fixed versions pass regression tests.
That intervention fits GitHub Advanced Security and Defender: Integrated DevOps security posture helps central teams connect source risk with affected development assets and cloud governance.
This is designed for GitHub App scope: GitHub Apps separate automation identity from a human account and can grant repository-scoped, revocable access.
This would instead address CodeQL static analysis: Static code analysis can trace risky code patterns and data flow without relying on runtime exploitation to surface the flaw.
An enterprise wants management-group governance and resource-group application resources deployed through distinct accountable workflows.
Which risk most directly follows if the team leaves this problem unresolved?
An incorrect scope or excessive identity permissions can fail deployment or expand unintended blast radius. The failure follows from the described gap because azure Resource Manager scopes determine where resources and policy assignments can be created, independently of template language. Mitigate it by choosing to select the appropriate ARM deployment scope and grant the deployment identity only required scoped permissions.
This risk is associated with Concurrent deployment serialization: Serialization prevents conflicting writes to the same mutable production target while allowing independent builds elsewhere. The present scenario instead leaves the deployment scopes requirement unresolved, which creates this more direct risk: an incorrect scope or excessive identity permissions can fail deployment or expand unintended blast radius.
That is a credible failure of Azure Deployment Environments: Deployment Environments enables self-service provisioning through approved templates rather than arbitrary subscription-wide access. The present scenario instead leaves the deployment scopes requirement unresolved, which creates this more direct risk: an incorrect scope or excessive identity permissions can fail deployment or expand unintended blast radius.
This risk is associated with IaC test pipeline: Infrastructure code benefits from the same automated feedback and controlled promotion as application code. The present scenario instead leaves the deployment scopes requirement unresolved, which creates this more direct risk: an incorrect scope or excessive identity permissions can fail deployment or expand unintended blast radius.
An application running on an Azure VM needs to read a secret but the team plans to embed a service-principal password in code.
Which risk most directly follows if the team leaves this problem unresolved?
Embedded credentials may leak and grant broader access than the running service requires. The failure follows from the described gap because azure-managed workload identities authenticate Azure resources without an application-managed secret, with access granted through role assignments. Mitigate it by choosing to use a managed identity for the Azure-hosted workload and assign minimal target-resource RBAC roles.
That consequence is characteristic of Container image scanning: Container scanning examines packaged runtime components that may not appear in application source analysis. The present scenario instead leaves the managed identity versus service principal requirement unresolved, which creates this more direct risk: embedded credentials may leak and grant broader access than the running service requires.
That is a credible failure of Workload identity federation: OIDC-based federation exchanges trusted workflow identity assertions for short-lived cloud access, reducing static credential exposure. The present scenario instead leaves the managed identity versus service principal requirement unresolved, which creates this more direct risk: embedded credentials may leak and grant broader access than the running service requires.
That consequence is characteristic of GitHub App scope: GitHub Apps separate automation identity from a human account and can grant repository-scoped, revocable access. The present scenario instead leaves the managed identity versus service principal requirement unresolved, which creates this more direct risk: embedded credentials may leak and grant broader access than the running service requires.
A repository uploads reusable libraries to GitHub Packages but consumption from a second repository fails because of package access settings.
What is the most appropriate action for this DevOps team?
Configure the required GitHub Packages permissions and least-privilege workflow token access. Package registry operations are authorized separately from ordinary repository read access, and permissions must match publish or consume operations. A useful check is that publishing and downstream restore succeed only for approved repositories and workflow identities.
This would instead address Semantic versioning: SemVer communicates compatibility intent by distinguishing major breaks, compatible additions and backward-compatible fixes.
That intervention fits Immutable pipeline artifact: Artifact promotion ensures deployment stages share tested bytes rather than rebuilding from potentially changing source or packages.
This is designed for YAML environments approvals: Environment checks are managed on the resource rather than inside the pipeline YAML, resisting bypass by repository edits.
A research portal team accepts unreviewed direct pushes by contractors even though their work requires approval.
What is the most appropriate action for this DevOps team?
Use short-lived feature branches and protected pull requests with required reviewers and checks. Branch protection enables isolated contribution while enforcing a consistent integration gate before accepted code reaches the default branch. A useful check is that direct pushes are rejected and proposed changes merge only after the configured approvals and successful checks.
This is designed for Code owner review: Path-based review rules route sensitive changes to accountable specialists before merge.
This would instead address Merge policy stale approval: Approvals should cover the final content actually merged, rather than an earlier snapshot of the branch.
That intervention fits Signed annotated release tags: A release tag marks an intended commit, while signing and tag protection add evidence against unauthorized retargeting.
A service supports Linux and Windows, but separate sequential builds add hours to every release.
Which risk most directly follows if the team leaves this problem unresolved?
Sequential execution wastes capacity, or omitted combinations allow a platform-specific failure into production. The failure follows from the described gap because independent job combinations can run concurrently, making compatibility tests faster without weakening the requirement that all pass. Mitigate it by choosing to use a matrix strategy and parallel jobs for independent platforms within agent capacity.
That consequence is characteristic of Reusable YAML template: Includes and parameterized templates centralize repeatable pipeline logic while keeping service-specific inputs explicit. The present scenario instead leaves the parallel matrix builds requirement unresolved, which creates this more direct risk: sequential execution wastes capacity, or omitted combinations allow a platform-specific failure into production.
This risk is associated with Trigger branch and path filters: Trigger rules map source changes to relevant pipelines and reduce unnecessary executions without weakening critical release checks. The present scenario instead leaves the parallel matrix builds requirement unresolved, which creates this more direct risk: sequential execution wastes capacity, or omitted combinations allow a platform-specific failure into production.
That consequence is characteristic of Coverage meaningful measurement: Coverage shows code exercised, not whether assertions verify correct outcomes or critical boundary conditions. The present scenario instead leaves the parallel matrix builds requirement unresolved, which creates this more direct risk: sequential execution wastes capacity, or omitted combinations allow a platform-specific failure into production.
or Guarantee your success by buying the full version which covers the full latest pool of questions. (398 Questions, Last Updated on Nov 11, 2026)
Please check your mailbox for a message from support@examlabs.com and follow the directions.