My latest Pluralsight course just went live last night.  It's been a long time coming and a ton of work.  I hope you all like it.

DevOps Skills for Developers with Visual Studio & TFS 2017

There's a huge divide between software that's developed and software that's delivered. DevOps helps you bridge that divide. It's a mindset plus a set of practices that focuses on automation, reliability, and optimizing the process of software delivery. In this course, DevOps Skills for Developers with Visual Studio and TFS 2017, will show you how to use the tools and features of Visual Studio 2017 and Team Foundation Server 2017 to create an automated DevOps release pipeline for your applications. First, you'll learn how to build and deploy applications written with ASP.NET, ASP.NET Core, Entity Framework, and Entity Framework Core. Next, you'll explore how to think about and measure your DevOps practices, and your multi-environment deployments to on-premise data centers, Microsoft Azure, and Docker. Finally, you'll discover how to utilize QA testing with TFS 2017, and automated UI testing using Selenium. By the end of this course, you'll have the necessary skills and knowledge to set up your own automated DevOps release pipeline that will deploy your applications into either an on-premise data center or Microsoft Azure.

DevOps: Focusing on What's Important

This module provides an overview for the course and introduces you to the concept of DevOps and "DevOps thinking". The idea is to discuss what's changed in this new version of TFS and to describe some of the latest thinking in the DevOps world.

• Course Intro & Module Intro
• DevOps: What, Why, & Where?
• What's New for DevOps with TFS2017 & VS2017?

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 with a focus on Git.

• Why Version Control?
• Two Types of Version Control in TFS
• Git Basics
• Demo: Git Basics
• Demo: Git & Work Items
• Demo: Git Get Latest
• Demo: Handling Git Conflicts
• Demo: Multiple Git Repos in TFS
• Branching & Merging
• Demo: Branching & Merging
• Branching Risks
• Demo: Code Reviews with Pull Requests

Planning and Tracking Your Team's Work

How do you decide what your team should be working on and track what it's doing? Too much work in progress almost guarantees that nothing will get done and constraints (aka. bottlenecks) ensure that everything takes forever. This module will talk about what work is, some relevant metrics for DevOps, and how to think about and fix constraints in your process.

• Too busy?
• What is work?
• DevOps Metrics: Lead Time & Cycle Time
• DevOps Metrics: Wait Time
• Bottlenecks & the Theory of Constraints

Planning & 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 2017.

• Scrum & Kanban Overview
• TFS Process Templates & Work Items
• Demo: Kanban with TFS
• Demo: Scrum Product Backlog with TFS
• Demo: Forecasting & Velocity with TFS
• Demo: Plan a Scrum Sprint with TFS
• Demo: Run a Daily Scrum Meeting with TFS
• Demo: Visualize Project Status with TFS Dashboards
• Demo: Work Item Queries & Work Item Charts
• Demo: Email Alerts using Follow Work Item
• Lead Time & Cycle Time with TFS & Excel, Part 1
• Demo: Lead Time & Cycle Time with TFS & Excel, Part 2

Automating Builds & Deployments

If you want to get good at DevOps, you need to have an automated way to bring your team's code together to and either deploy it or get ready to deploy it. In Team Foundation Server 2017, this is achieved by using two technologies: TFS Build and TFS Release Management. In this module, we'll discuss Team Foundation Server 2017's build system including how to create a build and how to customize the build.

• Automated Builds in DevOps: Why Do I Care?
• Separate Your Builds from Your Releases
• Please. I'm Begging You. Deploy More Often.
• Demo: Create a Build for .NET Standard
• Demo: Create a Build for .NET Core
• Demo: Builds on Your TFS Dashboards
• Demo: TFS Extensions in a Build
• Installing the TFS Build & Release Agent
• Demo: Configuring TFS Agent Capabilities

Managing & Deploying SQL Server Database Code

Your application probably uses a database – and your application probably won't work without it. If you want to automatically deploy and configure your application from TFS Build, you're going to need to deploy your database changes, too. If you're using SQL Server, your two big options are SQL Server Data Tools (SSDT) projects and Entity Framework Migrations. This module will show you how to track your database changes using version control and then build & deploy incremental updates using TFS Build, SSDT, and Entity Framework Migrations.

• Database Deployment Is Critical to DevOps
• Database Deployment Options for DevOps
• Demo: Entity Framework Migrations for .NET Framework
• Demo: Entity Framework Migrations for .NET Core
• Demo: SQL Server Data Tools (SSDT)
• Demo: Schema Comparisons with SSDT
• Demo: Lookup Data with SSDT
• Demo: Command Line Deploys Using SSDT & SqlPackage.exe

Feature Flags: Simplify Branching & Deployments

