Introduction

Prerequisites, Source Code and Course Slides

Run the Final Application

Project Code Structure

Microservices Architectures, Patterns, Libraries and Best Practices in Course

Microservices Multi-Architectural Patterns (External vs Internal Architectures)

How to Follow the Course (The Course Flow and Way of Learning)

What are Microservices?

What is Microservices Architecture?

Microservices Characteristics

Benefits of Microservices Architecture

Challenges of Microservices Architecture

When to Use Microservices Architecture - Best Practices

When Not to Use Microservices - Anti-Patterns of Microservices

Monolithic vs Microservices Architecture Comparison

The Database-per-Service Pattern - Polyglot Persistence

Decomposition of Ecommerce Microservices: Catalog, Basket, Discount and Ordering

Why .NET?

Cloud-Native Development with .NET 8

.NET loves Containers and Microservices

What is new in .NET 8?

What is new in C# 12? Primary Constructors, Collection Expressions, Inline Arrays

C# Top-level Statements, Global Usings, Pattern Matching

ASP.NET 8 for Microservice Development

Minimal APIs in ASP.NET Core

Create ASP.NET Core Web API for Single Microservice

Clear Project for Single Microservices: Setting Up a Minimal ASP.NET Web API

Todo Service: Create Minimal API with ASP.NET Core for Single Microservice

TEST - Todo Service: Create Minimal API with ASP.NET Core for Single Microservice

Containerize Microservices with Docker Containers, Images, and Registries

Containerize Todo ASP.NET Web API Microservice and Run Docker Profile

Introduction - Catalog.API with Vertical Slice Architecture and CQRS

Create New GitHub Repository for Our Microservice Project

Clone GitHub Repository and Create New Solution with Visual Studio

Create ASP.NET Web API for Catalog.API Microservice

Set Port Numbers for Catalog.API Microservice - Modify Launch Settings

Domain Analysis of Catalog Microservices: Models, UCs, Rest APIs, Databases

Technical Analysis of Catalog Microservices: Architectures, Patterns, Libraries

Vertical Slice Architecture

Vertical Slice versus Clean Architecture

CQRS Design Pattern

Logical and Physical Implementation of CQRS Pattern

CQRS Design Pattern With MediatR Library (Logical CQRS Implementation)

Develop Catalog.API Microservices Creating Domain Entities

Develop Vertical Slice Feature Folder with CQRS and MediatR

Develop Feature Handler Class with CQRS and MediatR

Create Abstraction on MediatR for CQRS - Command and Query Separation

Create Abstraction on MediatR for CQRS - Command and Query Separation - Part 2

Implement CQRS Abstractions ICommand into Vertical Slice Feature Handler Class

Develop Create Product Endpoint with Minimal APIs and Carter

Develop POST Endpoint with Carter Implements ICarterModule for Minimal APIs

Develop POST Endpoint with Carter Implements ICarterModule for Minimal APIs - Part 2

Register MediatR and Carter Libraries into ASP.NET Dependency Injection Service

Test Catalog API - CreateProduct POST Request - Debug Carter Minimal API and MediatR

Introduction - Develop Catalog.API Infrastructure, Handler, and Endpoint Classes

Infrastructure - Data Concerns for Catalog API - Marten .NET Transactional DB

Opening Sessions in Marten as Document DB

Develop CommandHandler to Save Product to DB using Marten Library

Register and Configure Marten DocumentDB Library into Program.cs ASP.NET DI

EShop Microservices Deployment Strategy

Setup PostgreSQL DB Using Docker-compose File for Multi-container Docker Environment

Add PostgreSQL DB Image into Docker-compose File for Multi-container Docker Environment

Run Docker-Compose on Visual Studio to Setup PostgreSQL DB on Docker

Connect Postgres DB from Local Catalog Microservices and Send POST Request

Develop GetProducts Feature in Vertical Slice with CQRS, MediatR in Handler Class

Develop GetProducts GET Endpoint with Minimal APIs and Carter

Test GetProducts Endpoint Connecting to Docker Postgres Container

Create Postman Collection for EShop Microservices

Develop GetProductById Handler with CQRS and MediatR

