AzureAZ-400

AZ-400 Azure DevOps: CI/CD, Infrastructure as Code, and Site Reliability Engineering

AZ-400 is the Azure DevOps Engineer Expert certification — it validates your ability to design and implement DevOps practices that improve developer productivity, deployment reliability, and operational efficiency. The exam covers CI/CD pipelines in Azure DevOps and GitHub Actions, infrastructure as code with Bicep and Terraform, site reliability engineering practices, and DevSecOps. You must hold AZ-104 or AZ-204 before taking AZ-400.

12 min
4 sections · 10 exam key points

Azure DevOps Pipelines and GitHub Actions

AZ-400 centres on CI/CD implementation. Azure DevOps Pipelines: defined in YAML (azure-pipelines.yml in the repository root). Pipeline structure: trigger (branch and path filters), pool (agent — Microsoft-hosted agent pools for Ubuntu, Windows, macOS, or self-hosted agents for private network access), stages (sequential or parallel), jobs (run on a single agent — parallel jobs on different agents), steps (individual tasks or scripts). Key tasks: AzureCLI@2 (run Azure CLI commands with service connection authentication), TerraformInstaller + TerraformTaskV4 (run Terraform init/plan/apply), DotNetCoreCLI@2 (build, test, publish .NET applications), PublishPipelineArtifact (store build outputs for later stages), DownloadPipelineArtifact (retrieve stored artifacts). Environments: Azure DevOps Environments gate deployments with approvals, checks (branch policy, required reviewers), and deployment history. GitHub Actions: .github/workflows/*.yml, triggered by on: push/pull_request/schedule/workflow_dispatch. Uses composite actions and reusable workflows for shared logic across repositories.

Infrastructure as Code: Bicep and ARM Templates

Azure-native IaC tools for AZ-400. Bicep: domain-specific language that compiles to ARM JSON — cleaner syntax than raw ARM, first-class support in Azure DevOps. Bicep advantages over ARM: no verbose JSON structure, type-safe parameters with decorators, modules for reusable components, output values, string interpolation. Bicep modules: separate .bicep files called from a parent — scope can be resource group, subscription, management group, or tenant. ARM template structure: $schema, contentVersion, parameters, variables, resources, outputs — functions available: resourceGroup(), subscription(), reference(), concat(), uniqueString(). Deployment modes: Incremental (add/update resources in template, ignore resources not in template — safer, default), Complete (deploy exactly what is in template, delete resources not in template — destructive, use carefully). Template spec: store ARM templates in Azure as a versioned resource — share and deploy consistently across teams. What-if: preview ARM or Bicep deployment changes without applying — similar to Terraform plan.

DevSecOps and Supply Chain Security

AZ-400 integrates security into DevOps. Shift left security: integrate security testing early in the pipeline rather than at the end. SAST (Static Application Security Testing): scan source code before build — Checkmarx, SonarQube (integrated as pipeline task), GitHub Advanced Security (CodeQL for code scanning, secret scanning, dependency review). DAST (Dynamic Application Security Testing): test the running application — OWASP ZAP, Burp Suite. Dependency scanning: identify vulnerable open-source libraries — Dependabot (GitHub), Azure DevOps OWASP Dependency Check task. Container security in pipelines: Trivy, Prisma Cloud, or Microsoft Defender for containers to scan images before push to registry. Software supply chain security: SBOM (Software Bill of Materials) generation, Sigstore (Cosign) for container image signing, attestation policies (only deploy images signed by the build pipeline). Policy enforcement: Azure Policy as Code (deploy policies via pipeline — manage as YAML files in Git, apply via Azure DevOps pipeline with az policy commands or Terraform azurerm_policy_definition resources).

Site Reliability Engineering Practices

AZ-400 covers SRE concepts applied to Azure. SLOs (Service Level Objectives): define target reliability (e.g., 99.9% request success rate, p99 latency < 500ms) — measured using SLIs from Application Insights or Azure Monitor. Error budgets: the allowed downtime before missing the SLO — (1 - SLO) x time period. When error budget is exhausted, new deployments are paused until reliability is restored. Feature flags: deploy code to production without enabling it — Microsoft Feature Management library for .NET, LaunchDarkly. Gradual rollout: combine feature flags with deployment rings (canary users > 5% > 20% > 100%). Chaos engineering: Azure Chaos Studio introduces faults (VM shutdown, network partition, CPU pressure) to validate system resilience. Toil reduction: automate repetitive operational tasks — identify toil (manual, repetitive, automatable, tactical work that grows with service scale) and systematically eliminate it through automation. Incident management: integrate Azure Monitor alerts with PagerDuty or Azure DevOps work items for tracked incident response.

Key exam facts — AZ-400

  • Azure Pipelines: YAML stages > jobs > steps — agents run jobs, Microsoft-hosted or self-hosted
  • Bicep compiles to ARM JSON — cleaner syntax with type-safe parameters, modules, and string interpolation
  • ARM deployment mode Incremental (safe, additive) vs Complete (deletes resources not in template)
  • What-if previews ARM/Bicep changes without applying — equivalent to Terraform plan
  • SAST scans source code before build; DAST tests the running application
  • SBOM + Cosign image signing implements software supply chain security in CI/CD
  • Error budget = (1 - SLO) x time — freeze deployments when error budget is consumed
  • Feature flags enable deploying code without activating it — gradual rollout control
  • Azure Chaos Studio introduces faults to validate system resilience under failure conditions
  • CodeQL (GitHub Advanced Security) performs SAST — finds security vulnerabilities in source code

Common exam traps

Azure DevOps Pipelines and GitHub Actions are competing tools — choose one

Many organisations use both: Azure DevOps for enterprise project management (boards, repos, test plans) and GitHub Actions for open-source or developer-centric workflows. They can also integrate — GitHub Actions can deploy to Azure using Azure service connections.

Bicep is just ARM templates with different syntax

Bicep adds significant abstractions: modules for reusability, loops and conditions that compile cleanly, type safety, and a much more readable language. The developer experience is substantially better, which reduces configuration errors and speeds up IaC development.

SRE is just DevOps with a different name

SRE is a specific implementation of DevOps principles from Google — it adds quantitative reliability engineering (SLOs, error budgets, toil measurement) and specific on-call practices. It is a more prescriptive and quantitative approach than generic DevOps.

Practice this topic

Test yourself on AZ-400 Azure DevOps

JT Exams routes you to questions in your exact weak areas — automatically, after every session.

No credit card · Cancel anytime

Related certification topics