What do you think?
Rate this book
Cloud Native Patterns: Designing change-tolerant software
Author Cornelia Davis likes to say that "the cloud" is more about how you design your applications than where you deploy them. Cloud Native Patterns: Designing Change-tolerant Software is your guide to developing strong applications that thrive in the dynamic, distributed, virtual world of the cloud. This book presents a mental model for cloud-native applications, along with the patterns, practices, and tooling that sets them apart. In it, you'll find realistic examples and expert advice for working with apps, data, services, routing, and more.
400 pages, Paperback
Published June 1, 2019
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 24 of 24 reviews
July 24, 2019
Primo: it's a good book.
Secundo: it's a well-written book.
Tertio: it's very "one-sided" as it presents CN is a singular way - a "microservice" way. Which IMHO is an issue as "change-tolerant" (& resilient, & fault-tolerant, & scalable, ...) software can be achieved in some other ways as well (life is not black & white, ya know ...).
What I really liked is:
* the way Cornelia described potential usage of replicated transaction log (but I disagree with pre-determining it has to be "eventsourcing")
* very well described difference between RPC-style synchro integration & event-style data replication
* the general approach to examples (the cases is VERY simple, yet it's good enough to illustrate the concepts)
* simple, yet sufficient description of basic resilience patterns - e.g. circuit breakers & bulk-heading
In the end, it's a very good book. IMHO it perfectly fits the mid way between 4 stars & 5 stars, but just to emphasize the fact that it's worth reading, I'm marking it with my stamp of quality (5 stars).
Secundo: it's a well-written book.
Tertio: it's very "one-sided" as it presents CN is a singular way - a "microservice" way. Which IMHO is an issue as "change-tolerant" (& resilient, & fault-tolerant, & scalable, ...) software can be achieved in some other ways as well (life is not black & white, ya know ...).
What I really liked is:
* the way Cornelia described potential usage of replicated transaction log (but I disagree with pre-determining it has to be "eventsourcing")
* very well described difference between RPC-style synchro integration & event-style data replication
* the general approach to examples (the cases is VERY simple, yet it's good enough to illustrate the concepts)
* simple, yet sufficient description of basic resilience patterns - e.g. circuit breakers & bulk-heading
In the end, it's a very good book. IMHO it perfectly fits the mid way between 4 stars & 5 stars, but just to emphasize the fact that it's worth reading, I'm marking it with my stamp of quality (5 stars).
January 28, 2021
I have great respect to Cornelia and her work but to be honest I didnt manage to finish the book (I read 8 out of 12 chapters). As another reviewer pointed out there is a lot of text, again and again to explain things that do not need that much text, and I got tired reading the obvious. The book could be half the length and still not miss anything. Maybe as an introduction book its good but if you already worked even a bit with K8s and/or Cloud Services, I dont think the book has much to offer you.
December 3, 2019
I found the book rather convoluted; there were several code examples, and they were all outdated since none of them work with Java 11 or higher (modules...). The author needs a lot of text to explain things that do not need that much text. I prefer Spring Microservices in Action
May 13, 2023
Pros:
- gives a good overview of patterns for a very beginner, unfamiliar with world of Kubernetes, microservices etc.
- live, runnable examples. It's great to be able to follow and verify authors words, see how application can break and recover when you imitate certain failures, how code and behaviour changes over time.
Not-really-cons:
- really aimed at beginners. While with some other beginner-friendly books (for instance, Sam Newman's books on microservices) I still felt like I definitely learnt something, here - not so much.
Cons:
- Often explanation of how certain pattern works was basically missing. For instance, circuit breaker - after discussing what it is, author just shows "put this annotation on your Spring app, it will handle that". Discussion on Kafka as Event log was much more detailed - that's good.
- I don't really agree with Event Sourcing chapter, initial idea and explanation of pattern. Definitely there are some thoughts there, but in my mind they don't map in the way it was explained in the book.
- gives a good overview of patterns for a very beginner, unfamiliar with world of Kubernetes, microservices etc.
- live, runnable examples. It's great to be able to follow and verify authors words, see how application can break and recover when you imitate certain failures, how code and behaviour changes over time.
Not-really-cons:
- really aimed at beginners. While with some other beginner-friendly books (for instance, Sam Newman's books on microservices) I still felt like I definitely learnt something, here - not so much.
Cons:
- Often explanation of how certain pattern works was basically missing. For instance, circuit breaker - after discussing what it is, author just shows "put this annotation on your Spring app, it will handle that". Discussion on Kafka as Event log was much more detailed - that's good.
- I don't really agree with Event Sourcing chapter, initial idea and explanation of pattern. Definitely there are some thoughts there, but in my mind they don't map in the way it was explained in the book.
March 25, 2022
I enjoyed reading the book a lot and do recommend it for every software engineer as a good first book in cloud direction.
Particularly the first part of it gives you a good overview and perfectly draws the big picture in the cloud-native world, emphasizing the core ideas which really define the architectural principles of distributed software solutions.
However, I see some issues in organizing the book. While the first part is general and technology agnostic, the second one dives too much into technical details and a big portion of it consists of the code fragments of a single framework and particular tools. I would prefer to discuss the actual patterns in the same, language and tool agonistic ways as in the first part of the book.
Overall, I highly recommend it as a gateway for the cloud-native world.
Particularly the first part of it gives you a good overview and perfectly draws the big picture in the cloud-native world, emphasizing the core ideas which really define the architectural principles of distributed software solutions.
However, I see some issues in organizing the book. While the first part is general and technology agnostic, the second one dives too much into technical details and a big portion of it consists of the code fragments of a single framework and particular tools. I would prefer to discuss the actual patterns in the same, language and tool agonistic ways as in the first part of the book.
Overall, I highly recommend it as a gateway for the cloud-native world.
January 18, 2020
Good explanation of a few frequently used cloud patterns. Worth noting, the main focus shifts a lot to the Java stack. As result, you might be disappointed unless you're Java developer. Obviously, the book would be better if an author considered more platform agnostic approaches.
May 18, 2019
(review of MEAP V11)
May 10, 2020
This book is a primer on how to build highly redundant, resilient, change-tolerant software for the cloud. It doesn't claim to be a primer, but it is highly redundant itself in a good way, typically presenting the same concept three ways: as text, as a code sample and as a diagram. And it doesn't go very deep into the hard questions at all. If you like your computer books, deep, dense and non-repetitive, this is probably not the book for you.
All of the example are built using the Spring Java framework (the author works at Pivotal, who developed Spring) and built using a microservice architecture. Which is certainly one way to develop for a cloud. There is little discussion of issues with eventual consistency, the difficulties with source of truth in a highly distributed environment or the sort of problems you shouldn't tackle in a highly distributed manner. For that sort of question the author recommends (at the very end) Designing Data-Intensive Applications by Martin Kleppmann, which I had read before this book, which was a kind of a spoiler at times.
Don't get me wrong -- when I described this book as a primer I didn't mean there wasn't a lot of great stuff, like how to build loosely coupled applications and why, about why events are cool, caching and logging in an unreliable environment, about how to deploy and debug the resultant systems. But I also sort of suspect this is the book the author wanted to have to hand to people who thought they knew what it was to program for the cloud, but didn't really didn't, so she wouldn't have to explain the basics one more blasted time. It was certainly useful for me.
All of the example are built using the Spring Java framework (the author works at Pivotal, who developed Spring) and built using a microservice architecture. Which is certainly one way to develop for a cloud. There is little discussion of issues with eventual consistency, the difficulties with source of truth in a highly distributed environment or the sort of problems you shouldn't tackle in a highly distributed manner. For that sort of question the author recommends (at the very end) Designing Data-Intensive Applications by Martin Kleppmann, which I had read before this book, which was a kind of a spoiler at times.
Don't get me wrong -- when I described this book as a primer I didn't mean there wasn't a lot of great stuff, like how to build loosely coupled applications and why, about why events are cool, caching and logging in an unreliable environment, about how to deploy and debug the resultant systems. But I also sort of suspect this is the book the author wanted to have to hand to people who thought they knew what it was to program for the cloud, but didn't really didn't, so she wouldn't have to explain the basics one more blasted time. It was certainly useful for me.
February 7, 2023
An interesting, valuable and well-written book by an experienced author. I enjoyed it!
What I liked:
- A holistic core idea that you can feel from the beginning till the end of the reading. It's not a set of chapters about different and disconnected patterns. The main message (designing change-tolerant software) is explicit and all the pieces fit together.
- Cornelia Davis has a beautiful skill of presenting and explaining issues and knowledge. Most of the things are broken into small enough parts. The diagrams have various forms and are definitely helpful. I didn't have a moment where I couldn't comprehend something (and it's not always the case!).
- The example project is quite well balanced between simplicity and complexity. I like the usage of Kubernetess and some fancy Spring frameworks for retrying and other concerns.
- The message itself. While at times I was expecting a little more advanced stuff, I have a premonition of the importance of the book. There are many companies that have not made the leap from the 90s / 00s sofware architecture to the modern Cloud Native approach. All the aspects described here are super important (redundancy, stateles, metrics, logs aggregation, EDA etc.). I believe that "Cloud Native Patterns" is an excellent entry point for the first step.
- Oh, the list of patterns on the inside pages of book covers is heartbreaking. I don't why (probably it's not rational at all) but it always cheers me up.
What I didn't like:
- I mentioned it before. I expected more innovative nad fresh knowledge. Not so complicated concepts like retries or service discovery via DNS are really explained in details.
To sum it up, I think that this should be a must read for all the Cloud Software Engineers. If you already have a couple years of experience in that area then you probably won't take too much new terms or concepts. However, it can still be a nice way to organize your knowledge.
What I liked:
- A holistic core idea that you can feel from the beginning till the end of the reading. It's not a set of chapters about different and disconnected patterns. The main message (designing change-tolerant software) is explicit and all the pieces fit together.
- Cornelia Davis has a beautiful skill of presenting and explaining issues and knowledge. Most of the things are broken into small enough parts. The diagrams have various forms and are definitely helpful. I didn't have a moment where I couldn't comprehend something (and it's not always the case!).
- The example project is quite well balanced between simplicity and complexity. I like the usage of Kubernetess and some fancy Spring frameworks for retrying and other concerns.
- The message itself. While at times I was expecting a little more advanced stuff, I have a premonition of the importance of the book. There are many companies that have not made the leap from the 90s / 00s sofware architecture to the modern Cloud Native approach. All the aspects described here are super important (redundancy, stateles, metrics, logs aggregation, EDA etc.). I believe that "Cloud Native Patterns" is an excellent entry point for the first step.
- Oh, the list of patterns on the inside pages of book covers is heartbreaking. I don't why (probably it's not rational at all) but it always cheers me up.
What I didn't like:
- I mentioned it before. I expected more innovative nad fresh knowledge. Not so complicated concepts like retries or service discovery via DNS are really explained in details.
To sum it up, I think that this should be a must read for all the Cloud Software Engineers. If you already have a couple years of experience in that area then you probably won't take too much new terms or concepts. However, it can still be a nice way to organize your knowledge.
January 1, 2021
The author does a good job of introducing Cloud Native, makes a persuasive case, and hits a lot of high-value patterns. She wove in the role of Cloud Platforms and tools like Kubernetes that have developed a large footprint in the ecosystem and will likely help shape the future of Cloud Native.
Some of the examples, especially the ones requiring following along with specific programming steps interrupted the flow of the narrative and made it difficult to follow the key points but the chapter summaries helped there.
Overall, I think the book is a good read, though the chapters that dive into the weeds will need to be updated in two or three years, as these patterns evolve and likely new PaaS / SaaS abstractions in cloud architecture and Cloud Platforms gain traction.
Some of the examples, especially the ones requiring following along with specific programming steps interrupted the flow of the narrative and made it difficult to follow the key points but the chapter summaries helped there.
Overall, I think the book is a good read, though the chapters that dive into the weeds will need to be updated in two or three years, as these patterns evolve and likely new PaaS / SaaS abstractions in cloud architecture and Cloud Platforms gain traction.
November 7, 2021
The book provides a plethora of information on what 'Cloud Native' means and goes to describe how to get from monolith to cloud native in subsequent chapters. "Factor-in failure" seems to be the mantra to design and develop effective APIs employing redundancy and resiliency all the way.
Event-driven microservices, handling secrets through configuration, staying stateless to help in scaling out, comparing blue-green vs rolling upgrades vs parallel deployments to suit your use case, retries and circuit breaker to assist with ever-changing infrastructure are things you'll learn in part 2 of the book.
As mentioned by others, it's a little verbose - seems like the author introduced redundancy in the book as well - no pun intended.
Event-driven microservices, handling secrets through configuration, staying stateless to help in scaling out, comparing blue-green vs rolling upgrades vs parallel deployments to suit your use case, retries and circuit breaker to assist with ever-changing infrastructure are things you'll learn in part 2 of the book.
As mentioned by others, it's a little verbose - seems like the author introduced redundancy in the book as well - no pun intended.
December 26, 2019
This is a great read, it enforces what we are doing and explains the why.
* What does cloud native actually mean ?
* Failure is the norm, not an exception.
* Cloud Native Platforms, more than just a place to run your images
* No Snowflakes
* Stateless services, advantages
* What does it mean to be Event Driven ?
* Cloud Native Configuration, why do we need it and ways to implement it.
* Advantage of using Circuit Breakers, Retries importance of using this to build resilient software.
* Service Mesh (Istio and envoy) alternative to baking in retries and circuit breakers into your software, in addition provides other features.
* What does cloud native actually mean ?
* Failure is the norm, not an exception.
* Cloud Native Platforms, more than just a place to run your images
* No Snowflakes
* Stateless services, advantages
* What does it mean to be Event Driven ?
* Cloud Native Configuration, why do we need it and ways to implement it.
* Advantage of using Circuit Breakers, Retries importance of using this to build resilient software.
* Service Mesh (Istio and envoy) alternative to baking in retries and circuit breakers into your software, in addition provides other features.
January 21, 2020
Read this for the January 2020 Austin Computer Book Club meetup, and really enjoyed it. The author has a painstaking and thorough style, which took a little getting used to, but which by the end I really appreciated. Concepts are presented as solutions to real-world problems, in a gradual and understandable way, even to the extent that less-than-perfect intermediate steps are worked through. I feel like I learned a lot, not just about key concepts in this area, but also about how to approach these kinds of systems overall. Recommended.
October 19, 2021
I did contemplate giving the book 5 Stars but then decided not to. Firstly, if you need to modernize any applications or architect an app from scratch, I highly recommend the book. It gives a good summary of the architectural choices that one must consider and highlights the pitfalls that you will invariably encounter. My biggest issue is with the Cloud Native patterns. I’m not convinced it’s specific to cloud of has anything to do with Cloud computing. The author uses Kubernetes to demonstrate a lot of the concepts. This is rather convenient as Cloud architectures often have different compute platforms and not all of them give you the convenience that comes with Kubernetes. It’s a good book, it could be better.
July 4, 2019
Well, the book describes various patterns that form what is called "cloud native patterns". I starts with an example written in the "old way", not really ready for cloud, and then gradually refactors it to the final, "cloud native" form.
Really good source of knowledge, especially for someone who just starts her journey with cloud.
Really good source of knowledge, especially for someone who just starts her journey with cloud.
March 8, 2021
It is an excellent book! You will learn from the beginning about why do we need cloud-native applications today, how to create them, why the patterns are used, all of this with code examples, architecture drawing, etc.
I recommend this book to everyone that works or wants to work with cloud-native software.
I recommend this book to everyone that works or wants to work with cloud-native software.
June 20, 2023
Good overview of cloud native (mostly micro service) approaches to software development. I liked especially the part about the principles of being prepared for change. As most of the content was already familiar to me, code examples felt unnecessary — but they can probably provide clarity to those new to the topic.
January 18, 2020
This is a very interesting book, covering cloud concepts from developer point of view. While there are many other books focused on cloud infrastructure, this one is on patterns and approaches. Definitely recommend read for dev people. It’s also cloud agnostic.
March 15, 2020
No real new information here for me, next to the last piece about event sourcing. Still, this is a good read for anyone who wants to break down monoliths and write resilient cloud native applications.
April 2, 2020
Well written book about fundamental cloud native patterns. The author clearly explains the why behind cloud native and each pattern, with code examples. But, if you already know these patterns and the problems that they intend to solve, this book might not be for you.
August 5, 2021
No cloud here. This is bigger and better than cloud. This is cloud native. Awesome overviews, details, and logical progressions to show not just how, but why.
A must read for anyone working in the software industry in any capacity. No coding knowledge required
A must read for anyone working in the software industry in any capacity. No coding knowledge required
March 9, 2023
Good enough and well detailed book on basics of designing distributed cloud-native applications. Well suited for newbies or those who hasn't tried developing of modern applications in cloud. But, probably skilled cloud-oriented developers will not find this book any useful for them
June 12, 2020
Not much I haven't know before, but it's well structured and offers lots of examples (Java/Maven/K8) to follow along.
June 23, 2023
Would add words "introductio to" to the begining of books name, but still, worth reading even if you already have some experience with cloud architecture.
Displaying 1 - 24 of 24 reviews