Mô tả

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

You will learn how to build Microservices on .Net platforms which used Asp.Net Web API, Docker, RabbitMQ, MassTransit, Grpc, Ocelot API Gateway, MongoDB, Redis, PostgreSQL, SqlServer, Dapper, Entity Framework Core, CQRS and Clean Architecture implementation with 24.5 hours fully upgraded videos.

You will develop e-commerce modules over Product, Basket and Ordering microservices with NoSQL (MongoDB, Redis) and Relational databases (PostgreSQL, Sql Server) with communicating over RabbitMQ Event Driven Communication and using Ocelot 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 Web API application

  • REST API principles, CRUD operations

  • MongoDB database connection and containerization

  • Repository Pattern Implementation

  • Swagger Open API implementation

Basket microservice which includes;

  • ASP.NET Web API application

  • REST API principles, CRUD operations

  • Redis database connection and containerization

  • Consume Discount gRPC Service for inter-service sync communication to calculate product final price

  • Publish BasketCheckout Queue with using MassTransit and RabbitMQ

Discount microservice which includes;

  • ASP.NET gRPC Server application

  • Build a Highly Performant inter-service gRPC Communication with Basket Microservice

  • Exposing gRPC Services with creating Protobuf messages

  • Using Dapper for micro-orm implementation to simplify data access and ensure high performance

  • PostgreSQL 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 DDD, CQRS, and Clean Architecture with using Best Practices

  • Developing CQRS with using MediatR, FluentValidation and AutoMapper packages

  • Consuming RabbitMQ BasketCheckout event queue with using MassTransit-RabbitMQ Configuration

  • SqlServer database connection and containerization

  • Using Entity Framework Core ORM and auto migrate to SqlServer when application startup

API Gateway Ocelot Microservice

  • Implement API Gateways with Ocelot

  • Sample microservices/containers to reroute through the API Gateways

  • Run multiple different API Gateway/BFF container types

  • The Gateway aggregation pattern in Shopping.Aggregator

WebUI ShoppingApp Microservice

  • ASP.NET Core Web Application with Bootstrap 4 and Razor template

  • Call Ocelot APIs with HttpClientFactory

  • ASPNET Core Razor Tools — View Components, partial Views, Tag Helpers, Model Bindings and Validations, Razor Sections etc.

Ancillary Containers

  • Use Portainer for Container lightweight management UI which allows you to easily manage your different Docker environments

  • pgAdmin PostgreSQL Tools feature rich Open Source administration and development platform for PostgreSQL

Docker Compose establishment with all microservices on docker;

  • Containerization of microservices

  • Containerization of databases

  • 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 90%+ 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.

Bạn sẽ học được gì

ASPNET Core Web API Development of Microservices

REST API Principles, CRUD Operations

Mongo DB and Redis NoSQL Database Connection on Docker

Entity Framework Core with SQL Server Database Connection on Docker

N-Layer implementation with Repository Pattern

Swagger Open API implementation

Consume Discount Grpc Service for inter-service sync communication to calculate product final price

Publish BasketCheckout Queue with using MassTransit and RabbitMQ

Build a Highly Performant inter-service gRPC Communication with Basket Microservice

Using Dapper for micro-orm implementation to simplify data access and ensure high performance

PostgreSQL database connection and containerization

Async Microservices Communication with RabbitMQ Message-Broker Service

Using RabbitMQ Publish/Subscribe Topic Exchange Model

Using MassTransit for abstraction over RabbitMQ Message-Broker system

Implementing DDD, CQRS, and Clean Architecture with using Best Practices

Developing CQRS with using MediatR, FluentValidation and AutoMapper packages

Consuming RabbitMQ BasketCheckout event queue with using MassTransit-RabbitMQ Configuration

Using Entity Framework Core ORM and auto migrate to SqlServer when application startup

Ocelot API Gateway Development of Microservices

Call Ocelot APIs with HttpClientFactory

The Gateway aggregation pattern in Shopping Aggregator

ASPNET Core Web Application with Bootstrap 4 and Razor template

Docker Compose Containerization of All Microservices

Use Portainer for Container lightweight management UI which allows you to easily manage your different Docker environments

