印刻数据库

外观

KingBaseES 集群管理命令 ​

KingBaseES集群管理命令是用于管理KingBaseES高可用集群的工具集合，包括集群创建、节点管理、状态监控、故障处理等功能。本文将详细介绍KingBaseES集群管理的常用命令及其使用方法。

集群管理工具概述 ​

KingBaseES集群管理主要使用以下工具：

  1. ksql：KingBaseES命令行客户端，用于执行SQL命令和管理数据库
  2. sys_ctl：用于管理KingBaseES数据库实例，包括启动、停止、重启等
  3. kbha：KingBaseES高可用管理工具，用于管理集群节点和故障切换
  4. kb_rman：KingBaseES备份恢复管理工具，用于集群备份和恢复
  5. kbcluster：KingBaseES集群创建和管理工具

集群创建命令 ​

kbcluster命令 ​

kbcluster是KingBaseES集群创建和管理的主要工具，用于创建、配置和管理KingBaseES集群。

集群初始化 ​

生产环境集群初始化脚本示例：

bash
#!/bin/bash
# KingBaseES 集群初始化脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
DB_USER="system"
DB_PASSWORD="Kingbase@2024"
PRIMARY_HOST="192.168.1.100"
PRIMARY_PORT="54321"
DATA_DIR="/opt/Kingbase/ES/V8/cluster/data"
LOG_DIR="/opt/Kingbase/ES/V8/cluster/logs"
BACKUP_DIR="/opt/Kingbase/backup"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1"
}

log "开始初始化KingBaseES集群：$CLUSTER_NAME"

# 检查目录是否存在
if [ -d "$DATA_DIR" ]; then
    log "错误：数据目录 $DATA_DIR 已存在，请选择新的目录或清理现有目录"
    exit 1
fi

if [ -d "$LOG_DIR" ]; then
    log "警告：日志目录 $LOG_DIR 已存在，将使用现有目录"
else
    mkdir -p $LOG_DIR
    log "创建日志目录：$LOG_DIR"
fi

mkdir -p $BACKUP_DIR
log "创建备份目录：$BACKUP_DIR"

# 初始化集群
log "执行集群初始化命令"
$KB_BIN/kbcluster init \
  --cluster-name=$CLUSTER_NAME \
  --db-user=$DB_USER \
  --db-password=$DB_PASSWORD \
  --primary-host=$PRIMARY_HOST \
  --primary-port=$PRIMARY_PORT \
  --data-dir=$DATA_DIR \
  --log-dir=$LOG_DIR

if [ $? -eq 0 ]; then
    log "集群初始化成功"
else
    log "错误：集群初始化失败"
    exit 1
fi

# 配置集群参数
log "配置集群参数"
cat >> $DATA_DIR/kingbase.conf << EOF
# 集群优化参数
shared_buffers = 16GB
work_mem = 64MB
effective_cache_size = 48GB
maintenance_work_mem = 2GB
max_connections = 2000
wal_level = replica
max_wal_size = 16GB
min_wal_size = 4GB
checkpoint_completion_target = 0.9
wal_buffers = 16MB
EOF

# 重启集群使配置生效
log "重启集群使配置生效"
$KB_BIN/sys_ctl restart -D $DATA_DIR -m fast

if [ $? -eq 0 ]; then
    log "集群重启成功"
else
    log "错误：集群重启失败"
    exit 1
fi

log "集群初始化完成，集群名称：$CLUSTER_NAME"
log "主节点地址：$PRIMARY_HOST:$PRIMARY_PORT"
log "数据目录：$DATA_DIR"
log "日志目录：$LOG_DIR"
log "备份目录：$BACKUP_DIR"

参数说明：

  • --cluster-name：集群名称，建议使用有意义的名称，如prod-kbcluster
  • --db-user：数据库超级用户，默认为system
  • --db-password：数据库超级用户密码，生产环境建议使用强密码
  • --primary-host：主节点主机地址
  • --primary-port：主节点端口号，建议使用非默认端口
  • --data-dir：数据目录，建议使用独立磁盘
  • --log-dir：日志目录，建议使用独立磁盘

添加备节点 ​

生产环境添加备节点脚本示例：

bash
#!/bin/bash
# KingBaseES 集群添加备节点脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
NODE_TYPE="standby"
NODE_HOST="192.168.1.101"
NODE_PORT="54321"
DATA_DIR="/opt/Kingbase/ES/V8/cluster/data"
LOG_DIR="/opt/Kingbase/ES/V8/cluster/logs"
PRIMARY_HOST="192.168.1.100"
PRIMARY_PORT="54321"
DB_USER="system"
DB_PASSWORD="Kingbase@2024"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1"
}

log "开始添加备节点到集群：$CLUSTER_NAME"

# 检查目录是否存在
if [ -d "$DATA_DIR" ]; then
    log "错误：数据目录 $DATA_DIR 已存在，请选择新的目录或清理现有目录"
    exit 1
fi

if [ -d "$LOG_DIR" ]; then
    log "警告：日志目录 $LOG_DIR 已存在，将使用现有目录"
else
    mkdir -p $LOG_DIR
    log "创建日志目录：$LOG_DIR"
fi

# 检查主节点是否可达
log "检查主节点 $PRIMARY_HOST:$PRIMARY_PORT 是否可达"
ping -c 3 $PRIMARY_HOST > /dev/null 2>&1
if [ $? -ne 0 ]; then
    log "错误：无法连接到主节点 $PRIMARY_HOST"
    exit 1
fi

# 检查主节点端口是否可达
telnet $PRIMARY_HOST $PRIMARY_PORT <<EOF > /dev/null 2>&1
quit
EOF
if [ $? -ne 0 ]; then
    log "错误：无法连接到主节点端口 $PRIMARY_PORT"
    exit 1
fi

# 添加备节点
log "执行添加备节点命令"
$KB_BIN/kbcluster add-node \
  --cluster-name=$CLUSTER_NAME \
  --node-type=$NODE_TYPE \
  --node-host=$NODE_HOST \
  --node-port=$NODE_PORT \
  --data-dir=$DATA_DIR \
  --log-dir=$LOG_DIR \
  --primary-host=$PRIMARY_HOST \
  --primary-port=$PRIMARY_PORT \
  --db-user=$DB_USER \
  --db-password=$DB_PASSWORD

if [ $? -eq 0 ]; then
    log "备节点添加成功"
else
    log "错误：备节点添加失败"
    exit 1
fi

# 配置备节点参数
log "配置备节点参数"
cat >> $DATA_DIR/kingbase.conf << EOF
# 备节点优化参数
hot_standby = on
max_standby_streaming_delay = 30s
wal_receiver_buffer_size = 16MB
wal_receiver_status_interval = 10s
hot_standby_feedback = on
EOF

# 重启备节点使配置生效
log "重启备节点使配置生效"
$KB_BIN/sys_ctl restart -D $DATA_DIR -m fast

if [ $? -eq 0 ]; then
    log "备节点重启成功"
else
    log "错误：备节点重启失败"
    exit 1
fi

# 验证备节点状态
log "验证备节点状态"
$KB_BIN/ksql -h $NODE_HOST -p $NODE_PORT -U $DB_USER -d test -c "SELECT pg_is_in_recovery();"

if [ $? -eq 0 ]; then
    log "备节点状态验证成功"
else
    log "错误：备节点状态验证失败"
    exit 1
fi

log "备节点添加完成"
log "备节点地址：$NODE_HOST:$NODE_PORT"
log "数据目录：$DATA_DIR"
log "日志目录：$LOG_DIR"

参数说明：

  • --node-type：节点类型（primary/standby）
  • --node-host：节点主机地址
  • --node-port：节点端口号
  • --data-dir：数据目录
  • --log-dir：日志目录
  • --primary-host：主节点主机地址
  • --primary-port：主节点端口号
  • --db-user：数据库超级用户
  • --db-password：数据库超级用户密码

集群状态监控命令 ​

查看集群状态 ​

生产环境集群状态监控脚本示例：

bash
#!/bin/bash
# KingBaseES 集群状态监控脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
DB_USER="system"
DB_PASSWORD="Kingbase@2024"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_status_$(date +%Y%m%d).log"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始检查集群状态：$CLUSTER_NAME"

# 查看集群整体状态
log "查看集群整体状态"
CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
echo "$CLUSTER_STATUS"
log "$CLUSTER_STATUS"

# 检查集群是否正常
if echo "$CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
    log "集群状态正常"
else
    log "警告：集群状态异常"
    # 发送告警邮件
    # echo "$CLUSTER_STATUS" | mail -s "KingBaseES Cluster Status Alert" $ALERT_EMAIL
fi

# 查看复制状态
log "查看主节点复制状态"
REPLICATION_STATUS=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U $DB_USER -d test -t -c "SELECT client_addr, application_name, state, sync_state, write_lag, flush_lag, replay_lag FROM sys_stat_replication;" << EOF
$DB_PASSWORD
EOF
)

if [ -z "$REPLICATION_STATUS" ]; then
    log "警告：未发现备节点连接"
    # 发送告警邮件
    # echo "未发现备节点连接" | mail -s "KingBaseES Replication Alert" $ALERT_EMAIL
else
    log "复制状态正常，备节点数量：$(echo "$REPLICATION_STATUS" | wc -l)"
    echo "$REPLICATION_STATUS"
    log "$REPLICATION_STATUS"
fi

log "集群状态检查完成"

查看节点状态 ​

生产环境节点状态监控脚本示例：

bash
#!/bin/bash
# KingBaseES 节点状态监控脚本

# 配置
NODES=(
    "192.168.1.100:/opt/Kingbase/ES/V8/cluster/data"
    "192.168.1.101:/opt/Kingbase/ES/V8/cluster/data"
)
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/node_status_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始检查节点状态"

for NODE in "${NODES[@]}"; do
    HOST=$(echo $NODE | cut -d: -f1)
    DATA_DIR=$(echo $NODE | cut -d: -f2)
    
    log "检查节点：$HOST"
    
    # 检查节点是否可达
    if ping -c 2 $HOST > /dev/null 2>&1; then
        # 检查数据库实例状态
        SSH_CMD="ssh $HOST \"$KB_BIN/sys_ctl status -D $DATA_DIR\""
        NODE_STATUS=$(eval $SSH_CMD)
        
        echo "节点 $HOST 状态："
        echo "$NODE_STATUS"
        log "节点 $HOST 状态：$NODE_STATUS"
        
        if echo "$NODE_STATUS" | grep -i "running" > /dev/null; then
            log "节点 $HOST 正常运行"
        else
            log "警告：节点 $HOST 状态异常"
            # 发送告警邮件
            # echo "节点 $HOST 状态异常：$NODE_STATUS" | mail -s "KingBaseES Node Status Alert" dba@example.com
        fi
    else
        log "错误：无法连接到节点 $HOST"
        # 发送告警邮件
        # echo "无法连接到节点 $HOST" | mail -s "KingBaseES Node Connection Alert" dba@example.com
    fi
    
    echo "========================================"
done

log "节点状态检查完成"

