.Net MVC-Docker & Microservice Architecture Project Building

Start building a microservice architecture for a virtual marketplace using .NET, Docker, and MongoDB, and learn to implement REST APIs, GitHub collaboration, and cloud deployment.

Create and organize a product microservice and its web API from the command line with PowerShell, building a .NET solution, adding projects, and managing folders step by step.

Explore MongoDB as a NoSQL, document-based database that uses collections instead of tables. Compare its fluid schema and scalable read and write performance to traditional relational systems.

Build a product microservice with a dedicated product controller and product entity, and integrate MongoDB using the MongoDB driver NuGet package, preparing for Docker-based deployment and API gateway–driven UI communication.

Explore how Docker uses images and containers to package applications, define multi-container services with Docker Compose, and manage networks and volumes for scalable, portable deployments in microservice architectures.

Pull and run a MongoDB docker image locally, map ports, and configure a product database with a connection for local development in a .NET mvc docker project.

Implement a MongoDB context for product content, wiring the product context interface to MongoDB clients, settings, and the database collection.

Learn the differences between synchronous, asynchronous, and multithread programming, with examples and guidance on when to apply each approach in software development.

Learn how to implement a MongoDB-backed product repository. Define interfaces, inject a product context, and build asynchronous CRUD operations (insert, get by name/category, update, delete) for a robust data layer.

Add get, create, and update actions to the product controller by wiring in a product repository and implementing asynchronous methods that return action results.

Add test swagger to a .NET MVC docker microservice project, configure swagger integration, expose CRUD operations, and validate endpoints with Postman for reliable API testing.

Dockerize and publish our project by configuring container orchestration, wiring up MongoDB, adjusting Docker Compose and YAML, exposing ports on localhost, and deploying the microservice.

Explore building the main microservice with MongoDB integration, rest api connections, and OpenAPI implementations, while designing the architecture and service sourcing for a multi-service net mvc docker project.

Create the main microservice ASP.NET Core web API project, wire auction bids in MongoDB via a dedicated API controller, and clarify controller base versus controller architecture for a scalable service.

Explore ASP.NET Core Web API project architecture and code structure, detailing microservice data flow with MongoDB, layers (presentation, business, data access), repositories, cross-cutting concerns, and clean folder organization.

Create the entity models and folder structure for an ASP.NET Core web API, detailing products, auctions, sellers, and collections, with MongoDB or relational database considerations.

Learn to implement appsettings.json and settings in a .NET microservice, configuring a MongoDB data context via dependency injection in startup, using a singleton settings service.

Develop a data context class to access MongoDB collections, such as auctions, through a dependency-injected interface. Configure startup settings with the connection string to localhost to enable service-layer data access.

Build a MongoDB backed data access layer with auction and bid repositories, implementing CRUD methods and GetByAuctionId and GetWinnerBid via dependency injection, and wire complete auction workflows with RabbitMQ.

Enhance the business layer by building repositories and async CRUD operations for auction and bid data in MongoDB, with GetByAuctionId and GetWinnerBid workflows, via dependency injection and RabbitMQ events.

Implement get auction by id and name filters on the mongo auction collection, return results, and perform update via replace; wire repository pattern through dependency injection for CRUD.

Develop and wire the business layer with dependency injection, repository interfaces, and service methods to manage auction bids, determine winners, and integrate with the presentation layer in a microservice context.

Enhance the presentation layer with API controllers, services, and repositories for auction operations. Implement async get, post, and update actions and OpenAPI swagger documentation for typed, secure responses.

Expose auction endpoints in the presentation layer to show winning bids and record submissions asynchronously, using optional results and a produce response type for APIs like /api/v1/bits.

Add swagger in the ASP.NET Core Web API to document and test endpoints. Configure startup and middleware, and expose sourcing and auction methods via swagger UI for testing, including docker.

Implement and test an ASP.NET Core web API with OpenAPI and Swagger, running a dockerized MongoDB, seeding data, and validating get, update, and delete operations via Swagger.

Create a Dockerfile and Docker Compose setup to containerize microservices and enable their communication in a .NET MVC-Docker project. Utilize product and sourcing services with MongoDB for scalable API-driven architecture.

Update the docker compose file to stand up containerized microservices, including the product service and source API, connected to MongoDB. Configure networking and ports to ensure cross-service communication.

Configure Docker Compose to run the sourcing service and product API, managing images, containers, networks, volumes, and ports on a local machine for a connected microservice architecture.