pgAdmin PostgreSQL Tools feature rich Open Source administration and development platform for PostgreSQL

Yêu cầu

  • C# knowledge (generics, async/await, anonymous methods, action, predicate)
  • Aspnet basics knowledge
  • Docker basics knowledge

Nội dung khoá học

21 sections

Course Introduction

7 lectures
Introduction
09:47
Prerequisites, Source Code and Course Slides
02:49
Run the Final Application
06:15
Project Code Structure
03:53
Microservices Architectures, Patterns, Libraries and Best Practices in Course
03:39
Microservices Multi-Architectural Patterns (External vs Internal Architectures)
03:28
How to Follow the Course (The Course Flow and Way of Learning)
03:35

What are Microservices ?

10 lectures
What are Microservices ?
01:25
What is Microservices Architecture ?
01:49
Microservices Characteristics
02:22
Benefits of Microservices Architecture
02:42
Challenges of Microservices Architecture
02:46
When to Use Microservices Architecture - Best Practices
03:12
When Not to Use Microservices - Anti-Patterns of Microservices
02:42
Monolithic vs Microservices Architecture Comparison
02:38
The Database-per-Service Pattern - Polyglot Persistence
02:36
Decomposition of Ecommerce Microservices: Catalog, Basket, Discount and Ordering
06:54

Why .NET and What is new .NET 8 and C# 12 ?

6 lectures
Why .NET ?
03:08
Cloud-Native Development with .Net 8
03:29
.NET loves Containers and Microservices
03:43
What is new .NET 8 ?
02:40
What is new .C# 12 ? Primary Constructors, Collection Expressions, Inline Arrays
03:30
C# Top-level statements, Global usings, Pattern Matching
03:32

Asp.Net 8 for Microservice Development: Minimal APIs, DI, Routing and Docker

8 lectures
ASP.NET 8 for Microservice Development
03:20
Minimal APIs in ASP.NET Core
02:08
Create ASP.NET Core Web API for Single Microservice
05:46
Clear Project for Single Microservices: Setting Up a Minimal ASP.NET Web API
04:38
Todo Service: Create Minimal API with ASP.NET Core for Single Microservice
09:53
TEST - Todo Service: Create Minimal API w/ ASP.NET Core for Single Microservice
05:03
Containerize Microservices with Docker Containers, Images, and Registries
03:36
Containerize Todo Asp.Net Web API Microservice and Run Docker Profile
10:16

First Microservice: Catalog.API with Vertical Slice Architecture and CQRS

23 lectures
Introduction - Catalog.API with Vertical Slice Architecture and CQRS
04:59
Create New Github Repository For Our Microservice Project
01:28
Clone Github Repository and Create New Solution with Visual Studio
05:08
Create Asp.Net Web Api for Catalog.API Microservice
06:03
Set Port Numbers for Catalog.API Microservice - Modify Launch Settings
06:04
Domain Analysis of Catalog Microservices: Models, UCs, Rest Apis, Databases
05:13
Technical Analysis of Catalog Microservices: Architectures, Patterns, Libraries
05:33
Vertical Slice Architecture
04:39
Vertical Slice versus Clean Architecture
04:31
CQRS Design Pattern
03:13
Logical and Physical Implementation of CQRS Pattern
02:43
CQRS Design Pattern With MediatR Library (Logical CQRS Implementation)
04:26
Develop Catalog.API Microservices Creating Domain Entities
04:10
Develop Vertical Slice Feature Folder with CQRS and MediatR
04:09
Develop Feature Handler class with CQRS and MediatR
09:05
Create Abstraction on MediatR for CQRS - Command and Query separation
10:34
Create Abstraction on MediatR for CQRS - Command and Query separation - 2
08:26
Implement CQRS Abstractions ICommand into Vertical Slice Feature Handler class
06:56
Develop Create Product Endpoint with Minimal Apis and Carter
06:57
Develop POST Endpoint with Carter implements ICarterModule for Minimal Apis
04:14
Develop POST Endpoint with Carter implements ICarterModule for Minimal Apis - 2
06:32
Register MediatR and Carter libraries into Asp.Net Dependency Injection Service
03:41
Test Catalog API - CreateProduct POST Request - Debug Carter Minimal API and Med
09:54

