MariaDB提供了兼容MySQL的数据库解决方案，它本身是MySQL的一个Fork。

MySQL中复制（Replication）是异步的、单向的。其中一个服务器作为Master，其它的作为Slave。所谓主主模式，是两个服务器分别配置为对方的Slave。MariaDB提供主主复制、主从复制。

MySQL 的默认二进制日志格式是基于行的，而在 MariaDB 中，默认的二进制日志格式是混合式的。

MariaDB支持二进制日志压缩（log_bin_compress）。

MySQL提供shared-nothing的集群支持，通过自动分区的方式将数据分发到不同节点。在内部MySQL使用同步的、两阶段的提交，确保数据被写入到多个分片。

MariaDB使用Galera Cluster实现多主，从10.1开始MariaDB内置Galera，只需要配置参数即可启用集群模式。

MariaDB支持更多的存储引擎：XtraDB（10.2-的默认引擎，InnoDB增强版）、InnoDB（10.2+默认引擎）、MariaDB ColumnStore、Aria、Archive、Blackhole、Cassandra Storage Engine、Connect、CSV、FederatedX、Memory、Merge、Mroonga、MyISAM、MyRocks、QQGraph、Sequence Storage Engine、SphinxSE、Spider、TokuDB

MariaDB 上可用，MySQL 不支持该功能。这个功能允许创建不再 SELECT * 语句中出现的列，而在进行插入时，如果它们的名字没有出现在 INSERT 语句中，就不需要为这些列提供值。

从 5.7 版本开始，MySQL 支持由 RFC 7159 定义的原生 JSON 数据类型，可以高效地访问 JSON 文档中的数据。

MariaDB 没有提供这一增强功能，认为 JSON 数据类型不是 SQL 标准的一部分。但为了支持从 MySQL 复制数据，MariaDB 为 JSON 定义了一个别名，实际上就是一个 LONGTEXT 列。

MariaDB 支持连接线程池，这对于短查询和 CPU 密集型的工作负载（OLTP）来说非常有用。在 MySQL 的社区版本中，线程数是固定的，因而限制了这种灵活性。MySQL 计划在企业版中增加线程池功能。

MariaDB Galera Cluster提供MariaDB多主集群，仅仅对XtraDB/InnoDB存储引擎提供支持。

从MariaDB 10.1开始，MySQL-wsrep补丁被合并到MariDB，这意味着使用标准的MariaDB+Galera wsrep提供者库即可构建Galera集群。该补丁由Codership开发，提供wsrep API支持。

Galera的主要特性包括：

1. 几乎同步的（virtually synchronous ）的复制
2. Active-Active多主拓扑支持，不需要failover
3. 针对集群的任何节点进行读写操作
4. 自动的集群成员控制，失败的节点能够自动的移出集群
5. 自动节点加入
6. 真正的（从底层）并行复制
7. 不需要读写分离
8. Slave支持多线程以提升性能

基于Galera的集群的主要优势包括：

1. 没有Slave的延迟
2. 不会丢失事务
3. 读操作的可扩容性
4. 更小的客户端延迟

Galera的使用场景包括：

1. 从Master读写：Galera支持这种传统场景，但是和MariaDB传统主从复制相比，任何一个节点都可以随时成为Master，而其它节点仅仅是客户端将其作为Slave看待而以。由于Slave可以并行的应用writeset，集群的吞吐量会快的多，此外复制的延迟也被消除
2. 广域网集群：可以支持这种网络下的几乎同步复制，可能会存在延迟，取决于RTT。这些延迟仅仅影响commit操作
3. 灾难恢复：广域网集群的子用例。这种情况下，位于某个数据中心的节点仅被动接受复制，不处理任何客户端事务。由于Galera的几乎同步的复制，它不会丢失数据，并可以在主节点宕机后立即升级为新的主节点
4. 延迟消除：让客户端访问靠近自己的节点，可以消除读操作的延迟。延迟仅仅在写操作时才发生

MariaDB、Galera库、wsrep API版本对应关系如下：

使用包名galera-4安装Galera 4 wsrep provider。版本26.4.6对应MariaDB的版本是10.5.7 / 10.4.16

使用包名galera安装Galera 3 wsrep provider。版本25.3.31对应MariaDB的版本是10.3.26 / 10.2.35 / 10.1.48

Galera复制功能实现为一个共享库，可以连接到任何实现了wsrep API的事务处理系统。它是由一系列组件组成的协议栈，提供准备、复制、应用事务writeset的功能。

在Galera 4很多组件被重新设计。

即写入集复制API（writeset replication API），它定义了Galera Replication和MariaDB之间的接口，以及各自的职责。 

在RDBMS引擎中的wsrep集成点。

为Galera库实现wsrep API。

尽管galera provider负责在提交时，在所有节点认证writeset，但是writeset不需要被立即apply到节点。实际上writeset被放置在节点的接收队列上，由节点的某个galera slave thread最终apply到数据库中。

Galera slave thread的数量可以通过系统变量

wsrep_slave_threads

Galera slave thread们负责自行判断哪些writeset可以被安全的并行apply，但是，如果节点经常出现数据一致性问题，可以将线程数量设置为1。

负责准备writeset，执行认证测试。

管理复制协议，提供整体上的排序能力（ordering capabilities）

为Group Communication系统（GCS）提供插件化架构。很多GCS实现可以被适配。内置实现是vsbes、gemini 

所谓状态转移是指从现有节点复制数据，以使得新节点/宕机后恢复的节点到达同步状态的操作。

在一次State Snapshot Transfers / SST中，集群通过从一个节点拷贝完整的数据集，来创建新节点。

当新节点加入集群后，它会触发一次SST。

在一次Incremental State Transfers /IST中，集群从正常节点，拷贝某个节点缺失的writeset。

如果节点离开集群时间比较短，则IST通常比SST更块。

在Galera集群中，服务器在提交（Commit）期间进行事务复制。其做法是，将事务关联的写入集（writeset）广播到所有节点。 

同步复制能够保证：如果一个节点上的数据发生变更，那么这些变更会同时发生在其它节点上。

