Continuous Delivery using Azure DevOps Services

Course Overview

This two-day course provides students with the DevOps principles and related hands-on practices to work better as a team, scale their agility, share and integrate their work, and deliver working software continuously in order to enable faster delivery of value and receive early and valuable feedback. To maximize learning, students will work in teams, in a common team project, on a common case study.

Key Learning Areas

DevOps principles, benefits, and related practices
DevOps principles, benefits, and related practices
The Three Ways: flow, feedback, and learning
Technical excellence at scale
Working as a team in an Azure DevOps environment
Increasing flow through a technical value stream
Practices and mindset of a Professional Scrum Team
Scaled Professional Scrum (Nexus) framework
Identifying and eliminating dependencies
Minimizing dependencies through feature teams
Configuring Azure DevOps for product development
Planning work at scale: epics, features, user stories
Product Backlog Refinement benefits and practices
Creating a definition of “ready”
Types of dependencies and the related risks
Cross-team refinement to mitigate dependencies
Working in small batches and limiting WIP
Using Azure Boards to plan and execute a Sprint
Creating and abiding-by a Definition of Done
Reporting data via queries, charts, and widgets
Using the Analytics service and related widgets
Using dashboards as information radiators
Collaborating as a cross-functional team
The collective ownership mindset
Git version control primer and workflows
Branching strategies and potential side effects
Visualizing and managing code dependencies
Adopting an internal open-source model
Creating fast feedback loops
Automated testing in Visual Studio and Azure Pipelines
Writing and running unit tests in Visual Studio
Creating and managing Azure Pipeline builds
Creating and customizing YAML-based pipelines
Queuing and monitoring automated builds
Running automated tests as part of a build
Collecting code coverage information
Using Test Impact Analysis to improve performance
Using test filters to run specific tests in a pipeline
Practicing Continuous Integration (CI) and CI+
Using Azure Pipelines for deployment
Infrastructure as Code (IaC)
Using Microsoft Azure for DevOps
Automated deployment to Azure App Services
Creating and deploying a release
Continuous Delivery (CD) and using triggers
Hypothesis-Driven Development (HDD)
Customizing Azure DevOps to implement HDD
Using feature flags to manage feature availability
Telemetry and application performance management
Using feature flags to support A/B testing
Using LaunchDarkly and Application Insights for HDD
Exploratory testing and taking testing “tours”
Using the Microsoft Test and Feedback extension
Understanding, identifying, and avoiding technical debt
Using SonarCloud to gauge technical debt
Patterns of effective collaboration
Building a culture of learning and improvement
Blameless retrospectives
Building feedback directly into the product
Tools for improvement, Communities of Practice (COPs)
Tracking improvement through agile metrics Hypothesis-Driven Development (HDD)

Course Outline

Increasing Flow at Scale

The complexity of software development
The need for empirical process control
Increasing flow through a technical value stream
Professional Scrum
The Nexus scaled Scrum framework
Practices for organizing teams
Establishing feature teams to minimize dependencies

Planning and Executing at Scale

Organizing and refining the Product Backlog
Creating a definition of “Ready”
Dependencies, types, and related risks
Cross-team refinement to identify dependencies
Planning and executing a Sprint
Limiting work in progress (WIP)
Working in small batches
Creating and obeying a Definition of Done
Using queries, charts, and Dashboards for reporting

Sharing Code

Working collaboratively as a team
Collective ownership mindset
Git version control workflow (optional)
Branching strategies and related side effects
Using Code Maps to visualize code dependencies
Using Package Management to share binaries
Practicing internal open source (inner source)

Integrating Continuously

Why and how to create fast feedback loops
The importance of automated testing
Unit testing in Visual Studio
Automated builds in Azure Pipelines
Creating and customizing YAML-based builds
Infrastructure as Code (IaC)
Build definitions and build tasks
Running tests during an automated build
Code coverage and regression testing
Configuring and using Test Impact Analysis
Continuous Integration (CI) and CI+

Delivering Continuously

Azure Pipelines deployment
Release definitions, environments, and releases
Deployment targets, IaaS, PaaS, containers
Using Microsoft Azure for DevOps
Configuring endpoints and deployment groups
Automated deployment to an Azure App Service
Release jobs, steps, and tasks
Creating and deploying a release
Release and stage triggers
Practicing Continuous Delivery (CD)

Empowering the Product Owner

Build-Measure-Learn explained
Hypothesis-Driven Development (HDD)
Customizing VSTS to implement HDD
Feature flags overview
Using LaunchDarkly to manage feature flags
Telemetry and application performance management
Using application Insights to gather telemetry
A/B testing explained
Using feature flags to support A/B testing
Exploratory testing and testing “tours”
Using the Microsoft Test and Feedback extension
Understanding and identifying technical debt
Using SonarQube to gauge your technical debt
Practices for paying off technical debt

Learning and Improving Continuously

Working and learning as a team
Patterns of effective collaboration
Pairing, swarming, and mobbing practices
Building a culture of learning and improvement
Blameless retrospectives
Building feedback directly into the product
Communities of Practice (COPs)
Tracking improvement through agile metrics
Using the wiki to build tribal knowledge

Who Benefits

The course contains over 50 hands-on activities where students work as a team, a pair, or individually using the tools that reinforce the DevOps principles and practices they are learning. Students will self-organize into cross-functional, collocated teams and work collaboratively on a case study using a shared Azure DevOps environment. All code will be provided.

This course is intended for experienced software development professionals who want to learn about DevOps in order to achieve Continuous Integration, Continuous Delivery, Continuous Feedback, and Continuous Learning in a technical value stream as supported by Azure DevOps Services, Visual Studio, and Azure in order to continually deliver working software at scale. Students will also install and utilize several extensions from the Azure DevOps Marketplace. Teams using Azure DevOps Server (Team Foundation Server) will also benefit from this course. Attendees should be familiar with C#, Visual Studio, Scrum, and have basic experience with Azure DevOps Services or Azure DevOps Server.

Prerequisites

Team-based development experience required.

Want this course for your team?

Atmosera can provide this course virtually or on-site. Please reach out to discuss your requirements.

Atmosera is thrilled to announce that we have been named GitHub AI Partner of the Year.