MongoDB学习Python3.6实现备忘录

最新推荐文章于 2021-06-03 08:55:52 发布

Deft_MKJing宓珂璟

最新推荐文章于 2021-06-03 08:55:52 发布

阅读量1.1k

点赞数

分类专栏：数据库Mysql，Redis，MongoDB Python3学习文章标签： MongoDB Mongod远程连接失败 Ubuntu 15.4安装MongoDB MongoDB配置访问权限

本文链接：https://blog.csdn.net/Deft_MKJing/article/details/81563853

版权

Python3学习同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

数据库Mysql，Redis，MongoDB

5 篇文章 0 订阅

订阅专栏

NoSQL简介

安装MongoDB

连接不上问题

1.sudo service mongod start失败

2.设置了0.0.0.0，远程连接还是无法访问

NoSQL简介

NoSQL，全名为Not Only SQL，指的是非关系型的数据库
随着访问量的上升，网站的数据库性能出现了问题，于是nosql被设计出来

优点/缺点

优点:
- 高可扩展性
- 分布式计算
- 低成本
- 架构的灵活性，半结构化数据
- 没有复杂的关系
缺点:
- 没有标准化
- 有限的查询功能（到目前为止）
- 最终一致是不直观的程序

分类

类型	部分代表	特点
列存储	Hbase Cassandra Hypertable	顾名思义，是按列存储数据的。最大的特点是方便存储结构化和半结构化数据，方便做数据压缩，对针对某一列或者某几列的查询有非常大的IO优势。
文档存储	MongoDB CouchDB	文档存储一般用类似json的格式存储，存储的内容是文档型的。这样也就有有机会对某些字段建立索引，实现关系数据库的某些功能。
key-value存储	Tokyo Cabinet / Tyrant Berkeley DB MemcacheDB Redis	可以通过key快速查询到其value。一般来说，存储不管value的格式，照单全收。（Redis包含了其他功能）
图存储	Neo4J FlockDB	图形关系的最佳存储。使用传统关系数据库来解决的话性能低下，而且设计使用不方便。
对象存储	db4o Versant	通过类似面向对象语言的语法操作数据库，通过对象的方式存取数据。
xml数据库	Berkeley DB XML BaseX	高效的存储XML数据，并支持XML的内部查询语法，比如XQuery,Xpath。

我用的Mac，弄了个虚拟机安装Ubuntu，安装方式很早之前Mysql的时候就有写了，需要的可以查看

Mysql相关知识

和Mysql一样，我们需要安装然后开启服务，网上找了半天，安装的话还是按照官方的介绍安装即可。

安装MongoDB

MongoDB官方安装方式

由于我弄的Ubuntu是15.04的，因此我安装的14.04下面的包，这里安装好了，理论上执行

sudo service mongod start

服务端用的是mongod，但是仅仅如此有可能是会报错的，没遇到可以无视

Failed to start mongod.service: Unit mongod.service failed to load: No such file or directory.

这是解决方案

翻译下解决方案，我们可以在任何地方vi一个文件

vi mongod.service

然后把下面的文本保存到这里mongod.service

[Unit]
Description=High-performance, schema-free document-oriented database
After=network.target

[Service]
User=mongodb
ExecStart=/usr/bin/mongod --quiet --config /etc/mongod.conf

[Install]
WantedBy=multi-user.target

注意，/etc/mongod.conf是配置文件，老外回答原文是mongodb.conf，根据自己的情况修改。

继续执行

sudo mv mongod.service /lib/systemd/system/

我是有遇到这个东西，需要自己设置，但是后来装就没有了，没有遇到的可以忽略

然后

