MongoDB分片与备份恢复

MongoDB分片与备份恢复

Administrator 1117 2018-09-05
  1. mongodb分片介绍
  2. mongodb分片搭建
  3. mongodb分片测试
  4. mongodb备份恢复

MongoDB分片

分片介绍

  • 分片就是将数据库进行拆分，将大型集合分割到不同服务器上，比如，本来100G的数据，可以分割成10份存储到10台服务器上，这样每台机器只有10G数据；

  • 通过一个mongos的进程（路由）实现分片后的数据存储和访问，也就是说mongos是整个分片架构的核心，对客户端而言是不知道是否有分片的，客户端只需要把读写操作转达给mongos即可，不再发送的mongod；

  • 虽然分片会把数据分割到很多台服务器上，但是每个节点（副本集）都是需要有一个备用角色的，这样能够保证数据的高可用；

  • 当系统需要更多空间或资源的时候，分片可以让我们按需方便扩展，只需要吧mongodb服务的机器加入到分片集群中即可；

  • MongoDB分片架构图：

    i9Z3md.png

    • 图中不论是Router还是Config Servers、Shard，都是由副本集构成的，以实现高可用。

  • mongos：数据库集群请求的入口，所有的请求都通过mongos进行协调，不需要在应用程序中添加一个路由选择器，mongos自己就是一个请求分发中心，它负责把对应的数据请求转发到对应的Shard服务器上，在生产环境中，通常有多mongos作为请求的入口，防止其中一个发生宕机导致所有的mongodb请求都没办法操作；

  • config server：配置服务器，存储所有数据库元信息（路由、分片）的配置，mongos本身没有物理存储分片服务器和数据路由信息，只是缓存在内存里，配置服务器则实际存储这些数据，mongos第一次启动或者重启，就会从config server中加载配置信息，以后如果配置服务器信息变化，会通知到所有的mongos更新自己的状态，这样mongos就能继续准确路由，在生产环境中通常有多个config server配置服务器，因为它存储了分片路由的元数据，防止数据丢失；

  • shard：存储了一个集合部分数据的MongoDB实例，每个分片是单独的MongoDB服务或者副本集，在生产环境中，所有的分片都应该是副本集。

分片搭建

服务器规划

  • 准备三台机器A、B、C
  • A搭建：mongos、config server、副本集1主节点、副本集2仲裁、副本集3从节点；
  • B搭建：mongos、config server、副本集1从节点、副本集2主节点、副本集3仲裁；
  • C搭建：mongos、config server、副本集1仲裁、副本集2从节点、副本集3主节点
  • 端口分配：mongos 20000，config 21000，副本集1 27001，副本集2 27002，副本集3 27003
  • 三台机器全部关闭firewalld和selinux服务，或者增加对应端口规则。

目录规划

  • 分别在三台机器上创建各个角色所需的目录：

    mkdir -p /data/mongodb/mongos/log
mkdir -p /data/mongodb/config/{data,log}
mkdir -p /data/mongodb/shard1/{data,log}
mkdir -p /data/mongodb/shard2/{data,log}
mkdir -p /data/mongodb/shard3/{data,log}

config server配置

  • 为三台机器添加config server配置文件：

    mkdir /etc/mongod/
vim /etc/mongod/config.conf

    写入如下内容：

    pidfilepath = /var/run/mongodb/configsrv.pid
dbpath = /data/mongodb/config/data/
logpath = /data/mongodb/config/log/configsrv.log
logappend = true
bind_ip = 0.0.0.0 #可以绑定各机器自己的内网ip
port = 21000
fork = true
configsvr = true	#declare this is a config db of cluster;
replSet=configs #副本集名称
maxConns=20000	#最大连接数

  • 然后分别启动三台config server服务：

    $ mongod -f /etc/mongod/config.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 6448
child process started successfully, parent exiting