查看复制延迟 ​

生产环境复制延迟监控脚本示例：

bash
#!/bin/bash
# KingBaseES 复制延迟监控脚本

# 配置
NODES=(
    "192.168.1.101:54321"
    "192.168.1.102:54321"
)
DB_USER="system"
DB_PASSWORD="Kingbase@2024"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/replication_delay_$(date +%Y%m%d).log"
ALERT_THRESHOLD=30 # 复制延迟告警阈值（秒）
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始检查复制延迟"

for NODE in "${NODES[@]}"; do
    HOST=$(echo $NODE | cut -d: -f1)
    PORT=$(echo $NODE | cut -d: -f2)
    
    log "检查备节点：$HOST:$PORT"
    
    # 查看备节点复制延迟
    REPLICATION_DELAY=$($KB_BIN/ksql -h $HOST -p $PORT -U $DB_USER -d test -t -c "SELECT extract(epoch FROM (now() - pg_last_xact_replay_timestamp())) AS replication_delay_seconds;" << EOF
$DB_PASSWORD
EOF
    )
    
    if [ -z "$REPLICATION_DELAY" ]; then
        log "错误：无法获取备节点 $HOST:$PORT 的复制延迟"
        # 发送告警邮件
        # echo "无法获取备节点 $HOST:$PORT 的复制延迟" | mail -s "KingBaseES Replication Delay Alert" $ALERT_EMAIL
    else
        echo "备节点 $HOST:$PORT 复制延迟：$REPLICATION_DELAY 秒"
        log "备节点 $HOST:$PORT 复制延迟：$REPLICATION_DELAY 秒"
        
        # 检查复制延迟是否超过阈值
        if (( $(echo "$REPLICATION_DELAY > $ALERT_THRESHOLD" | bc -l) )); then
            log "警告：备节点 $HOST:$PORT 复制延迟超过阈值，当前延迟：$REPLICATION_DELAY 秒，阈值：$ALERT_THRESHOLD 秒"
            # 发送告警邮件
            # echo "备节点 $HOST:$PORT 复制延迟超过阈值：$REPLICATION_DELAY 秒" | mail -s "KingBaseES Replication Delay Alert" $ALERT_EMAIL
        fi
    fi
    
    echo "========================================"
done

# 查看所有节点的复制状态
log "查看所有节点的复制状态"
REPLICATION_STATUS=$($KB_BIN/kbha replication-status --cluster-name=prod-kbcluster)
echo "$REPLICATION_STATUS"
log "$REPLICATION_STATUS"

log "复制延迟检查完成"

集群节点管理命令 ​

启动集群 ​

生产环境集群启动脚本示例：

bash
#!/bin/bash
# KingBaseES 集群启动脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_start_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始启动集群：$CLUSTER_NAME"

# 启动集群
log "执行集群启动命令"
$KB_BIN/kbha start --cluster-name=$CLUSTER_NAME

if [ $? -eq 0 ]; then
    log "集群启动成功"
    
    # 验证集群状态
    log "验证集群状态"
    sleep 5
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    log "$CLUSTER_STATUS"
    
    if echo "$CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
        log "集群状态正常"
    else
        log "警告：集群启动后状态异常"
    fi
else
    log "错误：集群启动失败"
    exit 1
fi

log "集群启动完成"

停止集群 ​

生产环境集群停止脚本示例：

bash
#!/bin/bash
# KingBaseES 集群停止脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_stop_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始停止集群：$CLUSTER_NAME"

# 检查集群当前状态
log "检查集群当前状态"
CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
log "$CLUSTER_STATUS"

# 停止集群
log "执行集群停止命令"
$KB_BIN/kbha stop --cluster-name=$CLUSTER_NAME

if [ $? -eq 0 ]; then
    log "集群停止成功"
    
    # 验证集群状态
    log "验证集群状态"
    sleep 3
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    log "$CLUSTER_STATUS"
else
    log "错误：集群停止失败"
    exit 1
fi

log "集群停止完成"

重启集群 ​

生产环境集群重启脚本示例：

bash
#!/bin/bash
# KingBaseES 集群重启脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_restart_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始重启集群：$CLUSTER_NAME"

# 重启集群
log "执行集群重启命令"
$KB_BIN/kbha restart --cluster-name=$CLUSTER_NAME

if [ $? -eq 0 ]; then
    log "集群重启成功"
    
    # 验证集群状态
    log "验证集群状态"
    sleep 10
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    log "$CLUSTER_STATUS"
    
    if echo "$CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
        log "集群状态正常"
    else
        log "警告：集群重启后状态异常"
    fi
else
    log "错误：集群重启失败"
    exit 1
fi

log "集群重启完成"

切换主节点 ​

生产环境主节点切换脚本示例：

bash
#!/bin/bash
# KingBaseES 主节点切换脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
TARGET_NODE="192.168.1.101"
TARGET_PORT="54321"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_switchover_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始主节点切换，目标节点：$TARGET_NODE:$TARGET_PORT"

# 检查目标节点状态
log "检查目标节点 $TARGET_NODE:$TARGET_PORT 状态"
ping -c 3 $TARGET_NODE > /dev/null 2>&1
if [ $? -ne 0 ]; then
    log "错误：无法连接到目标节点 $TARGET_NODE"
    exit 1
fi

# 执行主节点切换
log "执行主节点切换命令"
$KB_BIN/kbha switchover \
  --cluster-name=$CLUSTER_NAME \
  --target-node=$TARGET_NODE \
  --target-port=$TARGET_PORT

if [ $? -eq 0 ]; then
    log "主节点切换成功"
    
    # 验证新主节点状态
    log "验证新主节点状态"
    sleep 10
    NEW_PRIMARY_STATUS=$($KB_BIN/ksql -h $TARGET_NODE -p $TARGET_PORT -U system -d test -t -c "SELECT pg_is_in_recovery();" << EOF
Kingbase@2024
EOF
    )
    
    if [ "$NEW_PRIMARY_STATUS" = "f" ]; then
        log "新主节点 $TARGET_NODE:$TARGET_PORT 状态正常，已退出恢复模式"
    else
        log "警告：新主节点 $TARGET_NODE:$TARGET_PORT 仍处于恢复模式"
    fi
    
    # 验证集群状态
    log "验证集群整体状态"
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    log "$CLUSTER_STATUS"
else
    log "错误：主节点切换失败"
    exit 1
fi

log "主节点切换完成"

参数说明：

  • --target-node：目标主节点主机地址
  • --target-port：目标主节点端口号

强制故障切换 ​

生产环境强制故障切换脚本示例：

bash
#!/bin/bash
# KingBaseES 强制故障切换脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
TARGET_NODE="192.168.1.101"
TARGET_PORT="54321"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_failover_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始强制故障切换，目标节点：$TARGET_NODE:$TARGET_PORT"

# 检查原主节点是否真的不可用
log "检查原主节点状态（192.168.1.100:54321）"
ping -c 5 192.168.1.100 > /dev/null 2>&1
if [ $? -eq 0 ]; then
    log "警告：原主节点 192.168.1.100 仍然可达，是否确定要执行强制故障切换？"
    # 可以添加交互式确认或直接退出
    # read -p "是否继续？(y/n) " -n 1 -r
    # echo
    # if [[ ! $REPLY =~ ^[Yy]$ ]]; then
    #     log "用户取消了强制故障切换"
    #     exit 0
    # fi
fi

# 检查目标节点状态
log "检查目标节点 $TARGET_NODE:$TARGET_PORT 状态"
ping -c 3 $TARGET_NODE > /dev/null 2>&1
if [ $? -ne 0 ]; then
    log "错误：无法连接到目标节点 $TARGET_NODE"
    exit 1
fi

# 执行强制故障切换
log "执行强制故障切换命令"
$KB_BIN/kbha failover \
  --cluster-name=$CLUSTER_NAME \
  --target-node=$TARGET_NODE \
  --target-port=$TARGET_PORT \
  --force

if [ $? -eq 0 ]; then
    log "强制故障切换成功"
    
    # 验证新主节点状态
    log "验证新主节点状态"
    sleep 10
    NEW_PRIMARY_STATUS=$($KB_BIN/ksql -h $TARGET_NODE -p $TARGET_PORT -U system -d test -t -c "SELECT pg_is_in_recovery();" << EOF
Kingbase@2024
EOF
    )
    
    if [ "$NEW_PRIMARY_STATUS" = "f" ]; then
        log "新主节点 $TARGET_NODE:$TARGET_PORT 状态正常，已退出恢复模式"
    else
        log "警告：新主节点 $TARGET_NODE:$TARGET_PORT 仍处于恢复模式"
    fi
    
    # 验证集群状态
    log "验证集群整体状态"
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    log "$CLUSTER_STATUS"
else
    log "错误：强制故障切换失败"
    exit 1
fi

log "强制故障切换完成"
# 建议：执行完强制故障切换后，需要检查原主节点，修复问题后重新加入集群

集群配置管理命令 ​

查看集群配置 ​

生产环境集群配置查看脚本示例：

bash
#!/bin/bash
# KingBaseES 集群配置查看脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
CONFIG_DIR="/opt/Kingbase/ES/V8/cluster/config"
LOG_FILE="/opt/Kingbase/logs/cluster_config_view_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始查看集群配置：$CLUSTER_NAME"

# 确保配置目录存在
mkdir -p $CONFIG_DIR

# 查看集群整体配置
log "查看集群整体配置"
CLUSTER_CONFIG=$($KB_BIN/kbha config --cluster-name=$CLUSTER_NAME)
echo "$CLUSTER_CONFIG"
log "$CLUSTER_CONFIG"

# 保存集群配置到文件
CONFIG_FILE="$CONFIG_DIR/cluster_config_$(date +%Y%m%d_%H%M%S).txt"
echo "$CLUSTER_CONFIG" > $CONFIG_FILE
log "集群配置已保存到：$CONFIG_FILE"

# 查看主节点数据库配置
log "查看主节点数据库配置"
PRIMARY_CONFIG=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SHOW ALL;" << EOF
Kingbase@2024
EOF
)

# 保存主节点配置到文件
PRIMARY_CONFIG_FILE="$CONFIG_DIR/primary_config_$(date +%Y%m%d_%H%M%S).txt"
echo "$PRIMARY_CONFIG" > $PRIMARY_CONFIG_FILE
log "主节点配置已保存到：$PRIMARY_CONFIG_FILE"

# 查看备节点数据库配置
log "查看备节点数据库配置"
STANDBY_CONFIG=$($KB_BIN/ksql -h 192.168.1.101 -p 54321 -U system -d test -t -c "SHOW ALL;" << EOF
Kingbase@2024
EOF
)

# 保存备节点配置到文件
STANDBY_CONFIG_FILE="$CONFIG_DIR/standby_config_$(date +%Y%m%d_%H%M%S).txt"
echo "$STANDBY_CONFIG" > $STANDBY_CONFIG_FILE
log "备节点配置已保存到：$STANDBY_CONFIG_FILE"