Develop GetProductById GET Endpoint with Minimal APIs and Carter

Test GetProductById Endpoint Connecting to Docker Postgres Container

Develop GetProductByCategory Handler with CQRS and MediatR

Develop GetProductByCategory GET Endpoint with Minimal APIs and Carter

Test GetProductByCategory Endpoint Connecting to Docker Postgres Container

Develop UpdateProduct Handler with CQRS and MediatR

Develop UpdateProduct PUT Endpoint with Minimal APIs and Carter

Test UpdateProduct Endpoint Connecting to Docker Postgres Container

Develop DeleteProduct Handler with CQRS and MediatR

Develop DeleteProduct DELETE Endpoint with Minimal APIs and Carter

Test DeleteProduct Endpoint Connecting to Docker Postgres Container

Introduction - Develop Catalog.API Cross-Cutting Concerns

MediatR Pipeline Behaviours and Fluent Validation Library

Add Cross-Cutting Concerns into BuildingBlocks Class Library for All Services

Cross-Cutting Concerns: Validate with AbstractValidator using Fluent Validation

Validation Pipeline Behaviour with MediatR using Fluent Validation Library

Remove Manual Validator and Test Validation Pipeline Behaviour with MediatR

Develop CRUD Command Validators with Fluent Validation Pipeline Behaviour

Global Handling Exceptions in ASP.NET Core with app.UseExceptionHandler

BuildingBlocks Handling Exceptions Generic Way with app.UseExceptionHandler

Global Exception Handling with IExceptionHandler Interface in ASP.NET Core

Register Custom Exception Handling into ASP.NET with AddExceptionHandler Method

Logging Behavior in MediatR Pipeline for Cross-Cutting Concerns

Test Logging Behavior for All MediatR Requests on Catalog.API Microservices

Seeding CatalogDb with Marten Initial Baseline Data (IInitialData Interface)

Test Seeding Initial Data with Marten on PostgresDB for Catalog.API Microservice

Develop Pagination for GetProducts Query with ToPagedListAsync Extension Method

Test Pagination for GetProducts Query with ToPagedListAsync Extension Method

Health Check for Catalog Microservices with PostgresDB

Containerize Catalog.API Microservices with Docker

Orchestrate Catalog.API Microservices with Docker-Compose File

TEST - Docker-Compose Catalog.API Microservices with PostgresDB

Introduction - Basket Microservices with Vertical Slice Architecture and CQRS

Create ASP.NET Web API for Basket.API Microservice in Microservices Solution

Set Port Numbers for Basket.API Microservice - Modify Launch Settings

Domain Analysis of Basket Microservices: Models, UCs, REST APIs, Databases

Technical Analysis of Basket Microservices: Architectures, Patterns, Libraries

Develop Basket.API Microservices Creating Domain Entities

Develop Vertical Slice Feature Folder with CQRS and MediatR

Develop GetBasket Feature Handler Class with CQRS and MediatR

Develop Get Basket Endpoint with Minimal APIs and Carter

Develop StoreBasket Feature Handler Class with CQRS and MediatR

Develop Store Basket Endpoint with Minimal APIs and Carter

Develop DeleteBasket Feature Handler Class with CQRS and MediatR

Develop Delete Basket Endpoint with Minimal APIs and Carter

Register MediatR and Carter Libraries into ASP.NET Dependency Injection Service

Test Basket API - GET and POST Basket Request - Debug Carter Minimal API

Infrastructure - Data Concerns for Basket API - Marten .NET Transactional DB

Develop BasketRepository Class using Marten Library

Implement IBasketRepository Class using Marten IDocumentSession Interface

Register and Configure Marten DocumentDB Library into Program.cs ASP.NET DI

Setup PostgreSQL DB for Basket Microservices Using Docker-Compose File

Run Docker-Compose on Visual Studio to Setup PostgreSQL DB on Docker

Develop Basket Features in CQRS Handler Classes Using BasketRepository

Connect PostgreSQL DB from Local Basket Microservices and Send POST Request

TEST Basket Microservices Endpoints Connecting with Marten and PostgreSQL DB

Exception Handling in Basket Microservices

