Implementing Event-Driven Microservices Architecture in .NET 7: Develop event-based distributed apps that can scale with ever-changing business demands using C# 11 and .NET 7
- Length: 326 pages
- Edition: 1
- Language: English
- Publisher: Packt Publishing
- Publication Date: 2023-03-17
- ISBN-10: 1803232781
- ISBN-13: 9781803232782
- Sales Rank: #3127783 (See Top 100 Books)
Implement modern design patterns that leverage domain-driven data, to achieve resiliency and scalability for data-dependent applications
Key Features
- Learn the tenets of event-driven architecture, coupled with reliable design patterns to enhance your knowledge of distributed systems and build a foundation for professional growth
- Understand how to translate business goals and drivers into a domain model that can be used to develop an app that enables those goals and drivers
- Identify areas to enhance development and ensure operational support through the architectural design process
Book Description
This book will guide you through various hands-on practical examples for implementing event-driven microservices architecture using C# 11 and .NET 7. It has been divided into three distinct sections, each focusing on different aspects of this implementation.
The first section will cover the new features of .NET 7 that will make developing applications using EDA patterns easier, the sample application that will be used throughout the book, and how the core tenets of domain-driven design (DDD) are implemented in .NET 7.
The second section will review the various components of a local environment setup, the containerization of code, testing, deployment, and the observability of microservices using an EDA approach.
The third section will guide you through the need for scalability and service resilience within the application, along with implementation details related to elastic and autoscale components. You’ll also cover how proper telemetry helps to automatically drive scaling events. In addition, the topic of observability is revisited using examples of service discovery and microservice inventories.
By the end of this book, you’ll be able to identify and catalog domains, events, and bounded contexts to be used for the design and development of a resilient microservices architecture.
What you will learn
- Explore .NET 7 and how it enables the development of applications using EDA
- Understand messaging protocols and producer/consumer patterns and how to implement them in .NET 7
- Test and deploy applications written in .NET 7 and designed using EDA principles
- Account for scaling and resiliency in microservices
- Collect and learn from telemetry at the platform and application level
- Get to grips with the testing and deployment of microservices
Who this book is for
This book will help .NET developers and architects looking to leverage or pivot to microservices while using a domain-driven event model.
Implementing Event-Driven Microservices Architecture in .NET 7 Contributors About the authors About the reviewers Preface Who this book is for What this book covers To get the most out of this book Download the example code files Download the color images Conventions used Get in touch Share Your Thoughts Download a free PDF copy of this book Part 1:Event-Driven Architecture and .NET 7 Chapter 1: The Sample Application Technical requirements Exploring business drivers and the application Reviewing the domain model Assessing architectural structures and paradigms A high-level logical architecture Event sourcing Command-Query Responsibility Segregation Reviewing the implementation details The Visual Studio solution topology Identity and Access Management considerations Event structure and schema Local development and debugging New .NET 7 features Summary Questions Further reading Chapter 2: The Producer-Consumer Pattern Technical requirements Examining producers and consumers Relating to real-world examples Enabling event-driven architectures Understanding the adoption curve Exploring implementation details in code The producer code The consumer code Event handling Reviewing implementation details in infrastructure Topics Streams and tables Aggregate storage Summary Questions Further reading Chapter 3: Message Brokers Technical requirements What is a message broker? Queue-based technology Cache-based technology Stream-based technology Inspecting messaging protocols, schemas, and delivery patterns Messaging protocols Standard and custom schemas Message delivery patterns Implementing message broker technologies Reviewing essential Kafka components Enabling resiliency and scalability Summary Questions Further reading Chapter 4: Domain Model and Asynchronous Events Technical requirements Solution structure Core library review Reviewing domain structures and components Equipment Station Maintenance Scheduling Notifications Passenger Identification Using asynchronous actions Benefits of asynchronous programming Asynchronous parallel processing Summary Questions Further reading Part 2:Testing and Deploying Microservices Chapter 5: Containerization and Local Environment Setup Technical requirements Reviewing containerization fundamentals Development benefits Setting up the local environment Creating local infrastructure using Docker Leveraging GitHub Codespaces and Dev Containers Using Dockerfiles to build and run locally Sequential versus multi-stage files Adding services to the Docker Compose file Summary Questions Further reading Chapter 6: Localized Testing and Debugging of Microservices Technical requirements Configuring orchestration and containers Everything as Code (EaC) Creating container images Debugging in containers Debugging individual microservices Orchestrating and debugging all services Fixing the Debug custom image Testing against containers Functionality testing Load testing Summary Questions Further reading Chapter 7: Microservice Observability Technical requirements Observability Metrics Logs Traces Liveness and readiness Liveness endpoints Readiness endpoints Aggregation of logs Creating an Azure Application Insights instance Streaming telemetry to Application Insights Streaming logs to Application Insights Correlation and causation Producing logging and an event payload with correlation and causation IDs Consumer logging with consistent correlation and causation IDs Summary Questions Further reading Chapter 8: CI/CD Pipelines and Integrated Testing Reviewing common CI/CD patterns Environment-based Artifact management Triggers and gating Feature flags Enabling GitHub Actions for CI/CD implementation GitHub Actions for continuous integration GitHub Actions for continuous deployment Choosing an Integration Test Suite Methodology Summary Questions Further reading Chapter 9: Fault Injection and Chaos Testing Technical requirements Fault tolerance and fault injection Anticipating and tolerating faults Using your faults against you Chaos testing The order of chaos engineering Implementing fault injection and chaos tests Starting with Chaos Mesh Using Azure Chaos Studio Summary Questions Further reading Part 3:Testing and Deploying Microservices Chapter 10: Modern Design Patterns for Scalability Mechanisms for autoscaling Compute and CPU load Disk and I/O load Request and network load Memory-intensive operations Implementing autoscaling for Kubernetes services Native Kubernetes options Cloud platform options Third-party plugins Implementing autoscaling for Azure App Service Common platform options Adjustments for Web Apps Adjustments for API Apps Summary Questions Further reading Chapter 11: Minimizing Data Loss Technical requirements Preventing data loss Data consistency paradigms ACID paradigm/immediate consistency BASE paradigm / eventual consistency The Saga pattern Command query responsibility segregation (CQRS) Identifying acceptable data loss Acceptable and unacceptable data loss Methods of data loss Delivery guarantees At-most-once delivery At-least-once delivery Effectively-once delivery Data loss implications Summary Questions Further reading Chapter 12: Service and Application Resiliency Technical requirements Resiliency through cloud-native patterns Redundancy and enabling business continuity Event retries and continuity Local data redundancy Infrastructure continuity Graceful communication between services Common results Summary Questions Further reading Chapter 13: Telemetry Capture and Integration Technical requirements Application- versus service- versus component-level telemetry Implementing non-intrusive telemetry capture Implementing custom telemetry capture Bubbling up meaningful information Metric ingestion with the Prometheus exporter Distributed tracing using the Jaeger exporter Summary Questions Further reading Chapter 14: Observability Revisited Technical requirements Sharing API services Generating service information OpenAPI specification A brief history of Swagger Generating the Swagger documentation Service discovery It’s not quite load balancing… Exploring Consul Service discovery/registration Service resolution Service publishing Azure API Management Service cataloging Summary Questions Further reading Assessments Chapter 1, The Sample Application Chapter 2, The Producer-Consumer Pattern Chapter 3, Message Brokers Chapter 4, Domain Model and Asynchronous Events Chapter 5, Containerization and Local Environment Setup Chapter 6, Localized Testing and Debugging of Microservices Chapter 7, Microservice Observability Chapter 8, CI/CD Pipelines and Integrated Testing Chapter 9, Fault Injection and Chaos Testing Chapter 10, Modern Design Patterns for Scalability Chapter 11, Minimizing Data Loss Chapter 12, Service and Application Resiliency Chapter 13, Telemetry Capture and Integration Chapter 14, Observability Revisited Index Why subscribe? Other Books You May Enjoy Packt is searching for authors like you Share Your Thoughts Download a free PDF copy of this book
Donate to keep this site alive
How to download source code?
1. Go to: https://github.com/PacktPublishing
2. In the Find a repository… box, search the book title: Implementing Event-Driven Microservices Architecture in .NET 7: Develop event-based distributed apps that can scale with ever-changing business demands using C# 11 and .NET 7
, sometime you may not get the results, please search the main title.
3. Click the book title in the search results.
3. Click Code to download.
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.