# 查看关键配置参数
log "查看关键配置参数"
KEY_PARAMS=("shared_buffers" "work_mem" "effective_cache_size" "max_connections" "wal_level" "hot_standby")

for PARAM in "${KEY_PARAMS[@]}"; do
    log "查看参数 $PARAM"
    PRIMARY_VALUE=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SHOW $PARAM;" << EOF
Kingbase@2024
EOF
    )
    STANDBY_VALUE=$($KB_BIN/ksql -h 192.168.1.101 -p 54321 -U system -d test -t -c "SHOW $PARAM;" << EOF
Kingbase@2024
EOF
    )
    echo "参数 $PARAM：主节点=$PRIMARY_VALUE，备节点=$STANDBY_VALUE"
    log "参数 $PARAM：主节点=$PRIMARY_VALUE，备节点=$STANDBY_VALUE"
done

log "集群配置查看完成"
echo "配置文件已保存到：$CONFIG_DIR"

修改集群配置 ​

生产环境集群配置修改脚本示例：

bash
#!/bin/bash
# KingBaseES 集群配置修改脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
CONFIG_DIR="/opt/Kingbase/ES/V8/cluster/config"
LOG_FILE="/opt/Kingbase/logs/cluster_config_modify_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始修改集群配置：$CLUSTER_NAME"

# 备份当前配置
log "备份当前配置"
BACKUP_DIR="$CONFIG_DIR/backup_$(date +%Y%m%d_%H%M%S)"
mkdir -p $BACKUP_DIR

# 备份集群配置
$KB_BIN/kbha config --cluster-name=$CLUSTER_NAME > $BACKUP_DIR/cluster_config.txt
log "集群配置已备份到：$BACKUP_DIR/cluster_config.txt"

# 修改集群配置参数
log "修改集群配置参数"
$KB_BIN/kbha modify-config \
  --cluster-name=$CLUSTER_NAME \
  --parameter=ha_check_interval=5 \
  --parameter=ha_retry_count=3 \
  --parameter=ha_failover_timeout=60 \
  --parameter=ha_switchover_timeout=30

if [ $? -eq 0 ]; then
    log "集群配置修改成功"
else
    log "错误：集群配置修改失败"
    exit 1
fi

# 验证配置修改
log "验证配置修改"
NEW_CONFIG=$($KB_BIN/kbha config --cluster-name=$CLUSTER_NAME)
log "$NEW_CONFIG"

# 查看修改后的参数
log "查看修改后的参数"
for PARAM in "ha_check_interval" "ha_retry_count" "ha_failover_timeout" "ha_switchover_timeout"; do
    PARAM_VALUE=$(echo "$NEW_CONFIG" | grep -i "$PARAM" | awk -F'=' '{print $2}' | tr -d ' ')
    log "参数 $PARAM：$PARAM_VALUE"
done

# 修改数据库配置（主节点）
log "修改主节点数据库配置"
PRIMARY_DATA_DIR="/opt/Kingbase/ES/V8/cluster/data"

# 备份主节点配置文件
cp $PRIMARY_DATA_DIR/kingbase.conf $BACKUP_DIR/primary_kingbase.conf.backup
log "主节点配置文件已备份到：$BACKUP_DIR/primary_kingbase.conf.backup"

# 修改主节点配置参数
cat >> $PRIMARY_DATA_DIR/kingbase.conf << EOF

# 动态调整参数
maintenance_work_mem = 4GB
max_wal_senders = 10
wal_keep_segments = 100
EOF

# 重载主节点配置
log "重载主节点配置"
$KB_BIN/sys_ctl reload -D $PRIMARY_DATA_DIR

if [ $? -eq 0 ]; then
    log "主节点配置重载成功"
else
    log "错误：主节点配置重载失败"
    # 恢复备份配置
    cp $BACKUP_DIR/primary_kingbase.conf.backup $PRIMARY_DATA_DIR/kingbase.conf
    $KB_BIN/sys_ctl reload -D $PRIMARY_DATA_DIR
    exit 1
fi

# 修改备节点配置（示例：192.168.1.101）
log "修改备节点配置"
STANDBY_HOST="192.168.1.101"
STANDBY_DATA_DIR="/opt/Kingbase/ES/V8/cluster/data"

# 备份备节点配置文件
ssh $STANDBY_HOST "cp $STANDBY_DATA_DIR/kingbase.conf $STANDBY_DATA_DIR/kingbase.conf.backup"
log "备节点配置文件已备份"

# 修改备节点配置参数
ssh $STANDBY_HOST "cat >> $STANDBY_DATA_DIR/kingbase.conf << EOF

# 动态调整参数
maintenance_work_mem = 4GB
max_standby_streaming_delay = 60s
EOF"

# 重载备节点配置
log "重载备节点配置"
ssh $STANDBY_HOST "$KB_BIN/sys_ctl reload -D $STANDBY_DATA_DIR"

if [ $? -eq 0 ]; then
    log "备节点配置重载成功"
else
    log "错误：备节点配置重载失败"
    # 恢复备份配置
    ssh $STANDBY_HOST "cp $STANDBY_DATA_DIR/kingbase.conf.backup $STANDBY_DATA_DIR/kingbase.conf"
    ssh $STANDBY_HOST "$KB_BIN/sys_ctl reload -D $STANDBY_DATA_DIR"
    exit 1
fi

log "集群配置修改完成"
echo "配置备份已保存到：$BACKUP_DIR"

集群备份恢复命令 ​

集群全量备份 ​

生产环境集群全量备份脚本示例：

bash
#!/bin/bash
# KingBaseES 集群全量备份脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
BACKUP_DIR="/opt/Kingbase/backup"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_backup_full_$(date +%Y%m%d).log"
RETENTION_DAYS=30
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始执行集群全量备份：$CLUSTER_NAME"

# 确保备份目录存在
mkdir -p $BACKUP_DIR

# 检查磁盘空间
log "检查备份目录磁盘空间"
DISK_USAGE=$(df -h $BACKUP_DIR | tail -n 1 | awk '{print $5}' | sed 's/%//')
if [ $DISK_USAGE -gt 80 ]; then
    log "警告：备份目录磁盘使用率已达 $DISK_USAGE%，建议清理旧备份"
    # 发送告警邮件
    # echo "备份目录磁盘使用率已达 $DISK_USAGE%" | mail -s "KingBaseES Backup Disk Alert" $ALERT_EMAIL
fi

# 执行全量备份
log "执行全量备份命令"
$KB_BIN/kb_rman backup \
  --cluster-name=$CLUSTER_NAME \
  --backup-type=full \
  --backup-dir=$BACKUP_DIR \
  --compress=on \
  --parallel=4 \
  --backup-info=full_backup_$(date +%Y%m%d_%H%M%S)

if [ $? -eq 0 ]; then
    log "全量备份成功"
else
    log "错误：全量备份失败"
    # 发送告警邮件
    # echo "集群全量备份失败" | mail -s "KingBaseES Backup Failure Alert" $ALERT_EMAIL
    exit 1
fi

# 验证备份
log "验证备份完整性"
$KB_BIN/kb_rman verify \
  --cluster-name=$CLUSTER_NAME \
  --backup-dir=$BACKUP_DIR \
  --latest

if [ $? -eq 0 ]; then
    log "备份验证成功"
else
    log "警告：备份验证失败"
    # 发送告警邮件
    # echo "备份验证失败" | mail -s "KingBaseES Backup Verify Alert" $ALERT_EMAIL
fi

# 清理过期备份
log "清理 $RETENTION_DAYS 天前的备份"
$KB_BIN/kb_rman purge \
  --cluster-name=$CLUSTER_NAME \
  --backup-dir=$BACKUP_DIR \
  --retention-days=$RETENTION_DAYS

if [ $? -eq 0 ]; then
    log "过期备份清理成功"
else
    log "警告：过期备份清理失败"
fi

# 列出当前备份
log "当前备份列表："
$KB_BIN/kb_rman list \
  --cluster-name=$CLUSTER_NAME \
  --backup-dir=$BACKUP_DIR >> $LOG_FILE

log "集群全量备份完成"

# 发送备份成功邮件
# echo "集群全量备份成功，备份目录：$BACKUP_DIR" | mail -s "KingBaseES Backup Success" $ALERT_EMAIL

集群增量备份 ​

生产环境集群增量备份脚本示例：

bash
#!/bin/bash
# KingBaseES 集群增量备份脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
BACKUP_DIR="/opt/Kingbase/backup"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_backup_incremental_$(date +%Y%m%d).log"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始执行集群增量备份：$CLUSTER_NAME"

# 确保备份目录存在
mkdir -p $BACKUP_DIR

# 执行增量备份
log "执行增量备份命令"
$KB_BIN/kb_rman backup \
  --cluster-name=$CLUSTER_NAME \
  --backup-type=incremental \
  --backup-dir=$BACKUP_DIR \
  --compress=on \
  --parallel=4 \
  --backup-info=incremental_backup_$(date +%Y%m%d_%H%M%S)

if [ $? -eq 0 ]; then
    log "增量备份成功"
else
    log "错误：增量备份失败"
    # 发送告警邮件
    # echo "集群增量备份失败" | mail -s "KingBaseES Incremental Backup Failure Alert" $ALERT_EMAIL
    exit 1
fi

# 验证备份
log "验证备份完整性"
$KB_BIN/kb_rman verify \
  --cluster-name=$CLUSTER_NAME \
  --backup-dir=$BACKUP_DIR \
  --latest

if [ $? -eq 0 ]; then
    log "备份验证成功"
else
    log "警告：备份验证失败"
    # 发送告警邮件
    # echo "增量备份验证失败" | mail -s "KingBaseES Incremental Backup Verify Alert" $ALERT_EMAIL
fi

# 列出当前备份链
log "当前备份链："
$KB_BIN/kb_rman list \
  --cluster-name=$CLUSTER_NAME \
  --backup-dir=$BACKUP_DIR \
  --backup-type=chain >> $LOG_FILE

log "集群增量备份完成"

从备份恢复集群 ​

生产环境集群恢复脚本示例：

bash
#!/bin/bash
# KingBaseES 集群从备份恢复脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
BACKUP_DIR="/opt/Kingbase/backup"
RESTORE_TIME="2023-05-01 12:00:00"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_restore_$(date +%Y%m%d).log"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始执行集群恢复，恢复时间点：$RESTORE_TIME"

# 停止集群
log "停止当前集群"
$KB_BIN/kbha stop --cluster-name=$CLUSTER_NAME

if [ $? -eq 0 ]; then
    log "集群停止成功"
else
    log "警告：集群停止失败，可能已处于停止状态"
fi

# 列出可用备份
log "列出可用备份："
$KB_BIN/kb_rman list \
  --cluster-name=$CLUSTER_NAME \
  --backup-dir=$BACKUP_DIR >> $LOG_FILE

# 执行恢复
log "执行集群恢复命令"
$KB_BIN/kb_rman restore \
  --cluster-name=$CLUSTER_NAME \
  --backup-dir=$BACKUP_DIR \
  --restore-time="$RESTORE_TIME" \
  --parallel=4 \
  --force

