Week 1: Fundamentals

01 Welcome to the course! 5 lessons
  • Course Introduction
  • Source code and other course downloads
  • Development environment setup
  • What's wrong with the monolith?
  • What are microservices?
02 Your first microservice 5 lessons
  • Creating a microservice via the .NET CLI
  • Introduction to the REST API and DTOs
  • Adding the DTOs
  • Adding the REST API operations
  • Handling invalid inputs
03 Adding database storage 7 lessons
  • Introduction to the repository pattern and MongoDB
  • Implementing a MongoDB repository
  • Using the repository in the controller
  • Introduction to Docker
  • Trying out the REST API with a MongoDB container
  • Introduction to Dependency Injection and Configuration
  • Implementing dependency injection and configuration
04 Preparing for the next microservice 7 lessons
  • Using Postman
  • Reusing common code via NuGet
  • Refactoring into a generic MongoDB repository
  • Refactoring MongoDB registration into extension methods
  • Moving generic code into a reusable NuGet package
  • Introduction to Docker Compose
  • Moving MongoDB to docker compose
05 Synchronous inter-service communication 8 lessons
  • Creating the Inventory microservice
  • Introduction to synchronous communication
  • Implementing synchronous communication via IHttpClientFactory
  • Understanding timeouts and retries with exponential backoff
  • Implementing a timeout policy via Polly
  • Implementing retries with exponential backoff
  • Understanding the circuit breaker pattern
  • Implementing the circuit breaker pattern
06 Asynchronous inter-service communication 7 lessons
  • Introduction to asynchronous communication
  • Defining the message contracts
  • Publishing messages via MassTransit
  • Standing up a RabbitMQ docker container
  • Refactoring MassTransit configuration into the reusable NuGet package
  • Consuming messages for eventual data consistency
  • Removing the inter-service synchronous communication
07 Initial Frontend Integration 6 lessons
  • Installing Node.js
  • Getting the React frontend source code
  • Getting started with the frontend
  • Understanding CORS
  • Adding the CORS middleware
  • Exploring the frontend to microservices communication

Week 2: Security

08 Identity in Microservices 4 lessons
  • Introduction to ASP.NET Core Identity
  • Creating the Identity microservice
  • Integrating ASP.NET Core Identity with MongoDB
  • Adding the Users REST API
09 Microservices Security Patterns and Techniques 4 lessons
  • Microservices authentication
  • Introduction to OAuth 2.0
  • Introduction to OpenID Connect
  • Introduction to IdentityServer
10 Implementing Microservices Security 7 lessons
  • Setting up IdentityServer
  • Requesting tokens via Postman
  • Understanding JSON Web Tokens
  • Securing the Catalog microservice
  • Generalizing how to add authentication to microservices
  • Securing the Inventory microservice
  • Securing the Identity microservice
11 Authorization in Microservices 6 lessons
  • Storing secrets during local development
  • Understanding Authorization in ASP.NET Core
  • Seeding users and roles
  • Adding users to the Player role
  • Implementing role-based authorization
  • Implementing claims-based authorization
12 Frontend Integration to Secure Microservices 7 lessons
  • Getting the React frontend source code
  • Configuring CORS in the Identity microservice
  • Adding the frontend client to the IdentityServer configuration
  • Fixing the logout experience
  • Using ID tokens in the frontend client
  • Using access tokens in the frontend client
  • Fixing the user registration experience

Week 3: Transactions

13 Transactions with Microservices 4 lessons
  • Database Transactions
  • Distributed Transactions
  • Introduction to Sagas
  • Choreographed VS Orchestrated Sagas
14 Preparing the Saga participants 5 lessons
  • Purchase Saga Overview
  • Publishing Catalog prices
  • Allowing services to customize the retry configuration
  • Granting and subtracting items via asynchronous messages
  • Debiting gil via asynchronous messages
15 Implementing the Purchase Saga 12 lessons
  • Creating the Trading microservice
  • Creating a MassTransit state machine
  • Initializing the state machine
  • Adding the Purchase controller
  • Configuring the Trading microservice
  • Trying out the state machine
  • Querying the state machine via a controller action
  • Consuming Catalog prices in the Trading microservice
  • Adding a custom state machine activity
  • Sending and consuming Inventory messages from the state machine
  • Unsing the MassTransit In-Memory Outbox
  • Sending and consuming Identity messages from the state machine
