Building Amazon Style Full Stack Microservices

Build a catalog microservice from scratch, including database seeding, commands, queries, handlers, and custom mappers, plus repository patterns for brand, product, and type.

Create a new blank solution named e-commerce, set up a catalog microservice with asp.net core web api using dotnet nine, and scaffold the initial microservice skeleton in the services folder.

Set up a catalog microservice in a structured solution, create a web api project, and apply clean architecture with mediator pattern, including queries, commands, handlers, repositories, and data.

Install and configure essential NuGet packages, including MongoDB drivers, Swashbuckle for ASP.Net Core, and mediator pattern, to enable document-based data access and API scaffolding in a full-stack microservices project.

Create a base entity to standardize id handling with ObjectId and MongoDB driver attributes, while wiring mediator patterns for commands and queries and preparing for swagger integration.

Create a product entity inheriting from the base entity, with name, summary, image, brand, product type, and a decimal 128 price plus created date audit fields.

Create product brand and product type as base entities with name properties, using Poco objects and base entity structure, then connect them to repositories and interfaces.

Define brand and type repositories with clear interfaces, exposing get all and get by id methods, and implement asynchronous data access for an amazon-style full-stack microservices architecture.

Create a catalog specification container with pagination, page size, page index, and optional filters like brand ID, type ID, search, and sort to power the full stack catalog repository.

Define a product repository interface with contract methods for retrieving all products, pagination, and filtering by name, brand, or type, plus create, update, and delete operations.

Create a generic pagination class with a type parameter and default and parameterized constructors, including page index, page size, count, and a read-only data collection for scalable product paging.

Implement a brand repository using a mongo client and config settings, reading the catalog db and brand collection to fetch all brands and support id-based filtering.

Implement a type repository using the ITypeRepository interface, reading the connection string from configuration, and performing async read all and by id operations on the MongoDB product types collection.

Create a MongoDB-based product repository with collections for products, brands, and types, implementing create, delete, get by id, get by brand/type, and regex name search.

Implements a product repository with a query builder and filters, applying catalog spec params for search, sort, and pagination to return a paginated product list.

Create a seed data workflow by organizing brand, type, and product collections in MongoDB, adding seed JSON assets, and writing the first database seeder to initialize the dataset.

Create a database seeder that initializes a fresh database, checks for existing collections at startup, and seeds brands, types, and products from json files.

Create a product dto to exchange data over the wire with apis, using cqrs mediators and dto mappers. Use record types for immutable, value-based equality and concise syntax.

Implement a get all brands query and its brand response using mediator pattern, choosing records for immutability, organizing in a responses folder, and ensuring serialization-friendly properties.

Implement a get all brands handler that retrieves all brands from the brand repository and maps them to brand response objects with custom extension methods, avoiding automapper.

Implement a get all types query and handler using the mediator pattern, retrieving type entities from the type repository and mapping them to a types response list.

Develop a get all products query and handler that fetches products via a repository with catalog spec params, maps entities to a storage-agnostic product response, and returns paginated results.

Implement get product by brand query and handler, using compact syntax for brand name, map products to product responses with a mapper, and return a list from the repository.

Learn how to implement a get product by ID query and its handler in a microservices architecture, wiring a product repository, ID parameter, and mapper to return a product DTO.

Implement get product by name query and handler to fetch products by name from the repository and map to a product response list.

Create a product using a command and handler by mapping a create product command to an entity, validating brand and type via repository, and returning a product response.

Design and implement an update product command and handler that returns a boolean, validates existing products, fetches brand and type by id, maps updates, saves changes, and handles not-found errors.

Create a delete product by id command and handler in a cqrs pattern, delete via IProductRepository, return a bool, and prepare frontend dto integration.

Implement a catalog api controller using the mediator pattern to handle get all products, get product by id, and get by name, with dto mapping and brand/type details.

Implement catalog controller actions for creating, deleting, and updating products via http post, http delete, and http put, using dto from body, mediator for commands, and proper responses.

