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 …
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.
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.
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.
Inside:Chapter 1. Escaping monolithic hell
Escaping monolithic hell
Living in monolithic hell
Why this book is relevant to you
Microservice architecture to the rescue
Each service has its own database
Benefits and drawbacks of the microservice architecture
Drawbacks of the microservice architecture
The Microservice architecture pattern language
Patterns and pattern languages
Overview of the Microservice architecture pattern language
Beyond microservices: Process and organization
Chapter 2. Decomposition strategies
Decomposition strategies
What is software architecture and why does it matter?
Overview of architectural styles
The microservice architecture is an architectural style
Defining an application’s microservice architecture
Identifying the system operations
Defining services by applying the Decompose by business capability pattern
Defining services by applying the Decompose by sub-domain pattern
Obstacles to decomposing an application into services
Defining service APIs
Chapter 3. Interprocess communication in a microservice architecture
Interprocess communication in a microservice architecture
Defining APIs in a microservice architecture
Message formats
Communicating using the synchronous Remote procedure invocation pattern
Using gRPC
Handling partial failure using the Circuit breaker pattern
Using service discovery
Communicating using the Asynchronous messaging pattern
Implementing the interaction styles using messaging
Using a message broker
Competing receivers and message ordering
Transactional messaging
Libraries and frameworks for messaging
Using asynchronous messaging to improve availability
Eliminating synchronous interaction
Chapter 4. Managing transactions with sagas
Managing transactions with sagas
The trouble with distributed transactions
Using the Saga pattern to maintain data consistency
Coordinating sagas
Orchestration-based sagas
Handling the lack of isolation
Countermeasures for handling the lack of isolation Part 1
Countermeasures for handling the lack of isolation Part 2
The design of the Order Service and the Create Order Saga
The implementation of the Create Order Saga
The OrderCommandHandlers class
Chapter 5. Designing business logic in a microservice architecture
Designing business logic in a microservice architecture
Designing business logic using the Domain model pattern
Designing a domain model using the DDD aggregate pattern
Aggregate rules
Publishing domain events
Generating and publishing domain events
Kitchen Service business logic
Order Service business logic
The OrderService class
Chapter 6. Developing business logic with event sourcing
Developing business logic with event sourcing
Overview of event sourcing Part 1
Overview of event sourcing Part 2
Handling concurrent updates using optimistic locking
Using snapshots to improve performance
Evolving domain events
Drawbacks of event sourcing
Implementing an event store
The Eventuate client framework for Java
Using sagas and event sourcing together
Creating an orchestration-based saga
Implementing an event sourcing-based saga participant
Implementing saga orchestrators using event sourcing
Chapter 7. Implementing queries in a microservice architecture
Implementing queries in a microservice architecture
Overview of the API composition pattern
The benefits and drawbacks of the API composition pattern
Using the CQRS pattern
Motivations for using CQRS
Overview of CQRS
The benefits of CQRS
Designing CQRS views
Data access module design
Implementing a CQRS view with AWS DynamoDB
Data modeling and query design with DynamoDB Part 1
Data modeling and query design with DynamoDB Part 2
The OrderHistoryDaoDynamoDb class
Chapter 8. External API patterns
External API patterns
API design issues for the FTGO mobile client
API design issues for other kinds of clients
The API gateway pattern
Overview of the API gateway pattern
Benefits and drawbacks of an API gateway
API gateway design issues
Implementing an API gateway
Developing your own API gateway Part 1
Developing your own API gateway Part 2
Implementing an API gateway using GraphQL Part 1
Implementing an API gateway using GraphQL Part 2
Implementing an API gateway using GraphQL Part 3
Chapter 9. Testing microservices: Part 1
Testing microservices: Part 1
Testing strategies for microservice architectures
Overview of testing
The challenge of testing microservices Part 1
The challenge of testing microservices Part 2
The deployment pipeline
Writing unit tests for a service
Developing unit tests for sagas
Writing unit tests for event and message handlers
Chapter 10. Testing microservices: Part 2
Testing microservices: Part 2
Integration testing REST-based request/response style interactions
Integration testing publish/subscribe-style interactions
Developing component tests
Designing component tests
Writing end-to-end tests
Chapter 11. Developing production-ready services
Developing production-ready services
Overview of security in a traditional monolithic application
Implementing security in a microservice architecture Part 1
Implementing security in a microservice architecture Part 2
Designing configurable services
Designing observable services
Applying the Log aggregation pattern
Applying the Application metrics pattern
Developing services using the Microservice chassis pattern
Chapter 12. Deploying microservices
Deploying microservices
Deploying services using the Language-specific packaging format pattern
Deploying services using the Service as a virtual machine pattern
Deploying services using the Service as a container pattern
Deploying the FTGO application with Kubernetes
Deploying the Restaurant service on Kubernetes
Using a service mesh to separate deployment from release Part 1
Using a service mesh to separate deployment from release Part 2
Deploying services using the Serverless deployment pattern
Invoking lambda functions
Deploying a RESTful service using AWS Lambda and AWS Gateway
Chapter 13. Refactoring to microservices
Refactoring to microservices
Strangling the monolith
Strategies for refactoring a monolith to microservices
Extract business capabilities into services Part 1
Extract business capabilities into services Part 2
Designing how the service and the monolith collaborate
Designing the integration glue
Maintaining data consistency across a service and a monolith Part 1
Maintaining data consistency across a service and a monolith Part 2
Handling authentication and authorization
Implementing a new feature as a service: handling misdelivered orders
Breaking apart the monolith: extracting delivery management
Designing the Delivery Service domain model
Changing the FTGO monolith to interact with Delivery Service