第一章：逻辑结构

Mongodb

MySQL

database

collection

document

第二章：安装部署

系统准备

redhat

centos6.2

ip

hosts

iptables

SElinux

其他系统关闭参照官方文档：

https://docs.mongodb.com/manual/tutorial/transparent-huge-pages/

关闭

THP

Transparent Huge Pages (THP) is a Linux memory management system
that reduces the overhead of Translation Lookaside Buffer (TLB)
lookups on machines with large amounts of memory by using larger memory pages.
However, database workloads often perform poorly with THP,
because they tend to have sparse rather than contiguous memory access patterns.
You should disable THP on Linux machines to ensure best performance with MongoDB.

 透明大页面（THP）是一个Linux内存管理系统
 它降低了翻译查询缓冲区（TLB）的开销
 通过使用较大的内存页在具有大量内存的计算机上查找。
 但是，使用THP时，数据库工作负载通常表现不佳，
 因为它们倾向于使用稀疏而不是连续的内存访问模式。
 您应该在Linux机器上禁用THP，以确保MongoDB的最佳性能。

[root@db01 ~]# vi /etc/rc.local
if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
echo never > /sys/kernel/mm/transparent_hugepage/enabled
fi
if test -f /sys/kernel/mm/transparent_hugepage/defrag; then
echo never >/sys/kernel/mm/transparent_hugepage/defrag
fi
cat  /sys/kernel/mm/transparent_hugepage/enabled
cat /sys/kernel/mm/transparent_hugepage/defrag

mongodb安装

创建所需用户和组

[root@db01 opt]#  useradd mongod
[root@db01 opt]#  passwd mongod

创建mongodb所需目录结构

mkdir -p /mongodb/conf
mkdir -p /mongodb/log
mkdir -p /mongodb/data

上传并解压软件到指定位置

下载： https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-4.4.2.tgz

法一:

[root@db01opt]# wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-4.4.2.tgz
[root@db01 opt]# tar xf mongodb-linux-x86_64-rhel70-4.2.8.tgz
[root@db01 opt]# ln -s /opt/mongodb-linux-x86_64-rhel70-4.2.8 /usr/local/mongodb

法二：

[root@db01 opt]# rz 上传
[root@db01 opt]# tar xf mongodb-linux-x86_64-rhel70-4.2.8.tgz
[root@db01 opt]# ln -s /opt/mongodb-linux-x86_64-rhel70-4.2.8 /usr/local/mongodb

设置目录结构权限

[root@db01 opt]#  chown -R mongod:mongod /mongodb

设置用户环境变量

[mongod@db01 ~]$ su - mongod
[mongod@db01 ~]$ vi .bash_profile
export PATH=/usr/local/mongodb/bin:$PATH
[mongod@db01 ~]$ source .bash_profile

启动

mongodb

[mongod@db01 ~]$ mongod --dbpath=/mongodb/data --logpath=/mongodb/log/mongodb.log --port=27017 --logappend --fork

登录mongodb

[mongod@db01 ~]$ mongo

使用配置文件

YAML

YAML

系统日志有关

 systemLog:
 destination: file        
 path: "/mongodb/log/mongodb.log"    --日志位置
 logAppend: true                 --日志以追加模式记录

数据存储有关

 storage:
 journal:
 enabled: true
 dbPath: "/mongodb/data"   --数据路径的位置    

进程控制

   processManagement:
    fork: true             --后台守护进程
    pidFilePath: <string>  --pid文件的位置，一般不用配置，可以去掉这行，自动生成到data中

网络配置有关

 net:            
    bindIp: <ip>     -- 监听地址
    port: <port>   -- 端口号,默认不配置端口号，是27017

安全验证有关配置

   security:
   authorization: enabled   --是否打开用户名密码验证

------------------以下是复制集与分片集群有关----------------------

replication:
oplogSizeMB: <NUM>
replSetName: "<REPSETNAME>"
secondaryIndexPrefetch: "all"
sharding:
clusterRole: <string>
archiveMovedChunks: <boolean>
---for mongos only
replication:
localPingThresholdMs: <int>
sharding:
configDB: <string>

YAML

