Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Microsoft

Create cloud-native apps and services with .NET and ASP.NET Core

Microsoft via Microsoft Learn

Overview

Limited-Time Offer: Up to 75% Off Coursera Plus!
7000+ certificate courses from Google, Microsoft, IBM, and many more.
  • Module 1: Microservice applications are composed of small, independently versioned, and scalable customer-focused services that communicate with each other over standard protocols with well-defined interfaces. Each microservice typically encapsulates simple business logic, which you can scale out or in, test, deploy, and manage independently. Smaller teams develop a microservice based on a customer scenario and use any technologies that they want to use. This module will teach you how to build your first microservice with .NET.
  • By the end of this module, you'll be able to:

    • Explain what microservices are.
    • Know how various technologies involved in microservices are and how they relate.
    • Build a microservice using .NET.
  • Module 2: Microservice applications are composed of small, independently versioned, and scalable customer-focused services. Microservices applications deployed in containers make it possible to scale out apps, and respond to increased demand by deploying more container instances, and to scale back if demand is decreasing. In complex solutions of many microservices the process of deploying, updating, monitoring, and removing containers introduces challenges. This module explains some of those challenges and shows how Kubernetes can help.
  • In this module you will:

    • Learn the concepts behind orchestrators and why you might need them.
    • Take an existing .NET microservice hosted in a Docker container and push it to Docker Hub.
    • Deploy the microservice from Docker Hub to a local Kubernetes instance.
    • Learn how to scale a container instance in a Kubernetes cluster.
  • Module 3: This module guides you through containerizing an ASP.NET Core microservice and deploying it to Azure Kubernetes Service.
  • In this module, you will:

    • Examine existing ASP.NET Core microservices running in Azure Kubernetes Service (AKS).
    • Implement a new ASP.NET Core microservice and containerize it.
    • Publish the Docker image to Azure Container Registry (ACR).
    • Deploy the Docker container to the existing AKS cluster.
  • Module 4: This module guides you through implementing resiliency in an ASP.NET Core microservices app in Azure Kubernetes Service.
  • In this module, you will:

    • Understand foundational resiliency concepts.
    • Observe the behavior of a microservice with no resiliency strategy.
    • Implement failure handling code for HTTP requests in one microservice.
    • Deploy an infrastructure-based resiliency solution to an AKS cluster.
  • Module 5: This module guides you through implementing logging and monitoring in an ASP.NET Core microservices app in Azure Kubernetes Service.
  • In this module, you will:

    • Review diagnostics logging and performance monitoring concepts.
    • Implement diagnostics logging with Application Insights.
    • Implement performance monitoring with Application Insights.
    • Enable Azure Monitor for Containers in a Kubernetes cluster.
    • Create a custom performance metric using Prometheus.
    • Examine a custom performance metric using Azure Monitor for Containers.
  • Module 6: This module guides you through implementing a feature flag in an ASP.NET Core microservices app using Azure App Configuration.
  • In this module, you will:

    • Review ASP.NET Core and Kubernetes app configuration concepts.
    • Implement real-time feature toggling with the .NET Feature Management library.
    • Implement a centralized Azure App Configuration store.
  • Module 7: This module guides you through implementing Azure-managed data stores in an ASP.NET Core microservices app.
  • In this module, you will:

    • Review fully managed data service offerings in Azure.
    • Provision an Azure Cache for Redis instance.
    • Provision an Azure Cosmos DB instance using the MongoDB API.
    • Modify an existing microservices app to use the managed data services.
  • Module 8: This module guides you through implementing BFF in an ASP.NET Core microservices app.
  • In this module, you will:

    • Deploy an existing ASP.NET Core microservices e-commerce application to Azure Kubernetes Service (AKS).
    • Implement a Backend for Frontend (BFF) pattern by using .NET.
    • Deploy the microservices application to an AKS instance that's using Azure Application Gateway.
    • Expose the BFF API outside the Kubernetes cluster by using Application Gateway Ingress Controller and access that external Swagger client.
  • Module 9: Implement GitHub Actions to build a container image and deploy to Azure Kubernetes Service.
  • In this module, you will:

    • Authenticate GitHub Actions to a container registry.
    • Securely store sensitive information used by the GitHub Actions.
    • Implement a GitHub Action to build the container image for a microservice.
    • Modify and commit the microservice code to trigger a build.
    • Implement a GitHub Action to deploy a container to a Kubernetes cluster.
    • Modify and commit a Helm chart to trigger a deployment.
    • Revert the microservice to a previous deployment.

