MySQL 8.0.35 GTID + 延迟复制 + 过滤复制搭建

Mico182026-07-26 9:13

基于二进制包最小化安装，GTID 主从复制 + 延迟复制 + 过滤复制架构

  • 主库：192.168.195.141
  • 从库：192.168.195.142

1. 环境信息

项目 主库 (Master) 从库 (Slave)
IP 192.168.195.141 192.168.195.142
MySQL版本 8.0.35（二进制包，glibc2.17） 8.0.35（二进制包，glibc2.17）
server-id 1 2
gtid_mode ON ON
延迟复制 --- MASTER_DELAY=60
角色 Master Slave

2. 安装 MySQL（两台均执行）

2.1 创建用户与组

bash 复制代码 
groupadd mysql
useradd -g mysql mysql

2.2 解压二进制包

bash 复制代码 
cd /usr/local/
wget https://downloads.mysql.com/archives/get/p/23/file/mysql-8.0.35-linux-glibc2.17-x86_64.tar.xz
tar xvf mysql-8.0.35-linux-glibc2.17-x86_64.tar.xz
ln -s mysql-8.0.35-linux-glibc2.17-x86_64 mysql

验证：

bash 复制代码 
/usr/local/mysql/bin/mysql --version
# /usr/local/mysql/bin/mysql  Ver 8.0.35 for Linux on x86_64 (MySQL Community Server - GPL)

2.3 创建数据目录

bash 复制代码 
mkdir -p /data/mysql/3306/data
chown mysql.mysql /data/mysql/3306/data/

3. 编辑配置文件

3.1 主库 /etc/my.cnf（141）

ini 复制代码 
[client]
socket = /data/mysql/3306/data/mysql.sock
[mysqld]
basedir = /usr/local/mysql
datadir = /data/mysql/3306/data
user    = mysql
port    = 3306
socket  = /data/mysql/3306/data/mysql.sock
log_error = /data/mysql/3306/data/mysqld.err
log_timestamps = system
log-bin = mysql-bin
server-id = 1
gtid_mode = ON
enforce_gtid_consistency = ON

参数解释：

  • log-bin = mysql-bin：开启 binlog，主库必须开启。
  • server-id = 1：服务器唯一标识，主从环境中每个实例必须不同。
  • gtid_mode = ON：开启 GTID 复制。GTID（Global Transaction Identifier）为每个事务分配全局唯一ID，格式为 source_id:transaction_id。
  • enforce_gtid_consistency = ON：强制 GTID 一致性，只允许事务安全的语句执行。

3.2 从库 /etc/my.cnf（142）

ini 复制代码 
[client]
socket = /data/mysql/3306/data/mysql.sock
[mysqld]
basedir = /usr/local/mysql
datadir = /data/mysql/3306/data
user    = mysql
port    = 3306
socket  = /data/mysql/3306/data/mysql.sock
log_error = /data/mysql/3306/data/mysqld.err
log_timestamps = system
server-id = 2
gtid_mode = ON
enforce_gtid_consistency = ON

与主库的区别：

  • server-id = 2：从库的 server-id 必须与主库不同。
  • 从库不需要显式配置 log-bin，MySQL 8.0 默认开启 binlog。

4. 初始化实例（两台均执行）

bash 复制代码 
/usr/local/mysql/bin/mysqld --defaults-file=/etc/my.cnf --initialize

获取临时密码：

bash 复制代码 
grep "temporary password" /data/mysql/3306/data/mysqld.err

5. 配置 systemd 服务（两台均执行）

5.1 创建 /etc/systemd/system/mysqld.service

ini 复制代码 
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target

[Install]
WantedBy=multi-user.target

[Service]
User=mysql
Group=mysql
Type=forking
PIDFile=/data/mysql/3306/data/mysqld.pid
TimeoutSec=0
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/etc/my.cnf --pid-file=/data/mysql/3306/data/mysqld.pid --daemonize $MYSQLD_OPTS
EnvironmentFile=-/etc/sysconfig/mysql
LimitNOFILE = 65535
Restart=on-failure
RestartPreventExitStatus=1
PrivateTmp=false