cat >  /mongodb/conf/mongo.conf <<EOF
systemLog:
destination: file
path: "/mongodb/log/mongodb.log"
logAppend: true
storage:
journal:
enabled: true
dbPath: "/mongodb/data/"
processManagement:
fork: true
net:
port: 27017
bindIp: 10.0.0.51,127.0.0.1
EOF
mongod -f /mongodb/conf/mongo.conf --shutdown
mongod -f /mongodb/conf/mongo.conf

mongodb的关闭方式

mongod -f mongo.conf  --shutdown

mongodb 使用systemd管理

[mongod@db01 ~]$ exit
[root@db01 ~]# cat > /etc/systemd/system/mongod.service <<EOF
[Unit]
Description=mongodb
After=network.target remote-fs.target nss-lookup.target
[Service]
User=mongod
Type=forking
ExecStart=/mongodb/bin/mongod --config /mongodb/conf/mongo.conf
ExecReload=/bin/kill -s HUP \$MAINPID
ExecStop=/mongodb/bin/mongod --config /mongodb/conf/mongo.conf --shutdown
PrivateTmp=true
[Install]
WantedBy=multi-user.target
EOF
​
[root@db01 ~]# systemctl restart mongod
[root@db01 ~]# systemctl stop mongod
[root@db01 ~]# systemctl start mongod

mongodb常用基本操作

mongodb 默认存在的库

test

MongoDB

admin

local

config

MongoDB

show databases  / show dbs
show tables   / show collections
use admin
db  /  select databases()

命令种类

db 对象相关命令

 db.[TAB][TAB]
 db.help()
 db.oldboy.[TAB][TAB]
 db.oldboy.help()

rs 复制集有关(replication set):

 rs.[TAB][TAB]
 rs.help()

sh 分片集群(sharding cluster)

 sh.[TAB][TAB]
 sh.help()

mongodb对象操作

 mongo         mysql
 库    ----->  库
 集合  ----->  表
 文档  ----->  数据行

库的操作

> use test
>db.dropDatabase()
{ "dropped" : "test", "ok" : 1 }

集合的操作

app> db.createCollection('student')
{ "ok" : 1 }

方法2：插入文档，集合自动创建。

use oldboy
db.student.insert({name:"zhangsan"})
db.oldguo.insert({id:101,name:"zhangsan",age:20,gender:"m"})
show tables;
db.stu.insert({id:102,name:"lisi"})
db.stu.insert({a:"b",c:"d"})
db.stu.insert({a:1,c:2})

文档操作

数据录入

for(i=0;i<10000;i++){db.log.insert({"uid":i,"name":"mongodb","age":6,"date":new
Date()})}

查询数据行数

 db.log.count()

全表查询

 db.log.find()

每页显示50条记录

 DBQuery.shellBatchSize=50;

按照条件查询

 db.log.find({uid:999})

标准的json格式显示数据

db.log.find({uid:999}).pretty()
{
"_id" : ObjectId("5cc516e60d13144c89dead33"),
"uid" : 999,
"name" : "mongodb",
"age" : 6,
"date" : ISODate("2019-04-28T02:58:46.109Z")
}

删除集合中所有记录

app> db.log.remove({})

查看集合存储信息

app> db.log.totalSize() //集合中索引+数据压缩存储之后的大小

用户及权限管理

用户创建语法

use admin
db.createUser
{
user: "<name>",
pwd: "<cleartext password>",
roles: [
{ role: "<role>",
db: "<database>"
}

| "<role>",
...
]
}
#user:用户名
#pwd:密码
#roles:
role:角色名
db:作用对象
role：root, readWrite,read

验证数据库：

mongo -u oldboy -p 123 10.0.0.51/oldboy

用户管理例子

创建超级管理员：

$ mongo
use admin
db.createUser(
{
user: "root",
pwd: "root123",
roles: [ { role: "root", db: "admin" } ]
}
)

验证用户

db.auth('root','root123')

配置文件中，加入以下配置

vim /mongodb/conf/mongo.conf
systemLog:
destination: file
path: "/mongodb/log/mongodb.log"
logAppend: true
storage:
journal:
enabled: true
dbPath: "/mongodb/data/"
processManagement:
fork: true
net:
port: 27017
bindIp: 10.0.0.51,127.0.0.1
security:
authorization: enabled

重启mongodb

mongod -f /mongodb/conf/mongo.conf --shutdown
mongod -f /mongodb/conf/mongo.conf

登录验证

