1. MongoDB副本集三节点4核8GB极速型SSD概述

在4核8GB极速型SSD50GB的高性能服务器环境下部署MongoDB副本集三节点架构，需要特别关注SSD性能优化、资源分配和副本集配置。本文将详细介绍在4核8GB极速型SSD环境下部署MongoDB副本集三节点的运维实战经验，包括资源分配、性能调优、SSD优化、监控告警的完整解决方案。

1.1 核心功能

  1. 资源优化: 在4核8GB环境下合理分配系统资源
  2. SSD优化: 充分利用极速型SSD的高性能特性
  3. 三节点架构: 一主两从的副本集架构，确保高可用性
  4. 性能调优: 针对高性能服务器的MongoDB性能优化
  5. 监控告警: 全面的监控体系，确保系统稳定运行

1.2 技术架构

1
2
3
4
5
4核8GB极速型SSD → MongoDB主节点 → MongoDB从节点1 → MongoDB从节点2
    ↓              ↓              ↓              ↓
系统监控 → 资源分配 → 数据同步 → 故障转移
    ↓              ↓              ↓              ↓
SSD优化 → 性能调优 → 副本集管理 → 监控告警

2. 环境准备

2.1 4核8GB极速型SSD环境检查

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
#!/bin/bash
# check_mongodb_3node_4c8g_env.sh - MongoDB三节点4核8GB极速型SSD环境检查脚本
# @author 运维实战

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

# 检查系统资源
check_system_resources() {
    log "检查4核8GB极速型SSD系统资源..."
    
    # 检查CPU核心数
    CPU_CORES=$(nproc)
    log "CPU核心数: $CPU_CORES"
    
    if [ $CPU_CORES -lt 4 ]; then
        log "警告: CPU核心数不足4核"
    fi
    
    # 检查内存
    TOTAL_MEM=$(free -h | grep "Mem:" | awk '{print $2}')
    AVAILABLE_MEM=$(free -h | grep "Mem:" | awk '{print $7}')
    USED_MEM=$(free -h | grep "Mem:" | awk '{print $3}')
    
    log "总内存: $TOTAL_MEM"
    log "已用内存: $USED_MEM"
    log "可用内存: $AVAILABLE_MEM"
    
    # 检查内存是否足够8GB
    TOTAL_MEM_KB=$(free | grep "Mem:" | awk '{print $2}')
    TOTAL_MEM_GB=$((TOTAL_MEM_KB / 1024 / 1024))
    
    if [ $TOTAL_MEM_GB -lt 8 ]; then
        log "警告: 系统内存不足8GB (当前: ${TOTAL_MEM_GB}GB)"
    else
        log "系统内存充足: ${TOTAL_MEM_GB}GB"
    fi
    
    # 检查磁盘空间和类型
    check_disk_info
}

# 检查磁盘信息
check_disk_info() {
    log "检查磁盘信息..."
    
    # 检查磁盘使用情况
    DISK_USAGE=$(df -h / | tail -1 | awk '{print $5}' | sed 's/%//')
    DISK_AVAILABLE=$(df -h / | tail -1 | awk '{print $4}')
    DISK_TOTAL=$(df -h / | tail -1 | awk '{print $2}')
    
    log "磁盘总容量: $DISK_TOTAL"
    log "磁盘使用率: $DISK_USAGE%"
    log "可用磁盘空间: $DISK_AVAILABLE"
    
    if [ $DISK_USAGE -gt 80 ]; then
        log "警告: 磁盘使用率过高"
    fi
    
    # 检查磁盘类型
    DISK_TYPE=$(lsblk -d -o name,rota | grep -v NAME | head -1 | awk '{print $2}')
    if [ "$DISK_TYPE" = "0" ]; then
        log "磁盘类型: SSD (极速型)"
    else
        log "磁盘类型: HDD (机械硬盘)"
    fi
    
    # 检查磁盘性能
    check_disk_performance
}

