MongoDB性能优化 #

// 基本分析
db.users.find({ name: "John" }).explain()

// 详细分析
db.users.find({ name: "John" }).explain("executionStats")

// 关键指标
{
    executionStats: {
        totalDocsExamined: 1000,    // 扫描文档数
        totalKeysExamined: 1000,    // 扫描索引键数
        nReturned: 10,              // 返回文档数
        executionTimeMillis: 5      // 执行时间
    }
}

// 不推荐：全表扫描
db.users.find({ name: /John/ })

// 推荐：使用索引
db.users.find({ name: /^John/ })

// 不推荐：使用$where
db.users.find({ $where: "this.age > 20" })

// 推荐：使用操作符
db.users.find({ age: { $gt: 20 } })

// 不推荐：返回所有字段
db.users.find({ name: "John" })

// 推荐：只返回需要的字段
db.users.find({ name: "John" }, { name: 1, email: 1 })

// 减少返回字段
db.users.find(
    { status: "active" },
    { name: 1, email: 1, _id: 0 }
)

// 限制返回数量
db.users.find().limit(100)

// 分页查询
db.users.find().skip(100).limit(100)

// 开启慢查询日志
db.setProfilingLevel(1, 100)  // 记录超过100ms的查询

// 查看慢查询
db.system.profile.find().sort({ ts: -1 }).limit(10)

// 分析慢查询
db.system.profile.aggregate([
    { $group: { _id: "$ns", count: { $sum: 1 }, avgTime: { $avg: "$millis" } } },
    { $sort: { avgTime: -1 } }
])

// 单字段索引
db.users.createIndex({ email: 1 })

// 复合索引
db.users.createIndex({ status: 1, createdAt: -1 })

// 多键索引
db.users.createIndex({ tags: 1 })

// 文本索引
db.articles.createIndex({ content: "text" })

索引设计原则

1. 选择性高的字段
   - 区分度高的字段
   - 避免在低基数字段创建索引

2. 查询模式匹配
   - 根据查询模式设计索引
   - 复合索引遵循最左前缀

3. 排序优化
   - 排序字段考虑索引
   - 复合索引支持排序

4. 覆盖查询
   - 查询字段都在索引中
   - 避免回表查询

// 创建复合索引
db.users.createIndex({ name: 1, email: 1 })

// 覆盖查询（只查询索引字段）
db.users.find(
    { name: "John" },
    { name: 1, email: 1, _id: 0 }
)

// 验证是否覆盖查询
db.users.find({ name: "John" }, { name: 1, email: 1, _id: 0 }).explain()
// 查看executionStats.totalDocsExamined是否为0

// 查看索引使用情况
db.users.aggregate([
    { $indexStats: {} }
])

// 查找未使用的索引
db.users.aggregate([
    { $indexStats: {} },
    { $match: { "accesses.ops": 0 } }
])

// 查看索引大小
db.users.stats().indexSizes

// 查看冗余索引
// 如果有索引 { a: 1, b: 1 }，则索引 { a: 1 } 是冗余的

// 删除冗余索引
db.users.dropIndex("a_1")

# mongod.conf
storage:
  wiredTiger:
    engineConfig:
      cacheSizeGB: 4  # 缓存大小（建议50%系统内存）

# mongod.conf
net:
  maxIncomingConnections: 65536

# mongod.conf
systemLog:
  verbosity: 0
  quiet: false
  logRotate: rename

// 设置默认写关注
db.adminCommand({
    setDefaultRWConcern: 1,
    defaultWriteConcern: { w: "majority" }
})

// 选择合适的分片键
sh.shardCollection("mydb.users", { userId: "hashed" })

// 预分割Chunk
sh.splitAt("mydb.users", { userId: 1000 })
sh.splitAt("mydb.users", { userId: 2000 })

// 读写分离
db.getMongo().setReadPref("secondaryPreferred")

// 使用标签
db.users.find().readPref("secondary", [{ dc: "east" }])

// 嵌套文档 vs 引用文档
// 嵌套文档：适合一对一、一对少
{
    user: {
        name: "John",
        address: { city: "Beijing" }
    }
}

// 引用文档：适合一对多、多对多
{
    user: { _id: 1, name: "John" },
    orders: [{ orderId: 1 }, { orderId: 2 }]
}

存储建议

1. 使用SSD
   - 随机IO性能更好
   - 降低延迟

2. RAID配置
   - RAID 10：性能和冗余
   - 避免RAID 5/6

3. 文件系统
   - XFS：推荐
   - ext4：兼容性好

内存建议

1. 足够的内存
   - 工作集应该能放入内存
   - WiredTiger缓存50%系统内存

2. 避免交换
   - 关闭swap或限制使用

CPU建议

1. 多核CPU
   - MongoDB多线程
   - 更多核心更好

2. 高主频
   - 单线程操作更快

// 查看服务器状态
db.serverStatus()

// 关键指标
{
    connections: { current: 100, available: 50000 },
    network: { bytesIn: 1000000, bytesOut: 2000000 },
    opcounters: { query: 1000, insert: 500, update: 200 },
    memory: { resident: 1024, virtual: 2048 }
}

// 查看数据库统计
db.stats()

// 查看集合统计
db.users.stats()

// 查看当前操作
db.currentOp()

// 查看长时间运行的操作
db.currentOp({ "secs_running": { $gt: 5 } })

// 终止操作
db.killOp(opId)

监控工具

1. MongoDB Atlas
   - 云监控
   - 性能洞察

2. MongoDB Compass
   - 可视化监控
   - 查询分析

3. Prometheus + Grafana
   - 自定义监控
   - 告警配置

4. MongoDB Ops Manager
   - 企业级监控
   - 自动化管理

// 分析原因
db.users.find({ name: "John" }).explain("executionStats")

// 解决方案
// 1. 创建索引
db.users.createIndex({ name: 1 })

// 2. 使用覆盖查询
db.users.find({ name: "John" }, { name: 1, email: 1, _id: 0 })

// 3. 限制返回数量
db.users.find({ name: "John" }).limit(100)

// 分析原因
db.currentOp({ "op": "write" })

// 解决方案
// 1. 批量写入
db.users.insertMany([...])

// 2. 降低写关注
db.users.insertOne({...}, { writeConcern: { w: 1 } })

// 3. 无序写入
db.users.insertMany([...], { ordered: false })

// 分析原因
db.serverStatus().memory

// 解决方案
// 1. 增加内存
// 2. 优化查询减少内存使用
// 3. 调整缓存大小

1. 使用索引
2. 使用投影
3. 使用limit
4. 避免全表扫描
5. 使用覆盖查询

1. 选择性高的字段
2. 复合索引设计
3. 删除冗余索引
4. 定期重建索引
5. 监控索引使用

1. 合理配置内存
2. 调整连接数
3. 优化日志级别
4. 使用合适的写关注