1. 多数据库架构概述

在现代企业应用中，往往需要同时使用多种数据库技术来满足不同的业务需求。MongoDB用于文档存储，Kafka用于消息队列，Redis用于缓存，MySQL用于关系型数据存储。本文将详细介绍多数据库环境的运维实战经验，包括环境部署、数据同步、统一监控、运维管理的完整解决方案。

1.1 核心功能

  1. 多数据库部署: 统一部署MongoDB、Kafka、Redis、MySQL
  2. 数据同步: 实现不同数据库间的数据同步和集成
  3. 统一监控: 建立多数据库的统一监控体系
  4. 运维管理: 提供多数据库的统一运维管理方案
  5. 高可用保障: 确保多数据库系统的高可用性

1.2 技术架构

1
2
3
4
5
应用层 → MongoDB(文档) → Kafka(消息) → Redis(缓存) → MySQL(关系)
  ↓         ↓           ↓           ↓         ↓
数据同步 → 消息传递 → 缓存更新 → 数据持久化 → 监控告警
  ↓         ↓           ↓           ↓         ↓
统一监控 → 运维管理 → 故障处理 → 性能优化 → 备份恢复

2. 环境准备

2.1 多数据库环境检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
#!/bin/bash
# check_multi_db_env.sh - 多数据库环境检查脚本
# @author 运维实战

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

# 检查系统环境
check_system_environment() {
    log "开始检查多数据库系统环境..."
    
    # 检查操作系统
    if [[ "$OSTYPE" == "linux-gnu"* ]]; then
        OS_VERSION=$(cat /etc/os-release | grep PRETTY_NAME | cut -d'"' -f2)
        log "操作系统: $OS_VERSION"
    else
        log "错误: 不支持的操作系统 $OSTYPE"
        exit 1
    fi
    
    # 检查系统资源
    TOTAL_MEM=$(free -h | grep "Mem:" | awk '{print $2}')
    AVAILABLE_MEM=$(free -h | grep "Mem:" | awk '{print $7}')
    CPU_CORES=$(nproc)
    DISK_SPACE=$(df -h / | tail -1 | awk '{print $4}')
    
    log "系统资源检查:"
    log "  总内存: $TOTAL_MEM"
    log "  可用内存: $AVAILABLE_MEM"
    log "  CPU核心数: $CPU_CORES"
    log "  可用磁盘空间: $DISK_SPACE"
    
    # 检查网络连通性
    check_network_connectivity
}

# 检查网络连通性
check_network_connectivity() {
    log "检查网络连通性..."
    
    # 检查数据库节点间网络
    DB_NODES=("192.168.1.10" "192.168.1.11" "192.168.1.12")
    
    for node in "${DB_NODES[@]}"; do
        if ping -c 3 $node > /dev/null 2>&1; then
            log "节点网络连通正常: $node"
        else
            log "警告: 节点网络连通异常: $node"
        fi
    done
    
    # 检查端口可用性
    check_port_availability
}

# 检查端口可用性
check_port_availability() {
    log "检查多数据库端口可用性..."
    
    # MongoDB端口
    MONGODB_PORTS=(27017 27018 27019)
    # Kafka端口
    KAFKA_PORTS=(9092 9093 9094)
    # Redis端口
    REDIS_PORTS=(6379 6380 6381)
    # MySQL端口
    MYSQL_PORTS=(3306 3307 3308)
    
    ALL_PORTS=("${MONGODB_PORTS[@]}" "${KAFKA_PORTS[@]}" "${REDIS_PORTS[@]}" "${MYSQL_PORTS[@]}")
    
    for port in "${ALL_PORTS[@]}"; do
        if netstat -tlnp | grep ":$port " > /dev/null; then
            log "警告: 端口 $port 已被占用"
        else
            log "端口 $port 可用"
        fi
    done
}

# 检查数据库安装
check_database_installation() {
    log "检查多数据库安装状态..."
    
    # 检查MongoDB
    if command -v mongod > /dev/null 2>&1; then
        MONGODB_VERSION=$(mongod --version | head -1)
        log "MongoDB已安装: $MONGODB_VERSION"
    else
        log "MongoDB未安装，开始安装..."
        install_mongodb
    fi
    
    # 检查Kafka
    if [ -d "/opt/kafka" ]; then
        log "Kafka已安装"
    else
        log "Kafka未安装，开始安装..."
        install_kafka
    fi
    
    # 检查Redis
    if command -v redis-server > /dev/null 2>&1; then
        REDIS_VERSION=$(redis-server --version | head -1)
        log "Redis已安装: $REDIS_VERSION"
    else
        log "Redis未安装，开始安装..."
        install_redis
    fi
    
    # 检查MySQL
    if command -v mysql > /dev/null 2>&1; then
        MYSQL_VERSION=$(mysql --version)
        log "MySQL已安装: $MYSQL_VERSION"
    else
        log "MySQL未安装，开始安装..."
        install_mysql
    fi
}