$ ps aux |grep mongod
root       6448 11.0  9.8 1069924 47524 ?       Sl   22:28   0:00 mongod -f /etc/mongod/config.conf

$ netstat -tlnp|grep mongod
tcp        0      0 192.168.49.128:21000    0.0.0.0:*               LISTEN      6448/mongod

  • 登录任意一台机器的21000端口，初始化config server副本集：

    $ mongo --port 21000 --host 192.168.49.128

> config={_id:"configs",members:[{_id:0,host:"192.168.49.128:21000"},{_id:1,host:"192.168.49.129:21000"},{_id:2,host:"192.168.49.130:21000"}]}

> rs.initiate(config)
{
	"ok" : 1,
	"operationTime" : Timestamp(1536245789, 1),
	"$gleStats" : {
		"lastOpTime" : Timestamp(1536245789, 1),
		"electionId" : ObjectId("000000000000000000000000")
	},
	"$clusterTime" : {
		"clusterTime" : Timestamp(1536245789, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

分片(shard)配置

  • 在三台服务器上添加配置文件vi /etc/mongod/shard1.conf，写入以下内容：

    pidfilepath = /var/run/mongodb/shard1.pid
dbpath = /data/mongodb/shard1/data/
logpath = /data/mongodb/shard1/log/shard1.log
logappend = true
bind_ip = 0.0.0.0
port = 27001
fork = true
httpinterface = true	#打开web监控，3.6版本后已删除此配置参数
rest = true	# 3.6之后版本需要删除此配置项
replSet = shard1	#副本集名称
shardsvr = true
maxConns = 20000

  • 然后将三台服务器上的shard1的配置文件拷贝为shard2.conf和shard3.conf，并修改对应的配置：

    $ cp shard1.conf shard2.conf 
$ cp shard1.conf shard3.conf 
$ sed -i 's/shard1/shard2/g;s/27001/27002/g' shard2.conf
$ sed -i 's/shard1/shard3/g;s/27001/27003/g' shard3.conf

  • 接着在三台服务器上启动shard1：

    //启动shard1
$ ps aux |grep mongod
root       6448  0.5 11.9 1580640 57964 ?       Sl   22:28   0:23 mongod -f /etc/mongod/config.conf
root       6646  4.7  9.8 1028944 47448 ?       Sl   23:40   0:00 mongod -f /etc/mongod/shard1.conf
root       6672  0.0  0.2 112724   976 pts/1    R+   23:41   0:00 grep --color=auto mongod
$ netstat -tlnp|grep mongod
tcp        0      0 0.0.0.0:27001           0.0.0.0:*               LISTEN      6646/mongod         
tcp        0      0 192.168.49.128:21000    0.0.0.0:*               LISTEN      6448/mongod

  • 登录128或129的mongo命令行，配置副本集，130由于作为shard1的仲裁，所以不能在130机器上进行配置：

    //配置副本集
$ mongo --port 27001
> use admin
> config={_id:"shard1",members:[{_id:0,host:"192.168.49.128:27001"},{_id:1,host:"192.168.49.129:27001"},{_id:2,host:"192.168.49.130：27001",arbiterOnly:true}]}
> rs.initiate(config)

  • shard2副本集配置：

    $ mongod -f /etc/mongod/shard2.conf
$ mongo --port 27002
> use admin
> config={_id:"shard2",members:[{_id:0,host:"192.168.49.128:27002",arbiterOnly:true},{_id:1,host:"192.168.49.129:27002"},{_id:3,host:"192.168.49.130:27002"}]}
> rs.initiate(config)

  • shard3副本集配置：

    $ mongod -f /etc/mongod/shard2.conf
$ mongo --port 27002
> use admin
> config={_id:"shard2",members:[{_id:0,host:"192.168.49.128:27003"},{_id:1,host:"192.168.49.129:27003",arbiterOnly:true},{_id:3,host:"192.168.49.130:27003"}]}
> rs.initiate(config)

路由服务器(mongos)配置

  • 在三台服务器上添加配置文件vi /etc/mongod/mongos.conf,写入如下内容：

    pidfilepath = /var/run/mongodb/mongos.pid
logpath = /data/mongodb/mongos/log/mongos.log
logappend = true
bind_ip = 0.0.0.0
port = 20000
fork = true
configdb = configs/192.168.49.128:21000,192.168.49.129:21000,192.168.49.130:21000	#监听的配置服务器，只能有1个或者3个，configs为配置服务器的副本集名字
maxConns = 20000

  • 启动mongos服务，启动命令与config server和shard不同：

    mongos -f /etc/mongod/mongos.conf

    $ ps aux |grep mongos
root       6927  1.5  2.6 255320 12676 ?        Sl   00:12   0:00 mongos -f /etc/mongod/mongos.conf
root       6952  0.0  0.2 112724   976 pts/1    D+   00:12   0:00 grep --color=auto mongos
$ netstat -tlnp |grep mongos
tcp        0      0 0.0.0.0:20000           0.0.0.0:*               LISTEN      6927/mongos

  • 然后登录任何一台机器的20000端口，将所有的分片和路由串联：

    $ mongo --port 20000
mongos> use admin
mongos> sh.addShard("shard1/192.168.49.128:27001,192.168.49.129:27001,192.168.49.130:27001")
mongos> sh.addShard("shard2/192.168.49.128:27002,192.168.49.129:27002,192.168.49.130:27002")
mongos> sh.addShard("shard3/192.168.49.128:27003,192.168.49.129:27003,192.168.49.130:27003")

  • 查看集群状态使用rs.status()命令：

    mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("5b91402a5d2d80280a48ee8c")
  }
  shards:
        {  "_id" : "shard1",  "host" : "shard1/192.168.49.128:27001,192.168.49.129:27001",  "state" : 1 }
        {  "_id" : "shard2",  "host" : "shard2/192.168.49.129:27002,192.168.49.130:27002",  "state" : 1 }
        {  "_id" : "shard3",  "host" : "shard3/192.168.49.128:27003,192.168.49.130:27003",  "state" : 1 }
  active mongoses:
        "3.6.7" : 1
  autosplit:
        Currently enabled: yes	#当前分片状态
  balancer:
        Currently enabled:  yes	#当前负载均衡状态
        Currently running:  no	# 由于没有存入数据，所以运行状态为no
        Failed balancer rounds in last 5 attempts:  0
        Migration Results for the last 24 hours: 
                No recent migrations
  databases:
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                shard1	1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : shard1 Timestamp(1, 0)

分片测试

  • 登录任何一台服务器的mongo 20000端口；

  • 执行命令db.runCommand({enablesharding:"testdb"})或者sh.enableSharding("testdb")，用来指定要分片的数据库，如果数据库不存在，会自动创建：

    mongos> db.runCommand({enablesharding:"testdb"})
{
	"ok" : 1,
	"operationTime" : Timestamp(1536251270, 8),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1536251270, 8),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

  • 执行db.runCommand({shardcollection:"testdb.table1",key:{id:1}})或者sh.shardCollection("testdb.table1",{"id":1})，用来指定数据库里需要分片的集合和片键：

    mongos> sh.shardCollection("testdb.table1",{"id":1})
{
	"collectionsharded" : "testdb.table1",
	"collectionUUID" : UUID("ce310fe8-9c4e-4d0a-8b4a-b0ee39940352"),
	"ok" : 1,
	"operationTime" : Timestamp(1536251408, 14),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1536251408, 14),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

  • 然后为testdb数据库插入10000条数据：

    mongos> use testdb
switched to db testdb
mongos> for (var i=1;i<10000;i++) db.table1.save({id:i,"test1":"testval1"})
WriteResult({ "nInserted" : 1 })

mongos> db.table1.stats()	#查看table1状态

  • 执行sh.status()可以看到testdb所在的分片：

    mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("5b91402a5d2d80280a48ee8c")
  }
  shards:
        {  "_id" : "shard1",  "host" : "shard1/192.168.49.128:27001,192.168.49.129:27001",  "state" : 1 }
        {  "_id" : "shard2",  "host" : "shard2/192.168.49.129:27002,192.168.49.130:27002",  "state" : 1 }
        {  "_id" : "shard3",  "host" : "shard3/192.168.49.128:27003,192.168.49.130:27003",  "state" : 1 }
  active mongoses:
        "3.6.7" : 1
  autosplit:
        Currently enabled: yes
  balancer:
        Currently enabled:  yes
        Currently running:  no
        Failed balancer rounds in last 5 attempts:  0
        Migration Results for the last 24 hours: 
                No recent migrations
  databases:
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                shard1	1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : shard1 Timestamp(1, 0) 
        {  "_id" : "testdb",  "primary" : "shard2",  "partitioned" : true }
                testdb.table1
                        shard key: { "id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                shard2	1	#所在shard2
                        { "id" : { "$minKey" : 1 } } -->> { "id" : { "$maxKey" : 1 } } on : shard2 Timestamp(1, 0)

MongoDB备份恢复

备份

  • 备份指定库：

    mongodump --host [ip] --port [port] -d [db] -o [/path/to/dir/]

    $ mkdir /tmp/mongobak 
$ mongodump --host 127.0.0.1 --port 20000 -d testdb -o /tmp/mongobak/
2018-09-07T00:44:38.132+0800	writing testdb.table1 to 
2018-09-07T00:44:38.247+0800	done dumping testdb.table1 (9999 documents)

# 会生成对应数据库同名的目录，并生成两个备份文件
$ ls /tmp/mongobak/testdb/
table1.bson  table1.metadata.json

  • 备份所有库：

    mongodump --host [ip] --port [port] -o [/path/to/dir/]

    $ mongodump --host 127.0.0.1 --port 20000 -o /tmp/mongobak/
2018-09-07T00:48:30.744+0800	writing admin.system.version to 
2018-09-07T00:48:30.747+0800	done dumping admin.system.version (1 document)
2018-09-07T00:48:30.747+0800	writing testdb.table1 to 
2018-09-07T00:48:30.747+0800	writing db2.tb1 to 
2018-09-07T00:48:30.748+0800	writing db2.table1 to 
2018-09-07T00:48:30.748+0800	writing config.locks to 
2018-09-07T00:48:30.757+0800	done dumping config.locks (10 documents)
2018-09-07T00:48:30.757+0800	writing config.lockpings to 
2018-09-07T00:48:30.786+0800	done dumping config.lockpings (10 documents)
2018-09-07T00:48:30.786+0800	writing config.changelog to 
2018-09-07T00:48:30.876+0800	done dumping db2.tb1 (9999 documents)
2018-09-07T00:48:30.876+0800	writing config.collections to 
2018-09-07T00:48:30.881+0800	done dumping db2.table1 (6526 documents)
2018-09-07T00:48:30.881+0800	writing config.chunks to 
2018-09-07T00:48:30.882+0800	done dumping config.changelog (9 documents)
2018-09-07T00:48:30.882+0800	writing config.shards to 
2018-09-07T00:48:30.889+0800	done dumping config.shards (3 documents)
2018-09-07T00:48:30.889+0800	writing config.databases to 
2018-09-07T00:48:30.889+0800	done dumping config.collections (3 documents)
2018-09-07T00:48:30.889+0800	writing config.version to 
2018-09-07T00:48:30.891+0800	done dumping config.chunks (3 documents)
2018-09-07T00:48:30.891+0800	writing config.mongos to 
2018-09-07T00:48:30.921+0800	done dumping testdb.table1 (9999 documents)
2018-09-07T00:48:30.921+0800	writing config.migrations to 
2018-09-07T00:48:30.922+0800	done dumping config.version (1 document)
2018-09-07T00:48:30.922+0800	writing config.tags to 
2018-09-07T00:48:30.923+0800	done dumping config.databases (2 documents)
2018-09-07T00:48:30.923+0800	done dumping config.mongos (1 document)
2018-09-07T00:48:30.925+0800	done dumping config.migrations (0 documents)
2018-09-07T00:48:30.926+0800	done dumping config.tags (0 documents)

$ ls /tmp/mongobak/
admin  config  db2  testdb

  • 备份指定集合：

    mongodump --host [ip] --port [port] -d [db] -c [collection] -o [/path/dir/]

    $ mongodump --port 20000 -d db2 -c tb1 -o /tmp/db2
2018-09-07T00:52:31.596+0800	writing db2.tb1 to 
2018-09-07T00:52:31.645+0800	done dumping db2.tb1 (9999 documents)
$ ls /tmp/db2/
db2
$ ls /tmp/db2/db2/
tb1.bson  tb1.metadata.json

  • 导出集合为json文件：

    mongoexport --host [ip] --port [port] -d [db] -c [collection] -o [/path/dir/name.json]

    $ mongoexport --port 20000 -d db2 -c tb1 -o /tmp/db2/tb1.json
2018-09-07T00:54:42.632+0800	connected to: localhost:20000
2018-09-07T00:54:42.933+0800	exported 9999 records

# json格式数据
$ cat /tmp/db2/tb1.json 
{"_id":{"$oid":"5b915896464b3a14f3e21883"},"id":1.0,"t2":"testval2"}
{"_id":{"$oid":"5b915896464b3a14f3e21884"},"id":2.0,"t2":"testval2"}
{"_id":{"$oid":"5b915896464b3a14f3e21885"},"id":3.0,"t2":"testval2"}
{"_id":{"$oid":"5b915896464b3a14f3e21886"},"id":4.0,"t2":"testval2"}
{"_id":{"$oid":"5b915896464b3a14f3e21887"},"id":5.0,"t2":"testval2"}
...

恢复

  • 恢复所有库：

    mongorestore --host [ip] --port [port] --drop /path/dir/
    • 这里dir是备份所有库的目录的名字，其中--drop为可选参数，作用是在恢复之前先将数据情况，不建议使用。
    # 删除数据库
mongos> show dbs
admin   0.000GB
config  0.001GB
db2     0.001GB
testdb  0.000GB
mongos> db.drop
db.dropAllRoles(  db.dropAllUsers(  db.dropDatabase(  db.dropRole(      db.dropUser(
mongos> db.dropDatabase(db2)
2018-09-07T01:02:50.898+0800 E QUERY    [thread1] ReferenceError: db2 is not defined :
@(shell):1:1
mongos> use db2
switched to db db2
mongos> db.dropDatabase()
{
	"dropped" : "db2",
	"ok" : 1,
	"operationTime" : Timestamp(1536253396, 11),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1536253396, 11),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
mongos> show dbs
admin   0.000GB
config  0.001GB
testdb  0.000GB
mongos> use testdb
switched to db testdb
mongos> db.dropDatabase()
{
	"dropped" : "testdb",
	"ok" : 1,
	"operationTime" : Timestamp(1536253408, 18),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1536253408, 18),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 报错是由于config和admin数据库无法恢复，需要先删除
$ mongorestore --port 20000 --drop /tmp/mongobak/
2018-09-07T01:04:55.684+0800	preparing collections to restore from
2018-09-07T01:04:55.685+0800	Failed: cannot do a full restore on a sharded system - remove the 'config' directory from the dump directory first

$ rm -rf /tmp/mongobak/config/
$ mongorestore --port 20000 --drop /tmp/mongobak/
2018-09-07T01:06:01.752+0800	preparing collections to restore from
2018-09-07T01:06:01.756+0800	reading metadata for testdb.table1 from /tmp/mongobak/testdb/table1.metadata.json
2018-09-07T01:06:01.769+0800	reading metadata for db2.tb1 from /tmp/mongobak/db2/tb1.metadata.json
2018-09-07T01:06:01.790+0800	reading metadata for db2.table1 from /tmp/mongobak/db2/table1.metadata.json
2018-09-07T01:06:02.399+0800	restoring testdb.table1 from /tmp/mongobak/testdb/table1.bson
2018-09-07T01:06:02.423+0800	restoring db2.tb1 from /tmp/mongobak/db2/tb1.bson
2018-09-07T01:06:02.492+0800	restoring db2.table1 from /tmp/mongobak/db2/table1.bson
2018-09-07T01:06:03.231+0800	no indexes to restore
2018-09-07T01:06:03.231+0800	finished restoring db2.table1 (6526 documents)
2018-09-07T01:06:03.393+0800	restoring indexes for collection testdb.table1 from metadata
2018-09-07T01:06:03.396+0800	restoring indexes for collection db2.tb1 from metadata
2018-09-07T01:06:03.488+0800	finished restoring testdb.table1 (9999 documents)
2018-09-07T01:06:03.498+0800	finished restoring db2.tb1 (9999 documents)
2018-09-07T01:06:03.498+0800	done

# 恢复成功
mongos> show dbs
admin   0.000GB
config  0.001GB
db2     0.000GB
testdb  0.000GB

  • 恢复指定库：

    mongorestore --host [ip] --port [port] -d [db] /bak/dir/
    • 其中-d指定恢复库的名字，dir为该库备份时所在目录
    $ mongorestore --port 20000 -d db2 /tmp/db2/db2/
2018-09-07T01:10:43.043+0800	the --db and --collection args should only be used when restoring from a BSON file. Other uses are deprecated and will not exist in the future; use --nsInclude instead
2018-09-07T01:10:43.043+0800	building a list of collections to restore from /tmp/db2/db2 dir
2018-09-07T01:10:43.046+0800	reading metadata for db2.tb1 from /tmp/db2/db2/tb1.metadata.json
2018-09-07T01:10:43.309+0800	restoring db2.tb1 from /tmp/db2/db2/tb1.bson
2018-09-07T01:10:43.811+0800	restoring indexes for collection db2.tb1 from metadata
2018-09-07T01:10:43.843+0800	finished restoring db2.tb1 (9999 documents)
2018-09-07T01:10:43.843+0800	done

  • 恢复集合：

    mongorestore --host [ip] --port [port] -d [db] -c [collection] /dir/db/collection.bson
    • 其中-c指定要恢复的集合的名字，dir为备份时生成文件所在路径，这里要指定到集合的bson文件路径。
    # 删除集合
mongos> use db2
switched to db db2
mongos> show tables
tb1
mongos> db.tb1.drop()
true
mongos> show tables;
mongos> 
bye

$ mongorestore --port 20000 -d db2 -c tb1 /tmp/db2/db2/tb1.bson 
2018-09-07T01:19:28.287+0800	checking for collection data in /tmp/db2/db2/tb1.bson
2018-09-07T01:19:28.289+0800	reading metadata for db2.tb1 from /tmp/db2/db2/tb1.metadata.json
2018-09-07T01:19:28.297+0800	restoring db2.tb1 from /tmp/db2/db2/tb1.bson
2018-09-07T01:19:28.559+0800	restoring indexes for collection db2.tb1 from metadata
2018-09-07T01:19:28.588+0800	finished restoring db2.tb1 (9999 documents)
2018-09-07T01:19:28.588+0800	done

  • 导入集合：

    mongodimport --host [ip] --port [port] -d [db] -c [collection] --file /dir/collection.json

    $ mongoimport --port 20000 -d db2 -c tb1 --file /tmp/db2/tb1.json 
2018-09-07T01:23:38.029+0800	connected to: localhost:20000
2018-09-07T01:23:38.598+0800	imported 9999 documents
MongoDB