安科网

MongoDB安装部署

jaylong

jaylong

2020-05-30

关注 关注

MongoDB安装部署

逻辑结构

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

系统准备

关闭大页内存机制
root用户下
在vi /etc/rc.local最后添加如下代码
[ ~]# vim /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
		
[ ~]# echo never > /sys/kernel/mm/transparent_hugepage/enabled 
[ ~]# echo never > /sys/kernel/mm/transparent_hugepage/defrag

修改/etc/security/limits.conf
[ ~]# echo ‘*               -       nofile          65535‘ >> /etc/security/limits.conf
reboot重启生效

mongodb安装

#创建用户
[ ~]# useradd mongodb
[ ~]# echo ‘123‘ |passwd --stdin mongodb

#创建mongodb所需目录结构
[ ~]# mkdir -p /mongodb/conf
[ ~]# mkdir -p /mongodb/log
[ ~]# mkdir -p /mongodb/data

#下载并解压软件到指定位置
[ ~]# wget http://downloads.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.6.12.tgz
[ ~]# tar xf mongodb-linux-x86_64-rhel70-3.6.12_.tgz 
[ ~]# cp -a mongodb-linux-x86_64-rhel70-3.6.12/bin /mongodb/
[ ~]# chown -R mongodb:mongodb /mongodb

#设置用户环境变量
[ ~]# su - mongodb
[ ~]$ echo ‘export PATH=/mongodb/bin:$PATH‘ >> .bash_profile 
[ ~]$ source .bash_profile

# 启动mongodb
[ ~]$ mongod --dbpath=/mongodb/data --logpath=/mongodb/log/mongodb.log --port=27017 --logappend --fork

#登录mongodb
[ ~]$ mongo

配置文件

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

#使用配置文件
[ ~]$ cat /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.1.110,127.0.0.1

#关闭mongodb
[ ~]$ mongod -f /mongodb/conf/mongo.conf --shutdown

#启动mongodb
[ ~]$ mongod -f /mongodb/conf/mongo.conf 

#systemd管理(root)
[ ~]# [ ~]# cat /etc/systemd/system/mongod.service 
[Unit]
Description=mongodb 
After=network.target remote-fs.target nss-lookup.target
[Service]
User=mongodb
Type=forking
ExecStart=/mongodb/bin/mongod --config /mongodb/conf/mongo.conf
ExecReload=/bin/kill -s HUP 
ExecStop=/mongodb/bin/mongod --config /mongodb/conf/mongo.conf --shutdown
PrivateTmp=true  
[Install]
WantedBy=multi-user.target
[ ~]#

mongodb常用基本操作

#默认存在的库
admin库:系统预留库,MongoDB系统管理库
local库:本地预留库,存储关键日志
config库:MongoDB配置信息库

#命令种类
#db 对象相关命令
db        当前在的库
db.[TAB]  类似于linux中的tab功能
db.help() db级别的命令使用帮助

#collection级别操作:
db.Collection_name.xxx

#document级别操作:
db.t1.insert()

#rs 复制集有关(replication set):
rs.[TAB][TAB]
rs.help()

#sh 分片集群(sharding cluster)
sh.[TAB][TAB]
sh.help()

#常用操作
#查看当前db版本
db.version()

#显示当前数据库
db
或
db.getName()

#查询所有数据库
> show dbs

#切换数据库
> use local

#查看所有的collection
show  tables;
show collections

#显示当前数据库状态
> use local
> db.stats()

#录入数据
use opesn
db.hello.insert({name:"a"})

#查看数据
> use opesn
> db.hello.find()
{ "_id" : ObjectId("5db2f8b47143defb9ed182d2"), "name" : "a" }

#删除表
use opesn
db.hello.drop()

#查看当前数据库的连接机器地址
> db.getMongo()
connection to 127.0.0.1
指定数据库进行连接
默认连接本机test数据库

mongodb对象操作

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

#库的操作
– 创建数据库：
当use的时候，系统就会自动创建一个数据库。
如果use之后没有创建任何集合。
系统就会删除这个数据库。
– 删除数据库 创建集合
如果没有选择任何数据库，会删除默认的test数据库

#删除test数据库
> use opesn
switched to db opesn
> db.dropDatabase()
{ "dropped" : "opesn", "ok" : 1 }
> 

