Scalability Rules: Principles for Scaling Web Sites

Fully updated! Fifty Powerful, Easy-to-Use Rules for Supporting Hyper Growth “Whether you’re taking on a role as a technology leader in a new company or you simply want to make great technology decisions, Scalability Rules will be the go-to resource on your bookshelf.” –Chad Dickerson, CTO, Etsy Scalability Rules, Second Edition, is the easy-to-use scalability primer and reference for every architect, developer, network/software engineer, web professional, and manager. Authors Martin L. Abbott and Michael T. Fisher have helped scale hundreds of high-growth companies and thousands of systems. Drawing on their immense experience, they present 50 up-to-the-minute technical best practices for supporting hyper growth practically anywhere.   Fully updated to reflect new technical trends and experiences, this edition is even easier to read, understand, and apply. Abbott and Fisher have also added powerful “stories behind the rules”: actual experiences and case studies from CTOs and technology executives at Etsy, NASDAQ, Salesforce, Shutterfly, Chegg, Warby Parker, Twitter, and other scalability pioneers.   Architects will find powerful technology-agnostic insights for creating and evaluating designs. Developers will discover specific techniques for handling everything from databases to state. Managers will get invaluable help in setting goals, making decisions, and interacting with technical teams. Whatever your role, you’ll find practical risk/benefit guidance for setting priorities, translating plans into action, and gaining maximum scalability at minimum cost.   You’ll learn how to Simplify architectures and avoid “over-engineering” Design scale into your solution, so you can scale on a just-in-time basis Make the most of cloning and replication Separate functionality and split data sets Scale out, not up Get more out of databases without compromising scalability Eliminate unnecessary redirects and redundant double-checking Use caches and CDNs more aggressively, without unacceptable complexity Design for fault tolerance, graceful failure, and easy rollback Emphasize statelessness, and efficiently handle state when you must Effectively utilize asynchronous communication Learn from your own mistakes and others’ high-profile failures Prioritize your actions to get the biggest “bang for the buck”

Table of Contents:
Preface xv Acknowledgments xxi About the Authors xxiii   Chapter 1: Reduce the Equation 1 Rule 1—Don’t Overengineer the Solution 3 Rule 2—Design Scale into the Solution (D-I-D Process) 6 Rule 3—Simplify the Solution Three Times Over 8 Rule 4—Reduce DNS Lookups 10 Rule 5—Reduce Objects Where Possible 12 Rule 6—Use Homogeneous Networks 15 Summary 15 Notes 16   Chapter 2: Distribute Your Work 19 Rule 7—Design to Clone or Replicate Things (X Axis) 22 Rule 8—Design to Split Different Things (Y Axis) 24 Rule 9—Design to Split Similar Things (Z Axis) 26 Summary 28 Notes 28   Chapter 3: Design to Scale Out Horizontally 29 Rule 10—Design Your Solution to Scale Out, Not Just Up 31 Rule 11—Use Commodity Systems (Goldfish Not Thoroughbreds) 33 Rule 12—Scale Out Your Hosting Solution 35 Rule 13—Design to Leverage the Cloud 40 Summary 42 Notes 42   Chapter 4: Use the Right Tools 43 Rule 14—Use Databases Appropriately 47 Rule 15—Firewalls, Firewalls Everywhere! 52 Rule 16—Actively Use Log Files 55 Summary 58 Notes 58   Chapter 5: Get Out of Your Own Way 59 Rule 17—Don’t Check Your Work 61 Rule 18—Stop Redirecting Traffic 64 Rule 19—Relax Temporal Constraints 68 Summary 70 Notes 70   Chapter 6: Use Caching Aggressively 73 Rule 20—Leverage Content Delivery Networks 75 Rule 21—Use Expires Headers 77 Rule 22—Cache Ajax Calls 80 Rule 23—Leverage Page Caches 84 Rule 24—Utilize Application Caches 86 Rule 25—Make Use of Object Caches 88 Rule 26—Put Object Caches on Their Own “Tier” 90 Summary 91 Notes 92   Chapter 7: Learn from Your Mistakes 93 Rule 27—Learn Aggressively 95 Rule 28—Don’t Rely on QA to Find Mistakes 100 Rule 29—Failing to Design for Rollback Is Designing for Failure 102 Summary 105 Notes 106   Chapter 8: Database Rules 107 Rule 30—Remove Business Intelligence from Transaction Processing 109 Rule 31—Be Aware of Costly Relationships 111 Rule 32—Use the Right Type of Database Lock 114 Rule 33—Pass on Using Multiphase Commits 116 Rule 34—Try Not to Use Select for Update 118 Rule 35—Don’t Select Everything 120 Summary 121 Notes 122   Chapter 9: Design for Fault Tolerance and Graceful Failure 123 Rule 36—Design Using Fault-Isolative “Swim Lanes” 124 Rule 37—Never Trust Single Points of Failure 130 Rule 38—Avoid Putting Systems in Series 132 Rule 39—Ensure That You Can Wire On and Off Features 135 Summary 138   Chapter 10: Avoid or Distribute State 139 Rule 40—Strive for Statelessness 140 Rule 41—Maintain Sessions in the Browser When Possible 142 Rule 42—Make Use of a Distributed Cache for States 144 Summary 146 Notes 146   Chapter 11: Asynchronous Communication and Message Buses 147 Rule 43—Communicate Asynchronously as Much as Possible 149 Rule 44—Ensure That Your Message Bus Can Scale 151 Rule 45—Avoid Overcrowding Your Message Bus 154 Summary 157   Chapter 12: Miscellaneous Rules 159 Rule 46—Be Wary of Scaling through Third Parties 161 Rule 47—Purge, Archive, and Cost-Justify Storage 163 Rule 48—Partition Inductive, Deductive, Batch, and User Interaction (OLTP) Workloads 166 Rule 49—Design Your Application to Be Monitored 169 Rule 50—Be Competent 172 Summary 174 Notes 174   Chapter 13: Rule Review and Prioritization 177 A Risk-Benefit Model for Evaluating Scalability Projects and Initiatives 177 50 Scalability Rules in Brief 180 A Benefit/Priority Ranking of the Scalability Rules 200 Summary 202   Index 205