1. Introduction FREE CHAPTER

• Introduction
• Prerequisites, Source Code and Course Slides
• Run the Final Application
• Project Code Structure
• Modular Monoliths Architectures, Patterns, Libraries and Best Practices
• How to Follow the Course (The Course Flow and Way of Learning)

2. Monolithic Architecture - What's wrong with Traditional Monoliths?

• What is Traditional Monoliths (Monolithic Architecture)?
• What's wrong with Traditional Monolithic Architecture?
• Technology Lock-In and Fear Cycle in Traditional Monolithic Architecture
• Big Ball of Mud

3. Microservices Architectures - Why it is not fit for all projects?

• What are Microservices and Microservices Architecture?
• What's wrong with Microservices Architecture?
• Microservices Antipattern: The Distributed Monolith
• Amazon Case: Rearchitecting from a Distributed Microservices to a Monolith

4. The Bridge: Modular Monolith Architectures - Gateway between Monolithic and MS

• What is Modular Monolithic (Modulith) Architecture?
• Why Modular Monoliths? Advantages over Microservices?
• Monolith First Approaches from Martin Fowler and Sam Newman
• Starting Point for Microservices: Gradually Transition with Incremental Refactor
• Shopify Modular Monolithic Architecture
• Decomposition of EShop Modules: Catalog, Basket, Identity, and Ordering Modules

5. Create EShop Modular Monolith Project Solution Structure

• Introduction - Create EShop Modular Monolith Project Solution Structure
• Create GitHub Repository for EShop Modular Monolithic Architecture
• Create New Blank Solution: eshop-modular-monoliths
• Modular Monolith Folder Structure: Bootstrapper, Modules, Shared
• Create Bootstrapper Api Project
• Configure Empty Web Project to Bootstrapper Api of Modular Monolith
• Create Modules Folders according to DDD Bounded Context Analysis
• External vs Internal Architecture of Modular Monoliths Architecture
• Vertical Slice Architecture
• Clean Architecture
• Vertical Slice versus Clean Architecture
• Create Module Projects as a Class Library
• Shared Kernel Pattern in DDD
• Create Shared Kernel Class Library Project for All Modules
• Shared Project Dependencies to Modules Projects
• Module Dependencies to Bootstrapper Asp.Net Api Project

6. Wire-up Dependencies Between Modules (DI Management of Modules)

• Introduction - Wire-up Dependencies Between Modules (DI Management of Modules)
• Asp.net Dependency Injection Management and Program.cs
• Wiring up dependencies between modules
• Develop AddCatalogModule extension method in CatalogModule.cs
• Registering Catalog Dependencies into Program.cs
• Develop AddBasketModule, AddOrderingModule extension methods
• Registering Basket and Ordering Dependencies into Program.cs
• Asp.net Middlewares and HTTP Request Pipeline
• Configure HTTP Request Pipelines for Modules in Program.cs
• Examine WebApplication Class Use Abstractions and Install Required Packages
• Develop UseCatalogModule extension method for Module Configure the HTTP request
• Integrating UseCatalogModule in Program.cs
• Develop UseBasketModule and UseOrderingModule extension method for Module Config
• Integrating UseBasketModule and UseOrderingModule extension method in Program.cs
• Add GlobalUsings.cs for Each Project to Avoid Redundant Using Statements

7. First Module: Catalog Module with Vertical Slice Architecture and CQRS

• Introduction - First Module: Catalog Module with Vertical Slice Architecture
• Domain Analysis of Catalog Module: Models, UCs, Rest APIs, Databases
• Technical Analysis of Catalog Module: Architectures, Patterns, Libraries, Folder
• Way of Development: Shared -> Modules -> API

8. Develop Shared Domain for Tactical DDD Abstraction (Entity, Aggregate, Events)

• Introduction - Develop Shared Domain for Tactical DDD Abstraction
• Domain Driven Design - DDD
• Tactical Domain-Driven Design: Entities, Value Objects, Aggregates, A. Roots
• Develop DDD Abstractions (Entity, Aggregate, DomainEvent) in Shared Library
• Develop IDomainEvent interface in Tactical DDD Abstraction using MediatR
• Develop Aggregate classes in Tactical DDD Abstraction