#集合的操作：
#创建集合
#方法1
> use app
switched to db app
> db.createCollection(‘a‘)
{ "ok" : 1 }
> db.createCollection(‘b‘)
{ "ok" : 1 }
#查看当前数据下的所有集合
> show collections
a
b
> db.getCollectionNames()
[ "a", "b" ]
> 

#方法2：当插入一个文档的时候，一个集合就会自动创建。
> use opesn
switched to db opesn
> db.ops.insert({id : "1021" ,name : "zhssn" ,age : "22" ,gender : "female",address : "sz"})
WriteResult({ "nInserted" : 1 })
> db.ops.insert({id : "101" ,name : "lisi"})
WriteResult({ "nInserted" : 1 })

#查看数据
> db.ops.find()
{ "_id" : ObjectId("5db301b87143defb9ed182d3"), "id" : "1021", "name" : "zhssn", "age" : "22", "gender" : "female", "address" : "sz" }
{ "_id" : ObjectId("5db301cb7143defb9ed182d4"), "id" : "101", "name" : "lisi" }

> db.ops.find({id:"101"})
{ "_id" : ObjectId("5db301cb7143defb9ed182d4"), "id" : "101", "name" : "lisi" }

> db.ops.find().pretty()
{
	"_id" : ObjectId("5db301b87143defb9ed182d3"),
	"id" : "1021",
	"name" : "zhssn",
	"age" : "22",
	"gender" : "female",
	"address" : "sz"
}
{
	"_id" : ObjectId("5db301cb7143defb9ed182d4"),
	"id" : "101",
	"name" : "lisi"
} 

> db.ops.find({id:"101"}).pretty()
{
	"_id" : ObjectId("5db301cb7143defb9ed182d4"),
	"id" : "101",
	"name" : "lisi"
}
> 

#删除集合
> use app
> db.a.drop()

#重命名集合
> db.b.renameCollection(‘bb‘)
{ "ok" : 1 }
> show tables
bb
> 

#批量插入数据
> for(i=0;i<10000;i++){db.log.insert({"uid":i,"name":"mongodb","age":6,"date":new
Date()})}

#Mongodb数据查询语句:
#查询集合中的记录数
app> db.log.find() //查询所有记录

注：默认每页显示20条记录，当显示不下的的情况下，可以用it迭代命令查询下一页数据。
设置每页显示数据的大小：

> DBQuery.shellBatchSize=50; //每页显示50条记录

app> db.log.findOne() //查看第1条记录
app> db.log.count() //查询总的记录数

#删除集合中的记录数
app> db.log.remove({}) //删除集合中所有记录
> db.log.distinct("name") //查询去掉当前集合中某列的重复数据

#查看集合存储信息
app> db.log.stats()
app> db.log.dataSize() //集合中数据的原始大小
app> db.log.totalIndexSize() //集合中索引数据的原始大小
app> db.log.totalSize() //集合中索引+数据压缩存储之后的大小
app> db.log.storageSize() //集合中数据压缩存储的大小

用户管理

注意：
验证库，建立用户时use到的库，在使用用户时，要加上验证库才能登陆。
对于管理员用户,必须在admin下创建.
1. 建用户时,use到的库,就是此用户的验证库
2. 登录时,必须明确指定验证库才能登录
3. 通常,管理员用的验证库是admin,普通用户的验证库一般是所管理的库设置为验证库
4. 如果直接登录到数据库,不进行use,默认的验证库是test,不是我们生产建议的.

#基本语法说明：
user:用户名
pwd:密码
roles:
    role:角色名
    db:作用对象	
role：root, readWrite,read   
#验证数据库：
mongo -u oldboy -p 123 10.0.0.51/oldboy

#用户管理例子：
-- 1. 创建超级管理员：管理所有数据库（必须use admin再去创建）
$ mongo
use admin
db.createUser(
{
    user: "root",
    pwd: "root123",
    roles: [ { role: "root", db: "admin" } ]
}
)
#验证用户
db.auth(‘root‘,‘root123‘)
#配置文件中，加入以下配置
[ ~]$ vim /mongodb/conf/mongo.conf 
security:
  authorization: enabled
