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

Learn what microservices are: small, independent, loosely coupled services with separate code bases that communicate via well defined APIs, deploy independently, and use separate databases, tech-agnostic, with autonomous teams.

Describe microservices architecture as a suite of small, independently deployable services that communicate via lightweight APIs, enabling autonomous teams to use diverse tech stacks and bounded contexts.

Learn microservices characteristics from Martin Fowler: componentization via services, organization by business capabilities, products not projects, smart endpoints, decentralized governance, and polyglot persistence.

Discover microservices benefits like agility, faster time to market, independent deploys, and scalable microservices with small teams and a separated codebase, using container orchestration.

Explore the challenges of microservice architectures, including complexity, deployment and versioning, interservice communication across locations, network latency, and data integrity concerns with asynchronous patterns.

Assess whether microservices are necessary and weigh benefits like independent scalability and zero-downtime deployments. Begin with a modular monolithic approach, then refactor into microservices as needed to deploy updates independently.

Explore anti-patterns in microservices, including distributed monoliths, tight coupling, and neglecting cloud-native practices, and learn how proper decoupling, bounded contexts, and DevOps enable autonomy and scalability.

Compare monolithic and microservices architectures, highlighting structure, independent scalability, deployment with ci cd automation, and team implications to guide architecture decisions.

Explore the database per service pattern in microservice architecture, where each service owns its own database, enabling polyglot persistence, loose coupling, and independent scalability for product, cart, and orders.

Explore the e-commerce domain by defining use cases and decomposing into microservices such as customers, product, shopping cart, discount, and orders, plus fulfillment and intelligence services.

Learn why dot net evolved into a fast, open source, cross-platform unified platform that targets web, mobile, desktop, games, and IoT with blazing performance and a rich ecosystem.

Explore cloud-native development with .NET 8, leveraging observability, resilience, scalability, and manageability with built-in health checks, telemetry, testing, and open telemetry with Prometheus and Grafana dashboards.

Discover dotnet eight container enhancements such as chiselled lean images, non-root execution, and native AOT, delivering smaller runtimes, faster deployments, and easier Kubernetes integration.

Explore the new features in .NET 8, including dotnet aspire, enhanced libraries, metrics tagging, https proxy networking, extension libraries, function pointers, adaptive garbage collection, and improved reflection and sdk tooling.

Discover C# 12 enhancements for microservices: primary constructs in classes, collection expressions, inline arrays, optional lambda parameters, ref readonly parameters, and using alias for any type.

Learn C# top level statements, global usings, and pattern matching for microservice development. Apply concise switch expressions, property patterns, and discard patterns to simplify logic and improve maintainability.

Explore asp.net eight for microservices development by building robust, scalable web APIs and web UIs with asp.net core, using minimal APIs, dependency injection, docker containerization, and docker compose.

Master minimal APIs in ASP.NET Core to create fast, efficient REST endpoints with minimal coding, dynamic routing, and no controllers for microservices.

Create a single microservice using an ASP.NET Core web API in .NET 8 with minimal APIs and top-level statements. Build, run, and test a weather forecast endpoint that returns JSON.

Streamline a single microservice by building a minimal ASP.NET Core Web API, removing boilerplate, and following five steps from setup to run, emphasizing dependency injection and the HTTP request pipeline.

Create a Todo web API using ASP.NET Core minimal APIs with an in-memory EF Core database, exposing get, post, put, and delete CRUD endpoints.

Create and test a minimal ASP.NET Core todo API for a single microservice. Expose post, get, put, and delete endpoints, store items in memory, and verify behavior with Postman.

Learn how to containerize and orchestrate microservices with Docker, including building images from a Dockerfile, running containers, pushing to registries, and coordinating via Docker Compose and Kubernetes.

Learn to containerize a Todo ASP.NET web API using Docker, configure launch settings and ports in Visual Studio, and run, test, and debug the microservice in a Docker container.

Develop the catalog API microservice with vertical slice architecture and CQRS in dotnet 8, using minimal APIs, PostgreSQL with Martin library, mediator pattern, Carter, Mapster, fluent validation, and docker deployment.

Create a new GitHub repository for our microservices project, including a Readme and Visual Studio gitignore, and you can choose any license; then share the repository link for progress checks.

