后端开发数据库

MongoDB 大数据量索引创建实战：后台模式与进度监控

, ,

处理千万级甚至亿级数据的 MongoDB 时，索引创建是个大问题。用错方式可能阻塞整个库，影响线上服务。这篇记录一下大数据量场景下的索引创建策略，包括前台/后台创建、进度监控、踩过的坑。

索引创建方式对比

前台创建（Foreground）

1
2
// 默认方式：前台创建索引
db.collection.createIndex({ field: 1 })

特点：

  • 阻塞集合上的所有读写操作
  • 索引创建期间数据库无法提供正常服务
  • 适用于维护窗口或新集合
1
2
3
4
5
6
7
8
9
10
时间线：
├─ 开始创建索引
├─ 阻塞所有操作 [==========]
├─ 索引创建完成
└─ 恢复正常服务

影响：
- 应用程序超时
- 用户体验下降
- 可能的雪崩效应

后台创建（Background）

1
2
3
4
5
// 后台创建索引
db.collection.createIndex(
    { field: 1 },
    { background: true }
)

特点：

  • 不阻塞集合的读写操作
  • 数据库可以正常提供服务
  • 创建时间较长
1
2
3
4
5
6
7
8
9
10
11
时间线：
├─ 开始创建索引
├─ 正常读写操作 [==========] (同时进行)
├─ 后台索引创建 [==========] (同时进行)
├─ 索引创建完成
└─ 索引自动生效

优势：
- 服务不中断
- 用户无感知
- 适合线上环境

方式对比

特性 前台创建 后台创建
阻塞读写 是 否
创建速度 快 慢（约2-3倍）
线上可用 否 是
资源占用 高 较低
回滚能力 无 有限

大数据量索引创建实战

千万级数据索引创建

1
2
3
4
5
6
7
8
9
10
11
// 示例：927万条数据创建索引
// 预估时间：数小时

db.inventory.createIndex(
    { item: 1 },
    {
        background: true,        // 后台创建
        unique: false,           // 非唯一索引
        name: "idx_item"         // 指定索引名称
    }
)

创建复合索引：

1
2
3
4
5
6
7
8
9
// 复合索引，包含稀疏选项
db.people.createIndex(
    { city: 1, zipcode: 1 },
    {
        background: true,
        sparse: true,            // 稀疏索引，跳过不存在字段的文档
        name: "idx_city_zip"
    }
)

索引创建进度监控

使用 currentOp 查看进度

1
2
3
4
5
6
db.currentOp({
    $or: [
        { op: "command", "query.createIndexes": { $exists: true } },
        { op: "insert", ns: /\.system\.indexes\b/ }
    ]
})

返回结果解析：

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
{
    "inprog": [
        {
            "desc": "conn1",
            "threadId": "139911670933248",
            "connectionId": 1,
            "client": "127.0.0.1:37524",
            "active": true,
            "opid": 5014925,
            "secs_running": 21,
            "microsecs_running": NumberLong(21800738),
            "op": "command",
            "ns": "test.$cmd",
            "query": {
                "createIndexes": "inventory",
                "indexes": [
                    {
                        "ns": "test.inventory",
                        "key": { "item": 1 },
                        "name": "item_1"
                    }
                ]
            },
            "msg": "Index Build Index Build: 3103284/5000000 62%",
            "progress": {
                "done": 3103722,
                "total": 5000000
            },
            "numYields": 0,
            "locks": {
                "Global": "w",
                "Database": "W",
                "Collection": "w"
            },
            "waitingForLock": false
        }
    ],
    "ok": 1
}

关键字段说明：

字段 含义 示例值
secs_running 已运行秒数 21
msg 进度信息 “62%”
progress.done 已完成文档数 3103722
progress.total 总文档数 5000000
locks 持有的锁 Global: w