Create catalog endpoints to fetch all brands and types, and products by brand via mediator queries returning brand, type, and product DTOs; wire into program.cs with dependency injection.

Configure program.css by registering string and datetime offset serializers, enable swagger and mediator integration, and set up scoped repositories for seed data in MongoDB on startup.

Configure launch properties by defining an 8000 series port, selecting 5001, enabling the swagger url and a catalogue profile for local runs, with docker file and MongoDB setup later.

Set up MongoDB with docker by pulling the latest image from Docker Hub, run in detached mode on port 27017 with admin Rahul and password 1234567.

Resolve a docker issue by running the solution, trusting SSL, removing MongoDB username and password, and debugging Swagger data fetch to ensure the API returns data.

Debug the pagination bug in the catalog by using page index instead of page size; verify data seeding via Swagger and endpoint testing.

Learn end-to-end API testing for post, put, and delete with swagger, fixing id mappings for brand and type, and resolving validation errors.

Fix the created date issue in the create product flow by adjusting the mapping to use the incoming date time offset and verify via post calls.

Build a basket microservice from scratch in the basket module, implementing mediator pattern, custom mappers, dtos, and a live controller, with dockerized mongodb and radius db for demos.

Create a basket microservice inside a new basket solution folder, set the project path to services/basket, and organize code using VS Code and a git pattern.

Create a scalable folder structure for a microservices project, adding folders for controllers, dtos, entities, mappers, handlers, queries, and responses. Extend the structure later as needed to support future features.

Install NuGet packages including Swashbuckle for swagger, radius via Microsoft extensions, Newtonsoft.Json for serialization, and mediator to establish the basket foundation.

Create the basket checkout entity with fields for username, total price, user and address details, and card information such as name, number, expiration, CV, plus payment method.

Create a shopping cart and its items linked to a user, modeling quantity, price, product ID, name, and image for a full stack microservice using Entity Framework.

Create the IBasket repository interface and folder structure, defining get basket by username, update basket with a shopping cart, and delete basket by username, as preparation for implementation.

Implement a basket repository backed by a distributed cache, with get, delete, and upsert operations that serialize the shopping cart to json for storage and retrieval by user name.

Create a get basket by username query that accepts a username and returns a shopping cart response, including shopping cart item response, using a record pattern.

Create shopping cart item response and shopping cart response record classes with fields for product id, name, quantity, price, and image; compute total price; use constructor chaining for safe defaults.

Create a get basket by username handler that fetches a shopping cart from a basket repository, handles null results, and maps items to a shopping cart response.

Create a basket mapper that converts a shopping cart into a shopping cart response with a static method, including username and shopping cart item response, using default and full constructors.

Fix the mapper issue by moving to a record with init-only properties, enabling immutability, value-based equality, and safer object initialization.

Implement a delete basket by username command and its handler, wiring a basket repository to remove a user’s cart and return unit through the mediator pattern.

Create a shopping cart command as a record and a basket DTO with product id, name, price, quantity, and image, returning a shopping cart response and preparing for the handler.

Create a shopping cart command handler with constructor injection, map commands to a domain cart, update the basket via the repository, and return the updated cart as a response.

Create a basket controller from scratch with api controller and mediator integration, exposing a get endpoint to fetch a basket by username and return a shopping cart dto using cqrs.

Create a shopping cart and item dto with username, items, and total price, and define the basket dto including product id, name, image, price, and quantity for the basket controller.

Create and expose post and delete basket endpoints for the api v1 basket. Handle create or update with a create shopping cart command and delete by user name via mediator.

Wire up program.cs with dependency injection for controllers and a basket repository, configure swagger and mediator, set up radius cache from app settings, then enable swagger and run the app.

Configure launch settings and ports, enable swagger, and build the dotnet app. Then set up Redis with Docker, run the container named radius, and verify the APIs.

