MongoDB Shell脚本编写与自动化实践

MongoDB Shell 脚本基础

基本语法与变量

在 MongoDB Shell 中，语法与 JavaScript 类似，因为 MongoDB Shell 基于 JavaScript 构建。变量的声明使用 var 关键字，例如：

var myVar = "Hello, MongoDB!";
print(myVar);

这里声明了一个字符串变量 myVar 并将其打印出来。在 MongoDB 中，变量可以用来存储数据库连接、集合对象等。例如，连接到本地 MongoDB 实例并选择一个数据库和集合：

var dbConn = connect("mongodb://localhost:27017");
var myDb = dbConn.getDB("myDatabase");
var myCollection = myDb.getCollection("myCollection");

上述代码首先使用 connect 函数连接到本地 MongoDB 服务器，然后获取指定的数据库 myDatabase 和集合 myCollection。

基本操作语句

1. 插入文档：使用 insert 方法向集合中插入文档。例如：

var newDocument = { name: "John", age: 30, city: "New York" };
myCollection.insert(newDocument);

这里创建了一个简单的文档对象 newDocument 并插入到 myCollection 集合中。也可以一次插入多个文档，将多个文档对象组成一个数组传递给 insert 方法：

var docs = [
    { name: "Jane", age: 25, city: "Los Angeles" },
    { name: "Bob", age: 40, city: "Chicago" }
];
myCollection.insert(docs);

2. 查询文档：使用 find 方法查询集合中的文档。基本的查询语法如下：

var cursor = myCollection.find();
cursor.forEach(function(doc) {
    printjson(doc);
});

这段代码查询 myCollection 中的所有文档，并通过 forEach 方法遍历游标 cursor，将每个文档以 JSON 格式打印出来。find 方法也可以接受查询条件，例如查找年龄大于 30 的文档：

var query = { age: { $gt: 30 } };
var result = myCollection.find(query);
result.forEach(function(doc) {
    printjson(doc);
});

这里使用 $gt（大于）操作符构建查询条件，仅返回年龄大于 30 的文档。

3. 更新文档：使用 update 方法更新集合中的文档。例如，将名字为 “John” 的文档的年龄增加 1：

var updateQuery = { name: "John" };
var updateOperation = { $inc: { age: 1 } };
myCollection.update(updateQuery, updateOperation);

$inc 操作符用于增加文档中指定字段的值。如果要更新多个文档，可以设置 multi 选项为 true：

myCollection.update(updateQuery, updateOperation, { multi: true });

4. 删除文档：使用 remove 方法删除集合中的文档。例如，删除名字为 “Bob” 的文档：

var deleteQuery = { name: "Bob" };
myCollection.remove(deleteQuery);

如果要删除集合中的所有文档，可以不传递查询条件：

myCollection.remove({});

函数与控制结构

自定义函数

在 MongoDB Shell 中，可以定义自己的函数来封装重复的操作。例如，定义一个函数来插入多个文档：

function insertMultipleDocs(docsArray) {
    myCollection.insert(docsArray);
}

var newDocs = [
    { name: "Alice", age: 28, city: "Houston" },
    { name: "Eve", age: 32, city: "Phoenix" }
];
insertMultipleDocs(newDocs);

这里定义了 insertMultipleDocs 函数，它接受一个文档数组作为参数，并将这些文档插入到 myCollection 集合中。

控制结构

1. if - else 语句：用于根据条件执行不同的代码块。例如，根据查询结果执行不同操作：

var count = myCollection.find({ age: { $gt: 30 } }).count();
if (count > 0) {
    print("There are more than 0 documents with age > 30.");
} else {
    print("There are no documents with age > 30.");
}

这段代码先统计年龄大于 30 的文档数量，然后根据数量执行不同的打印操作。

2. for 循环：可以用于遍历数组或执行指定次数的操作。例如，插入 10 个编号从 1 到 10 的文档：

for (var i = 1; i <= 10; i++) {
    var doc = { number: i };
    myCollection.insert(doc);
}

这里使用 for 循环生成 10 个文档并插入到集合中。

3. while 循环：根据条件循环执行代码块。例如，不断查询集合中的文档，直到文档数量达到 20：

while (myCollection.count() < 20) {
    var newDoc = { counter: myCollection.count() + 1 };
    myCollection.insert(newDoc);
}

此代码在集合中文档数量小于 20 时，持续插入新文档。

自动化实践基础

脚本文件的创建与执行

1. 创建脚本文件：可以使用文本编辑器创建一个 JavaScript 文件，例如 mongoScript.js，在其中编写 MongoDB Shell 脚本。例如：

var dbConn = connect("mongodb://localhost:27017");
var myDb = dbConn.getDB("myDatabase");
var myCollection = myDb.getCollection("myCollection");

var newDocument = { name: "Automated Insert", age: 22, city: "Automation City" };
myCollection.insert(newDocument);

