Hit enter to search or ESC to close

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.

 

Teaser

Welcome to the teaser of an incoming Distributed .NET Core course! 🙂

 

 

Episode 1 [Intro, HTTP requests flow, Infrastructure with Docker]

The first episode is finally here – we’re discussing mostly the overall setup, configuration and to how get up and running with the services.

 

 

Episode 2 [CQRS – Write side, Discounts service, MongoDB repository]

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.

 

Episode 3 [Subscribing RabbitMQ messages, API gateway]

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.

 

Episode 4 [Asynchronous microservices integration via events]

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.

 

Episode 5 [CQRS – Read side, Internal HTTP communication]

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.

 

Episode 6 [Service discovery & Load balancing with Consul + Fabio]

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.

 

Episode 7 [Handling asynchronous requests, SignalR, Polly]

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.

 

Episode 8 [Distributed transactions, 2PC, Event Choreography, Saga]

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.

 

Episode 9 [Vault secrets, Seq logging, Jaeger distributed tracing]

In the ninth episode, we present a few useful tools, starting with Vault for storing credentials and app settings in general, then we talk about Seq which is a logging system, and eventually, we discuss the Jaeger which provides the distributed tracing.

 
 

Episode 10 [Metrics with AppMetrics, InfluxDB, Prometheus, Grafana]

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.

 

Episode 11 [Travis CI pipelines, custom MyGet feeds]

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).

 

Episode 12 [Docker basics, Docker Hub, docker-compose]

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.

 

Episode 13 [Integration tests with xUnit, Web API, Mongo, RabbitMQ]

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.

 

Episode 14 [Consumer-driven contract testing with Pact]

In the fourteenth episode, we discuss yet another approach to testing the Web API being consumer-driven contract testing using the pact.io framework.

 
 

Episode 15 [Orchestration with Portainer, Kubernetes and Rancher]

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.