deftmikejing@deftmikejing-VirtualBox:/lib/systemd/system$ sudo service mongod start
deftmikejing@deftmikejing-VirtualBox:/lib/systemd/system$ clear
[3;J
deftmikejing@deftmikejing-VirtualBox:/lib/systemd/system$ ps ajx|grep mongod
    1  6311  6311  6311 ?           -1 Ssl    121   0:00 /usr/bin/mongod --quiet --config /etc/mongod.conf
 2877  6339  6338  2877 pts/1     6338 S+    1000   0:00 grep --color=auto mongod

服务已经开启了，这个时候cd到 /etc/mongod.conf可以查看配置文件了

如果需要远程连接，需要如下操作

net:
  port: 27017
  bindIp: 0.0.0.0

把端口设置成0.0.0.0所有ip都可以访问，测试访问如下

也可以用GUI工具

在这里推荐一个可视化工具 RoboMongo/Robo 3T，使用简单，功能强大，官方网站：https://robomongo.org/，三大平台都有支持，下载链接：https://robomongo.org/download。连接即可。

连接不上问题

1.sudo service mongod start失败

这种情况我一开始遇到就一直没搞好，后来还是按照官方最新的安装方式，根据自己的系统版本安装下来，就再也没有出现。网上很多资料针对这个问题，总结下来就是路径没指定，直接执行如下也能解决

sudo mongod --dbpath=/var/lib/mongodb --port 27017

这里的路径就是 /etc/mongod.conf下面的配置内容。然后再起个终端就可连接

参考链接

2.设置了0.0.0.0，远程连接还是无法访问

这个问题困扰了我一天，怎么搞都连不上，但是我的mysql就可以，总共找了几个问题，如下

防火墙设置问题

权限认证问题，需要配置用户名密码（别按这个文章的介绍安装，安装按我上面的来）

反正我按照网上的来一直无法成功，后来还是全部卸载干净，然后重新按照官方的安装，简单的这是为 /etc/mongo.conf

0.0.0.0即可

sudo service mongod stop

sudo apt-get purge mongodb-org*

sudo rm -r /var/log/mongodb
sudo rm -r /var/lib/mongodb

找了很多资料，其实这种无法连接或者本地连接不上的问题，基本就是没有正常退出Mongod，服务被非正常杀死，会导致一系列连接问题，最好不用了执行stop

sudo service mongod stop

以上服务端开启完毕，而且小问题也搞定了

客户端连接中Mysql是安装完服务器自动开启了，MongoDB需要手动开启，而且Mysql的服务端连接方式是

mysql -uroot -p

MongoDB直接执行进入

mongo

MongoDB 和 Mysql的区别

SQL术语/概念	MongoDB术语/概念	解释/说明
database	database	数据库
table	collection	数据库表/集合
row	document	数据记录行/文档
column	field	数据字段/域
index	index	索引
table joins		表连接,MongoDB不支持
primary key	primary key	主键,MongoDB自动将_id字段设置为主键

MongoDB基础操作介绍

数据库操作

查看当前数据库名称

db

查看所有数据库名称
列出所有在物理上存在的数据库

show dbs

切换数据库
如果数据库不存在，则指向数据库，但不创建，直到插入数据或创建集合时数据库才被创建

use 数据库名称

默认的数据库为test，如果你没有创建新的数据库，集合将存放在test数据库中
删除当前指向的数据库
如果数据库不存在，则什么也不做

db.dropDatabase()

默认连接的test数据库，创建的时候直接use 数据库名称即可，当没有数据的时候是不会显示的，有数据后才会显示出来

Collection操作

语法

db.createCollection(name, options)

name是要创建的集合的名称
options是一个文档，用于指定集合的配置
选项参数是可选的，所以只需要到指定的集合名称。以下是可以使用的选项列表：
例1：不限制集合大小

db.createCollection("stu")

例2：限制集合大小，后面学会插入语句后可以查看效果
参数capped：默认值为false表示不设置上限，值为true表示设置上限
参数size：当capped值为true时，需要指定此参数，表示上限大小，当文档达到上限时，会将之前的数据覆盖，单位为字节

db.createCollection("sub", { capped : true, size : 10 } )

查看当前数据库的集合

语法

show collections

删除

语法

db.集合名称.drop()

数据类型

下表为MongoDB中常用的几种数据类型：
Object ID：文档ID
String：字符串，最常用，必须是有效的UTF-8
Boolean：存储一个布尔值，true或false
Integer：整数可以是32位或64位，这取决于服务器
Double：存储浮点值
Arrays：数组或列表，多个值存储到一个键
Object：用于嵌入式的文档，即一个值为一个文档
Null：存储Null值
Timestamp：时间戳
Date：存储当前日期或时间的UNIX时间格式

object id

每个文档都有一个属性，为_id，保证每个文档的唯一性
可以自己去设置_id插入文档
如果没有提供，那么MongoDB为每个文档提供了一个独特的_id，类型为objectID
objectID是一个12字节的十六进制数
- 前4个字节为当前时间戳
- 接下来3个字节的机器ID
- 接下来的2个字节中MongoDB的服务进程id
- 最后3个字节是简单的增量值

CRUD

插入

语法

db.集合名称.insert(document)

插入文档时，如果不指定_id参数，MongoDB会为文档分配一个唯一的ObjectId
例1

db.stu.insert({name:'gj',gender:1})

例2

s1={_id:'20160101',name:'hr'}
s1.gender=0
db.stu.insert(s1)

简单查询

语法

db.集合名称.find()

更新

语法

db.集合名称.update(
   <query>,
   <update>,
   {multi: <boolean>}
)

参数query:查询条件，类似sql语句update中where部分
参数update:更新操作符，类似sql语句update中set部分
参数multi:可选，默认是false，表示只更新找到的第一条记录，值为true表示把满足条件的文档全部更新
例3：全文档更新

db.stu.update({name:'hr'},{name:'mnc'})

例4：指定属性更新，通过操作符$set

db.stu.insert({name:'hr',gender:0})
db.stu.update({name:'hr'},{$set:{name:'hys'}})

例5：修改多条匹配到的数据

db.stu.update({},{$set:{gender:0}},{multi:true})

保存

语法

db.集合名称.save(document)

如果文档的_id已经存在则修改，如果文档的_id不存在则添加
例6

db.stu.save({_id:'20160102','name':'yk',gender:1})

例7

db.stu.save({_id:'20160102','name':'wyk'})

删除

语法

db.集合名称.remove(
   <query>,
   {
     justOne: <boolean>
   }
)

参数query:可选，删除的文档的条件
参数justOne:可选，如果设为true或1，则只删除一条，默认false，表示删除多条
例8：只删除匹配到的第一条

db.stu.remove({gender:0},{justOne:true})

例9：全部删除

db.stu.remove({})

详细查询操作

基本查询

方法find()：查询

db.集合名称.find({条件文档})

方法findOne()：查询，只返回第一个

db.集合名称.findOne({条件文档})

方法pretty()：将结果格式化

db.集合名称.find({条件文档}).pretty()

比较运算符

等于，默认是等于判断，没有运算符
小于$lt
小于或等于$lte
大于$gt
大于或等于$gte
不等于$ne
例1：查询名称等于'gj'的学生

db.stu.find({name:'gj'})

例2：查询年龄大于或等于18的学生

db.stu.find({age:{$gte:18}})

逻辑运算符

查询时可以有多个条件，多个条件之间需要通过逻辑运算符连接
逻辑与：默认是逻辑与的关系
例3：查询年龄大于或等于18，并且性别为1的学生

db.stu.find({age:{$gte:18},gender:1})

逻辑或：使用$or
例4：查询年龄大于18，或性别为0的学生

db.stu.find({$or:[{age:{$gt:18}},{gender:1}]})

and和or一起使用
例5：查询年龄大于18或性别为0的学生，并且学生的姓名为gj

db.stu.find({$or:[{age:{$gte:18}},{gender:1}],name:'gj'})

范围运算符

使用"$in"，"$nin" 判断是否在某个范围内
例6：查询年龄为18、28的学生

db.stu.find({age:{$in:[18,28]}})

支持正则表达式

使用//或$regex编写正则表达式
例7：查询姓黄的学生

db.stu.find({name:/^黄/})
db.stu.find({name:{$regex:'^黄'}}})

