MongoDB-（基础）

1.Mongo的特点

NoSQL(NoSQL = Not Only SQL )，意即"不仅仅是SQL"。

官方：https://www.mongodb.com/download-center

高性能：
Mongodb提供高性能的数据持久性
尤其是支持嵌入式数据模型减少数据库系统上的I/O操作
索引支持能快的查询，并且可以包括来嵌入式文档和数组中的键

丰富的语言查询：
Mongodb支持丰富的查询语言来支持读写操作（CRUD）以及数据汇总，文本搜索和地理空间索引

高可用性：
Mongodb的复制工具，成为副本集，提供自动故障转移和数据冗余

水平可扩展性：
Mongodb提供了可扩展性，作为其核心功能的一部分，分片是将数据分，在一组计算机上

2.Mongo和MySQL数据对比

mysql   mongo(json)
库       库
表       集合
字段      key
行       文档

#.Mongo数据语法为json格式

mysql里的数据：
name    age     job
cookz   29      IT
json    22      PY
bobo    28      IT

mongo里的数据:
{name:cooz,age:29,job:IT}
{name:json,age:22,job:PY}
{name:bobo,age:28,job:IT,host:SZ}

3.Mongo应用场景

1.游戏场景：使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、更新

2.物流场景：使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。

3.社交场景：使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能

4.物联网场景：使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析

5.视频直播：使用 MongoDB 存储用户信息、礼物信息等,用户评论

6.电商场景：使用 MongoDB
商城上衣和裤子两种商品，除了有共同属性，如产地、价格、材质、颜色等外，还有各自有不同的属性集，如上衣的独有属性是肩宽、胸围、袖长等，裤子的独有属性是臀围、脚口和裤长等

4.安装部署Mongo

#1.下载软件
https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.14.tgz

#2.目录规划
/opt/mongodb
/opt/mongo_27017/{conf,pid,logs}
/data/mongo_27017

-------------------------------------------------------------------------------------------------------
#3.下载并解压
yum install libcurl openssl -y
#wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.14.tgz
tar zxf mongodb-linux-x86_64-rhel70-4.0.14.tgz -C /opt/
cd /opt/
ln -s mongodb-linux-x86_64-rhel70-4.0.14 mongodb

#4.创建目录以及数据目录
mkdir -p /opt/mongo_27017/{conf,pid,log}
mkdir -p /data/mongo_27017

#5.创建配置文件
cat >/opt/mongo_27017/conf/mongodb.conf<<EOF
systemLog:
 destination: file   
 logAppend: true  
 path: /opt/mongo_27017/log/mongodb.log

storage:
 journal:
   enabled: true
 dbPath: /data/mongo_27017
 directoryPerDB: true
 wiredTiger:
    engineConfig:
       cacheSizeGB: 1
       directoryForIndexes: true
    collectionConfig:
       blockCompressor: zlib
    indexConfig:
       prefixCompression: true

processManagement:
 fork: true
 pidFilePath: /opt/mongo_27017/pid/mongod.pid

net:
 port: 27017
 bindIp: 127.0.0.1,10.0.0.51
EOF

#6.启动
/opt/mongodb/bin/mongod -f /opt/mongo_27017/conf/mongodb.conf

#7.检查
ps -ef|grep mongo
netstat -lntup|grep mongo

#8.进入mongo
/opt/mongodb/bin/mongo

-------------------------------------------------------------------------------------------------------
#配置文件注解：
systemLog:
  destination: file #Mongodb 日志输出的目的地，指定一个file或者syslog，如果指定file，必须指定
  logAppend: true #当实例重启时，不创建新的日志文件， 在老的日志文件末尾继续添加
  path: /opt/mongo_27017/logs/mongodb.log #日志路径

storage:
  journal: #回滚日志
    enabled: true
  dbPath: /data/mongo_27017 #数据存储目录
  directoryPerDB: true #默认，false不适用inmemoryengine
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1 #将用于所有数据缓存的最大小
      directoryForIndexes: true #默认false索引集合storage.dbPath存储在数据单独子目录
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true

processManagement: #使用处理系统守护进程的控制处理
  fork: true #后台运行
  pidFilePath: /opt/mongo_27017/pid/mongod.pid #创建 pid 文件