# 检查磁盘性能
check_disk_performance() {
    log "检查磁盘性能..."
    
    # 检查磁盘IO性能
    if command -v iostat > /dev/null 2>&1; then
        log "磁盘IO统计:"
        iostat -x 1 3 | tail -n +4
    else
        log "iostat未安装，跳过磁盘IO检查"
    fi
    
    # 检查磁盘读写速度
    log "测试磁盘读写速度..."
    
    # 测试写入速度
    WRITE_SPEED=$(dd if=/dev/zero of=/tmp/test_write bs=1M count=100 2>&1 | grep "copied" | awk '{print $8, $9}')
    log "磁盘写入速度: $WRITE_SPEED"
    
    # 测试读取速度
    READ_SPEED=$(dd if=/tmp/test_write of=/dev/null bs=1M 2>&1 | grep "copied" | awk '{print $8, $9}')
    log "磁盘读取速度: $READ_SPEED"
    
    # 清理测试文件
    rm -f /tmp/test_write
    
    # 检查SSD优化参数
    check_ssd_optimization
}

# 检查SSD优化参数
check_ssd_optimization() {
    log "检查SSD优化参数..."
    
    # 检查TRIM支持
    if command -v fstrim > /dev/null 2>&1; then
        log "TRIM支持: 已启用"
    else
        log "警告: TRIM支持未启用"
    fi
    
    # 检查SSD调度器
    SSD_SCHEDULER=$(cat /sys/block/sda/queue/scheduler 2>/dev/null | grep -o '\[.*\]' | tr -d '[]')
    log "SSD调度器: $SSD_SCHEDULER"
    
    # 检查SSD队列深度
    SSD_QUEUE_DEPTH=$(cat /sys/block/sda/queue/nr_requests 2>/dev/null)
    log "SSD队列深度: $SSD_QUEUE_DEPTH"
}

# 检查系统负载
check_system_load() {
    log "检查系统负载..."
    
    # 获取系统负载
    LOAD_AVG=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    log "系统负载: $LOAD_AVG"
    
    # 检查负载是否过高
    if (( $(echo "$LOAD_AVG > 3.0" | bc -l) )); then
        log "警告: 系统负载过高"
    else
        log "系统负载正常"
    fi
    
    # 检查进程数量
    PROCESS_COUNT=$(ps aux | wc -l)
    log "当前进程数: $PROCESS_COUNT"
    
    if [ $PROCESS_COUNT -gt 400 ]; then
        log "警告: 进程数量过多"
    fi
}

# 检查网络连接
check_network_connections() {
    log "检查网络连接..."
    
    # 检查TCP连接数
    TCP_CONNECTIONS=$(netstat -an | grep tcp | wc -l)
    log "TCP连接数: $TCP_CONNECTIONS"
    
    if [ $TCP_CONNECTIONS -gt 3000 ]; then
        log "警告: TCP连接数过多"
    fi
    
    # 检查监听端口
    LISTENING_PORTS=$(netstat -tlnp | grep LISTEN | wc -l)
    log "监听端口数: $LISTENING_PORTS"
    
    # 检查MongoDB相关端口
    MONGODB_PORTS=(27017 27018 27019)
    for port in "${MONGODB_PORTS[@]}"; do
        if netstat -tlnp | grep ":$port " > /dev/null; then
            log "端口 $port 已被占用"
        else
            log "端口 $port 可用"
        fi
    done
}

# 检查系统限制
check_system_limits() {
    log "检查系统限制..."
    
    # 检查文件描述符限制
    FD_LIMIT=$(ulimit -n)
    log "文件描述符限制: $FD_LIMIT"
    
    if [ $FD_LIMIT -lt 65536 ]; then
        log "警告: 文件描述符限制过低"
    fi
    
    # 检查进程限制
    PROCESS_LIMIT=$(ulimit -u)
    log "进程数限制: $PROCESS_LIMIT"
    
    # 检查内存限制
    MEMORY_LIMIT=$(ulimit -m)
    if [ $MEMORY_LIMIT != "unlimited" ]; then
        log "内存限制: $MEMORY_LIMIT KB"
    else
        log "内存限制: 无限制"
    fi
}

# 优化系统参数
optimize_system_parameters() {
    log "优化系统参数(4核8GB极速型SSD环境)..."
    
    # 优化内核参数
    cat >> /etc/sysctl.conf << EOF
# MongoDB优化参数 - 4核8GB极速型SSD环境
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 5000
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 3
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
vm.overcommit_memory = 1
vm.swappiness = 1
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5
vm.max_map_count = 262144
fs.file-max = 2097152
# SSD优化参数
vm.dirty_writeback_centisecs = 1500
vm.dirty_expire_centisecs = 3000
EOF
    
    # 应用内核参数
    sysctl -p
    
    # 优化文件描述符限制
    cat >> /etc/security/limits.conf << EOF
# MongoDB用户限制 - 4核8GB极速型SSD环境
mongodb soft nofile 65535
mongodb hard nofile 65535
mongodb soft nproc 32768
mongodb hard nproc 32768
root soft nofile 65535
root hard nofile 65535
EOF
    
    log "系统参数优化完成"
}