Distributed Caching with Redis in Basket Microservices

Cache-aside Pattern in Microservices / Cache Invalidation

Proxy Pattern, Decorator Pattern, and Scrutor Library

Develop CachedBasketRepository with Proxy Pattern, Decorator Pattern, and Scrutor

Develop CachedBasketRepository with Proxy Pattern, Decorator Pattern, and Scrutor (Part 2)

Register Decorated CachedBasketRepository and StackExchange.Redis with Scrutor

ECommerce Microservices Deployment Strategy

Setup Redis as a Distributed Cache Using Docker-Compose File for Multi-Container

Run Docker-Compose on Visual Studio to Setup Redis Distributed Cache on Docker

Configure Docker-Compose Launch Settings - Not Open Browser for Microservices

Connect Redis Cache from Local Basket Microservices and Send GET Request

Health Check for Basket Microservices with PostgresDB and Redis Cache

Containerize Basket.API Microservices with Docker

Orchestrate Basket.API Microservices with Docker-Compose File

TEST - Docker-Compose Basket. API Microservices with Postgres DB and Redis

Microservices Communication Types: Synchronous or Asynchronous Communication

Microservices Synchronous Communications and Best Practices

gRPC: High-Performance Remote Procedure Calls

How gRPC Works?

gRPC Usage in Microservices Communication

Introduction - Discount.Grpc Microservices for Microservices gRPC Communication

Create ASP.NET gRPC for Discount Microservices in Microservices Solution

Domain Analysis of Discount Microservices: Models, UCs, REST APIs, Databases

Technical Analysis of Discount Microservices: Architectures, Patterns, Libraries

Develop Discount.API Microservices Creating Domain Entities

Develop discount.proto ProtoBuf File for Exposing CRUD Services in Discount gRPC

Generate Proto Service Class from Discount.proto File in Discount gRPC Service

Develop DiscountService Class to Implement gRPC Proto Service Methods

Configure Discount gRPC Service to Request Pipeline in Program.cs and Invoke gRPC

Entity Framework Core and SQLite Database Connection in Discount Microservices

Create SQLite Database Using Entity Framework Core Tools in Discount Service

Seed and Auto-Migrate SQLite Database Using Entity Framework Core in Discount

TEST - Seed and Auto-Migrate SQLite Database Using Entity Framework Core

Develop DiscountService Class to Implement gRPC Proto Service Methods

Develop CreateDiscount in DiscountService Class to Implement CRUD gRPC Proto

Develop UpdateDiscount in DiscountService Class to Implement CRUD gRPC Proto

Develop DeleteDiscount in DiscountService Class to Implement CRUD gRPC Proto

Containerize Discount.Grpc Microservices with Docker

Orchestrate Discount.Grpc Microservices with Docker-Compose File

TEST - Docker-Compose Discount.Grpc Microservices with SQLite

Introduction - Consuming Discount gRPC Service From Basket Microservice

Consuming Discount gRPC Service From Basket Microservice When Adding Cart Item

Consuming Discount gRPC Service From Basket API Microservice When Adding Cart - Part 2

Register Discount gRPC Client and Discount gRPC Service into the Basket.API

Test and Run Discount gRPC and Basket Microservice

Add gRPC DiscountUrl Configuration in Basket.API Image Configuration on Docker

Test on Docker Environment - Basket.API Communicates with Discount.gRPC in Docker

Test on Docker - Basket.API Communicates with Discount.gRPC in Docker - Part 2

Introduction - Ordering Microservices with DDD, CQRS, and Clean Architecture

Create ASP.NET Web API for Ordering.API Microservice in Microservices Solution

Domain Analysis of Ordering Microservices: Models, UCs, REST APIs, Databases

Technical Analysis of Ordering Microservices: Architectures, Patterns, Libraries

SOLID, KISS, YAGNI, SoC, DIP - Common Principles

Apply DDD, CQRS, and Clean Architecture Patterns in Ordering Microservice

Domain Driven Design - DDD

Clean Architecture

Clean Architecture with Domain Driven Design (DDD)

Code Structure on DDD and Clean Architecture Layers in Ordering Microservices

