Microservices Patterns
With examples in Java
Chris Richardson
  • October 2018
  • ISBN 9781617294549
  • 520 pages
  • printed in black & white

A comprehensive overview of the challenges teams face when moving to microservices, with industry-tested solutions to these problems.

Tim Moore, Lightbend

Microservices Patterns teaches enterprise developers and architects how to build applications with the microservice architecture. Rather than simply advocating for the use the microservice architecture, this clearly-written guide takes a balanced, pragmatic approach, exploring both the benefits and drawbacks.

Table of Contents detailed table of contents

1. Escaping monolithic hell

1.1. The slow march towards monolithic hell

1.1.1. The architecture of the FTGO application

1.1.2. The benefits of the monolithic architecture

1.1.3. Living in monolithic hell

1.2. Why this book is relevant to you

1.3. What you’ll learn in this book

1.4. The microservice architecture to the rescue

1.4.1. Scale cube and microservices

1.4.2. Microservices as a form of modularity

1.4.3. Each service has its own database

1.4.4. The FTGO microservice architecture

1.4.5. Isn’t the microservice architecture the same as SOA?

1.5. Benefits and drawbacks of the microservice architecture

1.5.1. Benefits of the microservice architecture

1.5.2. The drawbacks of the microservice architecture

1.6. The microservice architecture pattern language

1.6.1. Microservices are not a silver bullet

1.6.2. What is a pattern and a pattern language?

1.6.3. Overview of the microservice architecture pattern language

1.7. Beyond microservices: process and organization

1.7.1. Software development and delivery organization

1.7.2. Software development and delivery process

1.7.3. The human side of adopting microservices

1.8. Summary

2. Decomposition strategies

2.1. What is the microservice architecture exactly?

2.1.1. What is software architecture and why it matters

2.1.2. Overview of architectural styles

2.1.3. The microservice architecture is an architectural style

2.2. Defining an application’s microservice architecture

2.2.1. Identifying the system operations

2.2.2. Defining services by applying the Decompose by business capability pattern

2.2.3. Defining services by applying the Decompose by sub-domain pattern

2.2.4. Decomposition guidelines

2.2.5. Obstacles to decomposing an application into services

2.2.6. Defining service APIs

2.3. Summary

3. Inter-process communication in a microservice architecture

3.1. Overview of inter-process communication in a microservice architecture

3.1.1. Interaction styles

3.1.2. Defining APIs in a microservice architecture

3.1.3. Evolving APIs

3.1.4. Message formats

3.2. Communicating using the synchronous Remote procedure invocation pattern

3.2.1. Using REST

3.2.2. Using gRPC

3.2.3. Handling partial failure using the Circuit Breaker pattern

3.2.4. Using service discovery

3.3. Communicating using the asynchronous Messaging pattern

3.3.1. Overview of messaging

3.3.2. Implementing the interaction styles using messaging

3.3.3. Creating an API specification for a messaging-based service API

3.3.4. Using a message broker

3.3.5. Competing receivers and message ordering

3.3.6. Handling duplicate messages

3.3.7. Transactional messaging

3.3.8. Libraries and frameworks for messaging

3.4. Using asynchronous messaging to improve availability

3.4.1. Synchronous communication reduces availability

3.4.2. Eliminating synchronous interaction

3.5. Summary

4. Managing transactions with sagas

4.1. Transaction management in a microservice architecture

4.1.1. The need for 'distributed transactions' in a microservice architecture

4.1.2. The trouble with distributed transactions

4.1.3. Using the Saga pattern to maintain data consistency

4.2. Coordinating sagas

4.2.1. Choreography-based sagas

4.2.2. Orchestration-based sagas

4.3. Handling the lack of isolation

4.3.1. Overview of anomalies.

4.3.2. Countermeasures for handling the lack of isolation

4.4. The design of the Order Service and the Create Order Saga

4.4.1. The OrderService class

4.4.2. The implementation of the Create Order Saga

4.4.3. The OrderCommandHandlers class

4.4.4. The OrderServiceConfiguration class

4.5. Summary

5. Designing business logic in a microservice architecture

5.1. Business logic organization patterns

5.1.1. Designing business logic using the Transaction script pattern

5.1.2. Designing business logic using the Domain Model pattern

5.1.3. About Domain Driven Design

5.2. Designing a domain model using the DDD aggregate pattern

5.2.1. The problem with fuzzy boundaries

5.2.2. Aggregates have explicit boundaries

5.2.3. Aggregate rules