9. Develop Catalog Domain with Product Domain Entity Models

• Introduction - Develop Catalog Domain with Product Domain Entity Models
• Develop Product Domain Entity Models in Catalog Module Domain Models
• Anemic-domain vs Rich-domain Model Entities in DDD
• Develop DDD Rich-domain model Entity for Product Entity
• Domain Events in DDD and Domain vs Integration Events
• Develop Product Created and Updated Domain Event in Catalog Module
• Raise ProductCreated and ProductPriceChanged Domain Event in Catalog Module

10. Data Management of Modular Monolith: Setup Postgres as a Main Database

• Introduction - Data Management of Modular Monolith: Setup Postgres DB
• Data Management of Modular Monoliths: 4 Data Isolation Strategies
• Best Practice: DB Schema separation of Modules in Modular Monoliths apps
• Multi-context EF DB Context object for DB Separate Schema for Data Isolation
• Backing Services for Cloud-Native Architectures
• EShop Modular Monolith Deployment Strategy
• Setup PostgreSQL DB using Docker-compose file for Multi-container Docker env
• Add PostgreSQL DB image into Docker-compose file for Multi-container Docker env
• Run Docker-Compose on Visual Studio to setup PostgreSQL DB on Docker
• Connect and Browse PostgreSQL DB using pgAdmin

11. Develop Shared and Catalog Data-Infrastructure with EF Core Code First

• Introduction - Develop Shared and Catalog Data-Infrastructure Layer with EF Core
• EF Core 8 Features, Code First Approach, Migrations and PostgreSQL Connection
• Steps of EF Core Developments for Shared and Catalog Data-Infrastructure
• Install EF Core NuGet Packages in Shared Library
• Develop EF Core DbContext Object for Storing Entities in Catalog Module
• Mapping DDD Objects to EF Entities - Develop EF Core Entity Configurations
• EF Core PostgreSQL Connection String in appsettings.json file
• Register EF Core DbContext in Asp.Net DependencyInjection Tool for PostgreSQL
• Create EF Core Migrations for CatalogDbContext - Part 1
• Create EF Core Migrations for CatalogDbContext - Part 2
• Review and Run Docker-Compose on Visual Studio to setup PostgreSQL DB on Docker
• Apply EF Core Migrations to PostgreSQL DB with Update-Database Command
• Auto Migrate EF Core Entities to PostgreSQL DB when Application Startup
• Develop Generic UseMigration Extension Method for DB Migration and Seed
• Using UseMigration Extension Method on Module DependencyInjection Classes
• Test Auto-Migrations with UseMigration Extension Method on WebApplication
• Seed EShopDb Product Data When Application Startup Just After UseMigration
• Run Catalog Module to Migrate and Seed EShopDb with UseMigration Method
• EF Core Interceptors: SaveChangesInterceptor for Auditing Entities
• Develop SaveChangesInterceptor to Auditing Entities for Order Entities
• Run & Test Catalog Module for Audit with EF Save Changes Interceptor
• Dispatch Domain Events with EF Core SaveChangesInterceptor
• Develop DispatchDomainEventsInterceptor to Trigger Domain Event Handlers
• Run & Test Catalog Module for Dispatch DomainEvents with EF SaveChanges Interceptor

12. Application Use Case Development with CQRS and MediatR

• Introduction - Application Use Case Development with CQRS and MediatR
• CQRS (Command Query Responsibility Segregation) Pattern
• Logical and Physical Implementation of CQRS Pattern
• CQRS Design Pattern With MediatR Library (Logical CQRS Implementation)
• 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

13. Catalog Application Use Case Development with CQRS and MediatR