Clone the GitHub repository in Visual Studio 2022, create a blank solution for .NET 8 microservices, and organize the project under a source folder before pushing changes to GitHub.

Set up the catalog api microservice by creating a services/catalog folder, starting an ASP.NET Core project in .NET 8, and simplifying Program.cs to separate service registration from the HTTP pipeline.

Configure catalog api port numbers across local and docker environments by editing launch settings to set http 5000 and https 5050, aligning internal 8080 and external 6000.

Analyze catalog microservices domain models, use cases, rest api endpoints, and underlying data structures; plan a document database approach with PostgreSQL and Martin library.

Explore a catalog microservice built with vertical slice architecture, CQRS, mediator, DI, minimal APIs, and ORM with PostgreSQL, and review Carter, Martin, Mobster, and FluentValidation.

Explore vertical slice architecture, a feature-based approach that cuts through all layers from UI to database, enabling self-contained slices and cross-functional teamwork for scalable, maintainable microservices.

Compare vertical slice architecture and clean architecture to reveal rapid feature delivery versus decoupled core business rules in microservices.

Explore the CQRS design pattern, separating command and query responsibilities to avoid complex joins, with separate NoSQL reads and relational writes using denormalized versus normalized data.

Demonstrate the logical and physical implementation of the CQRS pattern by separating read and write operations at the code level, and by using separate databases for reads and writes.

Learn CQRS with the MediatR library to model commands and queries as requests, dispatch them through a mediator, and apply pipeline behaviors like logging and validation in ASP.NET Core.

Develop catalog api microservices by creating a product domain entity with a category relation, placed in modules folder, using PostgreSQL with Martin Library for a document database via json columns.

Organize a products feature folder into vertical slices with MediatR, separating create, get, update, and delete use cases into handler and endpoint classes for clear UI, logic, and data access.

Leverage CQRS and MediatR to implement a create product feature within a vertical slice architecture, defining a create product command and result, and a command handler.

Demonstrate creating abstraction on the mediator for securities design pattern and cqrs by separating commands and queries with specialized interfaces and handlers, and building a Building Blocks library for microservices.

Continue building mediator abstractions for CQRS by defining command and query handlers, implementing ICommand and IQuery interfaces, and wiring building blocks to replace direct mediator references in catalog microservices.

Refactor the create product vertical slice to use CQRS abstractions ICommand and ICommandHandler, implement the command handler with mediator, and return a create product result via a minimal API endpoint.

Develop a create product endpoint with minimal APIs and the Carter library, exposing a post endpoint at /products using defined request and response models.

Develop a post endpoint using Carter by implementing the ICarterModule, map the create product request to a mediator command with the Master mapping library, and wire it into minimal APIs.

Implement an http post /products endpoint that maps requests to a create product command via Carter and Napster, sends it through the mediator, and returns a 201 created response.

Register Carter library into the ASP.NET dependency injection container to expose minimal API endpoints with Carter's model. Configure mediator to manage command and query handlers by registering services from assembly.

Test the catalog api by sending a create product http post to the minimal api endpoint, routing through Carter to mediator and the handler that creates the product.

Develop catalog api infrastructure, handler and endpoint clusters to perform CRUD operations using vertical slice architecture, mediator pattern, APIs, and Carter library, tested in a Docker PostgreSQL environment.

Discover how catalog microservices leverage backing services, using PostgreSQL and the Martin orm library. Transform PostgreSQL json storage into a transactional document database with strong consistency.

Open and explore Marten as a document database by creating and using query and document sessions, including identity map, lightweight, and dirty checking, with best practices for disposing sessions.

Develop a command handler that saves a product to PostgreSQL as a Marten document by injecting a document session, storing the product, and saving changes asynchronously.

Register and configure the Marten document database in Program.cs using ASP.NET dependency injection and a Postgres connection string from appsettings.json, enabling lightweight sessions for CRUD and noting auto-create schema objects.

Learn the two-phase deployment strategy for e-commerce microservices, using docker compose to set up postgres as catalog backing service and enable local development with end-to-end testing.

Set up PostgreSQL in a multi-container docker environment using docker-compose, exposing ports and connecting to local microservices, leveraging Visual Studio generated docker-compose files and environment-specific overrides.