5.2.4. Aggregate granularity

5.2.5. Designing business logic with aggregates

5.3. Publishing domain events

5.3.1. Why publish change events?

5.3.2. What is a domain event

5.3.3. Event enrichment

5.3.4. Identifying domain events

5.3.5. Generating and publishing domain events

5.3.6. Consuming domain events

5.4. Kitchen Service business logic

5.4.1. The Ticket aggregate

5.5. The Order Service business logic

5.5.1. The Order Aggregate

5.5.2. The OrderService class

5.6. Summary

6. Developing business logic with event sourcing

6.1. Developing business logic using event sourcing

6.1.1. The trouble with traditional persistence

6.1.2. Overview of event sourcing

6.1.3. Handling concurrent updates using optimistic locking

6.1.4. Event sourcing and publishing events

6.1.5. Using snapshots to improve performance

6.1.6. Idempotent message processing

6.1.7. Evolving domain events

6.1.8. Benefits of event sourcing

6.1.9. Drawbacks of event sourcing

6.2. Implementing an event store

6.2.1. How the Eventuate Local event store works

6.2.2. The Eventuate client framework for Java

6.3. Using sagas and event sourcing together

6.3.1. Implementing choreography-based sagas using event sourcing

6.3.2. Creating an orchestration-based saga

6.3.3. Implementing an event sourcing-based saga participant

6.3.4. Implementing saga orchestrators using event sourcing

6.4. Summary

7. Implementing queries in a microservice architecture

7.1. Querying using the API Composition pattern

7.1.1. The findOrder() query operation

7.1.2. An overview of the API composition pattern

7.1.3. Implementing the findOrder() query operation using the API Composition pattern

7.1.4. API Composition design issues

7.1.5. The benefits and drawbacks of the API composition pattern

7.2. Using the Command Query Responsibility Segregation (CQRS) pattern

7.2.1. Motivations for using CQRS

7.2.2. Overview of CQRS

7.2.3. The benefits of CQRS

7.2.4. The drawbacks of CQRS

7.3. Designing CQRS Views

7.3.1. Choosing a view datastore

7.3.2. Data access module design

7.3.3. Adding and updating CQRS views

7.4. Implementing a CQRS view with AWS DynamoDB

7.4.1. OrderHistoryEventHandlers module

7.4.2. Data modeling and query design with DynamoDB

7.4.3. The OrderHistoryDaoDynamoDb class

7.5. Summary

8. External API patterns

8.1. External API design issues

8.1.1. API design issues for the FTGO mobile client

8.1.2. API design issues for other kinds of clients

8.2. The API gateway pattern

8.2.1. Overview of the API gateway pattern

8.2.2. Benefits and drawbacks of an API gateway

8.2.3. Netflix as an example of an API gateway

8.2.4. API gateway design issues

8.3. Implementing an API gateway

8.3.1. Using an off-the-shelf API gateway product/service

8.3.2. Developing your own API gateway

8.3.3. Implementing an API gateway using GraphQL

8.4. Summary

9. Testing microservices - part 1

9.1. Testing strategies for microservice architectures

9.1.1. Overview of testing

9.1.2. The challenge of testing microservices

9.1.3. The deployment pipeline

9.2. Writing unit tests for a service

9.2.1. Developing unit tests for entities

9.2.2. Writing unit tests for value objects

9.2.3. Developing unit tests for sagas

9.2.4. Writing unit tests for domain services

9.2.5. Developing unit tests for controllers

9.2.6. Writing unit tests for event and message handlers

9.3. Summary

10. Testing microservices - part 2

10.1. Writing integration tests

10.1.1. Persistence integration tests

10.1.2. Integration testing REST-based request/reply style interactions

10.1.3. Integration testing publish/subscribe-style interactions

10.1.4. Integration contract tests for Request/async reply interactions

10.2. Developing component tests

10.2.1. Defining acceptance tests

10.2.2. Writing acceptance tests using Gherkin

10.2.3. Designing component tests

10.2.4. Writing component tests for the FTGO Order Service

10.3. Writing end-to-end tests

10.3.1. Designing end-to-end tests

10.3.2. Writing end-to-end tests

10.3.3. Running the end-to-end tests

10.4. Summary

11. Developing production ready services

11.1. Developing secure services

11.1.1. Overview of security in a traditional monolithic application

11.1.2. Implementing security in a microservice architecture

11.2. Designing configurable services

11.2.1. Using push-based externalized configuration

11.2.2. Using pull-based externalized configuration

