Patterns of Distributed Systems, 1st edition

Published by Addison-Wesley Professional (November 1, 2023) © 2024

  • Unmesh Joshi
Products list
Products list

Details

  • A print text
  • Free shipping

Learn How to Better Understand Distributed System Design and Solve Common Problems

Enterprises today rely on a range of distributed software handling data storage, messaging, system management, and compute capability. Distributed system designs need to be implemented in some programming language, and there are common problems that these implementations need to solve. These problems have common recurring solutions. A patterns approach is very suitable to describe these implementation aspects.

Patterns by nature are generic enough to cover a broad range of products from cloud services like Amazon S3 to message brokers like Apache Kafka to infrastructure frameworks like Kubernetes to databases like MongoDB or Actor frameworks like Akka. At the same time the pattern structure is specific enough to be able to show real code. The beauty of this approach is that even if the code structure is shown in one programming language (Java in this case), the structure applies to many other programming languages. Patterns also form a "system of names," with each name having specific meaning in terms of the code structure.

The set of patterns presented in Patterns of Distributed Systems will be useful to all developers--even if they are not directly involved in building these kinds of systems, and mostly use them as a black box. Learning these patterns will help readers develop a deeper understanding of the challenges presented by distributed systems and will also help them choose appropriate cloud services and products. Coverage includes Patterns of Data Replication, Patterns of Data Partitioning, Patterns of Distributed Time, Patterns of Cluster Management, and Patterns of Communication Between Nodes.

The patterns approach used here will help you

  • Learn what a distributed system is and why distributed systems are needed
  • Understand the implementation of a wide range of systems such as databases, in-memory data grids, message brokers, and various cloud services
  • Prepare you to confidently traverse through open source codebases and discover how patterns and solutions map to real world systems like Kafka and Kubernetes

Foreword xvii
Preface xix
Acknowledgments xxiii
About the Author xxv

Part I: Narratives 1

Chapter 1: The Promise and Perils of Distributed Systems 3
The Limits of a Single Server 3
Separate Business Logic and Data Layer 5
Partitioning Data 6
A Look at Failures 7
Replication: Masking Failures 9
Defining the Term "Distributed Systems" 10
The Patterns Approach 10

Chapter 2: Overview of the Patterns 13
Keeping Data Resilient on a Single Server 14
Competing Updates 15
Dealing with the Leader Failing 17
Multiple Failures Need a Generation Clock 21
Log Entries Cannot Be Committed until They Are Accepted by a Majority Quorum 26
Followers Commit Based on a High-Water Mark 29
Leaders Use a Series of Queues to Remain Responsive to Many Clients 34
Followers Can Handle Read Requests to Reduce Load on the Leader 40
A Large Amount of Data Can Be Partitioned over Multiple Nodes 42
Partitions Can Be Replicated for Resilience 45
A Minimum of Two Phases Are Needed to Maintain Consistency across Partitions 46
In Distributed Systems, Ordering Cannot Depend on System Timestamps 49
A Consistent Core Can Manage the Membership of a Data Cluster 58
Gossip Dissemination for Decentralized Cluster Management 62

Part II: Patterns of Data Replication 69

Chapter 3: Write-Ahead Log 71
Problem 71
Solution 71
Examples 76

Chapter 4: Segmented Log 77
Problem 77
Solution 77
Examples 79

Chapter 5: Low-Water Mark 81
Problem 81
Solution 81
Examples 83

Chapter 6: Leader and Followers 85
Problem 85
Solution 85
Examples 92

Chapter 7: HeartBeat 93
Problem 93
Solution 93
Examples 98

Chapter 8: Majority Quorum 99
Problem 99
Solution 100
Examples 102

Chapter 9: Generation Clock 103
Problem 103
Solution 104
Examples 107

Chapter 10: High-Water Mark 109
Problem 109
Solution 109
Examples 115

Chapter 11: Paxos 117
Problem 117
Solution 117
Examples 132

Chapter 12: Replicated Log 133
Problem 133
Solution 133
Examples 158

Chapter 13: Singular Update Queue 159
Problem 159
Solution 159
Examples 166

Chapter 14: Request Waiting List 167
Problem 167
Solution 167
Examples 173

Chapter 15: Idempotent Receiver 175
Problem 175
Solution 175
Examples 181

Chapter 16: Follower Reads 183
Problem 183
Solution 183
Examples 191

Chapter 17: Versioned Value 193
Problem 193
Solution 193
Examples 201

Chapter 18: Version Vector 203
Problem 203
Solution 203
Examples 216

Part III: Patterns of Data Partitioning 217

Chapter 19: Fixed Partitions 219
Problem 219
Solution 220
Examples 241

Chapter 20: Key-Range Partitions 243
Problem 243
Solution 244
Examples 255

Chapter 21: Two-Phase Commit 257
Problem 257
Solution 257
Examples 297

Part IV: Patterns of Distributed Time 299

Chapter 22: Lamport Clock 301
Problem 301
Solution 301
Examples 307

Chapter 23: Hybrid Clock 309
Problem 309
Solution 309
Examples 316

Chapter 24: Clock-Bound Wait 317
Problem 317
Solution 318
Examples 332

Part V: Patterns of Cluster Management 335

Chapter 25: Consistent Core 337
Problem 337
Solution 337
Examples 342

Chapter 26: Lease 345
Problem 345
Solution 345
Examples 354

Chapter 27: State Watch 355
Problem 355
Solution 355
Examples 362

Chapter 28: Gossip Dissemination 363
Problem 363
Solution 363
Examples 373

Chapter 29: Emergent Leader 375
Problem 375
Solution 375
Examples 392

Part VI: Patterns of Communication between Nodes 393

Chapter 30: Single-Socket Channel 395
Problem 395
Solution 395
Examples 397

Chapter 31: Request Batch 399
Problem 399
Solution 399
Examples 404

Chapter 32: Request Pipeline 405
Problem 405
Solution 405
Examples 408

References 409
Index 413

Need help? Get in touch