# 安装MongoDB
install_mongodb() {
    log "开始安装MongoDB..."
    
    # 添加MongoDB官方仓库
    wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
    echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
    
    # 更新包管理器
    sudo apt-get update
    
    # 安装MongoDB
    sudo apt-get install -y mongodb-org
    
    # 启动MongoDB服务
    sudo systemctl start mongod
    sudo systemctl enable mongod
    
    log "MongoDB安装完成"
}

# 安装Kafka
install_kafka() {
    log "开始安装Kafka..."
    
    # 下载Kafka
    wget https://downloads.apache.org/kafka/2.8.1/kafka_2.13-2.8.1.tgz
    tar -xzf kafka_2.13-2.8.1.tgz
    mv kafka_2.13-2.8.1 /opt/kafka
    
    # 创建Kafka用户
    sudo useradd -r -s /bin/false kafka
    sudo chown -R kafka:kafka /opt/kafka
    
    # 创建Kafka服务
    cat > /etc/systemd/system/kafka.service << EOF
[Unit]
Description=Apache Kafka
After=network.target

[Service]
Type=simple
User=kafka
ExecStart=/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/server.properties
Restart=always

[Install]
WantedBy=multi-user.target
EOF
    
    # 启动Kafka服务
    sudo systemctl daemon-reload
    sudo systemctl start kafka
    sudo systemctl enable kafka
    
    log "Kafka安装完成"
}

# 安装Redis
install_redis() {
    log "开始安装Redis..."
    
    # 更新包管理器
    sudo apt-get update
    sudo apt-get install -y redis-server
    
    # 启动Redis服务
    sudo systemctl start redis
    sudo systemctl enable redis
    
    log "Redis安装完成"
}

# 安装MySQL
install_mysql() {
    log "开始安装MySQL..."
    
    # 更新包管理器
    sudo apt-get update
    sudo apt-get install -y mysql-server
    
    # 启动MySQL服务
    sudo systemctl start mysql
    sudo systemctl enable mysql
    
    # 安全配置
    sudo mysql_secure_installation
    
    log "MySQL安装完成"
}

# 主函数
main() {
    log "=== 多数据库环境检查开始 ==="
    check_system_environment
    check_database_installation
    log "=== 多数据库环境检查完成 ==="
}

# 执行主函数
main "$@"

2.2 多数据库配置优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
#!/bin/bash
# multi_db_config.sh - 多数据库配置优化脚本
# @author 运维实战

# 配置参数
MONGODB_PORT=27017
KAFKA_PORT=9092
REDIS_PORT=6379
MYSQL_PORT=3306

# 备份配置文件
backup_config_files() {
    log "备份多数据库配置文件..."
    
    # 备份MongoDB配置
    if [ -f "/etc/mongod.conf" ]; then
        sudo cp /etc/mongod.conf /etc/mongod.conf.backup.$(date +%Y%m%d_%H%M%S)
        log "MongoDB配置文件已备份"
    fi
    
    # 备份Kafka配置
    if [ -f "/opt/kafka/config/server.properties" ]; then
        sudo cp /opt/kafka/config/server.properties /opt/kafka/config/server.properties.backup.$(date +%Y%m%d_%H%M%S)
        log "Kafka配置文件已备份"
    fi
    
    # 备份Redis配置
    if [ -f "/etc/redis/redis.conf" ]; then
        sudo cp /etc/redis/redis.conf /etc/redis/redis.conf.backup.$(date +%Y%m%d_%H%M%S)
        log "Redis配置文件已备份"
    fi
    
    # 备份MySQL配置
    if [ -f "/etc/mysql/mysql.conf.d/mysqld.cnf" ]; then
        sudo cp /etc/mysql/mysql.conf.d/mysqld.cnf /etc/mysql/mysql.conf.d/mysqld.cnf.backup.$(date +%Y%m%d_%H%M%S)
        log "MySQL配置文件已备份"
    fi
}

# 配置MongoDB
configure_mongodb() {
    log "配置MongoDB..."
    
    cat > /etc/mongod.conf << EOF
# MongoDB配置
storage:
  dbPath: /var/lib/mongodb
  journal:
    enabled: true
  wiredTiger:
    engineConfig:
      cacheSizeGB: 2
      journalCompressor: snappy
      directoryForIndexes: false
    collectionConfig:
      blockCompressor: snappy
    indexConfig:
      prefixCompression: true

systemLog:
  destination: file
  logAppend: true
  path: /var/log/mongodb/mongod.log
  logRotate: reopen

net:
  port: $MONGODB_PORT
  bindIp: 0.0.0.0
  maxIncomingConnections: 1000

processManagement:
  timeZoneInfo: /usr/share/zoneinfo

replication:
  replSetName: rs0

security:
  authorization: enabled
  keyFile: /etc/mongodb-keyfile

operationProfiling:
  slowOpThresholdMs: 100
  mode: slowOp

setParameter:
  enableLocalhostAuthBypass: false
EOF
    
    log "MongoDB配置完成"
}

