Microservices Architecture and Implementation

In this comprehensive course, you'll gain hands-on experience in building Microservices on .NET platforms, utilizing a wide array of cutting-edge technologies. You'll dive into Asp.Net Web API, Docker, RabbitMQ, Ocelot API Gateway, MongoDB, Redis, SQL Server, Entity Framework Core, CQRS, and Clean Architecture implementation.

Throughout the program, you'll develop practical e-commerce modules focusing on Product, Basket, and Ordering microservices. Leveraging NoSQL databases like MongoDB and Redis, as well as relational databases such as SQL Server, you'll master the art of seamless communication via RabbitMQ Event Driven Communication. The integration of Ocelot API Gateway will be a key aspect of your projects.

This course emphasizes a step-by-step approach, guiding you through the entire Microservices Architecture implementation on .NET. Each module is crafted with extensive explanations and details, ensuring you grasp the concepts thoroughly.

By the end of the course, you'll be well-equipped to create efficient and scalable Microservices applications, positioning yourself at the forefront of modern software development. Get ready to transform your skills and embark on an exciting journey into the world of Microservices with .NET.

​​​Certification Objectives:

    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
    Clean Architecture implementation with CQRS Pattern
    Swagger Open API implementation
    RabbitMQ Publish Event Queue When Checkout Cart
    Consuming RabbitMQ Messages from Ordering Microservices
    Base EventBus Implementation and Add References Microservices
    Implementation of MediatR, Autofac, FluentValidator, AutoMapper
    Ocelot API Gateway Development of Microservices
    ASPNET Core Web Application with Razor Pages
    Call Ocelot APIs with HttpClientFactory
    Docker Compose Establishments
    Dockerization of Microservices

Chapter 1: Introduction

    Prerequisites and Source Code
    Setting Up the Development Environment
    Run Final Application
    Service Oriented Architecture (SOA)
    Monolithic Architecture What is the Weaknesses and Strengths
    Microservices Architecture What is the Weaknesses and Strengths
    Docker Getting Started and Docker Commands

Chapter 2: Building Catalog Microservices

    Introduction
    Create Visual Studio Solution for Microservices Application
    Create ASP.NET Core Web API Project For Catalog Microservices
    ASP.NET Core Web API and Fundamental Features
    Create Catalog Controller Class
    Analysis & Design Catalog Microservices with Managing REST APIs
    Architecture & Code Structure of Catalog Web API Project
    Create Entities for Catalog Microservices Web API Project
    MongoDB Database Setup with Docker
    MongoDB CLI Commands on Docker
    ASP.NET Core Web API Settings Implementation from appsettings.json
    Developing Data Layer with Catalog DataContext Class
    Seeding MongoDB Products Collection
    Developing Business Layer with Repository Classes
    Developing Presentation Layer with Controller Classes
    CRUD Operations on Controller Classes
    Run Application
    Debug Application with Consuming APIs from Post
    Debugging CRUD APIs from Postman
    What is Swagger and Implementation on Catalog Microservices
    How to Dockerize Catalog.API Microservices
    Add Docker Compose and Dockerfile
    Docker-Compose File Explained and Communication with Mongo Image
    Run Application on Docker with Catalog API and Mongo Database

Chapter 3: Building Basket Microservices

    Introduction
    Create ASP.NET Core Web API Project For Basket Microservices
    Analysis & Design Basket Microservices with Managing REST APIs
    Architecture & Code Structure of Basket Web API Project
    Create Entities for Basket Microservices Web API Project
    What is Redis and Why we Choose Redis as a NoSQL Database
    Redis NoSQL Database Setup with Docker
    Redis CLI Commands in Redis Container
    Developing Data Layer with Catalog DataContext Class
    Create Redis Connection with ConnectionMultiplexer Object in Startup Class
    Developing Business Layer with Basket Repository Classes
    Register Basket Classes into ASP.NET Dependency Injection at Startup.cs
    Developing Presentation Layer with Basket Controller Classes
    Swagger Implementation on Basket Microservices
    Run and Debug Basket API Application
    Dockerize Basket.API Microservices
    Docker-Compose File Explained and Communication with Redis Image
    Run Application on Docker with Basket API and Redis Database

Chapter 4: Microservices Communication with Building RabbitMQ Library

    Introduction
    Microservices Communication Types Request-Driven or Event-Driven Architecture
    What is RabbitMQ, Main Features and Exchange Types of RabbitMQ
    RabbitMQ Setup with Docker on Local Environment
    Analysis & Design EventBus Class Library Project with RabbitMQ
    Create Class Library for EventBus Which Will Use Basket and Order Microservice
    RabbitMQ Connection Developments with RabbitMQ.Client Nuget Package
    RabbitMQ Events Developments with RabbitMQ.Client Nuget Package
    RabbitMQ Publish Event Send Queue Developments with RabbitMQ.Client Package
    EventBus Adding Common Class in Class Library
    Add EventBus Class Library References into Basket.API Microservices
    RabbitMQ Connection Establishment and Registered ASP.NET Dependecy Injection
    Basket Checkout API Method Development which publish an Event
    AutoMapper Implementation for Event Mapping in Basket Microservices
    Basket Checkout API Method Triggering a Basket Checkout Event
    Run Application with Debugging Basket Checkout API and Follow RabbitMQ Dashboard
    Dockerize RabbitMQ in Docker-compose File that Communicate Basket Microservice
    Run Application on Docker with RabbitMQ and Basket API