Version control can get in the way of DevOps and slow you down. Developing your code using feature flags can help. Feature flags shift your focus from deployments based on version control towards deployments based on configurations. And once you've got feature flags, it lets you do other interesting things like private betas, side-by-side deployments, and A/B testing, too.

• Typical Branching Structure & Deployments
• How Version Control-based Releases Break
• What Are Feature Flags?
• Demo Part 1 of 4: Tour of the Application
• Demo Part 2 of 4: IFeatureManager & the Database
• Demo Part 3 of 4: ASP.NET + Feature Flags
• Demo Part 4 of 4: ASP.NET Controllers + Feature Flags
• Demo: Multiple Versions of a Feature Side-by-side
• Demo: Private Beta Tests using Feature Flags

DevOps Release Pipelines with Visual Studio Release Management

At some point, your DevOps deployment requirements 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.

• Demo: Create a TFS Release Definition
• Demo: Server Phases, Agent Phases, & Human Interaction
• Demo: Running Release Actions in Parallel
• Demo: Multiple Environments & Environment-specific Configs
• Demo: Approvals for Environment Deployments
• Demo: Rollback & Abandon a Failed Release

Deploying ASP.NET 4.6 with Release Management

Let's say that your application is ASP.NET 4.6 with Entity Framework and SQL Server. You're probably going to deploying this application on to a Windows Server in your datacenter or to a server in the cloud. In this module, we'll show you how to build and deploy an ASP.NET 4.6 application to both Internet Information Server (IIS) and to servers in Microsoft Azure.

• Demo Part 1 of 2: Deploy ASP.NET to IIS & SQL Server
• Demo Part 1 of 2: Deploy to a QA Environment with an Approval
• Demo Part 1 of 3: Deploy ASP.NET to Azure
• Demo Part 2 of 3: Connect TFS Build to Your Azure Subscription
• Demo Part 3 of 3: Deploy SSDT to Azure SQL Database

Deploying ASP.NET Core & EF Core with Release Management

Let's say that your application is ASP.NET Core with Entity Framework Core and SQL Server. In this module, we'll show you how to build and deploy the application and the Entity Framework Migrations (EF Migrations) to both Internet Information Server (IIS) and to servers in Microsoft Azure.

• Demo Part 1 of 2: Configure the Build
• Demo Part 2 of 2: Create the Release Definition
• Demo: Add a QA Environment & Setup a Deployment Approval
• Demo: Deploy ASP.NET Core & EF Core to Azure

Deploying to Containers using TFS Build and Release Management

Let's say you have a web application.  How do you convert this application to run in a container on Docker?  And what are containers and what is Docker?  This module will give you an introduction to containers and Docker and also show you how to containerize your ASP.NET application and the application's database.  We'll wrap up by showing you how to build and run Docker-based containers from a Team Foundation Server build.

• Container & Docker Overview
• How to Docker-ize Your Application
• Demo Overview
• Demo: Quick Tour of Docker + Running SQL Server in a Container
• Demo: Use a Dockerfile to Create Your Own Docker Image
• Demo: Create a Dockerfile for an ASP.NET Core Application
• Demo: Using Docker Compose to Describe Services
• My Docker Lessons Learned (The Hard Way)
• Demo: Build & Run Docker Images from a TFS Build

QA Testing & Automated UI Tests with Selenium

Just because you're doing DevOps doesn't mean that QA testing goes away. You still have to verify that the application works properly...but you'll probably want to change how you do it.  DevOps needs a new kind of QA.  In this module, we'll discuss how to re-think the traditional manual testing / QA testing process to be a lot more DevOps-friendly.  We'll also show you how to manage your testing efforts and QA test cases using TFS.  Finally, we'll discuss how to use Selenium to automate the testing of your applications during your TFS builds and TFS releases.

• QA Testing & DevOps (aka. Traditional QA Is Broken)
• The Testing Pyramid
• Common Testing Mistakes of Agile / Scrum Teams
• Getting Started with 'New QA'
• A Testing Tip for Agile / Scrum Teams
• Team Foundation Server + QA Testing
• Demo: Create a Test Plan in TFS
• Demo: Create Test Cases in TFS
• Demo: Run Test Cases with the Chrome Extension
• Demo: View the Results of a Previous Test Run
• Demo: Run a Test Case & Create a Bug
• Demo: Create / Manage TFS Test Configurations
• Demo: Assign Test Cases to Testers
• Demo: Exploratory Testing with the Chrome Extension
• User Interface Automation Tests
• Demo: Getting Started with Selenium & PhantomJS
• Demo: Run Selenium Tests from a TFS Build using PhantomJS

And once again, here's the link to the course on Pluralsight.

Enjoy!

-Ben