net:
  port: 27017 #监听端口
  bindIp: 127.0.0.1,10.0.0.51 #绑定ip

5.配置Mongo环境变量

#1.配置环境变量
echo 'export PATH=/opt/mongodb/bin:$PATH' >> /etc/profile.d/mongo.sh
source /etc/profile

#2.登陆
mongo

#3.关闭
方法1:推荐
mongod -f /opt/mongo_27017/conf/mongodb.conf --shutdown

#方法2: 只能是使用localhost方式登陆
mongo
use admin
db.shutdownServer()

#方法3: system管理
#见下面的优化3

6.优化mongo警告

  • 内存不足
WARNING: The configured WiredTiger cache size is more than 80% of available RAM.
         See http://dochub.mongodb.org/core/faq-memory-diagnostics-wt

解决方法1: 加大机器内存
解决方法2: 调小配置文件里的缓存大小 cacheSizeGB: 0.5
  • 没有开启访问控制
WARNING: Access control is not enabled for the database.
         Read and write access to data and configuration is unrestricted.

解决方法：
开启安全账户功能
思路：
1.在未开启用户访问控制的实例下创建管理员用户
2.配置mongo的配置文件开启用户认证功能后并重启服务
3.使用管理员账号登录，并创建普通用户给予对库之间，不同的的权限
4.使用普通用户登录，并测试权限是否正常
  • 不建议以root身份运行
WARNING: You are running this process as the root user, which is not recommended.

解决方法1: 创建普通用户mongo，然后切换到mongo用户启动

解决方法2: 使用system方式登陆,指定运行用户为普通用户mongo

cat >/usr/lib/systemd/system/mongod.service<<EOF
[Unit]
Description=MongoDB Database Server
Documentation=https://docs.mongodb.org/manual
After=network.target

[Service]
User=mongo
Group=mongo
ExecStart=/opt/mongodb/bin/mongod -f /opt/mongo_27017/conf/mongodb.conf
ExecStartPre=/usr/bin/chown -R mongo:mongo /opt/mongo_27017/
ExecStartPre=/usr/bin/chown -R mongo:mongo /data/mongo_27017/

PermissionsStartOnly=true
PIDFile=/opt/mongo_27017/pid/mongod.pid
Type=forking

#file size
LimitFSIZE=infinity
#cpu time
LimitCPU=infinity
#virtual memory size
LimitAS=infinity
#open files
LimitNOFILE=64000
#processes/threads
LimitNPROC=64000
#locked memory
LimitMEMLOCK=infinity
#total threads (user+kernel)
TasksMax=infinity
TasksAccounting=false
#Recommended limits for for mongod as specified in
#http://docs.mongodb.org/manual/reference/ulimit/#recommended-settings

[Install]
WantedBy=multi-user.target
EOF
-------------------------------------------------------------------------------------
#关闭root方式启动。创建普通用户，使用system启动
pkill mongo
groupadd mongo -g 777
useradd mongo -g 777 -u 777 -M -s /sbin/nologin
id mongo
systemctl daemon-reload       # 重新加载system文件
systemctl start mongod.service
ps -ef|grep mongo
#登录并检查报警
mongo
  • 关闭大内存页
WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
         We suggest setting it to 'never'
WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
         We suggest setting it to 'never'

解决方法1：改完要重启(临时生效，重启失效)
echo "never" > /sys/kernel/mm/transparent_hugepage/enabled
echo "never" > /sys/kernel/mm/transparent_hugepage/defrag

解决办法2：写入开机自启动（永久生效）
chmod +x /etc/rc.d/rc.local
vim /etc/rc.d/rc.local
echo "never" >/sys/kernel/mm/transparent_hugepage/enabled
echo "never" >/sys/kernel/mm/transparent_hugepage/defrag
  • 数据目录磁盘不是XFS格式(少见)
WARNING: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine

解决方法：
把磁盘格式转成XFS
  • rlimits太低
WARNING: soft rlimits too low. rlimits set to 7266 processes, 100001 files. Number of processes should be at least 50000.5 : 0.5 times number of files.

解决方法：
vim /etc/profile
ulimit -f unlimited
ulimit -t unlimited
ulimit -v unlimited
ulimit -n 64000
ulimit -m unlimited
ulimit -u 64000