Chapter 5: Building Ordering Microservices with Clean Architecture and CQRS

    Introduction
    Analysis & Design Ordering Microservices with Managing REST APIs
    Create Web API Project for Ordering Microservices
    Architecture & Code Structure of Ordering Web API Project
    SOLID Principles and Dependency Inversion Principle (DIP)
    Domain Driven Design (DDD) and Implementation on Clean Architecture
    Clean Architecture (aka Ports and Adaptors) and N-Layer Implementation
    CQRS (Command Query Responsibility Segregation) Design Pattern
    Eventual Consistency and Event Sourcing with CQRS Design Pattern
    Code Structure on CQRS and DDD Implementation in Ordering Microservices
    Create Class Library Layers with Applying Clean Architecture Implementation
    Create Entities for Ordering Microservices in Core Layer
    Create Repositories for Ordering Microservices in Core Layer
    Create Entity Framework Context for Order Microservices in Infrastructure Layer
    Seeding SQL Server Database with Entity Framework Core in Infrastructure Layer
    Run Program.cs for Testing Seed Operation
    SQL Server Relational Database Setup with Docker
    OrderDb Creation in SQL Server
    Entity Framework Core Migration for OrderDb in SQL Server
    Repository Implementation Developments with User EF.Core Context Objects
    CQRS Implementation with Mediator Design Pattern
    Query Class Development with MediatR IQuery Class
    AutoMapper Implementation for Application Layer in Ordering Microservices
    Checkout Order Command Development with MediatR
    Developing API Controller for Ordering Microservices
    Registering ASP.NET Core Dependency Injections for Ordering Microservices
    Swagger Implementation on Ordering Microservices
    Run and Debug Ordering API Application

Chapter 6: Consume RabbitMQ Event from Ordering Microservice as a Listener

    Starting of Consuming RabbitMQ Events from Ordering Microservices
    Establishment to Connection with RabbitMQ from Ordering Microservices
    Developing RabbitMQ Consumer Class into Ordering Web API Project Part 1
    Developing RabbitMQ Consumer Class into Ordering Web API Project Part 2
    Create RabbitMQ Listener Pipeline with Developing Extension Method Part 1
    Create RabbitMQ Listener Pipeline with Developing Extension Method Part 2
    Run Ordering API Application
    Debugging Ordering API with RabbitMQ
    Dockerize Ordering.API Microservices
    Docker-Compose File Explained and Communication with SSQL Server Image
    Run Application on Docker with Ordering API, SQL Server Database and RabbitMQ
    Run Application on Docker with Ordering API, SQL Server Database and RabbitMQ 2

Chapter 7: Building Ocelot API Gateway Microservices

    Introduction
    API Gateway Microservice Design Pattern Explained
    Analysis & Design Ocelot API Gateway Microservices with Managing REST APIs
    Create Blank Web Application for Ocelot API Gateway Microservices
    Adapting Ocelot Nuget Package into Ocelot API Gateway Web Application
    Managing ocelot.json Configuration File For Routing Microservices APIs Part 1
    Managing ocelot.json Configuration File For Routing Microservices APIs Part 2
    Dockerize Ocelot API Gateway Microservices
    Docker-Compose File Explained and Communication with Internal Microservices
    Refactored Ocelot Implementation of API Gateway
    Run Application on Docker with Internal Microservices

Chapter 8: Building Shopping Web Application Microservices

    Introduction
    Background of Project
    ASP.NET Run Basics Base Web Application
    Analysis & Design Shopping Web Application Microservice
    Create WebApp Folder and Project into our Solution
    Refactored Existing Shopping Web Application
    Infrastructure Common Base Layer for HTTPClientFactory
    Create API Interfaces which Consumes Microservice APIs over Ocelot API Gateway
    Create Model Classes
    Settings Implementation for appsetting.json File
    Develop API Classes which Consumes Microservice APIs over Ocelot API Gateway
    Developing Index Page in Shopping Web Application
    Developing Product and Product Detail Page in Shopping Web Application
    8.14. Developing Cart Page in Shopping Web Application
    Developing Checkout Page in Shopping Web Application
    Developing Order Page in Shopping Web Application
    Refactoring Developments on Shopping Web Application Part 1
    Refactoring Developments on Shopping Web Application Part 2
    Run the Shopping Web Application
    Dockerize Shopping Web Application Microservices
    Run All Microservices on Docker Environment

Target Audience

"Microservices Architecture and Implementation" is designed for software developers, architects, and IT professionals seeking to master the intricacies of building scalable and resilient microservices-based applications. Whether you're a seasoned developer aiming to refine your architecture skills or a newcomer to the world of microservices, this course caters to a broad spectrum of learners. It's an ideal fit for those who possess a foundational understanding of software development concepts and want to explore the concepts, tools, and best practices surrounding microservices. By delving into topics like containerization, orchestration, API design, and deployment strategies, this course equips learners with the skills needed to design, develop, and manage modern software systems. Whether you're looking to transition to microservices or enhance your existing knowledge, this course empowers you with the expertise to thrive in the dynamic landscape of microservices architecture.

🌟 Certification Benefits:

"Microservices Architecture and Implementation" certification empowers individuals with modern architecture expertise, hands-on experience, and a skillset in high demand, positioning them for success in the evolving world of software development.

Embark on a transformative journey of Microservices Architecture and Implementation on .NET Core with this self-paced instructor-led course. This 180-word blurb provides a glimpse into the comprehensive program, highlighting its focus on equipping participants with the expertise to build scalable and efficient Microservices applications using cutting-edge technologies on the .NET Core platform.

Prerequisite Skills:

Prior familiarity with software development concepts, programming languages, and basic software architecture principles is recommended. Proficiency in any programming language and a foundational understanding of web services and APIs will be beneficial. This certification is suitable for both newcomers looking to explore microservices and experienced developers seeking to refine their skills.