Microservices .NET

In the Microservices dotNET course from SpiralTrain, participants learn to build and manage scalable microservices using ASP.

Introduction to Microservices

The course starts with an overview of microservices architecture, including benefits, challenges, decomposition strategies, domain-driven design (DDD), and designing bounded contexts.

Microservices with ASP.NET Core

Participants learn to build microservices with ASP.NET Core, including minimal APIs, API versioning, service configuration, and applying Clean Architecture principles.

API Gateway and Communication

Participants learn about synchronous and asynchronous communication, building an API Gateway with YARP, using gRPC for high-performance communication, and service discovery.

Authentication, Authorization and Security

This module covers securing microservices using OAuth 2.0, OpenID Connect, Identity Server integration, API authorization policies, distributed identity, and API gateway security.

Event-Driven Architecture

Participants dive into event-driven systems, message brokers (RabbitMQ, Kafka), event sourcing, the outbox pattern, sagas for distributed transactions, and event orchestration.

Distributed Data Management

This module discusses challenges of distributed data, the CAP theorem, CQRS, eventual consistency, cross-service querying, and polyglot persistence strategies.

Resilience, Monitoring and Logging

Participants learn transient fault handling, retries with Polly, circuit breakers, distributed tracing with OpenTelemetry, structured logging, and monitoring with Prometheus and Grafana.

Containerization and Deployment

The focus is on containerizing microservices with Docker, managing multi-service environments with Docker Compose, setting up CI/CD pipelines, and deploying to Azure Kubernetes Service.

Advanced Microservices Architecture

Finally, participants explore advanced topics like micro frontends, hybrid architectures, serverless integration, event streaming, service mesh technologies, and best practices for scaling.

Audience Microservices .NET Course

The Microservices .NET course is intended for experienced .NET developers who want to design and build scalable distributed applications based on microservices architecture.

Prerequisites Microservices .NET Course

Solid knowledge of C#, ASP.NET Core, and familiarity with API development, Docker, and distributed systems is required.

Training Execution Microservices .NET

The training consists of interactive theoretical sessions, live demonstrations, and practical hands-on labs under the guidance of an experienced trainer.

Certificate Microservices .NET

Participants will receive a certificate of completion for the Microservices .NET course after successfully finishing the training.

Modules

Module 1: Intro Microservices

• What are Microservices?
• Microservices vs Monoliths
• Benefits and Challenges
• Domain-Driven Design
• Bounded Contexts
• Designing Microservices
• Evolutionary Architecture
• Microservices Patterns
• Decomposition Strategies
• Database per Microservice

Module 2: Microservices .NET Core

• Building REST APIs
• Minimal APIs in ASP.NET Core
• Versioning APIs
• Model Validation
• Content Negotiation
• Health Checks
• Swagger and OpenAPI
• Service Registration and Discovery
• Service Configuration Options Pattern
• Microservices with Clean Architecture

Module 3: API Gateway

• Synchronous Communication
• Asynchronous Communication
• Introduction to API Gateway Pattern
• Building an API Gateway with YARP
• Routing and Aggregation
• Authentication at Gateway Level
• gRPC Basics in .NET
• gRPC vs REST
• Service Mesh Concepts
• Using Dapr for Communication

Module 4: Security

• Security in Microservices
• OAuth 2.0 and OpenID Connect
• IdentityServer Integration
• JWT Tokens and Validation
• Scopes and Claims
• API Authorization Policies
• User Authentication and Federation
• Distributed Identity Management
• Securing APIs behind API Gateway
• Handling Security at Service Mesh

Module 5: Event-Driven Architecture

• Event-Driven Architecture Overview
• Publish-Subscribe Pattern
• Message Brokers (RabbitMQ, Kafka)
• Event Sourcing Basics
• Integration Events
• Domain Events
• Idempotent Event Handling
• Outbox Pattern
• Saga Pattern
• Choreography vs Orchestration

Module 6: Distributed Data

• Challenges of Distributed Data
• CAP Theorem
• Database per Service Strategy
• Data Consistency Approaches
• Two-Phase Commit and Sagas
• CQRS Pattern
• Read Models and Write Models
• Eventual Consistency
• Cross-Service Queries
• Polyglot Persistence

Module 7: Resilience

• Transient Fault Handling
• Retry Policies with Polly
• Circuit Breaker Pattern
• Timeout and Bulkhead Isolation
• Distributed Tracing (OpenTelemetry)
• Structured Logging with Serilog
• Centralized Logging with ELK Stack
• Prometheus and Grafana
• Health Checks
• Metrics Aggregation and Alerting

Module 8: Containerization

• Introduction to Containers
• Dockerizing .NET Microservices
• Creating Dockerfiles for Services
• Multi-Stage Builds
• Using Docker Compose
• Container Registry (ACR, DockerHub)
• Continuous Integration with GitHub
• Continuous Deployment to AKS
• Helm Charts for Deployment
• Rolling Updates

Module 9: Advanced Microservices

• Micro Frontends and Microservices
• Serverless and Microservices
• Hybrid Architectures
• Edge Services
• Event Streaming Architectures
• Domain-Oriented Microservices
• Service Mesh Advanced Topics
• Federated Identity across Services
• Multi-Cluster Deployments
• Best Practices for Large Systems