This course will change your focus from “software development” to “software delivery”. If your code hasn’t been delivered so that someone can use it, it’s not very valuable. And the faster that you can build and deliver great features, the sooner that you’ll start capturing that value. The process of going from an idea for a feature to developing a feature to delivering a feature is called ‘DevOps’.
This course will show you how to use the tools and features of Visual Studio 2015 and Team Foundation Server 2015 to automate and improve your DevOps “flow”.
Here’s what you’ll see in the course.
Module 1: What Is Devops? Why Do I Care?
What Is DevOps?
Why Should I Care About DevOps?
DevOps with Microsoft Tools
Module 2: Consolidating Your Team’s Source Code with Version Control
Version Control (aka. Source Control) is at the center of any successful team-based development project. We’ll discuss the core version control features that are available in Team Foundation Server 2015 including how to choose between Team Foundation Server Version Control or Git.
Why Version Control?
Version Control Options in TFS
Team Project Collections
TFVC Overview & Demos
Git + TFS Overview
Git + TFS Demo, Part 1: Basics
Git + TFS Demo, Part 2: Fetch & Pull
Git + TFS Demo, Part 3: Associated Work Items
Git + TFS Demo, Part 4: Merge Conflicts
Git + TFS Demo, Part 5: Multiple Repositories
Git or TFVC?
Module 3: Work & Constraints
This module discusses the types of work you’ll see in IT, the dangers of multitasking, rework, bottlenecks in your process, and the Theory of Constraints.
Work & DevOps
Multitasking & Work In Progress
Theory of Constraints
Module 4: Planning and Tracking Your Team’s Work
This module will show you how to use Scrum and/or Kanban to plan, track, and manage your work using Team Foundation Server 2015.
Scrum and Kanban
Demo: Kanban with TFS
Demo: Scrum Backlog Management with TFS
Demo: Forecasting and Velocity
Demo: Scrum Sprint Planning with TFS
Demo: Running and Monitoring a Sprint with TFS
Demo: Project Dashboards
Demo: Work Item Queries and Charting
Module 5: Unit Testing and DevOps
Quality is not something that can be added later. You need to think about software quality early and a great way to do that is to start by developing code using Unit Tests.
Unit Test Demo and What Is a Unit Test?
Why Unit Testing and DevOps?
Module 6: Managing & Deploying SQL Server Database Code
If you want to be successful at DevOps, you’ll need to get your database code under version control and have a way to deploy it.
SQL Server Data Tools: What & Why?
Demo: SQL Server Data Tools
Demo: Comparisons & Updates
Demo: Lookup Data
Demo: Deploy & automate using SqlPackage.exe
Module 7: Automating Builds and Deployments
If you want to get good at DevOps, you need to have an automated way to bring your team’s code together to build it, test it, and deploy it. The core of this is going to be your TFS build servers and your automated builds. In this module, we’ll discuss Team Foundation Server 2015’s new build system including how to set up a build server, how to create a build, and how to customize the build to deploy your code automatically.
Why Automated Builds and DevOps?
Demo: Create a TFS Build
Demo: Build Failures and Bugs
Demo: Builds and the Project Dashboard
Demo: Configure Build Agents and Capabilities
Demo: Deploy Database Updates from a Build
Demo: Deploy an ASP.NET Application to IIS from a Build
Module 8: Managing ‘Hot Fixes’ & Code Quality: Branches and Code Reviews
What Is Branching & Merging?
Demo: Branching with TFVC
Demo: Branching with Git
Demo: Code Reviews with Git Pull Requests
Demo: Branch Policies with Git Pull Requests
Demo: Code Reviews with TFVC
Demo: Hot Fixes & Release Branches with TFVC
Demo: Hot Fixes with Git Tags
Module 9: QA Testing & Automated UI Tests with Coded UI
What about “QA testing”? Where does that fit in to a DevOps world? Well, in any complex application, you’ll almost definitely have manual test cases – aka. “QA Tests” – that will initially need to be run and tracked by humans. Conveniently enough, Team Foundation Server has a whole set of features that help you to manage, track, and (eventually) automate your manual testing (aka. “QA Testing”) efforts. In this module, we’re going to show you how to use the testing features of Team Foundation Server to plan, execute, and track your manual testing efforts. Since DevOps craves automation, we’ll also show you how to use Visual Studio Coded UI Tests to automate the work of human QA testers and incorporate it into your automated builds.
A New Kind of QA for Devops & TFS
Demo: QA Test Cases in TFS
Demo: QA Test Parameters & Data
Demo: Run Test Cases & Create Bugs via the Web
Demo: Shared Test Steps & Shared Parameters
Demo: Run QA Test Cases via the MTM Client
Demo: Assigning Test Cases + Test Suite Charts
DevOps + UI Automation Tests
Demo: Automated Smoke Test with Coded UI, Part 1
Demo: Automated Smoke Test with Coded UI, Part 2
Module 10: Simplifying Feature Deployments and Feedback
This module focuses on some of the architectural aspects of making your application participate in your DevOps flow. First we’ll talk about how to implement Feature Flag deployments in your application. Feature flags separates the production deployment of a feature from the ‘enablement’ of a feature using configuration. Put another way, you can deploy code for a feature to your production servers but then only turn it on when you think it’s ready for human consumption. Finally, we’ll talk about how to gather and track user feedback about your application.
Limits of Source Control-based Releases
Demo: Feature Flag Infrastructure
Demo: Using Feature Flags to Implement a Feature
Demo: Deploying Two Features at the Same Time with Feature Flags
Demo: Implementing a Private Beta with Feature Flags
DevOps, Product Ownership, & Feedback
Demo: Capturing Feedback & Feature Utilization
Module 11: DevOps Release Pipelines with Visual Studio Release Management
At some point, your DevOps deployment needs get complex and using just your TFS automated builds alone just won’t be enough. This is where Visual Studio Release Management comes in. Release Management (RM) builds on top of what you already have in TFS build and then allows you to define environments, approval workflows, and security policies that help you to manage and track your deployments. In this module, we’ll show you how to implement a more robust DevOps flow using Release Management.
What is TFS Release Management?
Demo: Create a Release, Part 1
Demo: Create a Release, Part 2
Demo: Add an Environment
Demo: Triggers & Continuous Deployment