5.2 创建 /etc/sysconfig/mysql

ini 复制代码 
MYSQLD_OPTS=

6. 启动实例（两台均执行）

bash 复制代码 
systemctl daemon-reload
systemctl start mysqld
systemctl enable mysqld

7. 修改 root 密码（两台均执行）

bash 复制代码 
/usr/local/mysql/bin/mysql -uroot -S /data/mysql/3306/data/mysql.sock -p
sql 复制代码 
alter user user() identified by 'Root@123456';

8. 搭建 GTID 主从复制

8.1 主库创建复制用户

sql 复制代码 
-- 在主库（141）执行
CREATE USER 'repl'@'%' IDENTIFIED BY '123456';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';

8.2 从库建立 GTID 复制

sql 复制代码 
-- 在从库（142）执行
CHANGE MASTER TO
MASTER_HOST='192.168.195.141',
MASTER_USER='repl',
MASTER_PASSWORD='123456',
MASTER_AUTO_POSITION=1,
GET_MASTER_PUBLIC_KEY=1;

START SLAVE;

参数解释：

  • MASTER_AUTO_POSITION=1：使用 GTID 自动定位，无需手动指定 binlog 文件和位置。
  • GET_MASTER_PUBLIC_KEY=1：MySQL 8.0 默认使用 caching_sha2_password 认证插件，非 SSL 连接时需获取主库公钥完成认证。

8.3 验证主从状态

sql 复制代码 
-- 在从库（142）执行
show slave status\G
复制代码 
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
        Seconds_Behind_Master: 0
                Auto_Position: 1

9. 延迟复制

9.1 什么是延迟复制

延迟复制是指从库的 SQL 线程在执行主库的事务时，故意延迟指定的时间。这样当主库发生误操作（如误删数据）时，从库还有一段时间的数据是正确的，可以用来恢复数据。

9.2 搭建延迟复制

方式一：搭建时设置

sql 复制代码 
-- 在从库（142）执行
CHANGE MASTER TO
MASTER_HOST='192.168.195.141',
MASTER_USER='repl',
MASTER_PASSWORD='123456',
MASTER_AUTO_POSITION=1,
GET_MASTER_PUBLIC_KEY=1,
MASTER_DELAY=60;

方式二：运行时设置（推荐，无需重建复制）

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE MASTER TO MASTER_DELAY = 60;
START SLAVE;

参数解释：

  • MASTER_DELAY = 60：设置从库延迟 60 秒执行主库的事务。单位为秒，常用值如 3600（1小时）、28800（8小时）等。

9.3 验证延迟复制

sql 复制代码 
-- 在从库（142）执行
show slave status\G
复制代码 
                    SQL_Delay: 60
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Replica has read all relay log; waiting for more updates

输出解释：

  • SQL_Delay: 60：期望延迟时间，即 CHANGE MASTER TO 语句中设置的 MASTER_DELAY 值。
  • SQL_Remaining_Delay: NULL：当前没有需要等待的事务。当有事务在等待延迟时，此值显示剩余等待秒数。
  • Slave_SQL_Running_State：当事务在等待延迟时，显示 Waiting until SOURCE_DELAY seconds after source executed event。

9.4 延迟效果测试

步骤1：主库写入数据

sql 复制代码 
-- 在主库（141）执行
CREATE DATABASE test_delay;
USE test_delay;
CREATE TABLE t1 (id INT PRIMARY KEY, name VARCHAR(20));
INSERT INTO t1 VALUES (1,'delay_test');
SELECT *, NOW() AS now_time FROM t1;
-- +----+------------+---------------------+
-- | id | name       | now_time            |
-- +----+------------+---------------------+
-- |  1 | delay_test | 2026-07-23 23:13:57 |
-- +----+------------+---------------------+

