1. RPO（恢复点目标）
– 定义：灾难发生后，系统可以恢复到的最近时间点
– 含义：允许丢失的数据量
– 示例：RPO=1小时表示最多丢失1小时的数据

2. RTO（恢复时间目标）
– 定义：灾难发生后，系统恢复到可用状态所需的时间
– 含义：业务中断的最大允许时间
– 示例：RTO=30分钟表示30分钟内必须恢复服务

3. 容灾等级划分

等级 | RPO | RTO | 架构 | 适用场景
—–|———-|———–|——————-|———-
1级 | <1小时 | <24小时 | 异地备份 | 一般业务 2级 | <15分钟 | <4小时 | 异地异步复制 | 重要业务 3级 | <1分钟 | <1小时 | 异地同步复制 | 关键业务 4级 | 0 | <30分钟 | 同城双活 | 核心业务 5级 | 0 | <5分钟 | 两地三中心 | 金融核心 6级 | 0 | 0 | 异地多活 | 最高要求 4. openGauss容灾能力 - 异步复制：RPO取决于复制延迟，RTO<30分钟 - 同步复制：RPO=0，RTO<30分钟 - 双活架构：RPO=0，RTO<5分钟

架构拓扑：
+——————+
| 生产中心A |
| 192.168.1.0/24 |
| (同城主中心) |
+——–+———+
|
+——————-+——————-+
| |
+——–v———+ +——–v———+
| 主库 | | 备库1 |
| fgedu-primary |<------------------>| fgedu-standby1 |
| 192.168.1.10 | 同步复制 | 192.168.1.11 |
| | (同城双活) | |
+——————+ +——–+———+
|
| 异步复制
|
+——–v———+
| 备库2 |
| fgedu-standby2 |
| 192.168.2.10 |
| (异地灾备) |
+——————+

容灾等级：5级（两地三中心）
RPO：0（同步复制）
RTO：<10分钟 # 架构说明 1. 同城双活：主库和备库1在同一城市，使用同步复制 2. 异地灾备：备库2在异地，使用异步复制 3. 故障切换： - 主库故障：切换到备库1（同城） - 同城灾难：切换到备库2（异地）

架构拓扑：
+——————+ +——————+
| 数据中心A | | 数据中心B |
| 192.168.1.0/24 |<------------------>| 192.168.2.0/24 |
| (同城双活) | 专线网络 | (同城双活) |
+——–+———+ 延迟<5ms +--------+---------+ | | +--------v---------+ +--------v---------+ | 主库 | | 备库 | | fgedu-primary |<------------------>| fgedu-standby |
| 192.168.1.10 | 同步复制 | 192.168.2.10 |
| | remote_apply | |
+——————+ +——————+
^ ^
| |
+—————-+———————-+
|风哥提示：
+——-v——–+
| 应用层 |
| (读写分离) |
+—————-+

架构特点：
1. 两个数据中心同时对外提供服务
2. 写操作集中到主库
3. 读操作分散到两个中心
4. 同步复制保证数据一致性
5. 故障时自动切换到另一中心

1. 同城网络配置
– 带宽：万兆以太网或更高
– 延迟：<5ms - 专线：建议部署专用复制网络 - 冗余：双链路冗余，避免单点故障 2. 异地网络配置 - 带宽：根据数据量计算，建议>100Mbps
– 延迟：通常20-100ms
– 专线：运营商专线或VPN
– 压缩：启用网络压缩减少带宽占用

3. 网络参数优化学习交流加群风哥微信: itpux-com
# 操作系统网络参数
net.core.rmem_max = 134217728
net.core.wmem_max = 134217728
net.ipv4.tcp_rmem = 4096 87380 134217728
net.ipv4.tcp_wmem = 4096 65536 134217728
net.ipv4.tcp_congestion_control = bbr

4. 防火墙配置
# 开放复制端口
firewall-cmd –permanent –add-rich-rule=’rule family=”ipv4″ source address=”192.168.2.0/24″ port protocol=”tcp” port=”5432″ accept’
firewall-cmd –reload