if [ $? -eq 0 ]; then
    log "集群恢复成功"
else
    log "错误：集群恢复失败"
    # 发送告警邮件
    # echo "集群恢复失败" | mail -s "KingBaseES Restore Failure Alert" $ALERT_EMAIL
    exit 1
fi

# 启动集群
log "启动恢复后的集群"
$KB_BIN/kbha start --cluster-name=$CLUSTER_NAME

if [ $? -eq 0 ]; then
    log "集群启动成功"
    
    # 验证集群状态
    log "验证集群状态"
    sleep 10
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    log "$CLUSTER_STATUS"
    
    if echo "$CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
        log "集群恢复后状态正常"
    else
        log "警告：集群恢复后状态异常"
    fi
else
    log "错误：集群启动失败"
    # 发送告警邮件
    # echo "集群恢复后启动失败" | mail -s "KingBaseES Cluster Start Failure Alert" $ALERT_EMAIL
    exit 1
fi

# 验证数据完整性（示例：查询重要表数据）
log "验证数据完整性"
$KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT count(*) FROM important_table;" << EOF
Kingbase@2024
EOF

if [ $? -eq 0 ]; then
    log "数据完整性验证成功"
else
    log "警告：数据完整性验证失败"
fi

log "集群恢复完成"
# 发送恢复成功邮件
# echo "集群恢复成功，恢复时间点：$RESTORE_TIME" | mail -s "KingBaseES Restore Success" $ALERT_EMAIL

集群故障处理命令 ​

处理节点故障 ​

生产环境节点故障处理脚本示例：

bash
#!/bin/bash
# KingBaseES 节点故障处理脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
FAULT_NODE="192.168.1.100"
FAULT_PORT="54321"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_node_fault_$(date +%Y%m%d).log"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始处理故障节点：$FAULT_NODE:$FAULT_PORT"

# 查看当前集群状态
log "查看当前集群状态"
CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
echo "$CLUSTER_STATUS"
log "$CLUSTER_STATUS"

# 检查故障节点状态
log "检查故障节点 $FAULT_NODE:$FAULT_PORT 状态"
ping -c 5 $FAULT_NODE > /dev/null 2>&1
if [ $? -eq 0 ]; then
    log "节点 $FAULT_NODE 网络可达，检查数据库状态"
    SSH_CMD="ssh $FAULT_NODE \"$KB_BIN/sys_ctl status -D /opt/Kingbase/ES/V8/cluster/data\""
    NODE_STATUS=$(eval $SSH_CMD 2>&1)
    log "节点数据库状态：$NODE_STATUS"
    
    if echo "$NODE_STATUS" | grep -i "running" > /dev/null; then
        log "节点数据库仍在运行，尝试重启数据库"
        SSH_CMD="ssh $FAULT_NODE \"$KB_BIN/sys_ctl restart -D /opt/Kingbase/ES/V8/cluster/data -m fast\""
        eval $SSH_CMD
        if [ $? -eq 0 ]; then
            log "节点数据库重启成功"
            # 验证节点状态
            sleep 5
            $KB_BIN/ksql -h $FAULT_NODE -p $FAULT_PORT -U system -d test -t -c "SELECT 1;" << EOF
Kingbase@2024
EOF
            if [ $? -eq 0 ]; then
                log "节点已恢复正常"
                exit 0
            fi
        fi
    fi
fi

log "节点 $FAULT_NODE:$FAULT_PORT 确认为故障，执行隔离操作"

# 隔离故障节点
$KB_BIN/kbha isolate-node \
  --cluster-name=$CLUSTER_NAME \
  --node-host=$FAULT_NODE \
  --node-port=$FAULT_PORT

if [ $? -eq 0 ]; then
    log "故障节点隔离成功"
else
    log "错误：故障节点隔离失败"
    # 发送告警邮件
    # echo "故障节点隔离失败：$FAULT_NODE:$FAULT_PORT" | mail -s "KingBaseES Node Isolation Failure" $ALERT_EMAIL
    exit 1
fi

# 等待集群自动故障切换
log "等待集群自动故障切换..."
sleep 20

# 验证集群状态
log "验证集群状态"
NEW_CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
log "$NEW_CLUSTER_STATUS"

if echo "$NEW_CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
    log "集群已自动恢复正常"
else
    log "警告：集群未自动恢复正常，需要手动干预"
    # 发送告警邮件
    # echo "集群未自动恢复正常" | mail -s "KingBaseES Cluster Recovery Alert" $ALERT_EMAIL
fi

log "节点故障处理完成"

重建备节点 ​

生产环境备节点重建脚本示例：

bash
#!/bin/bash
# KingBaseES 备节点重建脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
STANDBY_HOST="192.168.1.101"
STANDBY_PORT="54321"
PRIMARY_HOST="192.168.1.100"
PRIMARY_PORT="54321"
DB_USER="system"
DB_PASSWORD="Kingbase@2024"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
STANDBY_DATA_DIR="/opt/Kingbase/ES/V8/cluster/data"
LOG_FILE="/opt/Kingbase/logs/cluster_rebuild_standby_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始重建备节点：$STANDBY_HOST:$STANDBY_PORT"

# 检查主节点状态
log "检查主节点 $PRIMARY_HOST:$PRIMARY_PORT 状态"
ping -c 3 $PRIMARY_HOST > /dev/null 2>&1
if [ $? -ne 0 ]; then
    log "错误：无法连接到主节点 $PRIMARY_HOST"
    exit 1
fi

# 检查备节点状态
log "检查备节点 $STANDBY_HOST:$STANDBY_PORT 状态"
ping -c 3 $STANDBY_HOST > /dev/null 2>&1
if [ $? -ne 0 ]; then
    log "错误：无法连接到备节点 $STANDBY_HOST"
    exit 1
fi

# 停止备节点数据库
log "停止备节点数据库"
ssh $STANDBY_HOST "$KB_BIN/sys_ctl stop -D $STANDBY_DATA_DIR -m fast"

# 清理备节点数据目录
log "清理备节点数据目录：$STANDBY_DATA_DIR"
ssh $STANDBY_HOST "rm -rf $STANDBY_DATA_DIR/*"

# 重建备节点
log "执行备节点重建命令"
$KB_BIN/kbcluster rebuild-standby \
  --cluster-name=$CLUSTER_NAME \
  --standby-host=$STANDBY_HOST \
  --standby-port=$STANDBY_PORT \
  --primary-host=$PRIMARY_HOST \
  --primary-port=$PRIMARY_PORT \
  --db-user=$DB_USER \
  --db-password=$DB_PASSWORD \
  --data-dir=$STANDBY_DATA_DIR \
  --parallel=4

if [ $? -eq 0 ]; then
    log "备节点重建成功"
else
    log "错误：备节点重建失败"
    exit 1
fi

# 启动备节点
log "启动备节点数据库"
ssh $STANDBY_HOST "$KB_BIN/sys_ctl start -D $STANDBY_DATA_DIR"

# 验证备节点状态
log "验证备节点状态"
sleep 10
STANDBY_STATUS=$($KB_BIN/ksql -h $STANDBY_HOST -p $STANDBY_PORT -U $DB_USER -d test -t -c "SELECT pg_is_in_recovery();" << EOF
$DB_PASSWORD
EOF
)

if [ "$STANDBY_STATUS" = "t" ]; then
    log "备节点重建成功，已进入恢复模式"
else
    log "警告：备节点未进入恢复模式，状态异常"
    exit 1
fi

# 验证复制状态
log "验证复制状态"
sleep 5
REPLICATION_STATUS=$($KB_BIN/ksql -h $PRIMARY_HOST -p $PRIMARY_PORT -U $DB_USER -d test -t -c "SELECT client_addr, state FROM sys_stat_replication WHERE client_addr = '$STANDBY_HOST';" << EOF
$DB_PASSWORD
EOF
)

if [ -n "$REPLICATION_STATUS" ]; then
    log "复制已建立，状态：$REPLICATION_STATUS"
else
    log "警告：未检测到复制连接"
fi

# 查看集群状态
log "查看集群整体状态"
CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
log "$CLUSTER_STATUS"

echo "备节点重建完成，节点：$STANDBY_HOST:$STANDBY_PORT"
log "备节点重建完成"

修复集群分裂 ​

生产环境集群分裂修复脚本示例：

bash
#!/bin/bash
# KingBaseES 集群分裂修复脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
PRIMARY_NODE="192.168.1.100"
PRIMARY_PORT="54321"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_fix_split_$(date +%Y%m%d).log"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始修复集群分裂，指定主节点：$PRIMARY_NODE:$PRIMARY_PORT"

# 查看各节点状态
log "查看各节点状态"
NODES=("192.168.1.100" "192.168.1.101" "192.168.1.102")

for NODE in "${NODES[@]}"; do
    log "检查节点 $NODE 状态"
    ping -c 3 $NODE > /dev/null 2>&1
    if [ $? -eq 0 ]; then
        NODE_STATUS=$($KB_BIN/ksql -h $NODE -p 54321 -U system -d test -t -c "SELECT pg_is_in_recovery(); SELECT current_timestamp;" << EOF
Kingbase@2024
EOF
  2>&1)
        log "节点 $NODE 状态：$NODE_STATUS"
    else
        log "节点 $NODE 不可达"
    fi
done

# 执行集群分裂修复
log "执行集群分裂修复命令"
$KB_BIN/kbha fix-split-brain \
  --cluster-name=$CLUSTER_NAME \
  --primary-node=$PRIMARY_NODE \
  --primary-port=$PRIMARY_PORT \
  --force

if [ $? -eq 0 ]; then
    log "集群分裂修复成功"
else
    log "错误：集群分裂修复失败"
    # 发送告警邮件
    # echo "集群分裂修复失败" | mail -s "KingBaseES Split Brain Fix Failure" $ALERT_EMAIL
    exit 1
fi

# 等待集群恢复
log "等待集群恢复..."
sleep 30

# 验证集群状态
log "验证集群状态"
CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
echo "$CLUSTER_STATUS"
log "$CLUSTER_STATUS"

if echo "$CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
    log "集群已恢复正常"
else
    log "警告：集群仍未恢复正常，需要进一步检查"
    # 发送告警邮件
    # echo "集群分裂修复后状态异常" | mail -s "KingBaseES Cluster Recovery Alert" $ALERT_EMAIL
fi

# 查看各节点角色
log "查看各节点角色"
for NODE in "${NODES[@]}"; do
    ping -c 3 $NODE > /dev/null 2>&1
    if [ $? -eq 0 ]; then
        NODE_ROLE=$($KB_BIN/ksql -h $NODE -p 54321 -U system -d test -t -c "SELECT CASE WHEN pg_is_in_recovery() THEN 'standby' ELSE 'primary' END AS role;" << EOF
Kingbase@2024
EOF
  2>&1)
        log "节点 $NODE 角色：$NODE_ROLE"
    fi
done

log "集群分裂修复完成"

集群扩展命令 ​

添加新节点 ​

生产环境添加新备节点脚本示例：

