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

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.

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.

This is a timely and informative book written for new and experienced system architects. With the every-growing cloud services landscape, the concept of serverless systems has never been more important than it is today. The book assumes the reader has some familiarity with systems architecture and cloud servicers and does not waste time with background or filler content.The author details architectural patterns and focuses on the key elements of events, autonomous services, and micro-frontends. He also provides sufficient coverage of Robert C. Martin’s SOLID principles (Single-responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion).One of the most important sections is “Designing for Failure.” This section, albeit short, is one of the books real gems. This practical line of thinking is pervasive throughout the book and helps systems architects critically evaluate their design decisions.If you are a current system architect, or looking to get started in that field, this book makes a good companion to cloud and server knowledge.

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.

John Gilbert's intention for authoring this book was to show a cloud native, serverless-first architecture that is both enterprise grade and that enables solutions to adapt and change to change. This flexibility and ability to drive down lead time has been a goal of the software industry for many years.This book combines existing strategies and patterns to provide an event-first and highly scalable architecture that supports building autonomous subsystems. SOLID principles and patterns like CQRS are cornerstones to the architecture laid out in the book. In other words, this book is the culmination of many concepts and approaches that the industry has been embracing recently to good effect (e.g., microservices).Though all practical examples and code are using AWS services, I would not say the architecture is specific to AWS as the approach could be adapted to Azure, Google Cloud, and other cloud providers. But, AWS users will get the most benefit as they will have both theoretical and practical guidance.This book has an important place on my bookshop as it provides insight only gained from experience. Few books take architecture to this level of detail as John Gilbert has in this book. And even for architects not faced with a greenfields projects and/or are battling with breaking apart existing monoliths, this book offers many useful strategies and patterns.One of the most compelling reasons for my recommendation is the clear, honest narrative that John Gilbert uses throughout the chapters. This book contains many well explained, but not patronizing discussions of advanced challenges architects and designers face when building highly scalable solutions that adapt to change well.