What do you get with a Packt Subscription?

Free for first 7 days. $19.99 p/m after that. Cancel any time!

Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!

50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

Thousands of reference materials covering every tech concept you need to stay up to date.

Subscribe now

View plans & pricing

Key benefits

Learn best practices for designing enterprise-grade software systems from a seasoned CTO

Deeper your understanding of system reliability, maintainability, and scalability

Elevate your skills to a professional level by learning the most effective software design patterns and architectural concepts

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 showing you how to implement and operate anti-fragile systems. First, you’ll divide up a system and define boundaries so that your teams can work autonomously and accelerate innovation. You’ll cover low-level event and data patterns that support the entire architecture, while getting up and running with the different autonomous service design patterns. Next, the book will focus on best practices for security, reliability, testability, observability, and performance. You’ll combine all that you've learned and build upon that foundation, exploring the methodologies of continuous experimentation, deployment, and delivery before delving into 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.

Who is this book for?

This book is for software architects who want to learn more about different software design patterns and best practices. This isn’t a beginner’s manual – you’ll need an intermediate level of programming proficiency and software design to get started. You’ll get the most out of this software design book if you already know the basics of the cloud, but it isn’t a prerequisite.

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

What do you get with a Packt Subscription?

Free for first 7 days. $19.99 p/m after that. Cancel any time!

Unlimited ad-free access to the largest independent learning library in tech. Access this title and thousands more!

50+ new titles added per month, including many first-to-market concepts and exclusive early access to books as they are being written.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

Thousands of reference materials covering every tech concept you need to stay up to date.

Subscribe now

View plans & pricing

Frequently bought together

Software Architecture Patterns for Serverless Systems

Mex$1251.99

Mex$799.99

Mex$1128.99

Total Mex$ 3,180.97

janders Jul 18, 2022

I read this book once. Learned a ton. Re-read it again and realized all the things I missed the first go-around. I miss having physical technology books around. This one was definitely worth buying a physical copy of. I particularly enjoyed learning patterns around change data capture mechanisms and how to leverage them in event-based architectures.

Amazon Verified review

Daren May Aug 20, 2021

The objective of this book is to take the reader on a journey that culminates in the ability to architect event-driven serverless systems. The book delivers 10 chapters of content that establishes foundations and build on them. This approach, along with solution templates provided via a GitHub repo, ensure that this book achieves the objective. To gain the most from the book, the reader should work through the examples to get hands-on with the patterns introduced and revisit the content to reinforce the patterns learned. Although the templates provided target AWS, the equivalent Azure services are discussed throughout the book and, with some effort, the reader can create the equivalent architecture using Azure.The book is broken into 3 sections.1. Establishing the architectural visionThe first 2 chapters focus on defining and solving the problems that more traditional architectures suffer when moved to the cloud. Chapter 1 focuses on how to conceptualize an alternative high-level architectural approach more suitable for working in dynamic environments, Chapter 2 continues the thread on how new ways of thinking are required to support applications that not only run at scale, but are also built and maintained by large autonomous teams.The content focusing on SOLID principles I found to be especially useful.2. Dissecting the Software Architecture patternsChapters 3 through 8 focus on specific aspects of an architecture that focuses on events, autonomous services and micro front-ends. Each chapter discusses the problem at hand, approaches to solving it, the associated patterns and one or more AWS templates that implement solutions. I found it useful to revisit each chapter as necessary to reinforce the separation of concerns that the patterns are establishing:* Chapter 3 discusses the presentation tier and how utilizing micro frontends can assist in decoupling monolithic frontend apps.* Chapters 4 and 5 discuss facts and eventual consistency, and how to use the cloud as database by utilizing the Command Query Responsibility Segregation (CQRS) and Change Data Capture (CDC) patterns to fortify the boundaries of autonomous services.* Chapters 6 and 7 focus on boundary service patterns specifically such as the Backend for Frontend (BFF) pattern to support end-user activities and micro apps, and how to bridge intersystem gaps with the External Service Gateway pattern.* Chapter 8 focuses on inter-service collaborations using the Control Service pattern.3. Putting everything in motionThis section brings things together so that teams can start experimenting.* Chapter 9 turns to the challenge of decoupling autonomous teams so that each team can deploy and deliver with zero downtime.* Chapter 10 closes things out with approaches on how to get started.By the end of this book, I felt like I had a much better grasp of the pattern available for building this style of enterprise architecture.

Amazon Verified review

A Resourceful Mom Feb 06, 2023

I expect to not find anything new in books like this, but I loved it! This book does a great job of reviewing concepts I already know, while introducing additional architecture patterns that expand on what I already have done in the past.This book really helps you create a productive operations model and increases your efficiency.

Amazon Verified review

Sunster Jul 30, 2021

