Preface

Welcome back! This second edition of Microservices Design Patterns in .NET builds upon the original text and reflects the evolution of the .NET and cloud-native ecosystems. You’ll still learn about the core architectural patterns that make microservices effective, but now with deeper, production-ready techniques, refreshed code, and end-to-end scenarios. The main idea is the same: decompose complex domains into smaller, cohesive services that collaborate to deliver a unified user experience, while being transparent about the new complexities this introduces and the patterns that tame them.

Why .NET remains our foundation hasn’t changed, but the platform itself has: modern .NET emphasizes performance, cross-platform reliability, and a rich toolchain that accelerates shipping high-quality distributed systems. In this edition, we expand into updated gateway patterns (including BFF), micro-frontends for domain-aligned UX, hardened security, container-hosting techniques for day-to-day development, serverless microservices on Azure, and unified observability with contemporary tooling. These topics complement the original arc (aggregation, CQRS, event sourcing, sagas, resilience, and health) and reflect how real teams build, secure, and operate microservices today.

We continue to focus on .NET for the following reasons:

• Well-maintained ecosystem: Microsoft and the community iterate quickly with clear guidance, strong docs, and first-class tooling
• Performance: Each release improves runtime and library performance, which is critical when service hops, serialization, and network latency dominate
• Cross-platform: We can build and run on Windows, macOS, or Linux, and deploy to containers, orchestrators, and serverless platforms alike
• Breadth: From web and messaging to identity, telemetry, and DevOps, .NET spans the full surface area you’ll touch in a microservices program

Our approach remains pragmatic: We explain why each pattern is used, implement it in .NET, and show how the pieces fit together in a cohesive healthcare domain so you can apply them with confidence in your own systems. We’ll cover container hosting and development patterns beyond docker run. You’ll transition from single-service containers to cohesive local stacks, registries, and orchestrators, utilizing Docker Compose and Kubernetes patterns that can be used in both production environments and day-to-day iteration and development.

We’ll also cover modern observability with OpenTelemetry, sidecars, and .NET Aspire. We go far beyond “enabling logging.” We’ll show how to standardize traces, metrics, and logs with OpenTelemetry; compare Jaeger and Prometheus; introduce sidecars and meshes where beneficial (and skip them where not); and wire it all together with .NET Aspire so that developers can see the entire system while coding.

We will revisit security for distributed boundaries. Building on token-based security, we connect identity, scopes/claims, service-to-service trust, and zero-trust network posture, striking a balance between usability and defense-in-depth across services and gateways.

These additions don’t replace the core patterns from the first edition; they refine them. You still need to choose between synchronous and asynchronous communication deliberately, partition data with intention, and design for failure from the outset. The difference is that you’ll now do so with stronger primitives and better tooling.