# 主函数
main() {
    log "=== MongoDB三节点4核8GB极速型SSD环境检查开始 ==="
    check_system_resources
    check_system_load
    check_network_connections
    check_system_limits
    optimize_system_parameters
    log "=== MongoDB三节点4核8GB极速型SSD环境检查完成 ==="
}

# 执行主函数
main "$@"

2.2 三节点4核8GB极速型SSD MongoDB配置

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
#!/bin/bash
# mongodb_3node_4c8g_config.sh - MongoDB三节点4核8GB极速型SSD配置脚本
# @author 运维实战

# 配置参数
REPLICA_SET_NAME="rs0"
PRIMARY_NODE="192.168.1.10:27017"
SECONDARY_NODES=("192.168.1.11:27017" "192.168.1.12:27017")
MONGODB_PORT=27017
MONGODB_DATA_DIR="/var/lib/mongodb"
MONGODB_LOG_DIR="/var/log/mongodb"
CACHE_SIZE_GB="2"  # 分配2GB给MongoDB缓存
SYSTEM_MEMORY="6gb"  # 系统保留6GB内存

# 备份配置文件
backup_config_files() {
    log "备份MongoDB配置文件..."
    
    # 备份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
}

# 配置主节点(4核8GB极速型SSD优化)
configure_primary_node_4c8g() {
    log "配置MongoDB主节点(4核8GB极速型SSD优化)..."
    
    cat > /etc/mongod.conf << EOF
# MongoDB主节点配置 - 4核8GB极速型SSD优化
storage:
  dbPath: $MONGODB_DATA_DIR
  journal:
    enabled: true
    commitIntervalMs: 100
  wiredTiger:
    engineConfig:
      cacheSizeGB: $CACHE_SIZE_GB
      journalCompressor: snappy
      directoryForIndexes: false
      eviction: (threads_min=1,threads_max=4)
    collectionConfig:
      blockCompressor: snappy
    indexConfig:
      prefixCompression: true
    statisticsLog:
      path: $MONGODB_LOG_DIR/wiredTigerStats.log
      verbosity: 0

systemLog:
  destination: file
  logAppend: true
  path: $MONGODB_LOG_DIR/mongod.log
  logRotate: reopen
  verbosity: 0
  component:
    accessControl:
      verbosity: 0
    command:
      verbosity: 0

net:
  port: $MONGODB_PORT
  bindIp: 0.0.0.0
  maxIncomingConnections: 2000
  compression:
    compressors: snappy,zstd

processManagement:
  timeZoneInfo: /usr/share/zoneinfo
  fork: true
  pidFilePath: /var/run/mongodb/mongod.pid

replication:
  replSetName: $REPLICA_SET_NAME
  oplogSizeMB: 1024

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

operationProfiling:
  slowOpThresholdMs: 100
  mode: slowOp

setParameter:
  enableLocalhostAuthBypass: false
  logLevel: 1
  maxLogSizeKB: 10
  cursorTimeoutMillis: 600000
  wiredTigerConcurrentReadTransactions: 128
  wiredTigerConcurrentWriteTransactions: 128
EOF
    
    log "主节点配置完成"
}

# 配置从节点(4核8GB极速型SSD优化)
configure_secondary_node_4c8g() {
    local node_ip=$1
    log "配置MongoDB从节点(4核8GB极速型SSD优化): $node_ip..."
    
    cat > /etc/mongod.conf << EOF
# MongoDB从节点配置 - 4核8GB极速型SSD优化
storage:
  dbPath: $MONGODB_DATA_DIR
  journal:
    enabled: true
    commitIntervalMs: 100
  wiredTiger:
    engineConfig:
      cacheSizeGB: $CACHE_SIZE_GB
      journalCompressor: snappy
      directoryForIndexes: false
      eviction: (threads_min=1,threads_max=4)
    collectionConfig:
      blockCompressor: snappy
    indexConfig:
      prefixCompression: true
    statisticsLog:
      path: $MONGODB_LOG_DIR/wiredTigerStats.log
      verbosity: 0

systemLog:
  destination: file
  logAppend: true
  path: $MONGODB_LOG_DIR/mongod.log
  logRotate: reopen
  verbosity: 0
  component:
    accessControl:
      verbosity: 0
    command:
      verbosity: 0

net:
  port: $MONGODB_PORT
  bindIp: 0.0.0.0
  maxIncomingConnections: 2000
  compression:
    compressors: snappy,zstd

processManagement:
  timeZoneInfo: /usr/share/zoneinfo
  fork: true
  pidFilePath: /var/run/mongodb/mongod.pid

replication:
  replSetName: $REPLICA_SET_NAME
  oplogSizeMB: 1024

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

operationProfiling:
  slowOpThresholdMs: 100
  mode: slowOp

setParameter:
  enableLocalhostAuthBypass: false
  logLevel: 1
  maxLogSizeKB: 10
  cursorTimeoutMillis: 600000
  wiredTigerConcurrentReadTransactions: 128
  wiredTigerConcurrentWriteTransactions: 128
EOF
    
    log "从节点 $node_ip 配置完成"
}

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