#重启mongodb
[ ~]$ mongod -f /mongodb/conf/mongo.conf --shutdown 
[ ~]$ mongod -f /mongodb/conf/mongo.conf 
#登录验证
[ ~]$ mongo -uroot -proot123
[ ~]$ mongo -uroot -proot123 10.0.1.110/admin
[ ~]$ mongo -uroot -proot123 admin
#查看用户:
use admin
db.system.users.find().pretty()

#创建库管理用户
[ ~]$ mongo -uroot -proot123  admin
use app
db.createUser(
{
user: "admin",
pwd: "admin",
roles: [ { role: "dbAdmin", db: "app" } ]
}
)
#验证用户
db.auth(‘admin‘,‘admin‘)
#登录测试
[ ~]$ mongo -uadmin -padmin 10.0.1.110/app

#创建对app数据库，读、写权限的用户app01
（1）超级管理员用户登陆
[ ~]$ mongo -uroot -proot123 admin
（2）选择一个验证库
use app
(3)创建用户
db.createUser(
	{
		user: "app01",
		pwd: "app01",
		roles: [ { role: "readWrite" , db: "app" } ]
	}
)
[ ~]$ mongo  -uapp01 -papp01 10.0.1.110/app
#创建app数据库读写权限的用户并对test数据库具有读权限：
[ ~]$ mongo -uroot -proot123 10.0.1.110/admin
use app
db.createUser(
{
user: "app03",
pwd: "app03",
roles: [ { role: "readWrite", db: "app" },
{ role: "read", db: "test" }]})
#查询mongodb中的用户信息
[ ~]$ mongo -uroot -proot123 10.0.1.110/admin
db.system.users.find().pretty()

#删除用户（root身份登录，use到验证库）
#删除用户
# mongo -uroot -proot123 10.0.1.110/admin
use app
db.dropUser("app01")

MongoDB复制集RS

基本构成是1主2从的结构，自带互相监控投票机制（Raft（MongoDB） Paxos（mysql MGR 用的是变种））
如果发生主库宕机，复制集内部会进行投票选举，选择一个新的主库替代原有主库对外提供服务。同时复制集会自动通知
客户端程序，主库已经发生切换了。应用就会连接到新的主库。

Replication Set配置过程详解

#规划
三个以上的mongodb节点（或多实例）
多个端口：28017、28018、28019、28020

#多个目录：
[ ~]$ 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

#多个配置文件
[ ~]$ cat /mongodb/28017/conf/mongod.conf
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.1.110,127.0.0.1
  port: 28017
replication:
  oplogSizeMB: 2048
  replSetName: my_repl
[ ~]$ 
[ ~]$ \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

#启动多个实例
[ 28017]$ mongod -f /mongodb/28017/conf/mongod.conf
[ 28017]$ mongod -f /mongodb/28018/conf/mongod.conf
[ 28017]$ mongod -f /mongodb/28019/conf/mongod.conf
[ 28017]$ mongod -f /mongodb/28020/conf/mongod.conf
[ 28017]$ netstat -lntup |grep 280

#配置普通复制集：
1主2从，从库普通从库
[ 28017]$ mongo --port 28017 admin
config = {_id: ‘my_repl‘, members: [
                          {_id: 0, host: ‘10.0.1.110:28017‘},
                          {_id: 1, host: ‘10.0.1.110:28018‘},
                          {_id: 2, host: ‘10.0.1.110:28019‘}]
          }    	  
rs.initiate(config) 

#查询复制集状态
rs.status();

复制集管理操作

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

#添加删除节点
[ ~]$ mongo --port 28018 admin
my_repl:PRIMARY> rs.remove("10.0.1.110:28017")   // 删除一个节点
my_repl:PRIMARY> rs.addArb("10.0.1.110:28017")   // 新增仲裁节点
my_repl:PRIMARY> rs.add("10.0.1.110:28020")   // 新增从节点

特殊从节点

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)
#配置成功后，通过以下命令查询配置后的属性
rs.conf(); 

#取消以上配置方法
cfg=rs.conf() 
cfg.members[3].priority=1
cfg.members[3].hidden=false
cfg.members[3].slaveDelay=0
rs.reconfig(cfg)  