# 配置Kafka
configure_kafka() {
    log "配置Kafka..."
    
    cat > /opt/kafka/config/server.properties << EOF
# Kafka配置
broker.id=0
listeners=PLAINTEXT://0.0.0.0:$KAFKA_PORT
advertised.listeners=PLAINTEXT://192.168.1.10:$KAFKA_PORT
num.network.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
log.dirs=/opt/kafka/logs
num.partitions=3
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=3
transaction.state.log.replication.factor=3
transaction.state.log.min.isr=2
log.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
zookeeper.connect=localhost:2181
zookeeper.connection.timeout.ms=18000
group.initial.rebalance.delay.ms=0
EOF
    
    log "Kafka配置完成"
}

# 配置Redis
configure_redis() {
    log "配置Redis..."
    
    cat > /etc/redis/redis.conf << EOF
# Redis配置
bind 0.0.0.0
port $REDIS_PORT
timeout 300
tcp-keepalive 300

# 内存配置
maxmemory 2gb
maxmemory-policy allkeys-lru

# 持久化配置
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec

# 主从复制配置
replica-read-only yes
replica-serve-stale-data yes

# 安全配置
requirepass redis123

# 日志配置
loglevel notice
logfile /var/log/redis/redis-server.log

# 其他配置
daemonize yes
pidfile /var/run/redis/redis-server.pid
dir /var/lib/redis
EOF
    
    log "Redis配置完成"
}

# 配置MySQL
configure_mysql() {
    log "配置MySQL..."
    
    cat > /etc/mysql/mysql.conf.d/mysqld.cnf << EOF
# MySQL配置
[mysqld]
user = mysql
pid-file = /var/run/mysqld/mysqld.pid
socket = /var/run/mysqld/mysqld.sock
port = $MYSQL_PORT
basedir = /usr
datadir = /var/lib/mysql
tmpdir = /tmp
lc-messages-dir = /usr/share/mysql
skip-external-locking

# 性能优化
key_buffer_size = 256M
max_allowed_packet = 64M
table_open_cache = 256
sort_buffer_size = 2M
read_buffer_size = 2M
read_rnd_buffer_size = 8M
myisam_sort_buffer_size = 64M
thread_cache_size = 8
query_cache_size = 64M
tmp_table_size = 64M
max_heap_table_size = 64M

# 连接配置
max_connections = 1000
max_connect_errors = 1000
wait_timeout = 28800
interactive_timeout = 28800

# 日志配置
log-error = /var/log/mysql/error.log
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2

# 二进制日志
log-bin = mysql-bin
binlog_format = ROW
expire_logs_days = 7
max_binlog_size = 100M

# InnoDB配置
innodb_buffer_pool_size = 1G
innodb_log_file_size = 256M
innodb_log_buffer_size = 8M
innodb_flush_log_at_trx_commit = 1
innodb_lock_wait_timeout = 50

[mysql]
no-auto-rehash

[myisamchk]
key_buffer_size = 128M
sort_buffer_size = 128M
read_buffer = 2M
write_buffer = 2M

[mysqlhotcopy]
interactive-timeout
EOF
    
    log "MySQL配置完成"
}

# 创建认证密钥文件
create_keyfile() {
    log "创建MongoDB认证密钥文件..."
    
    # 生成随机密钥
    openssl rand -base64 756 > /etc/mongodb-keyfile
    chmod 600 /etc/mongodb-keyfile
    chown mongodb:mongodb /etc/mongodb-keyfile
    
    log "认证密钥文件创建完成"
}

# 启动服务
start_services() {
    log "启动多数据库服务..."
    
    # 启动MongoDB服务
    systemctl restart mongod
    systemctl enable mongod
    
    # 启动Kafka服务
    systemctl restart kafka
    systemctl enable kafka
    
    # 启动Redis服务
    systemctl restart redis
    systemctl enable redis
    
    # 启动MySQL服务
    systemctl restart mysql
    systemctl enable mysql
    
    # 检查服务状态
    sleep 5
    
    if systemctl is-active --quiet mongod; then
        log "MongoDB服务启动成功"
    else
        log "错误: MongoDB服务启动失败"
    fi
    
    if systemctl is-active --quiet kafka; then
        log "Kafka服务启动成功"
    else
        log "错误: Kafka服务启动失败"
    fi
    
    if systemctl is-active --quiet redis; then
        log "Redis服务启动成功"
    else
        log "错误: Redis服务启动失败"
    fi
    
    if systemctl is-active --quiet mysql; then
        log "MySQL服务启动成功"
    else
        log "错误: MySQL服务启动失败"
    fi
}

# 主函数
main() {
    log "=== 多数据库配置优化开始 ==="
    backup_config_files
    configure_mongodb
    configure_kafka
    configure_redis
    configure_mysql
    create_keyfile
    start_services
    log "=== 多数据库配置优化完成 ==="
}

# 执行主函数
main "$@"

3. 数据同步管理

3.1 数据同步脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
#!/bin/bash
# multi_db_sync.sh - 多数据库数据同步脚本
# @author 运维实战