Develop Catalog.API Infrastructure, Handler and Endpoint Classes for CRUD

26 lectures
Introduction - Develop Catalog.API Infrastructure, Handler and Endpoint Classes
01:07
Infrastructure - Data Concerns for Catalog API - Marten .NET Transactional DB
03:22
Opening Sessions in Marten as Document DB
03:20
Develop CommandHandler to Save Product to DB using Marten Library
06:24
Register and Configure Marten DocumentDB library into Program.cs asp.net DI
03:47
EShop Microservices Deployment Strategy
02:58
Setup PostgreSQL DB using Docker-compose file for Multi-container Docker env
04:19
Add PostgreSQL DB image into Docker-compose file for Multi-container Docker env
06:30
Run Docker-Compose on Visual Studio to setup PostgreSQL DB on Docker
05:50
Connect Postgres DB from local Catalog Microservices and send POST request
06:33
Develop GetProducts Feature in Vertical Slice with CQRS, MediatR in Handler clas
06:42
Develop GetProducts GET Endpoint with Minimal Apis and Carter
05:52
Test GetProducts Endpoint Connecting to Docker Postgres Container
05:13
Create Postman Collection for EShop Microservices
09:25
Develop GetProductById Handler with CQRS and MediatR
06:33
Develop GetProductById GET Endpoint with Minimal Apis and Carter
03:46
Test GetProductById Endpoint Connecting to Docker Postgres Container
03:04
Develop GetProductByCategory Handler with CQRS and MediatR
04:01
Develop GetProductByCategory GET Endpoint with Minimal Apis and Carter
03:26
Test GetProductByCategory Endpoint Connecting to Docker Postgres Container
02:14
Develop UpdateProduct Handler with CQRS and MediatR
05:30
Develop UpdateProduct PUT Endpoint with Minimal Apis and Carter
04:51
Test UpdateProduct Endpoint Connecting to Docker Postgres Container
03:55
Develop DeleteProduct Handler with CQRS and MediatR
04:12
Develop DeleteProduct DELETE Endpoint with Minimal Apis and Carter
03:56
Test DeleteProduct Endpoint Connecting to Docker Postgres Container
04:53

Develop Catalog.API Cross-cutting Concerns

21 lectures
Introduction - Develop Catalog.API Cross-cutting Concerns
00:40
MediatR Pipeline Behaviours and Fluent Validation Library
04:04
Add Cross-cutting Concerns into BuildingBlocks Class Library for all services
03:00
Cross-cutting Concerns: Validate with AbstractValidator using Fluent Validation
09:52
Validation Pipeline Behaviour with MediatR using Fluent Validation Library
08:42
Remove Manual Validator and Test Validation Pipeline Behaviour with MediatR
05:39
Develop CRUD Command Validators with Fluent Validation Pipeline Behaviour
05:05
Global Handling Exceptions in ASP.NET Core with app.UseExceptionHandler
04:49
BuildingBlocks Handling Exceptions Generic Way w/ app.UseExceptionHandler
05:46
Global Exception Handling with IExceptionHandler interface in Asp.net Core
09:13
Register Custom Exception Handling into Asp.net with AddExceptionHandler method
05:03
Logging Behavior in MediatR Pipeline for Cross-cutting concerns
06:02
Test Logging Behaviour for all MediatR Requests on Catalog.API microservices
06:52
Seeding CatalogDb with Marten Initial Baseline Data (IInitialData interface)
08:57
Test Seeding Initial Data with Marten on PostgresDB for Catalog.API microservice
05:07
Develop Pagination for GetProducts Query with ToPagedListAsync extention method
05:36
Test Pagination for GetProducts Query with ToPagedListAsync extention method
03:46
Health Check for Catalog Microservices with PostgresDB
07:31
Containerize Catalog.API microservices with Docker
02:44
Orchestrate Catalog.API microservices with Docker-compose file
05:54
TEST - Docker-compose Catalog.API microservices with PostgresDB
07:08

Basket Microservices with Vertical Slice Architecture and CQRS