# 创建管理员用户
create_admin_user() {
    log "创建MongoDB管理员用户..."
    
    # 等待MongoDB启动
    sleep 10
    
    # 创建管理员用户
    mongo --eval "
        use admin;
        db.createUser({
            user: 'admin',
            pwd: 'admin123',
            roles: [
                { role: 'userAdminAnyDatabase', db: 'admin' },
                { role: 'readWriteAnyDatabase', db: 'admin' },
                { role: 'dbAdminAnyDatabase', db: 'admin' },
                { role: 'clusterAdmin', db: 'admin' }
            ]
        });
    "
    
    log "管理员用户创建完成"
}

# 初始化三节点副本集
initialize_three_node_replica_set() {
    log "初始化MongoDB三节点副本集..."
    
    # 等待所有节点启动
    sleep 15
    
    # 初始化三节点副本集
    mongo --eval "
        rs.initiate({
            _id: '$REPLICA_SET_NAME',
            members: [
                { _id: 0, host: '$PRIMARY_NODE', priority: 3 },
                { _id: 1, host: '${SECONDARY_NODES[0]}', priority: 2 },
                { _id: 2, host: '${SECONDARY_NODES[1]}', priority: 1 }
            ]
        });
    "
    
    log "三节点副本集初始化完成"
}

# 优化SSD性能
optimize_ssd_performance() {
    log "优化SSD性能..."
    
    # 启用TRIM
    if command -v fstrim > /dev/null 2>&1; then
        fstrim -v /
        log "TRIM已执行"
    fi
    
    # 设置SSD调度器
    echo noop > /sys/block/sda/queue/scheduler 2>/dev/null || true
    log "SSD调度器已设置为noop"
    
    # 设置SSD队列深度
    echo 32 > /sys/block/sda/queue/nr_requests 2>/dev/null || true
    log "SSD队列深度已设置为32"
    
    # 禁用SSD写入缓存
    echo 1 > /sys/block/sda/queue/write_cache 2>/dev/null || true
    log "SSD写入缓存已禁用"
}

# 启动服务
start_services() {
    log "启动MongoDB服务..."
    
    # 启动MongoDB服务
    systemctl restart mongod
    systemctl enable mongod
    
    # 检查服务状态
    sleep 5
    
    if systemctl is-active --quiet mongod; then
        log "MongoDB服务启动成功"
    else
        log "错误: MongoDB服务启动失败"
        exit 1
    fi
}

# 主函数
main() {
    log "=== MongoDB三节点4核8GB极速型SSD配置开始 ==="
    backup_config_files
    configure_primary_node_4c8g
    create_keyfile
    optimize_ssd_performance
    start_services
    create_admin_user
    initialize_three_node_replica_set
    log "=== MongoDB三节点4核8GB极速型SSD配置完成 ==="
}

# 执行主函数
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
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
#!/bin/bash
# mongodb_performance_optimize_3node_4c8g.sh - MongoDB三节点4核8GB性能优化脚本
# @author 运维实战

# 配置参数
REPLICA_SET_NAME="rs0"
PRIMARY_NODE="192.168.1.10:27017"
SECONDARY_NODES=("192.168.1.11:27017" "192.168.1.12:27017")
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"

