Software Architecture Patterns for Serverless Systems: Architecting for innovation with events, autonomous services, and micro frontends
- Length: 432 pages
- Edition: 1
- Language: English
- Publisher: Packt Publishing
- Publication Date: 2021-07-30
- ISBN-10: 1800207034
- ISBN-13: 9781800207035
- Sales Rank: #884362 (See Top 100 Books)
A professional’s guide to solving complex problems while designing modern software
Key Features
- Learn best practices for designing enterprise-grade software systems
- Understand the importance of building reliable, maintainable, and scalable systems
- Become a professional software architect by learning the most effective software design patterns and architectural concepts
Book Description
As businesses are undergoing a digital transformation to keep up with competition, it is now more important than ever for IT professionals to design systems to keep up with the rate of change while maintaining stability.
This book takes you through the architectural patterns that power enterprise-grade software systems and the key architectural elements that enable change such as events, autonomous services, and micro frontends, along with demonstrating how to implement and operate anti-fragile systems. You’ll divide up a system and define boundaries so that teams can work autonomously and accelerate the pace of innovation. The book also covers low-level event and data patterns that support the entire architecture, while getting you up and running with the different autonomous service design patterns. As you progress, you’ll focus on best practices for security, reliability, testability, observability, and performance. Finally, the book combines all that you’ve learned, explaining the methodologies of continuous experimentation, deployment, and delivery before providing you with some final thoughts on how to start making progress.
By the end of this book, you’ll be able to architect your own event-driven, serverless systems that are ready to adapt and change so that you can deliver value at the pace needed by your business.
What you will learn
- Explore architectural patterns to create anti-fragile systems that thrive with change
- Focus on DevOps practices that empower self-sufficient, full-stack teams
- Build enterprise-scale serverless systems
- Apply microservices principles to the frontend
- Discover how SOLID principles apply to software and database architecture
- Create event stream processors that power the event sourcing and CQRS pattern
- Deploy a multi-regional system, including regional health checks, latency-based routing, and replication
- Explore the Strangler pattern for migrating legacy systems
Who this book is for
This book is for software architects and aspiring software architects who want to learn about different patterns and best practices to design better software. Intermediate-level experience in software development and design is required. Beginner-level knowledge of the cloud will also help you get the most out of this software design book.
Table of Contents
- Architecting for Innovation
- Defining Boundaries and Letting Go
- Taming the Presentation Tier
- Trusting Facts and Eventual Consistency
- Turning the Cloud into the Database
- A Best Friend for the Frontend
- Bridging Intersystem Gaps
- Reacting to Events with More Events
- Choreographing Deployment and Delivery
- Don’t Delay, Start Experimenting
Software Architecture Patterns for Serverless Systems Contributors About the author About the reviewers Preface Who this book is for What this book covers To get the most out of this book Download the color images Conventions used Get in touch Share Your Thoughts Section 1: Establishing an Architectural Vision Chapter 1: Architecting for Innovation Continuously delivering business value By the skin of our teeth Through high-velocity teamwork Taking control of lead time Risk mitigation Decision making Software Development Life Cycle methodology Hardware provisioning Software deployment Software structure Testing and confidence Dependencies and inter-team communication Dissecting integration styles Batch integration Spaghetti integration Real-time integration Enterprise application integration Shared database Service-oriented architecture Microservices Enabling autonomous teams with autonomous services Autonomous services – creating bulkheads Asynchronous inter-service communication Fortified boundaries Event-first – valuing facts Inversion of responsibility Events as first-class citizens Idempotence and ordered tolerance Serverless-first – creating knowledge Self-service Disposable architecture Data life cycle – fighting data gravity Micro frontends – equalizing tiers Observability – optimizing everything Organic evolution – embracing change Summary Chapter 2: Defining Boundaries and Letting Go Building on SOLID principles Single Responsibility Principle Open-Closed Principle Liskov Substitution Principle Interface Segregation Principle Dependency Inversion Principle Thinking about events first Event storming Verbs versus nouns Facts versus ephemeral messages Contracts versus notifications React and evolve Powered by an event hub Dividing a system into autonomous subsystems By actor By business unit By business capability By data life cycle By legacy system Creating subsystem bulkheads Separate cloud accounts External domain events Decomposing a subsystem into autonomous services Context diagram Micro frontend Event hub Autonomous service patterns Backend For Frontend External Service Gateways Control services Dissecting an autonomous service Repository CI/CD pipeline and GitOps Tests Stack Persistence Trilateral API Events API Gateway Functions Micro-app Shared libraries Governing without impeding Leveraging observability Work metrics Resource metrics System events Team metrics Cost metrics Facilitating a culture of robustness Audit continuously Securing the perimeter Elevating TestOps Automating account creation Summary Section 2: Dissecting the Software Architecture Patterns Chapter 3: Taming the Presentation Tier Zigzagging through time Client-side versus server-side rendering Build-time versus runtime rendering Web versus mobile Breaking up the frontend monolith By subsystem By user activity By device type By version Dissecting micro frontends The main app The index file The importmap file Micro-app registration Micro-app The entry file Root component Micro-app activation Micro-app life cycle Route-based activation Manual activation Mount points Manifest deployer Inter-application communication Designing for offline-first Transparency Status indicators Outbox Inbox Local cache Installation Read-through cache Write-through cache Live updates WebSocket Long polling Regional failover Securing the user experience OpenID Connect Conditional rendering Protected routes Passing the JWT to BFF services Observing real user activity RUM Synthetics Summary Chapter 4: Trusting Facts and Eventual Consistency Living in an eventually consistent world Staging Cooperative Atomic Consistency Transparency Facts Chain reaction Concurrency and partitions Order tolerance and idempotence Parallelism Publishing to an event hub Event bus Domain events Event envelope Event carried state transfer Substitution Internal versus external Routing and channel topology Dissecting the Event Sourcing pattern Systemwide event sourcing Event lake Perpetual storage Indexing events Replaying events Event streams Temporal storage Stream-first event sourcing Micro event stores Processing event streams Batch size Functional reactive programming Unit of work Filtering and multiplexing Mapping Connectors Designing for failure Backpressure and rate limiting Poison events Fault events Resubmission Optimizing throughput Batch size Asynchronous non-blocking I/O Pipelines and multiplexing Pipeline patterns Sharding Batching and grouping Batching Grouping Observing throughput Work metrics Iterator age Fault events Accounting for regional failover Protracted eventual consistency Regional messaging channels Summary Chapter 5: Turning the Cloud into the Database Escaping data's gravity Competing demands Insufficient capacity Intractable volumes Embracing data life cycle Create phase Use phase Analyze phase Archive phase Turning the database inside out The transaction log Derived data Dissecting the CQRS pattern Systemwide CQRS Materialized views Inbound bulkheads Live cache Capacity per reader, per query Keeping data lean Projections Time to live Implementing idempotence and order tolerance Deterministic identifiers Inverse optimistic locking Immutable event triggers Modeling data for operational performance Nodes, edges, and aggregates Sharding and partition keys Single table design examples Restaurant service Customer service Cart service Delivery service Leveraging change data capture Database-first event sourcing Soft deletes Latching Replicating across regions Multi-master replication Round-robin replication Regional failover, protracted eventual consistency, and order tolerance Observing resource metrics Capacity Throttling and errors Performance Redacting sensitive data Envelope encryption General Data Protection Regulation (GDPR) Summary Chapter 6: A Best Friend for the Frontend Focusing on user activities A BFF service is responsible for a single user activity A BFF service is owned by the frontend team Decoupled, autonomous, and resilient Dissecting the Backend for Frontend (BFF) pattern Datastore API Gateway Query and command functions Listener function Trigger function Models and connectors Choosing between GraphQL and REST REST GraphQL Implementing different kinds of BFF services Task BFF services Search BFF services Action BFF services Dashboard BFF services Reporting BFF services Archive BFF services Securing a BFF in depth The perimeter Federated identity In transit JWT authorizer JWT assertion JWT filter Last modified by Least privilege At rest Leveraging multiple regions Latency-based routing Regional health checks Regional failover Observing BFF metrics Work metrics Throttling and concurrency limits Optimizing BFF performance Function memory allocation Cold starts Timeouts and retries cache-control Summary Chapter 7: Bridging Intersystem Gaps Creating an anti-corruption layer Dissecting the External Service Gateway pattern Connectivity Semantic transformation Action versus reaction Egress Ingress Packaging Separate cloud accounts Integrating with third-party systems Egress – API call Ingress – webhook Asynchronous request response Integrating with other subsystems Egress – upstream subsystem Ingress – downstream subsystem Integrating across cloud providers Integrating with legacy systems Ingress – Change Data Capture Egress – Direct SQL Egress – circuit breaker Ingress – relay Messages Files Egress – relay Messages Files Providing an external API and SPI Ingress – event Ingress – command Egress – webhook Egress – query Tackling common data challenges Idempotence Enriching data Latching and cross-referencing Slow data resync Managing shared secrets Securing secrets Using API keys Addressing multi-regional differences Egress routing and failover Ingress routing and failover Summary Chapter 8: Reacting to Events with More Events Promoting inter-service collaboration Dissecting the Control Service pattern collect correlate collate evaluate emit expire Orchestrating business processes Entry and exit events Parallel execution Employing the Saga pattern Compensating transactions Abort events Calculating event-sourcing snapshots What is ACID 2.0? Snapshot events Implementing CEP logic Decision tables Missing events Leveraging ML for control flow Models Predictions Implementing multi-regional cron jobs Job records and events Replication and idempotence Summary Section 3: Putting Everything in Motion Chapter 9: Choreographing Deployment and Delivery Optimizing testing for continuous deployment Continuous discovery Continuous testing Focusing on risk mitigation Small batch size Decoupling deployment from release Feature flags Fail forward fast Achieving zero-downtime deployments The Robustness principle Between the frontend and its backend Between producers and consumers Between the backend and its data store Planning at multiple levels Experiments Story backlog Story mapping Story planning Task roadmaps Turning the crank Task branch workflow Create task branch Create draft pull request Ready for review Merge to master Accept canary deployment Continuous integration pipeline Unit testing Integration testing Contract testing Transitive end-to-end testing Continuous deployment pipeline Regional canary deployments Synthetics Anomaly detection Feature flipping Exploratory testing Beta users General availability Summary Chapter 10: Don't Delay, Start Experimenting Gaining trust and changing culture Establishing a vision Building momentum Constructing an architectural runway Seed and split Funding products, not projects Architecture-driven Team capacity-driven Dissecting the Strangler pattern Event-first migration Micro frontend – headless mode Retirement Addressing event-first concerns System of record versus source of truth Duplicate data is good Avoid false reuse Poly everything Polyglot programming Polyglot persistence Polycloud Summary Why subscribe? Other Books You May Enjoy Packt is searching for authors like you Share Your Thoughts
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: Software Architecture Patterns for Serverless Systems: Architecting for innovation with events, autonomous services, and micro frontends
, 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.