Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Building Microservices: Designing Fine-Grained Systems 1st Edition
There is a newer edition of this item:
Distributed systems have become more fine-grained in the past 10 years, shifting from code-heavy monolithic applications to smaller, self-contained microservices. But developing these systems brings its own set of headaches. With lots of examples and practical advice, this book takes a holistic view of the topics that system architects and administrators must consider when building, managing, and evolving microservice architectures.
Microservice technologies are moving quickly. Author Sam Newman provides you with a firm grounding in the concepts while diving into current solutions for modeling, integrating, testing, deploying, and monitoring your own autonomous services. You’ll follow a fictional company throughout the book to learn how building a microservice architecture affects a single domain.
- Discover how microservices allow you to align your system design with your organization’s goals
- Learn options for integrating a service with the rest of your system
- Take an incremental approach when splitting monolithic codebases
- Deploy individual microservices through continuous integration
- Examine the complexities of testing and monitoring distributed services
- Manage security with user-to-service and service-to-service models
- Understand the challenges of scaling microservice architectures.
- ISBN-101491950358
- ISBN-13978-1491950357
- Edition1st
- PublisherO'Reilly Media
- Publication dateMarch 17, 2015
- LanguageEnglish
- Dimensions7 x 0.75 x 9.25 inches
- Print length278 pages
Customers who viewed this item also viewed
From the Publisher
What Are Microservices?
Microservices are small, autonomous services that work together. Let’s break that definition down a bit and consider the characteristics that make microservices different.
The benefits of microservices are many & varied. Many of these benefits can be laid at the door of any distributed system. Microservices, however, tend to achieve these benefits to a greater degree primarily due to how far they take the concepts behind distributed systems and service-oriented architecture.
Key benefits include
- Technology Heterogeneity
- Resilience
- Scaling
- Ease of Deployment
- Organizational Alignment
- Composability
- Optimizing for Replaceability.
|
|
|
|
|---|---|---|---|
| Monolith to Microservices | Microservice Architecture | Production-Ready Microservices | |
| More Microservices from O'Reilly | Evolutionary Patterns to Transform Your Monolith | Aligning Principles, Practices, and Culture | Building Standardized Systems Across An Engineering Organization |
Editorial Reviews
About the Author
Sam has worked with a variety of companies across multiple industries all over the globe, often with one foot in the developer world, and another in the IT operations space. He has written articles, presented at conferences, and sporadically commits to open source projects. Sam is the author of the bestselling Building Microservices from O'Reilly.
Product details
- Publisher : O'Reilly Media; 1st edition (March 17, 2015)
- Language : English
- Paperback : 278 pages
- ISBN-10 : 1491950358
- ISBN-13 : 978-1491950357
- Item Weight : 1.04 pounds
- Dimensions : 7 x 0.75 x 9.25 inches
- Best Sellers Rank: #591,634 in Books (See Top 100 in Books)
- #138 in Computer Hardware Design & Architecture
- #324 in Enterprise Applications
- #776 in Software Development (Books)
- Customer Reviews:
Important information
To report an issue with this product, click here.
About the author