25 lectures
Introduction - Basket Microservices with Vertical Slice Architecture and CQRS
02:05
Create Asp.Net Web API for Basket.API Microservice in Microservices Solution
03:24
Set Port Numbers for Basket.API Microservice - Modify Launch Settings
02:30
Domain Analysis of Basket Microservices: Models, UCs, Rest Apis, Databases
04:18
Technical Analysis of Basket Microservices: Architectures, Patterns, Libraries
04:13
Develop Basket.API Microservices Creating Domain Entities
02:37
Develop Vertical Slice Feature Folder with CQRS and MediatR
03:08
Develop GetBasket Feature Handler class with CQRS and MediatR
05:08
Develop Get Basket Endpoint with Minimal Apis and Carter
05:33
Develop StoreBasket Feature Handler class with CQRS and MediatR
06:28
Develop Store Basket Endpoint with Minimal Apis and Carter
02:46
Develop DeleteBasket Feature Handler class with CQRS and MediatR
02:43
Develop Delete Basket Endpoint with Minimal Apis and Carter
01:45
Register MediatR and Carter libraries into Asp.Net Dependency Injection Service
04:05
Test Basket API - GET and POST Basket Request - Debug Carter Minimal API
06:29
Infrastructure - Data Concerns for Basket API - Marten .NET Transactional DB
02:13
Develop BasketRepository Class using Marten Library
04:35
Implement IBasketRepository Class using Marten IDocumentSession interface
06:20
Register and Configure Marten DocumentDB library into Program.cs asp.net DI
04:35
Setup PostgreSQL DB for Basket ms using Docker-compose file for Multi-container
04:42
Run Docker-Compose on Visual Studio to setup PostgreSQL DB on Docker
03:07
Develop Basket Features in CQRS Handler classes using BasketRepository
05:54
Connect Postgres DB from local Basket Microservices and send POST request
04:42
TEST Basket Microservices Endpoints connecting with Marten and Postgres DB
04:07
Exception Handling in Basket Microservices
04:06

Basket Microservices apply Distributed Caching with Redis

15 lectures
Distributed Caching with Redis in Basket Microservices
02:27
Cache-aside Pattern in Microservices / Cache Invalidation
03:28
Proxy Pattern, Decorator Pattern and Scrutor Library
03:32
Develop CachedBasketRepository with Proxy Pattern, Decorator Pattern and Scrutor
03:11
Develop CachedBasketRepository with Proxy Pattern, Decorator Pattern and Scrutor
08:39
Register Decorated CachedBasketRepository and StackExchangeRedis with Scrutor
05:29
ECommerce Microservices Deployment Strategy
02:09
Setup Redis as a Distributed Cache using Docker-compose file for Multi-container
02:29
Run Docker-Compose on Visual Studio to setup Redis Distributed Cache on Docker
03:42
Configure docker-compose launch settings - Not open browser for microservices
03:15
Connect Redis Cache from local Basket Microservices and send GET request
08:07
Health Check for Basket Microservices with PostgresDB and Redis Cache
07:01
Containerize Basket.API Microservices with Docker
02:07
Orchestrate Basket.API Microservices with Docker-compose file
06:11
TEST - Docker-compose Basket.API microservices with PostgresDB and Redis
07:24

Microservices Synchronous Communications with gRPC

5 lectures
Microservices Communication Types: Synchronous or Asynchronous Communication
02:29
Microservices Synchronous Communications and Best Practices
01:16
gRPC: High Performance Remote Procedure Calls
01:33
How gRPC works ?
01:06
gRPC Usage in Microservices Communication
01:58

Discount.Grpc Microservices for Microservices Grpc Communication