bash
#!/bin/bash
# KingBaseES 集群添加新备节点脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
NEW_NODE_TYPE="standby"
NEW_NODE_HOST="192.168.1.102"
NEW_NODE_PORT="54321"
DATA_DIR="/opt/Kingbase/ES/V8/cluster/data"
LOG_DIR="/opt/Kingbase/ES/V8/cluster/logs"
PRIMARY_HOST="192.168.1.100"
PRIMARY_PORT="54321"
DB_USER="system"
DB_PASSWORD="Kingbase@2024"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_add_node_$(date +%Y%m%d).log"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始添加新节点：$NEW_NODE_HOST:$NEW_NODE_PORT"

# 检查新节点网络连通性
log "检查新节点 $NEW_NODE_HOST 网络连通性"
ping -c 3 $NEW_NODE_HOST > /dev/null 2>&1
if [ $? -ne 0 ]; then
    log "错误：无法连接到新节点 $NEW_NODE_HOST"
    exit 1
fi

# 检查主节点状态
log "检查主节点 $PRIMARY_HOST:$PRIMARY_PORT 状态"
ping -c 3 $PRIMARY_HOST > /dev/null 2>&1
if [ $? -ne 0 ]; then
    log "错误：无法连接到主节点 $PRIMARY_HOST"
    exit 1
fi

# 检查新节点目录是否存在
log "检查新节点目录"
ssh $NEW_NODE_HOST "if [ -d '$DATA_DIR' ]; then echo 'exists'; else echo 'not exists'; fi" > /tmp/node_dir_check
DIR_EXISTS=$(cat /tmp/node_dir_check)
if [ "$DIR_EXISTS" = "exists" ]; then
    log "错误：数据目录 $DATA_DIR 已存在，请选择新的目录或清理现有目录"
    exit 1
fi

# 在新节点上创建必要目录
log "在新节点上创建必要目录"
ssh $NEW_NODE_HOST "mkdir -p $DATA_DIR $LOG_DIR"
if [ $? -ne 0 ]; then
    log "错误：无法在新节点上创建目录"
    exit 1
fi

# 添加新节点
log "执行添加新节点命令"
$KB_BIN/kbcluster add-node \
  --cluster-name=$CLUSTER_NAME \
  --node-type=$NEW_NODE_TYPE \
  --node-host=$NEW_NODE_HOST \
  --node-port=$NEW_NODE_PORT \
  --data-dir=$DATA_DIR \
  --log-dir=$LOG_DIR \
  --primary-host=$PRIMARY_HOST \
  --primary-port=$PRIMARY_PORT \
  --db-user=$DB_USER \
  --db-password=$DB_PASSWORD \
  --parallel=4

if [ $? -eq 0 ]; then
    log "新节点添加成功"
else
    log "错误：新节点添加失败"
    exit 1
fi

# 配置新节点参数
log "配置新节点参数"
cat > /tmp/new_node_config << EOF
# 备节点优化参数
hot_standby = on
max_standby_streaming_delay = 30s
wal_receiver_buffer_size = 16MB
wal_receiver_status_interval = 10s
hot_standby_feedback = on
EOF

ssh $NEW_NODE_HOST "cat /tmp/new_node_config >> $DATA_DIR/kingbase.conf"
if [ $? -eq 0 ]; then
    log "新节点参数配置成功"
else
    log "警告：新节点参数配置失败"
fi

# 重启新节点使配置生效
log "重启新节点使配置生效"
ssh $NEW_NODE_HOST "$KB_BIN/sys_ctl restart -D $DATA_DIR -m fast"

if [ $? -eq 0 ]; then
    log "新节点重启成功"
else
    log "警告：新节点重启失败"
fi

# 验证新节点状态
log "验证新节点状态"
sleep 10
NEW_NODE_STATUS=$($KB_BIN/ksql -h $NEW_NODE_HOST -p $NEW_NODE_PORT -U $DB_USER -d test -t -c "SELECT pg_is_in_recovery();" << EOF
$DB_PASSWORD
EOF
)

if [ "$NEW_NODE_STATUS" = "t" ]; then
    log "新节点状态正常，已进入恢复模式"
else
    log "警告：新节点未进入恢复模式，状态异常"
fi

# 验证复制状态
log "验证复制状态"
sleep 5
REPLICATION_STATUS=$($KB_BIN/ksql -h $PRIMARY_HOST -p $PRIMARY_PORT -U $DB_USER -d test -t -c "SELECT client_addr, state FROM sys_stat_replication WHERE client_addr = '$NEW_NODE_HOST';" << EOF
$DB_PASSWORD
EOF
)

if [ -n "$REPLICATION_STATUS" ]; then
    log "复制已建立，状态：$REPLICATION_STATUS"
else
    log "警告：未检测到复制连接"
fi

# 查看集群状态
log "查看集群整体状态"
CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
log "$CLUSTER_STATUS"

echo "新节点添加完成，节点：$NEW_NODE_HOST:$NEW_NODE_PORT"
log "新节点添加完成"

移除节点 ​

生产环境移除节点脚本示例：

bash
#!/bin/bash
# KingBaseES 集群移除节点脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
REMOVE_NODE="192.168.1.102"
REMOVE_PORT="54321"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_remove_node_$(date +%Y%m%d).log"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始移除节点：$REMOVE_NODE:$REMOVE_PORT"

# 查看当前集群状态
log "查看当前集群状态"
CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
echo "$CLUSTER_STATUS"
log "$CLUSTER_STATUS"

# 检查要移除的节点是否为主节点
if echo "$CLUSTER_STATUS" | grep -i "primary" | grep -i "$REMOVE_NODE" > /dev/null; then
    log "错误：无法移除主节点 $REMOVE_NODE，请先切换主节点"
    exit 1
fi

# 检查集群中节点数量
NODE_COUNT=$(echo "$CLUSTER_STATUS" | grep -i "node" | wc -l)
if [ $NODE_COUNT -le 2 ]; then
    log "警告：集群中节点数量已不足，移除后可能影响高可用性"
    # 可以添加交互式确认
    # read -p "是否继续？(y/n) " -n 1 -r
    # echo
    # if [[ ! $REPLY =~ ^[Yy]$ ]]; then
    #     log "用户取消了节点移除"
    #     exit 0
    # fi
fi

# 移除节点
log "执行移除节点命令"
$KB_BIN/kbcluster remove-node \
  --cluster-name=$CLUSTER_NAME \
  --node-host=$REMOVE_NODE \
  --node-port=$REMOVE_PORT

if [ $? -eq 0 ]; then
    log "节点移除成功"
else
    log "错误：节点移除失败"
    # 发送告警邮件
    # echo "节点移除失败：$REMOVE_NODE:$REMOVE_PORT" | mail -s "KingBaseES Node Remove Failure" $ALERT_EMAIL
    exit 1
fi

# 验证集群状态
log "验证集群状态"
sleep 10
NEW_CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
log "$NEW_CLUSTER_STATUS"

if echo "$NEW_CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
    log "集群状态正常"
else
    log "警告：集群状态异常"
    # 发送告警邮件
    # echo "集群状态异常" | mail -s "KingBaseES Cluster Status Alert" $ALERT_EMAIL
fi

# 清理移除节点上的数据目录（可选）
log "是否清理移除节点上的数据目录？(y/n)"
# 可以添加交互式确认
# read -p "是否清理移除节点上的数据目录？(y/n) " -n 1 -r
# echo
# if [[ $REPLY =~ ^[Yy]$ ]]; then
#     log "清理移除节点 $REMOVE_NODE 上的数据目录"
#     ssh $REMOVE_NODE "rm -rf /opt/Kingbase/ES/V8/cluster/data /opt/Kingbase/ES/V8/cluster/logs"
#     if [ $? -eq 0 ]; then
#         log "数据目录清理成功"
#     else
#         log "警告：数据目录清理失败"
#     fi
# fi

echo "节点移除完成：$REMOVE_NODE:$REMOVE_PORT"
log "节点移除完成"

集群监控命令 ​

实时监控集群状态 ​

生产环境集群实时监控脚本示例：

bash
#!/bin/bash
# KingBaseES 集群实时监控脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
INTERVAL=2
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_monitor_$(date +%Y%m%d).log"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始实时监控集群：$CLUSTER_NAME，监控间隔：${INTERVAL}秒"

# 创建监控报告目录
REPORT_DIR="/opt/Kingbase/reports/cluster_monitor_$(date +%Y%m%d_%H%M%S)"
mkdir -p $REPORT_DIR
log "监控报告将保存到：$REPORT_DIR"

# 实时监控集群状态
while true; do
    # 获取当前时间
    CURRENT_TIME=$(date '+%Y-%m-%d %H:%M:%S')
    
    # 查看集群状态
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    
    # 输出集群状态
    echo "$CURRENT_TIME - 集群状态："
    echo "$CLUSTER_STATUS"
    echo "========================================"
    
    # 记录集群状态到日志
    log "集群状态："
    log "$CLUSTER_STATUS"
    
    # 检查集群是否正常
    if ! echo "$CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
        log "警告：集群状态异常"
        # 发送告警邮件（每小时最多发送一次）
        if [ ! -f /tmp/cluster_alert_sent ]; then
            # echo "$CLUSTER_STATUS" | mail -s "KingBaseES Cluster Status Alert" $ALERT_EMAIL
            touch /tmp/cluster_alert_sent
            log "已发送集群异常告警邮件"
        fi
    else
        # 清除告警标记
        if [ -f /tmp/cluster_alert_sent ]; then
            rm /tmp/cluster_alert_sent
            log "集群已恢复正常，清除告警标记"
        fi
    fi
    
    # 每10次迭代（20秒）收集一次性能指标
    ITERATION=$((ITERATION + 1))
    if [ $((ITERATION % 10)) -eq 0 ]; then
        log "收集性能指标"
        
        # 查看集群性能指标
        PERFORMANCE_METRICS=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT datname, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched, tup_inserted, tup_updated, tup_deleted FROM sys_stat_database WHERE datname IS NOT NULL;" << EOF
Kingbase@2024
EOF
        )
        
        # 保存性能指标到文件
        METRICS_FILE="$REPORT_DIR/performance_metrics_$(date +%Y%m%d_%H%M%S).txt"
        echo "$CURRENT_TIME - 性能指标：" > $METRICS_FILE
        echo "$PERFORMANCE_METRICS" >> $METRICS_FILE
        log "性能指标已保存到：$METRICS_FILE"
        
        # 查看复制状态
        REPLICATION_STATUS=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT client_addr, application_name, state, sync_state, write_lag, flush_lag, replay_lag FROM sys_stat_replication;" << EOF
Kingbase@2024
EOF
        )
        
        # 保存复制状态到文件
        REPLICATION_FILE="$REPORT_DIR/replication_status_$(date +%Y%m%d_%H%M%S).txt"
        echo "$CURRENT_TIME - 复制状态：" > $REPLICATION_FILE
        echo "$REPLICATION_STATUS" >> $REPLICATION_FILE
        log "复制状态已保存到：$REPLICATION_FILE"
    fi
    
    # 休眠指定间隔
    sleep $INTERVAL
