Advanced Microservices with DDD, CQRS, and Event-Driven

Packt via Coursera

Go to class Write review

Overview

Coursera Flash Sale

40% Off Coursera Plus for 3 Months!

Grab it

This course features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. In this course, you will master building microservices with DDD, CQRS, and event-driven patterns. Learn to develop microservices using Clean Architecture, implement DDD patterns like entities, aggregates, and value objects, and apply asynchronous communication with RabbitMQ and MassTransit. You'll explore building a shopping web client using Refit, integrating it with backend services via YARP API Gateway. The course also covers deploying and orchestrating microservices using Docker and Docker-Compose. You'll work with real-world examples to create a highly maintainable and scalable system, applying CQRS for efficient data management and event sourcing for state changes. Ideal for developers with knowledge of microservices, .NET, CQRS, DDD, databases, Docker, and messaging systems like RabbitMQ. By the end of this course, you will be able to design and deploy advanced microservices that scale, communicate asynchronously, and integrate with various external systems.

Syllabus

Ordering Microservices with DDD, CQRS, and Clean Architecture

In this module, we will dive into the design and implementation of the Ordering microservice, applying Domain-Driven Design (DDD), CQRS, and Clean Architecture principles. You’ll explore how to structure your code using these patterns and integrate best practices such as SOLID and KISS. By the end of this section, you will have a robust foundation for your Ordering microservices, ensuring scalability and maintainability.

Ordering.Domain Layer with Tactical Domain-Driven Design Patterns

In this module, we will focus on implementing tactical DDD patterns in the Ordering domain layer. You will develop rich-domain model entities, including order-related value objects and aggregates, and explore the concept of domain events. This section will provide you with a deep understanding of DDD’s tactical patterns, ensuring a well-structured and maintainable domain layer.

Ordering.Infrastructure Layer with EF Core Code First and SQL Server

In this module, we will develop the infrastructure layer for Ordering microservices using EF Core with the code-first approach. You will configure SQL Server and apply EF Core migrations, enabling seamless data storage. Additionally, we will explore EF Core interceptors for entity auditing and domain event dispatching. By the end of this section, you will have a fully functional and scalable infrastructure layer for your Ordering service.

Ordering.Application Layer with CQRS and MediatR

In this module, we will dive into the Ordering.Application layer, where we will implement CQRS using MediatR for managing commands and queries. You will learn how to combine CQRS with Event Sourcing for robust state management and implement domain event handlers. By the end of this section, you will be able to handle complex business logic and data retrieval with ease using CQRS and MediatR.

Ordering.API Layer Exposing Minimal API Endpoints with Carter and REPR Pattern

In this module, we will build the Ordering.API layer by exposing Minimal REST APIs using Carter. We will implement CRUD operations for order management, including create, update, and delete functionalities. Additionally, you will apply the REPR pattern to standardize responses and handle errors efficiently. By the end of this section, your Ordering API will be ready to interact seamlessly with other services and clients.

Microservices Async Communication with RabbitMQ & MassTransit for Checkout Order

In this module, we will explore the implementation of asynchronous communication between the Basket and Ordering microservices using RabbitMQ and MassTransit. You will learn how to use the Fan-Out Publish/Subscribe pattern to handle event-driven messaging and manage distributed transactions with the Saga pattern. This section will provide you with the tools to build scalable, resilient microservices that communicate effectively in an event-driven architecture.

Building API Gateways with YARP Reverse Proxy Applying Gateway Routing Pattern

In this module, we will focus on building an API Gateway using YARP, a powerful reverse proxy for routing traffic between microservices. You will learn how to apply the Gateway Routing pattern and configure YARP to forward requests efficiently. We will also cover rate limiting and exception handling to ensure a secure and optimized gateway. By the end of this section, you will have a fully functional API Gateway that streamlines access to your microservices.

Building Shopping Web Client Application with Refit HttpClientFactory Library

In this module, we will build a Shopping Web Client application that communicates with the YARP API Gateway using Refit, an HTTP client library. You will learn how to develop a rich user interface using Razor Pages, where users can browse products, add items to their cart, and complete orders. By the end of this section, your Shopping Web application will be fully integrated with the microservices architecture, providing a seamless user experience.

Thanks

In this final module, we take a moment to thank you for your dedication and participation throughout the course. This section will motivate you to continue applying the best practices you’ve acquired, ensuring your success in building scalable and efficient microservices. Best of luck as you apply these skills in your future projects!