# 检查性能指标
check_performance_metrics() {
    log "检查MongoDB性能指标(三节点4核8GB环境)..."
    
    # 检查主节点性能
    log "主节点性能指标:"
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "
        print('=== 主节点性能指标 ===');
        print('连接数: ' + db.serverStatus().connections.current);
        print('总操作数: ' + db.serverStatus().opcounters.total);
        print('每秒操作数: ' + db.serverStatus().opcounters.total / db.serverStatus().uptime);
        print('内存使用: ' + db.serverStatus().mem.resident + 'MB');
        print('缓存使用: ' + db.serverStatus().wiredTiger.cache['bytes currently in the cache'] / 1024 / 1024 + 'MB');
        print('索引命中率: ' + (db.serverStatus().wiredTiger.cache['pages read into cache'] - db.serverStatus().wiredTiger.cache['pages written from cache']) / db.serverStatus().wiredTiger.cache['pages read into cache'] * 100 + '%');
    "
    
    # 检查从节点性能
    for node in "${SECONDARY_NODES[@]}"; do
        log "从节点 $node 性能指标:"
        mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $node --eval "
            print('=== 从节点 $node 性能指标 ===');
            print('连接数: ' + db.serverStatus().connections.current);
            print('总操作数: ' + db.serverStatus().opcounters.total);
            print('每秒操作数: ' + db.serverStatus().opcounters.total / db.serverStatus().uptime);
            print('内存使用: ' + db.serverStatus().mem.resident + 'MB');
            print('缓存使用: ' + db.serverStatus().wiredTiger.cache['bytes currently in the cache'] / 1024 / 1024 + 'MB');
        "
    done
}

# 优化性能配置
optimize_performance_config() {
    log "优化MongoDB性能配置(三节点4核8GB环境)..."
    
    # 优化主节点配置
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "
        // 优化WiredTiger缓存
        db.adminCommand({setParameter: 1, wiredTigerConcurrentReadTransactions: 128});
        db.adminCommand({setParameter: 1, wiredTigerConcurrentWriteTransactions: 128});
        
        // 优化连接数
        db.adminCommand({setParameter: 1, maxIncomingConnections: 2000});
        
        // 优化日志级别
        db.adminCommand({setParameter: 1, logLevel: 1});
        
        // 优化慢查询阈值
        db.adminCommand({setParameter: 1, slowOpThresholdMs: 100});
        
        print('主节点性能配置优化完成');
    "
    
    # 优化从节点配置
    for node in "${SECONDARY_NODES[@]}"; do
        mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $node --eval "
            // 优化WiredTiger缓存
            db.adminCommand({setParameter: 1, wiredTigerConcurrentReadTransactions: 128});
            db.adminCommand({setParameter: 1, wiredTigerConcurrentWriteTransactions: 128});
            
            // 优化连接数
            db.adminCommand({setParameter: 1, maxIncomingConnections: 2000});
            
            // 优化日志级别
            db.adminCommand({setParameter: 1, logLevel: 1});
            
            // 优化慢查询阈值
            db.adminCommand({setParameter: 1, slowOpThresholdMs: 100});
            
            print('从节点 $node 性能配置优化完成');
        "
    done
}

# 性能压力测试
performance_stress_test() {
    log "执行MongoDB性能压力测试(三节点4核8GB环境)..."
    
    # 创建测试数据库和集合
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "
        use performance_test;
        db.createCollection('test_collection');
        
        // 创建索引
        db.test_collection.createIndex({field1: 1});
        db.test_collection.createIndex({field2: 1});
        db.test_collection.createIndex({field3: 1});
        
        print('测试数据库和集合创建完成');
    "
    
    # 执行写入压力测试
    log "执行写入压力测试..."
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "
        use performance_test;
        
        var start = new Date();
        var count = 0;
        
        for (var i = 0; i < 10000; i++) {
            db.test_collection.insert({
                field1: 'value' + i,
                field2: Math.random(),
                field3: new Date(),
                data: 'x'.repeat(1000)
            });
            count++;
        }
        
        var end = new Date();
        var duration = end - start;
        var opsPerSec = count / (duration / 1000);
        
        print('写入压力测试完成:');
        print('写入文档数: ' + count);
        print('耗时: ' + duration + 'ms');
        print('每秒操作数: ' + opsPerSec.toFixed(2));
    "
    
    # 执行读取压力测试
    log "执行读取压力测试..."
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "
        use performance_test;
        
        var start = new Date();
        var count = 0;
        
        for (var i = 0; i < 10000; i++) {
            db.test_collection.findOne({field1: 'value' + Math.floor(Math.random() * 10000)});
            count++;
        }
        
        var end = new Date();
        var duration = end - start;
        var opsPerSec = count / (duration / 1000);
        
        print('读取压力测试完成:');
        print('读取文档数: ' + count);
        print('耗时: ' + duration + 'ms');
        print('每秒操作数: ' + opsPerSec.toFixed(2));
    "
    
    # 执行更新压力测试
    log "执行更新压力测试..."
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "
        use performance_test;
        
        var start = new Date();
        var count = 0;
        
        for (var i = 0; i < 5000; i++) {
            db.test_collection.updateOne(
                {field1: 'value' + Math.floor(Math.random() * 10000)},
                {\$set: {field2: Math.random(), updated: new Date()}}
            );
            count++;
        }
        
        var end = new Date();
        var duration = end - start;
        var opsPerSec = count / (duration / 1000);
        
        print('更新压力测试完成:');
        print('更新文档数: ' + count);
        print('耗时: ' + duration + 'ms');
        print('每秒操作数: ' + opsPerSec.toFixed(2));
    "
    
    # 清理测试数据
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "
        use performance_test;
        db.dropDatabase();
        print('测试数据清理完成');
    "
    
    log "性能压力测试完成"
}