进度监控脚本

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
// 实时监控索引创建进度
function monitorIndexBuild() {
    const interval = setInterval(() => {
        const ops = db.currentOp({
            "msg": /Index Build/
        }).inprog;

        if (ops.length === 0) {
            print("索引创建完成！");
            clearInterval(interval);
            return;
        }

        ops.forEach(op => {
            const percent = (op.progress.done / op.progress.total * 100).toFixed(2);
            const elapsed = Math.floor(op.secs_running / 60);
            const remaining = Math.floor(
                (op.progress.total - op.progress.done) /
                (op.progress.done / op.secs_running) / 60
            );

            print(`索引: ${op.query.createIndexes}`);
            print(`进度: ${op.progress.done}/${op.progress.total} (${percent}%)`);
            print(`已用: ${elapsed}分钟, 预计剩余: ${remaining}分钟`);
            print("---");
        });
    }, 5000); // 每5秒检查一次
}

monitorIndexBuild();

终止索引创建

如果需要终止正在创建的索引：

1
2
3
4
5
6
// 1. 先找到操作的 opid
db.currentOp({ "msg": /Index Build/ })

// 2. 使用 killOp 终止
// 注意：终止后已创建的索引部分会被删除
db.killOp(5014925)  // 替换为实际的 opid

注意事项：

  • 终止后需要重新创建索引
  • 终止操作不会保留部分创建的索引
  • 终止可能需要一些时间才能生效

索引创建期间注意事项

1. 会话阻塞问题

1
2
3
4
5
6
7
重要提示：
即使使用后台创建索引，当前执行 createIndex 的会话/连接
在索引创建完成前将不可用。

解决方案：
- 使用单独的连接/会话执行创建索引命令
- 应用程序连接不受影响

Mongo Shell 示例：

1
2
3
4
5
6
7
8
# 终端1：创建索引（此终端会被阻塞）
mongo
db.largeCollection.createIndex({ field: 1 }, { background: true })
# 等待完成...

# 终端2：其他操作（不受影响）
mongo
db.largeCollection.find()  # 可以正常查询

2. 管理操作限制

索引创建期间，以下管理操作无法执行：

1
2
3
4
5
6
7
8
9
10
11
12
// ❌ 以下操作在索引创建期间会被阻塞

// 修复数据库
db.repairDatabase()

// 删除集合
db.collection.drop()

// 压缩集合
db.collection.compact()

// 其他管理命令...

3. 异常中断处理

MongoDB 重启后的行为

1
2
3
4
5
6
7
8
9
10
11
12
13
场景：后台创建索引期间 mongod 异常终止

行为：
1. 未完成的索引创建将作为前台进程在启动时执行
2. 如果索引创建失败（如重复键错误），mongod 会报错并退出

解决方案：
1. 启动时使用 --noIndexBuildRetry 跳过索引创建
   mongod --noIndexBuildRetry

2. 或在配置文件中设置
   storage:
     indexBuildRetry: false

性能优化策略

1. 选择合适的维护窗口

1
2
3
4
5
6
7
8
9
10
11
12
// 即使使用后台创建，也建议在低峰期执行
// 减少对其他操作的影响

// 查看集合大小和预估时间
const stats = db.collection.stats()
print(`文档数: ${stats.count}`)
print(`数据大小: ${stats.size / 1024 / 1024} MB`)
print(`平均文档大小: ${stats.avgObjSize} bytes`)

// 预估索引创建时间（粗略估算）
// 1000万条数据可能需要数小时
// 具体时间取决于硬件性能和索引复杂度

2. 内存配置优化

1
2
3
4
5
6
7
8
9
10
11
12
// 确保有足够的内存用于索引创建
// 建议：索引大小 + 工作集 能放入内存

// 查看当前内存使用
db.serverStatus().mem

// 理想状态
{
    "resident": 2048,    // 物理内存使用 MB
    "virtual": 4096,     // 虚拟内存 MB
    "mapped": 3072       // 映射内存 MB
}