Syllabus

  • Module 1: Build your first microservice with .NET
    • Introduction
    • What are microservices?
    • Exercise - Build a Dockerfile for your microservice
    • Microservices orchestration
    • Exercise - Create a Docker Compose file
    • Summary
  • Module 2: Deploy a .NET microservice to Kubernetes
    • Introduction
    • What are orchestrators?
    • Exercise - Push a microservice image to Docker Hub
    • Exercise - Deploy a microservice container to Kubernetes
    • Exercise - Scale a container instance in Kubernetes
    • Exercise - Prove microservice resilience in Kubernetes
    • Summary
  • Module 3: Create and deploy a cloud-native ASP.NET Core microservice
    • Introduction
    • Exercise - Set up the environment
    • Review the solution architecture
    • Exercise - Review the code and verify deployment
    • Review the coupon service design
    • Exercise - Add the coupon service
    • Exercise - Deploy changes to AKS
    • Knowledge check
    • Summary
  • Module 4: Implement resiliency in a cloud-native ASP.NET Core microservice
    • Introduction
    • Exercise - Set up the environment
    • Review resiliency concepts
    • Exercise - Verify deployment and test the app
    • Exercise - Implement code-based resiliency
    • Exercise - Implement infrastructure-based resiliency
    • Knowledge check
    • Summary
  • Module 5: Instrument a cloud-native ASP.NET Core microservice
    • Introduction
    • Exercise - Set up the environment
    • Review logging and monitoring concepts
    • Exercise - Implement Application Insights
    • Exercise - Monitor Application Insights
    • Exercise - Implement Azure Monitor for Containers
    • Knowledge check
    • Summary
  • Module 6: Implement feature flags in a cloud-native ASP.NET Core microservices app
    • Introduction
    • Exercise - Set up the environment
    • Review app configuration concepts
    • Exercise - Implement the Feature Management library
    • Exercise - Implement the Azure App Configuration service
    • Knowledge check
    • Summary
  • Module 7: Use managed data stores in a cloud-native ASP.NET Core microservices app
    • Introduction
    • Exercise - Set up the environment
    • Review managed data stores in Azure
    • Exercise - Verify deployment and test the app
    • Exercise - Implement Azure Cache for Redis
    • Exercise - Implement Azure Cosmos DB
    • Knowledge check
    • Summary
  • Module 8: Understand API gateways in a cloud-native ASP.NET Core microservices app
    • Introduction
    • Exercise - Set up the environment
    • Exercise - Verify deployment and test the app
    • Understand API gateways and Backends for Frontends
    • Implement a new Backend for Frontend
    • Understand Kubernetes ingress controller concepts
    • Exercise - Implement a load balancer with Azure Application Gateway
    • Knowledge check
    • Summary
  • Module 9: Deploy a cloud-native ASP.NET Core microservice with GitHub Actions
    • Introduction
    • Exercise - Set up the environment
    • Exercise - Configure GitHub Action permissions and secrets
    • Exercise - Create a GitHub Action to build a container image
    • Exercise - Create a GitHub Action to deploy to AKS
    • Knowledge check
    • Summary

Reviews

Start your review of Create cloud-native apps and services with .NET and ASP.NET Core

Never Stop Learning.

Get personalized course recommendations, track subjects and courses with reminders, and more.

Someone learning on their laptop while sitting on the floor.