
Paths
.NET Microservices
Microservices are a design pattern in which applications are composed of small, independent modules that communicate with each other using well-defined contracts making it easier... Read more
Microservices architecture The software development lifecycle for microservices Microservices elements How ASP.NET Core can be used to create a microservices architecture How to create a basic microservices-based architecture with ASP.NET Core Client to Service architecture How to deploy the .NET Core microservices to Kubernetes using AKS Cross-cutting concerns when building .NET Core microservices
Pre-requisites
C# ASP.NET
Beginner
The courses in this beginning section have been designed to introduce the microservices architecture, terminology, and software development lifecycle including the planning and design process.
Microservices: The Big Picture
1h 45m
Description
Microservices are everywhere, but what are they? In this course, Microservices: The Big Picture, you will learn exactly what microservices are. First, you will become familiar with the elements of a microservice. Then, you will explore design patterns, terminology, and functional concepts. Finally, you will see the pros and cons of microservices architecture in a business as well as technical points of view. When you’re finished with this course you’ll have enough knowledge to decide whether to use microservices in your future project.
Table of contents
- Course Overview
- What Are Microservices?
- Microservices Elements
- Are Microservices Right for Your Organization?
ASP.NET Core Microservices: Getting Started
1h 20m
Description
Using autonomous microservices is a great solution for scenarios where high flexibility and scalability is needed. In this course, ASP.NET Core Microservices: Getting Started, you’ll learn the reasoning behind using microservices and how to create them using ASP.NET Core. First, you’ll explore a sample application using 2 microservices teaching you the basics. Next, you’ll discover when microservices should be used and what ASP.NET Core techniques are great when using them. Finally, you’ll learn how to communicate asynchronously with microservices. When you’re finished with this course, you’ll have the knowledge to decide if microservices are a good choice for your organization and the skills to implement them using ASP.NET Core.
Table of contents
- Course Overview
- How to Create a Microservice
- Connecting Microservices Synchronously and Asynchronously
- Microservices Considerations and Design
Microservices Communication in ASP.NET Core
3h 15m
Description
Microservices are getting more traction as an architectural approach for the design of applications, also on the .NET stack. Although the ideas behind microservices are rather simple, it can be a daunting task to get started with the creation of a full system based on microservices. In this course, Microservices Communication in ASP.NET Core, you’ll learn to set up a microservice architecture and to arrange the communication between these different services. First, you’ll explore how to set up synchronous communication between different services. Next, you’ll discover the asynchronous variant of microservices communication using a service bus. Finally, you’ll learn how to connect different application front-ends by building a backend-for-frontend (BFF) and by implementing the API Gateway pattern. When you’re finished with this course, you’ll have the skills and knowledge of setting up communication between different services needed to create a resilient microservices architecture based on ASP.NET Core.
Table of contents
- Course Overview
- Introducing Microservice Communication in ASP.NET Core
- Creating Synchronous Communication between ASP.NET Core Microservices
- Setting up Asynchronous Communication between ASP.NET Core Microservices
- Making Microservices More Resilient
- Accessing a Microservices Infrastructure
Intermediate
Moving beyond the basics in this intermediate level where you will begin to implement data management strategies, securing microservices, versioning, and finally deploying microservices using Kubernetes and AKS.
Implementing a Data Management Strategy for an ASP.NET Core Microservices Architecture
1h 53m
Description
Data management in a distributed architecture presents unique challenges and opportunities. In this course, Implementing a Data Management Strategy for an ASP.NET Core Microservices Architecture, you’ll learn to how to address common data management requirements within a microservices architecture. First, you’ll explore the challenges inherent in a distributed microservices architecture, where data may be distributed, or even duplicated and needs to be kept consistent during updates. Next, you’ll discover services in Azure that allow each microservice to choose the best data storage approach. Finally, you’ll learn how to keep data across microservices up to date, using eventual consistency. When you’re finished with this course, you’ll have the skills and knowledge to architect a data management strategy for your microservices solutions.
Table of contents
- Course Overview
- Data Management Architecture with Microservices
- Data Management within Microservices
- Data Consistency across Microservices
Securing Microservices in ASP.NET Core
3h 36m
Description
Authentication and authorization are two very important aspects of a secure microservices architecture. In this course, Securing Microservices in ASP.NET Core, you'll learn how to secure your microservices using a variety of best practice techniques for authentication and authorization. You'll learn how to work with an identity microservice, how to apply security with and without an API gateway, and how to improve upon the default security approach to reach a best-of-class implementation. By the end of this course you'll be comfortable implementing best-practice security techniques in microservices architectures.
Table of contents
- Course Overview
- Securing Your First Microservice
- Improving Your Security with Service to Service and Token Exchange Patterns
- Implementing Security with API Gateway and BFF Patterns
- Improving the API Gateway Pattern
- Enabling Long-lived Access and Token Stores
- Securing Async Service Communication
Versioning and Evolving Microservices in ASP.NET Core
1h 41m
Description
In this course, Versioning and Evolving Microservices in ASP.NET Core, you’ll learn to safely and effectively evolve your microservice APIs by versioning them. First, you’ll discover the value of avoiding breaking changes to allow us to safely add functionality to our APIs. Next, you’ll explore a variety of strategies and best practices for versioning APIs. Finally, you’ll learn how to put these techniques into practice in the context of a real-world ASP.NET Core microservices application. When you’re finished with this course, you’ll have the skills and knowledge of versioning strategies needed to evolve and improve your microservice APIs while maintaining backwards compatibility.
Table of contents
- Course Overview
- Understanding Why APIs Evolve
- Maintaining Backwards Compatibility
- Implementing API Versioning
- Versioning Messages
Deploying ASP.NET Core Microservices Using Kubernetes and AKS
2h 7m
Description
It can be useful to deploy your Microservices using containers and run them on a Kubernetes cluster that runs in Azure as a managed PaaS service (better known as AKS). In this course, Deploying ASP.NET Core Microservices Using Kubernetes and AKS, you’ll learn to deploy your Microservices using containers and run them on a Microsoft Azure Kubernetes Services provided Kubernetes cluster. First, you’ll explore why we want to use containers to deploy microservices and run them on a Kubernetes cluster. Next, you’ll discover what a Kubernetes cluster offers and how to set it up in the azure cloud. Then, you will automate the deployments to minimize downtime and outages. Finally, you’ll learn how to deploy database schema changes for your microservices while not having any downtime. When you’re finished with this course, you’ll have the skills and knowledge of containers, Kubernetes, and deployment automation with Azure DevOps and GitHub needed to deploy ASP.NET microservices to a Kubernetes infrastructure available in the Azure Cloud as AKS.
Table of contents
- Course Overview
- Understanding Microservices and Containers
- Deploying Micro Services to Kubernetes
- Automating Deployments with Azure DevOps and GitHub
- Updating the Database with Zero-downtime
Advanced
These advanced courses have been designed to take your understanding of microservices and learn about cross-cutting concerns and scalability.
Implementing Cross-cutting Concerns for ASP.NET Core Microservices
2h 8m
Description
This course will help you on your journey when building microservice applications using ASP.NET Core.
In this course, Implementing Cross-cutting Concerns for ASP.NET Core Microservices, you will learn how to implement logging and health checks in your microservices.
First, you will discover the importance of logging and some of the challenges that microservices introduce. Next, you will implement logging in several microservices, taking into consideration how log messages produced across microservice boundaries can be correlated and aggregated to form a complete story about a request or operation. Finally, you will explore how to apply health checks to ASP.NET Core microservices to support liveness and readiness checks, used to monitor services in production.
When you are finished with this course, you will have the skills and knowledge to apply logging and health checks in .NET Core microservices.
Table of contents
- Course Overview
- Implementing Logging
- Implementing Centralized Logging for Microservices
- Implementing Health Checks in Microservices
Strategies for Microservice Scalability and Availability in ASP.NET Core
1h 54m
Description
There is a tendency to dive straight into the complex world of containers and container orchestration engines when trying to improve your ability to scale out and increase resiliency within your software. There is however a much simpler strategy available with components and techniques that are easier to implement quickly. In this course, Strategies for Microservice Scalability and Availability in ASP.NET Core, you’ll learn how to scale-out architecture using .NET-microservices. First, you’ll explore the importance of stateless services. Next, you’ll discover how stateless microservices allow you to run multiple services behind a load balancer or a queue. Finally, you’ll learn how to implement caching strategies to protect backend systems and improve performance. When you’re finished with this course, you’ll have the skills and knowledge of how to scale out .NET microservices to create software architecture with high availability and performance.
Table of contents
- Course Overview
- Introduction
- Scaling Out with Load Balancers
- Scaling out with Queues and Message Brokers
- Caching Strategies