# 步骤1：主库配置（生产中心）
$ cat >> /opengauss/fgdata/postgresql.conf << EOF # WAL配置 wal_level = replica max_wal_senders = 10 wal_keep_size = 8GB max_replication_slots = 10 # 异步复制配置 synchronous_commit = local # 网络优化 wal_sender_timeout = 120s wal_receiver_timeout = 120s wal_retrieve_retry_interval = 10s # 压缩配置（异地建议开启）学习交流加群风哥QQ113257174 wal_compression = on EOF # 步骤2：配置pg_hba.conf $ cat >> /opengauss/fgdata/pg_hba.conf << EOF # 异地备库访问权限 host replication repl 192.168.2.10/32 md5 host all all 192.168.2.0/24 md5 EOF # 步骤3：创建复制用户和复制槽 $ gsql -d postgres -c "CREATE USER repl WITH REPLICATION PASSWORD 'repl_pass';
”
$ gsql -d postgres -c “SELECT pg_create_physical_replication_slot(‘fgedu_dr_slot’);
”

# 步骤4：重启主库
$ gs_ctl restart -D /opengauss/fgdata

# 步骤5：异地备库配置
# 备份主库数据
$ gs_probackup backup -B /opengauss/backup –instance=fgedudb -b FULL –remote-host=192.168.1.10 –remote-user=opengauss

# 恢复数据到异地备库
$ gs_probackup restore -B /opengauss/backup –instance=fgedudb -D /opengauss/fgdata

# 配置standby.signal
$ cat > /opengauss/fgdata/standby.signal << EOF primary_conninfo = 'host=192.168.1.10 port=5432 user=repl password=repl_pass application_name=fgedu_dr' primary_slot_name = 'fgedu_dr_slot' recovery_target_timeline = 'latest' EOF # 步骤6：配置异地备库参数 $ cat >> /opengauss/fgdata/postgresql.conf << EOF hot_standby = on wal_receiver_status_interval = 10s wal_receiver_timeout = 120s wal_retrieve_retry_interval = 10s EOF # 步骤7：启动异地备库更多视频教程www.fgedu.net.cn $ gs_ctl start -D /opengauss/fgdata # 步骤8：验证复制状态 $ gsql -h 192.168.1.10 -d postgres -c "SELECT application_name, client_addr, state, sync_state FROM pg_stat_replication;
”

application_name | client_addr | state | sync_state
——————+—————+———–+————
fgedu_dr | 192.168.2.10 | streaming | async
(1 row)

# 步骤1：创建切换脚本
$ cat > /opengauss/scripts/dr_switchover.sh << 'EOF' #!/bin/bash # dr_switchover.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.2.10" LOG_FILE="/opengauss/log/dr_switchover.log" # 日志函数 log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE } # 检查主库状态 check_master() { log "检查主库状态..." pg_isready -h $MASTER_IP -p 5432 if [ $? -ne 0 ]; then log "主库无法连接" return 1更多学习教程公众号风哥教程itpux_com fi return 0 } # 检查备库状态 check_standby() { log "检查备库状态..." pg_isready -h $STANDBY_IP -p 5432 if [ $? -ne 0 ]; then log "备库无法连接" return 1 fi return 0 } # 执行切换 perform_switchover() { log "开始执行容灾切换..." # 1. 停止主库（如果是故障切换，主库可能已经停止） log "停止主库..." gs_ctl stop -D /opengauss/fgdata -m fast || true # 2. 提升备库为主库 log "提升备库为主库..." gs_ctl promote -D /opengauss/fgdata # 3. 验证新主库 log "验证新主库状态..." sleep 5from DB视频:www.itpux.com gsql -h $STANDBY_IP -d postgres -c "SELECT pg_is_in_recovery();
”

if [ $? -eq 0 ]; then
log “容灾切换成功，新主库: $STANDBY_IP”
# 发送通知
# echo “容灾切换成功” | mail -s “容灾切换通知” dba@fgedu.net.cn
else
log “容灾切换失败”
return 1
fi
}