Run a swagger demo to validate a full stack microservices flow, fix dependency injection with mediator in program.cs, test get/post/delete basket scenarios, and drill into catalog and product ID handling.

Fixing delete basket issue in Amazon style microservices, correcting delete by username flow, ensuring remove happens instead of refresh, verified with 200 responses and empty collection.

Develop a discount service from scratch using gRPC and protobuf over HTTP/2 binary serialization with duplex channels, triggered from the basket module to apply discounts.

Create and organize folder structures for a microservices project, including commands, queries, handlers, dtos, mappers, and repositories, and prepare to import NuGet packages for the discount service and web API.

Install NuGet packages for gRPC, dapper, protobuf, and Google API common photos, plus mediator to bootstrap discount microservices, using a lightweight ORM and avoiding Entity Framework Core.

Create a coupon entity by establishing an entities folder and defining id, product name, description, and amount, then set up repositories for checkout.

Define the IDiscountRepository interface with get discount, create discount, update discount, and delete discount operations for coupons. Implement the repository with a Dapper style backend and inline queries.

Implement a discount repository by fetching the database connection string via configuration, opening a PostgreSQL connection, and inserting a coupon with name, description, and amount using dapper.

Implement the delete method and update discount logic by reusing the connection, executing commands asynchronously, and handling product name and coupon data to ensure accurate discount updates.

Create a get discount query by adding a query class and a coupon dto in dtos pattern, returning coupon record with id, product name, description, and amount via the mediator.

Create a get discount query handler using a discount repository with positional parameters, returning a coupon dto and throwing an rpc exception when coupon for the product is not found.

Implement a get discount handler by creating a coupon mapper and coupon dto, mapping coupon properties, and validating input within a gRPC-driven microservice.

Create a static gRPC error helper to generate a validation exception with field violations, bad request, and Google status, serialized into trailers for robust client errors.

Implement a custom error handler in get discount handler, validate input by ensuring the product name is not empty, return validation errors, and prepare for create, delete, and update commands.

Create the discount command and handler, validate product name, description, and amount, and return a coupon DTO while leveraging the gRPC error helper for validation.

Extend the mapper with a to entity method to convert a create discount command into a coupon entity, persist it via the discount repository, and return the dto.

Create and implement the update discount command and its handler, including validations, mapping to a DTO, and repository interaction to update a discount and handle not found errors.

Create delete discount command and handler, validate product name via gRPC validation, delete discount through the repository, and return a boolean; ready for the database migration step next.

Refactor the solution folder structure to remove redundant nesting by moving assets under services, reload, rebuild, and validate that all APIs and swagger endpoints run correctly with Docker.

Create a db migration extension method to run at startup, open a postgres connection, apply a scripted table creation with logging, retry logic, and error handling for robust migrations.

Create the discount protobuf file to define the gRPC service with RPCs for get discount, create discount, update discount, and delete discount, including the coupon model requests and responses.

Create a discount service using binary http/2 serialization, no rest API, scaffolding a services folder, implementing protobuf-generated code with mediator to handle get discount queries and map dto to model.

Create discount command in the mapper, implement update and delete discount commands with their handlers using mediator and dto, and wire up everything in program.cs.

Implement dependency wiring in program.cs by enabling mediator with assembly scanning, register the discount repository, configure gRPC services, migrate the database, and map gRPC endpoints via routing.

Configure app settings to use postgres on localhost for development, then point to the discount db service in deployment, set admin credentials, enable http2, and prepare the launch profile.

Consume the discount module within the basket microservice to apply coupon discounts via a gRPC service and proto file, and validate coupons migration with Swagger-tested price updates.

Learn to consume discount microservices in a basket using gRPC in a .NET project, by installing the gRPC ASP.NET core package via NuGet, importing the proto, and generating the client.

Create a discount gRPC service by configuring a protobuf client, wiring it via constructor injection, and referencing the discount project for internal communication with the basket.

