.NET 8 Microservices: DDD, CQRS, Vertical/Clean Architecture from Udemy

This course comes from a live github aspnetrun microservices repository which verified from community with 2300+ stars and 1300+ forks.

You will learn how to build Microservices on .Net platforms which used Asp.Net Web API, Docker, RabbitMQ, MassTransit, Grpc, Yarp API Gateway, PostgreSQL, Redis, SQLite, SqlServer, Marten, Entity Framework Core, CQRS, MediatR, DDD, Vertical and Clean Architecture implementation using latest codes and best practices of .NET 8 on cloud-native environments.

You will develop e-commerce modules over Product, Basket, Discount and Ordering microservices with NoSQL (PostgreSQL DocumentDB, Redis) and Relational databases (SQLite, Sql Server) with communicating over RabbitMQ Event Driven Communication and using Yarp API Gateway. You can find Microservices Architecture and Step by Step Implementation on .NET which step by step developing this course with extensive explanations and details.

Along with this you’ll develop following microservices and items:

Catalog microservice which includes;

ASP.NET Core Minimal APIs and latest features of .NET 8 and C# 12
Vertical Slice Architecture implementation with Feature folders
CQRS implementation using MediatR library
CQRS Validation Pipeline Behaviours with MediatR and FluentValidation
Marten library for .NET Transactional Document DB on PostgreSQL
Carter library for Minimal API endpoint definition
Cross-cutting concerns Logging, global Exception Handling and Health Checks
Dockerfile and docker-compose file for running Multi-container in Docker environment

Basket microservice which includes;

ASP.NET 8 Web API application, FollowingNET gRPC Server application
Build a Highly Performant inter-service gRPC Communication with Basket Microservice
Exposing gRPC Services with creating Protobuf messages
Entity Framework Core ORM - SQLite Data Provider and Migrations
SQLite database connection and containerization

Microservices Communication

Sync inter-service gRPC Communication
Async Microservices Communication with RabbitMQ Message-Broker Service
Using RabbitMQ Publish/Subscribe Topic Exchange Model
Using MassTransit for abstraction over RabbitMQ Message-Broker system
Publishing BasketCheckout event queue from Basket microservices and Subscribing this event from Ordering microservices
Create RabbitMQ EventBus.Messages library and add references Microservices

Ordering Microservice

Implementing NET Core Web Application with Bootstrap 4 and Razor template
Consume YarpApiGateway APIs using Refit Library with Generated HttpClientFactory
ASPNET Core Razor Tools — View Components, partial Views, Tag Helpers, Model Bindings and Validations, Razor Sections etc.

Docker Compose establishment with all microservices on docker;

Containerization of microservices
Orchestrating of microservices and backing services (databases, distributed caches, message brokers..)
Override Environment variables

On top of all these, you'll learn how to write quality code, not just how to build microservices. In this course you will see the demonstrating a layered application architecture with DDD best practices. Implements NLayer Hexagonal architecture (Core, Application, Infrastructure and Presentation Layers) and Domain Driven Design (Entities, Repositories, Domain/Application Services, DTO's...) and aimed to be a Clean Architecture, with applying SOLID principles in order to use for a project template. Also implements best practices like loosely-coupled, dependency-inverted architecture and using design patterns such as Dependency Injection, logging, validation, exception handling and so on.

Is this course for you?

This course is very practical, about 95%+ of the lessons will involve you coding along with me on this project. If you are the type of person who gets the most out of learning by doing, then this course is definitely for you.

Tools you need for this course

In this course all the lessons are demonstrated using Visual Studio as a code editor. You can of course use any code editor you like and any Operating system you like as long as it's Windows or Mac. Also using Docker Desktop in order to use different database providers.

What's inside

Learning objectives

