There are a number of techniques when using MySQL Replication with Global Transaction Identifiers (GTIDs) in MySQL 5.6.9 and later for provisioning a new slave which can then be used for scaleout, being promoted to master as necessary for failover. In this section, we discuss the four techniques listed here:
Global transaction identifiers were added to MySQL Replication for the purpose of simplifying in general management of the replication data flow and of failover activities in particular. Each identifier uniquely identifies a set of binary log events that together make up a transaction. GTIDs play a key role in applying changes to the database: the server automatically skips any transaction having an identifier which the server recognizes as one that it has processed before. This behavior is critical for automatic replication positioning and correct failover.
The mapping between identifiers and sets of events comprising a given transaction is captured in the binary log. This poses some challenges when a user wants to provision a new server with data from another existing server. To reproduce the identifier set on the new server, it is necessary, not only to copy the identifiers from the old server to the new one, but to preserve the relationship between the identifiers and the actual events as well, which is what is needed for restoring a slave that is immediately available as a candidate to become a new master on failover or switchover.
This is the easiest way to reproduce all identifiers and
transactions on a new server; you simply make the new server
into the slave of a master that has the entire execution
history, and enable global transaction identifiers on both
servers. (This requires that both master and slave are running
with the options
Section 126.96.36.199, “Setting Up Replication Using GTIDs”, for more
Once replication is started, the new server copies the entire binary log from the master and thus obtains all information about all GTIDs.
This method is simple and effective, but requires the slave to read the binary log from the master; it can sometimes take a comparatively long time for the new slave to catch up with the master, so this method is not suitable for fast failover or restoring from backup. We can obviate the need to fetch all of the execution history from the master by copying binary log files to the new server, as discussed in the next few paragraphs.
Copying data and transactions to the slave. Playing back the entire transaction history can be time-consuming, and represents a major bottleneck when setting up a new replication slave. To eliminate this requirement, we can take from the master a backup that includes, in addition to a dump containing a snapshot of the data set, the binary logs and the global transaction information they contain. Setting up the slave then consists of importing the snapshot, then playing back the binary log, after which replication can be started, allowing the slave to become current with any remaining transactions.
There are several variants of this method; these can be distinguished by the manner in which data (dumps) and transactions (binary logs) are shipped to the new slave, as outlined here:
|Data Set||Transaction History|
This method has the advantage that a new server is available almost immediately; only those transactions that were committed while the snapshot or dump file was being replayed still need to be obtained from the existing master. This means that the slave's availability is not instantanteous—but only a relatively short amount of time should be required for the slave to catch up with these few remaining transactions.
Copying over binary logs to the target server in advance is usually faster than reading the entire transaction execution history from the master in real time. However, due to size or other considerations, it may not always be feasible to move these files to the target when required. The two remaining methods for provisioning a new slave discussed in this section use other means to convey information about transactions to the new slave.
Injecting empty transactions.
The master's global
contains the set of all transactions executed on the master.
Rather than copy the binary logs when taking a snapshot to
provision a new server, you can instead note the content of
gtid_executed on the server from which the
snapshot was taken. Before adding the new server to the
replication chain, simply commit an empty transaction on the
new server for each transaction identifier contained in the
gtid_executed, like this:
SET GTID_NEXT='aaa-bbb-ccc-ddd:N'; BEGIN; COMMIT; SET GTID_NEXT='AUTOMATIC';
Once all transaction identifiers have been reinstated in this
way using empty transactions, you must flush and purge the
slave's binary logs, as shown here, where
N is the nonzero suffix of the
current binary log file name:
FLUSH LOGS; PURGE BINARY LOGS TO 'master-bin.00000
You should do this to prevent this server from flooding the
replication stream with false transactions in the event that it
is later promoted to master. (The
statement forces the creation of a new binary log file;
PURGE BINARY LOGS purges the
empty transactions, but retains their identifiers.)
This method creates a server that is essentially a snapshot, but in time is able to become a master as its binary log history converges with that of the replication stream (that is, as it catches up with the master or masters). This outcome is similar in effect to that obtained using the remaining provisioning method, which we discuss in the next few paragraphs.
Excluding transactions with
The master's global
gtid_purged variable contains
the set of all transactions that have been purged from the
master's binary log. As with the method discussed
Injecting empty transactions), you can
record the value of
gtid_executed on the server
from which the snapshot was taken (in place of copying the
binary logs to the new server). Unlike the previous method,
there is no need to commit empty transactions (or to issue
PURGE BINARY LOGS); instead,
you can set
the slave directly, based on the value of
gtid_executed on the server
from which the backup or snapshot was taken.
Prior to MySQL 5.6.9,
gtid_purged was not settable.
As with the method using empty transactions, this method creates a server that is functionally a snapshot, but in time is able to become a master as its binary log history converges with that of the replication master or group.