20 lectures
Introduction - Discount.Grpc Microservices for Microservices Grpc Communication
03:05
Create Asp.Net Grpc for Discount Microservices in Microservices Solution
10:22
Domain Analysis of Discount Microservices: Models, UCs, Rest Apis, Databases
02:51
Technical Analysis of Discount Microservices: Architectures, Patterns, Libraries
03:16
Develop Discount.API Microservices Creating Domain Entities
00:59
Develop discount.proto ProtoBuf file for Exposing Crud Services in Discount Grpc
04:04
Generate Proto Service Class from Discount proto File in Discount Grpc service
03:28
Develop DiscountService class to Implement Grpc Proto Service Methods
03:01
Configure DiscountGrpc Service to Request Pipeline in Program.cs and Invoke Grpc
04:59
Entity Framework Core and SQLite Database Connection in Discount Microservices
05:07
Create SQLite Database using Entity Framework Core Tools in Discount service
05:16
Seed and Auto-Migrate SQLite Database using Entity Framework Core in Discount
05:53
TEST - Seed and Auto-Migrate SQLite Database using Entity Framework Core
04:07
Develop DiscountService class to Implement Grpc Proto Service Methods
08:18
Develop CreateDiscount in DiscountService class to Implement CRUD Grpc Proto
05:53
Develop UpdateDiscount in DiscountService class to Implement CRUD Grpc Proto
02:37
Develop DeleteDiscount in DiscountService class to Implement CRUD Grpc Proto
03:48
Containerize Discount.Grpc microservices with Docker
01:26
Orchestrate Discount.Grpc microservices with Docker-compose file
03:13
TEST - Docker-compose Discount.Grpc microservices with SQLite
06:41

Consuming Discount Grpc Service From Basket Microservice When Adding Cart Item

8 lectures
Introduction - Consuming Discount Grpc Service From Basket Microservice
02:14
Consuming Discount Grpc Service From Basket Microservice When Adding Cart Item
06:14
Consuming Discount Grpc Service From Basket API Microservice When Adding Cart -2
03:50
Register Discount Grpc Client and Discount Grpc Service into the Basket.API
04:11
Test and Run Discount Grpc and Basket Microservice
07:16
Add Grpc DiscountUrl Configuration in Basket.API image configuration on Docker
04:37
Test on Docker environment - Basket.API communicate with Discount.Grpc in Docker
05:00
Test on Docker - Basket.API communicate with Discount.Grpc in Docker - Part 2
02:06

Ordering Microservices with DDD, CQRS and Clean Architecture

13 lectures
Introduction - Ordering Microservices with DDD, CQRS and Clean Architecture
03:28
Create Asp.Net Web Api for Ordering.API Microservice in Microservices Solution
04:39
Domain Analysis of Ordering Microservices: Models, UCs, Rest Apis, Databases
04:08
Technical Analysis of Ordering Microservices: Architectures, Patterns, Libraries
04:34
SOLID, KISS, YAGNI, SoC, DIP - Common Principles
03:22
Apply DDD, CQRS and Clean Architecture patterns in Ordering microservice
02:31
Domain Driven Design - DDD
03:25
Clean Architecture
03:44
Clean Architecture with Domain Driven Design(DDD)
08:26
Code Structure on DDD and Clean Architecture Layers in Ordering Microservices
02:12
Create Clean Architecture Layers: Domain, Application, Infrastructure and API
02:56
Adding Project References Between Clean Architecture Layers
03:49
Adding Dependency Injections Between Clean Architecture Layers
10:29

Ordering.Domain Layer with Tactical Domain-Driven Design Patterns

12 lectures
Tactical Domain-Driven Design: Entities, Value Objects, Aggregates, Agg. Roots
04:55
Develop DDD Abstractions (Entity, Aggregate, DomainEvent) in Ordering.Domain
11:16
Domain Modeling with Tactical DDD for Ordering Microservices
03:44
Develop Domain Modeling with DDD for Ordering Microservices
11:43
Primitive Obsession and Strongly typed IDs in DDD
02:58
Develop Strongly typed IDs for Order Entities
07:20
Anemic-domain vs Rich-domain Model Entities Entities in DDD
03:58
Develop DDD Rich-domain model Entity for Order Entities in Order.Domain Layer
06:25
Develop ValueObjects (Address, Payment) DDD Rich-domain model Entity
07:45
Develop DDD Rich-domain model for Order Entities in Order.Domain Layer
10:29
Domain Events in DDD and Domain vs Integration Events
05:49
Develop Order Created and Updated Domain Event in Ordering Microservices
04:04

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