Aspnet core 8 web api development of microservices
Aspnet minimal apis and latest features of .net8 and c# 12
Vertical slice architecture implementation with feature folders
Cqrs implementation using mediatr library
Cqrs validation pipeline behaviours with mediatr and fluentvalidation
Marten library for .net transactional document db on postgresql
Carter library for minimal api endpoint definition
Using redis as a distributed cache over basketdb
Implements proxy, decorator and cache-aside design patterns
Build a highly performant inter-service grpc communication with basket microservice
Consume discount grpc service for inter-service sync communication to calculate product final price
Publish basketcheckout queue with using masstransit and rabbitmq
Postgresql database connection and containerization
Implementing ddd, cqrs, and clean architecture with using best practices
Tactical domain-driven design: entities, value objects, aggregates, agg. roots
Developing cqrs with using mediatr, fluentvalidation and mapster packages

Using entity framework core orm and auto migrate to sqlserver when application startup
Entity framework core code-first approach, migrations, ddd entity configurations in clean architecture implementation
Async microservices communication with rabbitmq message-broker service
Using rabbitmq publish/subscribe topic exchange model
Consuming rabbitmq basketcheckout event queue with using masstransit-rabbitmq configuration
Using masstransit for abstraction over rabbitmq message-broker system
Api gateways with yarp reverse proxy applying gateway routing pattern
Yarp reverse proxy configuration; route, cluster, path, transform, destinations
Rate limiting with fixedwindowlimiter on yarp reverse proxy configuration
Aspnet core web application with bootstrap 4 and razor template
Consume yarpapigateway apis using refit library with generated httpclientfactory
Cross-cutting concerns logging, global exception handling and health checks
Dockerfile and docker-compose file for running multi-container docker environment
Show more
Show less

Aspnet core 8 web api development of microservices
Aspnet minimal apis and latest features of .net8 and c# 12
Vertical slice architecture implementation with feature folders
Cqrs implementation using mediatr library
Cqrs validation pipeline behaviours with mediatr and fluentvalidation
Marten library for .net transactional document db on postgresql
Carter library for minimal api endpoint definition
Using redis as a distributed cache over basketdb
Implements proxy, decorator and cache-aside design patterns
Build a highly performant inter-service grpc communication with basket microservice
Consume discount grpc service for inter-service sync communication to calculate product final price
Publish basketcheckout queue with using masstransit and rabbitmq
Postgresql database connection and containerization
Implementing ddd, cqrs, and clean architecture with using best practices
Tactical domain-driven design: entities, value objects, aggregates, agg. roots
Developing cqrs with using mediatr, fluentvalidation and mapster packages
Using entity framework core orm and auto migrate to sqlserver when application startup
Entity framework core code-first approach, migrations, ddd entity configurations in clean architecture implementation
Async microservices communication with rabbitmq message-broker service
Using rabbitmq publish/subscribe topic exchange model
Consuming rabbitmq basketcheckout event queue with using masstransit-rabbitmq configuration
Using masstransit for abstraction over rabbitmq message-broker system
Api gateways with yarp reverse proxy applying gateway routing pattern
Yarp reverse proxy configuration; route, cluster, path, transform, destinations
Rate limiting with fixedwindowlimiter on yarp reverse proxy configuration
Aspnet core web application with bootstrap 4 and razor template
Consume yarpapigateway apis using refit library with generated httpclientfactory
Cross-cutting concerns logging, global exception handling and health checks
Dockerfile and docker-compose file for running multi-container docker environment
Show more
Show less

Syllabus

What are Microservices ?

Course Introduction

Introduction

Prerequisites, Source Code and Course Slides

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Covers a wide range of technologies, including ASP.NET Web API, Docker, RabbitMQ, and gRPC, which are essential for building modern microservices architectures

Demonstrates a layered application architecture with DDD best practices, which promotes maintainability and scalability in complex systems

Employs patterns such as CQRS, MediatR, and Clean Architecture, which are valuable for designing robust and testable microservices

Requires Visual Studio and Docker Desktop, which may require learners to acquire software and set up their local environments

Focuses on .NET 8 and C# 12, so learners should be prepared to work with the latest versions of these technologies

Emphasizes hands-on coding, which may not suit learners who prefer a more theoretical approach to learning

Reviews summary

.net 8 microservices with ddd/cqrs

