Intermediate to advanced
Event-driven architecture: Kafka and the outbox pattern
Design distributed systems that share state through events and local projections instead of synchronous calls, without losing messages, and build them in .NET.
Overview
This 7-day training program equips your development team with the knowledge and practical skills to design, build, and operate production-grade microservices using the .NET ecosystem. Delivered by senior architects with hands-on experience building enterprise-scale distributed systems, the program balances theory with real-world implementation patterns.
Course content
1. Introduction to microservices
- Monolith, modular monolith and microservices compared
- The cost of moving to microservices: network, consistency, operations
- When not to split
- Incremental migration with the strangler fig pattern
2. Domain-driven design
- Ubiquitous language
- Bounded contexts and context maps
- Aggregates, entities and value objects
- Domain events
- Lab: drawing the boundaries of a sample monolith
3. Service contracts
- API-first design
- REST and gRPC contracts
- Versioning and backward compatibility
- Error model and error codes
4. Services with ASP.NET Core
- Minimal APIs and controllers compared
- Dependency injection and service lifetimes
- Configuration, the options pattern and secrets
- The middleware pipeline
- Health checks
5. Architecture patterns
- Clean Architecture layers
- Vertical slice architecture
- CQRS: separating commands and queries
- Repository and specification patterns
6. Data access
- Modelling with Entity Framework Core
- Managing migrations
- Database per service
- Optimistic concurrency and concurrency tokens
- Lab: a first service with CQRS
7. Synchronous communication
- HTTP clients and HttpClientFactory
- Service-to-service calls with gRPC
- API gateways and the BFF pattern
- The risks of synchronous calls: cascading failure
8. Asynchronous communication
- Queues and publish-subscribe
- RabbitMQ, Kafka and Azure Service Bus compared
- Transactional outbox
- Idempotent consumers
- Lab: publishing events with MassTransit
9. Distributed data
- Eventual consistency
- Sagas: choreography and orchestration
- Compensating actions
- Local projections
10. Containerization
- Docker basics
- Multi-stage builds for .NET
- Image size and security scanning
- A local environment with Docker Compose
11. Kubernetes
- Pods, Deployments, Services and Ingress
- ConfigMaps and Secrets
- Resource requests and limits
- Helm charts and environments
- Lab: deploying the services to a cluster
12. Observability
- Structured logging with Serilog
- Distributed tracing with OpenTelemetry
- Metrics and dashboards
- Carrying the trace ID through the message queue
13. Resilience
- Retries and timeouts with Polly
- Circuit breakers and bulkheads
- Graceful shutdown
- Load testing basics
14. CI/CD
- GitHub Actions and Azure DevOps pipelines
- Test stages: unit, integration, contract
- Promotion between environments
- Lab: end-to-end CI/CD and a monitoring dashboard
Schedule
Each module takes about 4 hours, half a day; 56 hours in total.
- Day 1: modules 1 and 2
- Day 2: modules 3 and 4
- Day 3: modules 5 and 6
- Day 4: modules 7 and 8
- Day 5: modules 9 and 10
- Day 6: modules 11 and 12
- Day 7: modules 13 and 14
Prerequisites
- Solid experience with C# and .NET (Core 6+)
- Basic understanding of RESTful APIs and SQL databases
- Familiarity with Git and command-line tools
- Laptops with Docker Desktop and .NET 10 SDK installed
Training format
- On-site or remote: delivered at your offices or via interactive virtual sessions
- Hands-on labs: 60% practical exercises, 40% instructor-led theory
- Lab environment: pre-configured cloud-based lab environments provided
- Materials: comprehensive course handbook, code repositories, and reference architectures
- Certificate: ByteGurus training completion certificate for all participants