Create Clean Architecture Layers: Domain, Application, Infrastructure, and API

Adding Project References Between Clean Architecture Layers

Adding Dependency Injections Between Clean Architecture Layers

Tactical Domain-Driven Design: Entities, Value Objects, Aggregates, Aggregate Roots

Develop DDD Abstractions (Entity, Aggregate, DomainEvent) in Ordering.Domain

Domain Modeling with Tactical DDD for Ordering Microservices

Develop Domain Modeling with DDD for Ordering Microservices

Primitive Obsession and Strongly Typed IDs in DDD

Develop Strongly Typed IDs for Order Entities

Anemic-Domain vs Rich-Domain Model Entities in DDD

Develop DDD Rich-Domain Model Entity for Order Entities in Ordering.Domain Layer

Develop ValueObjects (Address, Payment) in DDD Rich-Domain Model Entity

Develop DDD Rich-Domain Model for Order Entities in Ordering.Domain Layer

Domain Events in DDD and Domain vs Integration Events

Develop Order Created and Updated Domain Events in Ordering Microservices

Develop Ordering.Infrastructure Layer with EF Core Code First Approach

EF Core 8 Features, Code First Approach, Migrations, and SQL Server Connection

Steps of EF Core Developments for Ordering.Infrastructure

Install EF Core NuGet Packages in Ordering.Infrastructure

Develop EF Core DbContext Object for Storing Entities in Ordering.Infrastructure

Mapping DDD Objects to EF Entities - Develop EF Core Entity Configurations

EF Core 8 Relations and DDD ValueObject Mapping with ComplexType and ComplexProp

Mapping DDD Objects to EF Entities - Develop Order Entity Configurations

EF Core SQL Server Connection String in appsettings.json File

Register EF Core DbContext in ASP.NET Dependency Injection Tool for SQL Server

Create EF Core Migrations for ApplicationDbContext in Ordering.Infrastructure

Create EF Core Migrations for ApplicationDbContext in Ordering.Infrastructure - Part 2

Setup SQL Server DB Using Docker-Compose File for Multi-Container Docker Environment

Run Docker-Compose on Visual Studio to Setup SQL Server DB on Docker

Apply EF Core Migrations to SQL Server DB with Update-Database Command

Auto Migrate EF Core Entities to SQL Server When Application Starts

Seed SQL Server OrderDb Using EF Core When Application Starts

Seed Products and Orders in SQL Server OrderDb Using EF Core When App Starts

Run Ordering Microservices to Migrate and Seed OrderDb in SQL Server Using EF Core

EF Core Interceptors: SaveChangesInterceptor for Auditing Entities

Develop SaveChangesInterceptor to Audit Entities for Order Entities

Run & Test Ordering Microservices for Audit with EF SaveChangesInterceptor

Dispatch Domain Events with EF Core SaveChangesInterceptor

Develop DispatchDomainEventsInterceptor to Trigger Domain Event Handlers

Run & Test Ordering Microservices for Dispatching Domain Events with EF SaveChangesInterceptor

Develop Ordering.Application Layer with CQRS and MediatR to Implement Commands

CQRS (Command Query Responsibility Segregation) Pattern in Ordering Microservice

Event Sourcing Pattern

CQRS with Event Sourcing Pattern

Eventual Consistency Principle

Analysis of Ordering Microservice Application Layer

Implement CQRS Command and Command Handler Patterns with MediatR

Develop Ordering.Application Folder Structure for CQRS

Develop DTO Classes for Orders in Ordering.Application Layer

Develop Orders CreateOrderCommand and Handler in Ordering.Application Layer

Develop IApplicationDbContext for Injecting EF Core DbContext Object

Develop Orders CreateOrderCommandHandler Using IApplicationDbContext

Develop Orders UpdateOrderCommand and Handler Using IApplicationDbContext

Develop Orders DeleteOrderCommand and Handler Using IApplicationDbContext

Develop MediatR Pipeline Behaviours (Validation, Logging) in Ordering.Application

Develop Domain Event Handlers with MediatR INotificationHandler in Ordering.Application

Develop Order Queries with CQRS and MediatR in Ordering.Application Layer

