1. WAL产生
– 主库执行事务修改
– 生成WAL日志记录
– WAL写入WAL缓冲区

2. WAL发送
– WAL发送进程（WAL Sender）读取WAL
– 通过网络发送给备库
– 支持同步和异步发送

3. WAL接收
– 备库WAL接收进程（WAL Receiver）接收WAL
– 写入备库WAL文件
– 通知主库接收状态

4. WAL应用
– 备库启动恢复进程（Startup Process）
– 读取WAL并重放修改
– 更新备库数据文件

流复制流程图：
主库 备库
+——–+ WAL日志 +——–+
| 事务执行 | —————> | WAL接收 |
+——–+ +——–+
| |
v v
+——–+ +——–+
| WAL生成 | | WAL写入 |
+——–+ +——–+
| |
v v
+——–+ 网络传输 +——–+
|WAL Sender| ————–> |WAL Receiver|
+——–+ +——–+
| |
v v
+——–+ +——–+
| 等待确认 | <-------------- | 发送状态 | +--------+ +--------+ | v +--------+ | WAL应用 | +--------+ 复制模式： - 异步复制：主库不等待备库确认 - 同步复制：主库等待备库确认（remote_write/remote_flush/remote_apply）

1. 强一致性（Strong Consistency）
– 定义：主备数据实时一致
– 实现：synchronous_commit = remote_apply
– 特点：性能最低，一致性最高
– 适用：金融核心系统

2. 会话一致性（Session Consistency）
– 定义：同一会话的写操作立即可见
– 实现：应用层实现会话绑定
– 特点：用户体验好，实现复杂
– 适用：用户交互系统

3. 最终一致性（Eventual Consistency）
– 定义：数据最终会一致，允许短暂延迟
– 实现：异步复制
– 特点：性能最好，一致性较弱
– 适用：内容系统、日志系统

4. 单调读一致性（Monotonic Read Consistency）
– 定义：不会读到旧版本的数据
– 实现：读操作固定到同一备库
– 特点：避免时间倒流问题
– 适用：订单查询等场景

一致性级别对比：
级别 | 延迟 | 一致性 | 适用场景
——————|——|——–|———-
强一致性 | 高 | 最高 | 金融核心
会话一致性 | 中 | 高 | 用户系统
最终一致性 | 低 | 中 | 内容系统
单调读一致性 | 低 | 中 | 查询系统

1. WAL文件大小
– 默认大小：16MB
– 修改参数：wal_segment_size（编译时确定）
– 建议：保持默认值，除非有特殊需求

2. WAL保留策略
– 本地保留：wal_keep_size
– 归档保留：archive_command配置的目录
– 复制槽保留：复制槽关联的WAL风哥提示：

3. WAL清理策略
– 检查点清理：checkpoint完成后清理
– 复制槽限制：复制槽阻止WAL清理
– 手动清理：pg_archivecleanup

4. WAL监控指标
– WAL生成速率
– WAL积压数量
– WAL清理速率
– 复制延迟

# 生产环境建议
wal_keep_size = 4GB # 至少保留4GB WAL
max_wal_size = 8GB # 最大WAL大小
min_wal_size = 2GB # 最小WAL大小
archive_mode = on # 开启归档
wal_compression = on # 开启WAL压缩

1. 复制槽类型
– 物理复制槽：用于流复制
– 逻辑复制槽：用于逻辑复制

2. 复制槽作用学习交流加群风哥微信: itpux-com
– 防止WAL被过早清理
– 记录备库接收位置
– 支持断点续传

3. 复制槽管理命令
# 创建复制槽
SELECT pg_create_physical_replication_slot(‘slot_name’);

# 查看复制槽
SELECT * FROM pg_replication_slots;

# 删除复制槽
SELECT pg_drop_replication_slot(‘slot_name’);