• Introduction - Catalog Application Use Case Development with CQRS and MediatR
• Quick Remember Catalog Module Application Use Cases Analysis
• Develop Catalog Module Folder Structure for CQRS
• Develop DTO Classes for Product in Catalog Module
• Develop Products CreateProductCommand and Handler in Catalog Modules Application
• Develop Products CreateProductCommandHandler using CatalogDbContext in Catalog
• Develop Products UpdateProductCommand and Handler using CatalogDbContext
• Develop Products DeleteProductCommand and Handler using CatalogDbContext
• Develop Product Queries with CQRS and MediatR in Catalog Module
• Mapping with Mapster
• Develop Product Queries with CQRS and MediatR in Catalog Module with Mapster
• Develop GetProductByCategory Queries with CQRS and MediatR in Catalog Module
• Develop GetProductById Queries with CQRS and MediatR in Catalog Module
• Develop Domain Event Handlers with MediatR INotificationHandler in Catalog
• Develop Domain Event Handlers with MediatR INotificationHandler - Part 2

14. Develop Catalog API Endpoints Expose Minimal API Endpoints with Carter and REPR

• Introduction - Develop Catalog API Endpoints Exposing Minimal API Endpoints
• REPR Design Pattern and CQRS MediatR Request Lifecycle
• Minimal APIs and Install Carter Library to Expose Minimal APIs
• Quick Remember Catalog Module Endpoints Analysis
• Develop CreateProduct POST Endpoint with Carter Implements ICarterModule
• Develop CreateProduct POST Endpoint with Carter Implements ICarterModule - Part 2
• Developing UpdateProduct Endpoint for REST APIs in Catalog Module
• Developing DeleteProduct Endpoint for REST APIs in Catalog Module
• Developing GetProducts Endpoint for REST APIs in Catalog Module
• Developing GetProductById Endpoint for REST APIs in Catalog Module
• Developing GetProductByCategory Endpoint for REST APIs in Catalog Module
• Register Carter Libraries into ASP.NET Dependency Injection Service and Request
• Create Extension Method for Carter Assembly Registrations
• Create Postman Collection for EShopModules
• Test Catalog Module - CreateProduct POST Request - Debug Carter Minimal API
• Test UpdateProduct Endpoint with CQRS and VSA in Catalog Module
• Test Get Product Endpoints with CQRS and VSA in Catalog Module
• Test DeleteProduct Endpoint with CQRS and VSA in Catalog Module

15. Develop Cross-cutting Concerns for Catalog and Each Module in EShop Modules

• Introduction - Develop Cross-cutting Concerns for Catalog and Each Module
• MediatR Pipeline Behaviors and Fluent Validation Library
• Add Cross-cutting Concerns into Shared Class Library to Use in All Modules
• Apply Validation with AbstractValidator using Fluent Validation Library
• Apply Validation with AbstractValidator using Fluent Validation Library - Part 2
• Validation Pipeline Behavior with MediatR using Fluent Validation Library
• Remove Manual Validator and Test Validation Pipeline Behavior with MediatR
• Develop CRUD Command Validators with Fluent Validation
• Global Handling Exceptions in ASP.NET Core with app.UseExceptionHandler
• Shared Handle Exceptions Generic Way in ASP.NET Core 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 Module
• Structured Logging Using Serilog in .NET 8.0 Minimal APIs
• Serilog WriteTo Seq for Structured Logging in .NET
• Develop Pagination Class for Query GetProducts using CQRS and MediatR
• Develop GetProducts Query Apply Pagination using CQRS and MediatR

16. Develop Basket Module with Vertical Slice Architecture and CQRS

• Introduction - Develop Basket Module with Vertical Slice Architecture and CQRS
• Domain Analysis of Basket Module: Models, UCs, Rest APIs, Databases
• Technical Analysis of Basket Module: Architectures, Patterns, Libraries, Folders
• Develop ShoppingCart Domain Entity Models in Basket Domain Entities
• Develop DDD Rich-domain Model Entity for ShoppingCart Entities

17. Develop Basket Data-Infrastructure with EF Core Code First and PostgreSQL

