High Performance MySQL Proven Strategies for Operating at Scale, 4th Edition (Silvia Botros, Jeremy Tinley) (Z-Library)

【One-Line Pitch】 This is the definitive field manual for database engineers and architects who need to run MySQL at serious scale—covering everything from SLO-driven monitoring and InnoDB internals to replication, security, and automation—with hard-won lessons from real-world operations at companies like Twilio and SendGrid. 【Book Arc】 - **Opening (~0%–9%)**: Sets the stage with the book's core promise—moving from "keeping MySQL up" to "operating MySQL as a reliable platform." Introduces the reliability engineering mindset, the importance of service-level objectives (SLOs), and a preview of the full stack: schema design, indexing, query tuning, server configuration, and scaling through replication and high availability. - **Early (~9%–25%)**: Dives into MySQL's foundational architecture. Explains the layered design (server vs. storage engines), the critical role of the storage engine API, and why InnoDB has become the default and primary focus. Covers locking strategies (table vs. row locks), transaction handling across engines, and the major 8.0 improvements like atomic DDL and the new data dictionary. - **Early (~25%–34%)**: Transitions from theory to practice with a deep focus on monitoring. Emphasizes measuring outcomes, not outputs—availability, query latency, errors, and replication lag as key SLIs. Warns against alert fatigue and explains why replication lag is both an acute incident trigger and a long-term canary for write capacity issues. - **Middle (~34%–47%)**: Explores the Performance Schema in detail—the built-in instrumentation framework. Covers instruments, consumers, setup tables, and resource consumption. Highlights the CPU cost of over-instrumentation (e.g., row lock instruments on a million-row scan) and shows how to selectively enable monitoring for specific objects, schemas, or triggers. - **Middle (~47%–end)**: Expands into the operational layer: replication strategies to fight lag, high availability and failover patterns, security and compliance (HIPAA, GDPR, FedRAMP), secrets management, and role separation. Concludes with practical appendices on upgrading MySQL and running it on Kubernetes, plus a push toward automating traditional DBA tasks. 【Key Takeaways】 - **SLOs are the compass for database operations** (Early): Define SLIs for availability, latency, and errors based on customer experience, not internal metrics. A well-chosen SLO guides architectural decisions and helps you prioritize what to fix first. - **Replication lag is a dual-purpose signal** (Early): It's an acute SLI that can trigger incidents (e.g., a user's comment not appearing on a lagged replica) and a long-term trend indicating write capacity is being exceeded. Monitor it, but only alert when action is actionable—off-hours alerts must be worth waking someone. - **InnoDB is now the whole game** (Early): MySQL 8.0 has moved internal bookkeeping (metadata, auth) into InnoDB, bringing atomic DDL, more robust online DDL, and better crash resilience. For nearly every use case, InnoDB is the right storage engine—and you should avoid mixing engines in transactions at all costs. - **Row locks buy concurrency at a price** (Early): Row-level locking enables high concurrent writes but adds overhead in tracking and cleaning up locks. Table locks are cheaper but block everything. Understanding the trade-off is essential for schema and query design. - **Performance Schema is powerful but not free** (Middle): Every instrumented call adds CPU overhead—a wait instrument on a million-row scan means a million lock operations, while a statement instrument is a single call. Enable instrumentation selectively via `setup_objects` to balance insight against cost. - **Say no to averages in long-term metrics** (Middle): Aggregating metrics into averages (as some tools do by default) hides the outliers that cause customer-facing incidents. Choose monitoring solutions that preserve percentiles and distributions for meaningful trend analysis. - **I/O wait is the next bottleneck after memory** (Early): As data outgrows memory, disk I/O becomes the limiting factor. Monitoring I/O utilization (e.g., with `iostat`) helps you catch degradation before it becomes customer-facing, even on SSDs. - **Security and compliance are operational, not optional** (Late): Building for compliance controls (HIPAA, GDPR, FedRAMP) requires secrets management, separation of roles and data, and tracking changes—treat these as part of your database platform design, not afterthoughts. 【Reading Tips】 - **Skim the architecture chapters (Early) if you're experienced**: The layered model and InnoDB focus are foundational, but if you already know how MySQL executes queries, jump ahead to monitoring and operations. - **Deep-read the monitoring and Performance Schema sections (Early–Middle)**: These are the most actionable parts—they teach you what to measure, how to measure it without killing performance, and how to turn metrics into SLOs. - **Pay special attention to the replication lag discussion (Early)**: It's a recurring theme that ties monitoring to architecture. Understanding it early will make the later replication and high-availability chapters click. - **Use the appendices as reference, not reading material**: The upgrade guide and Kubernetes appendix are practical checklists—skim them when you need them, not cover-to-cover. - **Take notes on the "hard lessons"**: The authors share real-world failures (e.g., mixing storage engines, alert fatigue). These are the kind of insights you'll wish you had before an incident. 【Coverage Limits】 This guide covers the book's core arc from architecture and monitoring through operations and security. The excerpts do not cover detailed schema design patterns, specific query optimization techniques, or the full replication and high-availability chapters—those sections are referenced but not deeply excerpted here.