11.3. Designing observable services

11.3.1. Using the Health check API pattern

11.3.2. Apply the Log aggregation pattern

11.3.3. Using the Distributed tracing pattern

11.3.4. Applying the Application metrics patterns

11.3.5. Using the Exception tracking pattern

11.3.6. Applying the Audit logging pattern

11.4. Developing services using the Microservice chassis pattern

11.4.1. Using a microservice chassis

11.4.2. From microservice chassis to service mesh

11.5. Summary

12. Deploying microservices

12.1. Deploying services using the Language-specific packaging format pattern

12.1.1. Benefits of the Service as a language-specific package pattern

12.1.2. Drawbacks of the Service as a language-specific package pattern

12.2. Deploying services using the Service per Virtual machine pattern

12.2.1. The benefits of deploying services as VMs

12.2.2. The drawbacks of deploying services as VMs

12.3. Deploying services using the Service per container pattern

12.3.1. Deploying services using Docker

12.3.2. Benefits of deploying services as containers

12.3.3. Drawbacks of deploying services as containers

12.4. Deploying the FTGO application with Kubernetes

12.4.1. Overview of Kubernetes

12.4.2. Deploying the Restaurant service on Kubernetes

12.4.3. Deploying the API gateway

12.4.4. Zero-downtime deployments

12.4.5. Using a service mesh so separate deployment from release

12.5. Deploying services using the Serverless deployment pattern

12.5.1. Overview of serverless deployment with AWS Lambda

12.5.2. Developing a lambda function

12.5.3. Invoking lambda functions

12.5.4. Benefits of using lambda functions

12.5.5. Drawbacks of using lambda functions

12.6. Deploying a RESTful service using AWS Lambda and AWS Gateway

12.6.1. The design of the AWS Lambda version of the Restaurant Service

12.6.2. Packaging the service as ZIP file

12.6.3. Deploying lambda functions using the Serverless framework

12.7. Summary

13. Refactoring to microservices

13.1. Overview of refactoring to microservices

13.1.1. Why refactor a monolith?

13.1.2. Strangling the monolith

13.2. Strategies for refactoring a monolith to microservices

13.2.1. Implement new features as services

13.2.2. Separate presentation tier from the back end

13.2.3. Extract business capabilities into services

13.3. Designing how the service and the monolith collaborate

13.3.1. Designing the integration glue

13.3.2. Maintaining data consistency across a service and a monolith

13.3.3. Handling authentication and authorization

13.4. Implementing a new feature as a service: handling mis-delivered orders

13.4.1. The design of the Delayed Delivery Service

13.4.2. Designing the integration glue for the Delayed Delivery Service

13.5. Breaking apart the monolith: extracting delivery management

13.5.1. Overview the existing delivery management functionality

13.5.2. Overview of the Delivery Service

13.5.3. Designing the Delivery Service domain model

13.5.4. The design of the Delivery Service integration glue

13.5.5. Changing the FTGO monolith to interact with the Delivery Service

13.6. Summary

About the Technology

Successfully developing microservices-based applications requires mastering a new set of architectural insights and practices. In this unique book, microservice architecture pioneer and Java Champion Chris Richardson collects, catalogues, and explains 44 patterns that solve problems such as service decomposition, transaction management, querying, and inter-service communication.

About the book

Microservices Patterns teaches you how to develop and deploy production-quality microservices-based applications. This invaluable set of design patterns builds on decades of distributed system experience, adding new patterns for writing services and composing them into systems that scale and perform reliably under real-world conditions. More than just a patterns catalog, this practical guide offers experience-driven advice to help you design, implement, test, and deploy your microservices-based application.

What's inside

  • How (and why!) to use the microservice architecture
  • Service decomposition strategies
  • Transaction management and querying patterns
  • Effective testing strategies
  • Deployment patterns

About the reader

Written for enterprise developers familiar with standard enterprise application architecture. Examples are in Java.

About the author

Chris Richardson is a Java Champion, a JavaOne rock star, author of Manning’s POJOs in Action, and creator of the original CloudFoundry.com.

placing your order...

Don't refresh or navigate away from the page.

FREE domestic shipping on three or more pBooks

Pragmatic treatment of an important new architectural landscape.

Simeon Leyzerzon, Excelsior Software

A solid compendium of information that will quicken your migration to this modern cloud-based architecture.

John Guthrie, Dell/EMC

How to understand the microservices approach, and how to use it in real life.

Potito Coluccelli, Bizmatica Econocom