Implement asynchronous microservice communication using RabbitMQ, with producers and consumers linked to sourcing and order APIs, to build a reliable event-driven architecture and infrastructure.

Choose between synchronous and asynchronous communication in a microservice architecture. Design for single or multiple receivers using appropriate protocols and a message broker to keep services isolated.

Download RabbitMQ and host it on Docker to enable asynchronous messaging in a microservice architecture. Configure RabbitMQ as the message broker in Docker and manage ports.

Create a RabbitMQ library within a .NET MVC Docker microservice project by establishing a clear folder structure, defining interfaces, and implementing connection operations in the service.

Develop a robust RabbitMQ connection class by defining a connection interface and a connection factory, with disposable patterns, circuit breaker policies, and a policy-driven management for microservice communication.

Develop a robust RabbitMQ connection class that manages connection attempts with progressive delays, supports connect and disconnect workflows, disposal, and a connection factor property for operation control.

Explore RabbitMQ event development by modeling an abstract event base, handling order and auction events, and triggering actions such as email alerts within a microservice architecture.

Build a RabbitMQ producer by defining a producer class, establishing a connection, and implementing a policy-based publish flow to send messages to a queue via a channel, with dependency injection.

Add the EventBus library to the sourcing web api project to enable event-driven communication for auction events, publish and handle bids, and notify microservices.

Implement the event bus startup by configuring a connection factory and integrating a dependency injection model on startup, defining a singleton connection and producers to publish live events.

Implement the event bus startup in a .NET mvc docker microservice project by wiring configuration properties, including username and password, for secure event hosting. Leverage dependency injection.

Develop the complete auction method using EventBus library methods within a .net mvc docker microservice architecture project, triggering auctions, publishing events, validating inputs, and creating orders.

Install AutoMapper and the Microsoft dependency injection package, configure startup, and define mapping profiles to map source objects to destination objects in the .NET MVC Docker microservice project.

Develop and test event-driven communication via the event bus, publish test events with a dummy producer, and monitor results on the RabbitMQ dashboard.

Develop event bus tests with RabbitMQ and monitor the dashboard. Configure containers and ports, publish and consume messages, and validate broker, exchange, and queue connectivity.

Update docker compose file to enable local testing of microservice architecture, detailing network setup and port mappings. Ensure container dependencies and overrides support reliable communication with the sourcing group api.

Execute docker compose to bring up the sourcing api and its containers, verify port 8001 and api connectivity, and review dashboards and queues to confirm successful setup.

Develop the order microservice with an ASP.NET Core Web API, CRUD on SQL Server hosted by docker-compose, using EF Code First, CQRS with MediatR, in a clean architecture and Swagger.

Create the order microservice web API in a new ASP.NET Core project named ESourcing.Order, using api/v1 routing and an ApiController. The session previews clean architecture and CQRS before coding.

Create domain, application, and infrastructure layers as dotnet core class libraries under the e-sourcing order microservice, aligning with clean architecture.

Update the application domain and infrastructure libraries of the order microservice from dotnet core 3.1 to net5.0 within a clean architecture design pattern.

Develop the domain layer by creating an entities folder with an Order entity, a base Entity class, and an IEntityBase interface for id management, cloning, and repository readiness.

Create a generic repository in the domain layer with IRepository and IOrderRepository. Enable async CRUD, predicate-based queries, and entity framework features like include and no-tracking.

Create the infrastructure layer by implementing the OrderContext derived from DbContext and adding a DbSet<Order> for the domain Order, using Entity Framework Core.

Seed the order microservice database with Entity Framework Core migrations and preconfigured data during startup by building a host extension that runs OrderContextSeed.SeedAsync and migrations on the SQL database.

Implement infrastructure seeding with OrderContextSeed.SeedAsync, checking Any, adding preconfigured orders via AddRange, saving via SaveChangesAsync, and note PollyFramework retries for startup seeding.

Explore seeding and migration with entity framework, diagnose startup configuration errors, and implement a startup extension for dependency injection and AddDbContext with inMemoryDatabase and orderContext.

Configure in-memory entity framework and order context, test the seeding process, and enable the http pipeline and swagger to expose the API.

Develop a generic repository in infrastructure layer to perform CRUD operations on orders using a DbContext and Entity Framework, with in-memory development and plans to migrate to msSQL and Docker.

Implement an order-specific repository atop a generic repository, using IOrderableQuery, IncludeString, and AsNoTracking for performance; integrate via dependency injection and expose async methods.

