Distributed .NET Core
About course: Complete guide for creating, managing and orchestrating microservices using .NET Core platform, C# language, Docker technology and many more. Almost 20 hours of videos along with the whole source code and lots of practical samples that can be found on GitHub.
Welcome to the teaser of an incoming Distributed .NET Core course! 🙂
The first episode is finally here – we’re discussing mostly the overall setup, configuration and to how get up and running with the services.
In the second episode, we’re building a new Discounts Service, starting with a typical HTTP API, that will be able to receive and handle a command. During the whole episode, we’re following CQRS approach.
In the third episode, we use RabbitMQ in order to subscribe to the commands being sent to the message broker. We also modify API gateway to handle the new endpoint.
In the fourth episode, we make use of the events (being sent to the message bus) in order apply asynchronous integration between microservices. Such technique removes temporal coupling and increases resiliency.
In the fifth episode, we do focus on the read side – query part of CQRS. Starting with the implementation of QueryHandlers and DTOs, eventually, we add the internal HTTP communication between API Gateway and microservice using RestEase.
In the sixth episode, we present another example of internal HTTP communication – fetching (relatively) large objects from one service to another to avoid performance issues. Moreover, we introduce Consul as a Service Discovery and Fabio as a lightweight load balancer.
In the seventh episode, we talk about correlation context and how to handle the asynchronous requests. In order to provide real-time status updates of the ongoing operations, we make use of SignalR. We also talk about resiliency by using Polly library.
In the eighth episode, we focus on the distributed transactions – starting from 2PC, through Event Choreography and eventually Saga and Process Managers. We do implement such transaction using the Chronicle library, that deals with order creation in DShop.
In the 10th episode, we go through other useful tools but this time related to metrics. We start with the AppMetrics integration with ASP.NET Core, then we introduce InfluxDB as a data source which we later switch to Prometheus. We also visualize collected metrics using Grafana’s dashboards.
In the eleventh episode, we start discussing the first part of the CI & CD journey – how to use the build service (Travis CI in our scenario) and deal with the shared library using custom NuGet feeds (e.g. MyGet).
In the 12th episode, we discuss basics of Docker technology like building images based on Dockerfiles, running the containers using Docker CLI, connecting containers to the networks, creating easily runnable environments using docker-compose etc. We also extend build pipeline in Travis CI with another step by publishing Docker images to the public registry called Docker Hub.
In the thirteenth episode, we create integration tests for the microservice. Using ASP.NET Core integration testing library, along with xUnit framework, we deal with testing Web API endpoints, data contracts, and message handlers while using the infrastructural services such as MongoDB and RabbitMQ.
In the fourteenth episode, we discuss yet another approach to testing the Web API being consumer-driven contract testing using the pact.io framework.
In the fifteenth (and final) episode, we present a different deployment and orchestration strategies, starting with bare metal VM using Docker, then we talk about Portainer, discuss the basics of Kubernetes and finally use Rancher.