# 配置参数
MONGODB_HOST="192.168.1.10:27017"
KAFKA_HOST="192.168.1.10:9092"
REDIS_HOST="192.168.1.10:6379"
MYSQL_HOST="192.168.1.10:3306"
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"
REDIS_PASSWORD="redis123"
MYSQL_USER="root"
MYSQL_PASSWORD="mysql123"

# 检查数据库连接
check_database_connections() {
    log "检查多数据库连接..."
    
    # 检查MongoDB连接
    if mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --eval "db.runCommand('ping')" > /dev/null 2>&1; then
        log "MongoDB连接正常"
    else
        log "错误: MongoDB连接失败"
        return 1
    fi
    
    # 检查Kafka连接
    if /opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list > /dev/null 2>&1; then
        log "Kafka连接正常"
    else
        log "错误: Kafka连接失败"
        return 1
    fi
    
    # 检查Redis连接
    if redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD ping > /dev/null 2>&1; then
        log "Redis连接正常"
    else
        log "错误: Redis连接失败"
        return 1
    fi
    
    # 检查MySQL连接
    if mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT 1;" > /dev/null 2>&1; then
        log "MySQL连接正常"
    else
        log "错误: MySQL连接失败"
        return 1
    fi
}

# MongoDB到MySQL数据同步
sync_mongodb_to_mysql() {
    log "开始MongoDB到MySQL数据同步..."
    
    # 创建同步表
    mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "
        CREATE DATABASE IF NOT EXISTS sync_db;
        USE sync_db;
        CREATE TABLE IF NOT EXISTS mongodb_sync (
            id VARCHAR(255) PRIMARY KEY,
            collection_name VARCHAR(255),
            document_data JSON,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
        );
    "
    
    # 同步数据
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --eval "
        use test_db;
        db.test_collection.find().forEach(function(doc) {
            var data = {
                id: doc._id.toString(),
                collection_name: 'test_collection',
                document_data: JSON.stringify(doc)
            };
            
            // 这里应该调用MySQL插入操作
            print('同步文档: ' + doc._id);
        });
    "
    
    log "MongoDB到MySQL数据同步完成"
}

# MySQL到Redis数据同步
sync_mysql_to_redis() {
    log "开始MySQL到Redis数据同步..."
    
    # 获取MySQL数据
    mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "
        USE sync_db;
        SELECT id, collection_name, document_data FROM mongodb_sync;
    " | while read id collection_name document_data; do
        if [ "$id" != "id" ]; then
            # 同步到Redis
            redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD set "sync:$id" "$document_data"
            log "同步数据到Redis: $id"
        fi
    done
    
    log "MySQL到Redis数据同步完成"
}

# Redis到Kafka消息发送
send_redis_to_kafka() {
    log "开始Redis到Kafka消息发送..."
    
    # 创建Kafka主题
    /opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --create --topic redis_sync --partitions 3 --replication-factor 1 --if-not-exists
    
    # 获取Redis数据并发送到Kafka
    redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD keys "sync:*" | while read key; do
        value=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD get "$key")
        
        # 发送消息到Kafka
        echo "$value" | /opt/kafka/bin/kafka-console-producer.sh --bootstrap-server $KAFKA_HOST --topic redis_sync
        
        log "发送消息到Kafka: $key"
    done
    
    log "Redis到Kafka消息发送完成"
}

# Kafka到MongoDB消息消费
consume_kafka_to_mongodb() {
    log "开始Kafka到MongoDB消息消费..."
    
    # 消费Kafka消息并写入MongoDB
    /opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server $KAFKA_HOST --topic redis_sync --from-beginning | while read message; do
        # 解析消息并写入MongoDB
        mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --eval "
            use sync_db;
            var doc = JSON.parse('$message');
            db.kafka_sync.insertOne(doc);
        "
        
        log "消费消息并写入MongoDB: $message"
    done
    
    log "Kafka到MongoDB消息消费完成"
}

# 全量数据同步
full_sync() {
    log "开始全量数据同步..."
    
    # 检查数据库连接
    if ! check_database_connections; then
        log "错误: 数据库连接失败，无法进行数据同步"
        return 1
    fi
    
    # 执行数据同步
    sync_mongodb_to_mysql
    sync_mysql_to_redis
    send_redis_to_kafka
    
    log "全量数据同步完成"
}

# 增量数据同步
incremental_sync() {
    log "开始增量数据同步..."
    
    # 检查数据库连接
    if ! check_database_connections; then
        log "错误: 数据库连接失败，无法进行数据同步"
        return 1
    fi
    
    # 获取上次同步时间
    LAST_SYNC_TIME=$(date -d "1 hour ago" +"%Y-%m-%d %H:%M:%S")
    
    # 同步增量数据
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --eval "
        use test_db;
        db.test_collection.find({updated_at: {\$gte: new Date('$LAST_SYNC_TIME')}}).forEach(function(doc) {
            print('增量同步文档: ' + doc._id);
        });
    "
    
    log "增量数据同步完成"
}