步骤2：立即在从库查询（DDL 不受延迟影响，DML 受延迟影响）

sql 复制代码 
-- 在从库（142）执行，立即查询
USE test_delay;
SHOW TABLES;
-- t1 表已存在（DDL 不受延迟影响）

SELECT * FROM t1;
-- Empty set（INSERT 还在等待 60 秒延迟）

步骤3：查看延迟状态

sql 复制代码 
-- 在从库（142）执行
show slave status\G
复制代码 
                    SQL_Delay: 60
          SQL_Remaining_Delay: 32
      Slave_SQL_Running_State: Waiting until SOURCE_DELAY seconds after source executed event

SQL_Remaining_Delay: 32 表示还有 32 秒才执行 INSERT 事务。

步骤4：等待 60 秒后查询

sql 复制代码 
-- 在从库（142）执行，等待约 60 秒后
SELECT * FROM test_delay.t1;
-- +----+------------+
-- | id | name       |
-- +----+------------+
-- |  1 | delay_test |
-- +----+------------+

数据在约 60 秒后同步到从库，延迟复制验证成功。

9.5 取消延迟复制

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE MASTER TO MASTER_DELAY = 0;
START SLAVE;

10. 过滤复制

10.1 什么是过滤复制

过滤复制允许从库选择性地复制主库的数据。可以指定只复制某些库/表，或忽略某些库/表，甚至将主库的某个库重写到从库的另一个库中。

10.2 过滤复制语法

sql 复制代码 
CHANGE REPLICATION FILTER filter[, filter] [, ...] [FOR CHANNEL channel]

filter: {
    REPLICATE_DO_DB = (db_list)
  | REPLICATE_IGNORE_DB = (db_list)
  | REPLICATE_DO_TABLE = (tbl_list)
  | REPLICATE_IGNORE_TABLE = (tbl_list)
  | REPLICATE_WILD_DO_TABLE = (wild_tbl_list)
  | REPLICATE_WILD_IGNORE_TABLE = (wild_tbl_list)
  | REPLICATE_REWRITE_DB = (db_pair_list)
}

注意：

  • 不指定 FOR CHANNEL，默认创建全局规则，对所有 Channel 生效。
  • 执行 CHANGE REPLICATION FILTER 后，对应的规则会写入参数文件。
  • 清除过滤规则：将对应规则设为空列表，如 CHANGE REPLICATION FILTER REPLICATE_DO_DB = ()。

10.3 准备测试数据

在主库创建多个测试库和表：

sql 复制代码 
-- 在主库（141）执行
CREATE DATABASE db_do;
CREATE DATABASE db_ignore;
CREATE DATABASE db_other;
CREATE DATABASE dbA;
CREATE DATABASE dbB;

USE db_do;
CREATE TABLE t1 (id INT PRIMARY KEY, name VARCHAR(20));
CREATE TABLE t2 (id INT PRIMARY KEY, name VARCHAR(20));
CREATE TABLE t_old1 (id INT PRIMARY KEY, name VARCHAR(20));
CREATE TABLE t_new1 (id INT PRIMARY KEY, name VARCHAR(20));
INSERT INTO t1 VALUES (1,'db_do_t1');
INSERT INTO t2 VALUES (2,'db_do_t2');
INSERT INTO t_old1 VALUES (3,'old_data');
INSERT INTO t_new1 VALUES (4,'new_data');

USE db_ignore;
CREATE TABLE t1 (id INT PRIMARY KEY, name VARCHAR(20));
INSERT INTO t1 VALUES (5,'db_ignore_t1');

USE db_other;
CREATE TABLE t1 (id INT PRIMARY KEY, name VARCHAR(20));
INSERT INTO t1 VALUES (6,'db_other_t1');

USE dbA;
CREATE TABLE t1 (id INT PRIMARY KEY, name VARCHAR(20));
INSERT INTO t1 VALUES (7,'dbA_t1');