法一:

mongo -uroot -proot123  admin
mongo -uroot -proot123  10.0.0.51/admin

法二：

mongo
use admin
db.auth('root','root123')

查看用户:

use admin
db.system.users.find().pretty()

创建应用用户

use oldboy
db.createUser(
{
user: "app01",
pwd: "app01",
roles: [ { role: "readWrite" , db: "oldboy" } ]
}
)
​
mongo  -uapp01 -papp01 oldboy

查询mongodb中的用户信息

mongo -uroot -proot123 10.0.0.51/admin
db.system.users.find().pretty()

删除用户（root身份登录，use到验证库）

db.createUser({user: "app02",pwd: "app02",roles: [ { role: "readWrite" , db: "oldboy1" } ]})
mongo -uroot -proot123 10.0.0.51/admin
use oldboy1
db.dropUser("app02")

用户管理注意事项

建用户要有验证库，管理员admin，普通用户是要管理的库 登录时，注意验证库

mongo -uapp01 -papp01 10.0.0.51:27017/oldboy

重点参数

net:
port: 27017
bindIp: 10.0.0.51,127.0.0.1
security:
authorization: enabled

MongoDB复制RS（ReplicationSet）

基本原理

基本构成是1主2从的结构，自带互相监控投票机制（

Raft

MongoDB

Paxos

mysql MGR

Replication Set

配置过程详解

规划

三个以上的

mongodb

环境准备

多个端口：

28017、28018、28019、28020

多套目录：

su - mongod
mkdir -p /mongodb/28017/conf /mongodb/28017/data /mongodb/28017/log
mkdir -p /mongodb/28018/conf /mongodb/28018/data /mongodb/28018/log
mkdir -p /mongodb/28019/conf /mongodb/28019/data /mongodb/28019/log
mkdir -p /mongodb/28020/conf /mongodb/28020/data /mongodb/28020/log

多套配置文件

/mongodb/28017/conf/mongod.conf
/mongodb/28018/conf/mongod.conf
/mongodb/28019/conf/mongod.conf
/mongodb/28020/conf/mongod.conf

配置文件内容

cat > /mongodb/28017/conf/mongod.conf <<EOF
systemLog:
destination: file
path: /mongodb/28017/log/mongodb.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/28017/data
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
processManagement:
fork: true
net:
bindIp: 10.0.0.51,127.0.0.1
port: 28017
replication:
oplogSizeMB: 2048
replSetName: my_repl
EOF

\cp  /mongodb/28017/conf/mongod.conf  /mongodb/28018/conf/
\cp  /mongodb/28017/conf/mongod.conf  /mongodb/28019/conf/
\cp  /mongodb/28017/conf/mongod.conf  /mongodb/28020/conf/
​
sed 's#28017#28018#g' /mongodb/28018/conf/mongod.conf -i
sed 's#28017#28019#g' /mongodb/28019/conf/mongod.conf -i
sed 's#28017#28020#g' /mongodb/28020/conf/mongod.conf -i

启动多个实例备用

mongod -f /mongodb/28017/conf/mongod.conf
mongod -f /mongodb/28018/conf/mongod.conf
mongod -f /mongodb/28019/conf/mongod.conf
mongod -f /mongodb/28020/conf/mongod.conf
netstat -lnp|grep 280

配置普通复制集

1主2从，从库普通从库v

mongo --port 28017 admin
config = {_id: 'my_repl', members: [
{_id: 0, host: '10.0.0.51:28017'},
{_id: 1, host: '10.0.0.51:28018'},
{_id: 2, host: '10.0.0.51:28019'}]
}
   

初始化

rs.initiate(config)

查询复制集状态

rs.status();

1主1从1个arbiter

mongo -port 28017 admin
config = {_id: 'my_repl', members: [
{_id: 0, host: '10.0.0.51:28017'},
{_id: 1, host: '10.0.0.51:28018'},
{_id: 2, host: '10.0.0.51:28019',"arbiterOnly":true}]
}
           

初始化

rs.initiate(config)

复制集管理操作

查看复制集状态

rs.status();    //查看整体复制集状态
rs.isMaster();  // 查看当前是否是主节点
rs.conf()；     //查看复制集配置信息

添加删除节点