25 lectures
Develop Ordering.Infrastructure Layer with EF Core Code First Approach
02:50
EF Core 8 Features, Code First Approach, Migrations and SQL Server Connection
03:06
Steps of EF Core Developments for Ordering.Infrastructure
05:33
Install EF Core Nuget Packages in Ordering.Infrastructure
02:20
Develop EF Core DBContext Object for Storing Entities in Ordering.Infrastructure
06:18
Mapping DDD Objects to EF Entities - Develop EF Core Entity Configurations
07:48
EF Core 8 Relations and DDD ValueObject Mapping with ComplexType and ComplexProp
02:48
Mapping DDD Objects to EF Entities - Develop Order Entity Configurations
09:38
EF Core SQL Server Connection String in appsettings.json file
02:18
Register EF Core DbContext in Asp.Net DependencyInjection Tool for SQL Server
04:03
Create EF Core Migrations for ApplicationDbContext in Ordering.Infrastructure
05:40
Create EF Core Migrations for ApplicationDbContext in Ordering.Infrastructure -2
08:07
Setup SQL Server DB using Docker-compose file for Multi-container Docker Env
03:29
Run Docker-Compose on Visual Studio to setup SQL Server DB on Docker
03:24
Apply EF Core Migrations to SQL Server DB with Update-Database Command
03:14
Auto Migrate EF Core Entities to SQL Server when Application Startup w/ Coding
06:56
Seed SQL Server OrderDb using EF Core when Application Startup with Coding
05:53
Seed Product and Orders in SQL Server OrderDb using EF Core when App Startup
05:25
Run Order Microservices to Migrate and Seed OrderDb in SQL Server using EF Core
06:25
EF Core Interceptors: SaveChangesInterceptor for Auditing Entities
03:17
Develop SaveChangesInterceptor to Auditing Entities for Order Entities
08:58
Run&Test Order Microservices for Audit with EF Save Changes Interceptor
04:38
Dispatch Domain Events w/ EF Core SaveChangesInterceptor
04:10
Develop DispatchDomainEventsInterceptor to Trigger Domain Event Handlers
10:49
Run&Test Order Microservices for Dispatch DomainEvents with EF Save Changes
06:01

Ordering.Application Layer with CQRS and MediatR

22 lectures
Develop Ordering.Application Layer with CQRS and MediatR implement the Command
01:54
CQRS (Command Query Responsibility Segregation) Pattern in Ordering microservice
03:12
Event Sourcing Pattern
02:13
CQRS with Event Sourcing Pattern
01:59
Eventual Consistency Principle
02:28
Analysis of Ordering Microservice Application Layer
02:49
Implement CQRS Command and Command Handler Patterns with MediatR
04:34
Develop Ordering.Application Folder Structure for CQRS
03:19
Develop Dto Classes for Orders in Ordering.Application Layer
04:59
Develop Orders CreateOrderCommand and Handler in Ordering.Application Layer
07:08
Develop IApplicationDbContext for injection EFCore DB Context object in Ordering
07:29
Develop Orders CreateOrderCommandHandler using IApplicationDbContext in Ordering
06:19
Develop Orders UpdateOrderCommand and Handler using IApplicationDbContext
09:00
Develop Orders DeleteOrderCommand and Handler using IApplicationDbContext
06:41
Develop MediatR Pipeline Behaviours (Validation, Logging) in Ordering.App
04:20
Develop Domain Event Handlers with MediatR INotificationHandler in Ordering.App
06:20
Develop Domain Event Handlers with MediatR INotificationHandler in Ordering.App
04:41
Develop Order Queries with CQRS and MediatR in Ordering.Application Layer
09:02
Develop Extention method for ProjectToOrderDto use in GetOrders Methods
04:54
Develop GetOrdersByCustomer Queries w/ CQRS and MediatR in Ordering.Application
04:45
Develop Pagination Class for Query GetOrders using CQRS and MediatR
04:06
Develop GetOrders Query apply Pagination using CQRS and MediatR in Ordering.App
06:24

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

