Practical Event-Driven Microservices Architecture: Building Sustainable and Highly Scalable Event-Driven Microservices

by Hugo Filipe Oliveira Rocha

In the simplest terms, event-driven architectures are like onions; they are manageable as a single layer (like a monolith) but when you get into them, they begin to cascade apart and you quickly realize that there are many complex layers (distributed microservices architecture). And that’s when the tears begin.

This prescriptive guide takes you through the steps of moving a platform with millions of users from a monolith to a microservices event-driven architecture. You will learn about the challenges and complexities that arise in high-throughput environments that often contain upwards of hundreds of microservices. This book is designed to be your single best resource for learning how to apply event-driven architectures in real-world scenarios and offers hundreds of patterns to overcome the common and not so common challenges.

While event-driven architectures have been the standard for decoupled, pluggable, evolutionary architectures for years, they have onlyrecently been adopted by enterprises for the purpose of distributed microservices and there is little information about adopting them. Using them at scale can save valuable resources, but requires different considerations, including the added complexity of supporting several moving parts and getting the event schema right from the start in order to avoid large restructuring later on.

Author Hugo Rocha understands that these kinds of challenges, as well as many others, need to be considered from the beginning, and helps teach you the mindset needed to create a deliberate strategy upfront. This book offers learning approaches and patterns to get you up to speed in order to sustainably build and manage event-driven architectures.




What You Will Learn



Understand the real-world challenges of event-driven architectures and the patterns to deal with those challenges and the trade-offs of each solutionLeverage the advantages of event-driven architectures to build scalable solutions and address legacy applicationsPlan successful future implementations to avoid common pitfalls and apply proven patterns to deal with challenges in a real-world platform with millions of usersDecide whether event-driven solutions are the right choice for the requirements at handDiscuss and understand advanced concepts about event-driven architectures

 

Who Is This Book For
Software engineers and software architects. Anyone currently working with microservice architectures, primarily event-driven microservices, will greatly benefit from this book. Readers working with monoliths will benefit, as the book explores migration from a monolithic application to an event-driven microservice architecture.

Genres: Computer Science, Design

584 pages, Kindle Edition

Published November 10, 2021

Reviews

[Miguel Alho]

This is one of the best books I've come across in terms of event-driven services as it covers pretty much all the topics you need to consider when designing and developing this type of services. I think it is the right book to read if you're on a learning path towards event-driven architectures, or are currently going through a build of one. It's probably the first time I've found alot of the covered topics in a single book - most of the times, you could only find these scattered through a bunch of blog posts, which makes going through and learning about EDAs much more structured. Also, the author is not selling EDA as a silver-bullet and covers most or all of the pitfalls, caveats and failure modes you can find and suggests many ways to work through them. You'll get all the warnings you'll need before treading those waters.

It's a great read, worth reading after Nygard's "Release It" and Newman's "Building Microservices" and a DDD book/video set (like Vernon's "Domain-Driven Design" distilled) as it builds on many of the ideas (i feel) were introduced in those.

I also feel that this book, based on the coverage quality of the topics, can become a key references in the industry, with an impact on readers similar to what Nyagrd's "Release It" had on me - it was my first contact with so many topics when I first read it like Circuit Breakers and Cascading Failures, that it had a strong impact on my thinking of system design. Having gone through a build of an EDA with legacy migrations in the past 2 years, the contents match many of the learnings I had, including all the pitfalls, and would have been extremely useful if it had existed when I started.

If you're getting into EDA, you won't regret picking this one up.

[Roman Safronov · Rating 5 out of 5]

This book is a practical guide to design, implementation and release of EDA-based solutions.
Like the majority of recently released books it is a compilation of earlier works (books, papers and blog posts), but the mix is right and reference material is good. Only the last chapter covering QA strategy felt too shallow.

I suggest to read it along with DDIA for more in-depth implementation questions and Software Engineering at Google for scaling/process side.

[Ismail Mayat · Rating 5 out of 5]

Anyone doing event driven architectures needs to own a copy. It will be sat on my desk to be used as a reference.

[Marius Sørensen · Rating 4 out of 5]

7.5/10

Pretty good. Some weird problems that could be easily avoided by using an editor, typos and incomprehensible sentences and stuff.