Configure the app settings to consume the gRPC service on port 8002, wire up program.cs to register the discount service, delete the unnecessary folder, and implement the required handler changes.

Inject the discount gRPC service into the shopping cart handler and apply discounts via gRPC calls for each item by subtracting the coupon amount from item price, update program.cs.

Register the discount gRPC service in program.cs, configure a gRPC client for the discount proto service, and wire configuration via URI to run PostgreSQL in Docker for integrated microservices.

Run a PostgreSQL database in docker, map port 5432, configure admin user and password, and verify with docker ps while aligning app settings to startup Postgres, Mongo, and basket service.

Diagnose and fix a dependency injection error in a microservices setup by registering ilogger for context. Validate a discount migration and test catalog, basket, and discount interactions.

Use docker exec to access the discount postgres container, verify the coupon table with select * from coupon, and confirm migration worked before testing the discount via swagger.

Test Swagger endpoints to verify existing APIs remain intact while validating discount logic in the basket microservice, applying coupons, and advancing toward the ordering module.

Explore building microservices for ordering with a consistent branching strategy, Docker compose backed by SQL Server, and testing endpoints for catalog, basket, discount, and ordering modules.

Create an ordering microservice by setting up a solution folder and an ASP.NET Core Web API project under services, naming it ordering, and preparing the project structure for subsequent videos.

Organize your folder structure for a full stack microservices project by creating commands, queries, handlers, dtos, entities, repositories, fluent validation behaviors, mappers, and extensions, while removing unnecessary files.

Install and configure essential nuget packages for a full stack microservices project, including fluent validation, dependency injection extensions, mediator, ef core sql server, dotnet tools, and swashbuckle.

Define a base abstract entity with id and audit properties, derive an order entity with user, address, and payment fields, and implement these entities in the repository.

Create a generic i async repository interface with async methods for get all, get by id, add, update, and delete, using expression trees for a base entity.

Create the order context in the data folder, add a orders dbset, and configure the entity in on model creating, with plans for the outbox pattern using Saga later.

Override save changes async in the DbContext to automatically set created date and by for added entities, and last modified date and by for modified entities, using the change tracker.

Extend the async base repository to implement IOrderRepository for order entities, adding a GetOrdersByUsername method and using a non-tracking dbcontext for performance.

Define an order dto as a positional record with fields for id, user name, total price, and payment method, and wire this dto into a query that returns it.

Create a get order list query and its handler that fetches orders by user name from the repository, maps them to order dtos, and returns the list.

Develop a static order mapper to convert an order into an order dto by mapping id, user details, totals, address, and payment fields, with null handling.

Create an update order command and handler, fetch by id async, throw order not found if missing, map updates, persist via repository, and log outcomes.

Create a map update function to convert an update order request into an updated order, mapping username, contact details, address, payment info, and handling order not found.

Create an order not found exception by extending application exception, adding a constructor with name and key, and returning a message that entity with name and key is not found.

Implement delete order command and its handler using a mediator pattern, fetching the order by id, handling not found exceptions, performing the delete via the repository, and logging the outcome.

Create a fluent validator for checkout order command to enforce not empty fields, max length, and valid formats like email and card details, extending the same to update order command.

Create a fluent validation for the update order command, validating ID is greater than zero and required properties, optionally adjusting props, and reusing checkout validator patterns.

Create a validation behavior middleware that runs fluent validators before a handler, collects validation results, throws a validation exception on failures, and proceeds to the next middleware on success.

Create an order context factory to supply EF with a design-time DbContext, read the connection string from appsettings.json, configure SQL Server, and prepare for migrations and seed data.

Implement an order context seed class with a static async seed method that seeds the database orders when none exist and logs progress.

Extend the host with a db extension to migrate the database context and seed data, using Polly for retry on SQL exceptions and logging for observability.

Register application services via a dedicated extension to the service collection in program.cs, configuring mediator and validators from the executing assembly and adding pipeline behaviors for dependency injection.

