Three ASP.NET Core projects talking over HTTP is not a microservices architecture.
It is three brittle applications sharing one set of problems. An architecture earns the name only when each service owns its data, survives the failure of its neighbours, communicates through well-chosen patterns, and recovers from the particular class of accidents that distributed systems invite.
This book is about that difference and the unglamorous engineering work that closes it.
You will build CommerceFlow, a complete order-processing system of four cooperating ASP.NET Core 10 services and a message broker, and teach it to do the hard things properly. Not with toy examples, but with the patterns production systems actually depend on.
What you will build
- Design service boundaries with domain-driven design instead of guesswork
- Route public traffic through a YARP API gateway and expose a high-performance internal contract over gRPC
- Publish and consume integration events through RabbitMQ with publisher confirms and consumer acknowledgments
- Keep isolated PostgreSQL databases consistent with the transactional outbox, inbox and saga patterns
- Compensate failed workflows instead of pretending distributed rollbacks exist
- Survive partial failure with retries, exponential backoff, circuit breakers, timeouts and health checks
- Secure the edge with JWT authentication, identity forwarding and rate limiting
- Follow one request across every service with structured logging and OpenTelemetry
- Containerize each service and run the whole system under Docker Compose
- Test the system and its failure modes with xUnit, WebApplicationFactory and Testcontainers
Inside
Understanding microservices architecture - Building services with ASP.NET Core 10 - API gateways and service communication - Event-driven microservices with RabbitMQ - Distributed data management and consistency - Resilience and security - Containerizing and testing - Completing a real-world application. Plus seven appendices covering setup, the full solution layout, gateway configuration, gRPC, messaging, Docker Compose and further reading.
Who this book is for
C# developers comfortable building a single ASP.NET Core application who are ready to build and operate several. No prior distributed-systems experience is assumed. Every pattern is introduced because the system needs it, implemented in full, and then tested.
An honest scope
This book covers correctness, not everything. Kubernetes and cloud deployment belong to Book 5; caching and performance tuning belong to Book 6. What you get here is a distributed system honest about its own failure modes, and the judgment to read someone else's without flinching at terms like idempotent consumer, compensating transaction or circuit breaker.
Book 4 of The Modern ASP.NET Core Engineering Series. Built on .NET 10, C# 14, PostgreSQL, RabbitMQ and Docker.
Scroll up and start building services that survive each other.