Book
Microservices Patterns
With examples in Java
Chris Richardson
Summary
Chris Richardson organizes the microservice architecture as a catalog of named patterns rather than a single prescribed approach, so that each decision comes with its tradeoffs stated. The book opens on when a monolith stops paying its way and how to decompose one into services, then works through the problems that decomposition creates and that a single database used to hide: interprocess communication between services, managing a transaction that spans them using sagas, designing business logic and developing it with event sourcing, and implementing queries whose data now lives in several places. Later chapters cover external API patterns, testing microservices across two chapters, developing services fit for production, deployment, and refactoring an existing system toward services. Examples are in Java.
Target Readers
- Developers who have split a system into services and hit the problems that a single database used to hide, such as transactions and queries that now span services
- Architects weighing whether to decompose a monolith at all, who want each pattern's tradeoffs stated rather than a recommendation
- Java developers who want worked implementations rather than a language-agnostic patterns catalog
Tags
Colophon
- Publisher
- Impress
- ISBN
- 978-4295008583
- Published
- Mar 2020
- List price
- ¥5,280incl. taxMay differ from the actual selling price on Amazon
Get this book
* The link above is an advertisement via Amazon Associates.Related Books
Prerequisites
- Recommended
Concurrency in Go
Tools and Techniques for Developers
Katherine Cox-Buday
Reason: Having understood concurrency within a single process, you extend to a world where multiple processes—services—coordinate asynchronously. Microservices Patterns provides coordination patterns for distributed systems—messaging, sagas, event-driven design—extending the idea of concurrency across the network.
- Recommended
Monolith to Microservices
Evolutionary Patterns to Transform Your Monolith
Sam Newman
Reason: Once you can decide whether to split a monolith, you stock up on the implementation patterns needed after the split. Microservices Patterns catalogs the established practices for service decomposition, data management, communication, and deployment, bridging from 'how to divide' to 'how to build.'
- Recommended
Clean Architecture
A Craftsman's Guide to Software Structure and Design
Robert C. Martin
Reason: Once you can design boundaries and dependencies within a single process, you scale those principles to distributed systems. Microservices Patterns gives you the vocabulary for designing inter-service communication, consistency, and failure handling while preserving each service's internal architecture.
- Recommended
Enterprise Integration Patterns
Designing, Building, and Deploying Messaging Solutions
Gregor Hohpe, Bobby Woolf
Reason: Enterprise Integration Patterns organizes messaging channels, message construction, routing, transformation and endpoints with a vocabulary and a visual notation that do not depend on a product. Microservices Patterns takes up the problems that appear once a monolith is decomposed into services: interprocess communication between them, and transactions that span them, handled with sagas. With the messaging vocabulary of the first book in place, the second book's discussion of asynchronous communication can be followed from the ground up.
- Related
Understanding Distributed Systems, 2nd Edition
What every developer should know about large distributed applications
Roberto Vitillo
Reason: Understanding Distributed Systems introduces the outbox pattern and sagas in its chapter on asynchronous transactions, API gateways in its chapter on microservices, and asynchronous messaging in its chapter on messaging. Each is a short introduction. When the time comes to design with them, Microservices Patterns treats the same material as patterns, in detail.
Next Books
- Recommended
Release It!, 2nd Edition
Design and Deploy Production-Ready Software
Michael T. Nygard
Reason: Once you can implement distributed systems, designing 'how they behave when they break' becomes essential. Release It! provides stability patterns like circuit breakers and bulkheads, teaching you to design systems where failures don't cascade.
- Recommended
Designing Data-Intensive Applications
The Big Ideas Behind Reliable, Scalable, and Maintainable Systems
Martin Kleppmann
Reason: Learning microservice implementation patterns, you inevitably hit the hard problem of keeping data consistent across services. Designing Data-Intensive Applications supplies the theory of distributed-data consistency, replication, and transactions, underpinning why those patterns work.
- Related
Testing Web APIs
Mark Winteringham
Reason: Splitting into services creates the risk that integrations break whenever an inter-service interface changes. Testing Web APIs provides a contract-testing strategy including consumer-driven contracts (CDC), weaving a verification net that keeps independent deployment safe.