According to learners, this course on .NET 8 Microservices: DDD, CQRS, Vertical/Clean Architecture is a highly practical and comprehensive guide to building modern, robust systems. Students found the coverage of topics like DDD, CQRS, Clean Architecture, and Vertical Slice to be particularly strong and well-implemented. The course provides valuable hands-on experience, focusing on building a realistic e-commerce project using a wide array of technologies including Docker, RabbitMQ, gRPC, and YARP. While the course covers a lot of ground at a potentially fast pace, requiring some prior foundational knowledge, reviewers generally agree it's an excellent resource for developers looking to master these complex architectural patterns and produce clean, quality code. The accompanying GitHub repository is also seen as a significant benefit.

Associated code repository is valuable.

"The GitHub repo is a big plus and a great reference."

"This course comes from a live github aspnetrun microservices repository."

"Having access to the complete, verified code is extremely helpful."

Project code is clean and well-structured.

"The project structure is clean and easy to follow."

"You'll learn how to write quality code, not just how to build microservices."

"Implements best practices like loosely-coupled, dependency-inverted architecture."

Learn by building a realistic project.

"This course is very practical, about 95%+ of the lessons will involve you coding along with me on this project."

"The hands-on coding and projects are the strongest part of the course for me."

"If you are the type of person who gets the most out of learning by doing, then this course is definitely for you."

Solid examples of Clean, DDD, CQRS, VSA.

"The DDD, CQRS and Clean Architecture implementation is great."

"The use of Vertical Slice Architecture and MediatR is explained very well."

"It demonstrates a layered application architecture with DDD best practices... aimed to be a Clean Architecture."

Covers a wide array of modern technologies.

"Covers a lot of ground - microservices, DDD, CQRS, Docker, gRPC, RabbitMQ."

"Deep dive into DDD, CQRS with practical examples in .NET 8."

"Teaches how to implement DDD, CQRS, and Clean Architecture using best practices."

"The amount of topics covered is extensive and relevant for modern development."

May require prior knowledge or faster pace.

"Assumes a lot of prior knowledge about .NET and related concepts."

"Sometimes the pace was a bit fast, especially when introducing new libraries."

"Debugging issues when coding along can be challenging if you're not familiar with the tools."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in .NET 8 Microservices: DDD, CQRS, Vertical/Clean Architecture with these activities:

Review SOLID Principles

Show steps

Reinforce your understanding of SOLID principles, which are fundamental to the clean architecture and DDD concepts used throughout the course.

Browse courses on SOLID Principles

Show steps

Read articles and blog posts about SOLID principles.
Watch videos explaining each principle with examples.
Try to identify SOLID principles in existing codebases.

Review 'Domain-Driven Design: Tackling Complexity in the Heart of Software'

Show steps

Gain a deeper understanding of Domain-Driven Design (DDD) principles, which are heavily utilized in the course's microservices architecture.

View Domain-Driven Design Reference: Definitions and... on Amazon

Show steps

Read the core chapters on tactical DDD.
Identify DDD patterns in the course's example code.
Reflect on how DDD helps manage complexity in microservices.

Build a Simple CRUD API with .NET 8 Minimal APIs

Show steps

Practice building a basic CRUD (Create, Read, Update, Delete) API using .NET 8 Minimal APIs to solidify your understanding of the framework and its features.

Show steps

Set up a new .NET 8 Web API project.
Define data models and endpoints for CRUD operations.
Implement data persistence using an in-memory database.
Test the API endpoints using Postman or a similar tool.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Review 'Building Microservices: Designing Fine-Grained Systems'

Show steps

Expand your knowledge of microservices architecture and design principles by reading a comprehensive guide on the topic.

View Building Microservices: Designing Fine-Grained... on Amazon

Show steps

Read chapters on service decomposition and communication.
Study the examples of different microservices patterns.
Consider how the book's recommendations apply to the course project.

Write a Blog Post on CQRS Implementation

Show steps

Solidify your understanding of CQRS (Command Query Responsibility Segregation) by explaining its implementation in a blog post, focusing on the MediatR library.

Show steps

Research and understand the CQRS pattern.
Explain how MediatR simplifies CQRS implementation.
Provide code examples demonstrating CQRS with MediatR.
Publish the blog post on a platform like Medium or Dev.to.

Implement Eventual Consistency with RabbitMQ

Show steps