• Introduction - Develop Basket Data-Infrastructure with EF Core Code First
• Steps of Infrastructure EF Core Developments for Basket Module
• Develop EF Core DbContext Object for Storing Entities in Basket Infrastructure
• Mapping DDD Objects to EF Entities - Develop EF Core Entity Configurations
• EF Core 8 Relations and DDD ValueObject Mapping with ComplexType and Property
• Develop SC and SC Items Relations Entity Configurations
• EF Core SQL Server Connection String in appsettings.json file
• Register EF Core DbContext in ASP.NET Dependency Injection Tool for PostgreSQL
• Create EF Core Migrations for BasketDbContext in Basket Infrastructure
• Run Docker-Compose on Visual Studio to Setup PostgreSQL on Docker
• Apply EF Core Migrations to PostgreSQL DB with Update-Database Command
• Auto Migrate EF Core Entities to PostgreSQL When Application Startup with Coding
• Test Auto-Migrations with UseMigration Extension Method on WebApplication

18. Develop Basket Application Use Case Development with CQRS and MediatR

• Introduction - Basket Application Use Case Development with CQRS and MediatR
• Develop Basket Folder Structure for CQRS
• Develop DTO Classes for ShoppingCart in Basket Module
• Develop Basket CreateBasketCommand and Handler in Basket Application Use Cases
• Develop Basket CreateBasketCommandHandler using BasketDbContext in Basket Module
• Develop Basket DeleteBasketCommand and Handler using BasketDbContext in Basket
• Develop Basket Queries with CQRS and MediatR in Basket Module
• Develop Basket AddItemIntoBasketHandler with CQRS and MediatR
• Develop Basket RemoveItemFromBasketHandler with CQRS and MediatR

19. Develop Basket API Endpoints Exposing Minimal API Endpoints with Carter and REPR

• Introduction - Develop Basket API Endpoints Exposing Minimal API Endpoints
• Develop CreateBasket POST Endpoint with Carter Implements ICarterModule
• Develop DeleteBasket Endpoint with Carter Implements ICarterModule
• Develop GetBasket Endpoint with Carter Implements ICarterModule for Minimal APIs
• Develop AddItemIntoBasket Endpoint with Carter Implements ICarterModule
• Develop RemoveItemFromBasket Endpoint with Carter Implements ICarterModule
• Register MediatR and Carter Libraries into ASP.NET Dependency Injection Service
• Register MediatR Libraries into ASP.NET Dependency Injection Service and Request
• Develop MediatR Extension Method for Custom Registration With Assemblies
• Test Basket API - CreateBasket POST Request - Debug Carter Minimal API
• Test Get Basket Endpoints with CQRS and VSA in Basket Module
• Test DeleteBasket Endpoint with CQRS and VSA in Basket Module
• Test AddItemIntoBasket Endpoint with CQRS and VSA in Basket Module
• Test RemoveItemFromBasket Endpoint with CQRS and VSA in Basket Module

20. Develop Distributed Caching with Redis in Basket Module

• Introduction - Develop Distributed Caching with Redis in Basket Module
• Develop BasketRepository Class using EF Core DbContext Object
• Implement IBasketRepository Class using EF Core DbContext Object
• Register IBasketRepository into DI of Basket Module
• Inject and Use IBasketRepository into Handler Classes in Basket Module
• Inject and Use IBasketRepository into AddItem and RemoveItem Handler Classes
• Quick Test Basket Endpoint with CQRS and VSA in Basket Module
• Cache-aside Pattern and 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 - Part 2
• Develop CachedBasketRepository with Proxy Pattern, Decorator Pattern - Part 3
• Register Decorated CachedBasketRepository and StackExchangeRedis with Scrutor
• Register StackExchangeRedis into Common DI in API Project Program.cs
• 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
• Connect Redis Cache from Local Basket Module and Send GET Request Basket Cache
• Develop Custom JsonConverter for ShoppingCart and Items When Reading to Redis
• Develop Custom JsonConverter for ShoppingCart and Items - Part 2
• Use Custom JsonSerializerOptions with JsonConverter for ShoppingCart and Items
• Quick Test Basket Endpoint with CachedBasket Repository and Custom JsonConverter