生效配置:
source /etc/profile

验证：
systemctl stop mongod
systemctl start mongod
mongo
  • 监控服务体验
Enable MongoDB's free cloud-based monitoring service, which will then receive and display
metrics about your deployment (disk utilization, CPU, operation statistics, etc).

The monitoring data will be available on a MongoDB website with a unique URL accessible to you
and anyone you share the URL with. MongoDB may use this information to make product
improvements and to suggest MongoDB products and deployment options to you.

To enable free monitoring, run the following command: db.enableFreeMonitoring()

To permanently disable this reminder, run the following command: db.disableFreeMonitoring()

解决方法：(拒绝)
db.disableFreeMonitoring()

7. Mongo数据库指令介绍

  • 默认库
admin   #系统预留库,系统管理库
config  #配置信息库
local   #回滚日志
test    #用户默认登陆库
  • 查看数据库命令
show databases/show dbs         #查看有哪些库
show tables/show collections    #查看当前所在的库下有哪些集合
use admin                       #切换到不同的库
db                              #查看当前在哪个库下

#mongo特别的地方
  1.mongo默认登陆的时候是在test库下
  2.mongo不需要提前创建库和表，直接use切换就是创建库，直接插入数据就会创建表
  3.使用use切换到的库，如果没有任何数据，实际上并不会真正创建，是个虚的库，所以show dbs并不会显现

8.Mongo操作命令

Mongo命令严格区分大小写

  • 插入单条
#db.user_info.insertOne（db：当前库下，创建user_info表，insertOne：插入单条数据）

db.user_info.insertOne({"name":"json","age":27,"ad":"北京市朝阳区"})
db.user_info.insertOne({"name":"bobo","age":28,"ad":"北京市朝阳区","sex":"null"})
  • 插入多条
#db.user_info2.insertMany(db：当前库下，创建user_info2表，insertMany：插入多条数据，需加中括号)
db.user_info2.insertMany([
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]);
  • 查询语句
#查询1条数据
db.user_info.findOne()

#查询所有数据
db.user_info.find()

#按条件查询
#查询语句规则：字符串带双引，数字不用带
db.user_info.find({"age":28})        #对比MySQL查询语句select * from user_info where age = 28;

#只返回想要的字段
db.user_info.find({"name":"json"},{name:1,_id:0})
#                   条件          显示开关0：关闭，1：显示