# 优化系统参数
optimize_system_parameters() {
    log "优化系统参数(三节点4核8GB环境)..."
    
    # 优化内核参数
    cat >> /etc/sysctl.conf << EOF
# MongoDB性能优化参数 - 三节点4核8GB环境
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 5000
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 3
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
vm.overcommit_memory = 1
vm.swappiness = 1
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5
vm.max_map_count = 262144
fs.file-max = 2097152
# SSD优化参数
vm.dirty_writeback_centisecs = 1500
vm.dirty_expire_centisecs = 3000
# MongoDB优化参数
vm.zone_reclaim_mode = 0
vm.min_free_kbytes = 65536
EOF
    
    # 应用内核参数
    sysctl -p
    
    # 优化文件描述符限制
    cat >> /etc/security/limits.conf << EOF
# MongoDB用户限制 - 三节点4核8GB环境
mongodb soft nofile 65535
mongodb hard nofile 65535
mongodb soft nproc 32768
mongodb hard nproc 32768
root soft nofile 65535
root hard nofile 65535
EOF
    
    log "系统参数优化完成"
}

# 主函数
main() {
    case $1 in
        "check")
            check_performance_metrics
            ;;
        "optimize")
            optimize_performance_config
            ;;
        "test")
            performance_stress_test
            ;;
        "system")
            optimize_system_parameters
            ;;
        *)
            echo "用法: $0 {check|optimize|test|system}"
            echo "  check - 检查性能指标"
            echo "  optimize - 优化性能配置"
            echo "  test - 性能压力测试"
            echo "  system - 优化系统参数"
            ;;
    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
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
#!/bin/bash
# mongodb_performance_monitor_3node_4c8g.sh - MongoDB三节点4核8GB性能监控脚本
# @author 运维实战

# 监控配置
REPLICA_SET_NAME="rs0"
PRIMARY_NODE="192.168.1.10:27017"
SECONDARY_NODES=("192.168.1.11:27017" "192.168.1.12:27017")
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"
MONITOR_INTERVAL=30
LOG_FILE="/var/log/mongodb-performance-monitor-3node-4c8g.log"

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

# 监控性能指标
monitor_performance_metrics() {
    log "开始监控MongoDB性能指标(三节点4核8GB环境)..."
    
    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_performance_data "system_load" $SYSTEM_LOAD "system"
        log_performance_data "cpu_usage" $CPU_USAGE "system"
        log_performance_data "memory_usage" $MEMORY_USAGE "system"
        
        # 监控主节点性能
        PRIMARY_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            db.serverStatus().connections.current;
        ")
        
        PRIMARY_OPERATIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            db.serverStatus().opcounters.total;
        ")
        
        PRIMARY_MEMORY=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            db.serverStatus().mem.resident;
        ")
        
        PRIMARY_CACHE=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            db.serverStatus().wiredTiger.cache['bytes currently in the cache'] / 1024 / 1024;
        ")
        
        log_performance_data "connections" $PRIMARY_CONNECTIONS "primary"
        log_performance_data "operations" $PRIMARY_OPERATIONS "primary"
        log_performance_data "memory_usage" $PRIMARY_MEMORY "primary"
        log_performance_data "cache_usage" $PRIMARY_CACHE "primary"
        
        # 监控从节点性能
        for node in "${SECONDARY_NODES[@]}"; do
            SECONDARY_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
                db.serverStatus().connections.current;
            " --host $node)
            
            SECONDARY_OPERATIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
                db.serverStatus().opcounters.total;
            " --host $node)
            
            SECONDARY_MEMORY=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
                db.serverStatus().mem.resident;
            " --host $node)
            
            SECONDARY_CACHE=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
                db.serverStatus().wiredTiger.cache['bytes currently in the cache'] / 1024 / 1024;
            " --host $node)
            
            log_performance_data "connections" $SECONDARY_CONNECTIONS $node
            log_performance_data "operations" $SECONDARY_OPERATIONS $node
            log_performance_data "memory_usage" $SECONDARY_MEMORY $node
            log_performance_data "cache_usage" $SECONDARY_CACHE $node
        done
        
        # 监控副本集状态
        REPLICA_SET_STATUS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            rs.status().ok;
        ")
        
        log_performance_data "replica_set_status" $REPLICA_SET_STATUS "replica_set"
        
        sleep $MONITOR_INTERVAL
    done
}