21. Sync Communications Between Modules with In-Process Method Calls (Public APIs)

• Introduction - Sync Communications Between Modules with In-Process Method Calls
• How Modular Monolithic Architecture Handles Communications Between Modules
• Basket Module Synchronous Use Cases - Adding an Item to the Basket Communication
• Examine AddItemIntoBasketHandler Class: Get Product Price from Catalog Module
• Sync Communication Between Modules Using Contracts Class Libraries
• Step 1: Create Catalog.Contracts Class Library
• Step 2: Move Exposing MediatR Method Query or Commands into Catalog.Contracts
• Splitting CQRS Contract-Related Common Operations into Shared.Contracts Class Library
• Step 3: Modify Catalog Module Getting Reference from Catalog.Contracts Class Library
• Step 4: Basket Get Reference from Catalog.Contracts Class Library
• Step 6: Get Product Entity Values into AddItemIntoBasketHandler and Set Price
• Test Basket AddItemIntoBasket Sync Call to Catalog Module to Get Product Data
• Step 7: Migrating Microservices: Evolving Contracts Sync Communication

22. Async Communications Between Modules with RabbitMQ & MassTransit for UpdatePrice

• Introduction - Async Communications Between Modules with RabbitMQ & MassTransit
• How Modular Monolithic Architecture Handles Async Communications Between Modules
• Fan-Out Publish/Subscribe Messaging Pattern
• Quick Remember: Domain vs Integration Events - Domain Leads to Integration Event
• Domain Analysis of Async Communication Between Catalog and Basket Modules
• Technical Analysis of Async Communication Between Catalog and Basket Modules
• Steps of Developing Async Communication Between Catalog and Basket Modules
• Step 1: Examine Catalog Module Domain and Integration Events
• Step 2: Create Shared.Messaging Class Library
• Develop ProductPriceChangedIntegration Event in Shared.Messaging Class Library
• Develop MassTransit Extension Methods to Register RabbitMQ Connection into DI
• Develop MassTransit Extension Methods to Register Connection into DI of Catalog
• Add Project Reference to Shared.Messaging in Catalog and Basket Modules
• Register MassTransit Packages into Bootstrapper API DI in Program.cs File
• ProductPriceChanged Integration Event: How Domain Leads to Integration Event
• Step 3: Catalog Publish UpdatePrice Integration Event
• Step 4: Basket Subscribe and Consume ProductPriceChanged Integration Event
• Develop UpdateItemPriceInBasket Feature in Basket Module
• Develop UpdateItemPriceInBasket Feature in Basket Module - Part 2
• Call UpdateItemPriceInBasketCommand in ProductPriceChangedIntegrationEventHandler
• TEST - ProductPriceChangedIntegrationEvent with In-Memory MassTransit
• What is RabbitMQ and Main Components of RabbitMQ (Producer, Queue, Consumer)
• Shifting In-Memory Bus to RabbitMQ Message Broker in MassTransit
• Develop MassTransit Extension Methods to Register RabbitMQ Connection into DI
• Setup RabbitMQ for Async Communication Using Docker-Compose File
• Run Docker-Compose on Visual Studio to Setup RabbitMQ on Docker
• TEST - ProductPriceChangedIntegrationEvent with RabbitMQ MassTransit

23. Develop User Identity Module with Keycloak Authentication

• Introduction - Develop User Identity Module with Keycloak Authentication
• Keycloak Identity and Access Management
• Main Advantages of Using Keycloak
• Best Practices When Using Keycloak
• OAuth2 + OpenID Connect Flows with Keycloak
• Keycloak as a Backing Service of Modular Monolith Modules
• Setup Keycloak into Docker-Compose File for Identity Provider
• Run Docker-Compose on Visual Studio Setup Keycloak Identity Provider on Docker
• Setup Keycloak User Identity Database as a PostgreSQL DB Identity Schema
• Run Docker-Compose for Keycloak PostgreSQL Identity Schema Generation
• Create Realm, User and Client for OpenID Connect with Keycloak Identity Provider
• Secure EShop Modules with Keycloak OpenID Connect in ASP.NET
• Secure and Test Basket Endpoints with Keycloak Integration
• Get JwtBearer Token for OpenID Connect with Keycloak Identity
• Get Current User from Token with ClaimsPrincipal in ASP.NET Authentication
• TEST - Create Basket with Current User from Token with ClaimsPrincipal
• Secure Basket Endpoints with OpenID Connect Using Keycloak Identity Provider