4. 复制槽监控
# 查看复制槽状态
SELECT
slot_name,
plugin,
slot_type,
database,
active,
restart_lsn,
confirmed_flush_lsn
FROM pg_replication_slots;

# 查看复制槽保留的WAL
SELECT
slot_name,
pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)) as retained_wal
FROM pg_replication_slots;

5. 复制槽问题处理
# 复制槽导致WAL积压
# 原因：备库长时间断开，复制槽阻止WAL清理
# 解决：删除无用的复制槽或恢复备库

# 查找长时间未使用的复制槽
SELECT
slot_name,学习交流加群风哥QQ113257174
active,
pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) as retained_bytes
FROM pg_replication_slots
WHERE NOT active
AND pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) > 1073741824; — 超过1GB

1. 同步复制策略
# 最高级别一致性
synchronous_commit = remote_apply
synchronous_standby_names = ‘fgedu_standby1’

# 平衡性能和一致性
synchronous_commit = remote_flush
synchronous_standby_names = ‘fgedu_standby1’

2. 延迟检测策略
# 检测复制延迟
SELECT
application_name,
EXTRACT(EPOCH FROM (now() – pg_last_xact_replay_timestamp())) as delay_seconds
FROM pg_stat_replication;

# 延迟超过阈值告警
# 延迟超过10秒触发告警

3. 数据校验策略
# 定期数据校验
# 使用pg_dump校验关键表
# 使用checksum校验数据文件

4. 切换验证策略
# 切换前验证数据一致性
# 切换后验证应用连接
# 回滚方案准备更多视频教程www.fgedu.net.cn

# 一致性保障检查清单
□ 复制延迟在可接受范围
□ 复制槽状态正常
□ WAL积压不严重
□ 备库数据一致性验证通过
□ 切换脚本测试通过

# 步骤1：基础WAL配置
$ cat >> /opengauss/fgdata/postgresql.conf << EOF # WAL基本配置 wal_level = replica wal_sync_method = fdatasync wal_compression = on wal_log_hints = on # WAL文件配置 max_wal_size = 8GB min_wal_size = 2GB wal_keep_size = 4GB # WAL写入配置 wal_buffers = 64MB wal_writer_delay = 10ms wal_writer_flush_after = 1MB # 检查点配置 checkpoint_timeout = 15min checkpoint_completion_target = 0.9更多学习教程公众号风哥教程itpux_com max_checkpoint_flush_threads = 4 EOF # 步骤2：复制相关配置 $ cat >> /opengauss/fgdata/postgresql.conf << EOF # 复制配置 max_wal_senders = 10 max_replication_slots = 10 wal_sender_timeout = 60s wal_sender_buffer_size = 16MB # 热备配置 hot_standby = on max_standby_archive_delay = 30s max_standby_streaming_delay = 30s EOF # 步骤3：重启数据库 $ gs_ctl restart -D /opengauss/fgdata # 步骤4：验证配置 $ gsql -d postgres -c "SHOW wal_level;
”
wal_level
———–
replica
(1 row)

$ gsql -d postgres -c “SHOW max_wal_size;
”
max_wal_sizefrom DB视频:www.itpux.com
————–
8GB
(1 row)

$ gsql -d postgres -c “SHOW wal_keep_size;
”
wal_keep_size
—————
4GB
(1 row)

#!/bin/bash
# replication_monitor.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: `http://www.fgedu.net.cn`

MASTER_IP=”192.168.1.10″
LOG_FILE=”/opengauss/log/replication_monitor.log”
ALERT_DELAY=10 # 延迟告警阈值10秒

log() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” | tee -a $LOG_FILE
}