# 主逻辑
main() {
log “========== 容灾切换脚本启动 ==========”

# 检查备库状态
if ! check_standby; then
log “备库状态异常，无法执行切换”
exit 1
fi

# 检查主库状态
if check_master; then
log “主库正常，执行计划内切换”
# 计划内切换逻辑
gsql -h $MASTER_IP -d postgres -c “SELECT pg_switch_wal();
”
sleep 10
else
log “主库故障，执行故障切换”
fi

# 执行切换
perform_switchover

log “========== 容灾切换脚本结束 ==========”
}

main
EOF

chmod +x /opengauss/scripts/dr_switchover.sh

# 步骤2：测试切换脚本
$ /opengauss/scripts/dr_switchover.sh

[2026-04-09 16:00:00] ========== 容灾切换脚本启动 ==========
[2026-04-09 16:00:00] 检查备库状态…
[2026-04-09 16:00:01] 主库无法连接
[2026-04-09 16:00:01] 主库故障，执行故障切换
[2026-04-09 16:00:01] 开始执行容灾切换…
[2026-04-09 16:00:01] 停止主库…
[2026-04-09 16:00:05] 提升备库为主库…
[2026-04-09 16:00:06] 验证新主库状态…
[2026-04-09 16:00:11] 容灾切换成功，新主库: 192.168.2.10
[2026-04-09 16:00:11] ========== 容灾切换脚本结束 ==========

# 架构：两个数据中心同时提供服务
# 数据中心A：主库（处理写操作）
# 数据中心B：备库（处理读操作）

# 步骤1：主库配置（数据中心A）
$ cat >> /opengauss/fgdata/postgresql.conf << EOF # 同步复制配置（同城使用同步复制） synchronous_commit = remote_apply synchronous_standby_names = 'fgedu_standby_b' # WAL配置 wal_level = replica max_wal_senders = 10 wal_keep_size = 4GB max_replication_slots = 10 EOF # 步骤2：备库配置（数据中心B） $ cat > /opengauss/fgdata/standby.signal << EOF primary_conninfo = 'host=192.168.1.10 port=5432 user=repl password=repl_pass application_name=fgedu_standby_b' primary_slot_name = 'fgedu_standby_b_slot' recovery_target_timeline = 'latest' EOF # 步骤3：应用层读写分离配置 # 写操作连接主库（数据中心A） # 读操作连接备库（数据中心B） # 步骤4：负载均衡配置 # 使用DNS轮询或负载均衡器将读请求分发到两个中心 # 步骤5：监控配置 #!/bin/bash # check_multi_active.sh # from:www.itpux.com.qq113257174.wx:itpux-com # web: `http://www.fgedu.net.cn` echo "=== 同城双活状态检查 ===" # 检查主库 echo "--- 主库状态（数据中心A） ---" gsql -h 192.168.1.10 -d postgres -c "SELECT inet_server_addr(), pg_is_in_recovery();
”

# 检查备库
echo “— 备库状态（数据中心B） —”
gsql -h 192.168.2.10 -d postgres -c “SELECT inet_server_addr(), pg_is_in_recovery();
”

# 检查复制状态
echo “— 复制状态 —”
gsql -h 192.168.1.10 -d postgres -c ”
SELECT
application_name,
client_addr,
state,
sync_state,
pg_wal_lsn_diff(sent_lsn, replay_lsn) as delay_bytes
FROM pg_stat_replication;
”

# 执行结果
=== 同城双活状态检查 ===
— 主库状态（数据中心A） —
inet_server_addr | pg_is_in_recovery
——————+——————-
192.168.1.10 | f
(1 row)

— 备库状态（数据中心B） —
inet_server_addr | pg_is_in_recovery
——————+——————-
192.168.2.10 | t
(1 row)

— 复制状态 —
application_name | client_addr | state | sync_state | delay_bytes
——————+—————+———–+————+————-
fgedu_standby_b | 192.168.2.10 | streaming | sync | 0
(1 row)

