Microservices Patterns Video Edition

Microservices Patterns Video Edition

by Chris Richardson
Released October 2018
Publisher(s): Manning Publications
ISBN: None

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Video description

In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.

"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.

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:
  • How (and why!) to use the microservice architecture
  • Service decomposition strategies
  • Transaction management and querying patterns
  • Effective testing strategies
  • Deployment patterns
This book/course is made for enterprise developers familiar with standard enterprise application architecture. Examples are in Java.

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

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

NARRATED BY AIDEN HUMPHREYS AND LOU FERNANDEZ

Table of contents

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

Product information

  • Title: Microservices Patterns Video Edition
  • Author(s): Chris Richardson
  • Release date: October 2018
  • Publisher(s): Manning Publications
  • ISBN: None