异步复制不提供上述保证，这意味着，在第一个节点上发生变更后，复制完成之前该节点宕机，可能会导致数据丢失。

同步复制的优势：

1. 使用同步复制的集群，总是能保证HA和数据一致性。节点崩溃不会导致数据丢失
2. 同步复制允许事务在所有节点上并行的执行。而不是进行Replay
3. 因果律保证：如果先在A节点发生事务，然后在B节点执行查询，那么该查询一定能看到A节点那个事务的结果

典型的同步复制利用两阶段提交或者分布式锁来实现，非常缓慢。再加上实现的复杂度，导致MySQL、PostgreSQL等传统RDBMS都仅仅支持异步复制，或者所谓半同步复制（主库在执行完客户端提交的事务后不是立刻返回给客户端，而是等待至少一个从库接收到并写到Relay log中才返回给客户端）。

Galera使用基于认证的复制（Certification-based replication），实现几乎完全同步（virtually synchronous）的数据复制。

Galera的基本思想是乐观执行（ optimistic execution）：假设不存在冲突，正常执行事务，直到达到提交点（commit point），在提交之前，通过认证来检查冲突

Galera的核心机制包括：

1. 分组通信（group communication）：定义了数据库节点之间的通信pattern，保证复制数据的一致性
2. 写入集（writeset）：将若干数据库写操作合并为一个消息，避免了每次数据库操作都引发节点之间的协作。writeset中包含了事务的所有必要信息
3. 数据库状态机（database state machine）：只读事务仅在节点本地执行。非只读事务首先在单个节点本地执行，然后广播writeset到其它节点，认证并apply到数据库
4. 全局事务排序（global transaction reordering）：在复制期间，Galera为每个事务分配一个全局的序号即seqno，每个节点将以相同的顺序接收（和应用）事务。当事务到达提交点时，节点会检查上一次成功的事务的seqno。这两次事务seqno的差值，提示了尚未apply的事务数量。节点会对这些没处理的事务进行主键冲突检查，发现冲突则触发认证失败

Galera执行数据复制的流程如下：

1. 当客户端发出一个 commit 指令，在事务在服务器端被正式（数据已经写入，只差）提交之前，所有对数据库的更改都会被writeset收集起来，并且将 writeset 纪录广播给其他节点

2. writeset 将在每个节点（包括发起writeset的原始节点）上、基于主键进行决定性认证测试（deterministic certification test,），测试结果决定节点能否 apply writeset

3. 如果认证测试失败：节点丢弃writeset，集群回滚原始事务

4. 如果认证测试成功：事务被正式提交，其余节点则apply writeset

只有所有节点都认证成功，达成共识，那么发起事务的原始节点就可以正式提交并给客户端响应。在这个时间点，用户的写入集已经同步到了所有节点，不会因为原始节点故障而导致数据丢失

关于从普通MariaDB转到Galera的TIPS，参考：https://mariadb.com/kb/en/tips-on-converting-to-galera/

对任何其它引擎的表的写入，包括系统表（mysql.*，使用MyISAM引擎）都不会复制到其它节点。例外情况是DDL语句，这些语句虽然修改mysql.*表，但是却会被复制。

对MyISAM复制目前提供试验性支持，设置系统变量：wsrep_replicate_myisam。

FLUSH PRIVILEGES 不会被复制。

LOCK TABLES、FLUSH TABLES (table list) WITH READ LOCK等语句不被支持，可以通过适当的事务控制来达到相同效果。

全局性的锁操作，例如FLUSH TABLES WITH READ LOCK则可以被支持。

所有表必须具有主键（支持复合主键）。针对无主键表的DELETE操作是不支持的。没有主键的表，可能在不同节点上的顺序不同。

普通查询日志、缓慢查询日志，不支持写入到表中。如果启用这些日志，你必须设置log_out=FILE

尽管Galera没有明确限制，但是writeset被存储在内存中，这隐含了对事务尺寸的限制。

为了避免非常大的事务严重影响节点性能。系统变量的默认值设置为：

1. wsrep_max_ws_rows  事务最大影响行数，128K
2. wsrep_max_ws_size 事务最大尺寸（写入集大小）2GB

此外根据社区的反馈，大尺寸事务可能有额外的不可忽略的开销。你写入100K的行，可能需要额外200-300MB甚至数G内存。

你的DML语句操作一个锁，而另外一个DDL已经发起。正常情况下MySQL会等待元数据锁，但是Galera则会立即执行DML。甚至仅有单个节点的情况下，也会发生这种情况。

不要假设自增长的列是一个个顺序增长的。Galera为了保证没有冲突，为每个节点的自增长键都设置了空虚。

当出现网络分区，并且当前节点不再大多数节点所在分区。命令会导致ER_UNKNOWN_COM_ERROR：WSREP has not yet prepared node for application use / Unknown command。这个报错是为了放置数据不一致。网络分区状态可以通过检查

wsrep_ready

少部分节点所在的分区，节点可能会丢弃所有客户端连接，这个行为可能比较意外 —— 因为客户端可能是空闲的，甚至不知道发生什么连接就忽然断了。

这种被分区的节点重新连接到集群后，可能有大量数据需要同步。在同步完成之前，它仍然会报告unknown command。

在运行时修改binlog格式，不但会导致复制失败，还会导致其它节点崩溃。

根据Galera的设计，集群的整体性能取决于最慢的节点。

此外，即使只有一个节点。性能也可能比非集群模式的MariaDB低很多，特别是对于大事务。

在MariaDB Galera Cluster 5.5.40, MariaDB Galera Cluster 10.0.14以及MariaDB 10.1.2之前，需要设置query_cache_size=0以禁用查询缓存。

启用异步复制模式的情况下，不支持在Slave节点上进行并行复制（slave-parallel-threads 大于1）。

节点的表结构可能不一致，特别是在执行rolling schema upgrade期间。

读写分离不是必须的，但是仍然建议做读写分离，未来底层架构可能变化。

所有状态变量具有一致的前缀：

SHOW STATUS LIKE 'wsrep%';