2. 执行脚本文件：在命令行中使用 mongo 命令执行脚本文件。假设 mongoScript.js 位于当前目录下，执行命令如下：

mongo mongoScript.js

这样就会连接到指定的 MongoDB 实例，并执行脚本文件中的操作，向 myCollection 集合插入一个新文档。

传递参数到脚本

为了使脚本更具通用性，可以向脚本传递参数。在 mongo 命令中使用 --eval 选项结合 -- 分隔符来传递参数。例如，创建一个脚本 insertWithParam.js：

var param = JSON.parse(Param);
var dbConn = connect("mongodb://localhost:27017");
var myDb = dbConn.getDB("myDatabase");
var myCollection = myDb.getCollection("myCollection");

myCollection.insert(param);

然后在命令行中执行：

mongo insertWithParam.js --eval "var Param='{\"name\":\"Param Inserted\",\"age\":25,\"city\":\"Param City\"}'"

这里通过 --eval 定义了一个变量 Param，脚本中通过 JSON.parse 将其解析为对象并插入到集合中。

自动化备份与恢复

备份数据库

1. 使用 mongodump 工具：mongodump 是 MongoDB 自带的备份工具。在命令行中执行以下命令可以备份整个数据库：

mongodump --uri="mongodb://localhost:27017" --out=/backup/path

这里 --uri 指定了要备份的 MongoDB 实例地址，--out 指定了备份文件的输出目录。如果只需要备份特定的数据库，可以在 --uri 中指定数据库名称，例如：

mongodump --uri="mongodb://localhost:27017/myDatabase" --out=/backup/path

2. 使用 MongoDB Shell 脚本自动化备份：可以编写一个 MongoDB Shell 脚本结合 mongodump 命令实现自动化备份。例如，创建 backupScript.js：

var exec = require('child_process').exec;
var backupDir = '/backup/path/' + new Date().getTime();

var command = 'mongodump --uri="mongodb://localhost:27017" --out=' + backupDir;
exec(command, function (error, stdout, stderr) {
    if (error) {
        print('Backup failed: ', error);
    } else {
        print('Backup successful. Backup stored at: ', backupDir);
    }
});

在命令行中执行 mongo backupScript.js 即可执行备份操作，并将备份文件存储在以当前时间戳命名的目录中。

恢复数据库

1. 使用 mongorestore 工具：mongorestore 用于恢复 MongoDB 备份。例如，恢复之前备份的数据库：

mongorestore --uri="mongodb://localhost:27017" --dir=/backup/path

这里 --uri 指定要恢复到的 MongoDB 实例地址，--dir 指定备份文件所在目录。如果要恢复到特定的数据库，可以在 --uri 中指定数据库名称。

2. 使用 MongoDB Shell 脚本自动化恢复：创建 restoreScript.js 脚本：

var exec = require('child_process').exec;
var backupDir = '/backup/path';

var command ='mongorestore --uri="mongodb://localhost:27017" --dir=' + backupDir;
exec(command, function (error, stdout, stderr) {
    if (error) {
        print('Restore failed: ', error);
    } else {
        print('Restore successful.');
    }
});

执行 mongo restoreScript.js 即可自动化恢复数据库。

自动化数据迁移

跨实例迁移数据

1. 使用 mongoexport 和 mongoimport：mongoexport 用于将数据从 MongoDB 导出为 JSON 或 CSV 格式，mongoimport 用于将数据导入到 MongoDB。例如，从一个实例导出数据：

mongoexport --uri="mongodb://sourceInstance:27017/sourceDatabase" --collection=sourceCollection --out=exportedData.json

然后将导出的数据导入到另一个实例：

mongoimport --uri="mongodb://targetInstance:27017/targetDatabase" --collection=targetCollection --file=exportedData.json

2. 使用 MongoDB Shell 脚本自动化迁移：创建 dataMigration.js 脚本：

var exec = require('child_process').exec;
var exportCommand ='mongoexport --uri="mongodb://sourceInstance:27017/sourceDatabase" --collection=sourceCollection --out=exportedData.json';
var importCommand ='mongoimport --uri="mongodb://targetInstance:27017/targetDatabase" --collection=targetCollection --file=exportedData.json';

exec(exportCommand, function (error, stdout, stderr) {
    if (error) {
        print('Export failed: ', error);
    } else {
        exec(importCommand, function (error, stdout, stderr) {
            if (error) {
                print('Import failed: ', error);
            } else {
                print('Data migration successful.');
            }
        });
    }
});

执行 mongo dataMigration.js 即可实现跨实例的数据迁移。

数据转换与迁移

在数据迁移过程中，可能需要对数据进行转换。例如，将文档中的某个字段名称修改后再迁移。可以使用 MongoDB Shell 脚本来实现：

