Creating .Net Core Microservices using Clean Architecture

Complete guide to build enterprise edition application end to end
What you'll learn
Learn how to create Microservices using .Net Core
Learn how to stitch multiple technologies together
Learn how to implement message queues
Learn how to implement Mediator Pattern
Learn how to implement CQRS Pattern
Lear how how to Containerize entire solution
Lear how how to use Application Gateway
Learn how to implement structured Logging
Lear how to handle cross cutting concerns like ELK Stack, Observability etc
Learn how to put all the workloads on the K8s cluster
Learn how to apply Service Mesh using Istio
Learn how to implement Side Car pattern
Requirements
Basics of C#, .Net Core, Docker
Description
Microservices are a design pattern in which applications are composed of independent modules that communicate with each other within well defined boundaries. This makes it easier to develop, test, and deploy isolated parts of your application.
In this particular section, you will be learning plethora of technologies coming together for the common purpose. In the first segment, you will be building Microservices module using clean architecture. You will also be implementing CQRS design pattern in order to implement the clean architecture design. Here, you will learn how to apply all the industry best practices together. This series is designed using .Net Core 6 and Angular 15. Angular is used in the client application. For that there is a separate dedicate course for that.
This course is part of Microservices series where in you will learn all minute details related to Microservices. During this learning path, you will learn how to connect the dots using different technologies and tooling. This course "Getting Started with Microservices using Clean Architecture" is the first part of the series.
Other parts include
2. Securing Microservices using Identity Server 4
3. Implementing Cross Cutting Concerns
4. Versioning Microservices
5. Building Angular Application for MicroServices
6. Deploying Microservices to Kubernetes and AKS

Coupon Code:- 1F2E6B5C5336CE822FE3

IDE Required:- You can either use Visual Studio or JetBrains Rider, or VS Code itself.
In this course you will be learning and implementing following things.
Introduction
Course Overview
Architecture Overview
Project Overview
Branching Strategy
Layered Vs Domain Centric
Hexagonal Architecture
Onion Architecture
Clean Architecture
CQRS Pattern
Solution Overview
Demo

Developing Catalog Microservice using Clean Architecture
Introduction
Creating Empty Solution
Adding Required Project References
Startup and Program file creation
Launch property changes
Entity creation
Repositories creation
Seed data setup
Catalog context implementation
Seed data property changes
Product repository implementation - part 1
Product repository implementation - part 2
Get All Brands Handler
Implementing Lazy Mapper
Get All Products Handler
Get All Types Handler
Get Product By Id and Name Handler
Get Product By Brand Handler
Create Product Handler
Delete Product Handler
Base Controller Setup
Startup Registration
Startup Registration - 2nd Part
Get Product By Id Controller Method
Remaining Controller Implementations
Docker File Update
Running Docker File from IDE
Docker Project Creation
Catalog Flow
Debugging Catalog Application
Catalog Specifications Setup
Search Filter Implementation
Sorting Functionality Implementation
Sorting Functionality Implementation - 2nd Part
Testing Searching and Sorting
Fixed Catalog Query
Fixed Project Reference
Developing Basket Microservice using Clean Architecture
Introduction
Basket MicroService Project Creation
Creating Basket Entities
Basket Repository Implementation
Shopping Cart Response Creation
Get Basket By UserName Handler
Create Shopping Command Handler
Delete Basket By UserName
Adding Nuget Packages in Basket API Project
Startup File Creation
Program File and App Setting Changes
Basket Controller Creation
Docker File and Docker Compose Changes
Testing Basket inside Docker Container
Container Management using Portainer

Developing Discount Microservice Using Clean Architecture
Introduction
Discount Project Creation
Adding Project References
Entities Creation
Repository Implementation
Adding Db Extension
Discount Proto File Creation
Get Discount Query and Handler
Create Coupon Command Handler
Update Discount Command and Handler
Delete Discount Command and Handler
Startup File Creation
Discount Service Creation
Appsettings and Program File Changes
Docker File Changes
Container Issue Fix and Data Visualisation

Consuming Discount Microservice from Basket Microservice
Introduction
Consuming Discount Microservice
Calling Discount Microservice from Basket
Removing the Redundant References
Docker Volume Issue
Debugging Basket and Discount Service
Running Discount and Basket Microservice from Container

Developing Ordering Microservice using Clean Architecture
Introduction
Ordering Project Creation
Implementing Ordering Core
Adding Nuget Packages in Infrastructure
Order Context Creation
Creating OrderContextFactory and Seed Data
Async Repository Implementation
Order Repository Implementation
Adding Extensions
Creating Application Project Folders
Get Order List Query and Handler
Checkout Order Command Handler
Update Order Handler
Delete Order Command handler
Adding Fluent Validation
Validation Exception
Update Order Command Validator
Unhandled Exception Behaviour
Adding Service Registrations
Adding Nuget Packages in Ordering API
Startup Creation
Creating Db Extension
Program File Creation
Controller Creation Part 1
Controller Creation Part 2
Docker file changes
Running Containers Locally
Fixing Container Issue
Testing All Methods on swagger

Async Communication between Rabbit MQ, Basket and Ordering Microservice
Introduction
Creating Event Bus Project
Adding Mass Transit Nuget Packages
Startup Changes for Mass Transit
Publishing Basket Checkout Event - 1st Part
Publishing Basket Checkout Event - 2nd Part
Testing Basket Checkout Event
Event Bus Docker Issue
Testing Checkout Event using Docker
Adding Nuget Packages and Project Reference
Ordering Startup Changes
Basket Ordering Consumer Implementation
Issue At Consumer End
Fixing Container issue

Application Gateway Implementation
Introduction
Project Creation
Startup File Changes
Program File changes
Ocelot Configuration Changes
Converting the Project as Web Project
Docker File Changes
Gateway Issue
Gateway Demo
Whats Next
On top of that, you will learn how to write quality code. 99% time you guys will be coding along with me. Hence, you will be learning not only the theory part but rather its implementation as well.

Who this course is for:
Beginners, Intermediate or even Advanced level candidates who wanted to refine their Microservices knowledge using .Net core and other tons of different technologies

More Info