Add a PostgreSQL database image to a multi-container docker environment using docker-compose.yml and an override file, as backing services for catalog microservices, configuring ports, volumes, and environment variables.

Run docker compose on Visual Studio to spin up a PostgreSQL database in Docker, verify containers, and connect via psql; Martin ORM will auto-create catalog tables on startup.

Connect the local catalog microservice to PostgreSQL using the connection string, send http post requests to create products, and verify table creation and data persistence with Marten and PostgreSQL.

Develop a get products feature in vertical slice architecture using the mediator library, creating a get products endpoint and handler, and returning all products from the database.

Develop Getproducts endpoint using minimal APIs and Carter to expose the catalog's http get, fetch via mediator, and map to the Getproducts response.

Test the getproducts endpoint of the catalog microservices using a dockerized PostgreSQL database, validating connectivity via Docker Compose, Visual Studio, and Postman.

Create postman collections for catalog, basket, discount, and ordering microservices, and configure localhost and docker environments with environment variables to switch ports.

Develop GetProduct by ID using CQRS and MediatR in a vertical slice architecture, implementing a query handler and endpoint to fetch by ID and throw a product not found exception.

Develop a get product by id endpoint using minimal APIs and Carter, defining request and response records, mapping parameters, and mediating a get product by id query to a handler.

Test the get product by id endpoint by connecting to a PostgreSQL container via Docker Compose, and validate json responses from the catalog api using Postman and breakpoints.

Develop the get product by category feature by implementing a query, a result object, and a query handler; handle method logs the request and filters products by category, returning matches.

Develop a get products by category endpoint using minimal APIs and Carter in .NET 8 microservices, define request and response objects, and query category products via mediator.

Test the get product by category endpoint by connecting to a PostgreSQL container, using Docker Compose, and verify category-based filtering via Postman against the product document table.

Develop an update product handler using CQRS, MediatR, and SQS in vertical slice architecture. Load product by id, update fields, save changes, and return a success result.

Develop an update product put endpoint using minimal APIs and Carter, defining request and response records, mapping to an update product command via mediator, and returning appropriate http responses.

Test the update product endpoint in a .NET 8 microservices setup with a Docker PostgreSQL container using postman http put requests, and verify via id lookup with mediator-driven command handling.

Implement delete product functionality using CQRS and MediatR in a vertical slice, defining the delete product command and result, wiring the handler, and removing by id with save changes.

Develop a delete product endpoint with minimal APIs and Carter, exposing HTTP delete at /products/{id}, sending a delete command via mediator and adapting the result to a response.

Test delete product end-to-end by connecting to a Docker PostgreSQL container, running the catalog API, and using Postman to delete a product, then verify removal with get requests.

Develop concerns for catalog api microservices, including mediator pipeline behavior, fluent validation, logging, validation pipelines, exception handling, health checks, pagination for get products, and containerization with Docker and Docker Compose.

Discover mediator pipeline behaviors in dotnet with mediatR, injecting validation, logging, and tracing around handlers. See how fluent validation integrates with the pipeline to enforce rules before handling requests.

Extend all microservices by integrating cross-cutting concerns into the Building Blocks library, implementing validation with Fluent Validation, logging, and exception handling via dependency injection extensions for ASP.NET web APIs.

Define a create product command validator using abstract validator from fluent validation, enforce name, category, image file, and price rules, inject it into handler, and register validators in dependency injection.

Implement a MediatR pipeline behavior to centralize validation with fluent validation. Inject validators, run validations on command handlers, throw validation exceptions on failures, and register the behavior in dependency injection.

Remove manual validators from the create product command handler and rely on mediator validation pipeline behavior to streamline validation across the microservice.

Develop update and delete product command validators using full-length validation and fluent pipeline, mirroring the create validator to enforce id, non-empty name with length limits, and price greater than zero.

Learn global exception handling in ASP.NET Core using app.UseExceptionHandler and a lambda to return a structured json error response with problem details and logging.

Centralize exception handling in microservices with building blocks by creating generic not found, internal server error, and bad request exceptions and applying them with app.UseExceptionHandler.

Enable global exception handling in ASP.NET Core with IExceptionHandler, registered as a singleton via AddExceptionHandler. Create a custom handler that logs errors, uses pattern matching, and returns problem details.