17 lectures
Develop Ordering.API Layer with Exposing Minimal REST APIs w/ Carter
03:54
Analysis the Ordering.API layer in Clean Architecture
02:09
Program.cs and Dependency Injection class in Ordering.API Layer
03:13
Developing Order Endpoints for REST APIs in Ordering.API Layer
05:34
Developing CreateOrder Endpoint for REST APIs in Ordering.API Layer
07:04
Developing UpdateOrder Endpoint for REST APIs in Ordering.API Layer
03:28
Developing DeleteOrder Endpoint for REST APIs in Ordering.API Layer
03:04
Developing GetOrdersByName Endpoint for REST APIs in Ordering.API Layer
02:40
Developing GetOrdersByCustomer Endpoint for REST APIs in Ordering.API Layer
02:35
Developing GetOrders Endpoint w/ Pagination for REST APIs in Ordering.API Layer
04:54
Testing Ordering.API Endpoints with CQRS and Clean Architecture Layers
06:23
Test Create Order Endpoint with CQRS and Clean Architecture Layers in Ordering
12:33
Test Update Order Endpoint with CQRS and Clean Architecture Layers in Ordering
06:27
Test Get Order Endpoints with CQRS and Clean Architecture Layers in Ordering
11:25
Test Delete Order Endpoint with CQRS and Clean Architecture Layers in Ordering
02:34
Cross-Cutting Concerns Custom Exception Handler in Ordering Microservice
04:36
Health Checks for Ordering Microservices with EF.Core and SQL Server
06:41

Microservices Async Communication w/ RabbitMQ & MassTransit for Checkout Order

35 lectures
Introduction - Microservices Async Communication w/ RabbitMQ & MassTransit
02:59
Microservices Asynchronous Communication
03:20
Benefits of Asynchronous Communication
02:14
Challenges of Asynchronous Communication
01:42
Fan-Out Publish/Subscribe Messaging Pattern
02:44
Event-Driven Microservices Architecture
01:56
What is RabbitMQ and Main Components of RabbitMQ (Producer, Queue, Consumer..)
02:36
RabbitMQ Exchange Types: Direct, Fanout, Topic, and Headers
02:04
Domain Analysis of Async Communication between Basket and Ordering Microservices
03:45
Technical Analysis of Async Communication between Basket and Ordering ms
05:11
Steps of Developing Async Communication between Basket and Ordering Microservice
01:52
Create BuildingBlocks.Messaging Shared Class Library for Common Async connection
02:36
Develop BasketCheckout Event in BuildingBlocks.Messaging Shared Class Library
02:56
Develop MassTransit Extention Methods to Register RabbitMQ connection into DI
04:48
Develop MassTransit Extention Methods to Register RabbitMQ connection into DI -2
03:39
Publish BasketCheckout Event from Basket Microservices
05:04
Develop BasketCheckout Feature Folder to Expose POST Endpoint and Publish Event
06:43
Develop Basket Checkout Handler Method to Publish event to RabbitMQ-MassTransit
09:09
Dual-write Problem and Outbox Pattern
05:06
Ordering Microservices to Subscribe-Consume BasketCheckout event from RabbitMQ
04:11
Register MassTransit RabbitMQ packages into Ordering.Application DI
04:20
OrderCreated Integration Event: How Domain Event leads to Integration Event
04:32
Develop Basket Checkout Event Consumer integration event handler class
03:53
Develop Basket Checkout Event Consumer integration event handler class - 2
07:47
Saga Pattern for Distributed Transactions
04:38
Publish OrderCreated Integration event for Order Fullfiment microservices
07:31
Aspnet Feature Management Develop Feature Flag for OrderCreated Event
07:23
Setup RabbitMQ for Async Communication using Docker-compose file
05:33
Run Docker-Compose on Visual Studio to setup RabbitMQ on Docker
03:59
TEST- Publish BasketCheckout Event in Basket.API Microservices
13:56
TEST- Subscribe/Consume BasketCheckout Event in Ordering.API Microservices
16:53
TEST- Set OrderFullfilment feature = false. Re-Test Publish - Subscribe/Consume
03:19
Containerize and Configure Basket, Ordering and RabbitMQ Containers
04:37
Containerize and Orchestrate Ordering microservices with Docker & Docker-Compose
07:08
TEST- Docker-Compose Microservices - Publish/Subscribe BasketCheckout Event
12:06

Building API Gateways with Yarp Reverse Proxy applying Gateway Routing Pattern