# 主函数
main() {
    case $1 in
        "check")
            check_database_connections
            ;;
        "full")
            full_sync
            ;;
        "incremental")
            incremental_sync
            ;;
        "mongodb-mysql")
            sync_mongodb_to_mysql
            ;;
        "mysql-redis")
            sync_mysql_to_redis
            ;;
        "redis-kafka")
            send_redis_to_kafka
            ;;
        "kafka-mongodb")
            consume_kafka_to_mongodb
            ;;
        *)
            echo "用法: $0 {check|full|incremental|mongodb-mysql|mysql-redis|redis-kafka|kafka-mongodb}"
            echo "  check - 检查数据库连接"
            echo "  full - 全量数据同步"
            echo "  incremental - 增量数据同步"
            echo "  mongodb-mysql - MongoDB到MySQL同步"
            echo "  mysql-redis - MySQL到Redis同步"
            echo "  redis-kafka - Redis到Kafka同步"
            echo "  kafka-mongodb - Kafka到MongoDB同步"
            ;;
    esac
}

# 执行主函数
main "$@"

3.2 数据同步监控脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
#!/bin/bash
# multi_db_sync_monitor.sh - 多数据库数据同步监控脚本
# @author 运维实战

# 监控配置
MONGODB_HOST="192.168.1.10:27017"
KAFKA_HOST="192.168.1.10:9092"
REDIS_HOST="192.168.1.10:6379"
MYSQL_HOST="192.168.1.10:3306"
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"
REDIS_PASSWORD="redis123"
MYSQL_USER="root"
MYSQL_PASSWORD="mysql123"
MONITOR_INTERVAL=30
LOG_FILE="/var/log/multi-db-sync-monitor.log"

# 记录监控数据
log_sync_data() {
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local metric=$1
    local value=$2
    local database=$3
    
    echo "[$timestamp] Database:$database Metric:$metric Value:$value" >> $LOG_FILE
}

# 监控数据同步状态
monitor_sync_status() {
    log "开始监控多数据库数据同步状态..."
    
    while true; do
        # 监控MongoDB状态
        MONGODB_STATUS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
            db.runCommand('ping').ok;
        ")
        
        log_sync_data "status" $MONGODB_STATUS "mongodb"
        
        # 监控Kafka状态
        KAFKA_TOPICS=$(/opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list | wc -l)
        log_sync_data "topics_count" $KAFKA_TOPICS "kafka"
        
        # 监控Redis状态
        REDIS_STATUS=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD ping)
        log_sync_data "status" $REDIS_STATUS "redis"
        
        # 监控MySQL状态
        MYSQL_STATUS=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT 1;" 2>/dev/null | wc -l)
        log_sync_data "status" $MYSQL_STATUS "mysql"
        
        # 监控数据同步延迟
        monitor_sync_lag
        
        sleep $MONITOR_INTERVAL
    done
}

# 监控数据同步延迟
monitor_sync_lag() {
    # 监控MongoDB到MySQL同步延迟
    MONGODB_COUNT=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
        db.test_collection.count();
    ")
    
    MYSQL_COUNT=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT COUNT(*) FROM sync_db.mongodb_sync;" 2>/dev/null | tail -1)
    
    if [ "$MONGODB_COUNT" != "$MYSQL_COUNT" ]; then
        SYNC_LAG=$((MONGODB_COUNT - MYSQL_COUNT))
        log_sync_data "sync_lag" $SYNC_LAG "mongodb-mysql"
    fi
    
    # 监控MySQL到Redis同步延迟
    REDIS_COUNT=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD keys "sync:*" | wc -l)
    
    if [ "$MYSQL_COUNT" != "$REDIS_COUNT" ]; then
        SYNC_LAG=$((MYSQL_COUNT - REDIS_COUNT))
        log_sync_data "sync_lag" $SYNC_LAG "mysql-redis"
    fi
}

# 生成同步报告
generate_sync_report() {
    local report_file="/var/log/multi-db-sync-report-$(date +%Y%m%d).txt"
    
    log "生成多数据库同步报告: $report_file"
    
    cat > $report_file << EOF
多数据库同步监控报告
生成时间: $(date)
========================================

EOF
    
    # MongoDB状态
    echo "MongoDB状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --eval "db.stats()" >> $report_file
    echo "" >> $report_file
    
    # Kafka状态
    echo "Kafka状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    /opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list >> $report_file
    echo "" >> $report_file
    
    # Redis状态
    echo "Redis状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD info >> $report_file
    echo "" >> $report_file
    
    # MySQL状态
    echo "MySQL状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SHOW STATUS;" >> $report_file
    echo "" >> $report_file
    
    # 同步统计
    echo "同步统计:" >> $report_file
    echo "----------------------------------------" >> $report_file
    
    # 计算同步延迟
    MONGODB_COUNT=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
        db.test_collection.count();
    ")
    
    MYSQL_COUNT=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT COUNT(*) FROM sync_db.mongodb_sync;" 2>/dev/null | tail -1)
    
    REDIS_COUNT=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD keys "sync:*" | wc -l)
    
    echo "MongoDB文档数: $MONGODB_COUNT" >> $report_file
    echo "MySQL记录数: $MYSQL_COUNT" >> $report_file
    echo "Redis键数: $REDIS_COUNT" >> $report_file
    
    log "同步报告生成完成: $report_file"
}