# 检查复制状态
check_replication() {
log “=== 复制状态检查 ===”

# 检查复制连接
gsql -h $MASTER_IP -d postgres -c ”
SELECT
application_name,
client_addr,
state,
sync_state,
sent_lsn,
replay_lsn,
pg_wal_lsn_diff(sent_lsn, replay_lsn) as delay_bytes
FROM pg_stat_replication;
” >> $LOG_FILE

# 检查复制延迟
gsql -h $MASTER_IP -d postgres -c ”
SELECT
application_name,
EXTRACT(EPOCH FROM (now() – pg_last_xact_replay_timestamp())) as delay_seconds
FROM pg_stat_replication
WHERE EXTRACT(EPOCH FROM (now() – pg_last_xact_replay_timestamp())) > $ALERT_DELAY;
” | while read line; do
if [ -n “$line” ]; then
log “告警: 复制延迟超过阈值 – $line”
# 发送告警通知
# echo “复制延迟告警: $line” | mail -s “复制延迟告警” dba@fgedu.net.cn
fi
done
}

# 检查复制槽
check_slots() {
log “=== 复制槽检查 ===”

# 检查复制槽保留的WAL大小
gsql -h $MASTER_IP -d postgres -c ”
SELECT
slot_name,
active,
pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)) as retained_wal
FROM pg_replication_slots
WHERE pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) > 1073741824; — 超过1GB
” | while read line; do
if [ -n “$line” ]; then
log “告警: 复制槽WAL积压 – $line”
fi
done
}

# 检查WAL生成速率
check_wal_rate() {
log “=== WAL生成速率检查 ===”

# 计算WAL生成速率
gsql -h $MASTER_IP -d postgres -c ”
SELECT
pg_size_pretty(
(SELECT COUNT(*) * 16777216
FROM pg_ls_waldir()
WHERE modification > now() – interval ‘1 hour’)
/ 3600
) || ‘/s’ as wal_rate_per_second;
” >> $LOG_FILE
}

# 主逻辑
main() {
log “========== 复制监控开始 ==========”
check_replication
check_slots
check_wal_rate
log “========== 复制监控结束 ==========”
}

main

# 执行结果
[2026-04-09 20:00:00] ========== 复制监控开始 ==========
[2026-04-09 20:00:00] === 复制状态检查 ===
[2026-04-09 20:00:01] === 复制槽检查 ===
[2026-04-09 20:00:02] === WAL生成速率检查 ===
[2026-04-09 20:00:03] ========== 复制监控结束 ==========

#!/bin/bash
# consistency_check.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: `http://www.fgedu.net.cn`

MASTER_IP=”192.168.1.10″
STANDBY_IP=”192.168.1.11″
LOG_FILE=”/opengauss/log/consistency_check.log”

log() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” | tee -a $LOG_FILE
}

# 检查LSN一致性
check_lsn_consistency() {
log “=== LSN一致性检查 ===”

# 获取主库LSN
MASTER_LSN=$(gsql -h $MASTER_IP -d postgres -t -c “SELECT pg_current_wal_lsn();
” | tr -d ‘ ‘)
log “主库当前LSN: $MASTER_LSN”

# 获取备库接收LSN
STANDBY_RECEIVE_LSN=$(gsql -h $STANDBY_IP -d postgres -t -c “SELECT pg_last_wal_receive_lsn();
” | tr -d ‘ ‘)
log “备库接收LSN: $STANDBY_RECEIVE_LSN”

# 获取备库应用LSN
STANDBY_REPLAY_LSN=$(gsql -h $STANDBY_IP -d postgres -t -c “SELECT pg_last_xact_replay_lsn();
” | tr -d ‘ ‘)
log “备库应用LSN: $STANDBY_REPLAY_LSN”

# 计算延迟
DELAY=$(gsql -h $MASTER_IP -d postgres -t -c ”
SELECT pg_wal_lsn_diff(‘$MASTER_LSN’, ‘$STANDBY_REPLAY_LSN’);
” | tr -d ‘ ‘)
log “主备LSN差异: $DELAY bytes”

if [ “$DELAY” -lt 1024 ]; then
log “LSN一致性检查通过”
else
log “警告: LSN差异较大，请检查复制状态”
fi
}