In his book, Software Architecture Patterns for Serverless Systems, John Gilbert provides excellent patterns which designers can apply across Frontends, Backends, Infrastructure, as well as within inter-team communications. For Chapter 1, there is an overview of Software Lifecycle Development (SDLC) and how business value can be delivered through software. Gilbert describes how, in fluid environments of changing requirements, the cloud and lean methodologies allow for better reaction times. In addition, Infrastructure and application architectures, when prescribed for innovation, can enable change in design and delivery more efficiently. This can be evidenced with Infrastructure-as-code (IAC), smaller deployment releases, and continuous QA testing efforts. Chapter 2 describes how software components can be disciplined into defined boundaries, allowing modules to be more focused in scope and function. This principle, combined with extensibility and subtype replaceability, allows systems to evolve more easily over time. The ultimate goal, as Gilbert explains, is to allow independent changes to modules without breaking the application. Chapter 3 discusses patterns specific to the Frontend which can help teams to make modular, anonymous changes for evolving business needs. Central to these patterns is the concept of decomposing frontend components into "micro-apps", each with distinct functions, making deployments easier with more independent modules. Gilbert describes products which can support this concept including Jamstack and others. Chapter 4 delves into the world of asynchronous, inter-service communication patterns among loosely coupled systems and how to use such patterns to ensure data consistency across components. Gilbert describes how each component can act as an "event hub" which polices upstream and downstream consumers and producers. Complimentary to the event hub are the event lake and event sourcing patterns, which help to support the Command, Publish, Consume, Query (CPCQ) flow. Code snippets are intertwined with each pattern to provide a technical view of these patterns as well. To combat the problem of growing data, Gilbert explains, in Chapter 5, how the automous service functions can fit into one of the Data life cycle phases. By identifying the appropriate phase, services can help to address duplicity and demand for data across the entire system. The chapter helps to address caching issues as well. He also describes different approaches for sharding data to support more concurrent requests. Gilbert builds up to an entire chapter, Chapter 6, on Backend for Frontend (BFF) pattern, integral to creating Frontend boundary services for user activity. He describes the who is responsible for implementing the BFF pattern and how this pattern assists in removing inter-service dependencies by acting independent from other resources. Using CORS, the Frontend can access the Backend via the API Gateway and subsequent listener functions. On the topic of security, Gilbert outlines several steps to be taken in making BFF more secure against DDoS and Authorization attacks, to name a few. Taking to the macro-level, Gilbert explains, in Chapter 7, an anti-corruption layer for protecting egress and ingress traffic between systems to ensure protection against third-parties and external systems. Chapter 8 explores control services for mediating between boundary services. There is a background explanation of the differences between orchestration and choreography, assisting the reader to better understand how control services work in this space. In order to roll all of these patterns together, Gilbert describes changing testing practices from a one-time effort into a continuous process of discovery in Chapter 9. This process seeks to discover the right solution through feedback loops, KPIs, and MTTR, as opposed to testing that the right solution is build. In culmination, Chapter 10 describes how to begin the entire process of micro-app frontends, autonomous services, and other patterns introduced throughout the book. If you are an application architect, AWS designer, or need patterns to follow for Frontends or Backends, this book is an excellent resource which also includes code snippets to show possible implementation ideas to follow.

Amazon Verified review

Tiny Sep 22, 2021

John Gilbert takes see, learn, and do, to another level with this work. From conceptual understand to building the configuration code, this work covers it all. If you are looking for an advanced work to transition systems to a serverless architecture, this is the book for you.The first couple chapters cover the conceptual understanding, building on his background as a CTO with 30+ years of experience to explain why you should move to serverless, and the logical underpinning to that approach. The next section continues the same approach with building out basic serverless setups but adds the underpinning configuration supporting with Node.js, cloud examples, and numerous GitHub templates. Finally, the work delves into all the problems with implementing your system, fixing problems and continuing improvement. Each section has carefully labelled elements to find what you needFrom a DevOps perspective, Chapter 9 is exceptional. John works through how to get to zero-downtime with sequential deployments, planning your approach with the team, learning through experimentation, and managing your backlog. Chapter 10 follows this with a dissected approach to experimentation, highlighting how certain experiments can accelerate your transition by identifying critical points in the transition. The insight on source of record versus source of truth, as well as the need for polyglot programming is indispensable.If I had one gripe, it would be the book references back and forth across the text frequently. While this can be good in small amounts, it seems like every page was a mention to you will see this in Chapter X, or refer back to Chapter X for that discussion. The conceptual writing makes a lot of these areas extraneous, and probably could have been left out.Overall, a great work, designed for experienced folks who are looking for detailed knowledge on constructing a serverless architecture.

Amazon Verified review

Software Architecture Patterns for Serverless Systems: Architecting for innovation with events, autonomous services, and micro frontends

What do you get with a Packt Subscription?