MySQL Cluster builds a Galera cluster from bare machines and then runs it from one web page. You pick MySQL or MariaDB, and the rest is the same either way. Every node takes writes. No write is confirmed until all of them have agreed to it. Lose a machine and nothing pauses, nothing fails over, and nobody gets woken up.
Galera is excellent and it does not come with a way to run it.
Compiling MariaDB with Galera, or getting Percona onto a release they publish for, then sizing the buffer pool for the machine, writing a config that is identical on every node, and doing all of it three times without one of them drifting.
Galera publishes forty status variables per node and no page that puts them together. Whether a node is falling behind is a number you have to know to look for.
A node serving its own cluster of one looks perfectly healthy. A node out of quorum answers every connection and refuses every write. Neither announces itself.
Then the same two on the next machine, and a ticket from the web page to join it.
sudo git clone https://git.failoverlb.net/mysqlcluster.git \
/data/docker/mysqlcluster
cd /data/docker/mysqlcluster && sudo ./install.sh
That installs the agent, builds the manager and starts it. The database is one more command, or a button, and that is where you pick MySQL or MariaDB. Everything before that command and everything after it is the same either way.
Sixteen things, grouped by when you need them.
Compiles MariaDB and Galera from source on each machine, sized to the hardware it is on, so every node is genuinely identical.
A single use ticket from the interface, one command on the new machine, and it joins. No account to create, nothing typed twice.
A node that loses the others refuses to guess. Silence is never treated as evidence, because a wrong guess makes two databases.
Takes it off the roster, rewrites the node list everywhere, and refuses if it would leave a cluster that cannot survive a failure.
State, version and apply queue per machine. Serving and running are shown as the different questions they are.
Position, apply queue, flow control and conflicts, worked out per interval rather than since boot.
Processor, memory, disk and query rates. Drag to select a span and every chart narrows to it.
Who did what and whether it worked, written where it happened and never rewritten from anywhere else.
What exists, how big it is on disk, and what is inside it.
MySQL logins with the host half always shown, because that is the part that catches people out.
One statement at a time, split by read and write permission, and every one of them recorded.
Three identical nodes protect against a machine dying. A backup is the only copy a dropped table does not reach.
WireGuard across sites or behind NAT. One node is reachable, everything else dials out.
Local accounts with an authenticator, or your identity provider, with viewer, operator and admin roles.
Change it once and it is on the others in seconds, so the allow list cannot be right on one machine and wrong on the rest.
Anonymous accounts and the grants every account inherits, removed at build time rather than left for somebody to find.
Three machines, 4 processors, 16 GB of memory and NVMe disks, driven from all three nodes at once. Both servers, on the same machines, wiped and rebuilt in between.
The limit is the write path rather than the hardware: at peak the processors were 61% busy with 11.6 of 15.5 GB of memory free. Every write has to be accepted by every node before it commits, so writes do not scale by adding machines. Reads do.
Better said here than found out later.
A cluster writes no faster than one machine and usually a little slower, because every node does every write. What it buys is that losing a machine costs nothing.
Three identical copies protect against a machine dying and nothing else. A dropped table reaches every node in milliseconds. It takes backups too, and they are the copy that a mistake does not reach.
That is arithmetic rather than a limitation: either failure leaves one node holding half, and half is not a majority. Three is the smallest useful cluster.
There are two installers, MariaDB and Percona XtraDB Cluster, and a cluster has to be all of one or all of the other. A join of the wrong one is refused rather than allowed to become a cluster that disagrees with itself about what SQL means.
Free, MIT licensed, and yours to keep. There is no paid tier and nothing to sign up to.