# 检查数据一致性（抽样检查）
check_data_consistency() {
log “=== 数据一致性检查 ===”

# 检查关键表记录数
TABLES=”fgedu.users fgedu.orders fgedu.products”

for table in $TABLES; do
MASTER_COUNT=$(gsql -h $MASTER_IP -d fgedudb -t -c “SELECT count(*) FROM $table;
” | tr -d ‘ ‘)
STANDBY_COUNT=$(gsql -h $STANDBY_IP -d fgedudb -t -c “SELECT count(*) FROM $table;
” | tr -d ‘ ‘)

log “表 $table: 主库=$MASTER_COUNT, 备库=$STANDBY_COUNT”

if [ “$MASTER_COUNT” -eq “$STANDBY_COUNT” ]; then
log “表 $table 记录数一致”
else
log “警告: 表 $table 记录数不一致”
fi
done
}

# 检查复制延迟
check_replication_delay() {
log “=== 复制延迟检查 ===”

gsql -h $MASTER_IP -d postgres -c ”
SELECT
application_name,
client_addr,
EXTRACT(EPOCH FROM (now() – pg_last_xact_replay_timestamp())) as delay_seconds,
pg_wal_lsn_diff(sent_lsn, replay_lsn) as delay_bytes
FROM pg_stat_replication;
” >> $LOG_FILE
}

# 主逻辑
main() {
log “========== 一致性检查开始 ==========”
check_lsn_consistency
check_data_consistency
check_replication_delay
log “========== 一致性检查结束 ==========”
}

main

# 执行结果
[2026-04-09 21:00:00] ========== 一致性检查开始 ==========
[2026-04-09 21:00:00] === LSN一致性检查 ===
[2026-04-09 21:00:01] 主库当前LSN: 0/5001234
[2026-04-09 21:00:02] 备库接收LSN: 0/5001234
[2026-04-09 21:00:03] 备库应用LSN: 0/5001234
[2026-04-09 21:00:04] 主备LSN差异: 0 bytes
[2026-04-09 21:00:05] LSN一致性检查通过
[2026-04-09 21:00:06] === 数据一致性检查 ===
[2026-04-09 21:00:07] 表 fgedu.users: 主库=100000, 备库=100000
[2026-04-09 21:00:08] 表 fgedu.users 记录数一致
[2026-04-09 21:00:09] 表 fgedu.orders: 主库=500000, 备库=500000
[2026-04-09 21:00:10] 表 fgedu.orders 记录数一致
[2026-04-09 21:00:11] 表 fgedu.products: 主库=10000, 备库=10000
[2026-04-09 21:00:12] 表 fgedu.products 记录数一致
[2026-04-09 21:00:13] === 复制延迟检查 ===
[2026-04-09 21:00:14] ========== 一致性检查结束 ==========

# 问题分析
1. 网络延迟高：异地网络延迟50ms
2. 带宽不足：复制带宽仅10Mbps
3. WAL生成量大：高峰期WAL生成速率100MB/s
4. 备库性能差：备库硬件配置低于主库

# 优化措施

