The sixth episode was released. During this video, we make use of Consul – a service registry, which enables the service discovery capabilities for the microservices and eventually, we add Fabio on top of the stack, which provides an additional load balancer and a dynamic routing table.
Posts in ".NET Core"
Distributed .NET Core – Episode 5 (CQRS – Read side, Internal HTTP communication)
The fifth episode is available. In this video, we talk about queries (read side) part of CQRS. At first, we implement QueryHandlers and DTOs and eventually, we introduce an internal HTTP communication between API Gateway and microservice using RestEease.
Distributed .NET Core – Episode 4 (Asynchronous microservices integration via events)
The fourth episode was published. In this video, we’re implementing the events and event handlers as a way of asynchronous integration between microservices, that reduces the temporal coupling and improves the overall resiliency.
Distributed .NET Core – Episode 3 (Subscribing RabbitMQ messages, API gateway)
The third episode is available. We’re talking about the RabbitMQ message bus and implementing the message subscription on the service side, meaning that you shall be able to listen to the particular messages being sent to the message bus and handle them, just as we did in the previous episode, using in-memory command dispatcher.
Distributed .NET Core – Episode 2 (CQRS – Write side, Discounts service, MongoDB repository)
The second episode is here. In this video, we’re going through CQRS and implement a basic HTTP API, that is able to receive and handle the command. In the next episodes, we’ll be extending the newly created Discounts Service, in order to make it work with the overall solution (remaining microservices).
Distributed .NET Core – Episode 1 (Intro, HTTP requests flow, Infrastructure with Docker)
After almost 3 months, since we released the Distributed .NET Core Teaser and a lot of refactoring and code improvements along with custom libraries being implemented, we’d like to present the first episode of our online course, where we’re talking about setting up your environment, starting the services and validating HTTP requests.
Distributed .NET Core – Teaser
Hi there, folks. It’s been a while (a quarter to be exact) since I’ve announced for the first time Microservices in .NET Core with DShop series as a part of DevMentors idea. I do apologize for not being consistent back then, however, there was a single reason for it – together with Darek we did rewrite lots of code after gathering a great feedback during our lectures.
May I present you, the very first teaser of our incoming video series.
.NET Core Microservices – theory, DShop solution structure
In the previous post, being sort of a teaser, I made a brief introduction to DShop project, as well as the idea behind the overall course. Starting from now on, we’ll focus on the fundamental parts of DShop, including the theory behind a particular concept, its possible solutions, and eventually an implementation.
.NET Core Microservices – DShop
It’s been a while since I published the latest article, but it’s high time to finally get into the topic of microservices for real. Does open source, .NET Core, distributed system, Docker and other cool words sound good to you? If that’s the case, stick with me and let me guide you through the world (or at least part of it) of microservices. This is going to be the very first article (an introduction) of the upcoming series.
Canceling JWT tokens in .NET Core
Quite some time ago I published an article (along with the source code) about refreshing the JWTtokens. In the following post, I’m going to focus on canceling the token, thus it can’t be used by anyone else. This tutorial includes the video, so it might be easier to understand the implementation flow.