自定义查询

使用$where后面写一个函数，返回满足条件的数据
例7：查询年龄大于30的学生

db.stu.find({$where:function(){return this.age>20}})

Limit

方法limit()：用于读取指定数量的文档
语法：

db.集合名称.find().limit(NUMBER)

参数NUMBER表示要获取文档的条数
如果没有指定参数则显示集合中的所有文档
例1：查询2条学生信息

db.stu.find().limit(2)

skip

方法skip()：用于跳过指定数量的文档
语法：

db.集合名称.find().skip(NUMBER)

参数NUMBER表示跳过的记录条数，默认值为0
例2：查询从第3条开始的学生信息

db.stu.find().skip(2)

一起使用

方法limit()和skip()可以一起使用，不分先后顺序
创建数据集

for(i=0;i<15;i++){db.t1.insert({_id:i})}

查询第5至8条数据

db.stu.find().limit(4).skip(5)
或
db.stu.find().skip(5).limit(4)

投影

在查询到的返回结果中，只选择必要的字段，而不是选择一个文档的整个字段
如：一个文档有5个字段，需要显示只有3个，投影其中3个字段即可
语法：
参数为字段与值，值为1表示显示，值为0不显示

db.集合名称.find({},{字段名称:1,...})

对于需要显示的字段，设置为1即可，不设置即为不显示
特殊：对于_id列默认是显示的，如果不显示需要明确设置为0
例1

db.stu.find({},{name:1,gender:1})

例2

db.stu.find({},{_id:0,name:1,gender:1})

排序

方法sort()，用于对结果集进行排序
语法

db.集合名称.find().sort({字段:1,...})

参数1为升序排列
参数-1为降序排列
例1：根据性别降序，再根据年龄升序

db.stu.find().sort({gender:-1,age:1})

统计个数

方法count()用于统计结果集中文档条数
语法

db.集合名称.find({条件}).count()

也可以与为

db.集合名称.count({条件})

例1：统计男生人数

db.stu.find({gender:1}).count()

例2：统计年龄大于20的男生人数

db.stu.count({age:{$gt:20},gender:1})

消除重复

方法distinct()对数据进行去重
语法

db.集合名称.distinct('去重字段',{条件})

例1:查找年龄大于18的性别（去重）