done

查看集群日志 ​

生产环境集群日志分析脚本示例：

bash
#!/bin/bash
# KingBaseES 集群日志分析脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_DIR="/opt/Kingbase/ES/V8/cluster/logs"
KB_LOG_DIR="/opt/Kingbase/ES/V8/cluster/data/sys_log"
LOG_FILE="/opt/Kingbase/logs/cluster_log_analysis_$(date +%Y%m%d).log"
REPORT_DIR="/opt/Kingbase/reports/log_analysis_$(date +%Y%m%d_%H%M%S)"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始分析集群日志"

# 创建报告目录
mkdir -p $REPORT_DIR
log "日志分析报告将保存到：$REPORT_DIR"

# 查看集群管理日志
log "查看集群管理日志"
KBHA_LOG="$LOG_DIR/kbha.log"

if [ -f "$KBHA_LOG" ]; then
    # 查看最近的集群管理日志
    echo "最近的集群管理日志：" > $REPORT_DIR/kbha_log_recent.txt
    tail -n 200 $KBHA_LOG >> $REPORT_DIR/kbha_log_recent.txt
    log "集群管理日志已保存到：$REPORT_DIR/kbha_log_recent.txt"
    
    # 搜索错误日志
    echo "集群管理日志中的错误：" > $REPORT_DIR/kbha_log_errors.txt
    grep -i -E "(error|fatal|panic)" $KBHA_LOG >> $REPORT_DIR/kbha_log_errors.txt
    log "集群管理错误日志已保存到：$REPORT_DIR/kbha_log_errors.txt"
    
    # 搜索故障切换日志
    echo "集群故障切换记录：" > $REPORT_DIR/kbha_log_failover.txt
    grep -i -A 10 -B 5 "failover" $KBHA_LOG >> $REPORT_DIR/kbha_log_failover.txt
    log "集群故障切换记录已保存到：$REPORT_DIR/kbha_log_failover.txt"
else
    log "警告：集群管理日志文件不存在：$KBHA_LOG"
fi

# 查看数据库日志
log "查看数据库日志"
KINGBASE_LOG="$KB_LOG_DIR/kingbase.log"

if [ -f "$KINGBASE_LOG" ]; then
    # 查看最近的数据库日志
    echo "最近的数据库日志：" > $REPORT_DIR/kingbase_log_recent.txt
    tail -n 200 $KINGBASE_LOG >> $REPORT_DIR/kingbase_log_recent.txt
    log "数据库日志已保存到：$REPORT_DIR/kingbase_log_recent.txt"
    
    # 搜索错误日志
    echo "数据库日志中的错误：" > $REPORT_DIR/kingbase_log_errors.txt
    grep -i -E "(error|fatal|panic)" $KINGBASE_LOG >> $REPORT_DIR/kingbase_log_errors.txt
    log "数据库错误日志已保存到：$REPORT_DIR/kingbase_log_errors.txt"
    
    # 搜索慢查询日志
    SLOW_QUERY_LOG="$KB_LOG_DIR/slowquery.log"
    if [ -f "$SLOW_QUERY_LOG" ]; then
        echo "最近的慢查询日志：" > $REPORT_DIR/slow_query_recent.txt
        tail -n 100 $SLOW_QUERY_LOG >> $REPORT_DIR/slow_query_recent.txt
        log "慢查询日志已保存到：$REPORT_DIR/slow_query_recent.txt"
    fi
else
    log "警告：数据库日志文件不存在：$KINGBASE_LOG"
fi

# 查看集群性能日志（如果有）
PERFORMANCE_LOG="$LOG_DIR/performance.log"
if [ -f "$PERFORMANCE_LOG" ]; then
    echo "最近的性能日志：" > $REPORT_DIR/performance_log_recent.txt
    tail -n 200 $PERFORMANCE_LOG >> $REPORT_DIR/performance_log_recent.txt
    log "性能日志已保存到：$REPORT_DIR/performance_log_recent.txt"
fi

log "集群日志分析完成，报告目录：$REPORT_DIR"
echo "集群日志分析报告已生成，保存到：$REPORT_DIR"

# 可选：发送日志分析报告
# tar -zcvf $REPORT_DIR.tar.gz $REPORT_DIR
# echo "集群日志分析报告" | mail -s "KingBaseES Cluster Log Analysis Report" -a $REPORT_DIR.tar.gz $ALERT_EMAIL

集群维护命令 ​

集群健康检查 ​

生产环境集群健康检查脚本示例：

bash
#!/bin/bash
# KingBaseES 集群健康检查脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_health_check_$(date +%Y%m%d).log"
REPORT_DIR="/opt/Kingbase/reports/health_check_$(date +%Y%m%d_%H%M%S)"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始执行集群健康检查：$CLUSTER_NAME"

# 创建报告目录
mkdir -p $REPORT_DIR
log "健康检查报告将保存到：$REPORT_DIR"

# 执行集群健康检查
log "执行集群健康检查命令"
$KB_BIN/kbha check --cluster-name=$CLUSTER_NAME > $REPORT_DIR/cluster_health_check.txt

if [ $? -eq 0 ]; then
    log "集群健康检查通过"
else
    log "警告：集群健康检查未通过"
    # 发送告警邮件
    # cat $REPORT_DIR/cluster_health_check.txt | mail -s "KingBaseES Cluster Health Check Failed" $ALERT_EMAIL
fi

# 检查数据库一致性
log "检查数据库一致性"
CONSISTENCY_CHECK=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT * FROM sys_checksums;" << EOF
Kingbase@2024
EOF
)

echo "数据库一致性检查结果：" > $REPORT_DIR/db_consistency.txt
echo "$CONSISTENCY_CHECK" >> $REPORT_DIR/db_consistency.txt
log "数据库一致性检查已保存到：$REPORT_DIR/db_consistency.txt"

# 检查各节点状态
log "检查各节点状态"
NODES=("192.168.1.100" "192.168.1.101" "192.168.1.102")

for NODE in "${NODES[@]}"; do
    log "检查节点 $NODE 状态"
    
    # 检查网络连通性
    ping -c 3 $NODE > /dev/null 2>&1
    if [ $? -ne 0 ]; then
        log "警告：节点 $NODE 网络不可达"
        continue
    fi
    
    # 检查数据库状态
    SSH_CMD="ssh $NODE \"$KB_BIN/sys_ctl status -D /opt/Kingbase/ES/V8/cluster/data\""
    NODE_STATUS=$(eval $SSH_CMD 2>&1)
    
    echo "节点 $NODE 状态：" > $REPORT_DIR/node_${NODE}_status.txt
    echo "$NODE_STATUS" >> $REPORT_DIR/node_${NODE}_status.txt
    log "节点 $NODE 状态已保存到：$REPORT_DIR/node_${NODE}_status.txt"
    
    # 检查复制状态（备节点）
    if [ "$NODE" != "192.168.1.100" ]; then
        REPLICATION_STATUS=$($KB_BIN/ksql -h $NODE -p 54321 -U system -d test -t -c "SELECT pg_is_in_recovery(), now() - pg_last_xact_replay_timestamp() AS replication_delay;" << EOF
Kingbase@2024
EOF
        )
        echo "节点 $NODE 复制状态：" > $REPORT_DIR/node_${NODE}_replication.txt
        echo "$REPLICATION_STATUS" >> $REPORT_DIR/node_${NODE}_replication.txt
        log "节点 $NODE 复制状态已保存到：$REPORT_DIR/node_${NODE}_replication.txt"
    fi
done

# 检查集群性能指标
log "检查集群性能指标"
PERFORMANCE_METRICS=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT datname, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched FROM sys_stat_database WHERE datname IS NOT NULL;" << EOF
Kingbase@2024
EOF
)

echo "集群性能指标：" > $REPORT_DIR/cluster_performance.txt
echo "$PERFORMANCE_METRICS" >> $REPORT_DIR/cluster_performance.txt
log "集群性能指标已保存到：$REPORT_DIR/cluster_performance.txt"

# 检查锁等待情况
log "检查锁等待情况"
LOCK_WAITS=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT * FROM sys_lock_waits;" << EOF
Kingbase@2024
EOF
)

echo "锁等待情况：" > $REPORT_DIR/cluster_lock_waits.txt
echo "$LOCK_WAITS" >> $REPORT_DIR/cluster_lock_waits.txt
log "锁等待情况已保存到：$REPORT_DIR/cluster_lock_waits.txt"

# 检查长时间运行的事务
log "检查长时间运行的事务"
LONG_TRANS=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT pid, datname, usename, query_start, now() - query_start AS duration, query FROM sys_stat_activity WHERE state IN ('idle in transaction', 'active') AND query_start < now() - interval '5 minutes' ORDER BY duration DESC;" << EOF
Kingbase@2024
EOF
)

echo "长时间运行的事务：" > $REPORT_DIR/cluster_long_trans.txt
echo "$LONG_TRANS" >> $REPORT_DIR/cluster_long_trans.txt
log "长时间运行的事务已保存到：$REPORT_DIR/cluster_long_trans.txt"

log "集群健康检查完成，报告目录：$REPORT_DIR"
echo "集群健康检查报告已生成，保存到：$REPORT_DIR"

# 发送健康检查报告
# tar -zcvf $REPORT_DIR.tar.gz $REPORT_DIR
# echo "集群健康检查报告" | mail -s "KingBaseES Cluster Health Check Report" -a $REPORT_DIR.tar.gz $ALERT_EMAIL

集群版本升级 ​

生产环境集群版本升级脚本示例：

bash
#!/bin/bash
# KingBaseES 集群版本升级脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
NEW_VERSION="V8R7C3"
UPGRADE_PACKAGE="/opt/Kingbase/upgrade/KingbaseES_V8R7C3_Upgrade.tar.gz"
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_upgrade_$(date +%Y%m%d).log"
BACKUP_DIR="/opt/Kingbase/backup/upgrade_backup_$(date +%Y%m%d_%H%M%S)"
ALERT_EMAIL="dba@example.com"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始执行集群版本升级，目标版本：$NEW_VERSION"

# 检查升级包是否存在
if [ ! -f "$UPGRADE_PACKAGE" ]; then
    log "错误：升级包不存在：$UPGRADE_PACKAGE"
    exit 1
fi

# 停止集群监控和其他可能影响升级的进程
log "停止集群监控和其他相关进程"
# 这里可以添加停止监控进程的命令，如 killall -9 cluster_monitor.sh

# 创建升级备份目录
mkdir -p $BACKUP_DIR
log "升级备份将保存到：$BACKUP_DIR"

# 执行升级前备份
log "执行升级前备份"
$KB_BIN/kb_rman backup \
  --cluster-name=$CLUSTER_NAME \
  --backup-type=full \
  --backup-dir=$BACKUP_DIR \
  --compress=on \
  --backup-info=upgrade_pre_backup

if [ $? -ne 0 ]; then
    log "错误：升级前备份失败"
    exit 1
fi

