AZ-400T001: Designing and Implementing Microsoft DevOps Solutions Training Course

• Manage security and compliance
• Implement Infrastructure as Code (IaC)
• Manage Azure Kubernetes Service infrastructure
• Implement infrastructure compliance and security
• Recommend and design system feedback mechanisms
• Optimize feedback mechanisms
• Implement process for routing system feedback to development teams
• Design a release strategy
• Set up a release management workflow
• Implement an appropriate deployment pattern
• Design and implement an Agile work management approach
• Design a quality strategy
• Design a secure development process
• Implement a mobile DevOps strategy
• Managing application configuration and secrets
• Manage code quality and security policies
• Implement a container build strategy
• Implement a build strategy
• Design a tool integration strategy
• Design a version control strategy
• Implement and integrate source control
• Implement and manage build infrastructure
• Recommend a migration and consolidation strategy for DevOps tools
• Design a dependency management strategy
• Design an infrastructure and configuration management strategy

This course is likely to add to the employment-related skills of the participants. The skills developed are likely to be used in the course of being an employee or working in a business.

• Azure DevOps engineer
• Application developer
• Data engineer Azure
• Cloud engineer

• Analyse existing artifact (e.g., deployment packages, NuGet, Maven, npm) and container repositories
• Analyse existing test management tools
• Analyse existing work management tools
• Recommend migration and integration strategies for artifact repositories, source control, test management, and work management
• Identify and recommend project metrics, KPIs, and DevOps measurements (e.g., cycle time, lead time, WIP limit)
• Recommend branching models
• Recommend version control systems
• Recommend code flow strategy
• 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
• 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
• 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 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
• 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 pull request strategies
• Implement branch and fork strategies
• Configure branch policies
• 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
• 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
• 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)
• Create deployable images (e.g., Docker, Hub, Azure Container Registry)
• Analyze and integrate Docker multi-stage builds
• 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
• 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 pattern
• 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 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)
• 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
• 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
• 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
• 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)
• 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 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
• Design practices to measure end-user satisfaction (e.g., Send a Smile, app analytics)
• Design processes to capture and analyse 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
• 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)
• Analyse alerts to establish a baseline
• Analyse 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