# 1. 网络优化
# 增加带宽到100Mbps
# 启用WAL压缩减少传输量
$ cat >> /opengauss/fgdata/postgresql.conf << EOF wal_compression = on wal_sender_buffer_size = 32MB EOF # 2. 主库优化 # 调整WAL生成速率 $ cat >> /opengauss/fgdata/postgresql.conf << EOF wal_writer_delay = 20ms wal_writer_flush_after = 2MB EOF # 3. 备库优化 # 提升备库硬件配置 # 优化备库恢复参数 $ cat >> /opengauss/fgdata/postgresql.conf << EOF hot_standby = on max_standby_archive_delay = 60s max_standby_streaming_delay = 60s # 恢复进程优化 max_recovery_parallelism = 8 EOF # 4. 复制参数优化 # 调整复制超时和重试参数 $ cat >> /opengauss/fgdata/postgresql.conf << EOF wal_receiver_status_interval = 5s wal_receiver_timeout = 120s wal_retrieve_retry_interval = 5s EOF # 5. 重启数据库 $ gs_ctl restart -D /opengauss/fgdata # 优化效果 # 优化前：复制延迟10-30秒 # 优化后：复制延迟2-5秒 # 优化效果：延迟降低70% # 监控脚本 #!/bin/bash # check_delay_optimization.sh # from:www.itpux.com.qq113257174.wx:itpux-com # web: `http://www.fgedu.net.cn` MASTER_IP="192.168.1.10" echo "=== 复制延迟优化效果检查 ===" echo "检查时间: $(date)" gsql -h $MASTER_IP -d postgres -c " SELECT application_name, client_addr, EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())) as delay_seconds, pg_size_pretty(pg_wal_lsn_diff(sent_lsn, replay_lsn)) as delay_size FROM pg_stat_replication ORDER BY delay_seconds DESC; " # 执行结果 === 复制延迟优化效果检查 === 检查时间: Thu Apr 9 22:00:00 CST 2026 application_name | client_addr | delay_seconds | delay_size ------------------+---------------+---------------+------------ fgedu_standby1 | 192.168.1.11 | 0.50 | 128 kB fgedu_standby2 | 192.168.1.12 | 0.80 | 256 kB fgedu_dr | 192.168.2.10 | 2.50 | 2 MB (3 rows)

#!/bin/bash
# consistency_verification.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: `http://www.fgedu.net.cn`

NEW_MASTER_IP=”192.168.1.11″
LOG_FILE=”/opengauss/log/consistency_verification.log”

log() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” | tee -a $LOG_FILE
}

# 验证LSN
verify_lsn() {
log “=== LSN验证 ===”

LSN=$(gsql -h $NEW_MASTER_IP -d postgres -t -c “SELECT pg_current_wal_lsn();
” | tr -d ‘ ‘)
log “新主库LSN: $LSN”

# LSN应该在合理范围
log “LSN验证通过”
}

# 验证关键表数据
verify_tables() {
log “=== 关键表数据验证 ===”

# 定义关键表
declare -A TABLES
TABLES[“fgedu.users”]=100000
TABLES[“fgedu.orders”]=500000
TABLES[“fgedu.products”]=10000

for table in “${!TABLES[@]}”; do
EXPECTED=${TABLES[$table]}
ACTUAL=$(gsql -h $NEW_MASTER_IP -d fgedudb -t -c “SELECT count(*) FROM $table;
” | tr -d ‘ ‘)

log “表 $table: 期望=$EXPECTED, 实际=$ACTUAL”

if [ “$ACTUAL” -ge “$EXPECTED” ]; then
log “表 $table 验证通过”
else
log “警告: 表 $table 数据量异常”
fi
done
}

# 验证应用连接
verify_connections() {
log “=== 应用连接验证 ===”

# 检查活跃连接
gsql -h $NEW_MASTER_IP -d postgres -c ”
SELECT
datname,
count(*) as connections
FROM pg_stat_activity
WHERE state = ‘active’
GROUP BY datname;
” >> $LOG_FILE

log “应用连接验证完成”
}

# 主逻辑
main() {
log “========== 一致性验证开始 ==========”
verify_lsn
verify_tables
verify_connections
log “========== 一致性验证结束 ==========”
}

main

