MySQL 8.0大表迁移实战:我用这5个技巧实现了零停机(附完整代码)
去年我们团队接手了一个核心业务系统的数据库升级项目,需要将一个运行了五年的MySQL 5.7实例,迁移到全新的MySQL 8.0集群。这听起来像是一次常规升级,但当我们看到数据规模时,所有人都倒吸一口凉气:单表记录超过8000万条,总数据量接近2TB,而且业务要求7x24小时不间断服务,停机时间窗口为零。传统的mysqldump方案在测试环境就宣告失败,导出时间超过48小时,导入过程更是频繁超时。那段时间,我们几乎翻遍了所有技术文档,尝试了市面上能找到的每一种工具,最终摸索出一套组合拳,不仅平稳完成了迁移,整个过程对业务的影响几乎为零。今天,我就把这套经过实战检验的五个核心技巧,连同踩过的坑和完整的代码,毫无保留地分享给你。
1. 迁移前的战略评估与工具选型:别在起跑线上犯错
在动手写第一行迁移脚本之前,花在规划和评估上的时间,往往决定了整个项目的成败。面对千万级甚至亿级的大表,盲目选择工具等同于给自己挖坑。
首先,你需要一张清晰的“作战地图”。这张地图至少包含以下几个关键维度:
- 数据规模与增长趋势:不仅仅是当前的数据量,更要关注数据的日增/月增量。一个现在5000万记录的表,如果每月增长500万,你的迁移方案必须能应对这种动态变化。
- 表结构与访问模式:分析主键类型(自增整型、UUID、业务复合键)、索引数量、是否存在大字段(如
TEXT,BLOB)。同时,通过慢查询日志或性能模式(Performance Schema)了解表的读写比例、热点数据范围。 - 业务容忍度:明确回答,在迁移期间,允许的数据延迟是多少秒?可接受的读性能轻微下降比例是多少?这直接决定了你能否使用某些“最终一致性”的同步方案。
基于这份评估,工具选型就有了依据。下面这个表格对比了我们在实战中重点考察的几种方案:
| 工具/方案 | 核心原理 | 适用场景 | 大表迁移优势 | 潜在风险与注意事项 |
|---|---|---|---|---|
| MySQL原生复制 (Replication) | 基于Binlog的逻辑流复制 | 同版本或跨版本(5.7->8.0)主从搭建、迁移 | 原生支持,稳定性高,对源库压力相对分散。 | 初始全量同步(mysqldump)阶段对大表不友好;GTID模式在8.0下更稳定,但需提前规划。 |
| MyDumper/MyLoader | 多线程逻辑导出/导入 | 同构数据库的全量迁移,特别是大表 | 真正的并行导出/导入,速度远超单线程mysqldump。支持分块、压缩。 | 需要额外的网络和磁盘空间存放转储文件;导入时需注意外键约束,建议先禁用。 |
| 物理备份工具 (Percona XtraBackup) | 拷贝物理数据文件 | 需要最快恢复速度、数据量极大的场景 | 热备份,几乎不停机。备份恢复速度最快。 | 必须保证目标端与源端的MySQL版本、配置(如innodb_page_size)完全一致。跨大版本(如5.7到8.0)不推荐直接使用。 |
| 第三方CDC工具 (Debezium, Canal) | 解析Binlog的变更数据捕获 | 异构迁移、实时数据同步、双写过渡期 | 解耦应用与数据库,将数据变更作为事件流处理,非常灵活。 | 引入消息中间件(如Kafka),架构变复杂;需要处理DDL变更、网络抖动等问题。 |
提示:没有银弹。我们的策略是组合使用:用
MyDumper做高效的全量初始化,用基于GTID的原生复制或Debezium来追增量,形成一个“全量+增量”的完整流水线。
对于MySQL 5.7到8.0的迁移,版本兼容性是必须跨过的第一道坎。我们提前三个月就在测试环境进行了兼容性验证,重点关注以下几点:
- 默认字符集与排序规则:MySQL 8.0将默认字符集从
latin1改为了utf8mb4,默认排序规则从latin1_swedish_ci改为utf8mb4_0900_ai_ci。这可能导致索引失效或查询结果差异。 - 保留字与语法:8.0引入了新的保留字(如
GROUPING,JSON_TABLE),检查现有SQL和存储过程。 - 身份认证插件:8.0默认使用
caching_sha2_password,旧版客户端可能不支持,需要创建用户时指定mysql_native_password或升级客户端。
我们编写了一个简单的兼容性检查脚本,用于扫描潜在问题:
-- 检查可能受排序规则影响的索引
SELECT
TABLE_SCHEMA,
TABLE_NAME,
INDEX_NAME,
COLUMN_NAME,
COLLATION_NAME
FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = 'your_database'
AND COLLATION_NAME IS NOT NULL
AND COLLATION_NAME LIKE 'latin1%';
2. 技巧一:分而治之——大表拆解与并行导出导入
面对亿级大表,一次性操作就像试图一口吞下一头大象。分而治之是唯一可行的路径。我们的核心思路是:按主键范围将大表逻辑分片,利用多个线程并行处理每个分片。
MyDumper 正是为此而生。它不像mysqldump那样将整个数据库导成一个巨大的SQL文件,而是为每个表(甚至每个分片)生成独立的文件,极大提升了并行度。
实战操作:使用MyDumper进行智能分块导出
首先,安装MyDumper。在Ubuntu上可以直接使用apt安装,或者从GitHub编译最新版。
# Ubuntu/Debian 安装
sudo apt-get install -y mydumper
# 或者从源码编译(获取最新特性)
git clone https://github.com/mydumper/mydumper.git
cd mydumper
mkdir build
cd build
cmake ..
make
sudo make install
接下来是关键。假设我们要迁移一个名为order_history的表,它有8000万条记录,主键id是自增整型。直接导出可能仍然很慢,我们可以先探查数据边界,然后指导MyDumper分块。
# 1. 探查表的主键范围(在源数据库执行)
mysql -h source_host -u admin -p -e "SELECT MIN(id), MAX(id) FROM your_database.order_history;"
# 假设得到结果: min_id=1, max_id=80000000
# 2. 使用MyDumper,通过`--rows`和`--where`参数进行分块导出
# 我们计划分成8个块,每个块约1000万行。
for i in {0..7}; do
START=$((1 + i * 10000000))
END=$(( (i + 1) * 10000000 ))
# 注意:如果id不连续,END可能超过max_id,最后一块用独立的命令处理更稳妥
if [ $i -eq 7 ]; then
# 最后一块,不设上限
WHERE_CLAUSE="id >= $START"
else
WHERE_CLAUSE="id >= $START AND id < $END"
fi
mydumper \
--host=source_host \
--user=backup_user \
--password=your_password \
--database=your_database \
--tables-list=order_history \
--where="$WHERE_CLAUSE" \
--outputdir=/data/backup/chunk_$i \
--threads=4 \ # 每个分块导出进程使用4个线程
--compress \
--verbose=3 \
--no-locks \ # 谨慎使用,确保业务可接受短暂不一致
--long-query-guard=300 \
--success-on-1146 \
--trx-consistency-only &
done
wait # 等待所有后台进程完成
注意:
--no-locks参数会减少锁等待,加速导出,但可能无法获取完全一致的快照。对于交易型核心表,建议使用默认的FTWRL(全局读锁)或使用--trx-consistency-only(基于事务一致性),这需要源库是InnoDB引擎且事务隔离级别合适。
导出完成后,你会得到多个目录(chunk_0到chunk_7),每个里面都包含了order_history表一部分数据的.sql文件。接下来是并行导入。
并行导入与性能调优
使用MyLoader进行导入时,同样可以并行化。但直接导入多个分块文件到同一个目标表,可能会引发主键冲突。因此,更好的做法是在导入阶段就利用MyLoader的多线程能力,而不是简单地并行运行多个MyLoader实例。
# 将所有分块文件合并到一个目录(或指定多个目录)
# 假设我们将所有chunk_*下的文件都移动到了 /data/backup/full_backup
myloader \
--host=target_host \
--user=admin \
--password=target_password \
--database=your_database \
--directory=/data/backup/full_backup \
--threads=16 \ # 根据目标库IO和CPU能力调整,可以设置较高
--compress \
--overwrite-tables \
--verbose=3 \
--innodb-optimize-keys \ # 导入后优化索引,减少碎片
--enable-binlog=false & # 如果目标库是临时中转库,可关闭binlog加速
为了让导入速度最大化,我们必须在目标MySQL 8.0实例上做一些关键的参数调优,这些调整仅在导入期间生效,导入完成后应恢复为生产配置:
# 在目标数据库的my.cnf中[mysqld]下添加或调整
[mysqld]
# 1. 增大缓冲区,减少磁盘IO
innodb_buffer_pool_size = 64G # 建议设置为系统内存的70%-80%
innodb_log_file_size = 4G # 增大重做日志,减少checkpoint
innodb_log_buffer_size = 256M
# 2. 关闭双写缓冲,提升写入速度(仅用于数据导入阶段,有断电丢数据风险)
innodb_doublewrite = OFF
# 3. 调整刷页策略,偏向性能
innodb_flush_log_at_trx_commit = 2 # 每次事务提交只写日志缓冲区,每秒刷盘。风险是丢失最近1秒的事务。
innodb_flush_method = O_DIRECT # 避免操作系统缓存双重写入
# 4. 禁用唯一性和外键检查,导入完成后再恢复
innodb_checksum_algorithm = none # 导入时跳过校验(仅用于加速,需确保数据源可靠)
# 注意:unique_checks和foreign_key_checks是会话变量,在导入连接中设置,而非全局。
在导入会话中执行:
SET GLOBAL unique_checks=0;
SET GLOBAL foreign_key_checks=0;
-- 执行导入命令...
-- 导入完成后,务必恢复!
SET GLOBAL unique_checks=1;
SET GLOBAL foreign_key_checks=1;
3. 技巧二:无缝衔接——基于GTID与Binlog的增量同步追平
全量数据导入目标库后,源库的数据还在不断更新,两者之间存在一个“时间差”。我们的目标是在业务不停机的情况下,追平这个时间差,并让目标库实时同步源库的变更。MySQL的全局事务标识符(GTID) 是实现这一目标的利器。
GTID为每一个提交的事务分配一个全局唯一的ID,格式为server_uuid:transaction_id。使用GTID进行复制,可以轻松地实现故障转移和位置追踪,避免传统基于Binlog文件名和位置的复杂管理。
第一步:确保环境就绪
- 源库与目标库均启用GTID(MySQL 5.6及以上版本支持)。
-- 在源库和目标库的my.cnf中配置 [mysqld] gtid_mode=ON enforce_gtid_consistency=ON - 在目标库上,配置复制通道,指向源库。
第二步:建立复制关系并启动增量同步
在全量导入完成后,我们需要获取导入结束时源库的GTID位置,然后在目标库从这个点开始同步。
# 在全量导入开始前,记录源库的GTID位置(GTID1)
mysql -h source_host -u repl -p -e "SHOW MASTER STATUS\G" > /tmp/gtid_start.txt
# 在全量导入完成后,再次记录源库的GTID位置(GTID2)
mysql -h source_host -u repl -p -e "SHOW MASTER STATUS\G" > /tmp/gtid_end.txt
假设我们得到的GTID集合在导入期间从aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa:1-100增长到了aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa:1-1500。那么,我们需要让目标库从aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa:100之后开始同步。
在目标库上操作:
-- 1. 配置复制源
CHANGE MASTER TO
MASTER_HOST='source_host',
MASTER_USER='repl_user',
MASTER_PASSWORD='repl_password',
MASTER_PORT=3306,
MASTER_AUTO_POSITION=1; -- 关键!使用GTID自动定位
-- 2. 如果全量数据是通过非复制方式(如MyLoader)导入的,需要手动设置已执行的GTID集,
-- 告诉目标库:“这些事务我已经有了,不用再从源库拉取”。
-- 假设我们通过工具导入的数据,对应GTID集为 ‘aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa:1-100’
SET @@GLOBAL.gtid_purged='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa:1-100';
-- 3. 启动复制
START SLAVE;
-- 4. 检查复制状态
SHOW SLAVE STATUS\G
重点关注Slave_IO_Running和Slave_SQL_Running是否为Yes,以及Seconds_Behind_Master(延迟秒数)。这个值会逐渐减小,直到变为0,意味着目标库已经追平了源库。
注意:
gtid_purged的设置需要非常精确。如果设置错误(例如,包含了目标库实际上没有的事务),会导致复制中断。在生产环境中,建议先在一个从库上进行全量+增量的完整演练。
4. 技巧三:平滑切换——应用层双写与流量灰度切换
当目标库通过增量同步紧紧追随着源库,延迟稳定在秒级甚至毫秒级时,我们就来到了最关键的环节:切换流量。粗暴地更改数据库连接字符串会导致瞬间的请求失败。我们的策略是双写 + 读流量灰度。
第一步:应用层实现动态数据源与双写
我们基于Spring Boot框架,实现一个可动态路由的数据源。核心是利用AbstractRoutingDataSource和自定义注解。
首先,定义数据源配置和路由上下文:
@Configuration
public class DataSourceConfig {
@Bean
@ConfigurationProperties("spring.datasource.source")
public DataSourceProperties sourceDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@ConfigurationProperties("spring.datasource.target")
public DataSourceProperties targetDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@Primary
public DataSource routingDataSource() {
Map<Object, Object> targetDataSources = new HashMap<>();
targetDataSources.put(DbContextHolder.DbType.SOURCE, sourceDataSource());
targetDataSources.put(DbContextHolder.DbType.TARGET, targetDataSource());
DynamicRoutingDataSource routingDataSource = new DynamicRoutingDataSource();
routingDataSource.setDefaultTargetDataSource(sourceDataSource()); // 默认源库
routingDataSource.setTargetDataSources(targetDataSources);
routingDataSource.afterPropertiesSet();
return routingDataSource;
}
}
// 数据源上下文持有者,使用ThreadLocal保证线程安全
public class DbContextHolder {
private static final ThreadLocal<DbType> CONTEXT_HOLDER = new ThreadLocal<>();
public enum DbType {
SOURCE, TARGET
}
public static void setDbType(DbType dbType) {
CONTEXT_HOLDER.set(dbType);
}
public static DbType getDbType() {
return CONTEXT_HOLDER.get() == null ? DbType.SOURCE : CONTEXT_HOLDER.get(); // 默认源库
}
public static void clear() {
CONTEXT_HOLDER.remove();
}
}
// 自定义路由数据源
public class DynamicRoutingDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return DbContextHolder.getDbType();
}
}
然后,实现双写切面。我们为写操作(如@PostMapping, @PutMapping, @DeleteMapping标注的方法)添加一个自定义注解@DualWrite。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DualWrite {
}
@Aspect
@Component
@Slf4j
public class DualWriteAspect {
@Value("${dual-write.enabled:false}")
private boolean dualWriteEnabled;
@Around("@annotation(dualWrite)")
public Object doDualWrite(ProceedingJoinPoint joinPoint, DualWrite dualWrite) throws Throwable {
if (!dualWriteEnabled) {
// 双写未开启,直接走默认数据源(源库)
return joinPoint.proceed();
}
Object result = null;
Exception sourceException = null;
Exception targetException = null;
// 1. 写入源库(主写)
DbContextHolder.setDbType(DbContextHolder.DbType.SOURCE);
try {
result = joinPoint.proceed();
} catch (Exception e) {
sourceException = e;
log.error("写入源库失败", e);
throw e; // 源库写入失败,直接抛异常,事务回滚
} finally {
DbContextHolder.clear();
}
// 2. 异步写入目标库(从写)
if (result != null) {
CompletableFuture.runAsync(() -> {
DbContextHolder.setDbType(DbContextHolder.DbType.TARGET);
try {
joinPoint.proceed(); // 注意:这里重新执行原方法逻辑,需确保幂等性
log.debug("异步双写目标库成功");
} catch (Throwable e) {
targetException = e;
log.error("异步双写目标库失败,需记录日志并进入补偿队列", e);
// TODO: 将失败信息写入补偿表或消息队列,由后台任务重试
} finally {
DbContextHolder.clear();
}
});
}
return result;
}
}
在Service层使用:
@Service
public class OrderService {
@DualWrite
@Transactional(rollbackFor = Exception.class)
public Long createOrder(OrderCreateRequest request) {
// 业务逻辑...
return orderId;
}
}
第二步:读流量灰度切换
写流量通过双写保障了数据同步,读流量则可以更灵活地进行灰度。我们通过配置中心(如Nacos, Apollo)动态控制读请求的路由比例。
@Component
public class ReadRouteService {
@Value("${read.route.ratio:0}")
private int routeRatioToTarget; // 0-100,代表流量打到目标库的百分比
private final Random random = new Random();
public DbContextHolder.DbType decideReadDataSource() {
if (routeRatioToTarget <= 0) {
return DbContextHolder.DbType.SOURCE;
}
if (routeRatioToTarget >= 100) {
return DbContextHolder.DbType.TARGET;
}
int dice = random.nextInt(100);
return dice < routeRatioToTarget ? DbContextHolder.DbType.TARGET : DbContextHolder.DbType.SOURCE;
}
}
// 在查询操作的切面或拦截器中调用
@Around("@annotation(org.springframework.web.bind.annotation.GetMapping)")
public Object doReadRoute(ProceedingJoinPoint joinPoint) throws Throwable {
DbContextHolder.DbType dbType = readRouteService.decideReadDataSource();
DbContextHolder.setDbType(dbType);
try {
return joinPoint.proceed();
} finally {
DbContextHolder.clear();
}
}
切换流程:
- 开启双写:将
dual-write.enabled设为true。此时所有写操作会同时落盘到源库和目标库。 - 观察与校验:运行一段时间(例如30分钟),通过监控对比两个库的数据一致性、延迟和性能指标。
- 灰度读流量:将
read.route.ratio从0逐渐调大(如10%,30%,50%),观察目标库的负载和业务响应时间。 - 切读流量:当目标库读性能稳定后,将
read.route.ratio设为100%。此时所有读请求都转向目标库。 - 切写流量:在业务低峰期(如凌晨),短暂关闭双写(
dual-write.enabled=false),并将应用的默认数据源改为目标库。由于之前一直在双写,目标库数据是最新的,切换瞬间完成。 - 下线源库:观察一段时间(如24小时)后,确认目标库运行无误,即可下线源库。
5. 技巧四:质量守门员——自动化校验与回滚预案
再完美的方案也怕万一。在切换前后,必须有强有力的数据校验和可快速执行的回滚预案。
自动化校验脚本
我们编写了一个Python脚本,用于快速校验两个数据库的表记录数和关键字段的一致性。它使用SQLAlchemy进行连接,并通过多线程加速校验过程。
#!/usr/bin/env python3
import argparse
import threading
import queue
from datetime import datetime
import pymysql
from pymysql.cursors import DictCursor
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
class DatabaseChecker:
def __init__(self, source_config, target_config, thread_count=5):
self.source_conn = pymysql.connect(**source_config, cursorclass=DictCursor)
self.target_conn = pymysql.connect(**target_config, cursorclass=DictCursor)
self.thread_count = thread_count
self.result_queue = queue.Queue()
self.errors = []
def check_table_counts(self, database):
"""校验所有表的记录数"""
logger.info(f"开始校验数据库 [{database}] 的表记录数...")
with self.source_conn.cursor() as cursor:
cursor.execute(f"SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = %s", (database,))
tables = [row['TABLE_NAME'] for row in cursor.fetchall()]
work_queue = queue.Queue()
for table in tables:
work_queue.put(table)
def worker():
while not work_queue.empty():
try:
table = work_queue.get_nowait()
except queue.Empty:
break
try:
with self.source_conn.cursor() as cur:
cur.execute(f"SELECT COUNT(*) as cnt FROM `{database}`.`{table}`")
source_count = cur.fetchone()['cnt']
with self.target_conn.cursor() as cur:
cur.execute(f"SELECT COUNT(*) as cnt FROM `{database}`.`{table}`")
target_count = cur.fetchone()['cnt']
is_match = (source_count == target_count)
self.result_queue.put({
'table': table,
'source_count': source_count,
'target_count': target_count,
'match': is_match
})
if not is_match:
self.errors.append(f"表 [{table}] 记录数不匹配: 源={source_count}, 目标={target_count}")
except Exception as e:
logger.error(f"校验表 [{table}] 时发生错误: {e}")
self.errors.append(f"表 [{table}] 校验异常: {e}")
finally:
work_queue.task_done()
threads = []
for _ in range(min(self.thread_count, len(tables))):
t = threading.Thread(target=worker)
t.start()
threads.append(t)
for t in threads:
t.join()
# 打印结果
all_match = True
while not self.result_queue.empty():
res = self.result_queue.get()
status = "✓" if res['match'] else "✗"
logger.info(f"{status} {res['table']:30} 源: {res['source_count']:>12} | 目标: {res['target_count']:>12}")
if not res['match']:
all_match = False
return all_match
def close(self):
self.source_conn.close()
self.target_conn.close()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='MySQL数据库一致性校验工具')
parser.add_argument('--source', required=True, help='源数据库连接字符串,格式: user:pass@host:port/db')
parser.add_argument('--target', required=True, help='目标数据库连接字符串,格式: user:pass@host:port/db')
parser.add_argument('--threads', type=int, default=5, help='并发线程数')
args = parser.parse_args()
# 解析连接字符串(这里简化,实际应用可用更健壮的解析)
def parse_conn(conn_str):
# 简单解析示例,实际应处理更复杂的情况
user_pass, host_port_db = conn_str.split('@')
user, password = user_pass.split(':')
host_port, database = host_port_db.split('/')
host, port = host_port.split(':') if ':' in host_port else (host_port, '3306')
return {
'host': host,
'port': int(port),
'user': user,
'password': password,
'database': database
}
source_config = parse_conn(args.source)
target_config = parse_conn(args.target)
# 连接时先不指定database,因为要跨库查询information_schema
db_for_check = source_config.pop('database')
source_config['database'] = None
target_config['database'] = None
checker = DatabaseChecker(source_config, target_config, args.threads)
try:
success = checker.check_table_counts(db_for_check)
if success and not checker.errors:
logger.info("所有表记录数校验通过!")
else:
logger.error("校验未通过!")
for err in checker.errors:
logger.error(err)
exit(1)
finally:
checker.close()
回滚预案:不仅仅是技术,更是流程
回滚不是耻辱,而是专业性的体现。我们的预案文档包括:
- 触发条件:明确在什么情况下必须回滚(例如,目标库P95延迟持续超过500ms、核心接口错误率>1%、数据校验发现无法修复的不一致)。
- RTO(恢复时间目标):要求必须在5分钟内将读写流量全部切回源库。
- 具体步骤:
- 立即将配置中心的
read.route.ratio设为0,dual-write.enabled设为false。 - 验证应用日志,确认所有流量已回切至源库。
- 停止目标库的复制链路(
STOP SLAVE;)。 - 通知所有相关团队(业务、运维、监控)。
- 立即将配置中心的
- 数据修复:如果切换期间发生了双写失败导致的数据差异,预案中应包含基于Binlog或备份的数据订正脚本,并经过预演。
6. 技巧五:性能与稳定性的深度调优
迁移过程中和迁移后,对MySQL 8.0的性能调优是巩固战果的关键。以下是一些针对大表迁移场景的调优经验。
索引重建优化
使用MyLoader导入数据时,虽然可以边导入边建索引(--innodb-optimize-keys),但对于超大表,先导入数据,后集中创建索引往往更快。因为InnoDB的索引是聚簇的,按主键顺序导入数据本身效率就高。导入完成后,使用ALTER TABLE ... ALGORITHM=INPLACE在线创建二级索引。
-- 示例:为一个订单历史表添加联合索引
ALTER TABLE order_history ADD INDEX idx_user_date (user_id, create_date), ALGORITHM=INPLACE, LOCK=NONE;
注意:
ALGORITHM=INPLACE和LOCK=NONE可以减少锁表时间,但并非所有DDL操作都支持,需查阅官方文档。
InnoDB缓冲池预热
迁移后,目标库的缓冲池是冷的,热点数据不在内存中,会导致初期查询性能骤降。我们可以通过innodb_buffer_pool_dump_at_shutdown和innodb_buffer_pool_load_at_startup让MySQL在关闭时保存缓冲池状态,启动时加载。对于在线迁移,可以在业务低峰期,通过查询INFORMATION_SCHEMA.INNODB_BUFFER_PAGE来主动预热。
-- 查询当前缓冲池中的页(生产环境慎用,数据量大)
SELECT TABLE_NAME, INDEX_NAME, COUNT(*) AS page_count
FROM INFORMATION_SCHEMA.INNODB_BUFFER_PAGE
WHERE TABLE_NAME IS NOT NULL
GROUP BY TABLE_NAME, INDEX_NAME
ORDER BY page_count DESC
LIMIT 10;
-- 更实用的预热方式是,在低峰期跑一遍核心报表或缓存关键查询
SELECT /*+ MAX_EXECUTION_TIME(3600000) */ COUNT(*) FROM order_history WHERE create_date > '2023-01-01';
利用MySQL 8.0的新特性
- 不可见索引(Invisible Indexes):在切换前,可以在目标库创建与源库相同的索引,但设为不可见。切换完成后,再将其设为可见,避免在数据追赶阶段索引维护带来的额外开销。
CREATE INDEX idx_temp ON large_table(column) INVISIBLE; -- 切换后 ALTER TABLE large_table ALTER INDEX idx_temp VISIBLE; - 资源组(Resource Groups):可以为数据校验、备份等后台任务分配独立的CPU资源组,避免其与在线业务争抢资源,影响前端响应。
CREATE RESOURCE GROUP batch_group TYPE=USER VCPU=5-6 THREAD_PRIORITY=10; SET RESOURCE GROUP batch_group FOR CURRENT_THREAD; -- 执行校验脚本...
监控与告警 迁移不是一锤子买卖。切换完成后,需要建立对新集群的立体化监控:
- 数据库基础指标:QPS、TPS、连接数、缓冲池命中率、慢查询数量、复制延迟(如果还有从库)。
- 操作系统指标:CPU使用率、内存使用率、磁盘IOPS和吞吐量、网络流量。
- 业务指标:核心接口的响应时间、错误率。通过对比迁移前后的APM(应用性能监控)数据,量化迁移带来的影响。
整个迁移过程,就像一场精心策划的军事行动,侦察(评估)、武器选择(工具)、分兵推进(分片)、实时通信(同步)、切换阵地(流量切换)和战后扫荡(校验回滚)环环相扣。这套方法不仅适用于MySQL 8.0升级,对于任何需要零停机迁移的大型数据存储系统,其核心思想——并行化、增量同步、应用层灰度切换、自动化验证——都是相通的。最深的体会是,再复杂的架构问题,拆解成一个个可验证、可回滚的小步骤后,风险都是可控的。
174



被折叠的 条评论
为什么被折叠?



