Complete guide to build enterprise edition application end to end
What you will 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
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.
Content
Introduction
Developing Catalog Microservice using Clean Architecture
Developing Basket Microservice using Clean Architecture
Developing Discount Microservice Using Clean Architecture
Consuming Discount Microservice from Basket Microservice
Developing Ordering Microservice using Clean Architecture
Async Communication between Rabbit MQ, Basket and Ordering Microservice
Application Gateway Implementation
What’s Next
Why This Isn’t Just Another “Hello World” Microservices Course
Let’s be real for a second: the internet is drowning in tutorials that show you how to spin up two APIs and call it a “microservices architecture.” As someone who has spent years untangling spaghetti code in monolithic monsters, I’ve learned the hard way that the real challenge isn’t splitting the services—it’s keeping them from becoming a distributed nightmare. That’s why Creating .Net Core Microservices using Clean Architecture caught my eye. It doesn’t just hand you a script; it forces you to think like a Solution Architect.
The core philosophy here is rooted in Clean Architecture. Instead of the typical “database-first” mess, this course pushes the Domain-Driven Design (DDD) mindset. You aren’t just writing code; you’re building a decoupled, testable, and scalable ecosystem. It tackles the “stitching” problem—how to make disparate services talk without creating tight coupling that breaks every time you push a minor update. If you’re tired of “toy projects” and want to see how enterprise-grade applications are actually structured, this is where you start.
Prerequisites for Success
This isn’t a course for someone who just downloaded Visual Studio yesterday. To get the most out of these hands-on labs, you need a solid foundation. Here is what I’d suggest having in your toolkit before hitting play:
Intermediate C# Knowledge: You should be comfortable with LINQ, Asynchronous programming (async/await), and Generics.
Basic .NET Core CLI: While the course uses the IDE, knowing your way around the terminal helps with containerization tasks.
Understanding of REST: You should know your GETs from your POSTs and understand basic HTTP status codes.
Development Environment: A machine capable of running Docker Desktop and multiple instances of microservices simultaneously (aim for 16GB RAM if you don’t want your PC to sound like a jet engine).
The Industry-Standard Tools & Skills You’ll Master
The curriculum is packed with industry-standard tools that are currently non-negotiable in the high-paying tech job market. We aren’t just talking about basic CRUD operations here. You will dive deep into:
MediatR & Mediator Pattern: Essential for keeping your controllers thin and your logic encapsulated.
CQRS (Command Query Responsibility Segregation): Learning how to separate read and write operations to optimize performance—a must-have for senior-level developer roles.
Message Queues (RabbitMQ/Azure Service Bus): Mastering asynchronous communication to ensure your system doesn’t crash when one service goes offline.
Docker & Containerization: Moving beyond “it works on my machine” by packaging your services for the cloud.
Ocelot Application Gateway: Implementing a unified entry point for your client applications, handling routing, and security.
Serilog for Structured Logging: Because in a distributed system, plain text logs are useless when you’re trying to trace a bug across five different services.
Career Benefits & Job Roles
If you are looking for career growth, mastering these patterns is the fastest way to move from a Junior/Mid-level dev to a Senior Backend Engineer or Cloud Architect. Companies are desperate for developers who understand the SDLC of a cloud-native application. This course serves as an excellent certification prep for those eyeing the Microsoft AZ-204 or specialized architecture exams.
By completing the real-world projects included, you’ll have a portfolio piece that demonstrates job-ready skills. You’ll be able to walk into an interview and intelligently discuss distributed tracing, eventual consistency, and microservices orchestration—topics that command six-figure salaries in today’s market.
What I Liked (The Pros)
The “Clean” Focus: I love that the course emphasizes the Onion Architecture. It keeps the business logic pure and independent of frameworks, which is how real-world projects should be built to avoid technical debt.
The Full Stack Perspective: It doesn’t ignore the “boring” but vital parts like structured logging and health checks. These are the things that keep you from getting paged at 3 AM.
Complexity Done Right: It bridges the gap from beginner to advanced by starting with the basics of a single service and gradually layering on the complexity of Message Queues and API Gateways.
The Honest Truth (The Cons)
The Pacing for Newbies: My one gripe? If you aren’t familiar with Dependency Injection or the Repository Pattern, the sections on CQRS might feel like a whirlwind. The instructor assumes you’re there to work, not for a refresher on C# basics. It can be intense, but then again, building enterprise edition applications isn’t supposed to be easy.
Found It Free? Share It Fast!
The post Creating .Net Core Microservices using Clean Architecture appeared first on StudyBullet.com.