3. 分批创建索引

对于超大规模数据，考虑先导入数据再创建索引：

1
2
3
4
5
6
7
8
9
10
11
12
# 1. 导入数据（不带索引）
mongoimport -d mydb -c temp_collection --file data.json

# 2. 创建索引
mongo mydb --eval '
    db.temp_collection.createIndex({ field: 1 }, { background: true })
'

# 3. 重命名集合（原子操作）
mongo mydb --eval '
    db.temp_collection.renameCollection("production_collection", true)
'

4. 使用隐藏索引（MongoDB 4.4+）

1
2
3
4
5
6
7
8
9
10
11
// 创建隐藏索引，测试性能影响
db.collection.createIndex(
    { field: 1 },
    { hidden: true }  // 隐藏索引，查询优化器不可见
)

// 测试完成后取消隐藏
db.collection.unhideIndex("field_1")

// 或删除隐藏索引
db.collection.dropIndex("field_1")

索引创建性能对比

实际测试数据

数据量 索引字段 前台创建 后台创建 性能影响
100万 单字段 30秒 90秒 无
1000万 单字段 5分钟 15分钟 轻微
5000万 单字段 30分钟 90分钟 明显
1000万 复合索引 10分钟 30分钟 轻微
1000万 多键索引 15分钟 45分钟 明显

影响因素分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
索引创建时间影响因素：

1. 文档数量
   文档数 ↑ → 时间 ↑（线性关系）

2. 文档大小
   文档大小 ↑ → 时间 ↑

3. 索引字段类型
   字符串 > 数字 > 布尔值

4. 索引类型
   单字段 < 复合索引 < 多键索引 < 文本索引

5. 系统资源
   CPU、内存、磁盘 I/O

6. 并发操作
   后台创建时，读写操作会影响索引创建速度

最佳实践总结

线上环境索引创建流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1. 评估阶段
   ├─ 确认索引必要性
   ├─ 预估数据量和创建时间
   └─ 选择维护窗口

2. 准备阶段
   ├─ 备份数据（可选）
   ├─ 准备监控脚本
   └─ 通知相关人员

3. 执行阶段
   ├─ 使用 background: true 创建
   ├─ 实时监控进度
   └─ 观察系统负载

4. 验证阶段
   ├─ 确认索引创建成功
   ├─ 验证查询性能提升
   └─ 检查日志有无异常

索引创建检查清单

1
2
3
4
5
6
□ 是否使用了 background: true？
□ 是否选择了低峰期执行？
□ 是否监控了创建进度？
□ 是否准备了终止方案？
□ 是否验证了索引效果？
□ 是否更新了文档/运维手册？

常见问题

Q1: 后台创建索引为什么还是影响了性能？

原因：

  • 后台创建仍需要读取所有文档
  • 磁盘 I/O 竞争
  • 内存压力增加

优化：

  • 选择低峰期执行
  • 增加系统资源
  • 考虑分片集群分散压力

Q2: 索引创建到 90% 后很慢？

原因：

  • 最后阶段需要完成索引构建和验证
  • 可能遇到锁竞争

处理：

  • 耐心等待，不要强制终止
  • 检查当前操作是否有异常

Q3: 如何加速索引创建？

方法：

  • 临时增加内存
  • 使用 SSD 存储
  • 停止不必要的读操作
  • 考虑使用前台创建（维护窗口）

总结

MongoDB 大数据量索引创建的要点：

  1. 必须用后台创建：线上环境一定要加 background: true
  2. 监控创建进度：用 currentOp 实时跟踪，心里有数
  3. 选对执行时机：低峰期执行，减少影响
  4. 预留足够时间：大数据量可能要几个小时
  5. 准备应急预案：知道怎么终止和恢复，万一出问题能及时止损

索引创建这东西，看着简单，但大数据量时很容易出问题，提前规划好能省很多麻烦。