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 self-hosted runner still has vulnerable development tools because its image is never rebuilt or patched.
What is the most appropriate action for this DevOps team?
Manage versioned hardened runner images with patch schedules and automated smoke validation. Controlled immutable agent baselines reduce drift and known vulnerabilities while retaining build reproducibility. A useful check is that new runners launch from an approved image, report expected tool versions and pass test builds.
That intervention fits Pipeline health analytics: Build health includes reliability and time to feedback, not just the final successful outcome.
This is designed for 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 Pipeline duration hotspot: Critical-path analysis separates true sequential work from jobs that can safely run concurrently.
A desktop client team closes bugs after code merge but the quality lead has no feedback from repeat failures in production.
Which explanation best supports the needed implementation decision?
Tying operational feedback to original code and acceptance criteria exposes recurring failure patterns and supports process improvement. The appropriate response is to define a feedback loop that links production defects to work items, root-cause labels, tests and retrospective improvements. The expected evidence is that repeated defects lead to updated regression tests and documented follow-up changes visible from their work items.
This reasoning pertains to Teams pipeline notifications: Purposeful notifications give stakeholders timely actionable status while original pipeline permissions continue to protect detail.
That explanation is about Azure Boards GitHub traceability: The Boards-GitHub integration surfaces development activity against the planning record, supporting end-to-end traceability across services.
This describes the mechanism for GitHub Flow work visibility: Linking issues, pull requests, commits, checks, and releases gives stakeholders traceability without requiring a long-lived branch per ticket.
Four service teams build the same shared .NET library from copied source folders and keep releasing incompatible versions.
Which risk most directly follows if the team leaves this problem unresolved?
Copied binaries diverge between products and a security fix fails to reach every dependent service. The failure follows from the described gap because a central package feed provides controlled distribution and dependency metadata instead of silently copying libraries between repositories. Mitigate it by choosing to publish shared versioned packages to a governed Azure Artifacts feed and reference them explicitly in consumer builds.
That is a credible failure of Parallel matrix builds: Independent job combinations can run concurrently, making compatibility tests faster without weakening the requirement that all pass. The present scenario instead leaves the central internal package feed requirement unresolved, which creates this more direct risk: copied binaries diverge between products and a security fix fails to reach every dependent service.
That consequence is characteristic of Upstream package cache: Upstream caching serves previously resolved packages from the controlled feed and reduces direct external registry dependence. The present scenario instead leaves the central internal package feed requirement unresolved, which creates this more direct risk: copied binaries diverge between products and a security fix fails to reach every dependent service.
That is a credible failure of Date-based versioning: Calendar-based versions express release timing, but do not automatically convey semantic API compatibility. The present scenario instead leaves the central internal package feed requirement unresolved, which creates this more direct risk: copied binaries diverge between products and a security fix fails to reach every dependent service.
A repository that deploys a test service can also modify production Key Vault and network resources through its shared connection.
Which observation most directly confirms the required DevOps control is effective?
An authorized test pipeline can deploy to its resource group but cannot alter other environments. This shows that the control was implemented as intended: scope service connection roles and approvals to the smallest necessary Azure resources and pipeline consumers. It matters because service connections are privileged deployment identities, so resource RBAC and use restrictions should match actual blast radius.
This observation would support Azure DevOps least privilege, where the relevant control is assign appropriate Azure DevOps access levels and group roles according to actual work responsibilities.
Such evidence would establish Container image scanning, where the relevant control is scan container images and dependencies before promotion, enforce risk-based gates and retain image provenance.
This observation would support GitHub App scope, where the relevant control is use a GitHub App installation with narrowly requested repository permissions and short-lived installation tokens.
A repository allows merges when unit tests have failed because reviewers rely on a green comment from a developer.
Which risk most directly follows if the team leaves this problem unresolved?
Failing code can enter the shared branch despite visible but unenforced CI results. The failure follows from the described gap because server-enforced branch rules validate executable evidence before integration, independent of informal reviewer assurances. Mitigate it by choosing to configure required status checks and block protected-branch merges until the specified CI jobs succeed.
That consequence is characteristic of Code owner review: Path-based review rules route sensitive changes to accountable specialists before merge. The present scenario instead leaves the required status checks requirement unresolved, which creates this more direct risk: failing code can enter the shared branch despite visible but unenforced CI results.
That is a credible failure of Release branch stabilization: Release branches isolate stabilization and patching from ongoing development while still retaining traceable changes. The present scenario instead leaves the required status checks requirement unresolved, which creates this more direct risk: failing code can enter the shared branch despite visible but unenforced CI results.
This risk is associated with Signed annotated release tags: A release tag marks an intended commit, while signing and tag protection add evidence against unauthorized retargeting. The present scenario instead leaves the required status checks requirement unresolved, which creates this more direct risk: failing code can enter the shared branch despite visible but unenforced CI results.
A developer group wants actionable deployment completion summaries in Microsoft Teams without disclosing build secrets.
Which explanation best supports the needed implementation decision?
Purposeful notifications give stakeholders timely actionable status while original pipeline permissions continue to protect detail. The appropriate response is to integrate filtered pipeline status notifications with Microsoft Teams and link back to the secured run records. The expected evidence is that the correct Teams channel receives failure and deployment notifications with working links and no exposed credentials.
That explanation is about Versioned release notes: Releasing documented change history helps consumers and support understand compatible features, fixes and known constraints.
This describes the mechanism for Webhooks for event integration: Event subscriptions push relevant changes to a receiver; delivery validation and idempotency are necessary for dependable automation.
This reasoning pertains to Query-based work metrics: Consistent query definitions produce comparable operational metrics from the underlying tracked work rather than manual snapshots.
A platform team wants a reproducible pipeline definition while keeping existing protected production approvals.
Which explanation best supports the needed implementation decision?
YAML makes pipeline implementation reviewable as code, while protected environment checks remain separately configured. The appropriate response is to inventory existing classic tasks and resource checks, migrate logic into versioned YAML and validate parity in parallel. The expected evidence is that a parallel run matches current outputs and release controls before classic execution is retired.
That explanation is about Pipeline health analytics: Build health includes reliability and time to feedback, not just the final successful outcome.
This reasoning pertains to Immutable pipeline artifact: Artifact promotion ensures deployment stages share tested bytes rather than rebuilding from potentially changing source or packages.
That explanation is about Artifacts retention policy: Retention should balance recovery evidence, cost and governance rather than indiscriminately retaining or deleting every build.
A web API assumes its downstream queue contract is stable, yet production messages are rejected after a release.
Which risk most directly follows if the team leaves this problem unresolved?
Interface incompatibility reaches production despite each component passing its own unit tests. The failure follows from the described gap because integration testing checks behavior between components that unit tests with mocks cannot prove. Mitigate it by choosing to add integration tests against representative dependencies and validate interface contracts before promotion.
That consequence is characteristic of Azure App Service deployment slot: Slots provide a separately deployed target and controlled swap that can reduce disruption when application startup is validated. The present scenario instead leaves the integration test service boundary requirement unresolved, which creates this more direct risk: interface incompatibility reaches production despite each component passing its own unit tests.
That is a credible failure of Publish test results: Structured test results allow failures and trends to be associated with builds and commits, instead of buried in unstructured logs. The present scenario instead leaves the integration test service boundary requirement unresolved, which creates this more direct risk: interface incompatibility reaches production despite each component passing its own unit tests.
That consequence is characteristic of Flaky test quarantine: Flaky tests weaken confidence in build signals and consume delivery capacity; stabilization restores trustworthy pass/fail evidence. The present scenario instead leaves the integration test service boundary requirement unresolved, which creates this more direct risk: interface incompatibility reaches production despite each component passing its own unit tests.
A developer committed a service credential, deleted it in a later commit and assumes the leak has ended.
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.
That result would verify 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.
This observation would support Required status checks, where the relevant control is configure required status checks and block protected-branch merges until the specified CI jobs succeed.
Such evidence would establish Scalar for large monorepo, where the relevant control is evaluate Scalar and sparse or partial checkout strategies for large-repository development.
An application becomes slow during traffic peaks while a dashboard shows only successful HTTP request totals.
Which risk most directly follows if the team leaves this problem unresolved?
An application-only investigation can miss throttling, exhaustion or network constraints. The failure follows from the described gap because infrastructure performance indicators help identify resource bottlenecks and distinguish saturation from application defects. Mitigate it by choosing to analyze CPU, memory, disk and network metrics alongside application error and latency telemetry.
That consequence is characteristic of Application Insights request telemetry: Application-level instrumentation exposes call outcomes and dependency contributions that basic host availability cannot explain. The present scenario instead leaves the resource cpu memory investigation requirement unresolved, which creates this more direct risk: an application-only investigation can miss throttling, exhaustion or network constraints.
That is a credible failure of Correlated distributed traces: Trace correlation connects related requests and dependencies across service boundaries to reveal end-to-end latency contributors. The present scenario instead leaves the resource cpu memory investigation requirement unresolved, which creates this more direct risk: an application-only investigation can miss throttling, exhaustion or network constraints.
This risk is associated with Telemetry SLO feedback loop: Aligning deployment events to relevant user-facing reliability metrics turns observability into continuous improvement decisions. The present scenario instead leaves the resource cpu memory investigation requirement unresolved, which creates this more direct risk: an application-only investigation can miss throttling, exhaustion or network constraints.
A payments application receives releases from multiple branches and needs only one production deployment to hold the environment lock.
Which explanation best supports the needed implementation decision?
Serialization prevents conflicting writes to the same mutable production target while allowing independent builds elsewhere. The appropriate response is to configure an exclusive environment lock or equivalent serialized deployment control. The expected evidence is that only one deployment holds the protected environment at a time and later runs follow the agreed queue policy.
This describes the mechanism for Build cache with correctness: Correct cache keys improve speed while preventing incompatible or stale cached outputs from silently changing builds.
That explanation is about Package vulnerability response: Traceable package metadata and dependency scanning link vulnerabilities to actual consumers and enable controlled remediation.
This describes the mechanism for Artifacts retention policy: Retention should balance recovery evidence, cost and governance rather than indiscriminately retaining or deleting every build.
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.