10.4 REPLICATE_DO_DB --- 只复制指定库

含义： 只复制指定库的操作，其他库的操作被忽略。相当于 --replicate-do-db。

设置：

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER REPLICATE_DO_DB = (db_do);
START SLAVE;

验证：

sql 复制代码 
-- 查看过滤规则
show slave status\G
-- Replicate_Do_DB: db_do

在主库插入新数据：

sql 复制代码 
-- 在主库（141）执行
INSERT INTO db_do.t1 VALUES (100,'do_db_new');
INSERT INTO db_ignore.t1 VALUES (101,'ignore_db_new');
INSERT INTO db_other.t1 VALUES (102,'other_db_new');

在从库查询：

sql 复制代码 
-- 在从库（142）执行
SELECT * FROM db_do.t1 WHERE id=100;
-- +-----+------------+
-- | id  | name       |
-- +-----+------------+
-- | 100 | do_db_new  |    ✅ 已同步
-- +-----+------------+

SELECT * FROM db_ignore.t1 WHERE id=101;
-- Empty set                           ❌ 未同步（被过滤）

SELECT * FROM db_other.t1 WHERE id=102;
-- Empty set                           ❌ 未同步（被过滤）

结论： 只有 db_do 库的数据被复制，db_ignore 和 db_other 库的数据被过滤。

10.5 REPLICATE_IGNORE_DB --- 忽略指定库

含义： 忽略指定库的操作，其他库正常复制。相当于 --replicate-ignore-db。

设置：

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER REPLICATE_DO_DB = (), REPLICATE_IGNORE_DB = (db_ignore);
START SLAVE;

注意： 设置 IGNORE_DB 前需先清除 DO_DB（设为空列表），否则 DO_DB 优先级更高。

验证：

sql 复制代码 
-- 查看过滤规则
show slave status\G
-- Replicate_Ignore_DB: db_ignore

在主库插入新数据：

sql 复制代码 
-- 在主库（141）执行
INSERT INTO db_do.t1 VALUES (9999,'do_db_9999');
INSERT INTO db_ignore.t1 VALUES (9998,'ignore_db_9998');
INSERT INTO db_other.t1 VALUES (9997,'other_db_9997');

在从库查询：

sql 复制代码 
-- 在从库（142）执行
SELECT * FROM db_do.t1 WHERE id=9999;
-- +------+-------------+
-- | id   | name        |
-- +------+-------------+
-- | 9999 | do_db_9999  |    ✅ 已同步
-- +------+-------------+

SELECT * FROM db_ignore.t1 WHERE id=9998;
-- Empty set                           ❌ 未同步（被 IGNORE_DB 过滤）

SELECT * FROM db_other.t1 WHERE id=9997;
-- +------+---------------+
-- | id   | name          |
-- +------+---------------+
-- | 9997 | other_db_9997 |    ✅ 已同步
-- +------+---------------+

结论： db_ignore 库的数据被忽略，db_do 和 db_other 库的数据正常复制。

10.6 REPLICATE_DO_TABLE --- 只复制指定表

含义： 只复制指定表的操作，其他表的操作被忽略。相当于 --replicate-do-table。需要指定完整的表名（db_name.table_name）。

设置：

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER REPLICATE_IGNORE_DB = (), REPLICATE_DO_TABLE = (db_do.t1);
START SLAVE;

验证：

sql 复制代码 
-- 查看过滤规则
show slave status\G
-- Replicate_Do_Table: db_do.t1

在主库插入新数据：

sql 复制代码 
-- 在主库（141）执行
REPLACE INTO db_do.t1 VALUES (111111,'do_t1_111111');
REPLACE INTO db_do.t2 VALUES (222222,'do_t2_222222');

在从库查询：

sql 复制代码 
-- 在从库（142）执行
SELECT * FROM db_do.t1 WHERE id=111111;
-- +--------+----------------+
-- | id     | name           |
-- +--------+----------------+
-- | 111111 | do_t1_111111   |    ✅ 已同步（在 DO_TABLE 列表中）
-- +--------+----------------+

