MySQL之十一---MongoDB详解

时间 2021-03-05

标签 mysql linux sql mongodb shell 数据库 json vim centos 安全栏目 MySQL 繁體版

原文原文链接

第一章：逻辑结构

`Mongodb` 逻辑结构	`MySQL`逻辑结构
库`database`	库
集合（`collection`）	表
文档（`document`）	数据行

第二章：安装部署

系统准备

`redhat`或`centos6.2`以上系统
系统开发包完整
`ip`地址和`hosts`文件解析正常
`iptables`防火墙&`SElinux`关闭
关闭大页内存机制

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

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

关闭`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.tgzsql

法一:mongodb

 [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

法二：shell

 [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不支持制表符缩进：请改用空格。json

系统日志有关

 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   --是否打开用户名密码验证

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

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

YAML例子centos

 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库: 系统预留库,MongoDB系统管理库 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下建立.

建用户时,use到的库,就是此用户的验证库

登陆时,必须明确指定验证库才能登陆

一般,管理员用的验证库是admin,普通用户的验证库通常是所管理的库设置为验证库

若是直接登陆到数据库,不进行use,默认的验证库是test,不是咱们生产建议的.

从3.6 版本开始，不添加bindIp参数，默认不让远程登陆，只能本地管理员登陆。

用户建立语法

 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节点（或多实例）

环境准备

多个端口：

 2801七、2801八、2801九、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.freeze(300) //锁定从，使其不会转变成主库 freeze()和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格式的文件中的内容，若是要导入CSV格式文件中的内容，则须要经过--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

注：--headerline:指明第一行是列名，不须要导入。

异构平台迁移案例

`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运行时进行备份，它的工做原理是对运行的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是一个定容集合，因此时间窗口能覆盖的范围会由于你单位时间内的更新次数不一样而变化。想要查看当前的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

1. MySQL锁之一：锁详解
2. MongoDB之索引详解
3. MongoDB之compact操做详解
4. mongodb 索引详解（一）
5. MongoDB的Find详解(一)
6. MongoDB 索引详解（一）
7. asp.net夜话之十一：web.config详解
8. 第十九天 -- MongoDB -- MapReduce操做Mysql、MongoDB
9. MongoDB oplog详解
10. mongodb详解
更多相关文章...
• MySQL子查询详解 - MySQL教程
• MySQL下载步骤详解 - MySQL教程
• Flink 数据传输及反压详解
• 漫谈MySQL的锁机制