# 执行集群版本升级
log "执行集群版本升级命令"
$KB_BIN/kbcluster upgrade \
  --cluster-name=$CLUSTER_NAME \
  --new-version=$NEW_VERSION \
  --upgrade-package=$UPGRADE_PACKAGE \
  --backup-dir=$BACKUP_DIR \
  --parallel=4

if [ $? -eq 0 ]; then
    log "集群版本升级成功"
else
    log "错误：集群版本升级失败"
    # 发送告警邮件
    # echo "集群版本升级失败" | mail -s "KingBaseES Cluster Upgrade Failure" $ALERT_EMAIL
    exit 1
fi

# 验证升级结果
log "验证升级结果"
UPGRADE_RESULT=$($KB_BIN/ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT version();" << EOF
Kingbase@2024
EOF
)

echo "升级后的版本：" > $BACKUP_DIR/upgrade_result.txt
echo "$UPGRADE_RESULT" >> $BACKUP_DIR/upgrade_result.txt
log "升级结果已保存到：$BACKUP_DIR/upgrade_result.txt"

# 启动集群
log "启动升级后的集群"
$KB_BIN/kbha start --cluster-name=$CLUSTER_NAME

if [ $? -eq 0 ]; then
    log "集群启动成功"
    
    # 验证集群状态
    sleep 10
    CLUSTER_STATUS=$($KB_BIN/kbha status --cluster-name=$CLUSTER_NAME)
    log "$CLUSTER_STATUS"
    
    if echo "$CLUSTER_STATUS" | grep -i "normal" > /dev/null; then
        log "集群状态正常"
    else
        log "警告：集群启动后状态异常"
    fi
else
    log "错误：集群启动失败"
    # 发送告警邮件
    # echo "集群升级后启动失败" | mail -s "KingBaseES Cluster Start Failure" $ALERT_EMAIL
    exit 1
fi

# 执行升级后健康检查
log "执行升级后健康检查"
$KB_BIN/kbha check --cluster-name=$CLUSTER_NAME > $BACKUP_DIR/upgrade_post_check.txt

if [ $? -eq 0 ]; then
    log "升级后健康检查通过"
else
    log "警告：升级后健康检查未通过"
fi

log "集群版本升级完成，备份目录：$BACKUP_DIR"

# 发送升级报告
# tar -zcvf $BACKUP_DIR/upgrade_report.tar.gz $BACKUP_DIR
# echo "集群版本升级报告" | mail -s "KingBaseES Cluster Upgrade Report" -a $BACKUP_DIR/upgrade_report.tar.gz $ALERT_EMAIL

集群配置优化 ​

生产环境集群配置优化脚本示例：

bash
#!/bin/bash
# KingBaseES 集群配置优化脚本

# 配置
CLUSTER_NAME="prod-kbcluster"
WORKLOAD_TYPE="oltp"
CPU_CORES=16
MEMORY_GB=64
KB_BIN="/opt/Kingbase/ES/V8/Server/bin"
LOG_FILE="/opt/Kingbase/logs/cluster_optimize_$(date +%Y%m%d).log"
CONFIG_BACKUP_DIR="/opt/Kingbase/config_backup/optimize_backup_$(date +%Y%m%d_%H%M%S)"

# 日志函数
log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

log "开始执行集群配置优化，工作负载类型：$WORKLOAD_TYPE，CPU核心：$CPU_CORES，内存：${MEMORY_GB}GB"

# 创建配置备份目录
mkdir -p $CONFIG_BACKUP_DIR
log "配置备份将保存到：$CONFIG_BACKUP_DIR"

# 备份当前集群配置
log "备份当前集群配置"
$KB_BIN/kbha config --cluster-name=$CLUSTER_NAME > $CONFIG_BACKUP_DIR/cluster_config_backup.txt

# 备份各节点数据库配置
NODES=("192.168.1.100" "192.168.1.101" "192.168.1.102")

for NODE in "${NODES[@]}"; do
    log "备份节点 $NODE 数据库配置"
    SSH_CMD="ssh $NODE \"cp /opt/Kingbase/ES/V8/cluster/data/kingbase.conf $CONFIG_BACKUP_DIR/kingbase.conf.${NODE}.backup\""
    eval $SSH_CMD
    log "节点 $NODE 配置已备份到：$CONFIG_BACKUP_DIR/kingbase.conf.${NODE}.backup"
done

# 执行集群配置优化
log "执行集群配置优化命令"
$KB_BIN/kbha optimize-config \
  --cluster-name=$CLUSTER_NAME \
  --workload-type=$WORKLOAD_TYPE \
  --cpu-cores=$CPU_CORES \
  --memory-gb=$MEMORY_GB

if [ $? -eq 0 ]; then
    log "集群配置优化成功"
else
    log "错误：集群配置优化失败"
    exit 1
fi

# 查看优化后的配置
log "查看优化后的集群配置"
OPTIMIZED_CONFIG=$($KB_BIN/kbha config --cluster-name=$CLUSTER_NAME)
log "$OPTIMIZED_CONFIG"

# 保存优化后的配置
echo "优化后的集群配置：" > $CONFIG_BACKUP_DIR/cluster_config_optimized.txt
echo "$OPTIMIZED_CONFIG" >> $CONFIG_BACKUP_DIR/cluster_config_optimized.txt
log "优化后的配置已保存到：$CONFIG_BACKUP_DIR/cluster_config_optimized.txt"

# 重载各节点配置
log "重载各节点配置"
for NODE in "${NODES[@]}"; do
    log "重载节点 $NODE 配置"
    SSH_CMD="ssh $NODE \"$KB_BIN/sys_ctl reload -D /opt/Kingbase/ES/V8/cluster/data\""
    eval $SSH_CMD
    if [ $? -eq 0 ]; then
        log "节点 $NODE 配置重载成功"
    else
        log "警告：节点 $NODE 配置重载失败"
    fi
done

# 验证优化效果
log "验证配置优化效果"
# 这里可以添加验证优化效果的命令，如运行性能测试脚本

log "集群配置优化完成，配置备份目录：$CONFIG_BACKUP_DIR"
echo "集群配置优化已完成，配置备份保存到：$CONFIG_BACKUP_DIR"

V8 R6与V8 R7版本差异 ​

功能类别特性V8 R6V8 R7
集群创建与管理集群创建工具使用kbcluster工具，支持基础集群创建增强的kbcluster工具，支持更多集群类型（如多主集群、级联复制），提供更丰富的配置选项
集群配置管理基础的配置修改功能新增配置模板、配置对比和回滚功能，支持批量配置节点
故障切换自动故障切换支持自动故障切换，但可靠性和速度一般增强的自动故障切换，优化了决策算法，减少切换时间，提高可靠性
故障检测机制基于简单的心跳检测新增多维度健康检测（网络、磁盘、数据库状态），降低误切换率
手动切换支持基本的手动切换增强的手动切换，支持预检查和验证，提供更安全的切换流程
复制管理复制类型支持物理复制和逻辑复制新增增量复制、并行复制功能，优化了复制流控算法
复制延迟监控基础的复制延迟查看新增细粒度复制延迟指标（write_lag、flush_lag、replay_lag），支持延迟告警
复制压缩不支持新增复制流量压缩，减少网络带宽消耗
备份恢复集群备份支持全量和增量备份增强的备份策略，支持差异备份、备份集验证、备份加密和压缩
恢复能力基础的时间点恢复支持更灵活的时间点恢复，新增基于备份集的快速恢复
备份管理基础的备份列表和删除功能新增备份集合并、备份集归档、备份策略自动执行
监控与诊断监控指标基础的集群状态和性能指标新增20+细粒度监控指标，包括资源使用、复制性能、锁等待等
监控工具基础的命令行监控新增可视化监控界面，支持监控数据历史存储和趋势分析
诊断工具基础的诊断命令增强的诊断包生成工具，包含更多诊断信息，支持在线诊断和自动分析
集群扩展节点管理支持添加和移除节点，但操作复杂简化的节点添加和移除流程，支持在线扩容和缩容，自动平衡负载
集群拓扑支持主备和级联复制支持更灵活的集群拓扑，如环形复制、星型复制
性能优化事务管理基础的事务处理优化了长事务处理，减少锁冲突，提高并发性能
资源管理基础的资源分配新增资源组功能，支持基于用户和应用的资源隔离和优先级控制
查询优化基础的查询优化器增强的查询优化器，支持更多优化策略，提高复杂查询性能
安全性认证机制支持基本的密码认证新增LDAP、Kerberos认证支持，增强了密码策略和审计功能
加密功能不支持新增数据传输加密、存储加密、备份加密功能
工具链命令行工具基础的命令行工具增强的命令行工具，提供更友好的输出格式，支持命令补全和帮助信息
API支持不支持新增REST API支持，方便集成第三方管理工具

最佳实践 ​

命令使用建议 ​

  1. 定期备份：定期执行集群备份，确保数据安全
  2. 监控集群状态：使用kbha monitor命令实时监控集群状态，及时发现问题
  3. 测试故障切换：定期测试集群故障切换，确保高可用机制正常工作
  4. 记录操作日志：执行重要操作时，记录操作步骤和结果，便于后续分析
  5. 使用绝对路径：执行sys_ctl等命令时，建议使用绝对路径，避免路径问题

常见问题处理 ​

  1. 集群启动失败

    • 检查集群配置文件是否正确
    • 检查节点间网络连接是否正常
    • 检查数据目录权限是否正确

  2. 复制延迟过大

    • 检查网络带宽是否充足
    • 检查备节点性能是否足够
    • 检查主节点写入压力是否过大

  3. 故障切换失败

    • 检查kbha配置是否正确
    • 检查节点间通信是否正常
    • 检查仲裁机制是否正常

常见问题（FAQ） ​

Q1: 如何查看集群的当前主节点和集群状态？ ​

A: 使用以下命令查看集群主节点和整体状态：

bash
# 查看集群完整状态
kbha status --cluster-name=prod-kbcluster

# 只查看当前主节点
kbha status --cluster-name=prod-kbcluster | grep -i "primary"

# 查看各节点角色
ksql -h 192.168.1.100 -p 54321 -U system -d test -t -c "SELECT client_addr, application_name, state FROM sys_stat_replication;"

Q2: 如何手动触发故障切换，确保切换过程安全？ ​

A: 使用kbha switchover命令进行安全的手动切换：

bash
# 执行手动切换前预检查
kbha switchover --cluster-name=prod-kbcluster --target-node=192.168.1.101 --target-port=54321 --check-only

# 执行手动切换
kbha switchover --cluster-name=prod-kbcluster --target-node=192.168.1.101 --target-port=54321

# 验证切换结果
kbha status --cluster-name=prod-kbcluster

Q3: 集群出现复制延迟过大怎么办？ ​

A: 可以通过以下步骤解决复制延迟过大问题：

  1. 检查网络带宽和延迟：ping -c 10 <primary-host>; iperf3 -c <primary-host>
  2. 检查主库WAL生成速度：ksql -U system -d test -c "SELECT * FROM sys_wal_usage;"
  3. 检查备库资源使用：ksql -U system -d test -c "SELECT * FROM sys_os_usage;"
  4. 调整复制参数：wal_receiver_buffer_size = 32MB; wal_receiver_status_interval = 5s
  5. 考虑使用并行复制：max_wal_senders = 10; max_replication_slots = 10

