Development > Web Development
34h 49m
£17.99 £12.99
Mastering Microservices Architecture with .NET 8 and Angular 18
What you will learn:
- Microservices architecture using .NET 8
- Clean architecture implementation
- Integration of various technologies (Angular 18, Docker, Kubernetes, Azure AD, RabbitMQ, gRPC, Istio)
- Message queue implementation (RabbitMQ)
- Mediator and CQRS patterns
- Containerization and Docker Compose
- API gateway using Ocelot and Nginx
- Structured logging and ELK stack integration
- Handling cross-cutting concerns
- Deployment to Kubernetes and AKS
- Service mesh implementation using Istio
- Sidecar pattern implementation
Description
Important Note: This course requires the installation of Docker Desktop. Udemy Business users should consult their employer before downloading software.
Elevate your development skills with our comprehensive guide to building microservices using .NET 8 and Angular 18. This intensive 51-hour course provides a complete, hands-on journey, transforming you into a microservices expert.
Dive deep into clean architecture principles and leverage Docker and Kubernetes for efficient deployment and management. Secure your applications with Azure AD/Identity Server 4, and master seamless communication using RabbitMQ and gRPC. Optimize your database performance with SQL Server, MongoDB, PostgreSQL, and Redis.
Learn to effectively manage microservices traffic with Istio Service Mesh and control API access using Azure API Gateway/Ocelot and Nginx. Deploy your applications seamlessly on Azure using Helm Charts and gain proficiency in auto-scaling for optimal performance and reliability.
Who will benefit from this course?
- Aspiring developers seeking to build highly scalable applications.
- Junior developers looking to advance their skills in microservices architecture.
- Experienced developers aiming to master cutting-edge tools and technologies.
- Software architects designing and implementing robust, distributed systems.
- Technical leads who want to enhance their team's microservices expertise.
Your Microservices Journey Starts Now
Transform your understanding of application development through practical, end-to-end project creation. We start with an e-commerce platform vision, meticulously guiding you through the design and implementation of each microservice, building on a strong foundation of clean architecture and best practices.
This is not just theory; each module includes challenges and tasks that allow you to implement your knowledge and build a real-world application. By the end of this course, you'll confidently design, develop, and deploy enterprise-grade microservices using .NET 8 and Angular 18.
Course Highlights:
- 43+ engaging modules
- 600+ in-depth video tutorials
- 53+ hours of premium video content
- Comprehensive quizzes
- Yearly course updates to ensure currency
- Lifetime access for ongoing learning
Why choose this course?
- Expert instruction from an industry professional
- A wealth of hands-on exercises and practical projects
- A vibrant learning community to support your journey
- Focus on building high-quality, production-ready systems
- Excellent value and ongoing access to course updates
Enroll today and embark on your microservices mastery journey!
Curriculum
Introduction
This introductory section lays the groundwork for the entire course. Lectures cover introductions to the course, a detailed architectural overview, strategies for using GitHub effectively, a comprehensive project overview, information on the instructor's blog, and comparisons of different architectural patterns like layered, domain-centric, hexagonal, onion, and clean architectures. The CQRS pattern is also explained, followed by a solution overview and application demo, details on the technologies used, and guidance on navigating the course effectively.
Developing Catalog Microservice using Clean Architecture
This section focuses on building the Catalog Microservice. Lectures guide you through creating an empty solution, building the Catalog API project, establishing other class libraries, managing project references, understanding the Program.cs file, adding Swagger metadata, adjusting ports and profiles, installing Mongo packages, creating product entities, brands, and types, and developing repositories. It also covers creating seed data, implementing the Catalog context, implementing the Product repository, setting up the Application layer, creating handlers for Brands, Products, Types, and implementing controllers. Finally, it covers Docker file updates, building the Docker Compose project, debugging and running the application in Docker Desktop, and implementing specifications for pagination, filtering, and sorting.
Developing Basket Microservice using Clean Architecture
This section mirrors the Catalog Microservice development, but for the Basket Microservice. You'll create the Basket projects, add references, create entities and repositories, and implement the repository logic. Lectures also cover creating application folder structures, importing necessary packages, creating responses and mappers, creating query and command handlers for managing baskets, and developing the API controller. Finally, Docker file and Docker Compose setups are covered, alongside debugging and testing using Portainer.
Developing Discount Microservice Using Clean Architecture
This section covers the development of the Discount Microservice using similar steps as the previous sections. You'll create the project, add references, build entities and repositories, implement repository logic, handle database migrations, and set up the application layer. Lectures detail the creation of proto files, implementing handlers, and configuring the program file. Docker file and Docker Compose setup are also covered, along with troubleshooting any issues during deployment.
Consuming Discount Microservice from Basket Microservice
This section demonstrates how to consume the Discount Microservice from the Basket Microservice. You will learn how to import required packages, import the Discount proto file as a client, create the Discount gRPC service, and make the necessary AppSettings changes. Lectures cover registering gRPC services in the Program file, modifying the Basket API controller, updating Docker Compose, and changing handler logic, all while troubleshooting potential issues, such as socket exceptions.
Developing Ordering Microservice using Clean Architecture
This section focuses on the Ordering Microservice, guiding you through project creation, adding references, creating entities and repositories, implementing repository logic, and handling database migrations. Lectures cover implementing different handlers for managing orders, creating custom exceptions and handling unhandled exceptions, adding service registrations, configuring the program file and app settings, creating the API controller and handling Docker Compose and potential deployment issues.
Async Communication between Rabbit MQ, Basket and Ordering Microservice
This section explores asynchronous communication using RabbitMQ between the Basket and Ordering Microservices. It covers infrastructure project creation, implementing a Basket Checkout Event, configuring MassTransit in both the Basket and Ordering APIs, and handling potential issues during implementation and deployment. The section culminates in a demo showcasing asynchronous message handling via RabbitMQ.
Implementing Cross Cutting Concerns
This section focuses on implementing cross-cutting concerns. You'll learn to create a logging project, implement a logging class, and wire up logging in all microservices. This section includes an introduction to ELK stack, and configuring Elasticsearch, Logstash, and Kibana, troubleshooting potential issues during the setup, and finally visualizing logs in Kibana.
API Versioning
This section explores various API versioning strategies. You'll learn how to implement different versions of API controllers and handlers, configure Swagger for different versions, and address potential issues related to API versioning, including troubleshooting Swagger issues and implementing different versioning strategies like header, URL-based and media-type based versioning.
Angular 18 Upgrade
A brief section dedicated to demonstrating the process of upgrading an Angular application to version 18.
What's Next
A concluding section offering guidance on future learning and development.
Developing Catalog Microservice using Clean Architecture -> .Net 6
This section repeats the Catalog Microservice development using .NET 6, covering similar steps as in the .NET 8 version, but with adjustments for the older framework. It covers project creation, entity and repository creation, seed data setup, handler implementation, and controller development, as well as Docker file and Docker Compose setup and debugging. This section also includes multiple-choice questions to test understanding.
Developing Basket Microservice using Clean Architecture -> .net 6
This section repeats the Basket Microservice development for .NET 6, mirroring the steps from the .NET 8 version but adapting to the .NET 6 framework. It involves project creation, entity and repository creation, handler implementation, controller development, and Docker setup, along with multiple-choice questions.
Developing Discount Microservice Using Clean Architecture -> .net 6
Similar to the previous sections, this section covers the Discount Microservice development in .NET 6, adapting the steps from the .NET 8 version. It includes project creation, entity and repository creation, proto file creation, handler implementation, and Docker setup. Multiple-choice questions are included for assessment.
Consuming Discount Microservice from Basket Microservice -> .net 6
This section demonstrates consuming the Discount Microservice from the Basket Microservice in .NET 6, adapting the approach from the .NET 8 version. It covers package imports, gRPC service creation, and handling Docker-related issues. Multiple-choice questions are included.
Developing Ordering Microservice using Clean Architecture -> .net 6
This section repeats the development of the Ordering Microservice in .NET 6, following a similar structure to the .NET 8 version. It emphasizes project creation, entity and repository creation, handler implementation, and Docker setup. Multiple-choice questions are included.
Async Communication between Rabbit MQ Basket and Ordering Microservice -> .net 6
This section showcases asynchronous communication in .NET 6, using RabbitMQ, between the Basket and Ordering Microservices. It covers MassTransit setup, event handling, and debugging container issues. Multiple-choice questions are included.
Application Gateway Implementation -> .net 6
This section covers the implementation of an application gateway using Ocelot in .NET 6, including project creation, configuration changes, and Docker setup.
Identity Server Introduction -> .net 6
This section provides an introduction to Identity Server, covering architecture and branching strategies within the .NET 6 context.
Securing Catalog and Basket Microservice -> .net 6
This section focuses on securing the Catalog and Basket Microservices using Identity Server in .NET 6. It covers the implementation of authentication and authorization mechanisms using JWT tokens and managing various authorization flows.
Securing Service to Service Communication -> .net 6
This section covers securing service-to-service communication using Identity Server in .NET 6, including setting up clients and handling scope-level authorization.
Setting up Nginx Gateway -> .net 6
This section focuses on setting up an Nginx gateway, configuring certificates, and troubleshooting related issues.
Implementing Cross Cutting concerns -> .net 6
This section revisits the implementation of cross-cutting concerns, including architectural overview and branching strategy, but specifically within the context of .NET 6.
Adding Logging to Console -> .net 6
This section covers adding console logging to the application within .NET 6 framework, introducing different log levels, implementing ILogger, and integrating Serilog.
Elastic Implementation -> .net 6
This section details the integration of Elasticsearch and Kibana with .NET 6 applications, including setting up ELK stack using Docker, configuring Elasticsearch and Kibana, handling correlation IDs, and visualizing logs in Kibana.
Versioning Microservices -> .net 6
This section re-iterates API versioning strategies within the .NET 6 framework. It includes an overview of architectural considerations and branching strategies related to version control.
Implementing API Versioning -> .net 6
This section dives into the practical implementation of API versioning using different techniques within .NET 6. It involves updating controllers, configuring Swagger, and handling potential issues during implementation.
Building eCommerce Angular Application
This section covers building the e-commerce frontend using Angular, from installation to setting up the project structure and incorporating necessary components and services.
Getting Started with Angular
This section focuses on foundational Angular concepts, such as project structure, installing packages (ngx-bootstrap, Font Awesome), creating components (Navbar), understanding Observables and Promises, implementing HttpClient, enabling CORS, and fetching data.
Building the Store Front
This section covers building the main e-commerce storefront, including creating feature modules, components (Store, Product Items), services (Store Service), implementing filtering, pagination, and sorting functionalities, and handling data passing between components.
Routing
This section focuses on setting up routing within the Angular application, creating routes, implementing router links, handling data fetching for product details, and implementing lazy loading.
Error Handling
This section covers error handling mechanisms in the Angular application, implementing error interceptors, and improving error pages for better user experience.
UI Components
This section guides you in building reusable UI components, such as Header, using ngx-breadcrumb, and implementing loading interceptors and visual loading indicators using Ngx Spinner.
Basket Implementation
This section covers implementing the shopping basket functionality, including creating Basket components and services, handling basket operations (add, remove, update), calculating basket totals, and displaying basket information on the storefront.
Identity Server Client Implementation
This section details the implementation of Identity Server for authentication and authorization, covering setting up the Account module, handling routing, integrating with the backend, managing access tokens and refresh tokens, and handling potential issues like 401 errors.
Deploying Microservices to Kubernetes and AKS
This section covers deploying the microservices to Kubernetes and AKS, providing an overview of architecture, branching strategies, and Kubernetes components. It includes guidance on creating YAML files, managing Docker images, and setting up the Kubernetes dashboard.
Kubernetes Setup
This section guides you through the process of setting up Kubernetes, creating necessary YAML files for deployment, managing ConfigMaps and Secrets, and deploying the application to a Kubernetes cluster, including handling potential issues during the deployment process.
Azure Setup
This section covers setting up Azure Container Registry (ACR) and Azure Kubernetes Service (AKS), pushing Docker images to ACR, and managing credentials for integration with the local Kubernetes configuration.
Helm Installation
This section details the process of installing and configuring Helm for managing application deployments on Kubernetes. It covers understanding Helm templates, managing images, and resolving potential issues during Helm setup and deployment.
Enabling Service Mesh using Istio
This section focuses on enabling Istio Service Mesh for improved observability and traffic management within the Kubernetes cluster. It covers Istio setup, verifying Istio's operation, and using Kiali dashboard for visualizing application traffic flows.
Setting up API Gateway
This section guides you through setting up an API gateway using Ocelot, covering configuration, Docker setup, and troubleshooting potential issues during deployment.
Implementing Security Using Azure AD
This section covers implementing security using Azure AD B2C, creating users, registering applications, managing user flows, and securing the application using JWT tokens. It covers implementing authentication and authorization mechanisms in both the backend and frontend applications.
Bonus Section
This section contains additional content, potentially covering advanced topics or supplementary information.