SELECT * FROM db_do.t2 WHERE id=222222;
-- Empty set                           ❌ 未同步（不在 DO_TABLE 列表中）

结论： 只有 db_do.t1 表的数据被复制，db_do.t2 表的数据被过滤。

10.7 REPLICATE_IGNORE_TABLE --- 忽略指定表

含义： 忽略指定表的操作，其他表正常复制。相当于 --replicate-ignore-table。

设置：

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER REPLICATE_DO_TABLE = (), REPLICATE_IGNORE_TABLE = (db_do.t2);
START SLAVE;

验证：

sql 复制代码 
-- 查看过滤规则
show slave status\G
-- Replicate_Ignore_Table: db_do.t2

在主库插入新数据：

sql 复制代码 
-- 在主库（141）执行
REPLACE INTO db_do.t1 VALUES (333333,'ignore_t1_333333');
REPLACE INTO db_do.t2 VALUES (444444,'ignore_t2_444444');

在从库查询：

sql 复制代码 
-- 在从库（142）执行
SELECT * FROM db_do.t1 WHERE id=333333;
-- +--------+-------------------+
-- | id     | name              |
-- +--------+-------------------+
-- | 333333 | ignore_t1_333333  |    ✅ 已同步
-- +--------+-------------------+

SELECT * FROM db_do.t2 WHERE id=444444;
-- Empty set                           ❌ 未同步（被 IGNORE_TABLE 过滤）

结论： db_do.t2 表的数据被忽略，db_do.t1 表的数据正常复制。

10.8 REPLICATE_WILD_DO_TABLE --- 通配符匹配复制指定表

含义： 复制匹配通配符模式的表的操作，支持 % 通配符。相当于 --replicate-wild-do-table。

设置：

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER REPLICATE_IGNORE_TABLE = (), REPLICATE_WILD_DO_TABLE = ('db_do.t_old%');
START SLAVE;

通配符说明： % 匹配任意字符序列。db_do.t_old% 匹配 db_do.t_old1、db_do.t_old2、db_do.t_old_data 等。

验证：

sql 复制代码 
-- 查看过滤规则
show slave status\G
-- Replicate_Wild_Do_Table: db_do.t_old%

在主库更新数据：

sql 复制代码 
-- 在主库（141）执行
REPLACE INTO db_do.t_old1 VALUES (3,'old_data_v2');
REPLACE INTO db_do.t_new1 VALUES (4,'new_data_v2');

在从库查询：

sql 复制代码 
-- 在从库（142）执行
SELECT * FROM db_do.t_old1 WHERE id=3;
-- +----+-------------+
-- | id | name        |
-- +----+-------------+
-- |  3 | old_data_v2 |    ✅ 已同步（匹配 db_do.t_old%）
-- +----+-------------+

SELECT * FROM db_do.t_new1 WHERE id=4;
-- +----+-----------+
-- | id | name      |
-- +----+-----------+
-- |  4 | new_data  |    ❌ 未更新（不匹配 db_do.t_old%）
-- +----+-----------+

结论： 只有匹配 db_do.t_old% 模式的表（如 t_old1）被复制，不匹配的表（如 t_new1）被过滤。

10.9 REPLICATE_WILD_IGNORE_TABLE --- 通配符忽略指定表

含义： 忽略匹配通配符模式的表的操作，支持 % 通配符。相当于 --replicate-wild-ignore-table。

设置：

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER REPLICATE_WILD_DO_TABLE = (), REPLICATE_WILD_IGNORE_TABLE = ('db_do.t_new%');
START SLAVE;

验证：

sql 复制代码 
-- 查看过滤规则
show slave status\G
-- Replicate_Wild_Ignore_Table: db_do.t_new%

在主库更新数据：

