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
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 foun...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham, England :
Packt Publishing, Limited
[2023]
|
| Edición: | 1st ed |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009729739006719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- Contributors
- About the reviewers
- Table of Contents
- Preface
- 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
- Technical requirements
- 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
- Technical requirements
- 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
- Other Books You May Enjoy.