19 lectures
Introduction - API Gateways with Yarp Reverse Proxy
03:04
Gateway Routing Pattern
02:19
API Gateway Pattern
02:46
Main features in the API Gateway Pattern
02:40
BFF Backend for Frontend Pattern
02:17
YARP Reverse Proxy for API Gateway
05:32
YARP Architecture with pipeline and Extensibility
03:27
Domain Analysis of YarpApiGateway Microservices: Models, UCs, Rest Apis,Database
04:57
Technical Analysis of YarpApiGateway Microservices: Architectures, Patterns
02:48
Create YarpApiGateway Microservices into ECommerce Solution
05:00
Develop Yarp Reverse Proxy in YarpApiGateway Microservices
07:24
Implement API Gateway using Yarp Reverse Proxy in YarpApiGateway Microservices
06:28
Implement API Gateway using Yarp Reverse Proxy in YarpApiGateway Microservices-2
05:31
TEST - Yarp Reverse Proxy as an API Gateway in YarpApiGateway Microservices
06:54
Rate Limiting to Yarp Reverse Proxy as an API Gateway in YarpApiGateway
05:55
Move Local Test Configuration to Local appsettings.json file-Yarp Reverse Proxy
03:30
Develop Yarp appsettings.json file Configurations for Docker Host Network
03:52
Containerize and Orchestrate YarpApiGateway Microservices for Reverse Proxy
04:43
TEST on Docker-Compose - Yarp Reverse Proxy as an API Gateway in YarpApiGateway
07:16

Building Shopping Web Client Application with Refit HttpClientFactory Library

31 lectures
Introduction - Shopping Web Client Application with Refit HttpClientFactory
03:45
Background of Project
02:26
Domain Analysis of Shopping.Web Microservices
02:17
Technical Analysis of Shopping.Web Microservices
02:51
Developing Shopping Web Application Microservices
05:55
Create Catalog Models for Shopping Web Application Microservices consume YarpApi
05:52
Create Basket Models for Shopping Web Application Microservices consume YarpApi
09:15
Create Ordering Models for Shopping Web Application Microservice consume YarpApi
05:37
Develop Service Classes for consume YarpApiGateway
04:50
Refit HttpClientFactory Library: The automatic type-safe REST library
03:05
Install and Configure Refit HttpClientFactory Library in our Shopping.Web ms
02:59
Develop ICatalogService Classes with Refit HttpClientFactory Library
04:12
Develop IBasketService Classes with Refit HttpClientFactory Library
05:58
Develop IOrderingService Classes with Refit HttpClientFactory Library
03:31
Build Presentation Layer: Asp.Net Web Application Razor Pages w/ AspNetRunBasics
10:31
Develop Index html Pages and cs files with Shared Partial Product pages
05:31
Develop Index C# Page Consume YarpApiGateway Endpoints with ICatalogService
07:58
AddToCart Submit Handle in Index cshtml Page with IBasketService
09:08
Develop Cart Razor Page in Shopping.Web Application
02:20
Develop Cart C# Page and Consume YarpApiGateway Endpoints with IBasketService
06:10
Develop ProductList Razor Page in Shopping.Web Application
03:28
Develop ProductList C# Page and Consume YarpApiGateway Endpoint w IBasketService
08:02
Develop ProductDetail Razor Page in Shopping.Web Application
01:57
Develop ProductDetail C# Page and Consume YarpApiGateway Endpoints
03:20
Develop Checkout and Confirmation Razor Page in Shopping.Web Application
03:45
Develop Checkout and Confirmation C# Page and Consume YarpApiGateway Endpoints
07:04
Develop OrderList and Contact Razor Page in Shopping.Web Application
03:54
Develop OrderList C# Page and Consume YarpApiGateway Endpoints w/ IBasketService
04:42
TEST - Shopping.Web Client Application using YarpApiGateway Microservices
14:03
Containerize and Orchestrate Shopping.Web Application in Docker-Compose
04:50
TEST on Docker-Compose - Shopping.Web Application consumes YarpApiGateway
05:35

Thanks and Bonus Lecture

2 lectures
Thanks
00:58
Bonus Lecture
00:28

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.