sql 复制代码 
-- 在主库（141）执行
REPLACE INTO db_do.t_old1 VALUES (3,'old_data_v3');
REPLACE INTO db_do.t_new1 VALUES (4,'new_data_v3');

在从库查询：

sql 复制代码 
-- 在从库（142）执行
SELECT * FROM db_do.t_old1 WHERE id=3;
-- +----+-------------+
-- | id | name        |
-- +----+-------------+
-- |  3 | old_data_v3 |    ✅ 已同步（不匹配 db_do.t_new%）
-- +----+-------------+

SELECT * FROM db_do.t_new1 WHERE id=4;
-- +----+-----------+
-- | id | name      |
-- +----+-----------+
-- |  4 | new_data  |    ❌ 未更新（匹配 db_do.t_new%，被忽略）
-- +----+-----------+

结论： 匹配 db_do.t_new% 模式的表（如 t_new1）被忽略，其他表正常复制。

10.10 REPLICATE_REWRITE_DB --- 库名重写

含义： 将主库 A 库的操作重写到从库 B 库中。相当于 --replicate-rewrite-db。格式为 ((from_db, to_db))。

设置：

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER REPLICATE_WILD_IGNORE_TABLE = (), REPLICATE_REWRITE_DB = ((dbA, dbB));
START SLAVE;

注意： REWRITE_DB 只重写 DML（INSERT/UPDATE/DELETE）中的库名，DDL（CREATE TABLE 等）也会被重写。从库需要确保目标库（dbB）和对应的表结构已存在。

验证：

sql 复制代码 
-- 查看过滤规则
show slave status\G
-- Replicate_Rewrite_DB: (dbA, dbB)

在主库 dbA 插入数据：

sql 复制代码 
-- 在主库（141）执行
INSERT INTO dbA.t1 VALUES (100001,'dbA_rewrite_100001');

在从库查询：

sql 复制代码 
-- 在从库（142）执行
SELECT * FROM dbB.t1;
-- +--------+------------------------+
-- | id     | name                   |
-- +--------+------------------------+
-- | 100001 | dbA_rewrite_100001     |    ✅ 主库 dbA 的数据重写到从库 dbB
-- +--------+------------------------+

SELECT * FROM dbA.t1;
-- +----+----------+
-- | id | name     |
-- +----+----------+
-- |  7 | dbA_t1   |    （只有旧数据，新数据被重写到 dbB）
-- +----+----------+

结论： 主库 dbA 的 DML 操作被重写到从库的 dbB 中，从库 dbA 中不会收到新数据。

10.11 清除所有过滤规则

sql 复制代码 
-- 在从库（142）执行
STOP SLAVE;
CHANGE REPLICATION FILTER
REPLICATE_DO_DB = (),
REPLICATE_IGNORE_DB = (),
REPLICATE_DO_TABLE = (),
REPLICATE_IGNORE_TABLE = (),
REPLICATE_WILD_DO_TABLE = (),
REPLICATE_WILD_IGNORE_TABLE = (),
REPLICATE_REWRITE_DB = ();
START SLAVE;

注意： 将对应规则设为空列表 () 即可清除该规则。清除后所有库/表恢复正常复制。

11. 过滤复制规则优先级

MySQL 过滤复制的检查顺序如下（从上到下，匹配即停止）：

  1. REPLICATE_DO_DB / REPLICATE_IGNORE_DB
  2. REPLICATE_DO_TABLE / REPLICATE_IGNORE_TABLE
  3. REPLICATE_WILD_DO_TABLE / REPLICATE_WILD_IGNORE_TABLE

重要规则：

  • DO 规则和 IGNORE 规则不要同时使用在同一级别（如同时设置 DO_DB 和 IGNORE_DB），否则行为可能不符合预期。
  • REPLICATE_REWRITE_DB 在 DO/IGNORE 规则之前执行，先将库名重写，然后再按重写后的库名进行过滤判断。
  • 设置新的过滤规则前，建议先清除旧的过滤规则（设为空列表），避免规则叠加。