16 Compensation and Idempotency 6 lessons
  • Compensating actions in the state machine
  • Idempotency in microservices
  • Adding idempotency to a controller action
  • Handling out of order messages in the state machine
  • Handling message duplication
  • Implementing idempotent consumers
17 The Frontend Store Experience 9 lessons
  • Store experience overview
  • Publishing inventory updated events
  • Publishing user updated events
  • Consuming Inventory and Identity events in the Trading microservice
  • Implementing the Store controller
  • Trying out the updated Frontend portal
  • Real-time updates via SignalR
  • Configuring SignalR authentication
  • Sending real-time updates from the state machine via SignalR

Week 4: Docker and Microsoft Azure

18 Microservices and Source Control 5 lessons
  • Monorepo vs Multirepo
  • Installing Git
  • Using Git to add files to source control
  • Creating a GitHub organization
  • Uploading files to a GitHub repository
19 Publishing NuGet Packages to GitHub 4 lessons
  • Preparing NuGet packages for GitHub
  • Generating a GitHub Personal Access Token
  • Publishing to GitHub Packages
  • Consuming a NuGet package from GitHub
20 Dockerizing your microservices 5 lessons
  • Running your microservice anywhere via Docker
  • Adding a Dockerfile
  • Consuming NuGet packages within a Dockerfile
  • Building a Docker image
  • Running a Docker container
21 Getting Started with Microsoft Azure 3 lessons
  • Creating an Azure account
  • Installing the Azure CLI
  • Creating an Azure resource group
22 Using Azure Cosmos DB 3 lessons
  • Creating a Cosmos DB account
  • Adding Cosmos DB support to the Common library
  • Using Cosmos DB in a microservice
23 Using Azure Service Bus 3 lessons
  • Creating a Service Bus namespace
  • Adding Service Bus support to the Common library
  • Using Service Bus in a microservice
24 Using the Azure Container Registry 2 lessons
  • Creating an Azure Container Registry
  • Publishing Docker images to Azure Container Registry

Week 5: Cloud Deployment

25 Deploying microservices to Azure Kubernetes Service 6 lessons
  • Introduction to Kubernetes
  • Creating a Kubernetes cluster
  • Defining a Kubernetes deployment
  • Using Kubernetes secrets
  • Creating a Kubernetes pod
  • Creating a Kubernetes service
26 Reporting the microservices health 4 lessons
  • Adding a basic health check
  • Creating a custom database health check
  • Adding Kubernetes health probes
  • Generalizing the health check configuration
27 Storing Secrets in Azure Key Vault 5 lessons
  • Creating an Azure Key Vault
  • Reading secrets from Azure Key Vault
  • Creating AAD pod-managed identities
  • Using AAD pod-managed identities
  • Generalizing the Azure Key Vault configuration
28 Adding the API Gateway 6 lessons
  • Introduction to the API Gateway
  • Installing Helm
  • Installing the Emissary-ingress API Gateway
  • Configuring Routing to a Microservice
  • Running the Identity microservice behind the API gateway
  • Using Postman environments
29 Enabling HTTPS and TLS Termination 6 lessons
  • Installing cert-manager
  • Generating a TLS certificate
  • Enabling HTTPS and TLS termination in Emissary-ingress
  • Forwarding headers to the Identity microservice
  • Creating a signing certificate
  • Using the signing certificate in the Identity microservice
30 Running the system in Production 2 lessons
  • Deploying the Catalog microservice to AKS
  • Trying out the Frontend in Production

Week 6: CI/CD

31 Using Helm charts to simplify microservices deployment 7 lessons
  • Creating a Helm chart (Part 1)
  • Creating a Helm chart (Part 2)
  • Creating a Helm chart (Part 3)
  • Deploying a microservice using a Helm chart
  • Generalizing the Helm chart
  • Publishing a Helm chart to ACR
  • Deploying a microservice using a Helm chart from ACR
32 Microservices and Continuous Integration 5 lessons
  • Introduction to CI/CD
  • Creating a CI/CD pipeline with GitHub Actions
  • Generating version numbers via GitHub Actions
  • Publishing NuGet packages via GitHub Actions
  • Building docker images via GitHub Actions
33 Microservices and Continuous Deployment 4 lessons
  • Authenticating GitHub repositories with Azure
  • Logging in to Azure via GitHub Actions
  • Publishing docker images via GitHub Actions
  • Deploying a microservice to AKS via GitHub Actions