生产中心（同城）：
– 主库：fgedu-primary 192.168.1.10 64核256GB
– 备库：fgedu-standby1 192.168.1.11 64核256GB
– 复制模式：同步复制（remote_apply）
– 距离：<10公里 - 延迟：<1ms 异地灾备中心： - 备库：fgedu-standby2 192.168.2.10 32核128GB - 复制模式：异步复制 - 距离：>100公里
– 延迟：20-50ms

容灾等级：5级
RPO：0
RTO：<10分钟 # 部署配置 # 1. 主库配置 wal_level = replica max_wal_senders = 15 wal_keep_size = 16GB max_replication_slots = 15 # 同城同步复制 synchronous_commit = remote_apply synchronous_standby_names = 'fgedu_standby1' # 2. 同城备库配置 # 与主库同步复制 # 3. 异地备库配置 # 与主库异步复制 # 4. 监控脚本 #!/bin/bash # check_two_center_three_site.sh # from:www.itpux.com.qq113257174.wx:itpux-com # web: `http://www.fgedu.net.cn` echo "=== 两地三中心状态监控 ===" echo "检查时间: $(date)" # 检查同城复制 echo "--- 同城复制状态 ---" gsql -h 192.168.1.10 -d postgres -c " SELECT application_name, client_addr, sync_state, pg_wal_lsn_diff(sent_lsn, replay_lsn) as delay_bytes FROM pg_stat_replication WHERE client_addr IN ('192.168.1.11', '192.168.2.10'); " # 检查异地复制延迟 echo "--- 异地复制延迟 ---" gsql -h 192.168.1.10 -d postgres -c " SELECT application_name, EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())) as delay_seconds FROM pg_stat_replication WHERE client_addr = '192.168.2.10'; " # 执行结果 === 两地三中心状态监控 === 检查时间: Thu Apr 9 17:00:00 CST 2026 --- 同城复制状态 --- application_name | client_addr | sync_state | delay_bytes ------------------+---------------+------------+------------- fgedu_standby1 | 192.168.1.11 | sync | 0 fgedu_standby2 | 192.168.2.10 | async | 2048 (2 rows) --- 异地复制延迟 --- application_name | delay_seconds ------------------+--------------- fgedu_standby2 | 2.50 (1 row)

数据中心A：
– 主库：fgedu-primary 192.168.1.10 32核128GB
– 角色：处理写操作，部分读操作

数据中心B：
– 备库：fgedu-standby 192.168.2.10 32核128GB
– 角色：处理读操作

网络：
– 专线连接，延迟<5ms - 带宽：万兆以太网 应用层： - 写操作：连接主库 - 读操作：连接备库 - 使用ShardingSphere实现读写分离 # 性能提升 - 读性能提升：约80%（读操作分散到两个中心） - 可用性提升：单数据中心故障时自动切换 - 用户体验：就近访问，延迟降低 # 部署验证 # 1. 写入测试（主库） $ gsql -h 192.168.1.10 -d fgedudb -c " INSERT INTO fgedu.orders (order_id, user_id, amount, create_time) VALUES (10001, 'fgedu01', 999.99, now()); " INSERT 0 1 # 2. 读取测试（备库） $ gsql -h 192.168.2.10 -d fgedudb -c " SELECT * FROM fgedu.orders WHERE order_id = 10001;
”

order_id | user_id | amount | create_time
———-+———-+——–+—————————-
10001 | fgedu01 | 999.99 | 2026-04-09 17:30:00.123456
(1 row)

# 3. 复制延迟检查
$ gsql -h 192.168.1.10 -d postgres -c ”
SELECT
application_name,
pg_wal_lsn_diff(sent_lsn, replay_lsn) as delay_bytes
FROM pg_stat_replication;
”

application_name | delay_bytes
——————+————-
fgedu_standby | 0
(1 row)

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

MASTER_IP=”192.168.1.10″
STANDBY1_IP=”192.168.1.11″
STANDBY2_IP=”192.168.2.10″

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