db.stu.distinct('gender',{age:{$gt:18}}

MongoDB进阶操作介绍

聚合 aggregate

聚合(aggregate)主要用于计算数据，类似sql中的sum()、avg()
语法

db.集合名称.aggregate([{管道:{表达式}}])

管道

管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的输入

ps ajx | grep mongo

在mongodb中，管道具有同样的作用，文档处理完毕后，通过管道进行下一次处理
常用管道
- $group：将集合中的文档分组，可用于统计结果
- $match：过滤数据，只输出符合条件的文档
- $project：修改输入文档的结构，如重命名、增加、删除字段、创建计算结果
- $sort：将输入文档排序后输出
- $limit：限制聚合管道返回的文档数
- $skip：跳过指定数量的文档，并返回余下的文档
- $unwind：将数组类型的字段进行拆分

表达式

处理输入文档并输出
语法

表达式:'$列名'

常用表达式
- $sum：计算总和，$sum:1同count表示计数
- $avg：计算平均值
- $min：获取最小值
- $max：获取最大值
- $push：在结果文档中插入值到一个数组中
- $first：根据资源文档的排序获取第一个文档数据
- $last：根据资源文档的排序获取最后一个文档数据

$group

将集合中的文档分组，可用于统计结果
_id表示分组的依据，使用某个字段的格式为'$字段'
例1：统计男生、女生的总人数

db.stu.aggregate([
    {$group:
        {
            _id:'$gender',
            counter:{$sum:1}
        }
    }
])

Group by null

将集合中所有文档分为一组
例2：求学生总人数、平均年龄

db.stu.aggregate([
    {$group:
        {
            _id:null,
            counter:{$sum:1},
            avgAge:{$avg:'$age'}
        }
    }
])

透视数据不单单是统计，和Mysql里面不同的是这里会把集合里面的数据变成json对象列出来或者$$ROOT列成数组

例3：统计学生性别及学生姓名

db.stu.aggregate([
    {$group:
        {
            _id:'$gender',
            name:{$push:'$name'}
        }
    }
])

使用$$ROOT可以将文档内容加入到结果集的数组中，代码如下

db.stu.aggregate([
    {$group:
        {
            _id:'$gender',
            name:{$push:'$$ROOT'}
        }
    }
])

$match

用于过滤数据，只输出符合条件的文档
使用MongoDB的标准查询操作
例1：查询年龄大于20的学生

db.stu.aggregate([
    {$match:{age:{$gt:20}}}
])

例2：查询年龄大于20的男生、女生人数

db.stu.aggregate([
    {$match:{age:{$gt:20}}},
    {$group:{_id:'$gender',counter:{$sum:1}}}
])

$project

修改输入文档的结构，如重命名、增加、删除字段、创建计算结果类似上面的投影
例1：查询学生的姓名、年龄

db.stu.aggregate([
    {$project:{_id:0,name:1,age:1}}
])

例2：查询男生、女生人数，输出人数

db.stu.aggregate([
    {$group:{_id:'$gender',counter:{$sum:1}}},
    {$project:{_id:0,counter:1}}
])

$sort

将输入文档排序后输出
例1：查询学生信息，按年龄升序

b.stu.aggregate([{$sort:{age:1}}])

例2：查询男生、女生人数，按人数降序

db.stu.aggregate([
    {$group:{_id:'$gender',counter:{$sum:1}}},
    {$sort:{counter:-1}}
])

$limit

限制聚合管道返回的文档数
例1：查询2条学生信息

db.stu.aggregate([{$limit:2}])

$skip

跳过指定数量的文档，并返回余下的文档
例2：查询从第3条开始的学生信息

db.stu.aggregate([{$skip:2}])

例3：统计男生、女生人数，按人数升序，取第二条数据

db.stu.aggregate([
    {$group:{_id:'$gender',counter:{$sum:1}}},
    {$sort:{counter:1}},
    {$skip:1},
    {$limit:1}
])

注意顺序：先写skip，再写limit

$unwind

将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值

语法1

对某字段值进行拆分

db.集合名称.aggregate([{$unwind:'$字段名称'}])

构造数据

db.t2.insert({_id:1,item:'t-shirt',size:['S','M','L']})

查询

db.t2.aggregate([{$unwind:'$size'}])

语法2

对某字段值进行拆分
处理空数组、非数组、无字段、null情况

db.inventory.aggregate([{
    $unwind:{
        path:'$字段名称',
        preserveNullAndEmptyArrays:<boolean>#防止数据丢失
    }
}])

构造数据

db.t3.insert([
{ "_id" : 1, "item" : "a", "size": [ "S", "M", "L"] },
{ "_id" : 2, "item" : "b", "size" : [ ] },
{ "_id" : 3, "item" : "c", "size": "M" },
{ "_id" : 4, "item" : "d" },
{ "_id" : 5, "item" : "e", "size" : null }
])

使用语法1查询

db.t3.aggregate([{$unwind:'$size'}])

查看查询结果，发现对于空数组、无字段、null的文档，都被丢弃了
问：如何能不丢弃呢？
答：使用语法2查询

db.t3.aggregate([{$unwind:{path:'$sizes',preserveNullAndEmptyArrays:true}}])

看个简单的例子

我们先通过$group管道把数据分组，由于_id是null，因此不分组，只求和，然后通过$$ROOT把所有的对象都组合到root字段下面变成数组，最后求得一个age的平均值

db.stu.aggregate([{$group:{_id:null,counter:{$sum:1},root:{$push:'$$ROOT'},avgAge:{$avg:'$age'}}}])


/* 1 */
{
    "_id" : null,
    "counter" : 6.0,
    "root" : [ 
        {
            "_id" : ObjectId("5b6e4bf7dc670021c8d5d25c"),
            "name" : "keai",
            "age" : 0.8,
            "gender" : 0.0
        }, 
        {
            "_id" : ObjectId("5b6e4c03dc670021c8d5d25d"),
            "name" : "xingfu",
            "age" : 28.0,
            "gender" : 0.0
        }, 
        {
            "_id" : ObjectId("5b6e4c0cdc670021c8d5d25e"),
            "name" : "jiankang",
            "age" : 28.0,
            "gender" : 1.0
        }, 
        {
            "_id" : ObjectId("5b6e4cd5dc670021c8d5d25f"),
            "age" : 25.0,
            "address" : "shenzhen",
            "name" : "faker"
        }, 
        {
            "_id" : ObjectId("5b702863d37384a89aec4047"),
            "age" : 35.0,
            "address" : "shenzhen",
            "name" : "dashen"
        }, 
        {
            "_id" : ObjectId("5b70304ed37384a89aec4048"),
            "name" : "xiyue",
            "age" : 18.0,
            "gender" : 0.0,
            "favirate" : [ 
                "study", 
                "computer", 
                "dance", 
                "finacial"
            ]
        }
    ],
    "avgAge" : 22.4666666666667
}

索引

查询性能检测

db.集合名.finf({name:'xxx'}).explain('executionStats')

创建索引

1：升序，-1降序

db.集合名.ensureIndex({属性:1})

再去执行上面的查询检测

唯一索引和联合索引

db.集合名.ensureIndex({'name':1},{'unique':true})  唯一

db.集合名.ensureIndex({name:1，age:1})  联合
 
db.集合名.getIndexes()  查看

db.集合名.dropIndexes('索引名')  删除

安全访问权限设置

一、关于权限的默认配置

在默认情况下，mongod是监听在0.0.0.0之上的，任何客户端都可以直接连接27017，且没有认证。这样做的好处是，用户可以即时上手，不用担心被一堆配置弄的心烦意乱。然而坏处也是显而易见，如果直接在公网服务器上如此搭建MongoDB，那么所有人都可以直接访问并修改数据库数据了。

默认情况下，mongod也是没有管理员账户的。因此除非你在admin数据库中使用db.addUser()命令添加了管理员帐号，且使用–auth参数启动mongod，否则在数据库中任何人都可以无需认证执行所有命令。包括delete和shutdown。

此外，mongod还会默认监听28017端口，同样是绑定所有ip。这是一个mongod自带的web监控界面。从中可以获取到数据库当前连接、log、状态、运行系统等信息。如果你开启了–rest参数，甚至可以直接通过web界面查询数据，执行mongod命令。

其实MongoDB本身有非常详细的安全配置准则，显然开发者也是想到了，然而他是将安全的任务推给用户去解决，这本身的策略就是偏向易用性的，对于安全性，则得靠边站了。

二、MongoDB用户类型

MongoDB的用户分为两种，一种是admin用户，另一种是特定数据库用户。admin用户拥有最高的权限，而特定数据库用户则只能访问特定的数据库。当MongoDB的admin库里没有任何用户的时候，也就是说整个MongoDB没有一个MongoDB用户的时候，即便–auth权限需求打开了，用户还是可以通过localhost界面进入MongoDB进行用户设置，否则的话整个MongoDB就完全没法访问了。而当这个用户创建完成之后，之后的用户登录和操作就需要授权了，不是直接登录就能使用的了。

root：只在admin数据库中可用，超级账号，超级权限
Read：允许用户读取指定数据库
readWrite：允许用户读写指定数据库

创建超级管理用户，首先

1.    sudo service mongod start

2.    mongo

3.    use admin
4.    db.createUser({
        user:'admin',
        pwd:'123',
        roles:[{role:'root',db:'admin'}]
      })

启用安全认证

修改配置文件

sudo vi /etc/mongod.conf

启用身份验证
注意：keys and values之间一定要加空格, 否则解析会报错

security:
  authorization: enabled

重启服务

sudo service mongod stop
sudo service mongod start

终端连接，如果整个时候你还是用mongo去连接会看到如下

deftmikejing@deftmikejing-VirtualBox:~$ mongo
MongoDB shell version v4.0.1
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 4.0.1
> db
test
> use admin
switched to db admin
> show collections
Warning: unable to run listCollections, attempting to approximate collection names by parsing connectionStatus
> db.auth('admin','123')
1
> show collections
> show dbs
admin    0.000GB
config   0.000GB
final    0.000GB
local    0.000GB
names    0.000GB
python3  0.000GB
>

由于你还是没有指定用户名和密码去鉴权，但是我们之前已经开启了最高权限的认证，因此进去之后你任何的操作都会失败，内部切换admin，然后执行以下，如果是1，代表登录成功

db.auth(用户名，密码)

还有一种就是外部直接输入账号和密码，即可登录操作

 mongo -u 'admin' -p '123' --authenticationDatabase 'admin'

以上都是admin最高权限，以下是普通指定数据库的登录权限

首先还是用上面的使用超级管理员登录，然后进入用户管理操作
查看当前数据库的用户

> show dbs
admin    0.000GB
config   0.000GB
final    0.000GB
local    0.000GB
names    0.000GB
python3  0.000GB
> 

use names
show users

创建普通用户

db.createUser({
    user:'names',
    pwd:'密码',
    roles:[{role:'readWrite',db:'names'}]
})

查看如下

> use names
switched to db names
> show users
{
	"_id" : "names.names",
	"user" : "names",
	"db" : "names",
	"roles" : [
		{
			"role" : "readWrite",
			"db" : "names"
		}
	],
	"mechanisms" : [
		"SCRAM-SHA-1",
		"SCRAM-SHA-256"
	]
}
>

终端连接

mongo -u names -p '密码' --authenticationDatabase names

如果还有链接进去，只是进入而已，需要再次执行

db.auth('names','密码')

切换数据库，执行命令查看效果
修改用户：可以修改pwd、roles属性

db.updateUser('names',{pwd:'456'})

注意上面是shell操作，GUI操作不仅仅是填写好IP和port，还需要填写鉴权信息再去连接

复制（副本集）

什么是复制

复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提高了数据的可用性，并可以保证数据的安全性
复制还允许从硬件故障和服务中断中恢复数据

为什么要复制

数据备份
数据灾难恢复
读写分离
高（24* 7）数据可用性
无宕机维护
副本集对应用程序是透明

复制的工作原理

复制至少需要两个节点A、B...
A是主节点，负责处理客户端请求
其余的都是从节点，负责复制主节点上的数据
节点常见的搭配方式为：一主一从、一主多从
主节点记录在其上的所有操作，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致
主节点与从节点进行数据交互保障数据的一致性

复制的特点

N 个节点的集群
任何节点可作为主节点
所有写入操作都在主节点上
自动故障转移
自动恢复

设置复制节点

接下来的操作需要打开多个终端窗口，而且可能会连接多台ubuntu主机，会显得有些乱，建议在xshell中实现
step1:创建数据库目录t1、t2
在Desktop目录下演示，其它目录也可以，注意权限即可

多态服务器镜像，一主多从，避免宕机

Linux上可以用Xshell，那么咱们Mac上面可以直接使用终端，直接进行远程ssh连接，由于我是虚拟机Ubuntu，那么需要手动开启SSH权限

Ubuntu开始SSH教程

安装配置开启之后执行如下测试

ssh username@192.168.1.103 
其中，username为192.168.1.103机器上的用户，需要输入密码。 
断开连接：exit

然后我们开启两个终端，SSH连接Ubuntu

Last login: Mon Aug 13 15:03:37 on ttys002
mintoudeMacBook-Pro-2:~ mintou$ ssh deftmikejing@192.168.0.102
deftmikejing@192.168.0.102's password: 
Welcome to Ubuntu 15.04 (GNU/Linux 3.19.0-15-generic x86_64)

 * Documentation:  https://help.ubuntu.com/

332 packages can be updated.
201 updates are security updates.

Your Ubuntu release is not supported anymore.
For upgrade information, please visit:
http://www.ubuntu.com/releaseendoflife

New release '15.10' available.
Run 'do-release-upgrade' to upgrade to it.

Last login: Mon Aug 13 15:05:30 2018 from 192.168.0.45

step1:创建数据库目录t1、t2
在桌面目录下演示，其它目录也可以，注意权限即可

mkdir t1
mkdir t2

step2:使用如下格式启动mongod，注意replSet的名称是一致的

这里原服务的端口是27017，我们为了区分开来重新备份开启另外两个端口接口，然后文件目录在桌面

mongod --bind_ip IP地址 --port 27020 --dbpath ~/桌面/t1 --replSet rs0
mongod --bind_ip IP地址 --port 27021 --dbpath ~/桌面/t2 --replSet rs0

如果开启成功，可以在终端看到，而且切换到对应文件夹下面是会有很多文件出现的，如下即可

deftmikejing@deftmikejing-VirtualBox:~/桌面$ cd t1/
deftmikejing@deftmikejing-VirtualBox:~/桌面/t1$ ls -a
.                                     index-1-8253210363328822103.wt
..                                    index-18-8253210363328822103.wt
collection-0-8253210363328822103.wt   index-20-8253210363328822103.wt
collection-11-8253210363328822103.wt  index-22-8253210363328822103.wt
collection-13-8253210363328822103.wt  index-23-8253210363328822103.wt
collection-15-8253210363328822103.wt  index-25-8253210363328822103.wt
collection-17-8253210363328822103.wt  index-3-8253210363328822103.wt
collection-19-8253210363328822103.wt  index-5-8253210363328822103.wt
collection-21-8253210363328822103.wt  index-7-8253210363328822103.wt
collection-24-8253210363328822103.wt  journal
collection-2-8253210363328822103.wt   _mdb_catalog.wt
collection-4-8253210363328822103.wt   mongod.lock
collection-6-8253210363328822103.wt   sizeStorer.wt
collection-8-8253210363328822103.wt   storage.bson
collection-9-8253210363328822103.wt   WiredTiger
diagnostic.data                       WiredTigerLAS.wt
index-10-8253210363328822103.wt       WiredTiger.lock
index-12-8253210363328822103.wt       WiredTiger.turtle
index-14-8253210363328822103.wt       WiredTiger.wt
index-16-8253210363328822103.wt
deftmikejing@deftmikejing-VirtualBox:~/桌面/t1$

step3:连接主服务器，此处设置192.168.196.128:27017为主服务器

mongo --host IP地址 --port 27020

step4:初始化

rs.initiate()

step5:连接第二个

mongo --host IP地址 --port 27021

step6:添加复本集

rs.add('IP地址:27021')

step7:查看当前状态

rs.status()


rs0:PRIMARY> rs.status()
{
	"set" : "rs0",
	"date" : ISODate("2018-08-13T07:33:35.181Z"),
	"myState" : 1,
	"term" : NumberLong(1),
	"syncingTo" : "",
	"syncSourceHost" : "",
	"syncSourceId" : -1,
	"heartbeatIntervalMillis" : NumberLong(2000),
	"optimes" : {
		"lastCommittedOpTime" : {
			"ts" : Timestamp(1534145612, 1),
			"t" : NumberLong(1)
		},
		"readConcernMajorityOpTime" : {
			"ts" : Timestamp(1534145612, 1),
			"t" : NumberLong(1)
		},
		"appliedOpTime" : {
			"ts" : Timestamp(1534145612, 1),
			"t" : NumberLong(1)
		},
		"durableOpTime" : {
			"ts" : Timestamp(1534145612, 1),
			"t" : NumberLong(1)
		}
	},
	"lastStableCheckpointTimestamp" : Timestamp(1534145612, 1),
	"members" : [
		{
			"_id" : 0,
			"name" : "192.168.0.102:27020",
			"health" : 1,
			"state" : 1,
			"stateStr" : "PRIMARY",
			"uptime" : 1171,
			"optime" : {
				"ts" : Timestamp(1534145612, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2018-08-13T07:33:32Z"),
			"syncingTo" : "",
			"syncSourceHost" : "",
			"syncSourceId" : -1,
			"infoMessage" : "",
			"electionTime" : Timestamp(1534144591, 2),
			"electionDate" : ISODate("2018-08-13T07:16:31Z"),
			"configVersion" : 2,
			"self" : true,
			"lastHeartbeatMessage" : ""
		},
		{
			"_id" : 1,
			"name" : "192.168.0.102:27021",
			"health" : 1,
			"state" : 2,
			"stateStr" : "SECONDARY",
			"uptime" : 958,
			"optime" : {
				"ts" : Timestamp(1534145612, 1),
				"t" : NumberLong(1)
			},
			"optimeDurable" : {
				"ts" : Timestamp(1534145612, 1),
				"t" : NumberLong(1)
			},
			"optimeDate" : ISODate("2018-08-13T07:33:32Z"),
			"optimeDurableDate" : ISODate("2018-08-13T07:33:32Z"),
			"lastHeartbeat" : ISODate("2018-08-13T07:33:34.960Z"),
			"lastHeartbeatRecv" : ISODate("2018-08-13T07:33:34.168Z"),
			"pingMs" : NumberLong(0),
			"lastHeartbeatMessage" : "",
			"syncingTo" : "192.168.0.102:27020",
			"syncSourceHost" : "192.168.0.102:27020",
			"syncSourceId" : 0,
			"infoMessage" : "",
			"configVersion" : 2
		}
	],
	"ok" : 1,
	"operationTime" : Timestamp(1534145612, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1534145612, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
rs0:PRIMARY>

stateStr字段可以看出一主一从

step8:向主服务器中插入数据

rs0:PRIMARY> db
test
rs0:PRIMARY> use name
switched to db name
rs0:PRIMARY> for(i=0;i<10;i++){db.t1.insert({_id:i})
... 
... 
rs0:PRIMARY> db.name.find()
rs0:PRIMARY> db.name.insert({name:'hehe'})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> db.name.find()
{ "_id" : ObjectId("5b7130e8fb15eaff5c01ba5d"), "name" : "hehe" }
rs0:PRIMARY> db.name.insert({name:'haha'})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> db.name.insert({name:'heihei'})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> db.name.insert({name:'enen'})
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> db.name.find()
{ "_id" : ObjectId("5b7130e8fb15eaff5c01ba5d"), "name" : "hehe" }
{ "_id" : ObjectId("5b7130f4fb15eaff5c01ba5e"), "name" : "haha" }
{ "_id" : ObjectId("5b7130f9fb15eaff5c01ba5f"), "name" : "heihei" }
{ "_id" : ObjectId("5b7130fcfb15eaff5c01ba60"), "name" : "enen" }

step9:在从服务器中插查询
说明：如果在从服务器上进行读操作，需要设置rs.slaveOk() 同步两个数据库数据

rs0:SECONDARY> rs.slaveOk()
rs0:SECONDARY> db.name.find()
{ "_id" : ObjectId("5b7130e8fb15eaff5c01ba5d"), "name" : "hehe" }
{ "_id" : ObjectId("5b7130f4fb15eaff5c01ba5e"), "name" : "haha" }
{ "_id" : ObjectId("5b7130f9fb15eaff5c01ba5f"), "name" : "heihei" }
{ "_id" : ObjectId("5b7130fcfb15eaff5c01ba60"), "name" : "enen" }

其它说明

删除从节点

rs.remove('IP地址：端口')

关闭主服务器后，再重新启动，会发现原来的从服务器变为了从服务器，新启动的服务器（原来的从服务器）变为了从服务器

这四个都是远程ssh连接的，上面两个分别是端口27020和27021两个mongod服务，数据库地址都变更为桌面了

下面两个分别是客户端连接的服务，这两个服务器就是相同的，数据的更改都会不间断同步，因此本地只要slaveOk更新即可获取，无论哪个挂了都会变更成另一个为主服务器，一主一从就这样的操作了

备份和恢复

语法

mongodump -h dbhost -d dbname -o dbdirectory

-h：服务器地址，也可以指定端口号
-d：需要备份的数据库名称
-o：备份的数据存放位置，此目录中存放着备份出来的数据
例1

sudo mkdir test1bak
sudo mongodump -h 192.168.196.128:27017 -d test1 -o ~/Desktop/test1bak

恢复

语法

mongorestore -h dbhost -d dbname --dir dbdirectory

-h：服务器地址
-d：需要恢复的数据库实例
--dir：备份数据所在位置
例2

mongorestore -h 192.168.196.128:27017 -d test2 --dir ~/Desktop/test1bak/test1

Python3.6交互

点击查看官方文档

安装pymongo

pip3 install pymongo

基本操作

import pymongo

# 连接
client = pymongo.MongoClient('mongodb://admin:123@192.168.0.102:27017/admin')
# 获取指定连接数据库
db = client.python3
# 指定collections集合
stu = db.stu
# 插入
# stu.insert({'name':'张三李四'})
# 查找
s1 = stu.find_one({'name':'keai'})
# 更新
# stu.update({'name':'张三李四'},{'$set':{'name':'曦月'}})
# 删除
# stu.delete_one({'name':'真的皮'})

for cur in stu.find():
    print(cur)

/Users/mintou/venv/bin/python /Users/mintou/Desktop/PYCharm/mongoTest.py
{'_id': ObjectId('5b6e4bf7dc670021c8d5d25c'), 'name': 'keai', 'age': 0.8, 'gender': 0.0}
{'_id': ObjectId('5b6e4c03dc670021c8d5d25d'), 'name': 'xingfu', 'age': 28.0, 'gender': 0.0}
{'_id': ObjectId('5b6e4c0cdc670021c8d5d25e'), 'name': 'jiankang', 'age': 28.0, 'gender': 1.0}
{'_id': ObjectId('5b6e4cd5dc670021c8d5d25f'), 'age': 25.0, 'address': 'shenzhen', 'name': 'faker'}
{'_id': ObjectId('5b702863d37384a89aec4047'), 'age': 35.0, 'address': 'shenzhen', 'name': 'dashen'}
{'_id': ObjectId('5b70304ed37384a89aec4048'), 'name': 'xiyue', 'age': 18.0, 'gender': 0.0, 'favirate': ['study', 'computer', 'dance', 'finacial']}
{'_id': ObjectId('5b7126b2158426278b9ea922'), 'name': '很溜'}
{'_id': ObjectId('5b7126be1584262793bb79e7'), 'name': '完美'}
{'_id': ObjectId('5b7126cb158426279fd462b7'), 'name': '奥迪'}
{'_id': ObjectId('5b71271615842627cf5addc9'), 'name': '曦月'}

Process finished with exit code 0

Deft_MKJing宓珂璟

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
MongoDB学习Python3.6实现备忘录

目录NoSQL简介安装MongoDB连接不上问题1.sudo service mongod start失败2.设置了0.0.0.0，远程连接还是无法访问MongoDB 和 Mysql的区别MongoDB基础操作介绍数据库操作Collection操作数据类型CRUD详细查询操作Limitskip投影排序统计个数消除重复...
复制链接

扫一扫