Generic filters
Search in title

Microservices Using .NET Core Training

  • Training Duration:
  • 5 Days
  • Training Environment:
  • On-site at the Institution
  • In DVA Classrooms
  • Online
Download Training Document
Request Information!

About the Training

The “Microservices Using .NET Core Training” offers a comprehensive education on how to develop microservices using .NET Core. This training covers microservices architecture topics and the foundational skills required in this area.

The training teaches the core features of .NET Core and microservices, service design, performance optimization, security, and other key concepts. Participants enhance their knowledge through real-world examples and projects.

Additionally, the training explains which tools and technologies can be used during the design and development of microservices using .NET Core. Participants learn how to manage essential features such as data processing, performance optimization, service design, and security. They also understand how to design and manage microservices with .NET Core.

The “Microservices Using .NET Core Training” covers all the fundamental aspects of designing and managing modern microservices solutions. Participants gain the necessary skills before they start designing and developing effective microservices.

The training program starts with the fundamentals of .NET Core and microservices. Participants learn essential concepts such as service design, performance optimization, and security. Additionally, it covers designing and managing microservices using .NET Core. Participants gain insight into the role .NET plays in the design process. These insights provide the foundational building blocks needed for designing microservices.

The training focuses on the core features and components of .NET Core. This gives participants the necessary skills for data processing, service design, and security. Topics such as service design and service management are addressed.

Finally, we provide knowledge on how to develop a microservices solution based on .NET Core. This process includes the initial design, testing, and developing the microservices solution using .NET Core. These insights help participants successfully design and develop microservices solutions with .NET Core.

What Will You Learn?

In the Microservices Using .NET Core training, participants will learn the following:
  • The fundamental concepts of the .NET Core framework and how to use it.
  • RESTful API design and development techniques.
  • How to establish database connections and data access techniques.
  • How to deploy microservices-based applications.
  • Techniques for ensuring the security, performance, and scalability of applications.
  • Testing and debugging techniques.
  • How to ensure communication between microservices.
  • How to configure and manage microservices.
  • Understanding the advantages and disadvantages of microservices-based applications.
  • How to deploy applications in Kubernetes or a similar deployment environment.
  • How to improve workflow and the efficiency of your applications.
This training is suitable for software developers with experience in microservices-based application development or those who wish to gain advanced skills in this area.

Prerequisites