Practice implementing eventual consistency between microservices using RabbitMQ to reinforce your understanding of asynchronous communication.

Show steps

Set up a RabbitMQ server using Docker.
Create two microservices that communicate via RabbitMQ.
Implement a scenario where data is eventually consistent.
Monitor and troubleshoot the message queue.

Create a Docker Compose File for the Course Project

Show steps

Develop a Docker Compose file to orchestrate the microservices in the course project, gaining practical experience with containerization and deployment.

Show steps

Identify all the microservices and dependencies in the project.
Define the Docker images and configurations for each service.
Create a Docker Compose file to define the multi-container application.
Test the Docker Compose file to ensure all services start correctly.

Career center

Learners who complete .NET 8 Microservices: DDD, CQRS, Vertical/Clean Architecture will develop knowledge and skills that may be useful to these careers:

API Developer

API Developers specialize in designing, building, and managing Application Programming Interfaces (APIs). This course helps API Developers learn how to construct robust and scalable APIs using ASP.NET Web API and other modern technologies. The course explores the development of microservices-based APIs, focusing on architectural patterns like CQRS, DDD, and clean architecture, and provides hands-on experience in developing e-commerce modules using microservices. API Developers will particularly benefit from the course's coverage of gRPC, YARP API Gateway, and other tools for building and managing APIs.

See salaries and explore the career path for API Developer

Microservices Architect

A microservices architect is responsible for designing and implementing microservices-based applications. This course may be useful for aspiring Microservices Architects because it explores the development of microservices on .NET platforms, using ASP.NET Web API, Docker, RabbitMQ, gRPC, and more. It delves into architectural patterns like CQRS, DDD, and clean architecture. The course also covers practical implementation of e-commerce microservices and addresses inter-service communication, database management, and containerization, all essential aspects of the microservices architect role.

See salaries and explore the career path for Microservices Architect

Software Engineer

Software Engineers design, develop, and test software applications. This course helps Software Engineers build skills in .NET 8, ASP.NET Web API, Docker, and other technologies crucial for modern software development. The course provides practical experience in developing e-commerce modules using microservices architecture and explores important concepts like CQRS, DDD, and clean architecture. By following along with the course's hands-on projects, a Software Engineer can gain valuable experience in building and deploying microservices-based applications, making them more effective in their role.

See salaries and explore the career path for Software Engineer

Backend Developer

Backend Developers focus on the server-side logic and databases that power applications. This course may be useful for Backend Developers looking to expand their skills in microservices architecture and .NET development. The course provides in-depth coverage of ASP.NET Web API, Docker, RabbitMQ, gRPC, and other technologies essential for building modern backend systems. Through hands-on projects, Backend Developers can master microservices development using CQRS, DDD, and clean architecture, and learn how to manage databases and inter-service communication effectively.

See salaries and explore the career path for Backend Developer

Full-Stack Developer

Full Stack Developers work on both the front-end and back-end aspects of web applications. Learning microservices with .NET 8 is useful for Full Stack Developers wishing to broaden their expertise. This course covers topics such as ASP.NET Web API, Docker, RabbitMQ, CQRS, DDD, and clean architecture. By adopting these skills, the full stack developer will find that they are more competent in the full scope of app development from client to server.

See salaries and explore the career path for Full-Stack Developer

Application Developer

Application Developers create and maintain software applications for various platforms. This .NET 8 microservices course helps Application Developers learn how to construct microservices using ASP.NET Web API, Docker, RabbitMQ, and other modern technologies. The course covers architectural patterns like CQRS, DDD, and clean architecture, and provides hands-on experience in developing e-commerce modules using microservices. Application Developers will find the focus on practical implementation and the use of the latest .NET 8 features particularly valuable for designing and building robust and scalable applications.

See salaries and explore the career path for Application Developer

Cloud Engineer

Cloud Engineers are responsible for designing, implementing, and managing cloud-based infrastructure and applications. This course may be very useful for Cloud Engineers who want to deepen their understanding of .NET microservices on cloud-native environments. The course covers ASP.NET Web API, Docker, RabbitMQ, and gRPC, which are vital for building and deploying applications in the cloud. Cloud Engineers can particularly benefit from the practical experience in containerization, orchestration, and database management within a microservices architecture.