Sam Newman is an author, speaker, and independent consultant interested in cloud, continuous delivery and microservices. Aside from other things he's spoken at more than a few conferences, and wrote some things including the books Building Microservices and Monolith To Microservices for O'Reilly.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonReviews with images
Submit a report
- Harassment, profanity
- Spam, advertisement, promotions
- Given in exchange for cash, discounts
Sorry, there was an error
Please try again later.-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
Something I appreciate about this book is how it incorporates and integrates best practices from many well-regarded sources, including Domain-Driven Design (Evans), Continuous Delivery (Humble and Farley), Release It (Nygard), Enterprise Integration Patterns (Hohpe), and even Information Dashboard Design (Few), among several others. I've incorporated lessons learned from those authors in my own work, and Newman's work helped me to take a step back and see how it all fits into a mutually-reinforcing set of ideas and practices.
Another strength this book has is that it treats the organizational forces driving systems design on a par with the technical forces, especially around Conway's Law. While I've been reasonably thoughtful about Conway's Law for some years, I walked away from the book with new insights. For example, in my organization we often talk about how we can make geography "invisible" so that developers around the world can closely collaborate on the same development projects. So we've tried things like asking people to focus more on communicating via wiki or Slack, having video teleconference meetings, trying to schedule meetings at times that are friendly to multiple time zones, and so forth, with limited success. We may need to rethink this. Newman's book offers some nice insights about the difference between loosely- and tightly-coupled organizations, and how different strategies work better depending on the organizational context. (For instance, if _everybody_ is "remote", then you're more likely to see successful wiki-based collaboration than you are when only one or two team members are.)
Coupling and its dangers are a constant theme in the book. Besides the organization coupling I mentioned above, Newman treats technical coupling as well, and offers plenty of food for thought. At one point he offers a fair criticism against one of my favorite frameworks, Spring Data REST. (He refers to it as Spring Boot, but it's clear from the context that he's talking about a Spring Boot demo that includes Spring Data REST specifically.) Spring Data REST essentially takes your database schema and exports it as a REST API, and it's a convenient way to get a full-blown REST API in just an hour or two. But as Newman points out, this creates strong coupling between the API client and database-related implementation details. (To be fair to SDR, there are ways to customize the mapping, but point is essentially correct.) Also SDR is more focused around exposing data, where Newman argues that to decrease coupling we should focus more on exposing capabilities. I don't know exactly how to resolve this tension yet, but I walked away with a better appreciation of the forces in tension, which is exactly what I'd want.
There was one way in which the book surprised me. Based on the title I was expecting a more in-depth how-to on building microservices, with specifics on tooling, code examples and so on. (E.g., "cloud native" concerns like using linkerd and Consul to set up a service mesh, or the pros-and-cons of using DNS vs service discovery for cross-region failover.) The book does a nice job of pulling in current and relevant tools and design patterns into the discussion where they make sense. But as Newman states at the outset the book is a more theoretical presentation of the microservices approach, concerned more with helping the reader understand the forces that brought us where we are today, and strategies to keep scope and coupling low. In the end I was glad to read the book as it is--I have a better lay of the land--but there will be some follow-up reading.
Perhaps it sells better w/ this title -- the book is overall pretty good, I gave it 4-stars because it is misleading.
The good parts of it -- covers end to end, design, deployment, logging/monitoring, deployment, etc. Overall good to introduce someone to system design. Not enough depth to really be a bible for seasoned architects -- good for an old architect like me to get back into more up to date technologies.
Sam Newman, the author of Building Microservices, doesn't pretend to be able to dictate the best answer for every situation. Instead, Mr. Newman teaches basic, but well thought out, concepts related to breaking a legacy or new application into small, manageable services. Throughout the book, he provides the cases when it makes sense, and generalities of how to implement this, but acknowledges that different implementations will work best for different companies, languages, situations, and programs. Where possible, he gives an overview of several methods that can be used to solve a problem.
And to be honest, this is the sort of book I like best. Books that teach concrete methods often focus too heavily on implementation. The concepts are far more important, and a good programmer should be able to decide on the best implementation for each particular situation. This book does a good job of covering the full range of practical and theoretical considerations, and provides real-world examples where necessary.
That being said, the book does have some shortfalls. I find the pacing to be inconsistent. Some chapters seem so short that they could be a section while others so long that I wonder why they weren't broken into separate topics. There are also references to supporting technologies that occasionally could use more detail.
Overall, I think that this book will not offer a lot of new information for people who have lots of experience in this field. I also don't know that it would make a great textbook for a class due to the lack of specific implementation details. However, the book excels in giving practical knowledge, and for an individual or team tasked with splitting a monolithic application for the first time, I highly recommend it.
Top reviews from other countries
That being said, the title is misleading since you will not learn much about the actual implementation and development of actual services and how to choose where to "cut" a service out from the monolith. The author tends to argue both sides of an issue so you end up with no clear path on how to approach the actual *building* of microservices.
I don't think that it would have hurt the book to be slightly longer and have a little more flesh to some of the topics like HATEOAS, persisting references to other services, benefits and downsides of MQs etc.
It covers a broad scope well and feels pretty balanced in what it presents, also linking you to many other great sources for further reading.
I recommed this book for senior developers or team leaders and surely for technical architects. This book will take you through the practices of system designing history in very brief but contextual way and will suggest future learning path to follow for keeping ahead in this field.
This book along with teaching about microservices also implants the idea of it.