为了安装MariaDB Galera Cluster，需要以下包：

1. 支持Galera的MariDB
2. Galera wsrep提供者库

为了支持基于SST的备份，可能需要额外的包。

添加源配置：

# MariaDB 10.5 CentOS repository list - created 2021-01-15 07:44 UTC
# http://downloads.mariadb.org/mariadb/repositories/
[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/10.5/centos8-amd64
module_hotfixes=1
gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck=1

执行安装：

dnf install MariaDB-server
systemctl start mariadb

dnf install galera4 

集群的第一个节点需要以下面的命令行选项来自举（bootstrap）：

mysqld --wsrep-new-cluster

这个选项告诉MariaDB，不需要连接到既有集群。对于一个现有的节点，以该选项重启，会导致创建新的识别集群身份的UUID，并且它不会再连接到老集群。

对于使用Systemd的系统，应该使用下面的命令创建新集群：

galera_new_cluster

要添加新节点，需要通过wsrep_cluster_address选项指定集群地址，如果第一个节点的地址是192.168.0.1，则可以用下面的配置加入新节点：

[mariadb]
; 支持IP地址或DNS名称
wsrep_cluster_address=gcomm://192.168.0.1

使用上述配置，新节点将会连接到一个既有集群节点，并随后发现所有的节点。最好在此配置中，指定所有集群成员的地址，免得因为单点的故障 导致无法加入集群。

当所有成员加入到集群，状态不一致的集群可能通过IST/SST来达到一致性。

当集群所有节点关闭后，需要依次重启节点。

如果第一个节点以常规方式启动， 则它会尝试连接到wsrep_cluster_address中的其它节点，这必然失败。因此，集群完全关闭之后，需要对第一个节点进行bootstrap操作。

第一个节点，必须是数据最新的节点。如果节点检测到它可能不是数据最新（如果它不是最后一个关闭的，或者它是崩掉的）的节点，它会拒绝bootstrap。

查看所有节点的grastate.dat文件，其中seqno字段的值最大的，就是数据最新的节点。如果节点是崩掉的且seqno=-1，则可以使用下面的命令恢复seqno：

mysqld --wsrep_recover

确定数据最新节点后，可以修改它的数据目录下的grastate.dat文件，设置：

safe_to_bootstrap=1

使用Systemd的情况下，节点的seqno可以通过命令：

galera_recovery

#                                 集群group id                         seqno
[Note] WSREP: Recovered position: 7bff636d-50c7-11eb-81c8-6f8dd75e7fb4:1202

启用Galera时，MariaDB的Systemd服务会在启动数据库之前自动运行galera_recovery。

和Galera相关的状态变量，都放在wsrep_前缀下：

SHOW GLOBAL STATUS LIKE 'wsrep_%';

参考在K8S中运行一节。

当新加入一个节点到Galera集群时，此节点需要从集群节点获取数据，这个复制过程被称作状态转移（State Transfer），Galera支持两种状态传输方式：

1. State Snapshot Transfers (SST) 传输一个节点的完整状态（即所有数据），全量复制
2. Incremental State Transfers (IST) 只传输缺失的数据，增量复制

使用 IST 的方式时，集群会判断加入集群的节点所缺失的数据，而不必传输完整的数据集。使用 IST 必须满足特定的条件：

1. 加入节点的 state UUID 必须和此集群的相同
2. 加入节点所缺失的数据都在 donor 节点的 writeset cache 中存在

如果上述条件满足，供给节点会发送加入节点上缺失的事务，按照顺序replay它们，直到加入节点赶上集群进度。

IST不会阻塞供给节点

使用 IST 最重要的参数是 donor 节点的 gcache.size 大小，这个参数表示分配多少空间用于缓存 writeset。缓存的空间越多，能够使用 IST 的几率就越大

所谓状态快照转移（SST），就是指集群通过将某个up-to-date节点的数据集，完整的拷贝到另外一个节点的过程/操作。

从概念上来看，存在两种状态转移方式。

即mysqldump SST，该SST方法，实际上是调用mysqldump，从源节点获取数据库的逻辑dump文件。

要使用mysqldump SST，新加入的节点必须完全初始化，并且准备好接受连接。

该SST方法会阻塞源节点，在状态转移期间，无法对源节点进行修改。该SST方法是最慢的一种，在高负载集群中可能导致问题。

这类SST方法将数据文件从源节点拷贝到新加入的节点。节点需要在状态转移之后再完成初始化。mariabackup SST等属于这一类别。

这类方法比mysqldump SST快很多，但是具有一些限制条件：

1. 只能在服务器启动时使用
2. 新节点必须和源节点配置很相似，例如 innodb_file_per_table取值必须相同

这类方法中的某些，例如mariabackup SST，是非阻塞的，也就是说，在状态转移期间源节点可以继续处理请求。

通过设置全局系统变量，可以修改使用的SST方法：

SET GLOBAL wsrep_sst_method='mariabackup';

SST方法也可以在配置文件中修改：

[mariadb]
wsrep_sst_method = mariabackup

注意：源节点和新节点必须使用相同的SST方法。 建议所有节点使用一致的SST方法。

除了rsync SST之外，都需要配置基于用户名:密码的身份验证：

SET GLOBAL wsrep_sst_auth = 'mariabackup:password';

或者修改配置文件：

[mariadb]
wsrep_sst_auth = mariabackup:password

某些身份认证插件，例如unix_socket或gssapi，不需要密码，这种情况下只需要指定用户名： 

[mariadb]
wsrep_sst_auth = mariabackup:

为了防止脑裂的出现，推荐最小集群规模为3。

另外一个需要3节点的原因是，当SST阻塞了源节点时，仍然可以有一个节点能响应查询。

如果状态转移失败，新节点一般是不可用的。

如果使用mysqldump SST，可能还需要手工恢复某些MariaDB管理表。

本节介绍如何使用这种SST方法。

修改配置文件：

[mariadb]
wsrep_sst_method = mariabackup 

或者通过命令行设置：

SET GLOBAL wsrep_sst_method='mariabackup';

该SST方法需要在所有供给（donor）节点上进行本地身份验证。

首先需要创建专用的数据库账号： 

CREATE USER 'mariabackup'@'localhost' IDENTIFIED BY 'mypassword';
GRANT RELOAD, PROCESS, LOCK TABLES, REPLICATION CLIENT ON *.* TO 'mariabackup'@'localhost';

然后修改配置文件或执行命令行设置：

[mariadb]
wsrep_sst_auth = mariabackup:mypassword

SET GLOBAL wsrep_sst_auth = 'mariabackup:mypassword';

可以使用unix_socket身份认证插件，这样就不需要指定密码： 

CREATE USER 'mysql'@'localhost' IDENTIFIED VIA unix_socket;
GRANT RELOAD, PROCESS, LOCK TABLES, REPLICATION CLIENT ON *.* TO 'mysql'@'localhost';

当mariadbbackup在供给（donor）节点创建备份时，它需要在备份最后创建一个全局的锁：

1. 在10.3-，锁通过 

   FLUSH TABLES WITH READ LOCK

   实现
2. 在10.4+，锁通过 

   BACKUP STAGE BLOCK_COMMIT

   实现

如果集群中某个节点正作为“主”节点来使用 —— 也就是说应用程序连接到它来写入数据，那么该节点不应该用作SST源，因为全局锁会干扰应用程序的写操作。

可以通过下面的系统变量，来设置偏好使用哪些节点作为源：

[mariadb]
; 如果集群由 node1, node2, node3, node4, node5构成。node1作为主使用
; 那么node2可以这样配置：
wsrep_sst_donor=node3,node4,node5,
; 结尾的逗号表示，如果偏好的节点不可用，允许选择任何节点作为源

mariabackup SST具有独立的日志，不和数据库日志在一起：

[sst]
sst-log-archive=1
sst-log-archive-dir=/var/log/mysql/sst/
; 记录到syslog中
sst-syslog=1

Galera Load Balancer（GLB）是一个简单的、特地为Galera设计负载均衡器。该LB支持多种负载均衡策略。

节点可以被设置不同的权重，优先使用高权重的节点，根据选择的策略，低权重节点可能被忽略（除非高权重节点挂掉）。

一个轻量级的守护进程glbd负责接收客户端连接，并执行LB算法，重定向客户端请求到适当的节点。

1. 可以在运行时配置后端节点列表
2. 支持drain节点，也就是不分配新的连接给它，但是不会kill服务器 —— 让它优雅关闭
3. 使用epool提升性能
4. 支持多线程，可以利用多核心CPU
5. 支持可选的watchdog来监控后端并调整路由表

GLB支持以下负载均衡策略：

1. least connected： 最少连接，新连接并分发给连接最少的节点，需要考虑节点权重
2. round-robin：依次循环调度给每个节点
3. single：所有连接调度给最高权重的节点，除非此节点挂了，或者引入一个新的、更高权重的节点
4. random：随机调度
5. source tracking：来自同一源地址的连接，总是被调度给同一节点

推荐的部署模式是3节点以上，奇数节点。

如果部署第3个节点（例如只有两个数据中心）的成本过高，可以考虑引入仲裁节点（Galera Arbitrator）以防止脑裂。仲裁节点：

1. 参与投票，来决定Primary Component。当两节点集群出现网络分区时，能够看到仲裁节点的那个构成Primary Component
2. 不参与复制。尽管仲裁节点不参与复制，但是它会接收所有数据（但是不存储），这意味着你不能将其放置在网络连接差的地方，否则可能导致很差的集群性能

仲裁节点还有另外一个用途——用于备份，它可以请求数据库状态的一致性快照。

由独立的守护进程garbd来运行仲裁节点：

garbd --group=example_cluster \
     --address="gcomm://192.168.1.1,192.168.1.2,192.168.1.3" \
     --option="socket.ssl_key=/etc/ssl/galera/server-key.pem;socket.ssl_cert=/etc/ssl/galera/server-cert.pem;socket.ssl_ca=/etc/ssl/galera/ca-cert.pem;socket.ssl_cipher=AES128-SHA256""

配置信息也可以放在独立文件中：

group = example_cluster
address = gcomm://192.168.1.1,192.168.1.2,192.168.1.3

garbd --cfg /path/to/arbitrator.config

由于Galera集群的复制特性，执行备份时我们只需要在一个节点上进行。而在恢复时，也仅仅需要在一个节点上执行，剩下节点的同步，可以依靠状态转移自动完成。

任何时候，都可以针对某个Galera节点，使用常规的MariaDB备份工具进行备份。

上文中的内置SST方法，对应了各种备份工具，混合使用多种备份方法，能够提高额外的数据安全性。这里挑选几个工具说明用法：

--single-transaction

wsrep_desync=OFF

# 备份所有数据库
mysqldump -u root -p pswd –all-databases > data.sql
# 仅仅备份gmem数据库的表结构
mysqldump -u root -p pswd –no-data gmem > schema.sql


# 恢复数据库，可能需要先清空
mysql> drop database gmem;

mysql -u root -p pswd <  schema.sql

#                   数据目录                  备份存放目录
xtrabackup --backup --datadir=/var/lib/mysql/ --target-dir=/data/backups/mysql/

xtrabackup: Transaction log of lsn (<SLN>) to (<LSN>) was copied.

# 假设使用innodb_file_per_table选项
/data/backups/mysql/ibdata1
/data/backups/mysql/test
/data/backups/mysql/test/tbl1.ibd
/data/backups/mysql/xtrabackup_checkpoints
/data/backups/mysql/xtrabackup_logfile

xtrabackup --prepare --target-dir=/data/backups/mysql/

# 结束时会打印
101107 16:40:15  InnoDB: Shutdown completed; log sequence number <LSN>

rsync -avrP /data/backup/ /var/lib/mysql/
chown -R mysql:mysql /var/lib/mysql

# 备份      数据库帐号密码                      备份根目录            不创建基于时间戳的子目录
innobackupex --user=DBUSER --password=DBUSERPASS /path/to/BACKUP-DIR/ --no-timestamp
#            指定MySQL配置文件
innobackupex --defaults-file=/tmp/other-my.cnf --user=DBUSER --password=DBUSERPASS /path/to/BACKUP-DIR/

# 准备                   允许使用多少内存
innobackupex --apply-log --use-memory=100M  /path/to/BACKUP-DIR

# 恢复
innobackupex --copy-back /path/to/BACKUP-DIR

由于所有Galera节点具有相同的数据，因此你可以使用常规的MariaDB备份工具进行备份，但是这种方式存在缺点 —— 缺少全局事务ID信息（GTID）。使用这种备份来恢复，不能让节点进入良好定义的状态。此外，某些备份工具会阻塞节点，这也需要注意。

因此，理想的备份方式是发起一次SST：

1. 节点会在一个良好定义的点发起备份
2. 节点会将GTID关联到备份
3. 备份期间，节点从集群desync，避免影响性能 —— 备份过程可能阻塞节点
4. 集群知道节点正在进行备份，因此不会将其选为donor

我们需要利用仲裁节点来发起备份：

# garbd可以以函数方式执行，调用一个命令
#                                   如果在集群节点上发起，则4567已被占用，另外选择一个端口
garbd --address gcomm://192.168.1.2?gmcast.listen_addr=tcp://0.0.0.0:4444 \
#   机器名称               供给节点名称           在供给节点上执行的脚本的后缀
  --group example_cluster --donor galera-3 --sst backup_mysqldump

你也可以通过配置文件指定各种选项：

; 填写集群的wsrep_cluster_name
group='example_cluster'
; 填写集群的wsrep_cluster_address
address="gcomm://172.31.30.39:4567,172.31.18.53:4567,172.31.26.106:4567"
; 填写集群的wsrep_provider_options。listen_addr添加garbd进程的监听端口
options="gmcast.listen_addr=tcp://0.0.0.0:4444"
; 指定哪个节点执行备份
donor="galera-3"
; 日志文件路径
log='/var/log/garbd.log'
; 备份节点上的备份脚本的后缀，对于下面的后缀，脚本名是wsrep_sst_backup_mysqldump
sst='backup_mysqldump'

下面是一个脚本的示例，它使用了bash + mysqldump，但是任何脚本语言、备份工具都是可以的： 

#!/bin/bash

# SET VARIABLES
db_user='admin_backup'
db_passwd='Rover123!'

backup_dir='/backup'
backup_sub_dir='temp'

today=`date +"%Y%m%d"`
# Dump文件路径
backup_today="galera-mysqldump-$today.sql"
# GTID文件路径
gtid_file="gtid-$today.dat"


# 加载此脚本，它提供GTID变量
. /usr/bin/wsrep_sst_common


# 备份配置文件
cp /etc/my.cnf $backup_dir/$backup_sub_dir/
cp /etc/garb.cnf $backup_dir/$backup_sub_dir/
# 备份GTID
echo "GTID: ${WSREP_SST_OPT_GTID}" > $backup_dir/$backup_sub_dir/$gtid_file


# 进行数据库Dump
mysqldump --user="$db_user" --password="$db_passwd" \
          --flush-logs --all-databases \
          > $backup_dir/$backup_sub_dir/$backup_today

# 打包
cd $backup_sub_dir
tar -czf $backup_dir/$backup_today.tgz * --transform "s,^,$backup_today/," 

将备份恢复到一个新集群，或者既有集群，可以使用相同的步骤：

1. 选择一个节点，作为恢复节点
2. 停止其它节点
3. 关闭恢复节点的Galera Replication，进入Standalone模式：
   

   SET GLOBAL wsrep_provider = 'none';
   
   SHOW STATUS LIKE 'wsrep_connected';
   
   +-----------------+-------+
    
   | Variable_name   | Value |
    
   +-----------------+-------+
    
   | wsrep_connected | OFF   |
    
   +-----------------+-------+

4. 调用备份工具，执行恢复
5. 在恢复节点上重新开启Galera Replication
6. 启动被停止的节点重新加入集群，并通过SST重新获得同步

用于存放writeset的特殊缓存，叫作writeset cache或GCache。GCache支持三种存储：

1. Permanent In-Memory Store：直接使用操作系统的内存，适合有很多空余内存的系统，默认情况是禁用的
2. Permanent Ring-Buffer File：在缓存初始化时就预先分配的一块磁盘空间，默认情况下，它的大小是 128Mb
3. On-Demand Page Store：根据需要在运行时动态分配内存映射页文件，默认情况下是 128Mb，但如果需要更大的 write-set，它可以动态的增长。当 page file 不再使用时，Galera Cluster 会删除这些文件，可以对 page file 的总大小进行限制

Galera Cluster 的缓存分配算法会按上面的顺序来分配缓存空间，gcache.dir 参数可以指定缓存保存在磁盘的位置。

Galera允许一个节点根据需要来暂停/恢复复制，这叫作Flow Control。FC可以节点在apply事务方面，过于落后其它节点。

我们知道，所有节点收到writeset并进行认证之后，原始的接收请求的节点就可以在本地完成提交并应答客户端了。此时，其它节点不一定也apply/commit了事务（取决于配置）。尚未apply/commit的事务（writeset）会存放在接收队列中。

如果某个节点速度缓慢，那么它的接收队列会不断积压，到达一定程度之后，就会触发FC：

1. 暂停复制
2. 处理接收队列的积压
3. 当队列到达可管理的大小之后，再恢复复制

在Galera中，需要去分单节点内的、集群范围的事务隔离级别。单节点内的事务隔离级别不必多提，参考MariaDB提供的配置项即可。

集群范围的事务隔离，受到复制协议的影响，不同节点上发起的事务，可能不会完全等同的隔离。

集群中能互相保持心跳通信的节点的集合叫作Component，两个Component之间存在网络分区，无法相互通信。理想情况下，集群只有一个Component。

大部分节点组成的Component叫作Primary Component —— PC必须满足大多数原则，在三节点集群中，至少两个节点才能组成PC。

只有位于PC中的节点，才能继续修改数据库状态。

Galera Cluster 会周期性的检查每个节点的连接是否正常， evs.inactive_check_peroid 参数可以设置检查的周期。如果一个节点的失效时间超过了 evs.suspect_timeout 的值，那么节点将被标记为 suspect。如果 Primary Component 中的所有节点都将某个节点标记为 suspect ，那么此节点被移出集群。

如果一个节点的失效时间超过了 evs.inactive_timeout 的值，此节点将直接被移出集群而不需要协商。故障的节点将不可读不可写。

在计算是否构成Primary Component / Quorum时，节点是可以被加权的。节点的权重通过pc.weight配置。例如下面的配置：

node1: pc.weight = 2
node2: pc.weight = 1
node3: pc.weight = 0

即使同时杀掉node2和node3，node1仍然构成PC 

提供者选项在系统变量 wsrep_provider_options 中配置，选项之间用;隔开。

Orange开发了一个Galera Operator，简化K8S中的Galera的部署和运维。支持的特性包括：

1. 创建、销毁集群
2. 集群规模括缩容
3. 垂直括缩：修改容器CPU/内存、持久卷大小
4. 节点崩溃后自动故障转移
5. 备份Galera集群到外部S3存储
6. 从外部备份恢复Galera集群

来自 severalnines / galera-docker-mariadb。此方案在K8S中运行Maria DB 10.1，支持Galera，需要同时运行一个Etcd集群。

逻辑比较乱，主要是通过查询Etcd来获得集群节点列表、各节点的seqno信息：

#!/bin/bash
set -e

# if command starts with an option, prepend mysqld
if [ "${1:0:1}" = '-' ]; then
  CMDARG="$@"
fi

[ -z "$TTL" ] && TTL=10

if [ -z "$CLUSTER_NAME" ]; then
  echo >&2 'Error:  You need to specify CLUSTER_NAME'
  exit 1
fi

DATADIR="$("mysqld" --verbose --help 2>/dev/null | awk '$1 == "datadir" { print $2; exit }')"
echo >&2 "Content of $DATADIR:"
ls -al $DATADIR

if [ ! -s "$DATADIR/grastate.dat" ]; then
  # 没有grastate.dat文件，意味着集群尚未初始化
  INITIALIZED=1
  if [ -z "$MYSQL_ROOT_PASSWORD" -a -z "$MYSQL_ALLOW_EMPTY_PASSWORD" -a -z "$MYSQL_RANDOM_ROOT_PASSWORD" ]; then
    echo >&2 'error: database is uninitialized and password option is not specified '
    echo >&2 '  You need to specify one of MYSQL_ROOT_PASSWORD, MYSQL_ALLOW_EMPTY_PASSWORD and MYSQL_RANDOM_ROOT_PASSWORD'
    exit 1
  fi
  mkdir -p "$DATADIR"
  chown -R mysql:mysql "$DATADIR"

  # 初始化MariaDB
  echo 'Running mysql_install_db'
  mysql_install_db --user=mysql --datadir="$DATADIR" --rpm
  echo 'Finished mysql_install_db'

  # 在后台启动MariaDB
  mysqld --user=mysql --datadir="$DATADIR" --skip-networking &
  pid="$!"

  mysql=(mysql --protocol=socket -uroot)

  # 等待MariaDB初始化完毕
  for i in {30..0}; do
    if echo 'SELECT 1' | "${mysql[@]}" &>/dev/null; then
      break
    fi
    echo 'MySQL init process in progress...'
    sleep 1
  done
  if [ "$i" = 0 ]; then
    echo >&2 'MySQL init process failed.'
    exit 1
  fi

  # sed is for https://bugs.mysql.com/bug.php?id=20545
  mysql_tzinfo_to_sql /usr/share/zoneinfo | sed 's/Local time zone must be set--see zic manual page/FCTY/' | "${mysql[@]}" mysql
  if [ ! -z "$MYSQL_RANDOM_ROOT_PASSWORD" ]; then
    MYSQL_ROOT_PASSWORD="$(pwmake 128)"
    echo "GENERATED ROOT PASSWORD: $MYSQL_ROOT_PASSWORD"
  fi

  # 在本地（禁止复制）创建root xtrabackup等用户
  "${mysql[@]}" <<-EOSQL
	  -- What's done in this file shouldn't be replicated
	  --  or products like mysql-fabric won't work
	  SET @@SESSION.SQL_LOG_BIN=0;
	  DELETE FROM mysql.user ;
	  CREATE USER 'root'@'%' IDENTIFIED BY '${MYSQL_ROOT_PASSWORD}' ;
	  GRANT ALL ON *.* TO 'root'@'%' WITH GRANT OPTION ;
	  CREATE USER 'xtrabackup'@'localhost' IDENTIFIED BY '$XTRABACKUP_PASSWORD';
	  GRANT RELOAD,LOCK TABLES,REPLICATION CLIENT ON *.* TO 'xtrabackup'@'localhost';
	  GRANT REPLICATION CLIENT ON *.* TO monitor@'%' IDENTIFIED BY 'monitor';
	  DROP DATABASE IF EXISTS test ;
	  FLUSH PRIVILEGES ;
EOSQL
  if [ ! -z "$MYSQL_ROOT_PASSWORD" ]; then
    mysql+=(-p"${MYSQL_ROOT_PASSWORD}")
  fi

  # 创建额外的数据库、用户
  if [ "$MYSQL_DATABASE" ]; then
    echo "CREATE DATABASE IF NOT EXISTS \`$MYSQL_DATABASE\` ;" | "${mysql[@]}"
    mysql+=("$MYSQL_DATABASE")
  fi

  if [ "$MYSQL_USER" -a "$MYSQL_PASSWORD" ]; then
    echo "CREATE USER '"$MYSQL_USER"'@'%' IDENTIFIED BY '"$MYSQL_PASSWORD"' ;" | "${mysql[@]}"

    if [ "$MYSQL_DATABASE" ]; then
      echo "GRANT ALL ON \`"$MYSQL_DATABASE"\`.* TO '"$MYSQL_USER"'@'%' ;" | "${mysql[@]}"
    fi

    echo 'FLUSH PRIVILEGES ;' | "${mysql[@]}"
  fi

  if [ ! -z "$MYSQL_ONETIME_PASSWORD" ]; then
    "${mysql[@]}" <<-EOSQL
		ALTER USER 'root'@'%' PASSWORD EXPIRE;
EOSQL
  fi
  if ! kill -s TERM "$pid" || ! wait "$pid"; then
    echo >&2 'MySQL init process failed.'
    exit 1
  fi

  echo
  echo 'MySQL init process done. Ready for start up.'
  echo
fi
chown -R mysql:mysql "$DATADIR"

function join {
  local IFS="$1"
  shift
  echo "$*"
}


# 将当前MariaDB实例加入到Galera集群，通过访问Etcd获取必要信息
if [ -z "$DISCOVERY_SERVICE" ]; then
  cluster_join=$CLUSTER_JOIN
else
  echo
  echo '>> Registering in the discovery service'

  etcd_hosts=$(echo $DISCOVERY_SERVICE | tr ',' ' ')
  flag=1

  echo
  # 寻找健康Etcd节点
  for i in $etcd_hosts; do
    echo ">> Connecting to https://${i}/health"
    curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key https://${i}/health || continue
    if curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key https://$i/health | jq -e 'contains({ "health": "true"})'; then
      healthy_etcd=$i
      flag=0
      break
    else
      echo >&2 ">> Node $i is unhealty. Proceed to the next node."
    fi
  done

  # 如果没有Etcd节点则放弃
  if [ $flag -ne 0 ]; then
    echo ">> Couldn't reach healthy etcd nodes."
    exit 1
  fi

  echo
  echo ">> Selected healthy etcd: $healthy_etcd"

  if [ ! -z "$healthy_etcd" ]; then
    URL="https://$healthy_etcd/v2/keys/galera/$CLUSTER_NAME"

    set +e
    echo >&2 ">> Waiting for $TTL seconds to read non-expired keys.."
    # 防止刚刚死去的Galera节点的注册信息仍然存在
    sleep $TTL

    # 获取活动Galera节点列表
    echo >&2 ">> Retrieving list of keys for $CLUSTER_NAME"
    addr=$(curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key $URL | jq -r '.node.nodes[]?.key' | awk -F'/' '{print $(NF)}')
    cluster_join=$(join , $addr)

    ipaddr=$(hostname -i | awk {'print $1'})
    [ -z $ipaddr ] && ipaddr=$(hostname -I | awk {'print $1'})

    echo
    if [ -z $cluster_join ]; then
      # 没有活动Galera节点。集群尚未初始化，或者集群完全宕机后重启（需要bootstrap）
      echo >&2 ">> KV store is empty. This is a the first node to come up."
      echo
      echo >&2 ">> Registering $ipaddr in https://$healthy_etcd"
      # 写入当前节点信息到Etcd
      curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key $URL/$ipaddr/ipaddress -X PUT -d "value=$ipaddr"
    else
      # 存在活动的Galera节点，看看有没有Synced的
      curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key ${URL}?recursive=true\&sorted=true >/tmp/out
      running_nodes=$(cat /tmp/out | jq -r '.node.nodes[].nodes[]? | select(.key | contains ("wsrep_local_state_comment")) | select(.value == "Synced") | .key' | awk -F'/' '{print $(NF-1)}' | tr "\n" ' ' | sed -e 's/[[:space:]]*$//')
      echo
      echo ">> Running nodes: [${running_nodes}]"

      if [ -z "$running_nodes" ]; then
        # 没有Synced节点，必须恢复本节点的seqno，如果本节点最大，则可以自举
        TMP=/var/lib/mysql/$(hostname).err
        echo >&2 ">> There is no node in synced state."
        echo >&2 ">> It's unsafe to bootstrap unless the sequence number is the latest."
        echo >&2 ">> Determining the Galera last committed seqno using --wsrep-recover.."
        echo

        # 恢复seqno
        mysqld_safe --wsrep-cluster-address=gcomm:// --wsrep-recover
        cat $TMP
        seqno=$(cat $TMP | tr ' ' "\n" | grep -e '[a-z0-9]*-[a-z0-9]*:[0-9]' | head -1 | cut -d ":" -f 2)
        # 此容器是新启动的，才会设置INITIALIZED。对于新节点，seqno设置为0
        if [ $INITIALIZED -eq 1 ]; then
          echo >&2 ">> This is a new container, thus setting seqno to 0."
          seqno=0
        fi

        echo
        if [ ! -z $seqno ]; then
          # 将当前节点的seqno写入到Etcd
          echo >&2 ">> Reporting seqno:$seqno to ${healthy_etcd}."
          WAIT=$(($TTL * 2))
          curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key $URL/$ipaddr/seqno -X PUT -d "value=$seqno&ttl=$WAIT"
        else
          seqno=$(cat $TMP | tr ' ' "\n" | grep -e '[a-z0-9]*-[a-z0-9]*:[0-9]' | head -1)
          echo >&2 ">> Unable to determine Galera sequence number."
          exit 1
        fi
        rm $TMP

        echo
        echo >&2 ">> Sleeping for $TTL seconds to wait for other nodes to report."
        sleep $TTL

        echo
        echo >&2 ">> Retrieving list of seqno for $CLUSTER_NAME"
        bootstrap_flag=1

        # Retrieve seqno from etcd
        curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key ${URL}?recursive=true\&sorted=true >/tmp/out
        cluster_seqno=$(cat /tmp/out | jq -r '.node.nodes[].nodes[]? | select(.key | contains ("seqno")) | .value' | tr "\n" ' ' | sed -e 's/[[:space:]]*$//')

        for i in $cluster_seqno; do
          if [ $i -gt $seqno ]; then
            # 如果存在其它节点的seqno更大，本节点不处理bootstrap
            bootstrap_flag=0
            echo >&2 ">> Found another node holding a greater seqno ($i/$seqno)"
          fi
        done

        echo
        if [ $bootstrap_flag -eq 1 ]; then
          # 本节点seqno最大，处理bootstrap
          # Find the earliest node to report if there is no higher seqno
          # node_to_bootstrap=$(cat /tmp/out | jq -c '.node.nodes[].nodes[]?' | grep seqno | tr ',:\"' ' ' | sort -k 11 | head -1 | awk -F'/' '{print $(NF-1)}')
          ## The earliest node to report if there is no higher seqno is computed wrongly: issue #6
          node_to_bootstrap=$(cat /tmp/out | jq -c '.node.nodes[].nodes[]?' | grep seqno | tr ',:"' ' ' | sort -k5,5r -k11 | head -1 | awk -F'/' '{print $(NF-1)}')
          if [ "$node_to_bootstrap" == "$ipaddr" ]; then
            echo >&2 ">> This node is safe to bootstrap."
            cluster_join=
          else
            echo >&2 ">> Based on timestamp, $node_to_bootstrap is the chosen node to bootstrap."
            echo >&2 ">> Wait again for $TTL seconds to look for a bootstrapped node."
            sleep $TTL
            curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key ${URL}?recursive=true\&sorted=true >/tmp/out

            # Look for a synced node again
            running_nodes2=$(cat /tmp/out | jq -r '.node.nodes[].nodes[]? | select(.key | contains ("wsrep_local_state_comment")) | select(.value == "Synced") | .key' | awk -F'/' '{print $(NF-1)}' | tr "\n" ' ' | sed -e 's/[[:space:]]*$//')

            echo
            echo >&2 ">> Running nodes: [${running_nodes2}]"

            if [ ! -z "$running_nodes2" ]; then
              cluster_join=$(join , $running_nodes2)
            else
              echo
              echo >&2 ">> Unable to find a bootstrapped node to join."
              echo >&2 ">> Exiting."
              exit 1
            fi
          fi
        else
          # seqno不是最大的，不处理bootstrap
          echo >&2 ">> Refusing to start for now because there is a node holding higher seqno."
          echo >&2 ">> Wait again for $TTL seconds to look for a bootstrapped node."
          sleep $TTL

          # Look for a synced node again
          curl -s -k --cacert /etc/etcd/ca.crt --cert /etc/etcd/client.crt --key /etc/etcd/client.key ${URL}?recursive=true\&sorted=true >/tmp/out
          running_nodes3=$(cat /tmp/out | jq -r '.node.nodes[].nodes[]? | select(.key | contains ("wsrep_local_state_comment")) | select(.value == "Synced") | .key' | awk -F'/' '{print $(NF-1)}' | tr "\n" ' ' | sed -e 's/[[:space:]]*$//')

          echo
          echo >&2 ">> Running nodes: [${running_nodes3}]"

          if [ ! -z "$running_nodes2" ]; then
            cluster_join=$(join , $running_nodes3)
          else
            echo
            echo >&2 ">> Unable to find a bootstrapped node to join."
            echo >&2 ">> Exiting."
            exit 1
          fi
        fi
      else
        # if there is a Synced node, join the address
        cluster_join=$(join , $running_nodes)
      fi
    fi
    set -e

    echo
    echo >&2 ">> Cluster address is gcomm://$cluster_join"
  else
    echo
    echo >&2 '>> No healthy etcd host detected. Refused to start.'
    exit 1
  fi
fi

echo
echo >&2 ">> Starting reporting script in the background"
nohup /report_status.sh root $MYSQL_ROOT_PASSWORD $CLUSTER_NAME $TTL $DISCOVERY_SERVICE &

# set IP address based on the primary interface
sed -i "s|WSREP_NODE_ADDRESS|$ipaddr|g" /etc/my.cnf

echo
echo >&2 ">> Starting mysqld process"
if [ -z $cluster_join ]; then
  export _WSREP_NEW_CLUSTER='--wsrep-new-cluster'
  # set safe_to_bootstrap = 1
  GRASTATE=$DATADIR/grastate.dat
  [ -f $GRASTATE ] && sed -i "s|safe_to_bootstrap.*|safe_to_bootstrap: 1|g" $GRASTATE
else
  export _WSREP_NEW_CLUSTER=''
fi

exec mysqld --wsrep_cluster_name=$CLUSTER_NAME --wsrep-cluster-address="gcomm://$cluster_join" --wsrep_sst_auth="xtrabackup:$XTRABACKUP_PASSWORD" $_WSREP_NEW_CLUSTER $CMDARG

该脚本会每TTL报告一次当前Galera容器的状态。

如果Galera集群名字为my_wsrep_cluster，则此方案会在Etcd中存储以下数据：

// url -s "http://192.168.55.111:2379/v2/keys/galera/my_wsrep_cluster?recursive=true"
{
    "action": "get",
    "node": {
        "createdIndex": 10049,
        "dir": true,
        "key": "/galera/my_wsrep_cluster",
        "modifiedIndex": 10049,
        "nodes": [
            {
                "createdIndex": 10067,
                "dir": true,
                // 每个节点在 /galera/$CLUSTER_NAME/下有个键
                "key": "/galera/my_wsrep_cluster/10.255.0.6",
                "modifiedIndex": 10067,
                "nodes": [
                    {
                        "createdIndex": 10075,
                        "expiration": "2016-11-29T10:55:35.37622336Z",
                        // 存储节点seqno
                        "key": "/galera/my_wsrep_cluster/10.255.0.6/wsrep_last_committed",
                        "modifiedIndex": 10075,
                        "ttl": 10,
                        "value": "0"
                    },
                    {
                        "createdIndex": 10073,
                        "expiration": "2016-11-29T10:55:34.788170259Z",
                        // 存储节点状态
                        "key": "/galera/my_wsrep_cluster/10.255.0.6/wsrep_local_state_comment",
                        "modifiedIndex": 10073,
                        "ttl": 10,
                        "value": "Synced"
                    }
                ]
            }...
        ]
    }
}

The post Galera学习笔记 appeared first on 绿色记忆.