var sourceDbConn = connect("mongodb://sourceInstance:27017/sourceDatabase");
var sourceCollection = sourceDbConn.getCollection("sourceCollection");
var targetDbConn = connect("mongodb://targetInstance:27017/targetDatabase");
var targetCollection = targetDbConn.getCollection("targetCollection");

var cursor = sourceCollection.find();
cursor.forEach(function(doc) {
    var newDoc = doc;
    newDoc.newFieldName = newDoc.oldFieldName;
    delete newDoc.oldFieldName;
    targetCollection.insert(newDoc);
});

此脚本从源集合中读取文档，修改字段名称后插入到目标集合中。

自动化监控与维护

监控数据库状态

1. 使用 db.stats()：在 MongoDB Shell 中，可以使用 db.stats() 方法获取当前数据库的统计信息，例如数据库大小、文档数量等。

var stats = myDb.stats();
printjson(stats);

2. 自动化定期监控：可以编写一个脚本定时执行监控操作并记录结果。例如，创建 monitorScript.js：

var fs = require('fs');
var dbConn = connect("mongodb://localhost:27017");
var myDb = dbConn.getDB("myDatabase");
var stats = myDb.stats();

var logMessage = new Date() + ": " + JSON.stringify(stats) + "\n";
fs.appendFileSync('monitorLog.txt', logMessage);

通过使用操作系统的任务调度工具（如 cron 或 Windows 任务计划程序）定期执行 mongo monitorScript.js，可以实现定期监控并记录数据库状态。

索引维护

1. 创建索引：在 MongoDB 中，可以使用 createIndex 方法为集合创建索引以提高查询性能。例如，为 myCollection 集合的 name 字段创建索引：

myCollection.createIndex({ name: 1 });

这里 1 表示升序索引，-1 表示降序索引。 2. 自动化索引重建：为了确保索引的有效性，有时需要重建索引。可以编写脚本实现自动化重建索引。例如，创建 rebuildIndex.js：

var dbConn = connect("mongodb://localhost:27017");
var myDb = dbConn.getDB("myDatabase");
var myCollection = myDb.getCollection("myCollection");

var indexes = myCollection.getIndexes();
indexes.forEach(function(index) {
    if (index.name!== "_id_") {
        myCollection.dropIndex(index.name);
        myCollection.createIndex(index.key);
    }
});

执行 mongo rebuildIndex.js 可以删除除 _id_ 之外的所有索引并重新创建。

高级自动化技巧

结合外部工具与框架

1. 与 Python 和 PyMongo 结合：Python 可以通过 PyMongo 库与 MongoDB 进行交互。例如，在 Python 中编写脚本实现数据插入：

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017")
db = client["myDatabase"]
collection = db["myCollection"]

new_document = {"name": "Python Inserted", "age": 23, "city": "Python City"}
collection.insert_one(new_document)

通过结合 Python 的强大功能，可以实现更复杂的自动化任务，如数据处理、数据分析等与 MongoDB 操作的集成。

2. 与 Ansible 结合进行服务器级自动化：Ansible 是一个自动化运维工具，可以用于部署 MongoDB 实例、执行备份恢复等操作。例如，通过 Ansible playbook 部署 MongoDB：

- name: Install MongoDB
  hosts: all
  tasks:
    - name: Add MongoDB apt key
      apt_key:
        url: https://www.mongodb.org/static/pgp/server-4.4.asc
    - name: Add MongoDB repository
      apt_repository:
        repo: deb [arch=amd64] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse
        state: present
    - name: Install MongoDB packages
      apt:
        name: mongodb-org
        state: present
        update_cache: yes

这样可以在多台服务器上自动化部署 MongoDB，结合 MongoDB Shell 脚本进一步实现数据库层面的自动化操作。

错误处理与日志记录

1. 错误处理：在 MongoDB Shell 脚本中，要妥善处理错误。例如，在执行数据库操作时捕获错误：

try {
    myCollection.insert({ name: "Error Test" });
} catch (e) {
    print('Insertion error: ', e);
}

这里使用 try - catch 块捕获插入操作可能出现的错误并打印错误信息。

2. 日志记录：除了简单的打印错误信息，还可以使用日志记录库（如 winston 结合 Node.js 环境扩展 MongoDB Shell 功能）进行更详细的日志记录。例如，安装 winston 并在脚本中使用：

var winston = require('winston');

winston.add(winston.transport.Console, {
    format: winston.format.json()
});

try {
    myCollection.insert({ name: "Logging Test" });
    winston.info('Insertion successful');
} catch (e) {
    winston.error('Insertion error: ', e);
}

这样可以将操作信息和错误信息以 JSON 格式记录到控制台或文件中，方便后续排查问题。

通过以上对 MongoDB Shell 脚本编写与自动化实践的详细介绍，你可以根据实际需求灵活运用这些知识，实现高效的 MongoDB 数据库管理与自动化操作。无论是备份恢复、数据迁移还是监控维护，都可以通过精心编写的脚本和合理利用工具来完成。