See salaries and explore the career path for Cloud Engineer

DevOps Engineer

DevOps Engineers automate and streamline the software development and deployment process. This course helps DevOps Engineers understand how to build, deploy, and manage microservices-based applications using .NET 8 and related technologies. The course covers ASP.NET Web API, Docker, RabbitMQ, gRPC, and more, and provides practical experience in containerization, orchestration, and continuous integration/continuous deployment (CI/CD) for microservices. DevOps Engineers will find the course's emphasis on automation and infrastructure-as-code valuable for improving their DevOps practices.

See salaries and explore the career path for DevOps Engineer

Technical Lead

Technical Leads guide and mentor development teams, providing technical expertise and direction. This course helps Technical Leads build a strong understanding of microservices architecture and its implementation using .NET 8. The course covers ASP.NET Web API, Docker, RabbitMQ, gRPC, and more, and provides practical experience in developing e-commerce modules using microservices. Technical Leads will find the course's emphasis on best practices, coding standards, and architectural principles valuable for leading their teams effectively.

See salaries and explore the career path for Technical Lead

Solutions Architect

Solutions Architects design and oversee the implementation of complex software systems. This course may be helpful for Solutions Architects because it provides a comprehensive understanding of microservices architecture and its implementation using .NET 8. The course explores architectural patterns like CQRS, DDD, and clean architecture, and covers practical aspects such as database management, inter-service communication, and containerization. Solutions Architects will find the broad coverage of technologies and architectural principles valuable for designing robust and scalable solutions.

See salaries and explore the career path for Solutions Architect

Enterprise Architect

Enterprise Architects align IT strategy with business goals, designing enterprise-level systems and architectures. This course may be useful for Enterprise Architects to broaden their understanding of microservices architecture and its implementation using .NET 8. The course covers core concepts such as ASP.NET Web API, Docker, RabbitMQ, and gRPC. It also explores DDD and clean architecture, and addresses inter-service communication, database management, and containerization. The knowledge gained will help in designing scalable and maintainable enterprise systems.

See salaries and explore the career path for Enterprise Architect

Software Consultant

Software Consultants advise organizations on software development strategies and technologies. This course may be useful for Software Consultants who need to understand microservices architecture with .NET 8. It will provide insight into concepts such as ASP.NET Web API, Docker, RabbitMQ, and gRPC. By exploring DDD, CQRS, and clean architecture the consultant will be able to better advise clients about the intricacies of inter-service communication, database management, and containerization. All this ensures a consultant is well-informed with strategies.

See salaries and explore the career path for Software Consultant

Technical Project Manager

Technical Project Managers oversee software development projects, ensuring they are completed on time and within budget. This course may be good to take for Technical Project Managers to give them a better understanding of .NET 8 microservices. The course covers ASP.NET Web API, Docker, RabbitMQ, and gRPC, and is a primer for microservice implementation including CQRS, DDD, and clean architecture. A project manager who has completed this course will be better positioned to oversee their project.

See salaries and explore the career path for Technical Project Manager

Data Engineer

Data Engineers design, build, and maintain data pipelines and infrastructure. While this course primarily focuses on microservices architecture, some concepts may be helpful for Data Engineers. The course covers the use of databases like PostgreSQL, Redis, SQLite, and SQL Server in a microservices context. Experiencing the practical implementation of integrating these databases with .NET 8 microservices may provide valuable insight into data management and integration strategies for data-intensive applications.

See salaries and explore the career path for Data Engineer

Database Administrator

Database Administrators (DBAs) oversee the performance, integrity, and security of databases. While this course primarily focuses on microservices architecture, some aspects may be useful for DBAs. The course covers the use of databases like PostgreSQL, Redis, SQLite, and SQL Server in a microservices context. DBAs stand to benefit from experience in the practical implementation of integrating these databases with .NET 8 microservices, possibly leading to more effective database management strategies.

See salaries and explore the career path for Database Administrator

.NET 8 Microservices

DDD, CQRS, Vertical/Clean Architecture

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

.net 8 microservices with ddd/cqrs

Activities

Career center

Reading list

Share

Similar courses