Software Architecture Fundamentals 2nd Edition, Chapter 18: Microservices

Finally, we arrive at everyone's favorite "cool-kid" architecture, Microservices. We actually don't spend a lot of time describing the topology and features of microservices, which are well documented pretty much everywhere. Instead, we chatted about things that don't fit in a book: the origins of microservices, why it worked, where it hasn't worked well, and the lessons we've learned with more than a decade of this architectural style. Come join us for a wide-ranging conversation not without some controversy but always collegial. 

Continuing our survey of architectures styles, we uncover a style that is surging in popularity over the last few years, the modular monolith. Inspired by the principles in Domain-driven Design, this style tries to achieve many of the benefits of microservices but inside the convenience of a monolithic architecture. Join us as we talk about the properties of this style, when it's a better alternative to others (including microservices), and more about this popular style.

Continuing on our survey of architectural styles, this month we brush against Orchestration-driven Service-oriented Architecture (SOA), a dinosaur that roamed the earth more than a decade ago but contains many lessons that led to microservices and related architectures. In this episode, we describe the topology of SOA, the goals and motivations, and why it failed, along with some important lessons. Not just rants about the problems in SOA (although there are a few), this episode highlights how and why we went through that architectural waystation.

No, it has nothing to do with outer space but rather tuple space. We continue our survey of architectural styles with an exotic one, Space-based architecture, which answers the question: how can you design an architecture that can handle several hundred thousand simultaneous requests...before cloud providers existed. Today, this architecture style is used for caching and other high volume problems. Join us as we describe this architecture style, how it works, what's good and bad, and how it's still useful today.

We continue our survey of architectural styles with a widely misunderstood one, Event-driven Architecture. The first thing we attack on this episode is how this style and microservices are alike and, more importantly, differ. We talk about common usages of this style, variations based on events versus messages, data strategies, and a host of other details, some not found in the book (including some extended metaphors). Join us as we cover one of the most powerful distributed architecture styles.

Continuing our relentless cataloging of architectural styles, in this episode we cover the service-based architecture. This is the only style in the book with a bespoke name, created by Mark and Neal, because it appeared in the wild so often as a pragmatic compromise on the extremes of microservices. In this episode, we describe the origins of the style, untangle the name from other architectures that include the word "service", and discuss trade-offs and ramifications beyond what we covered in the book, leading to a wide-ranging conversation. 

Continuing our catalog of architectural styles, in this episode we cover the Microkernel architecture. Sometimes also known as a plug-in architecture, we introduce the idea of "microkernality" in this episode and talk about the myriad ways this architecture style appears in the real world. We cover a lot of information in this episode, expanding on the material in the book chapter.

Continuing our exploration of architecture styles, this month we go deep on the Pipeline (or Pipes and Filters) Style. This episode explores different types of filters, uses of this architecture, and how it differs from other similar styles.

This is the first of many chapters that each do a deep-dive on a particular architecture style; in this chapter, we start with the layered monolithic architecture, also known by many as the default architecture. We describe the topology, communication, data strategies, and philosophy underlying this style. We also point to ways to govern this style and how to adapt the style without breaking it.

The outcome of the architectural characteristics and logical component analysis we've been undertaking over the last few chapters is for an architect to choose an appropriate architecture style most suitable for the problem and capabilities we must build to be successful. Thus, this chapter starts a deep-dive on the most popular generic architecture styles that architects should be aware of. This chapter separates the concept of style versus pattern and describe how we'll tackle each fundamental style.