# 执行结果
[2026-04-09 23:00:00] ========== 一致性验证开始 ==========
[2026-04-09 23:00:00] === LSN验证 ===
[2026-04-09 23:00:01] 新主库LSN: 0/6001234
[2026-04-09 23:00:02] LSN验证通过
[2026-04-09 23:00:03] === 关键表数据验证 ===
[2026-04-09 23:00:04] 表 fgedu.users: 期望=100000, 实际=100000
[2026-04-09 23:00:05] 表 fgedu.users 验证通过
[2026-04-09 23:00:06] 表 fgedu.orders: 期望=500000, 实际=500000
[2026-04-09 23:00:07] 表 fgedu.orders 验证通过
[2026-04-09 23:00:08] 表 fgedu.products: 期望=10000, 实际=10000
[2026-04-09 23:00:09] 表 fgedu.products 验证通过
[2026-04-09 23:00:10] === 应用连接验证 ===
[2026-04-09 23:00:11] 应用连接验证完成
[2026-04-09 23:00:12] ========== 一致性验证结束 ==========

#!/bin/bash
# slot_cleanup.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: `http://www.fgedu.net.cn`

MASTER_IP=”192.168.1.10″
LOG_FILE=”/opengauss/log/slot_cleanup.log”

log() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” | tee -a $LOG_FILE
}

# 检查复制槽状态
check_slots() {
log “=== 复制槽状态检查 ===”

gsql -h $MASTER_IP -d postgres -c ”
SELECT
slot_name,
plugin,
slot_type,
database,
active,
restart_lsn,
pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)) as retained_wal
FROM pg_replication_slots
ORDER BY pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) DESC;
” >> $LOG_FILE
}

# 清理无效复制槽
cleanup_inactive_slots() {
log “=== 清理无效复制槽 ===”

# 查找非活跃且WAL积压超过1GB的复制槽
gsql -h $MASTER_IP -d postgres -t -c ”
SELECT slot_name
FROM pg_replication_slots
WHERE NOT active
AND pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) > 1073741824;
” | while read slot_name; do
if [ -n “$slot_name” ]; then
log “删除复制槽: $slot_name”
gsql -h $MASTER_IP -d postgres -c “SELECT pg_drop_replication_slot(‘$slot_name’);
”
log “复制槽 $slot_name 已删除”
fi
done
}

# 检查WAL目录大小
check_wal_size() {
log “=== WAL目录大小检查 ===”

WAL_SIZE=$(du -sh /opengauss/fgdata/pg_wal | awk ‘{print $1}’)
log “WAL目录大小: $WAL_SIZE”

# 如果超过10GB，触发清理
WAL_SIZE_BYTES=$(du -sb /opengauss/fgdata/pg_wal | awk ‘{print $1}’)
if [ “$WAL_SIZE_BYTES” -gt 10737418240 ]; then
log “警告: WAL目录超过10GB，需要清理”
# 触发检查点加速WAL清理
gsql -h $MASTER_IP -d postgres -c “CHECKPOINT;”
log “已触发检查点”
fi
}

# 主逻辑
main() {
log “========== 复制槽清理开始 ==========”
check_slots
cleanup_inactive_slots
check_wal_size
log “========== 复制槽清理结束 ==========”
}

main

# 执行结果
[2026-04-09 23:30:00] ========== 复制槽清理开始 ==========
[2026-04-09 23:30:00] === 复制槽状态检查 ===
[2026-04-09 23:30:01] === 清理无效复制槽 ===
[2026-04-09 23:30:02] 删除复制槽: fgedu_old_slot
[2026-04-09 23:30:03] 复制槽 fgedu_old_slot 已删除
[2026-04-09 23:30:04] === WAL目录大小检查 ===
[2026-04-09 23:30:05] WAL目录大小: 8.5G
[2026-04-09 23:30:06] ========== 复制槽清理结束 ==========

# 日常检查项
□ 复制延迟是否在可接受范围
□ 复制槽状态是否正常
□ WAL积压是否严重
□ 网络连接是否正常
□ 备库状态是否正常

# 定期检查项
□ 主备数据一致性
□ 复制性能指标
□ WAL生成速率
□ 复制槽使用情况
□ 磁盘空间使用

# 告警阈值设置
– 复制延迟：>10秒告警
– WAL积压：>1GB告警
– 复制中断：立即告警
– 磁盘空间：>80%告警
– 网络延迟：>100ms告警