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 security lead finds a compromised open-source library version and cannot locate which deployed services include it.
Which observation most directly confirms the required DevOps control is effective?
Affected builds are identified and redeployed with a reviewed patched version and passing regression checks. This shows that the control was implemented as intended: maintain dependency inventories and a governed update pipeline that tests and promotes fixed package versions. It matters because traceable package metadata and dependency scanning link vulnerabilities to actual consumers and enable controlled remediation.
That result would verify Immutable pipeline artifact, where the relevant control is publish an immutable versioned build artifact once and promote the same artifact through environments.
Such evidence would establish YAML multi-stage dependency, where the relevant control is declare explicit YAML stage/job dependencies and conditions to enforce required execution order.
That result would verify Semantic versioning, where the relevant control is apply semantic versioning and increase the major version for breaking public compatibility changes.
A platform department accelerates deployments but rollback alerts increase while reported velocity looks excellent.
What is the most appropriate action for this DevOps team?
Track deployment frequency and change failure rate together, with clear production-change and failure definitions. Delivery speed without failure consequences is incomplete; balanced flow and stability indicators reveal unhealthy tradeoffs. A useful check is that a shared dashboard displays release frequency with failed or rolled-back changes over the same period.
That intervention fits Bug quality feedback loop: Tying operational feedback to original code and acceptance criteria exposes recurring failure patterns and supports process improvement.
This is designed for Mean time to restore: Recovery duration captures actual service impact better than activity counts and can guide investment in incident response.
That intervention fits Lead time versus cycle time: Lead time represents a broader demand-to-delivery interval while cycle time examines active flow through the chosen process boundaries.
An operations team enables blind retry for a pipeline step that creates cloud resources without checking whether the first attempt partially succeeded.
What is the most appropriate action for this DevOps team?
Retry only safe idempotent operations and use checkpoints and explicit recovery for state-changing steps. Retries are reliable only when repeated execution has a defined effect and partial failures are detectable. A useful check is that a failed stage resumes or rolls back without duplicate schema changes or conflicting infrastructure resources.
This is designed for Contract testing independent release: Contract tests check agreed service boundaries, supporting independent deployment while detecting incompatible changes.
This would instead address Pipeline duration hotspot: Critical-path analysis separates true sequential work from jobs that can safely run concurrently.
That intervention fits Artifacts retention policy: Retention should balance recovery evidence, cost and governance rather than indiscriminately retaining or deleting every build.
Documentation-only commits trigger expensive full production builds although no deployable application changes occurred.
Which explanation best supports the needed implementation decision?
Trigger rules map source changes to relevant pipelines and reduce unnecessary executions without weakening critical release checks. The appropriate response is to set precise branch and path trigger filters, retaining broad protected-branch verification where needed. The expected evidence is that representative commits run only expected pipelines and a security-sensitive main-branch change still executes its required gate.
That explanation is about Cross-repository pipeline checkout: Explicit repository resources make multi-repository dependencies reproducible and subject to service-connection and permission checks.
This describes the mechanism for Extends security template: An extends template can constrain allowed pipeline steps, while checks on protected resources prevent easy removal of the requirement.
This reasoning pertains to Coverage meaningful measurement: Coverage shows code exercised, not whether assertions verify correct outcomes or critical boundary conditions.
An application becomes slow during traffic peaks while a dashboard shows only successful HTTP request totals.
What is the most appropriate action for this DevOps team?
Analyze CPU, memory, disk and network metrics alongside application error and latency telemetry. Infrastructure performance indicators help identify resource bottlenecks and distinguish saturation from application defects. A useful check is that a time-aligned view connects resource saturation with service errors and supports an evidence-based capacity fix.
That intervention fits Correlated distributed traces: Trace correlation connects related requests and dependencies across service boundaries to reveal end-to-end latency contributors.
This would instead address Application Insights request telemetry: Application-level instrumentation exposes call outcomes and dependency contributions that basic host availability cannot explain.
That intervention fits Kusto query failed requests: Kusto Query Language supports time-window filtering, aggregation and ranking of collected telemetry for focused diagnosis.
An Azure Pipeline cannot build a mono-service deployment because a required policy template is maintained in a separate secured repo.
Which risk most directly follows if the team leaves this problem unresolved?
Implicit downloads from uncontrolled source locations can change pipeline behavior without review. The failure follows from the described gap because explicit repository resources make multi-repository dependencies reproducible and subject to service-connection and permission checks. Mitigate it by choosing to declare authorized repository resources and checkout steps with pinned or reviewed source references.
That consequence is characteristic of Deployment scopes: Azure Resource Manager scopes determine where resources and policy assignments can be created, independently of template language. The present scenario instead leaves the cross-repository pipeline checkout requirement unresolved, which creates this more direct risk: implicit downloads from uncontrolled source locations can change pipeline behavior without review.
That is a credible failure of 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 cross-repository pipeline checkout requirement unresolved, which creates this more direct risk: implicit downloads from uncontrolled source locations can change pipeline behavior without review.
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 cross-repository pipeline checkout requirement unresolved, which creates this more direct risk: implicit downloads from uncontrolled source locations can change pipeline behavior without review.
A small product team maintains month-long feature branches and repeatedly spends days resolving integration conflicts.
What is the most appropriate action for this DevOps team?
Adopt trunk-based integration with short-lived branches, automated tests and feature flags for incomplete work. Frequent small integrations reduce divergence while flags separate code integration from customer feature exposure. A useful check is that pull requests merge frequently against a passing trunk and incomplete features remain safely disabled.
This would instead address Remove leaked credential from Git: Deleting a current file does not remove earlier Git objects or copies; invalidating the credential is the immediate security control.
That intervention fits Release branch stabilization: Release branches isolate stabilization and patching from ongoing development while still retaining traceable changes.
This is designed for Code owner review: Path-based review rules route sensitive changes to accountable specialists before merge.
A group of independent contributors needs parallel isolated review of code changes before merging to main.
Which observation most directly confirms the required DevOps control is effective?
Direct pushes are rejected and proposed changes merge only after the configured approvals and successful checks. This shows that the control was implemented as intended: use short-lived feature branches and protected pull requests with required reviewers and checks. It matters because branch protection enables isolated contribution while enforcing a consistent integration gate before accepted code reaches the default branch.
Such evidence would establish Remove leaked credential from Git, where the relevant control is revoke and rotate the exposed credential immediately, remove sensitive history using an approved rewrite and coordinate downstream cleanup.
That result would verify Merge policy stale approval, where the relevant control is enable review dismissal or fresh approvals when new commits change an approved pull request.
This observation would support Release branch stabilization, where the relevant control is maintain a controlled release branch for the supported version and cherry-pick reviewed fixes as appropriate.
A Kubernetes delivery flow trusts an image tag without checking OS libraries or image provenance.
Which risk most directly follows if the team leaves this problem unresolved?
An insecure base image can be deployed even though application-level code checks pass. The failure follows from the described gap because container scanning examines packaged runtime components that may not appear in application source analysis. Mitigate it by choosing to scan container images and dependencies before promotion, enforce risk-based gates and retain image provenance.
That consequence is characteristic of Secret scanning in pull requests: Secret scanning detects known credential patterns before promotion and alerts owners to rotate any exposed credential. The present scenario instead leaves the container image scanning requirement unresolved, which creates this more direct risk: an insecure base image can be deployed even though application-level code checks pass.
This risk is associated with Service connection scope: Service connections are privileged deployment identities, so resource RBAC and use restrictions should match actual blast radius. The present scenario instead leaves the container image scanning requirement unresolved, which creates this more direct risk: an insecure base image can be deployed even though application-level code checks pass.
That consequence is characteristic of CodeQL static analysis: Static code analysis can trace risky code patterns and data flow without relying on runtime exploitation to surface the flaw. The present scenario instead leaves the container image scanning requirement unresolved, which creates this more direct risk: an insecure base image can be deployed even though application-level code checks pass.
Windows service hosts drift from their required security and service configuration after manual emergency changes.
What is the most appropriate action for this DevOps team?
Use an appropriate Azure Machine Configuration or desired-state policy mechanism to audit and remediate configuration drift. Desired-state tools assess ongoing configuration after provisioning, whereas resource deployment alone does not ensure guest settings persist. A useful check is that a deliberate unauthorized VM setting change is detected and addressed according to policy.
This would instead address Environment parameters without secrets: Version-controlled IaC can contain safe configuration values, but privileged credentials require a protected secret delivery path.
That intervention fits 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.
This would instead address Deployment scopes: Azure Resource Manager scopes determine where resources and policy assignments can be created, independently of template language.
A sensitive application pipeline publishes production artifacts even when secret scanning or required integration tests fail.
Which observation most directly confirms the required DevOps control is effective?
A test or security failure prevents the protected deployment and records the unsuccessful check. This shows that the control was implemented as intended: define mandatory test, security and governance gates that block promotion on a failing check. It matters because a gate turns verifiable quality and risk evidence into an enforceable deployment decision rather than advisory console output.
This observation would support Flaky test quarantine, where the relevant control is diagnose and stabilize nondeterministic tests, isolating known flaky cases without silently disabling all quality gates.
Such evidence would establish Environment parameters without secrets, where the relevant control is separate nonsecret environment parameters and inject sensitive values from approved secret stores at deployment.
That result would verify Contract testing independent release, where the relevant control is add producer-consumer contract tests to both pipelines and gate incompatible interface changes before rollout.
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.