Register a custom exception handler in ASP.NET with AddExceptionHandler, replacing inline program code with a modular dependency injection setup and a configured request pipeline.

Centralize logging across all MediatR requests with a pipeline logging behavior, addressing cross-cutting concerns by logging each request and response and timing execution via dependency injection.

Demonstrates centralized logging for all mediator requests in catalog api microservices by removing manual logging from handlers and validating the logging behavior across get, create, update, and delete operations.

seed the catalog database using the IInitialData interface to load pre-configured products via Martin's upsert store in PostgreSQL.

Seed initial data for the catalog microservice on PostgreSQL using Martin, creating the product table and inserting records during startup.

Use the to page list async extension method to paginate the Getproducts query with page number and page size, leveraging the Martin library to simplify pagination in the endpoint.

Test pagination for GetProducts with ToPagedListAsync, validating page number and page size in a dockerized postgres catalog, five items on page one and two on page two.

Register health checks for catalog microservices with PostgreSQL using ASP.NET Core, exposing json endpoints. Add PostgreSQL health checks and a UI client, then test with Postman.

Create a multi-stage Dockerfile with a base image ASP.NET 8, build and publish, then use Docker Compose to orchestrate catalog API microservices and databases in containers.

Orchestrate catalog API microservices and PostgreSQL using Docker Compose, configuring ports, environment variables, and dependencies, override application settings to connect via catalog db service, then deploy with Docker Compose up.

Test and run catalog api microservices with docker-compose, linking to PostgreSQL, using Visual Studio to start, debug, verify health checks, and perform GET, POST, PUT, and DELETE operations via Postman.

Develop basket microservices with vertical slice architecture and cqrs, using postgresql and redis as backing services. Build fast rest endpoints with minimal apis, mediator library, repository pattern, and docker compose.

Create a dotnet 8 asp.net web api basket api microservice, organize solution under services/basket, enable http/https and docker/linux, and refactor program.cs to configure services before building and map endpoints after.

Learn to configure port mappings for the Basket API microservice by editing launchSettings.json, setting http 5001 and https 5051, and launching with the https profile for local development.

Analyze basket microservice domains, models, and data structures, covering shopping cart, cart item, and basket checkout, with CRUD, gRPC, and asynchronous use cases, REST endpoints, and PostgreSQL and Redis.

Explore basket microservices architecture, patterns, and libraries. Analyze vertical slice structure, repository pattern, and key components like mediator, dependency injection, minimal APIs, and Docker deployment.

Develop domain models for basket api by creating cart item and cart entities with quantity, color, price, and product info; map cart to Martin document database and Redis.

Build a basket feature with vertical slice architecture using CQRS and MediatR. Create get, store, and delete folders each with endpoint and handler classes aligned to clean architecture.

Develop a get basket query handler using CQRS and MediatR in a .NET 8 microservice, wiring SQS, building blocks, and a mocked shopping cart for the username.

Implement a get basket endpoint with minimal APIs and Carter, creating request and response records and wiring a Carter module. Use mediator to handle the get basket query by username.

Develop a store basket feature handler using cqrs and MediatR to upsert a shopping cart in the database and update the Redis cache via an HTTP post.

Expose a store basket post endpoint using minimal APIs and Carter, mapping request and response objects, mediator-based command handling, and returning a 201 created response.

Develop the delete basket command and handler using cqrs and MediatR, validating the username, and scaffolding database and cache integration with a mocked success result.

Develop a delete basket endpoint with minimal API and Carter, exposing an http delete route that uses mediator to run the delete basket command and return a response.

Register Mediator and Carter libraries into ASP.NET core dependency injection and request pipeline. Map Carter endpoints and configure mediator open behaviors, including validation and logging, for efficient request handling.

Test basket APIs using get, post, and delete requests with postman and debug the mediator request lifecycle from client to handler to store basket.

Explore how backing services like PostgreSQL and Redis enable a decoupled infrastructure for the basket api, and implement a repository with cache-aside using a decorator to manage data.

Develop a basket repository using Marten, defining ai basket repository interface for get, store, and delete basket operations. Inject the repository into handlers for username-based retrieval and shopping cart storage.