Install and wire the required libraries, configure dependency injection, mediator, and validations in the application layer, and implement the add application method to set up services and extensions.

Develop and organize an application layer using CQRS with Mediatr, configuring commands, queries, handlers, and mapping with AutoMapper, and validating orders with FluentValidation and pipeline behaviors.

Create an OrderCreateHandler in the application layer using MediatR to handle OrderCreateCommand, map it with AutoMapper to OrderEntity, and persist via IOrderRepository with AddAsync, all asynchronously.

Map the created order to an order response using AutoMapper profiles and MediatR, and return the wrapped response after persisting via the order repository.

Develop a MediatR query handler to fetch orders by username, introducing GetOrdersByUserNameHandler, GetOrdersByUserName query, repository extensions, and mapping to OrderResponse for async results.

Enhance the order service controller with a mediator pattern and dependency injection to perform get orders by username and insert orders, enabling testing via live server access.

Install swashbuckle for ASP.NET Core, configure startup with swagger gen and swagger UI, define v1 open api info, and test the order web api via swagger.

Test swagger open api services and verify dependency injection for IRepository and IOrderRepository. Seed in memory data and plan sql on docker with entity framework in clean architecture.

Open api swagger tests demonstrate seeding in-memory data, creating orders via mediator with OrderCreateCommand and OrderCreatorHandler, persisting with AddAsync, and transitioning to sql provider with migrations.

Apply cross-cutting concerns in the application layer by validating requests with a validation behavior powered by FluentValidation, chaining performance and exception pipelines through MediatR before reaching CQRS handlers.

Implement a performance behaviour in the application layer pipeline by measuring request handling time with a stopwatch, logging warnings when over 500 milliseconds, and continuing the delegate flow.

Implement application layer exception handling by introducing UnhandledExceptionBehavior in the pipeline behaviors, wrap Send method calls in try-catch, log unmanaged errors via dependency-injected logger, and respond in a controlled way.

Examine MediatR pipeline behaviors for cross-cutting concerns by wiring validation, performance, and unhandled-exception behaviors into dependency injection, then test with Swagger and IIS Express.

Develop the order consumer in the order microservice by adding the EventBus RabbitMQ integration, configuring startup, creating the EventbusOrderCreateConsumer, and wiring mediator and mapper via dependency injection.

Develop the order consumer using the EventBus library, listening to the OrderCreateQueue, deserializing messages to OrderCreateEvent, mapping to OrderCreateCommand, and persisting to the database via mediator, with proper disconnect handling.

Develop and consume order events with event bus and RabbitMQ; declare the queue, start consuming, deserialize messages with a JsonConvertor, and map OrderCreateEvent to OrderCreateCommand via Automapper.

Set up sql server in docker and modify docker-compose to expose the port and configure environment variables with an initial password, enabling local connection and loose dependencies in clean architecture.

Convert entity framework in memory db to sql db by updating the connection information and configuring the context in infrastructure, then apply migrations to create tables on sql server.

Explains code-first entity framework core migrations on sql server, creating an initial migration in the infrastructure library, configuring startup projects, and applying migrations to the order database.

Add a description field to the order table and reflect it in SQL Server via EF Core migrations. Create and apply migrations with the package manager, then undo via delete.

Configure the order microservice web api in the docker-compose setup by adding a dockerfile with container orchestrator support and override the sql server and RabbitMQ connections.

Run docker-compose up to build and start containers, verify services via docker desktop, fix automapper in startup.cs, rebuild, and confirm order updates via swagger tests.

Create an asp.net core ocelot api gateway, learn routing and upstream downstream concepts, configure microservices via a config file, dockerize with docker-compose to connect product, sourcing, and order.

Explore the api gateway design pattern as a single entrance to multiple backend microservices, enabling routing, authentication, rate-limiting, caching, load balancing, and request aggregation.

Create a blank asp.net core api gateway project named ESourcing.ApiGateway, install Ocelot, configure startup with AddOcelot and UseOcelot, and map controllers.

Configure the api gateway routing with ocelot.json to route requests to product, sourcing, and order services via downstream and upstream settings, aligning paths and ports.

Define and configure ocelot.json for the main web service and order service, exposing auction, bid, and complete auction endpoints under /api/v1, with downstream templates and api gateway routing.

Build and test an ocelot api gateway by dockerizing the api gateway, configuring docker-compose with depends_on microservices, mapping ports to localhost:5000, and validating routing to product, order, and sourcing services.

Create an asp.net core web application for the e-sourcing ui, enable microsoft identity login, and set up ms sql with docker compose, controllers, views, and view models.