#副本集其他操作命令
#查看副本集的配置信息
admin> rs.conf()
#查看副本集各成员的状态
admin> rs.status()
++++++++++++++++++++++++++++++++++++++++++++++++
#副本集角色切换（不要人为随便操作）
admin> rs.stepDown()
注：
admin> rs.freeze(300) //锁定从，使其不会转变成主库
freeze()和stepDown单位都是秒。
+++++++++++++++++++++++++++++++++++++++++++++
#设置副本节点可读：在副本节点执行
admin> rs.slaveOk()
admin> use app
app> db.createCollection(‘a‘)
{ "ok" : 0, "errmsg" : "not master", "code" : 10107 }

#查看副本节点（监控主从延时）
rs.printSlaveReplicationInfo()

MongoDB Sharding Cluster 分片集群

#规划
10个实例：38017-38026
（1）configserver:
3台构成的复制集（1主两从，不支持arbiter）38018-38020（复制集名字configsvr）
（2）shard节点：
sh1：38021-23    （1主两从，其中一个节点为arbiter，复制集名字sh1）
sh2：38024-26    （1主两从，其中一个节点为arbiter，复制集名字sh2）
（3） 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
#修改配置文件：
#sh1:
[ ~]$ cat /mongodb/38021/conf/mongodb.conf 
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.1.110,127.0.0.1
  port: 38021
replication:
  oplogSizeMB: 2048
  replSetName: sh1
sharding:
  clusterRole: shardsvr
processManagement: 
  fork: true
[ ~]$ 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

#sh2:
[ ~]$ cat /mongodb/38024/conf/mongodb.conf 
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.1.110,127.0.0.1
  port: 38024
replication:
  oplogSizeMB: 2048
  replSetName: sh2
sharding:
  clusterRole: shardsvr
processManagement: 
  fork: true
[ ~]$ 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  

[ ~]$ mongo --port 38021 admin
config = {_id: ‘sh1‘, members: [
                          {_id: 0, host: ‘10.0.1.110:38021‘},
                          {_id: 1, host: ‘10.0.1.110:38022‘},
                          {_id: 2, host: ‘10.0.1.110:38023‘,"arbiterOnly":true}]
           }

rs.initiate(config)