Implement a basket repository using the Martin document session, injected via the constructor, to get by username, upsert with store, and delete, with a custom basket not-found exception.

Register and configure the Marten DocumentDB library in Program.cs using asp.net di, connect PostgreSQL, enable lightweight sessions, auto-create schema, and set shopping cart identity to username.

Configure a second PostgreSQL database for the basket microservice using docker compose. Update ports, volumes, and environment settings to connect from localhost.

Run docker compose in Visual Studio to launch catalog on 5432 and basket on 5433. Use pgadmin to register servers and explore basket get, delete, and store operations.

Integrate the basket repository with CQRS handlers to perform CRUD on baskets, injecting the repository into get, store, and delete handlers via ASP.NET Core DI.

Connect a local basket microservice to a Docker container running PostgreSQL, create a shopping cart via Postman, and verify JSON data storage in Pgadmin using a Jsonb column.

Test http get and delete endpoints of the basket microservice connected to PostgreSQL via Martin, ensuring 200 responses with cart data and user-friendly error messaging for not found baskets.

Implement robust exception handling in basket microservices by integrating a custom exception handler into the basket api program.cs, enabling a cross-cutting, structured json error response.

Integrate Redis as a distributed cache for basket microservices to cache user and shopping cart data, apply cache aside and invalidation patterns, and deploy via Docker Compose to boost performance.

Implement the cache aside pattern in microservices to store frequently accessed data in a distributed cache, check cache first, fall back to the database on miss, and update the cache.

Explore the proxy pattern and decorator pattern with the security library and Scrutor, and learn to define interfaces, create a cached decorator, and register services in ASP.NET Core.

Develop a cache-enabled basket repository by decorating the base basket repository with proxy and decorator patterns, injecting the underlying repository, and integrating Redis caching for get, store, and delete operations.

Develop a cached basket repository using proxy and decorator patterns with scrutor, integrating a redis cache to minimize database calls by caching basket data on get, store, and delete operations.

Decorate the cash basket repository with the security library and its decorate extension method, and configure stack exchange redis as a distributed cache in Program.cs.

Set up Redis as a distributed cache for the e-commerce basket microservice with Docker Compose, connecting from the local environment while deploying the Redis image from Docker Hub.

Integrate Redis as a distributed cache into a multi-container docker compose setup by configuring the docker-compose.yaml and docker-compose.override.yaml with local development settings, ports, volumes, restart always, and container naming.

Run Docker Compose in Visual Studio to set up Redis as a distributed cache in a Docker environment, initialize PostgreSQL databases, start microservices, and verify connectivity with Redis CLI.

Configure Docker Compose launch settings to prevent browser opening for microservices, using Postman collections for requests and setting per-microservice HTTP/HTTPS launch browsers to false.

Connect Redis distributed cache with local basket microservices, test get, post, and delete requests, and validate basket data flows from PostgreSQL to cache and back for performance.

Register and configure ASP.NET core health checks for the basket microservice, monitoring PostgreSQL and Redis, exposing the /health endpoint, and using the UI client to render json health status.

Containerize the basket api microservices with docker by generating a dockerfile in Visual Studio, building with dotnet sdk, publishing to /app/publish, and using docker compose to run all services.

Orchestrate basket API microservices in a Docker Compose multi-container network. Configure environment variables, depends_on, and port mappings, using basket db and distributed cache with ports 6001 and 6061.

Test and run the basket microservices in a Docker environment using Docker Compose, PostgreSQL and Redis, verify the health endpoint, and store, retrieve, and delete baskets in the Redis cache.

Explore microservices communication types, contrasting synchronous http or grpc calls, where the client blocks until a response, with asynchronous amqp messaging via brokers like Kafka and RabbitMQ.

Explore synchronous microservice communication using http/rest, gRPC, GraphQL, and WebSocket within a request–response model, and learn best practices for implementing these patterns.

Explore high performance open source gRPC for remote procedure calls, using protobuf contracts over http/2 to build fast, language-agnostic microservices and inter-service communication.

Learn how gRPC enables client-server remote procedure calls across machines and languages, with services defined by interfaces, servers implementing them, and clients mirroring methods.

See how the shopping cart coordinates synchronous gRPC calls to product and discount microservices, using HTTP/2 and protocol buffers for high-performance communication.