Monolith To Microservices

Monolith To Microservices is a new book on system decomposition from O'Reilly

How do you detangle a monolithic system and migrate it to a microservices architecture? How do you do it while maintaining business-as-usual? As a companion to Building Microservices, this new book details multiple approaches for helping you transition from existing monolthic systems to microservice architectures. This book is ideal if you're looking to evolve your current systems, rather than just rewriting everything from scratch.

How To Get The Book

The book is now available, and you can order the dead-tree and Kindle versions over at Amazon. You can also read the book online on O'Reilly's online learning platform.

Read on O'Reilly Learning Online Order at Amazon.com Order at Amazon.co.uk

Video Overview

Translations And Other Formats

At present, there are plans to translate the book into Portuguese, German, and Chinese (simplified), in addition to creating an audio book. I'll update this page with details of when these editions are available, along with information of any other confirmed translations.

Topics

  • Should you migrate to microservices, and if you should, how do you prioritise where to start
  • How do you incrementally decompose an application
  • Discusses multiple migration patterns and where they apply
  • Delves into details of database decomposition, including the impact of breaking referential and transactional integrity, new failure modes, and more
  • The growing pains you'll experience as your microservice architecture grows

Table Of Contents

  • Chapter 1: Just Enough Microservices

    1. What Are Microservices?
    2. The Monolith
    3. On Coupling And Cohesion
    4. Just Enough Domain-Driven Design

  • Chapter 2: Planning A Migration

    1. Understanding The Goal
    2. Why Might You Choose Microservices?
    3. When Might Microservices Be A Bad Idea?
    4. Trade-offs
    5. Taking People On The Journey
    6. Changing Organizations
    7. Importance Of Incremental Migration
    8. Cost Of Change
    9. Domain-Driven Design
    10. Reorganizing Teams
    11. How Will You Know If It's Working?

  • Chapter 3: Splitting The Monolith

    1. To Change The Monolith, Or Not?
    2. Pattern: Strangler Fig Applications
    3. Changing Behavior While Migrating Functionality
    4. Pattern: UI Composition
    5. Pattern: Branch by Abstraction
    6. Pattern: Parallel Run
    7. Pattern: Decorating Collaborator
    8. Pattern: Change Data Capture

  • Chapter 4: Decomposing The Database

    1. Pattern: The Shared Database
    2. Pattern: Database View
    3. Pattern: Database Wrapping Service
    4. Pattern: Database-as-a-Service Interface
    5. Transfering Ownership
    6. Data Synchronization
    7. Pattern: Synchronize Data In Application
    8. Pattern: Tracer Write
    9. Splitting Apart The Database
    10. Pattern: Split Table
    11. Pattern: Move Foreign-Key Relationship To Code
    12. Transactions
    13. Sagas

  • Chapter 5: Growing Pains

    1. More Services, More Pain
    2. Breaking Changes
    3. Reporting
    4. Monitoring and Troubleshooting
    5. Local Developer Experience
    6. Running Too Many Things
    7. End-to-end Testing
    8. Global Verses Local Optimization
    9. Robustness and Resiliency
    10. Orphaned Services

  • Chapter 6: Closing Words