Develop Extension Method for ProjectToOrderDto for GetOrders Methods

Develop GetOrdersByCustomer Queries with CQRS and MediatR

Develop Pagination Class for Query GetOrders Using CQRS and MediatR

Develop GetOrders Query Applying Pagination Using CQRS and MediatR

Develop GetOrders Query Apply Pagination Using CQRS and MediatR in Ordering.Application

Develop Ordering.API Layer with Exposing Minimal REST APIs with Carter

Analyze the Ordering.API Layer in Clean Architecture

Program.cs and Dependency Injection Class in Ordering.API Layer

Develop Order Endpoints for REST APIs in Ordering.API Layer

Develop CreateOrder Endpoint for REST APIs in Ordering.API Layer

Develop UpdateOrder Endpoint for REST APIs in Ordering.API Layer

Develop DeleteOrder Endpoint for REST APIs in Ordering.API Layer

Develop GetOrdersByName Endpoint for REST APIs in Ordering.API Layer

Develop GetOrdersByCustomer Endpoint for REST APIs in Ordering.API Layer

Develop GetOrders Endpoint with Pagination for REST APIs in Ordering.API Layer

Testing Ordering.API Endpoints with CQRS and Clean Architecture Layers

Test Create Order Endpoint with CQRS and Clean Architecture Layers in Ordering

Test Update Order Endpoint with CQRS and Clean Architecture Layers in Ordering

Test Get Order Endpoints with CQRS and Clean Architecture Layers in Ordering

Test Delete Order Endpoint with CQRS and Clean Architecture Layers in Ordering

Cross-Cutting Concerns Custom Exception Handler in Ordering Microservice

Health Checks for Ordering Microservices with EF Core and SQL Server

Introduction - Microservices Async Communication with RabbitMQ & MassTransit

Microservices Asynchronous Communication

Benefits of Asynchronous Communication

Challenges of Asynchronous Communication

Fan-Out Publish/Subscribe Messaging Pattern

Event-Driven Microservices Architecture

What is RabbitMQ and Main Components of RabbitMQ (Producer, Queue, Consumer)

RabbitMQ Exchange Types: Direct, Fanout, Topic, and Headers

Domain Analysis of Async Communication Between Basket and Ordering Microservices

Technical Analysis of Async Communication Between Basket and Ordering Microservices

Steps of Developing Async Communication Between Basket and Ordering Microservices

Create BuildingBlocks.Messaging Shared Class Library for Common Async Connection

Develop BasketCheckout Event in BuildingBlocks.Messaging Shared Class Library

Develop MassTransit Extension Methods to Register RabbitMQ Connection into DI

Develop MassTransit Extension Methods to Register RabbitMQ Connection into DI - Part 2

Publish BasketCheckout Event from Basket Microservices

Develop BasketCheckout Feature Folder to Expose POST Endpoint and Publish Event

Develop Basket Checkout Handler Method to Publish Event to RabbitMQ-MassTransit

Dual-Write Problem and Outbox Pattern

Ordering Microservices to Subscribe/Consume BasketCheckout Event from RabbitMQ

Register MassTransit RabbitMQ Packages into Ordering.Application DI

OrderCreated Integration Event: How Domain Event Leads to Integration Event

Develop Basket Checkout Event Consumer Integration Event Handler Class

Develop Basket Checkout Event Consumer Integration Event Handler Class - Part 2

Saga Pattern for Distributed Transactions

Publish OrderCreated Integration Event for Order Fulfillment Microservices

ASP.NET Feature Management - Develop Feature Flag for OrderCreated Event

Setup RabbitMQ for Async Communication Using Docker-Compose File

Run Docker-Compose on Visual Studio to Setup RabbitMQ on Docker

TEST - Publish BasketCheckout Event in Basket.API Microservices

TEST - Subscribe/Consume BasketCheckout Event in Ordering.API Microservices

TEST - Set OrderFulfillment Feature = False. Re-Test Publish - Subscribe/Consume

Containerize and Configure Basket, Ordering, and RabbitMQ Containers

Containerize and Orchestrate Ordering Microservices with Docker & Docker-Compose