[ ~]$ mongo --port 38024  admin
config = {_id: ‘sh2‘, members: [
                          {_id: 0, host: ‘10.0.1.110:38024‘},
                          {_id: 1, host: ‘10.0.1.110:38025‘},
                          {_id: 2, host: ‘10.0.1.110: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 
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.1.110,127.0.0.1
  port: 38018
replication:
  oplogSizeMB: 2048
  replSetName: configReplSet
sharding:
  clusterRole: configsvr
processManagement: 
  fork: true
[ ~]$ 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 
[ ~]$ mongo --port 38018 admin
config = {_id: ‘configReplSet‘, members: [
                          {_id: 0, host: ‘10.0.1.110:38018‘},
                          {_id: 1, host: ‘10.0.1.110:38019‘},
                          {_id: 2, host: ‘10.0.1.110:38020‘}]
           }
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 
systemLog:
  destination: file
  path: /mongodb/38017/log/mongos.log
  logAppend: true
net:
  bindIp: 10.0.1.110,127.0.0.1
  port: 38017
sharding:
  configDB: configReplSet/10.0.1.110:38018,10.0.1.110:38019,10.0.1.110:38020
processManagement: 
  fork: true
[ ~]$ mongos -f /mongodb/38017/conf/mongos.conf

分片集群添加节点

#连接到其中一个mongos（10.0.1.110），做以下配置
（1）连接到mongs的admin数据库
[ ~]$ mongo 10.0.1.110:38017/admin
（2）添加分片
db.runCommand( { addshard : "sh1/10.0.1.110:38021,10.0.1.110:38022,10.0.1.110:38023",name:"shard1"} )
db.runCommand( { addshard : "sh2/10.0.1.110:38024,10.0.1.110:38025,10.0.1.110:38026",name:"shard2"} )
（3）列出分片
db.runCommand({ listshards : 1 })
（4）整体状态查看
sh.status();

使用分片集群

RANGE分片配置及测试
#激活数据库分片功能
[ ~]$ mongo --port 38017 admin
mongos> db.runCommand( { enablesharding : "test" } )

#指定分片键对集合分片
##创建索引
mongos> use test
mongos> db.vast.ensureIndex( { id: 1 } )

##开启分片
mongos> use admin
mongos> db.runCommand( { shardcollection : "test.vast",key : {id: 1} } )

#集合分片验证
mongos> use test
mongos> for(i=1;i<1000000;i++){ db.vast.insert({"id":i,"name":"opesn","age":70,"date":new Date()}); }

#分片结果测试
shard1:
mongo --port 38021
db.vast.count();

shard2:
mongo --port 38024
db.vast.count();
Hash分片例子
#创建哈希索引
#对于opesn开启分片功能
[ ~]$ mongo --port 38017 admin
mongos> use admin
mongos> db.runCommand( { enablesharding : "opesn" } )

#对于oldboy库下的vast表建立hash索引
mongos> use opesn
mongos> db.vast.ensureIndex( { id: "hashed" } )

#开启分片 
mongos> use admin
mongos> sh.shardCollection( "opesn.vast", { id: "hashed" } )

#录入10w行数据测试
mongos> use opesn
mongos> for(i=1;i<100000;i++){ db.vast.insert({"id":i,"name":"opesn","age":70,"date":new Date()}); }

#hash分片结果测试
mongo --port 38021
use opesn
db.vast.count();

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

分片集群的查询及管理

#判断是否Shard集群
db.runCommand({ isdbgrid : 1})
#列出所有分片信息
db.runCommand({ listshards : 1})
#列出开启分片的数据库
mongos> db.databases.find( { "partitioned": true } )
或者：
mongos> db.databases.find() //列出所有数据库分片情况
#查看分片的片键
db.collections.find().pretty()
#查看分片的详细信息
sh.status()
#删除分片节点（谨慎）
（1）确认blance是否在工作
sh.getBalancerState()
（2）删除shard2节点(谨慎)
db.runCommand( { removeShard: "shard2" } )
注意：删除操作一定会立即触发blancer。

balancer操作

#mongos的一个重要功能，自动巡查所有shard节点上的chunk的情况，自动做chunk迁移。
什么时候工作？
1、自动运行，会检测系统不繁忙的时候做迁移
2、在做节点删除的时候，立即开始迁移工作
3、balancer只能在预设定的时间窗口内运行

#有需要时可以关闭和开启blancer（备份的时候）
mongos> sh.stopBalancer()
mongos> sh.startBalancer()

#自定义 自动平衡进行的时间段
[ ~]$ mongo --port 38017 admin
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;

备份恢复

#备份恢复工具
（1）mongoexport/mongoimport    //导出/导入的是JSON格式或者CSV格式
（2）mongodump/mongorestore     //导出/导入的是BSON格式
#JSON可读性强但体积较大，BSON则是二进制文件，体积小但对人类几乎没有可读性。
在一些mongodb版本之间，BSON格式可能会随版本不同而有所不同，所以不同版本之间用mongodump/mongorestore可能不会成功，具体要看版本之间的兼容性。当无法使用BSON进行跨版本的数据迁移的时候，
使用JSON格式即mongoexport/mongoimport是一个可选项。

#应用场景总结:
mongoexport/mongoimport:json csv 
1、异构平台迁移  mysql  <---> mongodb
2、同平台，跨大版本：mongodb 2  ----> mongodb 3

mongodump/mongorestore
日常备份恢复时使用.

#导出工具mongoexport
mongoexport具体用法如下所示：
[ ~]$ mongoexport --help  
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-f:指明要导出那些列
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
--authenticationDatabase admin

#单表备份至json格式
[ ~]$ mongoexport -uroot -proot123 -d opesn -c ops --authenticationDatabase admin -o /mongodb/backup/ops.json
#注：备份文件的名字可以自定义，默认导出了JSON格式的数据

#单表备份至csv格式
如果需要导出CSV格式的数据，则需要使用----type=csv参数：
[ ~]$ mongoexport -uroot -proot123 -d opesn -c ops --type=csv -f id,name --authenticationDatabase admin -o /mongodb/backup/ops.csv

#导入工具mongoimport
Mongodb中的mongoimport工具可以把一个特定格式文件中的内容导入到指定的collection中。该工具可以导入JSON格式数据，也可以导入CSV格式数据。具体使用如下所示：
$ mongoimport --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-f:指明要导入那些列
-j, --numInsertionWorkers=<number>  number of insert operations to run concurrently  //并行

#数据恢复:
#恢复json格式表数据到ops01
[ ~]$ mongoimport -uroot -proot123 -d opesn -c ops01 --authenticationDatabase admin /mongodb/backup/ops.json

#恢复csv格式的文件到ops02
上面演示的是导入JSON格式的文件中的内容，如果要导入CSV格式文件中的内容，则需要通过--type参数指定导入格式
（1）csv格式的文件头行，有列名字
[ ~]$ mongoimport -uroot -proot123 -d opesn -c ops02 --type=csv --headerline  --authenticationDatabase admin /mongodb/backup/ops.csv
# --headerline:指明第一行是列名，不需要导入。
（2）csv格式的文件头行，没有列名字
[ ~]$ mongoimport -uroot -proot123 -d opesn -c ops04 --type=csv -f id,name --authenticationDatabase admin /mongodb/backup/ops02.csv

#异构平台迁移
mysql   -----> mongodb  
（1）mysql开启安全路径
[ ~]# vim /etc/my.cnf 
secure-file-priv=/tmp
[ ~]# /etc/init.d/mysqld restart
（2）导出mysql的表数据
mysql> select * from test.t100w into outfile ‘/tmp/t100w.csv‘ fields terminated by ‘,‘;
（3）处理备份文件
[ ~]# head -1 /tmp/t100w.csv 
id,num,k1,k2,dt     //添加第一行列名信息
[ ~]# scp  /tmp/t100w.csv :/mongodb/backup/
(4)在mongodb中导入备份
[ ~]$ mongoimport -uroot -proot123 -d opesn -c t100w --type=csv --headerline  --authenticationDatabase admin /mongodb/backup/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 -uroot -proot123 --authenticationDatabase admin -o /mongodb/backup/
#备份opesn库
[ ~]$ mongodump -uroot -proot123 --authenticationDatabase admin -d opesn -o /mongodb/backup/
#备份opesn库下的t100w集合
[ ~]$ mongodump -uroot -proot123 --authenticationDatabase admin -d opesn -c t100w -o /mongodb/backup/
#压缩备份
[ ~]$ mongodump -uroot -proot123 --authenticationDatabase admin -d opesn -c t100w -o /mongodb/backup/ --gzip

#恢复opesn库
[ ~]$ mongorestore  -uroot -proot123 --authenticationDatabase admin -d opesn /mongodb/backup/opesn/
#恢复opesn库下的t100w集合
[ ~]$ mongorestore  -uroot -proot123 --authenticationDatabase admin -d opesn -c t100w /mongodb/backup/opesn/t100w.bson 
或者
[ ~]$ mongorestore  -uroot -proot123 --authenticationDatabase admin -d opesn -c t100w --gzip /mongodb/backup/opesn/t100w.bson.gz 
#--drop表示恢复的时候把之前的集合drop掉(危险)
[ ~]$ mongorestore  -uroot -proot123 --authenticationDatabase admin -d opesn --drop  /mongodb/backup/opesn

oplog

在replica set中oplog是一个定容集合（capped collection），它的默认大小是磁盘空间的5%（可以通过--oplogSizeMB参数修改）.
位于local库的db.oplog.rs，有兴趣可以看看里面到底有些什么内容。
其中记录的是整个mongod实例一段时间内数据库的所有变更（插入/更新/删除）操作。
当空间用完时新记录自动覆盖最老的记录。
其覆盖范围被称作oplog时间窗口。需要注意的是，因为oplog是一个定容集合，
所以时间窗口能覆盖的范围会因为你单位时间内的更新次数不同而变化。

#想要查看当前的oplog时间窗口预计值，可以使用以下命令：
my_repl:PRIMARY> db.oplog.rs.find().pretty()
"ts" : Timestamp(1572276634, 1),
"op" : "n"
"o"  :

"i": insert
"u": update
"d": delete
"c": db cmd

my_repl:PRIMARY> rs.printReplicationInfo()
configured oplog size:   2048MB <--集合大小
log length start to end: 132876secs (36.91hrs) <--预计窗口覆盖时间
oplog first event time:  Mon Oct 28 2019 23:28:02 GMT+0800 (CST)
oplog last event time:   Wed Oct 30 2019 12:22:38 GMT+0800 (CST)
now:                     Wed Oct 30 2019 12:22:45 GMT+0800 (CST)
my_repl:PRIMARY> 

#oplog企业级应用
（1）实现热备，在备份时使用--oplog选项
注：为了演示效果我们在备份过程，模拟数据插入
（2）准备测试数据
[ ~]$ mongo --port 28018
my_repl:PRIMARY> use opesn
for(var i = 1 ;i < 100; i++) {
    db.foo.insert({a:i});
}
#查看插入的oplog
my_repl:PRIMARY> use local
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高级应用
#全备数据库
#模拟原始数据
[ ~]$ mongo --port 28018
my_repl:PRIMARY> use wo
for(var i = 1 ;i < 20; i++) {
    db.ci.insert({a: i});
}
[ ~]$ mongodump --port 28018 --oplog -o /mongodb/backup
--oplog功能:在备份同时,将备份过程中产生的日志进行备份文件必须存放在/mongodb/backup下,自动命令为oplog.bson

#再次模拟数据
my_repl:PRIMARY> use wo
db.ci1.insert({id:1})
db.ci2.insert({id:2})
#删除wo库下的ci表
my_repl:PRIMARY> use wo
db.ci.drop()
#备份现有的oplog.rs表
[ ~]$ mongodump --port 28018 -d local -c oplog.rs -o /mongodb/backup/
#截取oplog并恢复到drop之前的位置
[ ~]$ mongo --port 28018
my_repl:PRIMARY> use local
#获取到oplog误删除时间点位置:
	"ts" : Timestamp(1572435602, 1),
#恢复备份+应用oplog
[ ~]$ cd /mongodb/backup/local/
[ local]$ cp oplog.rs.bson ../oplog.bson  
[ local]$ rm -rf /mongodb/backup/local/
[ local]$ mongorestore --port 28018 --oplogReplay --oplogLimit "1572435602:1" --drop /mongodb/backup/

mongodb

jaylong

jaylong

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

分布式文档存储数据库之MongoDB访问控制的操作方法

　　什么是访问控制？

fengzhongdengdai 2020-11-17

分布式文档存储数据库之MongoDB备份与恢复的实践详解

　　为什么要备份？　　备份的目的是对数据做冗余的一种方式，它能够让我们在某种情况下保证最少数据的丢失；之前我们对mongodb做副本集也是对数据做冗余，但是这种在副本集上做数据冗余仅仅是针对系统故障或服务异常等一些非人为的故障发生时，保证数据服务的可用性；

lbyd0 2020-11-17

Pycharm连接MongoDB数据库安装教程详解

最新版本的Pycharm搜不到Plugin插件，自己手动下载Mongo Plugin插件下载地址。我把它放在了MongoDB的安装路径下。下一节开始试用。

BigYellow 2020-11-16

分布式文档存储数据库之MongoDB分片集群的问题

　　1、什么是分片？比如用户要查询年龄大于30的用户，该怎么查询呢？而年龄大于30的用户的数据，可能server1上有一部分数据，server2上有部分数据，我们怎么才能够把所有满足条件的数据全部查询到呢？

sushuanglei 2020-11-12

MongoDB数据库用户角色和权限管理详解

使用终端命令行输入 mongo 登陆 mongodb 之后切换到 admin 库，并认证后可查看所有数据库，操作如下所示：。Implicit session: session { "id" : UUID }. 说明：1 表示认证成功，0

我心似明月 2020-11-09

利用golang驱动操作MongoDB数据库的步骤

MongoDB中的JSON文档以称为BSON的二进制表示形式存储。与其他将JSON数据存储为简单字符串和数字的数据库不同，BSON编码扩展了JSON表示形式，例如int，long，date，float point和decimal128。这使应用程序更容易可

zhushenghan 2020-11-09

ubuntu安装mongodb创建账号和库及添加坐标索引的流程分析

... roles: [ { role: "readWrite", db: "lbs" },　　4.3移除数据库和日志文件

sunnnyduan 2020-10-16

MongoDB查询之高级操作详解（多条件查询、正则匹配查询等）

MongoDB查询文档使用find()方法，同时find()方法以非结构化的方式来显示所有查询到的文档。db.collection.find -- 返回所有符合查询条件的文档。$type操作符是基于BSON类型来检索集合中匹配的数据类型，MongoDB中可

不要皱眉 2020-10-14

SpringBoot+MongoDB实现物流订单系统的代码

我们都知道MongoDB是一款非常出色的非关系型文档数据库，你肯定会想问MongoDB这么强，我们该怎么用或者有啥运用场景呢？MongoDB的应用场景非常多，无论是数据存储还是日志存储越来越多的公司在使用MongoDB，而我们今天也在SpringBoot基

xiaohai 2020-09-29

MongoDb CPU利用率过高问题如何解决

在公司的项目中，突然出现过一个情况，mongodb 的CPU利用率到达100%,导致服务器这边卡死了，请求了半天无响应，提示请求超时。因为，当时APP用户可能会在某一个时间段集中的使用，所以，请求量一下子就飙上去了，刚好APP打开请求的时候，有一个mong

songxiugongwang 2020-09-22

flask_16：通过 MongoEngine 使用 MongoDB

使用一个 MongoDB 之类的文档型数据库来代替关系 SQL 数据是很常见的。本方案演示 如何使用文档映射库MongoEngine来集成 MongoDB 。基本的配置是在app.config中定义MONGODB_SETTINGS并创建一个MongoEng

萌亖 2020-09-17

MongoDB通配符索引的用法实例

MongoDB在4.2 版本推出了Wildcard Indexes，究竟什么是Wildcard Indexes以及Wildcard Indexes适合哪些场景本文结合官方文档以及实际测试进行简单概述。因为MongoDB是dynamic schemas，所以

LuckyLXG 2020-09-08

MongoDB 用户管理

小小最近接触了MongoDB，所以这里开始学习MongoDB，之用户管理模块的相关内容。使用如上的命令，切换数据库到admin数据库。cusomData 字段，任意内容，可以是用户名的全民介绍。roles 字段 指定用户的角色，用于给一个空数组，给新用户设

sdmzhu 2020-09-01

MongoDB如何查看版本信息详解

它处理数据请求，管理数据存储，和执行后台管理操作。当我们运行mongod命令意味着正在启动MongoDB进程,并且在后台运行。mongo是一个命令行工具用于连接一个特定的mongod实例。当我们没有带参数运行mongo命令它将使用默认的端口号和localh

mkhhxxttxs 2020-09-16

Centos7 yum安装mongodb实现步骤详解

复制和高可用性：支持服务器之间的数据复制，支持主-从模式及服务器之间的相互复制。复制的主要目的是提供冗余及自动故障转移。#这里可以修改 gpgcheck=0, 省去gpg验证[root@localhost ~]# yum makecache. system

xiaohai 2020-09-16

Docker 搭建集群MongoDB的实现步骤

由于公司业务需要，我们打算自己搭建 MongoDB 的服务，因为 MongoDB 的云数据库好贵，我们这次采用副本集的方式来搭建集群，三台服务器，一主、一副、一仲裁。Replica Set 副本集：一个副本集就是一组 MongoDB 实例组成的集群，由一个

newcome 2020-09-09

mongodb的聚合操作

聚合是MongoDB的高级查询语言，它允许我们通过转化合并由多个文档的数据来生成新的在单个文档里不存在的文档信息。MongoDB中聚合主要用于处理数据，并返回计算后的数据结果，有点类似sql语句中的 count(*)。Pipeline查询速度快于MapRe

jaylong 2020-08-19

mongodb的java客户端

<artifactId>spring-boot-starter-data-mongodb</artifactId>. private Long id;private String userName;private String pa

大秦铁骑 2020-08-19

mongodb的java客户端

<artifactId>spring-boot-starter-data-mongodb</artifactId>. private Long id;private String userName;private String pa

thatway 2020-08-19

mongodb的java客户端

<artifactId>spring-boot-starter-data-mongodb</artifactId>. private Long id;private String userName;private String pa

lovecodeblog 2020-08-19
jaylong

jaylong

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号