The MySQL High Availability Landscape in 2017, Part 1: The Elders
This review will be in three parts. The first part (this post) will cover the technologies that have been around for a long time: the elders.
Join the DZone community and get the full member experience.Join For Free
In this blog, we’ll look at different MySQL high availability options.
The dynamic MySQL ecosystem is rapidly evolving many technologies built around MySQL. This is especially true for the technologies involved with the high availability (HA) aspects of MySQL. When I joined Percona back in 2009, some of these HA technologies were very popular – but have since been almost forgotten. During the same interval, new technologies have emerged. In order to give some perspective to the reader, and hopefully, help to make better choices, I’ll review the MySQL HA landscape as it is in 2017. This review will be in three parts. The first part (this post) will cover the technologies that have been around for a long time: the elders. The second part will focus on the technologies that are very popular today: the adults. Finally, the last part will try to extrapolate which technologies could become popular in the upcoming years: the babies.
Quick disclaimer: I am reporting on the technologies I see the most. There are likely many other solutions not covered here, but I can’t talk about technologies I have barely or never used. Apart from the RDS-related technologies, all the technologies covered are open-source. The target audience for this post are people relatively new to MySQL.
Let’s define the technologies in the elders group. These are technologies that anyone involved with MySQL for last ten years is sure to be aware of. I could have called this group the “classics”. I include the following technologies in this group:
- Shared storage.
- NDB cluster.
Let’s review these technologies in the following sections.
Replication: Simple Replication Topology
MySQL replication is very well known. It is one of the main features behind the wide adoption of MySQL. Replication gets used almost everywhere. The reasons for that are numerous:
- Replication is simple to set up. There are tons of how-to guides and scripts available to add a slave to a MySQL server. With Amazon RDS, adding a slave is just a few clicks.
- Slaves allow you to easily scale reads. The slaves are accessible and can be used for reads. This is the most common way of scaling up a MySQL database.
- Slaves have little impact on the master. Apart from the added network traffic, the presence of slaves does not impact the master performance significantly.
- It is well known. No surprises here.
- Used for failover. Your master died, promote a slave and use it as your new master.
- Used for backups. You don’t want to overload your master with the backups, run them off a slave.
Of course, replication also has some issues:
- Replication can lag. Replication used to be single-threaded. That means a master with a concurrent load could easily outpace a slave. MySQL 5.6 and MariaDB 10.0 have introduced some parallelism to the slave. Newer versions have further improved to a point where today’s slaves are many times faster than they were.
- Slaves can diverge. When you modify data on the master, the slave must perform the exact same update. That seems easy, but there are many ways an update can be non-deterministic with statement-based replication. They fixed many issues, and the introduction of row-based replication has been another big step forward. Still, if you write directly to a slave you are asking for trouble. There is a
read_onlysetting, but if the MySQL user has the
SUPERprivilege it is just ignored. That’s why there is now the
super_read_onlysetting. Tools like pt-table-checksum and pt-table-sync from the Percona toolkit exist to solve this problem.
- Replication can impact the master. I wrote above that the presence of slaves does not affect the master, but logging changes are more problematic. The most common issue is the InnoDB table-level locking for
auto_incrementvalues with statement-based replication. Only one thread can insert new rows at a time. You can avoid this issue with row-based replication and properly configuring settings.
- Data gets lost. Replication is asynchronous. That means the master will reply “done” after a commit statement even though the slaves have not received updates yet. Some transactions can get lost if the master crashes.
Although an old technology, a lot of work has been done on replication. It is miles away from the replication implementation of 5.0.x. Here’s a list, likely incomplete, of the evolution of replication:
- Row-based replication (since 5.1). The binary internal representation of the rows is sent instead of the SQL statements. This makes replication more robust against slave divergence.
- Global transaction ID (since 5.6). Transactions are uniquely identified. Replication can be set up without knowing the binlog file and offset.
- Checksum (since 5.6). Binlog events have checksum values to validate their integrity.
- Semi-sync replication (since 5.5). An addition to the replication protocol to make the master aware of the reception of events by the slaves. This helps to avoid losing data when a master crashes.
- Multi-source replication (since 5.7). Allows a slave to have more than one master.
- Multi-threaded replication (since 5.6). Allows a slave to use multiple threads. This helps to limit the slave lag.
Managing replication is a tedious job. The community has written many tools to manage replication:
- MMM. An old Perl tool that used to be quite popular, but had many issues. Now rarely used.
- MHA. The most popular tool to manage replication. It excels at reconfiguring replication without losing data, and does a decent at handling failover. It is also simple. No wonder it is popular.
- PRM. A Pacemaker-based solution developed to replace MMM. It’s quite good at failover, but not as good as MHA at reconfiguring replication. It’s also quite complex, thanks to Pacemaker. Not used much.
- Orchestrator. The new cool tool. It can manage complex topologies and has a nice web-based interface to monitor and control the topology.
Shared Storage: Simple Shared Storage Topology
Back when I was working for MySQL ten years ago, shared storage HA setups were very common. A shared storage HA cluster uses one copy of the database files between one of two servers. One server is active, the other one is passive. In order to be shared, the database files reside on a device that can be mounted by both servers. The device can be physical (like a SAN), or logical (like a Linux DRBD device). On top of that, you need a cluster manager (like Pacemaker) to handle the resources and failovers. This solution is very popular because it allows for failover without losing any transactions.
The main drawback of this setup is the need for an idle standby server. The standby server cannot have any other assigned duties since it must always be ready to take over the MySQL server. A shared storage solution is also obviously not resilient to file-level corruption (but that situation is exceptional). Finally, it doesn’t play well with a cloud-based environment.
Today, newly-deployed shared storage HA setups are rare. The only ones I encountered over the last year were either old implementations needing support, or new setups that deployed because of existing corporate technology stacks. That should tell you about the technology’s loss of popularity.
NDB Cluster: A Simple NDB Cluster Topology
An NDB Cluster is a distributed clustering solution that has been around for a long time. I personally started working with this technology back in 2008. An NDB Cluster has three types of nodes: SQL, management, and data. A full HA cluster requires a minimum of four nodes.
An NDB Cluster is not a general purpose database due to its distributed nature. For suitable workloads, it is extraordinary good. For unsuitable workloads, it is miserable. A suitable workload for an NDB Cluster contains high concurrency, with a high rate of small primary key oriented transactions. Reaching one million trx/s on an NDB Cluster is nothing exceptional.
At the other end of the spectrum, a poor workload for an NDB Cluster is a single-threaded report query on a star-like schema. I have seen some extreme cases where just the network time of a reporting query amounted to more than 20 minutes.
Although NDB Clusters have improved, and are still improving, their usage has been pushed toward niche-type applications. Overall, the technology is losing ground and is now mostly used for Telcos and online gaming applications.
Published at DZone with permission of Yves Trudeau, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.