12. 过滤复制规则汇总

规则 含义 示例
REPLICATE_DO_DB 只复制指定库 REPLICATE_DO_DB = (db1, db2)
REPLICATE_IGNORE_DB 忽略指定库 REPLICATE_IGNORE_DB = (db1)
REPLICATE_DO_TABLE 只复制指定表 REPLICATE_DO_TABLE = (db1.t1)
REPLICATE_IGNORE_TABLE 忽略指定表 REPLICATE_IGNORE_TABLE = (db1.t1)
REPLICATE_WILD_DO_TABLE 通配符复制指定表 REPLICATE_WILD_DO_TABLE = ('db1.old%')
REPLICATE_WILD_IGNORE_TABLE 通配符忽略指定表 REPLICATE_WILD_IGNORE_TABLE = ('db1.new%')
REPLICATE_REWRITE_DB 库名重写 REPLICATE_REWRITE_DB = ((dbA, dbB))

13. 连接信息

bash 复制代码 
# 主库（141）
/usr/local/mysql/bin/mysql -uroot -S /data/mysql/3306/data/mysql.sock -p'Root@123456'

# 从库（142）
/usr/local/mysql/bin/mysql -uroot -S /data/mysql/3306/data/mysql.sock -p'Root@123456'

14. 当前环境最终状态

14.1 主库配置文件 /etc/my.cnf（141）

ini 复制代码 
[client]
socket = /data/mysql/3306/data/mysql.sock
[mysqld]
basedir = /usr/local/mysql
datadir = /data/mysql/3306/data
user    = mysql
port    = 3306
socket  = /data/mysql/3306/data/mysql.sock
log_error = /data/mysql/3306/data/mysqld.err
log_timestamps = system
log-bin = mysql-bin
server-id = 1
gtid_mode = ON
enforce_gtid_consistency = ON

14.2 从库配置文件 /etc/my.cnf（142）

ini 复制代码 
[client]
socket = /data/mysql/3306/data/mysql.sock
[mysqld]
basedir = /usr/local/mysql
datadir = /data/mysql/3306/data
user    = mysql
port    = 3306
socket  = /data/mysql/3306/data/mysql.sock
log_error = /data/mysql/3306/data/mysqld.err
log_timestamps = system
server-id = 2
gtid_mode = ON
enforce_gtid_consistency = ON

14.3 从库复制状态

复制代码 
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
        Seconds_Behind_Master: 0
                    SQL_Delay: 60
                Auto_Position: 1
         Get_master_public_key: 1
相关推荐
瞬间&永恒~15 小时前
【MySQL】4-6:在同一个主机上使用 systemd 运行多个 MySQL服务器
服务器·数据库·mysql
一嘴一个橘子17 小时前
MysqL 哪些情况适合创建索引
mysql
时间的拾荒人17 小时前
MySQL C语言连接 - 从入门到实战
android·c语言·mysql
Database_Cool_19 小时前
云数据库控制台好不好用、能不能可视化操作：阿里云 RDS MySQL 控制台体验详解
数据库·mysql·阿里云
番茄炒鸡蛋加糖20 小时前
MySQL 实战调优& 分表基础
数据库·mysql
万亿少女的梦16820 小时前
基于Spring Boot的游戏交易管理系统设计与实现
java·spring boot·mysql·系统设计·交易管理
Database_Cool_20 小时前
云数据库如何保证高可用、故障了怎么办：阿里云 RDS MySQL 高可用架构详解
数据库·mysql·阿里云
Mem0rin21 小时前
[MySQL] 聚合函数、分组查询、连接查询
android·mysql
一棵星21 小时前
内网 MySQL 表结构一键导出 Word 文档：直连 + Agent 双模式实战
数据库·mysql·word
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02GitHub 镜像站点032026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片04AI科技热点日报 | 2026年07月01日05国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路07幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南082026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？09微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新102026 年 AI 大模型 & AI 编程工具实战全总结