Set up infra services by configuring a DB context and repository registrations, reading the connection string from app settings, enabling SQL Server options with retry, and wiring them into program.cs.

Register services and middleware in the program file, enable swagger and endpoint explorer, wire infra and application services, perform database migration and seed the order context.

Create an API v1 orders controller that uses the mediator pattern to fetch orders by username, logging the fetch action and returning a list of order dto.

Create the checkout order endpoint, implement create order dto and checkout order command, map dto to command, send via mediator, and test with http post.

Launch a local SQL Server 2022 instance with Docker, update the dotnet ef tool, apply the initial migration, and verify the orders table via SQL Server Management Studio and Swagger.

Configure startup profiles and swagger for the ordering service, then test endpoints and validate payloads. Debug dto mappings to fix the address line and prepare for async pattern integration.

Explore the event bus messaging pattern in our infrastructure project, using RabbitMQ as the message broker and MassTransit to consume queued checkout messages from baskets, driving the ordering microservice.

Create a reusable infrastructure class library within an infrastructure folder, configuring an event bus with message types and events like basket created and basket checkout for a saga-based flow.

Implement a base integration event class for checkout events, including correlation id and creation date in UTC, with constructors for auto-generated and provided correlation IDs, to enable tracing across services.

Create a basket checkout event by inheriting from basket integration event, making fields nullable for backward compatibility, and adding an event bus constant for the basket checkout queue.

Install and reference NuGet packages for MassTransit to publish events to a message broker, and wire up the event bus messages in the basket API project.

Create the basket checkout command and its handler returning unit, and define the BasketCheckoutDTO with username, email, total price, address details, and card information.

Create a checkout basket command handler using mediator, publish a basket checkout event, fetch the basket by username, map to the event, and then delete the basket by username.

Create a basket checkout event mapper that converts a shopping cart DTO into a basket checkout event by mapping items (product id, name, price, quantity) and user totals for integration.

Extend the basket controller with an HTTP post checkout method that accepts a basket checkout DTO, delegates to a checkout basket command via mediator, and publishes to RabbitMQ.

Wire mass transit into the basket API by configuring mass transit in program.cs, using RabbitMQ as the message broker, and reading event bus settings from app settings.

Install NuGet packages for the ordering microservice, including MassTransit and MassTransit.RabbitMQ, then set up and implement the consumer library for the ordering API.

Implement a basket ordering consumer using mass transit to handle basket checkout events. Map messages to a checkout order command via a mediator, enabling correlation id logging across microservices.

Create a checkout order command mapper that converts a basket checkout event into a checkout order command, mapping user, address, and payment fields for transmission through message broker via mediator.

Register mass transit services in the ordering microservice, add a basket ordering consumer, and configure rabbit mq transport with the host address and basket checkout queue via app settings.

Spin up RabbitMQ containers with docker run and docker compose, access the RabbitMQ dashboard with guest/guest, and diagnose the failing basket API while other services run.

Explore a RabbitMQ demo that demonstrates a pub-sub messaging flow, from creating a basket and processing checkout to queuing and consuming messages in RabbitMQ, with API checks.

Learn the saga pattern for reliable cross-microservice transactions with the outbox pattern, publishing pending orders to a broker like RabbitMQ, then advancing to the payment module.

Understand the saga pattern as a sequence of local transactions across services, where each publishes an event and the next listens and reacts, using an outbox table and RabbitMQ.

Create the outbox message entity in the ordering microservice by extending the entity base, defining type, content, correlationId, occurredOn, processedOn, isProcessed, and error, and register it in the entities.

Extend the order table with an order status enum (pending, paid, failed) and associate it with the order entity. Track saga progression and mark paid after processing, updating the DbSet.

Extend the db context by overriding on model creating to map the outbox message table, define keys, indices, and required properties, and configure order status conversion for clear database values.

