MySQL Replication is a well-known approach to providing high-availability and scaling out read-only operations (i.e. transactions) as well. In order to make it easy to exploit this scalability axis, we have extended both Fabric and the connectors' interface so that an application can express its willingness to execute a read-only operation and have its request redirected to the server that is most capable of handling it.
In this post, we are going to describe how we can use Fabric and the connector python to scale out read-only operations. We need to introduce some concepts first though.
Fabric organizes the servers in high-availability groups, uses the standard MySQL Replication to synchronize the servers which can be classified according to its status, mode and weight.
The blog post
MySQL Fabric High-Availability Groups from Mats briefly describes these concepts and the background for them.
Status
The status of the server provide information about what the server is currently doing in the group:
- Primary can accept both reads and writes. It is the master in the standard MySQL Replication.
- Secondary can accept only reads. It is a slave in the standard MySQL Replication.
- Spare does not accept reads nor writes, but can be used to replace servers in the event of a failure. It is also a slave in the standard MySQL Replication.
- Faulty is used to denote that a server is not working properly for any reason.
The following table depicts the transitions from one status to the other and the operations
that can trigger them:
|
Target Status |
Source Status |
PRIMARY |
SECONDARY |
SPARE |
FAULTY |
PRIMARY |
|
promote/demote |
|
report |
SECONDARY |
pomote/demote |
|
set_status |
report |
SPARE |
promote/demote |
set_status |
|
report |
FAULTY |
|
|
set_status |
|
The report commands, which are
"threat report_failure" and
"threat report_error", can be used
by external entities (e.g. connectors) and MySQL Fabric itself to inform that either a server is faulty or that it seems to
be faulty, respectively. In other words, Fabric immediately sets a server to faulty after getting a notification through the
"threat report_failure" command and only sets a server to faulty after getting notifications from different entities within a time period through the
"threat report_error".
These parameters might be set up in the configuration file under the
"failure_tracking" section:
- notifications: Number of reported errors after which a server is considered unstable.
- notification_clients: Number of different sources that must report an error to consider a server unstable.
- notification_interval: Window interval in seconds that is considered to compute the number of reported errors.
The
"group promote" command is used to automatically demote the current primary, if there is any, and elect a new one among the healthy slaves.
The "group demote" command is used to demote the current primary. Only secondaries are automatically picked by the
"group promote" command as possible candidates to replace a primary. On the other hand, spares might be used to replace a primary only if explicitly requested.
Note that if a server is marked as faulty and we want to change its status after it has been repaired, the
"server set_status" command must be used. In this case, the only possibility is to set its status from faulty to spare:
mysqlfabric server set_status server-id spare
Secondaries are ready to accept read requests so setting the status to spare avoid serving stale data as the server was down for a period of time and might have missed some updates. If the recently re-enabled spare was once a primary and we want to restore its previous status, the following command would do the task:
mysqlfabric group promote group-name --slave_id=server-id
The
group-name and
server-id must be replaced by the group which the server belongs to and its real UUID or address, respectively.
Mode
The mode of the server gives information on whether it can be read or written and
provides information to the connector on where it should send queries to.
- Offline server does not accept reads nor writes. Any spare server has its mode
set to offline.
- Read-only server can accept only reads. Any secondary server has its mode set to
read-only.
- Write-only server can accept only writes. It is possible to make a primary accept only writes.
- Read-write server can accept both reads and writes. By default a primary accepts both reads and writes.
The server's mode is automatically changed when the status is changed. However, we can still perform some additional changes through the
"server set_mode":
|
Possible Mode |
Status |
OFFLINE |
READ_ONLY |
WRITE_ONLY |
READ_WRITE |
PRIMARY |
|
|
x |
x |
SECONDARY |
x |
x |
|
|
SPARE |
x |
x |
|
|
FAULTY |
|
|
|
|
By default a spare server will not be picked by connectors to serve neither reads nor writes. However, if we want to expand the pool of scale-out servers, we can change its mode to read-only as follows:
mysqlfabric server set_mode server-id read_only
Weight
The weight represents the relative power of the server. It is a float number greater
than zero and less or equal to one. By default, any server has the weight property
equal to 1.0.
Although any server may have its weighted changed through the
"server set_weight" command in
the server group command, this information is only used now to implement a weighted
round-robin scheduling in the connectors to distribute reads:
mysqlfabric server set_weight server-id weight
The
server-id and weight must be replaced by a real UUID or address and float number greater than zero and less or equal to one.
Scaling out Reads
Using python, an application can set that it wants to execute a read-only transaction
as follows:
self.__cnx = mysql.connector.connect(**fabric_params)
self.__cnx.set_property(group=group, mode=MODE_READONLY)
Note the
"mode" parameter in the
"set_property" method. Read-only transactions are sent to any server that has the
"mode" set to read_only or read_write meaning that it might be sent to either a secondary, a spare or a primary. The primary is only used though as the last resort to serve a query. Connectors try to offload the primary which
might become overloaded if both read-only and read-write transactions are sent to it. If Using secondaries and spares to process read operations has a drawback though. Read operations
may return stale information because the replication protocol is asynchronous which means
that changes to the primary are not immediately propagated to slaves. If we want
to read updated information, we need to guarantee that requests are sent to the primary (i.e. master) as follows:
self.__cnx = mysql.connector.connect(**fabric_params)
self.__cnx.set_property(group=group, mode=MODE_READWRITE)
Note the
"mode" parameter in the
"set_property" method. It specifies that the application
wants to execute a read-write transaction. However, only the primary accepts writes. So
a connection to the primary will be established thus allowing the application to retrieve updated
information. We are considering ways to improve this by providing the possibility of
returning updated information even when a secondary server is used. See some insights on this in the blog post
MySQL Fabric: Musings on Release 1.4.3 from Mats.
To take advantage of all possible secondary servers in the system, the load should be
distributed among them. To make this easier, servers in Fabric have a weight property
which represents the relative power of the server. When balancing the load between servers,
the connector will figure out which servers are eligible for accepting a transaction and
then pick one of the servers in such a way that the distribution over time will be
proportional to the weight of the server.
Summary and a sketch of an application
After installing and configuring MySQL Fabric (click
here for further details on that), there aren't many things we need to do to exploit its ability to scale out reads:
- If there are spares, decide whether they will accept reads or not. If a spare should accept reads, execute the following command:
mysqlfabric server set_mode server-id read_only
- If there are secondaries that should not accept reads, execute the following command:
mysqlfabric server set_mode server-id offline
- Configure the servers' weights according to their capacity to handle requests:
mysqlfabric server set_weight server-id weight
The next step consisting in calling the appropriate functions and methods within the application:
conn = mysql.connector.connect(
fabric={"host" : "localhost", "username": "admin",
"password" : "adminpass"
},
user="webuser", password="webpass"
)
conn.set_property(group="my_group", mode=fabric.MODE_READONLY)
cur = conn.cursor()
cur.execute(
"SELECT first_name, last_name FROM employees "
"WHERE emp_no = %s", (emp_no, )
)
conn.commit()