# 设置同步告警
setup_sync_alerts() {
    log "设置多数据库同步告警..."
    
    # 创建告警脚本
    cat > /opt/multi-db-sync-alert.sh << 'EOF'
#!/bin/bash
# 多数据库同步告警脚本

MONGODB_HOST="192.168.1.10:27017"
KAFKA_HOST="192.168.1.10:9092"
REDIS_HOST="192.168.1.10:6379"
MYSQL_HOST="192.168.1.10:3306"
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"
REDIS_PASSWORD="redis123"
MYSQL_USER="root"
MYSQL_PASSWORD="mysql123"

check_sync_alerts() {
    # 检查MongoDB状态
    MONGODB_STATUS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
        db.runCommand('ping').ok;
    ")
    
    if [ "$MONGODB_STATUS" != "1" ]; then
        echo "告警: MongoDB连接失败"
    fi
    
    # 检查Kafka状态
    if ! /opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list > /dev/null 2>&1; then
        echo "告警: Kafka连接失败"
    fi
    
    # 检查Redis状态
    REDIS_STATUS=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD ping)
    
    if [ "$REDIS_STATUS" != "PONG" ]; then
        echo "告警: Redis连接失败"
    fi
    
    # 检查MySQL状态
    if ! mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT 1;" > /dev/null 2>&1; then
        echo "告警: MySQL连接失败"
    fi
    
    # 检查同步延迟
    MONGODB_COUNT=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
        db.test_collection.count();
    ")
    
    MYSQL_COUNT=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT COUNT(*) FROM sync_db.mongodb_sync;" 2>/dev/null | tail -1)
    
    if [ "$MONGODB_COUNT" != "$MYSQL_COUNT" ]; then
        SYNC_LAG=$((MONGODB_COUNT - MYSQL_COUNT))
        echo "告警: MongoDB到MySQL同步延迟过高 ($SYNC_LAG)"
    fi
}

# 每5分钟检查一次
while true; do
    check_sync_alerts
    sleep 300
done
EOF
    
    chmod +x /opt/multi-db-sync-alert.sh
    
    # 启动告警服务
    nohup /opt/multi-db-sync-alert.sh > /var/log/multi-db-sync-alert.log 2>&1 &
    
    log "同步告警设置完成"
}

# 主函数
main() {
    case $1 in
        "monitor")
            monitor_sync_status
            ;;
        "report")
            generate_sync_report
            ;;
        "alerts")
            setup_sync_alerts
            ;;
        *)
            echo "用法: $0 {monitor|report|alerts}"
            echo "  monitor - 开始同步监控"
            echo "  report - 生成同步报告"
            echo "  alerts - 设置同步告警"
            ;;
    esac
}

# 执行主函数
main "$@"

4. 统一监控管理

4.1 统一监控脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
#!/bin/bash
# multi_db_unified_monitor.sh - 多数据库统一监控脚本
# @author 运维实战

# 监控配置
MONGODB_HOST="192.168.1.10:27017"
KAFKA_HOST="192.168.1.10:9092"
REDIS_HOST="192.168.1.10:6379"
MYSQL_HOST="192.168.1.10:3306"
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"
REDIS_PASSWORD="redis123"
MYSQL_USER="root"
MYSQL_PASSWORD="mysql123"
MONITOR_INTERVAL=30
LOG_FILE="/var/log/multi-db-unified-monitor.log"

# 记录监控数据
log_monitor_data() {
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local metric=$1
    local value=$2
    local database=$3
    
    echo "[$timestamp] Database:$database Metric:$metric Value:$value" >> $LOG_FILE
}

# 监控多数据库状态
monitor_multi_db_status() {
    log "开始监控多数据库状态..."
    
    while true; do
        # 监控系统性能
        SYSTEM_LOAD=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
        CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | sed 's/%us,//')
        MEMORY_USAGE=$(free | grep "Mem:" | awk '{printf "%.2f", $3/$2 * 100.0}')
        
        log_monitor_data "system_load" $SYSTEM_LOAD "system"
        log_monitor_data "cpu_usage" $CPU_USAGE "system"
        log_monitor_data "memory_usage" $MEMORY_USAGE "system"
        
        # 监控MongoDB
        monitor_mongodb_status
        
        # 监控Kafka
        monitor_kafka_status
        
        # 监控Redis
        monitor_redis_status
        
        # 监控MySQL
        monitor_mysql_status
        
        sleep $MONITOR_INTERVAL
    done
}

# 监控MongoDB状态
monitor_mongodb_status() {
    if mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --eval "db.runCommand('ping')" > /dev/null 2>&1; then
        # 获取MongoDB状态
        MONGODB_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
            db.serverStatus().connections.current;
        ")
        
        MONGODB_OPERATIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
            db.serverStatus().opcounters.total;
        ")
        
        MONGODB_MEMORY=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
            db.serverStatus().mem.resident;
        ")
        
        log_monitor_data "connections" $MONGODB_CONNECTIONS "mongodb"
        log_monitor_data "operations" $MONGODB_OPERATIONS "mongodb"
        log_monitor_data "memory_usage" $MONGODB_MEMORY "mongodb"
    else
        log_monitor_data "status" "down" "mongodb"
    fi
}