Q4: 如何检查集群节点间的网络连接和通信状态？ ​

A: 使用以下命令检查节点间网络连接和通信：

bash
# 检查网络连通性
for node in 192.168.1.100 192.168.1.101 192.168.1.102; do
    ping -c 5 $node
    echo "========================================"
done

# 检查数据库端口可达性
for node in 192.168.1.100 192.168.1.101 192.168.1.102; do
    telnet $node 54321 <<EOF
quit
EOF
done

# 检查集群内部通信
kbha check --cluster-name=prod-kbcluster

Q5: 如何查看集群的历史事件和故障记录？ ​

A: 使用以下命令查看集群历史事件：

bash
# 查看集群历史事件
kbha history --cluster-name=prod-kbcluster --days=7

# 查看集群管理日志中的故障记录
grep -i -A 10 -B 5 "failover" /opt/Kingbase/ES/V8/cluster/logs/kbha.log

# 查看数据库日志中的相关记录
grep -i -E "replication|wal" /opt/Kingbase/ES/V8/cluster/data/sys_log/kingbase.log

Q6: 如何修改集群的仲裁配置和故障检测参数？ ​

A: 使用kbha modify-config命令修改集群配置：

bash
# 修改仲裁配置
kbha modify-config --cluster-name=prod-kbcluster --parameter=ha_quorum_type=majority

# 修改故障检测参数
kbha modify-config --cluster-name=prod-kbcluster \
  --parameter=ha_check_interval=3 \
  --parameter=ha_retry_count=5 \
  --parameter=ha_failover_timeout=60

# 查看修改后的配置
kbha config --cluster-name=prod-kbcluster

Q7: 如何重建故障的备节点，确保数据一致性？ ​

A: 使用以下步骤重建故障备节点：

bash
# 1. 停止故障备节点
sys_ctl stop -D /opt/Kingbase/ES/V8/cluster/data -m fast

# 2. 清理备节点数据目录
rm -rf /opt/Kingbase/ES/V8/cluster/data/*

# 3. 重建备节点
kbcluster rebuild-standby \
  --cluster-name=prod-kbcluster \
  --standby-host=192.168.1.101 \
  --standby-port=54321 \
  --primary-host=192.168.1.100 \
  --primary-port=54321 \
  --db-user=system \
  --db-password=Kingbase@2024

# 4. 验证备节点状态
ksql -h 192.168.1.101 -p 54321 -U system -d test -c "SELECT pg_is_in_recovery();"

# 5. 验证复制状态
ksql -h 192.168.1.100 -p 54321 -U system -d test -c "SELECT client_addr, state FROM sys_stat_replication;"

Q8: 如何查看和优化集群的资源使用情况？ ​

A: 使用以下命令查看和优化集群资源使用：

bash
# 查看CPU和内存使用情况
ksql -U system -d test -c "SELECT * FROM sys_os_usage;"

# 查看磁盘使用情况
ksql -U system -d test -c "SELECT * FROM sys_disk_usage;"

# 查看表空间使用情况
ksql -U system -d test -c "SELECT spcname, size_mb, used_mb, round(used_mb::numeric/size_mb::numeric*100, 2) AS usage_percent FROM sys_tablespace_usage;"

# 优化资源配置
tuned-adm profile enterprise-storage

Q9: 如何升级集群的版本，确保升级过程安全？ ​

A: 按照以下步骤安全升级集群版本：

bash
# 1. 备份集群
kb_rman backup --cluster-name=prod-kbcluster --backup-type=full --backup-dir=/opt/Kingbase/backup/upgrade_backup

# 2. 停止集群监控和业务
systemctl stop cluster-monitor

# 3. 执行版本升级
kbcluster upgrade \
  --cluster-name=prod-kbcluster \
  --new-version=V8R7C3 \
  --upgrade-package=/opt/Kingbase/upgrade/KingbaseES_V8R7C3_Upgrade.tar.gz \
  --backup-dir=/opt/Kingbase/backup/upgrade_backup

# 4. 启动集群
kbha start --cluster-name=prod-kbcluster

# 5. 验证升级结果
kbha status --cluster-name=prod-kbcluster
ksql -U system -d test -c "SELECT version();"

Q10: 集群出现脑裂怎么办？ ​

A: 按照以下步骤修复集群脑裂：

bash
# 1. 停止所有节点的数据库服务
for node in 192.168.1.100 192.168.1.101; do
    ssh $node "sys_ctl stop -D /opt/Kingbase/ES/V8/cluster/data -m fast"
done

# 2. 选择正确的主节点，修复脑裂
kbha fix-split-brain \
  --cluster-name=prod-kbcluster \
  --primary-node=192.168.1.100 \
  --primary-port=54321 \
  --force

# 3. 启动集群
kbha start --cluster-name=prod-kbcluster

# 4. 验证集群状态
kbha status --cluster-name=prod-kbcluster

Q11: 如何监控集群的复制延迟？ ​

A: 使用以下命令监控集群复制延迟：

bash
# 在主节点查看所有备节点复制状态
ksql -U system -d test -c "SELECT client_addr, sync_state, write_lag, flush_lag, replay_lag FROM sys_stat_replication;"

# 在备节点查看自身复制延迟
ksql -U system -d test -c "SELECT extract(epoch FROM (now() - pg_last_xact_replay_timestamp())) AS replication_delay_seconds;"

# 使用kbha查看复制状态
kbha replication-status --cluster-name=prod-kbcluster

Q12: 如何添加新的备节点到现有集群？ ​

A: 使用以下步骤添加新备节点：

bash
# 1. 在新节点上创建必要目录
mkdir -p /opt/Kingbase/ES/V8/cluster/data /opt/Kingbase/ES/V8/cluster/logs

# 2. 添加新节点到集群
kbcluster add-node \
  --cluster-name=prod-kbcluster \
  --node-type=standby \
  --node-host=192.168.1.102 \
  --node-port=54321 \
  --data-dir=/opt/Kingbase/ES/V8/cluster/data \
  --log-dir=/opt/Kingbase/ES/V8/cluster/logs \
  --primary-host=192.168.1.100 \
  --primary-port=54321 \
  --db-user=system \
  --db-password=Kingbase@2024

# 3. 验证新节点状态
ksql -h 192.168.1.102 -p 54321 -U system -d test -c "SELECT pg_is_in_recovery();"

# 4. 验证复制状态
ksql -h 192.168.1.100 -p 54321 -U system -d test -c "SELECT client_addr, state FROM sys_stat_replication;"

Q13: 如何移除集群中的一个备节点？ ​

A: 使用以下步骤移除备节点：

bash
# 1. 检查要移除的节点是否为主节点
kbha status --cluster-name=prod-kbcluster | grep -i "primary"

# 2. 移除备节点
kbcluster remove-node \
  --cluster-name=prod-kbcluster \
  --node-host=192.168.1.102 \
  --node-port=54321

# 3. 验证节点已移除
kbha status --cluster-name=prod-kbcluster

# 4. 清理节点数据（可选）
ssh 192.168.1.102 "rm -rf /opt/Kingbase/ES/V8/cluster/data /opt/Kingbase/ES/V8/cluster/logs"

Q14: 如何执行集群的健康检查？ ​

A: 使用以下命令执行集群健康检查：

bash
# 执行集群健康检查
kbha check --cluster-name=prod-kbcluster

# 检查数据库一致性
ksql -U system -d test -c "SELECT * FROM sys_checksums;"

# 检查各节点状态
for node in 192.168.1.100 192.168.1.101; do
    ssh $node "sys_ctl status -D /opt/Kingbase/ES/V8/cluster/data"
done

# 检查复制状态
kbha replication-status --cluster-name=prod-kbcluster

Q15: 如何优化集群的性能？ ​

A: 可以通过以下方式优化集群性能：

  1. 调整数据库参数：shared_buffers = 16GB; work_mem = 64MB; effective_cache_size = 48GB
  2. 优化存储：使用SSD存储，调整RAID级别
  3. 调整复制参数：wal_compression = on; max_wal_senders = 10
  4. 优化查询：创建适当的索引，优化慢查询
  5. 使用连接池：如PgBouncer或Pgpool-II
  6. 配置资源隔离：使用cgroups或资源组
  7. 定期维护：执行VACUUM和ANALYZE，重建索引
  8. 监控性能：使用pg_stat_statements和pg_stat_monitor分析性能瓶颈

Q16: 如何备份和恢复集群？ ​

A: 使用以下命令备份和恢复集群：

bash
# 执行全量备份
kb_rman backup \
  --cluster-name=prod-kbcluster \
  --backup-type=full \
  --backup-dir=/opt/Kingbase/backup \
  --compress=on

# 执行增量备份
kb_rman backup \
  --cluster-name=prod-kbcluster \
  --backup-type=incremental \
  --backup-dir=/opt/Kingbase/backup \
  --compress=on

# 从备份恢复集群
kb_rman restore \
  --cluster-name=prod-kbcluster \
  --backup-dir=/opt/Kingbase/backup \
  --restore-time="2023-05-01 12:00:00" \
  --parallel=4

Q17: 如何配置集群的自动故障切换？ ​

A: 使用以下命令配置集群自动故障切换：

bash
# 修改自动故障切换配置
kbha modify-config \
  --cluster-name=prod-kbcluster \
  --parameter=ha_failover_enabled=true \
  --parameter=ha_check_interval=3 \
  --parameter=ha_retry_count=5 \
  --parameter=ha_failover_timeout=60 \
  --parameter=ha_quorum_type=majority

# 查看配置
kbha config --cluster-name=prod-kbcluster | grep -i failover

Q18: 如何监控集群的性能指标？ ​

A: 使用以下命令和工具监控集群性能：

bash
# 查看集群性能指标
ksql -U system -d test -c "SELECT * FROM sys_stat_database;"

# 查看TOP SQL
ksql -U system -d test -c "SELECT queryid, calls, total_time, mean_time, rows, left(query, 100) AS query_sample FROM sys_stat_statements ORDER BY total_time DESC LIMIT 10;"

# 查看锁等待
ksql -U system -d test -c "SELECT * FROM sys_lock_waits;"

# 使用pg_stat_monitor（V8 R7）
ksql -U system -d test -c "SELECT * FROM pg_stat_monitor ORDER BY total_time DESC LIMIT 10;"

# 使用监控脚本
./cluster_monitor.sh --interval=2 --cluster-name=prod-kbcluster

总结 ​

KingBaseES集群管理命令是管理KingBaseES高可用集群的重要工具，掌握这些命令对于保障集群的高可用性和稳定性至关重要。本文介绍了KingBaseES集群管理的常用命令，包括集群创建、节点管理、状态监控、故障处理等功能。在实际使用中，应根据具体的集群环境和需求，选择合适的命令进行操作，并遵循最佳实践，确保集群的安全和稳定运行。