AZ-400: Microsoft Azure DevOps Solutions

Recommend a migration and consolidation strategy for DevOps tools

 Analyze existing artifact (e.g., deployment packages, nuget, maven, npm) and container repositories

 Analyze existing test management tools

 Analyze existing work management tools

 Recommend migration and integration strategies for artifact repositories, source control, test management, and work management

Design and implement an Agile work management approach

 identify and recommend project metrics, KPIs, and DevOps measurements (e.g., cycle time, lead time, WIP limit)

 implement tools and processes to support Agile work management

 mentor team members on Agile techniques and practices

 recommend an organization structure that supports scaling Agile practices

 recommend in-team and cross-team collaboration mechanisms

Design a quality strategy

 Analyse existing quality environment

 Identify and recommend quality metrics

 Recommend a strategy for feature flag lifecycle

 Recommend a strategy for measuring and managing technical debt

 Recommend changes to team structure to optimize quality

 Recommend performance testing strategy

Design a secure development process

 Inspect and validate code base for compliance

 Inspect and validate infrastructure for compliance

 Recommend a secure development strategy

 Recommend tools and practices to integrate code security validation (e.g., static code analysis)

 Recommend tools and practices to integrate infrastructure security validation

Design a tool integration strategy

• Design a license management strategy (e.g., vsts users, concurrent pipelines, test environments, open source software licensing, third-party devops tools and services, package management licensing)

• Design a strategy for end-to-end traceability from work items to working software

• Design a strategy for integrating monitoring and feedback to development teams

• Design an authentication and access strategy

• Design a strategy for integrating on-premises and cloud resources

Design a version control strategy

• Recommend branching models

• Recommend version control systems

• Recommend code flow strategy

Implement and integrate source control

• Integrate external source control

• Integrate source control into third-party continuous integration and continuous deployment (CI/CD) systems

Implement and manage build infrastructure

• Implement private and hosted agents

• Integrate third party build systems

• Recommend strategy for concurrent pipelines

• Manage Azure pipeline configuration (e.g., agent queues, service endpoints, pools, webhooks)

Implement code flow

• Implement pull request strategies

• Implement branch and fork strategies

• Configure branch policies

Implement a mobile DevOps strategy

• Manage mobile target device sets and distribution groups

• Manage target ui test device sets

• Provision tester devices for deployment

• Create public and private distribution groups

Managing application configuration and secrets

• Implement a secure and compliant development process

• Implement general (non-secret) configuration data

• Manage secrets, tokens, and certificates

• Implement applications configurations (e.g., web app, azure kubernetes service, containers

• Implement secrets management (e.g., web app, azure kubernetes service, containers, azure key vault)

• Implement tools for managing security and compliance in the pipeline

Manage code quality and security policies

• Monitor code quality

• Configure build to report on code coverage

• Manage automated test quality

• Manage test suites and categories

• Monitor quality of tests

• Integrate security analysis tools (e.g., SonarQube, White Source Bolt, Open Web Application Security Project)

Implement a container build strategy

• Create deployable images (e.g., docker, hub, azure container registry)

• Analyze and integrate Docker multi-stage builds

Implement a build strategy

• Design build triggers, tools, integrations, and workflow

• Implement a hybrid build process

• Implement multi-agent builds

• Recommend build tools and configuration (e.g. Azure pipelines, jenkins)

• Set up an automated build workflow

Design a release strategy

• Recommend release tools

• Identify and recommend release approvals and gates

• Recommend strategy for measuring quality of release and release process

• Recommend strategy for release notes and documentation

• Select appropriate deployment patter

Set up a release management workflow

• Automate inspection of health signals for release approvals by using release gates

• Configure automated integration and functional test execution

• Create a release pipeline (e.g., azure kubernetes service, service fabric, webapp)

• Create multi-phase release pipelines

• Integrate secrets with release pipeline

• Provision and configure environments

• Manage and modularize tasks and templates (e.g., task and variable groups)

Implement an appropriate deployment pattern

• Implement blue-green deployments

• Implement canary deployments

• Implement progressive exposure deployments

• Scale a release pipeline to deploy to multiple endpoints (e.g., deployment groups, azure kubernetes Service, Service Fabric

Design a dependency management strategy

• Recommend artifact management tools and practices (Azure Artifacts, npm, Maven, Nuget

• Abstract common packages to enable sharing and reuse

• Inspect codebase to identify code dependencies that can be converted to packages

• Identify and recommend standardized package types and versions across the solution

• Refactor existing build pipelines to implement version strategy that publishes packages

Manage security and compliance

• Inspect open source software packages for security and license compliance to align with corporate standards (e.g., gplv3)

• Configure build pipeline to access package security and license rating (e.g., black duck, white source)

• Configure secure access to package feeds

Design an infrastructure and configuration management strategy

• Analyze existing and future hosting infrastructure

• Analyze existing infrastructure as code (iac) technologies

• Design a strategy for managing technical debt on templates

• Design a strategy for using transient infrastructure for parts of a delivery lifecycle

• Design a strategy to mitigate infrastructure state drift

Implement Infrastructure as Code (IaC)

• Create nested resource templates

• Manage secrets in resource templates

• Provision azure resources

• Recommend an infrastructure as code (iac) strategy

• Recommend appropriate technologies for configuration management (e.g., arm templates, terraform, chef, puppet, ansible)

Manage Azure Kubernetes Service infrastructure

• Provision Azure Kubernetes Service (e.g., using ARM templates, CLI)

• Create deployment file for publishing to Azure Kubernetes Service (e.g., kubectl, Helm)

• Develop a scaling plan

Implement infrastructure compliance and security

• Implement compliance and security scanning

• Prevent drift by using configuration management tools

• Automate configuration management by using powershell desired state configuration (dsc)

• Automate configuration management by using a vm agent with custom script extensions

• Set up an automated pipeline to inspect security and compliance

Recommend and design system feedback mechanisms

• Design practices to measure end-user satisfaction (e.g., send a smile, app analytics)

• Design processes to capture and analyze user feedback from external sources (e.g., twitter, reddit, help desk)

• Design routing for client application crash report data

• Recommend monitoring tools and technologies

• Recommend system and feature usage tracking tools

Implement process for routing system feedback to development teams

• Configure crash report integration for client applications

• Develop monitoring and status dashboards

• Implement routing for client application crash report data

• Implement tools to track system usage, feature usage, and flow

• Integrate and configure ticketing systems with development team's work management system (e.g., it service management connector, servicenow cloud management, app insights work items)

Optimize feedback mechanisms

• Analyze alerts to establish a baseline

• Analyze telemetry to establish a baseline

• Perform live site reviews and capture feedback for system outages

• Perform ongoing tuning to reduce meaningless or non-actionable alerts