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.

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.

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.

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.

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.

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 name query and handler to fetch products by name from the repository and map to a product response list.

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.

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

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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 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 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.