# 监控Kafka状态
monitor_kafka_status() {
    if /opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list > /dev/null 2>&1; then
        # 获取Kafka状态
        KAFKA_TOPICS=$(/opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list | wc -l)
        
        # 获取Kafka消费者组
        KAFKA_CONSUMER_GROUPS=$(/opt/kafka/bin/kafka-consumer-groups.sh --bootstrap-server $KAFKA_HOST --list | wc -l)
        
        log_monitor_data "topics_count" $KAFKA_TOPICS "kafka"
        log_monitor_data "consumer_groups" $KAFKA_CONSUMER_GROUPS "kafka"
    else
        log_monitor_data "status" "down" "kafka"
    fi
}

# 监控Redis状态
monitor_redis_status() {
    if redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD ping > /dev/null 2>&1; then
        # 获取Redis状态
        REDIS_CONNECTIONS=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD info clients | grep "connected_clients:" | cut -d: -f2 | tr -d '\r')
        
        REDIS_OPERATIONS=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD info stats | grep "total_commands_processed:" | cut -d: -f2 | tr -d '\r')
        
        REDIS_MEMORY=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD info memory | grep "used_memory_human:" | cut -d: -f2 | tr -d '\r')
        
        log_monitor_data "connections" $REDIS_CONNECTIONS "redis"
        log_monitor_data "operations" $REDIS_OPERATIONS "redis"
        log_monitor_data "memory_usage" $REDIS_MEMORY "redis"
    else
        log_monitor_data "status" "down" "redis"
    fi
}

# 监控MySQL状态
monitor_mysql_status() {
    if mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT 1;" > /dev/null 2>&1; then
        # 获取MySQL状态
        MYSQL_CONNECTIONS=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SHOW STATUS LIKE 'Threads_connected';" 2>/dev/null | tail -1 | awk '{print $2}')
        
        MYSQL_OPERATIONS=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SHOW STATUS LIKE 'Queries';" 2>/dev/null | tail -1 | awk '{print $2}')
        
        MYSQL_MEMORY=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SHOW STATUS LIKE 'Innodb_buffer_pool_pages_data';" 2>/dev/null | tail -1 | awk '{print $2}')
        
        log_monitor_data "connections" $MYSQL_CONNECTIONS "mysql"
        log_monitor_data "operations" $MYSQL_OPERATIONS "mysql"
        log_monitor_data "memory_usage" $MYSQL_MEMORY "mysql"
    else
        log_monitor_data "status" "down" "mysql"
    fi
}

# 生成统一监控报告
generate_unified_report() {
    local report_file="/var/log/multi-db-unified-report-$(date +%Y%m%d).txt"
    
    log "生成多数据库统一监控报告: $report_file"
    
    cat > $report_file << EOF
多数据库统一监控报告
生成时间: $(date)
========================================

EOF
    
    # 系统性能信息
    echo "系统性能信息:" >> $report_file
    echo "----------------------------------------" >> $report_file
    uptime >> $report_file
    free -h >> $report_file
    echo "" >> $report_file
    
    # MongoDB状态
    echo "MongoDB状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --eval "db.serverStatus()" >> $report_file
    echo "" >> $report_file
    
    # Kafka状态
    echo "Kafka状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    /opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list >> $report_file
    echo "" >> $report_file
    
    # Redis状态
    echo "Redis状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD info >> $report_file
    echo "" >> $report_file
    
    # MySQL状态
    echo "MySQL状态:" >> $report_file
    echo "----------------------------------------" >> $report_file
    mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SHOW STATUS;" >> $report_file
    echo "" >> $report_file
    
    # 统一统计
    echo "统一统计:" >> $report_file
    echo "----------------------------------------" >> $report_file
    
    # 计算总连接数
    MONGODB_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
        db.serverStatus().connections.current;
    ")
    
    REDIS_CONNECTIONS=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD info clients | grep "connected_clients:" | cut -d: -f2 | tr -d '\r')
    
    MYSQL_CONNECTIONS=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SHOW STATUS LIKE 'Threads_connected';" 2>/dev/null | tail -1 | awk '{print $2}')
    
    TOTAL_CONNECTIONS=$((MONGODB_CONNECTIONS + REDIS_CONNECTIONS + MYSQL_CONNECTIONS))
    
    echo "MongoDB连接数: $MONGODB_CONNECTIONS" >> $report_file
    echo "Redis连接数: $REDIS_CONNECTIONS" >> $report_file
    echo "MySQL连接数: $MYSQL_CONNECTIONS" >> $report_file
    echo "总连接数: $TOTAL_CONNECTIONS" >> $report_file
    
    log "统一监控报告生成完成: $report_file"
}