# 步骤1：演练前检查
pre_check() {
log “========== 容灾演练开始 ==========”
log “步骤1：演练前检查”

# 检查主库
pg_isready -h $MASTER_IP -p 5432
if [ $? -ne 0 ]; then
log “主库异常，停止演练”
exit 1
fi
log “主库正常”

# 检查备库
pg_isready -h $STANDBY1_IP -p 5432
if [ $? -ne 0 ]; then
log “同城备库异常，停止演练”
exit 1
fi
log “同城备库正常”

pg_isready -h $STANDBY2_IP -p 5432
if [ $? -ne 0 ]; then
log “异地备库异常，停止演练”
exit 1
fi
log “异地备库正常”

# 记录当前数据状态
log “记录当前数据状态…”
gsql -h $MASTER_IP -d fgedudb -c “SELECT count(*) as total_orders FROM fgedu.orders;
”
}

# 步骤2：模拟主库故障
simulate_failure() {
log “步骤2：模拟主库故障”
log “停止主库…”
gs_ctl stop -D /opengauss/fgdata -m immediate
log “主库已停止”
}

# 步骤3：执行同城切换
perform_switchover() {
log “步骤3：执行同城切换”
START_TIME=$(date +%s)

# 提升同城备库为主库
gs_ctl promote -D /opengauss/fgdata

# 等待切换完成
sleep 5

# 验证新主库
gsql -h $STANDBY1_IP -d postgres -c “SELECT pg_is_in_recovery();
”
if [ $? -ne 0 ]; then
log “切换失败”
return 1
fi

END_TIME=$(date +%s)
SWITCH_TIME=$((END_TIME – START_TIME))
log “同城切换完成，耗时: ${SWITCH_TIME}秒”

return 0
}

# 步骤4：验证数据一致性
verify_consistency() {
log “步骤4：验证数据一致性”

# 检查数据完整性
gsql -h $STANDBY1_IP -d fgedudb -c “SELECT count(*) as total_orders FROM fgedu.orders;
”

log “数据一致性验证通过”
}

# 步骤5：恢复演练
restore_drill() {
log “步骤5：恢复演练环境”

# 将原主库恢复为备库
log “恢复原主库为备库…”
# … 恢复步骤

log “演练环境恢复完成”
}

# 主逻辑
main() {
pre_check
simulate_failure
if perform_switchover; then
verify_consistency
log “容灾演练成功，RTO=${SWITCH_TIME}秒”
else
log “容灾演练失败”
fi
restore_drill
log “========== 容灾演练结束 ==========”
}

main

# 演练结果
[2026-04-09 18:00:00] ========== 容灾演练开始 ==========
[2026-04-09 18:00:00] 步骤1：演练前检查
[2026-04-09 18:00:01] 主库正常
[2026-04-09 18:00:02] 同城备库正常
[2026-04-09 18:00:03] 异地备库正常
[2026-04-09 18:00:04] 记录当前数据状态…
total_orders
————–
150000
[2026-04-09 18:00:05] 步骤2：模拟主库故障
[2026-04-09 18:00:06] 停止主库…
[2026-04-09 18:00:10] 主库已停止
[2026-04-09 18:00:11] 步骤3：执行同城切换
[2026-04-09 18:00:20] 同城切换完成，耗时: 9秒
[2026-04-09 18:00:21] 步骤4：验证数据一致性
total_orders
————–
150000
[2026-04-09 18:00:25] 数据一致性验证通过
[2026-04-09 18:00:26] 容灾演练成功，RTO=9秒
[2026-04-09 18:00:27] 步骤5：恢复演练环境
[2026-04-09 18:05:00] 演练环境恢复完成
[2026-04-09 18:05:01] ========== 容灾演练结束 ==========

# 部署前检查
□ 网络带宽和延迟满足要求
□ 防火墙端口开放
□ 操作系统参数配置
□ 数据库版本一致

# 部署中检查
□ 主备复制配置正确
□ 复制槽创建成功
□ 复制状态正常
□ 延迟在可接受范围

# 部署后检查
□ 容灾切换脚本测试通过
□ 监控告警配置完成
□ 容灾演练执行成功
□ 文档化流程完成

# 日常检查
□ 复制延迟监控
□ 备库状态检查
□ 网络质量检测
□ 容灾演练计划