Builds the ASP.NET Core MVC project structure, including shared views, layout, view imports, a home controller and index view, and integrates an admin LTE template with wwwroot assets.

Tidy the admin layout, remove unnecessary navigation, and add Microsoft identity frameworks using EF Core 5.0.2 to enable login and code-first customization.

Enable Microsoft identity features by adding an AppUser entity inheriting IdentityUser, configure identity in the web context with EF Core, and prepare docker-based ms sql using code-first migrations.

Learn to integrate sql server via docker, configure code-first migrations with entity framework, apply update-database to create identity tables for AppUser, and work with docker-compose in a .net mvc project.

Create a public login screen in the home controller using a login view model with email and password validation, wired to a razor login view and post action.

Register users through a .net mvc signup flow by building the sign-up form, validating inputs (username, email, phone), and wiring the controller action to post the user model.

Implement client-side signup validation with jquery validate to reduce backend calls. Add jquery validation and unobtrusive validation in the UI layer, and test by inspecting network requests.

In this lesson, build the register post by replacing checkboxes with a buyer/seller dropdown, create AppUser via the user manager, validate model state, and persist to the database.

Implement the login post process with user validation, asynchronous user lookup by email, sign-in via cookie authentication, remember me handling, and redirects to the home page with authorization controls.

Create the auction index page in a .net mvc project by defining an auction view model with validation, and rendering a bootstrap table with a detail action.

Create an auction page with http get and http post actions using an auction view model and razor view. Fetch product from mongo db and supplier data from ms sql.

Design a bidding detail page in an MVC app with a Razor view, Bootstrap layout, and SignalR integration for real-time bid updates.

Edit the left menu to display the logged-in user’s information using Microsoft identity, inject signInManager and userManager, and conditionally show login, signup, and navigation links in the layout.

Implement a generic repository pattern across core and infrastructure, introducing IRepository<T>, and build a repository with async CRUD, include, predicate, and optional no-tracking support.

Implement IUserRepository and its concrete repository, inject it in startup with services.AddScoped, retrieve user lists via GetAllAsync, and enable authentication to support login flows in the auction controller.

Seed default user data on startup by implementing WebAppContextSeed.SeedAsync, apply ef migrations, and bootstrap test app users via the web app context during docker-compose up with ms sql.

Explore building a multi-project net app with an api gateway, orchestrating the ui, esourcing order and esourcing product services, and introducing a product client to fetch remote product data.

Create a product client and a generic result infrastructure to consume remote product data via http client. Define a shared base address and deserialize api responses from the product microservice.

Explore request creation and client class setup with HttpClientFactory to post a new auction from the create screen, including auction client, controller, json serialization with JsonConvert, and response handling.

List auctions on the index page by calling auction client's get auctions asynchronously and rendering auction list. Build creation, testing with swagger, and add SignalR for real-time tender updates.

Explore SignalR, a real-time, open source library for .NET Core, using a hub for persistent two-way server-client communication, with integration via NuGet and MapHub setup.

Create an auction hub on the server with add to group and bid methods, and configure startup to map the SignalR hub for real-time bidding.

Integrate the signalR client by adding the Microsoft signalR package and script, connect to the auction hub with WithUrl, and disable the submit button until the connection is established.

Learn to start a SignalR connection, subscribe to a group via invoke, and handle then and catch for errors, while debugging cors policy and script reference issues.

Learn how to integrate a SignalR client and resolve a CORS policy error by configuring a CORS policy in startup, enabling cross-origin requests to auction hub endpoints.

Wire a click action to the send button, extract seller name, product id, and bid from the view, and build a send bid model for an ajax call, preventing default.

Implement an asynchronous detail action that fetches an auction by id and its bids using auction and bid clients, then deserialize json into view models for the detail page.

Develop real-time auction functionality with SignalR by implementing bid posting, UI updates, and frontend tests within a .NET MVC Docker microservice project.

Implement admin status handling by adding an isAdmin flag to AppUser, update migrations and packages, configure startup and session in an mvc project, and read admin state via http context.

Continue finalization by adding a complete bid method in auction controller, wiring id-based requests to the auction client, and updating the index view to show status as active or closed.

Configure the api gateway to route to microservices via a single base address, update clients and ocelot json, and prepare docker deployment for auction, product, and e-sourcing services.

Deploy a Docker Compose driven microservice project with an API gateway, routing requests via Ocelot to product, auction, and bid services, using Docker Desktop and IIS Express for testing.