# 设置统一告警
setup_unified_alerts() {
    log "设置多数据库统一告警..."
    
    # 创建告警脚本
    cat > /opt/multi-db-unified-alert.sh << 'EOF'
#!/bin/bash
# 多数据库统一告警脚本

MONGODB_HOST="192.168.1.10:27017"
KAFKA_HOST="192.168.1.10:9092"
REDIS_HOST="192.168.1.10:6379"
MYSQL_HOST="192.168.1.10:3306"
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"
REDIS_PASSWORD="redis123"
MYSQL_USER="root"
MYSQL_PASSWORD="mysql123"

check_unified_alerts() {
    # 检查系统负载
    SYSTEM_LOAD=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    
    if (( $(echo "$SYSTEM_LOAD > 5.0" | bc -l) )); then
        echo "告警: 系统负载过高 ($SYSTEM_LOAD)"
    fi
    
    # 检查MongoDB
    MONGODB_STATUS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
        db.runCommand('ping').ok;
    ")
    
    if [ "$MONGODB_STATUS" != "1" ]; then
        echo "告警: MongoDB连接失败"
    fi
    
    MONGODB_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $MONGODB_HOST --quiet --eval "
        db.serverStatus().connections.current;
    ")
    
    if [ $MONGODB_CONNECTIONS -gt 800 ]; then
        echo "告警: MongoDB连接数过高 ($MONGODB_CONNECTIONS)"
    fi
    
    # 检查Kafka
    if ! /opt/kafka/bin/kafka-topics.sh --bootstrap-server $KAFKA_HOST --list > /dev/null 2>&1; then
        echo "告警: Kafka连接失败"
    fi
    
    # 检查Redis
    REDIS_STATUS=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD ping)
    
    if [ "$REDIS_STATUS" != "PONG" ]; then
        echo "告警: Redis连接失败"
    fi
    
    REDIS_CONNECTIONS=$(redis-cli -h $REDIS_HOST -p 6379 -a $REDIS_PASSWORD info clients | grep "connected_clients:" | cut -d: -f2 | tr -d '\r')
    
    if [ $REDIS_CONNECTIONS -gt 500 ]; then
        echo "告警: Redis连接数过高 ($REDIS_CONNECTIONS)"
    fi
    
    # 检查MySQL
    if ! mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SELECT 1;" > /dev/null 2>&1; then
        echo "告警: MySQL连接失败"
    fi
    
    MYSQL_CONNECTIONS=$(mysql -h $MYSQL_HOST -u $MYSQL_USER -p$MYSQL_PASSWORD -e "SHOW STATUS LIKE 'Threads_connected';" 2>/dev/null | tail -1 | awk '{print $2}')
    
    if [ $MYSQL_CONNECTIONS -gt 200 ]; then
        echo "告警: MySQL连接数过高 ($MYSQL_CONNECTIONS)"
    fi
}

# 每5分钟检查一次
while true; do
    check_unified_alerts
    sleep 300
done
EOF
    
    chmod +x /opt/multi-db-unified-alert.sh
    
    # 启动告警服务
    nohup /opt/multi-db-unified-alert.sh > /var/log/multi-db-unified-alert.log 2>&1 &
    
    log "统一告警设置完成"
}

# 主函数
main() {
    case $1 in
        "monitor")
            monitor_multi_db_status
            ;;
        "report")
            generate_unified_report
            ;;
        "alerts")
            setup_unified_alerts
            ;;
        *)
            echo "用法: $0 {monitor|report|alerts}"
            echo "  monitor - 开始统一监控"
            echo "  report - 生成统一报告"
            echo "  alerts - 设置统一告警"
            ;;
    esac
}

# 执行主函数
main "$@"

5. 总结

5.1 多数据库运维最佳实践

  1. 统一部署: 统一部署MongoDB、Kafka、Redis、MySQL，确保版本兼容性
  2. 数据同步: 建立完善的数据同步机制，确保数据一致性
  3. 统一监控: 建立多数据库的统一监控体系，及时发现和处理问题
  4. 运维管理: 提供多数据库的统一运维管理方案
  5. 高可用保障: 确保多数据库系统的高可用性

5.2 关键指标监控

  • 系统性能: 监控CPU、内存、磁盘使用情况
  • 数据库状态: 监控各数据库的连接数、操作数、内存使用
  • 数据同步: 监控数据同步延迟和一致性
  • 故障转移: 监控故障转移事件和恢复时间
  • 性能指标: 监控各数据库的性能指标

5.3 运维工具推荐

  1. 监控工具: Prometheus + Grafana, 自定义监控脚本
  2. 告警工具: Alertmanager, 统一告警机制
  3. 管理工具: 各数据库原生管理工具, 统一管理脚本
  4. 备份工具: 各数据库备份工具, 统一备份方案
  5. 诊断工具: 各数据库诊断工具, 统一诊断脚本

通过本文的MongoDB、Kafka、Redis、MySQL多数据库运维实战指南，您可以建立完善的多数据库运维体系，确保系统的高可用性和数据一致性。记住，多数据库的运维需要统一管理，确保各数据库之间的协调工作。