# 生成性能报告
generate_performance_report() {
    local report_file="/var/log/mongodb-performance-report-3node-4c8g-$(date +%Y%m%d).txt"
    
    log "生成MongoDB性能报告(三节点4核8GB环境): $report_file"
    
    cat > $report_file << EOF
MongoDB性能监控报告 - 三节点4核8GB环境
生成时间: $(date)
========================================

EOF
    
    # 系统性能信息
    echo "系统性能信息:" >> $report_file
    echo "----------------------------------------" >> $report_file
    uptime >> $report_file
    free -h >> $report_file
    echo "" >> $report_file
    
    # 主节点性能信息
    echo "主节点 ($PRIMARY_NODE) 性能信息:" >> $report_file
    echo "----------------------------------------" >> $report_file
    mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --eval "db.serverStatus()" >> $report_file
    echo "" >> $report_file
    
    # 从节点性能信息
    for node in "${SECONDARY_NODES[@]}"; do
        echo "从节点 ($node) 性能信息:" >> $report_file
        echo "----------------------------------------" >> $report_file
        mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --host $node --eval "db.serverStatus()" >> $report_file
        echo "" >> $report_file
    done
    
    # 性能统计
    echo "性能统计:" >> $report_file
    echo "----------------------------------------" >> $report_file
    
    # 计算平均操作数
    PRIMARY_OPS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        db.serverStatus().opcounters.total;
    ")
    
    echo "主节点总操作数: $PRIMARY_OPS" >> $report_file
    
    # 计算连接数
    PRIMARY_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        db.serverStatus().connections.current;
    ")
    
    echo "主节点当前连接数: $PRIMARY_CONNECTIONS" >> $report_file
    
    # 计算内存使用
    PRIMARY_MEMORY=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        db.serverStatus().mem.resident;
    ")
    
    echo "主节点内存使用: ${PRIMARY_MEMORY}MB" >> $report_file
    
    # 计算缓存使用
    PRIMARY_CACHE=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        db.serverStatus().wiredTiger.cache['bytes currently in the cache'] / 1024 / 1024;
    ")
    
    echo "主节点缓存使用: ${PRIMARY_CACHE}MB" >> $report_file
    
    log "性能报告生成完成: $report_file"
}

