Free AZ-400 practice test: 30 questions with answers

Conditions based on the branch let the same pipeline build everywhere and deploy only from main. Copying pipelines, manual artifact copies, and laptop deployments are error-prone and inconsistent.

YAML templates let teams define shared jobs, steps, or stages once and reference them across pipelines. Variables hold values, triggers start runs, and environment names identify targets.

Environments with approvals and checks pause a deployment until authorized people approve it. A comment, a midnight trigger, or disabling the stage does not enforce approval.

Microsoft-hosted agents provide managed, fresh build environments on demand without infrastructure work. A laptop cannot scale, manual servers add effort, and running builds on production systems is unsafe.

Self-hosted agents let teams install and control specific tools and versions. Hosted images cannot be edited by customers, ignoring requirements breaks builds, and ad hoc installs are not reproducible.

Secret scanning detects credentials in code and history and can block or alert on them. Commit message review misses secrets in code, deleting history does not remove exposure, and README storage is insecure.

Pipeline history with recorded approvals and audit logs gives traceable, verifiable evidence. Verbal confirmation, one-off screenshots, and unsigned emails are not reliable audit evidence.

Scoped role assignments limit a service connection to the resources it needs. Subscription-wide owner rights, shared personal credentials, and no permissions each create either excessive risk or non-functional pipelines.

Managed identities and service connections avoid long-lived passwords, and scheduled rotation limits the window of exposure. Logging, plain-text visibility, and sharing one secret widely each increase the risk.

Admission policies enforce allowed image sources at deployment time, which blocks unapproved images regardless of developer choice. Wiki notes and trust are not enforced, and open internet images are unapproved.

Branch policies enforce pull requests, required reviewers, and build validation before changes reach protected branches. Direct pushes, disabled reviews, and shared folders each remove that protection.

Sparse-checkout and partial clone reduce the working set and transferred data for large repositories. Deleting history loses traceability, renaming does not affect size, and storing binaries worsens the problem.

Focused commits with clear messages make history readable and let individual changes be reverted safely. Large monthly commits hide the purpose of each change, and rewriting shared history disrupts collaborators.

A build validation policy runs a pipeline for each pull request and blocks completion until it passes. Reminders, wiki checklists, and spreadsheets do not enforce the gate.

Frequent integration, short-lived branches, and feature flags with automated tests keep trunk-based development fast and safe. Long-lived branches and merges without tests create integration pain and risk.

Azure Monitor and Application Insights collect telemetry, provide dashboards, and drive alerts for failures and performance. Boards, Artifacts, and Repos manage work, packages, and code.

Distributed tracing links spans across services for a single request, which shows where latency occurs. CPU counters alone do not follow a request, and invoices and browser lists are unrelated.

DORA metrics measure delivery performance, including deployment frequency, lead time, change failure rate, and recovery time. The other measures do not describe delivery health.

Metric alert rules evaluate conditions over a time window and trigger action groups to notify people or systems. Manual or printed checks are too slow, and wallpapers are unrelated.

End-to-end transaction views show dependencies and their timing within a request, which pinpoints slow operations. Version numbers, user counts, and repository names do not reveal where time is spent.

Azure Artifacts hosts feeds for internal packages and can use upstream sources to control access to public packages. Boards tracks work, Test Plans manages testing, and Monitor observes running systems.

Pinned versions and pipeline tests make dependency changes deliberate and verified. Automatic newest-version use, removed lock files, and ignored alerts each expose production to unplanned change.

Assessing exposure, remediating or mitigating, and verifying through the pipeline addresses the risk. Disabling scans, hiding findings, and delaying review leave the vulnerability active.

Lock files record exact resolved versions so builds use the same dependencies each time. Using whatever is newest, deleting caches without locks, and unknown sources make builds non-reproducible or unsafe.

Caching restores previously downloaded packages when the dependency key matches, which shortens runs. Deleting caches, disabling restore, and storing packages in source do not speed up builds reliably.

Azure Boards tracks work items, boards, and states so teams can manage backlogs and progress. Artifacts stores packages, Load Testing measures performance, and Key Vault stores secrets.

Linking work items to builds and releases gives traceability from requirements through delivery. Memory, paper lists, and ignoring items cannot reliably support release traceability.

Dashboards with query-based widgets update live from work item queries. A monthly spreadsheet, hand-drawn chart, or sprint screenshot are not live.

Pull requests linked to work items with required reviewers record the reason and the approval for each change. Direct commits, verbal approvals, and unrecorded changes lack that traceability.

Cycle time and lead time analytics show how long work takes to flow through the process, which supports improvement. Emoji counts, board colours, and deleting items do not measure flow.