Here is the English translation of your text:
The prerequisites for the Microservices Using .NET Core training are as follows:
  • Knowledge of .NET programming languages (e.g., C#) and web development fundamentals.
  • Basic understanding of RESTful API and HTTP protocol.
  • Basic knowledge of database technologies (e.g., SQL Server) and data access techniques.
  • Skills in using terminal or command line.
  • Experience in web development (e.g., ASP.NET MVC or ASP.NET Core).
  • Knowledge of Agile software development methodologies and working methods like SCRUM.
  • Basic knowledge of Docker or a similar containerization technology.
  • Experience in deploying applications on Azure or a similar cloud-based platform.
If you possess some of these skills, you will have the opportunity to learn more efficiently and quickly in the Microservices Using .NET Core training.

Who Should Attend?

  • Software developers interested in .NET programming languages and web development.
  • Software developers who want to gain more knowledge about RESTful API and microservices architecture.
  • Software developers looking to understand cloud-based application development and deployment processes.
  • Software developers planning to work with technologies like .NET Core and Docker.
This training is designed for the professional audience mentioned above and will help them improve their skills in working with microservices architecture and .NET Core.

Outline

Introduction to Containers and Docker
  • Understanding VM’s and Containers
  • What is Docker?
  • Docker Benefits
  • Docker Architecture and Docker Taxonomy
Developing Docker Custom Images using .NET Core
  • Docker Images for .NET Core
  • Executing .NET Core applications in Containers
  • Inspecting the Image Architecture
  • Developing and Publishing .NET Core Applications
  • Dockerfile and Building Docker Images
  • Breaking down and understanding dockerfile in-depth
Multi-Stage Builds
  • Multiple stages in dockerfile
  • Hosting NET Applications in Docker
State and Data in Docker Applications
  • Purpose of using Data Volumes
  • Access Data in Docker Containers
  • Creating a Container with Volumes
  • Data volume containers
Docker Compose
  • Overview
  • Docker-compose features
  • Building docker-compose.yml file
  • Docker-compose command
  • Working with multiple images in a single application
  • Environment Variables and Configuration File
Microservices Architecture – Get perfect in concepts and practical Understanding Microservices Understanding Monolithic Architecture
  • What are Monolithic Applications
  • Deploying
  • Containerizing using Docker
  • Scaling Applications
  • Managing State and Data
  • Benefits and Drawbacks of Monolithic Architecture
Microservices Architecture
  • What are Microservices
  • Monolithic vs Microservices Architecture
  • Characteristics of Microservices Architecture
  • Benefits of using Microservices Architecture
  • Microservices Design Principles
SOA vs. Microservices Handling Data in Microservices Communication between Microservices
  • Synchronous Communication across Microservices
  • Asynchronous communication across Microservices
  • API Gateway Pattern
  • Microservices Patterns
    • Domain-Driven Design
    • Command and Query Responsibility Separation (CQRS)
    • Event Sourcing
  • Creating Composite UI with Microservices
  • Drawbacks of Microservices
Setup Microservice Based Application and Perform CRUD Operations
  • Creating a Solution and Project Layout
  • Implementing a CRUD microservice
  • Writing Domain Classes and Controllers
  • Data Context Class and Data Seeding
  • Using Repository Classes
  • Swagger and SwashBuckle Integration
  • Practical Demonstration using eStoreApplication
    • Product CatalogService with SQL Server
    • Invoking both services using Swagger UI
    • Implementing Layered Architecture
    • Generic Repository Pattern
Build UI Service
  • Adding NET MVC Project
  • Writing Model Classes
  • Writing Service Classes
  • Building Web Controller and Views
  • Practical Demonstration using eStoreApplication
    • Writing Backend for Frontend (BFF)
    • UI Microservice to display Product Catalog
Hosting Microservices using Docker Containers
  • Adding Docker Support to the Microservice Application
  • Creating a Dockerfile file
  • Designing and Developing Multi-Container Microservices
  • Database Connection string and environment variables in Docker containers
  • Handling Configuration Data
  • Use a database server running as a container
  • Practical Demonstration using eStoreApplication
    • Creating an SQL Server database container
    • Create docker images for Product Catalog Microservices
    • Create a docker image for UI Microservice
    • Writing a YAML for deploying and executing the application
Using Redis Cache in Microservices
  • Understanding Redis Cache importance
  • Programming Microservice to use Redis Cache
  • Consuming Microservice in Web Client
  • Practical Demonstration using eStoreApplication
    • Building Shopping Cart Microservice
    • Persisting Cart data in Redis Cache
    • Create a docker image for Shopping Cart Microservice
Understanding OAuth2 and OpenIdConnect
  • Authentication and Authorization
  • Introduction to Basic Authentication Workflow
  • Understanding OAuth
  • OAuth Grant Types
  • Understanding OpenIDConnect
  • Securing Services and Middleware in NET Core
  • Using JWT Token to Authenticate and Authorize
IdentityServer4 Server
  • What is IdentityServer4
  • Authorization Grant Types
  • Authorization Code
    • Implicit
    • Client Credentials
    • Resource Owner Password Credentials (ROPC)
  • Including UserInfo in ID Token and Access Token
Implementing Security for Microservices
  • The Big Picture
  • Implementing Identity Microservice
  • Using Client Credential Token to Access Microservice
  • Using Access Token to call Microservices
  • Authentication between Microservices
  • Implementing Role-based and Policy-based Authorization
  • Practical Demonstration using eStoreApplication
    • Adding Authentication Microservice to Solution
    • Securing ProductCatalog Microservice
    • Accessing secure ProductCatalog in Swagger UI
    • Accessing secure ProductCatalog in Client Application
API Gateway Integration
  • Introduction to API Gateway
  • Understanding Ocelot Middleware
  • Integrating API Gateway for Routing
  • Handling Secure Microservices in API Gateway
  • Practical Demonstration using eStoreApplication
    • Adding API Gateway Service using Ocelot Middleware
    • Updating ocelot configuration for routing to ProductCatalog and ShoppingCart Microservices
    • Deploying Gateway Service in Docker Container
Microservices Communication
  • Synchronous Communication using REST API
  • Asynchronous Communication using Service Bus
  • Integration Events and Event Handlers
  • Handing Atomicity and Resiliency when Publishing to EventBus
  • Practical Demonstration using eStoreApplication
  • Adding Shopping Cart Service with Redis Cache
  • Adding Product to Shopping Cart Service for logged-in client
  • Create docker images for Product Catalog Microservices
  • Asynchronous Communicating with Notification Service and Service Bus Queue
Implementing the CQRS Pattern
  • Overview of CRQS Pattern
  • Understanding the Command Pattern
  • Domain Model and Read Model
  • Comparing CQRS with the traditional CRUD approach
  • Apply CQRS and CQS approach in DDD microservice
  • Practical Demonstration using eStoreApplication
    • Build a New ProductCatalog Service Demo
    • Update ShoppingCart if Product Price changes
    • Update ProductCatalog inventory if the order is placed
Domain-Driven Pattern
  • Overview of Domain and Domain-Driven Design
  • Layered Architecture in DDD Microservices
  • Implementing the Command and Command Handler Pattern
  • About Domain Events
  • Command and Command Handler Classes
  • Practical Implementation of DDD Pattern
  • Practical Demonstration using eStoreApplication
    • Implementing DDD using Order Microservices
Handling Failures
  • Handle Partial failure
  • Implement retries and exponential backoff
  • Using Polly policies
  • Circuit Breaker Pattern
  • Practical Demonstration using eStoreApplication
  • Handle Order Service failure
  • Handling temporary downtime of SQL Database
Microservices Deployment in App Services Microservices and Kubernetes
  • What is Monolithic Application
  • What are Microservices
  • Kubernetes Architecture
  • Azure Kubernetes Service (AKS)
  • Practical Demonstration using eStoreApplication

Training Request Form

If you want to maximize the benefits of your training in terms of time and cost efficiency, all you need to do is contact us.

Our training consultants will get in touch with you, assist in identifying your organization’s needs, and provide the most suitable training programs for your employees.

Training Request Form

Digital Vision Academy © All Rights Reserved 2023