rs.remove("ip:port");   // 删除一个节点
rs.add("ip:port");      // 新增从节点
rs.addArb("ip:port");   // 新增仲裁节点

案例1：添加 arbiter节点

连接到主节点

[mongod@db01 ~]$ mongo --port 28018 admin

• 添加仲裁节点

my_repl:PRIMARY> rs.addArb("10.0.0.53:28020")

• 查看节点状态

my_repl:PRIMARY> rs.isMaster()
{
"hosts" : [
"10.0.0.51:28017",
"10.0.0.51:28018",
"10.0.0.51:28019"
],
"arbiters" : [
"10.0.0.51:28020"
]

案例2：删除节点

rs.remove("ip:port");
my_repl:PRIMARY> rs.remove("10.0.0.51:28019");
{ "ok" : 1 }
my_repl:PRIMARY> rs.isMaster()

案例3：新增从节点

rs.add("ip:port");
my_repl:PRIMARY> rs.add("10.0.0.51:28019")
{ "ok" : 1 }
my_repl:PRIMARY> rs.isMaster()

特殊从节点

arbiter

hidden

delay

hidden

delay+hidden

配置延时节点（一般延时节点也配置成hidden）

cfg=rs.conf()
cfg.members[3].priority=0
cfg.members[3].hidden=true
cfg.members[3].slaveDelay=120
rs.reconfig(cfg)

取消配置

cfg=rs.conf()
cfg.members[2].priority=1
cfg.members[2].hidden=false
cfg.members[2].slaveDelay=0
rs.reconfig(cfg)
###members[2]  ##下标索引

查询配置

 rs.conf();

副本集其他操作命令

查看副本集的配置信息

admin> rs.conf()

查看副本集各成员的状态

admin> rs.status()

副本集角色切换（不要人为随便操作）

admin> rs.stepDown()

设置副本节点可读：在副本节点执行

admin> rs.slaveOk()
show  tables;
eg：
admin> use app
switched to db app
app> db.createCollection('a')
{ "ok" : 0, "errmsg" : "not master", "code" : 10107 }

查看副本节点（监控主从延时）

admin> rs.printSlaveReplicationInfo()
source: 192.168.1.22:27017
syncedTo: Thu May 26 2016 10:28:56 GMT+0800 (CST)
0 secs (0 hrs) behind the primary

OPlog日志（备份恢复章节）

扩展：

P S A D

1 1 0 1

cfg=rs.conf()
cfg.members[2].priority=0
cfg.members[2].votes=0
rs.reconfig(cfg)

MongoDB Sharding Cluster

分片集群

规划

10个实例：38017-38026
configserver:38018-38020
3台构成的复制集（1主两从，不支持arbiter）38018-38020（复制集名字configserver）
shard节点：
sh1：38021-23 （1主两从，其中一个节点为arbiter，复制集名字sh1）
sh2：38024-26 （1主两从，其中一个节点为arbiter，复制集名字sh2）
mongos:38017

Shard节点配置过程

目录创建：

mkdir -p /mongodb/38021/conf  /mongodb/38021/log  /mongodb/38021/data
mkdir -p /mongodb/38022/conf  /mongodb/38022/log  /mongodb/38022/data
mkdir -p /mongodb/38023/conf  /mongodb/38023/log  /mongodb/38023/data
mkdir -p /mongodb/38024/conf  /mongodb/38024/log  /mongodb/38024/data
mkdir -p /mongodb/38025/conf  /mongodb/38025/log  /mongodb/38025/data
mkdir -p /mongodb/38026/conf  /mongodb/38026/log  /mongodb/38026/data

修改配置文件：

第一组复制集搭建：（1主 1从 1Arb）

cat >  /mongodb/38021/conf/mongodb.conf  <<EOF
systemLog:
destination: file
path: /mongodb/38021/log/mongodb.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/38021/data
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
bindIp: 10.0.0.51,127.0.0.1
port: 38021
replication:
oplogSizeMB: 2048
replSetName: sh1
sharding:
clusterRole: shardsvr
processManagement:
fork: true
EOF
\cp  /mongodb/38021/conf/mongodb.conf  /mongodb/38022/conf/
\cp  /mongodb/38021/conf/mongodb.conf  /mongodb/38023/conf/
​
sed 's#38021#38022#g' /mongodb/38022/conf/mongodb.conf -i
sed 's#38021#38023#g' /mongodb/38023/conf/mongodb.conf -i

第二组节点：(1主1从1Arb)

cat > /mongodb/38024/conf/mongodb.conf <<EOF
systemLog:
destination: file
path: /mongodb/38024/log/mongodb.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/38024/data
directoryPerDB: true
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
bindIp: 10.0.0.51,127.0.0.1
port: 38024
replication:
oplogSizeMB: 2048
replSetName: sh2
sharding:
clusterRole: shardsvr
processManagement:
fork: true
EOF
​
\cp  /mongodb/38024/conf/mongodb.conf  /mongodb/38025/conf/
\cp  /mongodb/38024/conf/mongodb.conf  /mongodb/38026/conf/
sed 's#38024#38025#g' /mongodb/38025/conf/mongodb.conf -i
sed 's#38024#38026#g' /mongodb/38026/conf/mongodb.conf -i

启动所有节点，并搭建复制集

mongod -f  /mongodb/38021/conf/mongodb.conf
mongod -f  /mongodb/38022/conf/mongodb.conf
mongod -f  /mongodb/38023/conf/mongodb.conf
mongod -f  /mongodb/38024/conf/mongodb.conf
mongod -f  /mongodb/38025/conf/mongodb.conf
mongod -f  /mongodb/38026/conf/mongodb.conf
ps -ef |grep mongod

38021登录

mongo --port 38021
use  admin
config = {_id: 'sh1', members: [
{_id: 0, host: '10.0.0.51:38021'},
{_id: 1, host: '10.0.0.51:38022'},
{_id: 2, host: '10.0.0.51:38023',"arbiterOnly":true}]
}

初始化

rs.initiate(config)

38024 登录

mongo --port 38024
use admin
config = {_id: 'sh2', members: [
{_id: 0, host: '10.0.0.51:38024'},
{_id: 1, host: '10.0.0.51:38025'},
{_id: 2, host: '10.0.0.51:38026',"arbiterOnly":true}]
}

初始化

rs.initiate(config)

config节点配置

目录创建

mkdir -p /mongodb/38018/conf  /mongodb/38018/log  /mongodb/38018/data
mkdir -p /mongodb/38019/conf  /mongodb/38019/log  /mongodb/38019/data
mkdir -p /mongodb/38020/conf  /mongodb/38020/log  /mongodb/38020/data

修改配置文件：

cat > /mongodb/38018/conf/mongodb.conf <<EOF
systemLog:
destination: file
path: /mongodb/38018/log/mongodb.conf
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/38018/data
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
bindIp: 10.0.0.51,127.0.0.1
port: 38018
replication:
oplogSizeMB: 2048
replSetName: configReplSet
sharding:
clusterRole: configsvr
processManagement:
fork: true
EOF
​
\cp /mongodb/38018/conf/mongodb.conf /mongodb/38019/conf/
\cp /mongodb/38018/conf/mongodb.conf /mongodb/38020/conf/
sed 's#38018#38019#g' /mongodb/38019/conf/mongodb.conf -i
sed 's#38018#38020#g' /mongodb/38020/conf/mongodb.conf -i

启动节点，并配置复制集

mongod -f /mongodb/38018/conf/mongodb.conf
mongod -f /mongodb/38019/conf/mongodb.conf
mongod -f /mongodb/38020/conf/mongodb.conf

38018登录

mongo --port 38018
use  admin
config = {_id: 'configReplSet', members: [
{_id: 0, host: '10.0.0.51:38018'},
{_id: 1, host: '10.0.0.51:38019'},
{_id: 2, host: '10.0.0.51:38020'}]
}

38018初始化

 rs.initiate(config)  

configserver

configserver

arbiter

mongodb 3.4

config server

replica set

arbiter

mongos

节点配置：

创建目录：

mkdir -p /mongodb/38017/conf  /mongodb/38017/log

配置文件：

cat > /mongodb/38017/conf/mongos.conf <<EOF
systemLog:
destination: file
path: /mongodb/38017/log/mongos.log
logAppend: true
net:
bindIp: 10.0.0.51,127.0.0.1
port: 38017
sharding:
configDB: configReplSet/10.0.0.51:38018,10.0.0.51:38019,10.0.0.51:38020
processManagement:
fork: true
EOF

启动

mongos

mongos -f /mongodb/38017/conf/mongos.conf

分片集群添加节点

连接

mongos（10.0.0.51）

配置

• 连接到mongs的admin数据库

 # su - mongod
 $ mongo 10.0.0.51:38017/admin

• 添加分片

db.runCommand( { addshard : "sh1/10.0.0.51:38021,10.0.0.51:38022,10.0.0.51:38023",name:"shard1"} )
db.runCommand( { addshard : "sh2/10.0.0.51:38024,10.0.0.51:38025,10.0.0.51:38026",name:"shard2"} )

• 列出分片

mongos> db.runCommand( { listshards : 1 } )

• 整体状态查看

mongos> sh.status();

使用RANGE分片集群

RANGE分片配置及测试

RANGE自动分片策略

激活数据库分片功能

mongo --port 38017 admin
use admin
admin>  ( { enablesharding : "数据库名称" } )
admin> db.runCommand( { enablesharding : "autoshard" } )

指定分片键对集合分片

创建索引

use autoshard
db.autotab.ensureIndex( { id: 1 } )

开启分片

use admin
db.runCommand( { shardcollection : "autoshard.autotab",key : {id: 1} } )

集合分片验证

use autoshard
for(i=1;i<1000000;i++){ db.autotab.insert({"id":i,"name":"shenzheng","age":70,"date":new Date()}); }
db.autotab.stats()

分片结果测试

shard1:
mongo --port 38021
db.autotab.count();
​
shard2:
mongo --port 38024
db.autotab.count();

zone

进行range手工定制分片

mongo --port 38017 admin
use zonedb
db.vast.ensureIndex( {order_id: 1 } )
​
use admin
db.runCommand( { enablesharding : "zonedb" } )
sh.shardCollection("zonedb.vast", {order_id: 1});
​
​
sh.addShardTag("shard1", "shard00")
sh.addShardTag("shard2", "shard01")
​
​
sh.addTagRange(
"zonedb.vast",
{  "order_id" : MinKey },
{  "order_id" : 500 },"shard00" )
​
sh.addTagRange(
"zonedb.vast",
{"order_id" : 501 },
{"order_id" : MaxKey},"shard01" )
​
use zonedb
for(i=1;i<1000;i++){ db.vast.insert({"order_id":i,"name":"shenzheng","age":70,"date":new Date()}); }
​
db.vast.getShardDistribution()

Hash

分片例子：

对oldboy库下的vast大表进行hash创建哈希索引

oldboy

开启分片功能

mongo --port 38017 admin
use admin
db.runCommand( { enablesharding : "oldboy" } )

oldboy

库下

vast

表建立

hash

索引

use oldboy
db.vast.ensureIndex( { id: "hashed" } )

开启分片

use admin
sh.shardCollection( "oldboy.vast", { id: "hashed" } )

oldboy

库下录入

10w

行数据测试

use oldboy
for(i=1;i<100000;i++){ db.vast.insert({"id":i,"name":"shenzheng","age":70,"date":new Date()}); }

查看结果

db.vast.getShardDistribution()

hash

分片结果测试

mongo --port 38021
use oldboy
db.vast.count();
mongo --port 38024
use oldboy
db.vast.count();

分片集群的查询及管理

判断是否

Shard

集群

admin> db.runCommand({ isdbgrid : 1})

列出所有分片信息

admin> db.runCommand({ listshards : 1})

列出开启分片的数据库

admin> use config
config> db.databases.find( { "partitioned": true } )
或者：
config> db.databases.find() //列出所有数据库分片情况

查看分片的片键

config> db.collections.find().pretty()
{
"_id" : "test.vast",
"lastmodEpoch" : ObjectId("58a599f19c898bbfb818b63c"),
"lastmod" : ISODate("1970-02-19T17:02:47.296Z"),
"dropped" : false,
"key" : {
"id" : 1
},
"unique" : false
}

查看分片的详细信息

admin> sh.status()

删除分片节点（谨慎）

 （1）确认blance是否在工作
 sh.getBalancerState()
 （2）删除shard2节点(谨慎)
 mongos> db.runCommand( { removeShard: "shard2" } )
 注意：删除操作一定会立即触发blancer。

balancer

操作

mongos

shard

chunk

chunk

balancer

有需要时可以关闭和开启

blancer

mongos> sh.stopBalancer()
mongos> sh.startBalancer()

自定义 自动平衡进行的时间段

https://docs.mongodb.com/manual/tutorial/manage-sharded-cluster-balancer/#schedule-the-balancing-window

use config
sh.setBalancerState( true )
db.settings.update({ _id : "balancer" }, { $set : { activeWindow : { start : "3:00", stop : "5:00" } } }, true )
​
sh.getBalancerWindow()
sh.status()

关于集合的

balancer

关闭某个集合的

balance

sh.disableBalancing("students.grades")

打开某个集合的

balancer

sh.enableBalancing("students.grades")

确定某个集合的

balance

是开启或者关闭

db.getSiblingDB("config").collections.findOne({_id : "students.grades"}).noBalance;

备份恢复

备份恢复工具介绍：

mongoexport/mongoimport  #导出/导入
mongodump/mongorestore

备份工具区别

应用场景总结:

mongoexport/mongoimport:json csv

mysql <---> mongodb

`mongodb 2 ----> mongodb 3

mongodump/mongorestore

导出工具

mongoexport

参数：

$ mongoexport --help
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-f:指明要导出那些列
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
--authenticationDatabase admin

用法：

单表备份至json格式

mongoexport -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldboy -c log -o /mongodb/log.json

JSON

csv

如果我们需要导出CSV格式的数据，则需要使用----type=csv参数：

mongoexport -uroot -proot123 --port 27017 --authenticationDatabase admin -d test -c log --type=csv -f uid,name,age,date  -o /mongodb/log.csv

导入工具

mongoimport

参数：

$ mongoimport --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-f:指明要导入那些列
-j, --numInsertionWorkers=<number>  number of insert operations to run concurrently       (defaults to 1)
//并行

数据恢复:

恢复

json

格式表数据到

log1

mongoimport -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldboy -c log1 /mongodb/log.json

恢复

csv

格式的文件到

log2

上面演示的是导入

JSON

--type

csv

mongoimport   -uroot -proot123 --port 27017 --authenticationDatabase admin   -d oldboy -c log2 --type=csv --headerline --file  /mongodb/log.csv

csv

mongoimport   -uroot -proot123 --port 27017 --authenticationDatabase admin   -d oldboy -c log3 --type=csv -f id,name,age,date --file  /mongodb/log.csv

异构平台迁移案例

mysql -----> mongodb

mysql

vim /etc/my.cnf   --->添加以下配置
secure-file-priv=/tmp
 --重启数据库生效
 /etc/init.d/mysqld restart

导出

MySQL

数据为

CSV

格式

select * from test.t100w  limit 100  into outfile '/tmp/t100w.csv' fields terminated by ',';

导入

MongoDB

[mongod@db01 mongodb]$ mongoimport   -uroot -proot123 --port 27017 --authenticationDatabase admin   
-d test -c t100w --type=csv  -f id,num,k1,k2,dt  --file /mongodb/t100w.csv

mongodump

和

mongorestore

mongodump

`Mongodb

mongodump

Mongodb

mongodump

用法：

参数说明

$ mongodump --help
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
-j, --numParallelCollections=  number of collections to dump in parallel (4 by default)
--oplog  备份的同时备份oplog

mongodump

和

mongorestore

基本使用

全库备份

mkdir /mongodb/backup
mongodump  -uroot -proot123 --port 27017 --authenticationDatabase admin -o /mongodb/backup

备份test库

$ mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -d test -o /mongodb/backup/

备份oldboy库下的log集合

$ mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldboy -c log -o /mongodb/backup/

压缩备份

$ mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -d test -o /mongodb/backup/ --gzip

mongorestore

[mongod@db01 ~]$ mongorestore  -uroot -proot123 --port 27017 --authenticationDatabase admin /mongodb/backup/ --gzip

全库恢复

[mongod@db01 ~]$ mongorestore  -uroot -proot123 --port 27017 --authenticationDatabase admin /mongodb/backup/ --gzip --drop

# 恢复

test

库

[mongod@db01 ~]$ mongorestore  -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldguo /mongodb/backup/test --gzip --drop

恢复

test

库下的

t100w

集合

[mongod@db01 ~]$ mongorestore  -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldguo -c t1 /mongodb/backup/test/t100w.bson.gz --gzip

mongodump

和

mongorestore

高级企业应用（--oplog）

replica set

master/slave

--oplog

use oplog for taking a point-in-time snapshot

oplog

介绍

在

replica set

oplog

capped collection

5%

--oplogSizeMB

local

db.oplog.rs

mongod

oplog

oplog

mongod -f /mongodb/28017/conf/mongod.conf
mongod -f /mongodb/28018/conf/mongod.conf
mongod -f /mongodb/28019/conf/mongod.conf
mongod -f /mongodb/28020/conf/mongod.conf

use local
db.oplog.rs.find().pretty()
"ts" : Timestamp(1553597844, 1),
"op" : "n"
"o"  :
​
"i": insert
"u": update
"d": delete
"c": db cmd
​
test:PRIMARY> rs.printReplicationInfo()
configured oplog size:   1561.5615234375MB <--集合大小
log length start to end: 423849secs (117.74hrs) <--预计窗口覆盖时间
oplog first event time:  Wed Sep 09 2015 17:39:50 GMT+0800 (CST)
oplog last event time:   Mon Sep 14 2015 15:23:59 GMT+0800 (CST)
now:                     Mon Sep 14 2015 16:37:30 GMT+0800 (CST)

oplog

企业级应用

实现热备，在备份时使用

--oplog

[mongod@db01 conf]$ mongo --port 28018
use oldboy
for(var i = 1 ;i < 100; i++) {
db.foo.insert({a:i});
}
my_repl:PRIMARY> db.oplog.rs.find({"op":"i"}).pretty()

oplog

配合

mongodump

实现热备

mongodump --port 28018 --oplog -o /mongodb/backup

作用介绍：

--oplog

oplog.bson

mongorestore  --port 28018 --oplogReplay /mongodb/backup

oplog

高级应用

背景：每天0点全备，oplog恢复窗口为48小时 某天，上午10点test 业务表被误删除。 恢复思路： 0.停应用 1.找测试库 2.恢复昨天晚上全备 3.截取全备之后到test误删除时间点的oplog，并恢复到测试库 4.将误删除表导出，恢复到生产库

恢复步骤：

模拟故障环境：

全备数据库 模拟原始数据

mongo --port 28017
use test
for(var i = 1 ;i < 100; i++) {
db.a.insert({a: i});
}

全备:

rm -rf /mongodb/backup/*
mongodump --port 28017 --oplog -o /mongodb/backup

--oplog功能:在备份同时,将备份过程中产生的日志进行备份 文件必须存放在/mongodb/backup下,自动命令为oplog.bson

再次模拟数据

 db.b.insert({id:1})
 db.c.insert({id:2})

2.上午10点：删除wo库下的ci表 10:00时刻,误删除

3.备份现有的oplog.rs表

mongodump --port 28017 -d local -c oplog.rs  -o /mongodb/bak

4.截取oplog并恢复到drop之前的位置 更合理的方法：登陆到原数据库

[mongod@db01 local]$
my_repl:PRIMARY> use local
db.oplog.rs.find({op:"c"}).pretty();
{
"ts" : Timestamp(1606212278, 1),
"t" : NumberLong(3),
"h" : NumberLong(0),
"v" : 2,
"op" : "c",
"ns" : "test.$cmd",
"ui" : UUID("091af5ca-20c2-4ea4-a015-7b42de975220"),
"o2" : {
"numRecords" : 1
},
"wall" : ISODate("2020-11-24T10:04:38.310Z"),
"o" : {
"drop" : "b"
}
}

5.获取到oplog误删除时间点位置:

"ts":Timestamp(1606212278 #发生的时间戳, 1，#这一秒钟发生了什么)

恢复备份+应用

oplog

[mongod@db01 backup]$ cp /mongodb/bak/local/oplog.rs.bson ./oplog.bson
mongorestore --port 28017  --oplogReplay --oplogLimit "1606212278:1"  --drop   /mongodb/backup/
[mongod@db01 backup]$mondb --port 28017
db.a.count()
db.b.count()
db.c.count()

分片集群的备份思路

备份的目标:
config server
shard 节点
单独进行备份
备份有什么困难和问题
chunk迁移的问题
人为控制在备份的时候，避开迁移的时间窗口
shard节点之间的数据不在同一时间点。
选业务量较少的时候
Ops Manager