#嵌套条件查询
题：{ "_id" : ObjectId("5eb943926e8bd93326d797ae"), "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "cm" }, "status" : "A" }
#（size.uom:size字段中的uom字段。"."：表示第二级）

db.inventory.find(
  {
    "size.uom":"in"
  },
  {
    size:1,
    _id:0
  }
)

#逻辑查询：and
#（","：逗号分隔第二个条件。即and：同时满足条件）
db.inventory.find(
  {
     "size.uom":"cm",
     "status":"D"
  },
  {
     size:1,
     status:1,
     _id:0
  }
)

#逻辑查询：or
#官方：https://docs.mongodb.com/manual/reference/operator/query-comparison/

db.inventory.find({$or:[{"size.uom":"cm"},{qty:{$gt:50}}]})
#（$or:[{}]：中括号中条件为或者，{}：表示指定的条件）

db.inventory.find(
  {
    $or:[
           {"size.uom":"cm"},
           {"qty":{$gt:50}}, 
        ]
  }
)

#逻辑查询+或+and+正则表达式

db.inventory.find({"status":"A",$or:[{"qty":{$gt:50}},{"item":/^p/}]})
#（首先必须满足status：A，然后满足qty:大于50或item:p开头的字段）

db.inventory.find(
  {
    "status":"A",
    $or:[
           {"qty":{$gt:50}}, 
           {"item":/^p/}
        ]
  }
)

db.inventory.find({
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
})
  • 更新语句

按条件更新
语句：先按照查询条件找出数据→然后进行修改或添加新字段

#更新单条
#db.inventory.updateOne（单条数据修改，查找item：paper，然后修改字段中内容）

db.inventory.find({"item":"paper"})
db.inventory.updateOne(
  {"item":"paper"},
  {
      $set: {  
               "size.uom" : "cm",  
               "status" : "P" 
            }
  }
)

#按条件更新多条
#db.inventory.updateMany（先按照条件查找，然后更新所有查找出的数据）

db.inventory.updateMany(
  {
    "status":"A",
    $or:[
           {"qty":{$lt:100}}, 
           {"item":/^p/}
        ]
  },
  {
      $set: {  
               "item" : "cookzhang",  
               "status" : "P" 
            }
  }
)

#增加字段
#db.inventory.updateMany（先按照条件查找出满足条件数据，然后更新，添加一个字段）
db.inventory.updateMany(
  {
    "status":"A",
    $or:[
           {"qty":{$lt:100}}, 
           {"item":/^c/}
        ]
  },
  {
      $set: {  
                "pet":"cat"
            }
  }
)

9.索引命令

  • 查看执行计划
#.explain()：显示执行计划
db.user_info2.find({age:{$lt:30}}).explain()
#观察"stage" : "COLLSCAN",collscan:全表扫描。只要不为collscan即可
  • 创建索引
#age字段中“1”：升序，background:true后台创建
db.user_info2.createIndex({age:1},{background:true})
  • 查看索引详细
#查看user_info2表中的索引详细信息
db.user_info2.getIndexes()
#再次查看执行计划，此时"stage" : "IXSCAN"，已经走索引
db.user_info.find({age:{$lt:30}}).explain()
  • explain需注意关键词
#stage" : "COLLSCAN：全表扫描，没走索引
"stage" : "IXSCAN"       # 已走索引
"indexName" : "age_1"    # 已走索引的名称

10.删除语句

  • 查删除单条
#按照条件查询单条数据。如果查询结果为多条，默认只删除第一条数据
db.inventory.deleteOne({"status":"A"})
  • 删除多条
db.inventory.deleteMany({"status":"A"})
  • 删除索引
#填写索引的名称indexName后名称
db.user_info.dropIndex("age_1")
  • 删库
#删除库后，虽然任然在当前库，但是show dbs查看所有库，不存在
db.dropDatabase()

11.创建用户和角色

官方说明：https://docs.mongodb.com/manual/core/authorization/

  • 在未开启用户访问控制的实例下创建管理员账户
use admin
db.createUser(
  {
    user: "myUserAdmin",
    pwd: "123456", 
    roles: [ { role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase" ]
  }
)

#4.2版本以上，密码填写查看官方
# 权限：对所有库拥有所有权限。但无删库权限。集合可以
  • 配置mongo的配置文件开启用户认证功能后并重启服务
vim /opt/mongo_27017/conf/mongodb.conf 
security:
 authorization: enabled       # 安全认证
# 重启mongod服务
systemctl restart mongod.service
  • 使用管理员账号登录，并创建普通用户给予对库之间，不同的的权限
mongo --authenticationDatabase "admin" -u "myUserAdmin" -p
# 登录原则，需填写用户名，密码，登录用户创建时，信息存放的所在目录
# admin 为库，此库存放了管理员用户的信息。


#1.使用管理员账户创建普通用户并查看
use test
db.createUser(
  {
    user: "mysun",
    pwd:  "123456",
    roles: [ { role: "readWrite", db: "readWrite" },
             { role: "read", db: "read" } ]
  }
)

db.getUsers()          #查看当前库下用户信息
#role：权限，db：指定的单个库。read：读权限，readWrite：读写权限

#2.使用管理员账户创建测试库
use readWrite
db.write.insertOne({"name":"cookzhang"})

use read
db.read.insertOne({"name":"cookzhang"})
  • 退出管理员账户并使用刚才创建的普通用户登陆
mongo --authenticationDatabase "test" -u "mysun" -p             
show dbs

use readWrite
show tables
db.write.insertOne({"name":"json"}) #正常写入
db.write.find()

use read
show tables
db.read.find()
db.read.insertOne({"name":"bobo"})  #应该报错
  • 修改用户权限(需使用管理员账户)
mongo --authenticationDatabase "admin" -u "myUserAdmin" -p     
use test
db.updateUser(
  'mysun',
  { 
    pwd: "123456",
    roles: [ { role: "readWrite", db: "readWrite" },
             { role: "readWrite", db: "read" } ,
             { role: "readWrite", db: "test" }]
             
  }
)
db.getUsers()
  • 普通账户测试修改后的权限
mongo --authenticationDatabase "test" -u "mysun" -p 
show dbs

use readWrite
show tables
db.write.insertOne({"name":"json"}) #正常写入
db.write.find()

use read
show tables
db.read.find()
db.read.insertOne({"name":"bobo"})  #正常写入
  • 删除用户(管理员)
mongo --authenticationDatabase "admin" -u "myUserAdmin" -p 
use test
db.getUsers()          #查看当前库下用户信息，记录名称用于删除
db.dropUser("mysun")
db.getUsers()        # 再次查看，检查是否已经成功删除

12.windows安装Mongo图形化工具

连接单机

image.png

image.png

image.png

连接副本集

image.png

image.png

13.mongo工具介绍

[root@db01 /opt/mongodb/bin]# ll
mongo         #登陆命令
mongod        #启动命令
mongodump     #全备导出，压缩格式
mongorestore  #恢复mongodump备份
mongoexport   #备份导出，可读的json格式
mongoimport   #恢复mongoexport备份
mongos        #集群分片
mongotop      #查看mongo的运行状态
mongostat     #查看mongo的运行状态
  • mongostat使用说明
#默认一秒打印一次
#使用-n参数可以只打印一次
mongostat -n 1     # 查看频繁操作的语句类型。增删改查
mongotop -n 1      # 查看那个集合在进行操作

## mongostat字段说明

insert/s : 官方解释是每秒插入数据库的对象数量，如果是slave，则数值前有*,则表示复制集操作
query/s : 每秒的查询操作次数
update/s : 每秒的更新操作次数
delete/s : 每秒的删除操作次数
getmore/s: 每秒查询cursor(游标)时的getmore操作数
command: 每秒执行的命令数，在主从系统中会显示两个值(例如 3|0),分表代表 本地|复制 命令
注： 一秒内执行的命令数比如批量插入，只认为是一条命令（所以意义应该不大）
dirty: 仅仅针对WiredTiger引擎，官网解释是脏数据字节的缓存百分比
used:仅仅针对WiredTiger引擎，官网解释是正在使用中的缓存百分比
flushes:
For WiredTiger引擎：指checkpoint的触发次数在一个轮询间隔期间
For MMAPv1 引擎：每秒执行fsync将数据写入硬盘的次数
注：一般都是0，间断性会是1， 通过计算两个1之间的间隔时间，可以大致了解多长时间flush一次。flush开销是很大的，如果频繁的flush，可能就要找找原因了
vsize： 虚拟内存使用量，单位MB （这是 在mongostat 最后一次调用的总数据）
res:  物理内存使用量，单位MB （这是 在mongostat 最后一次调用的总数据）
注：这个和你用top看到的一样, vsize一般不会有大的变动， res会慢慢的上升，如果res经常突然下降，去查查是否有别的程序狂吃内存。
qr: 客户端等待从MongoDB实例读数据的队列长度
qw：客户端等待从MongoDB实例写入数据的队列长度
ar: 执行读操作的活跃客户端数量
aw: 执行写操作的活客户端数量
注：如果这两个数值很大，那么就是DB被堵住了，DB的处理速度不及请求速度。看看是否有开销很大的慢查询。如果查询一切正常，确实是负载很大，就需要加机器了
netIn:MongoDB实例的网络进流量
netOut：MongoDB实例的网络出流量
注：此两项字段表名网络带宽压力，一般情况下，不会成为瓶颈
conn: 打开连接的总数，是qr,qw,ar,aw的总和
注：MongoDB为每一个连接创建一个线程，线程的创建与释放也会有开销，所以尽量要适当配置连接数的启动参数，maxIncomingConnections，阿里工程师建议在5000以下，基本满足多数场景
  • 小实验

一个终端写入测试数据，并观察mongostat和mongotop值的变化

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

一个终端使用mongotop观察   # 观察那个库.集合   
一个终端使用mongostat观察  # 观察操作

14.备份与恢复

工具介绍
mongodump/mongorestore #mongo自带的备份和恢复套件
mongoexport/mongoimport #mongo自带的备份和恢复套件

  • 应用场景
定时备份 mongodump/mongorestore         #不可读
分析数据 mongoexport/mongoimport          # json格式，可读
迁移数据 mongoexport/mongoimport          # csv格式，可读
  • mongodump-备份单节点数据
#全备数据-mongodump   -o : 指定路径
mongodump --port 28017 -o mongo_backup
#只备份某个库   -d : 指定库   -o : 指定路径
mongodump --port 28017 -d test -o mongo_backup 
#只备份某个库下某个集合   -d : 指定库 -C：指定集合  -o : 指定路径
mongodump --port 28017 -d bobo -c bobo -o mongo_backup
  • mongodump-备份整个副本集
# --host : 副本集id -o : 指定路径
mongodump --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 -o mongo_backup
# --host : 副本集id -o : 指定路径  gzip 压缩格式备份
mongodump --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 -o mongo_backup --gzip
# 副本集中只要有一个节点存活就可以备份数据。    仲裁节点除外
  • mongorestore-恢复整个副本集数据
#  --host : 副本集id -o : 指定路径  drop 参数会顶掉。原本集合中的参数
mongorestore --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 --dir=./mongo_backup --drop
#恢复gzip压缩格式的数据。drop 参数会顶掉。原本集合中的参数
mongorestore --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 --dir=./mongo_backup --drop --gzip
  • mongoexport-导出数据
# 导出json格式可读， -d :指定库 -c:指定集合
mongoexport -d test -c user_info --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 -o mongo_backup/user_info.json
# 导出csv格式，直接表格excel可打开 -d :指定库 -c:指定集合 --type：类型csv fields:指定导出集合中的字段
mongoexport -d test -c user_info --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010  --type=csv --fields=name,age,ad -o mongo_backup/user_info.csv
  • mongoimport-恢复数据
#  -d :指定库 -c:指定集合  drop 参数会顶掉。原本集合中的参数
mongoimport -d test -c user_info --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 mongo_backup/user_info.json --drop
# -d :指定库 -c:指定集合  --type：类型csv drop 参数会顶掉。原本集合中的参数
mongoimport -d test -c user_info --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010  --type=csv --headerline mongo_backup/user_info.csv

15.mysql数据迁移到mongo

  • mysql自定义分隔符导出成csv格式
select * from world.city into outfile '/var/lib/mysql/city.csv' fields terminated by ',';
# 指定分隔符为：, 号  fields:指定字段
#/var/lib/mysql/:为mysql自身目录。如需指定其他目录。需要在配置文件添加安全目录的参数
  • 修改CSV格式并添加字段
# 手动为csv文件加上mysql表中的字段
vim /var/lib/mysql/city.csv
ID,Name,CountryCode,District,Population
  • mongo导入修改后的csv格式
mongoimport -d world -c city --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010  --type=csv --headerline city.csv
# -d :指定库 -c ：指定集合

案例1：

任务背景：
老大发给他几个CSV格式的文件，让他导入到ES里

  • 解决步骤
1.先把csv导入到mongo里
mongoimport -d world -c city --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010  --type=csv --headerline city.csv

2.把mongo数据导出成json
mongoexport -d world -c city --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 -o mongo_backup/city.json

3.把json导入到es
例如：
curl -XPOST '27.10.1.2:9200/bank/account/_bulk?pretty' --data-binary "@/home/dd/accounts.json"

案例2：

#1.模拟场景
小波早上10点误删除数据库 
mongo副本集数据库和全备文件情况：
1
2
3
全备
4
5
6
drop database        #10点误删除数据库

#测试环境模拟
2.准备测试数据
use backup
db.backup.insertMany( [
    { "id": 1},
    { "id": 2},
    { "id": 3},
]);

3.全备数据（模拟全备的文件）
rm -rf mongo_backup
mongodump --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 --oplog -o mongo_backup

4.增加新数据
db.backup.insertMany( [
    { "id": 4},
    { "id": 5},
    { "id": 6},
]);

5.模拟误删除数据
use backup
db.dropDatabase()

6.备份oplog（紧急备份当前数据，保护好现场）
mongodump --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 -d local -c oplog.rs -o mongo_backup

7.登录集群，查找误删除时间点
use local
db.oplog.rs.find({"ns":"backup.$cmd"}).pretty()          #ns:对那块库操作，$cmd：执行所有的操作命令，pretty()人类可读json模式

8.找到误删除的时间点
"ts" : Timestamp(1584408504, 1)

9.截断oplog的drop时间点，然后恢复
cd mongo_backup
cp local/oplog.rs.bson oplog.bson    #提取出oplog并需改名
rm -rf local        #删除local库

10.恢复数据
mongorestore --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 --oplogReplay --oplogLimit="1584408504" mongo_backup --drop

案例3：

#场景：test、back库均有误操作删除库，且未及时发现，有新数据写入。
#下面是全备文件内容，和误操作流程图
test back
1     a
2     b
3     c
全备
dorp  test
4     d
5     e
dorp  back
6     f

#整体思路
1.保护现场，紧急备份全备当前数据情况，并拷贝多份
2.先恢复test库，然后还原
3.再恢复backup库

恢复test数据思路：（先拆分两库）
 test 
1    
2    
3    
全备
dorp  test
4   
5   
6 

#1.因为test库现有4,5,6数据，这里缺少的1,2,3。而全备中有，这里只需恢复全备即可。
#2.测试环境test库数据恢复后，当初文件并保存，用于后面恢复到生产环境

1.恢复全备：
mongorestore --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 mongo_backup_20200316

2.导出test:（测试环境数据恢复成功后导出数据）
mongoexport -d test -c test --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 -o mongo_backup_test_ok/test.json


恢复backup库：
back
a
b
c
全备      20200316           # 全备文件
d
e
dorp  back                  # 误操作删库
f                           # 当前库中数据情况

1.导出当前的oplog到全备里：
mongodump --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019 -d local -o mongo_backup_20200316
cd mongo_backup_20200316
cp local/oplog.rs.bson oplog.bson 
rm -rf local

2.查找时间戳：
use local
db.oplog.rs.find({"ns":"backup.$cmd"}).pretty()                # 查找误删除时间点
db.oplog.rs.find({"op":"i","ns":"backup.backup"}).pretty()     # 查找具体的数据写入内容

3.核对时间戳，删除库的时间戳是否存在于，切入数据e,f之间（如不存在，根据本题意则错误）
1584427733 e 
1584427746 drop 
1584427763 f 

4.恢复到drop时间戳之前：
mongorestore --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 --oplogReplay --oplogLimit="1584427746" mongo_backup_20200316 

5.导出backup数据：（测试环境backup库数据恢复成功后导出数据）
mongoexport -d backup -c backup --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 -o mongo_backup_backup_ok/backup.json

----------------------------将测试环境数据恢复到生产环境中-------------------------------------------

#恢复全备：（生产环境）
mongorestore --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 mongo_backup_20200316 --drop

#恢复test:（测试环境拷贝文件）
mongoimport -d test -c test --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 mongo_backup_test_ok/test.json

#恢复backup:（测试环境拷贝文件）
mongoimport -d backup -c backup --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 mongo_backup_backup_ok/backup.json


#补充：如果时间戳有多条记录，如何恢复指定的时间的操作的方法
mongorestore --host=dba/10.0.0.51:28017,10.0.0.51:28018,10.0.0.51:28019,10.0.0.51:28010 --oplogReplay --oplogLimit="1584419170:4" mongo_backup_20200316
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
禁止转载，如需转载请通过简信或评论联系作者。

推荐阅读更多精彩内容

  • mongodb-基础
    第1章 关系型与非关系型 第2章 mongo和mysql数据对比 第3章 MongoDB特点 第4章 mongo应...
    被运维耽误的厨子阅读 1,389评论 0赞 3
  • MongoDB-基础篇章
    1.NoSQL和MongoDB简介 文档是以二进制格JSON(BSON)对象的方式存储的，使用集合将数据编组，相当...
    JAVA觅音阁阅读 835评论 0赞 1
  • MongoDB基础
    备注：本文非原创，参考自以下文章https://blog.csdn.net/hayre/article/detai...
    加坊小子阅读 62评论 0赞 0
  • MongoDB基础操作
    MongoDB是什么 MongoDB是一个基于分布式文件存储的数据库。有C++语言编写，旨在为WEB应用提供可扩展...
    魔炫Max阅读 378评论 0赞 1
  • MongoDB数据库基本操作
    MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写，旨在为 WEB 应用提供可扩展的高性能数据...
    LittlePy阅读 1,626评论 0赞 4