TEST - Docker-Compose Microservices - Publish/Subscribe BasketCheckout Event

Introduction - API Gateways with YARP Reverse Proxy

Gateway Routing Pattern

API Gateway Pattern

Main Features in the API Gateway Pattern

BFF (Backend for Frontend) Pattern

YARP Reverse Proxy for API Gateway

YARP Architecture with Pipeline and Extensibility

Domain Analysis of YarpApiGateway Microservices: Models, Use Cases, REST APIs, Database

Technical Analysis of YarpApiGateway Microservices: Architectures, Patterns

Create YarpApiGateway Microservices into eCommerce Solution

Develop YARP Reverse Proxy in YarpApiGateway Microservices

Implement API Gateway Using YARP Reverse Proxy in YarpApiGateway Microservices

Implement API Gateway Using YARP Reverse Proxy in YarpApiGateway Microservices - Part 2

TEST - YARP Reverse Proxy as an API Gateway in YarpApiGateway Microservices

Rate Limiting to YARP Reverse Proxy as an API Gateway in YarpApiGateway

Move Local Test Configuration to Local appsettings.json File - YARP Reverse Proxy

Develop YARP appsettings.json File Configurations for Docker Host Network

Containerize and Orchestrate YarpApiGateway Microservices for Reverse Proxy

TEST on Docker-Compose - YARP Reverse Proxy as an API Gateway in YarpApiGateway

Introduction - Shopping Web Client Application with Refit HttpClientFactory

Background of Project

Domain Analysis of Shopping.Web Microservices

Technical Analysis of Shopping.Web Microservices

Developing Shopping Web Application Microservices

Create Catalog Models for Shopping Web Application Microservices Consume YarpApi

Create Basket Models for Shopping Web Application Microservices Consume YarpApi

Create Ordering Models for Shopping Web Application Microservices Consume YarpApi

Develop Service Classes for Consume YarpApiGateway

Refit HttpClientFactory Library: The Automatic Type-Safe REST Library

Install and Configure Refit HttpClientFactory Library in Shopping.Web Microservices

Develop ICatalogService Classes with Refit HttpClientFactory Library

Develop IBasketService Classes with Refit HttpClientFactory Library

Develop IOrderingService Classes with Refit HttpClientFactory Library

Build Presentation Layer: ASP.NET Web Application Razor Pages with AspNetRunBasics

Develop Index HTML Pages and CS Files with Shared Partial Product Pages

Develop Index C# Page to Consume YarpApiGateway Endpoints with ICatalogService

AddToCart Submit Handle in Index CSHTML Page with IBasketService

Develop Cart Razor Page in Shopping.Web Application

Develop Cart C# Page and Consume YarpApiGateway Endpoints with IBasketService

Develop ProductList Razor Page in Shopping.Web Application

Develop ProductList C# Page and Consume YarpApiGateway Endpoint with IBasketService

Develop ProductDetail Razor Page in Shopping.Web Application

Develop ProductDetail C# Page and Consume YarpApiGateway Endpoints

Develop Checkout and Confirmation Razor Page in Shopping.Web Application

Develop Checkout and Confirmation C# Page and Consume YarpApiGateway Endpoints

Develop OrderList and Contact Razor Page in Shopping.Web Application

Develop OrderList C# Page and Consume YarpApiGateway Endpoints with IBasketService

TEST - Shopping.Web Client Application Using YarpApiGateway Microservices

Containerize and Orchestrate Shopping.Web Application in Docker-Compose

TEST on Docker-Compose - Shopping.Web Application Consumes YarpApiGateway

Thanks

.NET 8 Microservices - DDD, CQRS, Vertical/Clean Architecture: Master Microservices Architecture with .NET 8 and Modern Patterns

What do you get with a video?

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with a video?

Product Details

Table of Contents

Recommendations for you

About the author

FAQs

.NET 8 Microservices - DDD, CQRS, Vertical/Clean Architecture: Master Microservices Architecture with .NET 8 and Modern Patterns

What do you get with a video?

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with a video?

Product Details

Packt Subscriptions

Table of Contents

Recommendations for you

About the author

FAQs