# 设置性能告警
setup_performance_alerts() {
    log "设置MongoDB性能告警(三节点4核8GB环境)..."
    
    # 创建告警脚本
    cat > /opt/mongodb-performance-alert-3node-4c8g.sh << 'EOF'
#!/bin/bash
# MongoDB性能告警脚本 - 三节点4核8GB环境

REPLICA_SET_NAME="rs0"
PRIMARY_NODE="192.168.1.10:27017"
SECONDARY_NODES=("192.168.1.11:27017" "192.168.1.12:27017")
MONGODB_USER="admin"
MONGODB_PASSWORD="admin123"

check_performance_alerts() {
    # 检查系统负载
    SYSTEM_LOAD=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    
    if (( $(echo "$SYSTEM_LOAD > 3.0" | bc -l) )); then
        echo "告警: 系统负载过高 ($SYSTEM_LOAD)"
    fi
    
    # 检查主节点性能
    PRIMARY_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        db.serverStatus().connections.current;
    ")
    
    if [ $PRIMARY_CONNECTIONS -gt 1500 ]; then
        echo "告警: 主节点连接数过高 ($PRIMARY_CONNECTIONS)"
    fi
    
    PRIMARY_OPERATIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        db.serverStatus().opcounters.total;
    ")
    
    if [ $PRIMARY_OPERATIONS -gt 1000000 ]; then
        echo "告警: 主节点操作数过高 ($PRIMARY_OPERATIONS)"
    fi
    
    PRIMARY_MEMORY=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        db.serverStatus().mem.resident;
    ")
    
    if [ $PRIMARY_MEMORY -gt 6000 ]; then
        echo "告警: 主节点内存使用过高 (${PRIMARY_MEMORY}MB)"
    fi
    
    # 检查从节点性能
    for node in "${SECONDARY_NODES[@]}"; do
        SECONDARY_CONNECTIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            db.serverStatus().connections.current;
        " --host $node)
        
        if [ $SECONDARY_CONNECTIONS -gt 1500 ]; then
            echo "告警: 从节点 $node 连接数过高 ($SECONDARY_CONNECTIONS)"
        fi
        
        SECONDARY_OPERATIONS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            db.serverStatus().opcounters.total;
        " --host $node)
        
        if [ $SECONDARY_OPERATIONS -gt 1000000 ]; then
            echo "告警: 从节点 $node 操作数过高 ($SECONDARY_OPERATIONS)"
        fi
        
        SECONDARY_MEMORY=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
            db.serverStatus().mem.resident;
        " --host $node)
        
        if [ $SECONDARY_MEMORY -gt 6000 ]; then
            echo "告警: 从节点 $node 内存使用过高 (${SECONDARY_MEMORY}MB)"
        fi
    done
    
    # 检查副本集状态
    REPLICA_SET_STATUS=$(mongo -u $MONGODB_USER -p $MONGODB_PASSWORD --authenticationDatabase admin --quiet --eval "
        rs.status().ok;
    ")
    
    if [ "$REPLICA_SET_STATUS" != "1" ]; then
        echo "告警: 副本集状态异常 ($REPLICA_SET_STATUS)"
    fi
}

# 每5分钟检查一次
while true; do
    check_performance_alerts
    sleep 300
done
EOF
    
    chmod +x /opt/mongodb-performance-alert-3node-4c8g.sh
    
    # 启动告警服务
    nohup /opt/mongodb-performance-alert-3node-4c8g.sh > /var/log/mongodb-performance-alert-3node-4c8g.log 2>&1 &
    
    log "性能告警设置完成"
}

# 主函数
main() {
    case $1 in
        "monitor")
            monitor_performance_metrics
            ;;
        "report")
            generate_performance_report
            ;;
        "alerts")
            setup_performance_alerts
            ;;
        *)
            echo "用法: $0 {monitor|report|alerts}"
            echo "  monitor - 开始性能监控"
            echo "  report - 生成性能报告"
            echo "  alerts - 设置性能告警"
            ;;
    esac
}

# 执行主函数
main "$@"

4. 总结

4.1 三节点4核8GB极速型SSD环境最佳实践

  1. 资源分配: 合理分配内存，每个节点2GB缓存，系统保留6GB内存
  2. SSD优化: 充分利用极速型SSD的高性能特性，优化IO性能
  3. 三节点架构: 一主两从的副本集架构，确保高可用性和数据冗余
  4. 性能调优: 针对4核8GB环境的MongoDB性能优化策略
  5. 监控告警: 建立全面的监控体系，确保系统稳定运行

4.2 关键指标监控

  • 系统负载: 监控CPU和内存使用情况
  • MongoDB性能: 监控连接数、操作数、内存使用、缓存使用
  • 副本集状态: 监控主从节点状态和同步情况
  • SSD性能: 监控磁盘IO性能和SSD优化参数
  • 故障转移: 监控故障转移事件和恢复时间

4.3 运维工具推荐

  1. 监控工具: MongoDB Compass, MongoDB Atlas, 自定义监控脚本
  2. 告警工具: 完善的告警机制，及时发现问题
  3. 管理工具: mongo shell, MongoDB Ops Manager
  4. 备份工具: mongodump, mongorestore
  5. 诊断工具: mongostat, mongotop, 性能分析脚本

通过本文的MongoDB副本集三节点4核8GB极速型SSD运维实战指南，您可以在高性能服务器上建立高效的MongoDB副本集架构，充分利用4核8GB和极速型SSD的性能优势，确保系统的高性能和高可用性。记住，在资源充足的环境中，需要更加精细的资源管理和性能优化。