Extend the order repository to persist outbox messages within the same transaction, implement the outbox pattern, and save changes asynchronously via dbcontext.

Extend the checkout handler to emit an outbox message by mapping orders with an order mapper to outbox messages, using outbox message types and json serialization via Newtonsoft.Json.

Implement an outbox message dispatcher as a background service that deserializes JSON from pending messages and publishes order created events via IPublishEndpoint to RabbitMQ.

Create an order created event by defining its class, inheriting the base integration, and adding user name, total price, payment method, and order status; test via dispatcher and cli.

Wire up the outbox message dispatcher by registering it in the program file and hosting service so the background process can check the queue for pending messages and publish them.

Apply EF migrations to align the database schema with the application by adding an outbox table, running database update, and validating the new tables while starting the services.

Explore the outbox pattern demo by guiding you through end-to-end order creation, publishing an order created event via RabbitMQ, and tracking outbox processing and saga flow with live debugging.

Learn to wire a marker payment microservice to handle saga events: order created, payment completed, and payment failed, updating the order status to paid via RabbitMQ and a consumer.

Install and configure NuGet packages for the payment module, including MassTransit, MassTransit.RabbitMQ, and Swashbuckle.AspNetCore, then add a project reference and rebuild.

Create an order created consumer that implements i consumer with a logger, processes order created events by simulating payment, and publishes payment completed or failed events.

Wire up a consumer in the program file by configuring mass transit with RabbitMQ, defining event queues such as order created, payment completed, and payment failed, with swagger support.

Adjust app settings for the payment microservice, configure launch ports 8004 and 5004, remove unused http profile, and set startup projects to run background services alongside ordering.

Create a payment completed consumer that consumes payment events from rabbitmq via the event bus, updates the order status to paid using the order repository, and logs actions.

Implement a payment failed consumer that retrieves the order by id, performs a defensive null check, updates the order status to failed via the order repository, and logs the outcome.

Wire up the program file to register payment completed and payment failed consumers, configure rabbitmq bindings and receive endpoints, and test the end-to-end payment flow.

Experience a saga outbox pattern demo that validates end-to-end payment processing, outbox event tracking, and robust, reliable messaging across disconnected microservices via RabbitMQ and a payment consumer.

Access the identity module to register and log in ASP.NET users, secure APIs with JSON web token authentication, and verify bearer tokens while mapping ports for dual SQL servers.

Create an identity microservice by scaffolding a new asp.net core web api project, forming an identity solution, removing extra templates, and validating the build to ensure a functional authentication component.

Create an application user model by inheriting from identity user, implement an app identity DbContext, and configure dependency injection and EF Core with a connection string in Program.cs.

Set up app settings by configuring a secure identity connection string to the identity DB and implementing JWT-based bearer authentication with a 60-minute token lifetime.

Wire up the program file by configuring the db context with sql server, set up identity and authentication with jwt bearer, then enable swagger and map controllers.

Wire identity with ef store in the identity db, enable token providers, and configure jwt bearer authentication with issuer, audience, lifetime, and signing key validation, plus policy-based authorization and swagger.

Create a register dto with first name, last name, email, and password, and a login dto with email and password in the identity model. Implement these dtos in the controller.

Create an auth controller using api routing, inject user manager, config, and logger, and implement a register method that creates a user from a dto with a password.

Builds an authentication controller with a login http post, validates user by email and password, and issues a token with claims using a symmetric key, issuer, audience, and expires.

Update the properties launch settings by pinning the identity profile, removing extra profiles, enabling launch browser, and setting port 8005 with Swagger as the launch URL; then apply the migration.

Set up a docker container for sql server, map a new port 1434 for the identity db alongside the order db on 1433, then connect and prepare to apply migrations.

Learn how to set up and migrate the identity database for a full-stack microservices app using ef migrations, update the sql server, and validate registration and login.

demonstrates the identity module demo, including registering a user, logging in to obtain a token, and wiring authentication through the gateway to secure APIs across microservices.