24. Ordering Module with Vertical Slice Architecture and CQRS

• Introduction - Ordering Module with Vertical Slice Architecture and CQRS
• Domain Analysis of Ordering Module: Models, UCs, Rest APIs, Databases
• Technical Analysis of Ordering Module: Architectures, Patterns, Libraries
• Develop Ordering Domain Entities with Tactical Domain-Driven Design Patterns
• Develop Ordering Data-Infrastructure with EF Core Code First and PostgreSQL
• Develop Ordering.Application Layer with CQRS and MediatR
• Develop Ordering API Endpoints Exposing Minimal API Endpoints with Carter

25. Outbox Pattern for Reliable Microservices Messaging with BasketCheckout Use Case

• Introduction - Outbox Pattern for Reliable Microservices Messaging
• Analyze Basket Checkout Event Between Basket and Ordering Modules
• Develop BasketCheckout Event in Shared.Messaging Class Library
• Quick Remember Async Communication MassTransit RabbitMQ Setup
• Develop BasketCheckout Feature Folder to Expose POST Endpoint and Publish Event
• Develop Basket Checkout Handler Method to Publish Event to RabbitMQ via MassTransit
• Dual-write Problem and Outbox Pattern
• Develop Outbox Pattern for Reliable Microservices Messaging with BasketCheckout
• Step 1-2: Create the Outbox Entity and Modify the DbContext
• Step 3: Update CheckoutBasketHandler with Outbox and Database Begin and Commit
• Step 4: Create a Background Service to Process Outbox Messages
• Ordering Module to Subscribe-Consume BasketCheckout Event from RabbitMQ
• Register Ordering Module into MassTransit for Async Event-driven Communication
• Develop Basket Checkout Event Consumer Integration Event Handler
• TEST - Checkout Basket Use Case - Reliable Async Communication Outbox Pattern - Part 1
• TEST - Checkout Basket Use Case - Reliable Async Communication Outbox Pattern - Part 2

26. Containerize and Orchestrate EShop Modular App in Docker-Compose

• Introduction - Containerize and Orchestrate EShop Modular App in Docker-Compose
• EShop Modular Monolith Deployment Strategy
• Add ASP.NET API Project into Docker-Compose File for Multi-container Docker Environment
• Set Environment Variables of API Project Configurations According to appsettings
• TEST ALL - Docker-Compose All with API Project and Backing Services
• TEST Basket Module - Docker-Compose All with API Project
• TEST CheckoutBasket with RabbitMQ and Ordering Module - Docker-Compose All with API
• TEST Ordering Module - Docker-Compose All with API Project
• Client Apps - Consume API Module in EShop Modules

27. Migrating to Microservices: EShop Modules to Microservices with Strangler Fig

• Migrating to Microservices: Challenges and Considerations
• Strangler Fig Pattern for Refactoring Monolith into Microservices
• Steps of Refactoring Monolith into Microservices
• Step 1: Decompose EShop Modules to Microservices with DDD Bounded Contexts
• Step 2: Prioritize Modules-Services for Migration
• Step 3: Extract a Service from a Monolith
• Step 4: Manage a Monolithic Database
• Step 5: Design and Implement Interservice Communication
• Step 6: Async Communication Between Services
• Step 7: Distributed Transactions and Data Consistency
• Step 8: Deployment of Microservices After Monolithic
• .NET 8 Microservices: DDD, CQRS, Vertical/Clean Architecture - Course Summary

28. Thanks

• Thanks