NoSQL数据库:MongoDB初探

最新推荐文章于 2020-04-02 17:36:01 发布
最新推荐文章于 2020-04-02 17:36:01 发布
阅读量1.1w 收藏 6
点赞数
文章标签： mongodb nosql数据库 search 数据库 多线程 sharding

原文地址：http://www.searchtb.com/2010/12/a-probe-into-the-mongodb.html

 

跟着时下炒得火热的NOSQL潮流，学习了一下mongodb，记录在此，希望与感兴趣的同学一起研究！

MongoDB概述

mongodb由C＋＋写就，其名字来自humongous这个单词的中间部分，是由10gen开发并维护的,关于它的一个最简洁描述为：scalable, high-performance, open source, schema-free, document-oriented database。MongoDB的主要目标是在键/值存储方式（提供了高性能和高度伸缩性）以及传统的RDBMS系统（丰富的功能）架起一座桥梁，集两者的优势于一身。

MongoDB特性：

l  面向文档存储

l  全索引支持,扩展到内部对象和内嵌数组

l  复制和高可用

l  自动分片支持云级扩展性

l  查询记录分析

l  动态查询

l  快速,就地更新

l  支持Map/Reduce操作

l  GridFS文件系统

l  商业支持,培训和咨询

官网: http://www.mongodb.org/

配置

Master-slaves 模式

机器IP角色
test001192.168.1.1master
test002192.168.1.2slave
test003192.168.1.3slave
test004192.168.1.4slave
test005192.168.1.5slave
test006192.168.1.6slave

启动master:

 

1
./mongod -dbpath=/mongodb/data/ -logpath=/mongodb/logs/mongodb.log -oplogSize=10000 -logappend -master -port=27017 -fork

 

添加repl用户:

1
2
3
./mongo
>use local
> db.addUser('repl','replication');

启动slaves:

1
2
./mongod -dbpath=/mongodb/data/ -logpath=/mongodb/logs/mongodb.log -slave  -port=27017 -source=test001:27017 --autoresync
-fork

添加repl用户:

1
2
3
./mongo
>use local
> db.addUser('repl','replication');

autoresync 参数会在系统发生意外情况造成主从数据不同步时，自动启动复制操作 (同步复制 10 分钟内仅执行一次)。除此之外，还可以用 –slavedelay 设定更新频率(秒)。

通常我们会使用主从方案实现读写分离，但需要设置 Slave_OK。

slaveOk

When querying a replica pair or replica set, drivers route their requests to the master mongod by default; to perform a query against an (arbitrarily-selected) slave, the query can be run with the slaveOk option. Here’s how to do so in the shell:

db.getMongo().setSlaveOk(); // enable querying a slave
db.users.find(...)

Note: some language drivers permit specifying the slaveOk option on each find(), others make this a connection-wide setting. See your language’s driver for details.

Replica Set模式

Replica Sets 使用 n 个 Mongod 节点，构建具备自动容错转移(auto-failover)、自动恢复(auto-recovery) 的高可用方案。

机器IP角色
test001192.168.1.1secondary
test002192.168.1.2secondary
test003192.168.1.3primary
test004192.168.1.4secondary
test005192.168.1.5secondary
test006192.168.1.6secondary
test007192.168.1.7secondary

启动:

1
./mongod -dbpath=/mongodb/data/ -logpath=/mongodb/logs/mongodb.log -oplogSize=10000 -logappend -replSet set1 -port=27017 -fork –rest

添加repl用户:

1
2
3
./mongo
>use local
> db.addUser('repl','replication');

配置:

1
2
3
4
5
6
7
8
9
10
config={_id:'set1',members:[
{_id:0,host:'test001:27017'},
{_id:1,host:'test002:27017'},
{_id:2,host:'test003:27017'},
{_id:3,host:'test004:27017'},
{_id:4,host:'test005:27017'},
{_id:5,host:'test006:27017'},
{_id:6,host:'test007:27017'}]
}
rs.initiate(config);

查看:

访问 http://test001 :28017/_replSet

或者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
./mongo
> rs.status()
{
"set" : "set1",
"date" : "Fri Dec 03 2010 00:57:44 GMT+0800 (CST)",
"myState" : 2,
"members" : [
{
"_id" : 0,
"name" : "test001:27017",
"health" : 1,
"state" : 2,
"self" : true
},
{
"_id" : 1,
"name" : "test002:27017",
"health" : 1,
"state" : 2,
"uptime" : 194451,
"lastHeartbeat" : "Fri Dec 03 2010 00:57:42 GMT+0800 (CST)"
},
{
"_id" : 2,
"name" : "test003:27017",
"health" : 1,
"state" : 1,
"uptime" : 194689,
"lastHeartbeat" : "Fri Dec 03 2010 00:57:43 GMT+0800 (CST)"
},
{
"_id" : 3,
"name" : "test004:27017",
"health" : 1,
"state" : 2,
"uptime" : 194689,
"lastHeartbeat" : "Fri Dec 03 2010 00:57:42 GMT+0800 (CST)"
},
{
"_id" : 4,
"name" : "test005:27017",
"health" : 1,
"state" : 2,
"uptime" : 194689,
"lastHeartbeat" : "Fri Dec 03 2010 00:57:42 GMT+0800 (CST)"
},
{
"_id" : 5,
"name" : "test006:27017",
"health" : 1,
"state" : 2,
"uptime" : 194689,
"lastHeartbeat" : "Fri Dec 03 2010 00:57:43 GMT+0800 (CST)"
},
{
"_id" : 6,
"name" : "test007:27017",
"health" : 1,
"state" : 2,
"uptime" : 194689,
"lastHeartbeat" : "Fri Dec 03 2010 00:57:42 GMT+0800 (CST)"
}
],
"ok" : 1
}

在Replica Sets上做操作后调用getlasterror使写操作同步到至少3台机器后才返回

db.runCommand( { getlasterror : 1 , w : 3 } )

注：该模式不支持auth功能，需要auth功能请选择m-s模式

Sharding模式

要构建一个 MongoDB Sharding Cluster，需要三种角色：

  • Shard Server: mongod 实例，用于存储实际的数据块。
  • Config Server: mongod 实例，存储了整个 Cluster Metadata，其中包括 chunk 信息。
  • Route Server: mongos 实例，前端路由，客户端由此接入，且让整个集群看上去像单一进程数据库。
机器IP角色
test002192.168.1.2mongod shard11:27017
test003192.168.1.3mongod shard21:27017
test004192.168.1.4mongod shard31:27017
test005192.168.1.5mongod config1:20000
mongs1:30000
test006192.168.1.6mongod config2:20000
mongs2:30000
test007192.168.1.7mongod config3:20000
mongs3:30000
test008192.168.1.8mongod shard12:27017
test009192.168.1.9mongod shard22:27017
test010192.168.1.10mongod shard32:27017

Shard配置

Shard1

[test002; test008]

test002:

1
./mongod -shardsvr -replSet shard1 -port 27017 -dbpath /mongodb/data/shard11 -oplogSize 10000 -logpath /mongodb/logs/shard11.log -logappend -fork

test008:

1
./mongod -shardsvr -replSet shard1 -port 27017 -dbpath /mongodb/data/shard12 -oplogSize 10000 -logpath /mongodb/logs/shard12.log -logappend -fork

初始化shard1

1
2
3
4
5
config={_id:'shard1',members:[
{_id:0,host:'test002:27017'},
{_id:1,host:'test008:27017'}]
}
rs.initiate(config);

Shard2

[test003; test009]

test003:

1
./mongod -shardsvr -replSet shard2 -port 27017 -dbpath /mongodb/data/shard21 -oplogSize 10000 -logpath /mongodb/logs/shard21.log -logappend -fork

test009:

1
./mongod -shardsvr -replSet shard2 -port 27017 -dbpath /mongodb/data/shard22 -oplogSize 10000 -logpath /mongodb/logs/shard22.log -logappend -fork

初始化shard2

1
2
3
4
5
config={_id:'shard2',members:[
{_id:0,host:'test003:27017'},
{_id:1,host:'test009:27017'}]
}
rs.initiate(config);

Shard3

[test004; test010]

test004:

1
./mongod -shardsvr -replSet shard3 -port 27017 -dbpath /mongodb/data/shard31 -oplogSize 10000 -logpath /mongodb/logs/shard31.log -logappend -fork

test010:

1
./mongod -shardsvr -replSet shard3 -port 27017 -dbpath /mongodb/data/shard32 -oplogSize 10000 -logpath /mongodb/logs/shard32.log -logappend -fork

初始化shard3

1
2
3
4
5
config={_id:'shard3',members:[
{_id:0,host:'test004:27017'},
{_id:1,host:'test010:27017'}]
}
rs.initiate(config);

config server配置

[test005; test006; test007]

1
./mongod -configsvr -dbpath /mongodb/data/config -port 20000 -logpath /mongodb/logs/config.log -logappend -fork

Mongos配置

[test005; test006; test007]

1
./mongos -configdb test005:20000,test006:20000,test007:20000 -port 30000 -chunkSize 5 -logpath /mongodb/logs/mongos.log -logappend -fork

Route 转发请求到实际的目标服务进程，并将多个结果合并回传给客户端。Route 本身并不存储任何数据和状态，仅在启动时从 Config Server 获取信息。Config Server 上的任何变动都会传递给所有的 Route Process。

Configuring the Shard Cluster

1.     连接admin数据库

1
./mongo test005:30000/admin

2.      加入shards

1
2
3
db.runCommand({addshard:"shard1/test002:27017,test008:27017",name:"s1",maxsize:20480});
db.runCommand({addshard:"shard2/test003:27017,test009:27017",name:"s2",maxsize:20480});
db.runCommand({addshard:"shard3/test004:27017,test010:27017",name:"s3",maxsize:20480});

3.      Listing shards

1
db.runCommand({listshards:1})

如果列出了以上3个shards，表示shards已经配置成功

4.      激活数据库和表分片

1
2
db.runCommand({enablesharding:"taobao"});
db.runCommand({shardcollection:"taobao.test0",key:{_id:1}}); db.runCommand({shardcollection:"taobao.test1",key:{_id:1}});

使用

shell操作数据库

超级用户相关：

1)     进入数据库admin

1
use admin

2)     增加或修改用户密码

1
db.addUser('name','pwd')

3)     查看用户列表

1
db.system.users.find()

4)     用户认证

1
db.auth('name','pwd')

5)     删除用户

1
db.removeUser('name')

6)     查看所有用户

1
show users

7)     查看所有数据库

1
show dbs

8)     查看所有的collection

1
show collections

9)     查看各collection的状态

1
db.printCollectionStats()

10)   查看主从复制状态

1
db.printReplicationInfo()

11)   修复数据库

1
db.repairDatabase()

12)   设置记录profiling，0=off 1=slow 2=all

1
db.setProfilingLevel(1)

13)   查看profiling

1
show profile

14)   拷贝数据库

1
db.copyDatabase('mail_addr','mail_addr_tmp')

15)   删除collection

1
db.mail_addr.drop()

16)   删除当前的数据库

1
db.dropDatabase()

增加删除修改:

1) Insert

1
2
3
db.user.insert({'name':'dump','age':1})
or
db.user.save({'name':'dump','age':1})

嵌套对象:

1
db.foo.save({'name':'dump','address':{'city':'hangzhou','post':310015},'phone':[138888888,13999999999]})

数组对象:

1
db.user_addr.save({'Uid':'dump','Al':['test-1@taobao.com','test-2@taobao.com']})

2) delete

删除name=’dump’的用户信息:

1
db.user.remove({'name':'dump'})

删除foo表所有信息:

1
db.foo.remove()

3) update

//update foo set xx=4 where yy=6

//如果不存在则插入，允许修改多条记录

1
db.foo.update({'yy':6},{'$set':{'xx':4}},upsert=true,multi=true)

查询:

1
2
3
4
5
6
7
8
coll.find() // select * from coll
coll.find().limit(10) // select * from coll limit 10
coll.find().sort({x:1}) // select * from coll order by x asc
coll.find().sort({x:1}).skip(5).limit(10) // select * from coll order by x asc limit 5, 10
coll.find({x:10}) // select * from coll where x = 10
coll.find({x: {$lt:10}}) // select * from coll where x <= 10
coll.find({}, {y:true}) // select y from coll
coll.count() //select count(*) from coll

其他:

1
2
3
4
5
coll.find({"address.city":"gz"}) // 搜索嵌套文档address中city值为gz的记录
coll.find({likes:"math"}) // 搜索数组
coll.find({name: {$exists: true}}); //查询所有存在name字段的记录
coll.find({phone: {$exists: false}}); //查询所有不存在phone字段的记录
coll.find({name: {$type: 2}}); //查询所有name字段是字符类型的coll.find({age: {$type: 16}}); //查询所有age字段是整型的

索引:

1(ascending),-1(descending)

1
2
3
4
5
6
7
coll.ensureIndex({productid:1}) // 在productid上建立普通索引
coll.ensureIndex({district:1, plate:1}) // 多字段索引
coll.ensureIndex({"address.city":1}) // 在嵌套文档的字段上建索引
coll.ensureIndex({productid:1}, {unique:true}) // 唯一索引
coll.ensureIndex({productid:1}, {unique:true, dropDups:true|) // 建索引时，如果遇到索引字段值已经出现过的情况，则删除重复记录
coll.getIndexes() // 查看索引
coll.dropIndex({productid:1}) // 删除单个索引
MongoDB Drivers

C

C#

C++

Haskell

Java

Javascript

Perl

PHP

Python

Ruby

Scala (via Casbah)

Mongodb支持的client 编程api非常多，由于dump中心是建立在hadoop的基础上的，所以着重介绍java api,后面的测试程序采用的也是java api.

MongoDB in Java

下载MongoDB的Java驱动，把jar包(mongo-2.3.jar)扔到项目里去就行了，

Java中，Mongo对象是线程安全的，一个应用中应该只使用一个Mongo对象。Mongo对象会自动维护一个连接池，默认连接数为10。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import com.mongodb.*
try{
Mongo mg = new Mongo(server_lists);// List<ServerAddress> server _lists
DB db = mg.getDB("taobao");
if (db.isAuthenticated() == false) {
db.authenticate("name", "pwd".toCharArray());
}
DBCollection coll=db.getCollection("category_property_values");
coll.slaveOk();//repl set模式必须调用，否则所有query将只发到主节点查询
//insert
 
BasicDBObject doc = <strong>new</strong> BasicDBObject();
 
//赋值
doc.put("name", "MongoDB");
doc.put("type", "database");
coll.insert(doc);
……
//select
//查询一条数据
BasicDBObject doc = <strong>new</strong> BasicDBObject();
doc.put("name", "MongoDB");
DBObject query = coll.findOne(doc);
……
//使用游标查询
DBCursor cur = coll.find(doc);
while(cur.hasNext()) {
cur.next();
……
}
……
//update
DBObject dblist = new BasicDBObject();
DBObject qlist = new BasicDBObject();
qlist.put("_id", j);
dblist.put("t1", str);
coll.update(qlist, dblist);
……
 
//delete
DBObject dlist = new BasicDBObject();
dlist.put("_id", j);
coll.remove(dlist);
}catch(MongoException ex){
}
MongoDB 测试

测试版本: 1.6.3

采用单线程分别插入100万，300万,500万,1000万数据和多个线程，每线程插入100万数据.

插入数据格式:

1
{ "_id" : NumberLong(16), "nid" : NumberLong(16), "t1" : "search_engine_insert", "t2" : "search_engine_insert", "t3" : "search_engine_insert", "t4" : "search_engine_insert" }

1) Master slaves模式

Insert

Per-thread rowsrun timePer-thread insertTotal-insertTotal rowsthreads
100000020500005000010000001
300000060500005000030000001
500000099505055050550000001
8000000159503145031480000001
100000002084807648076100000001
100000064156253125020000002

Mongodb只有主节点才能进行插入和更新操作.

Update

数据格式:

1
{ "_id" : NumberLong(16), "nid" : NumberLong(16), "t1" : "search_engine_update", "t2" : "search_engine_update", "t3" : "search_engine_update", "t4" : "search_engine_update" }

Per-thread rowsrun timePer-thread updateTotal-updateTotal rowsthreads
100000096104161041610000001
3000000287104521045230000001
100000018853191595730000003
100000035128491424550000005

Select

以”_id”字段为key，返回整条记录

a)      客户端:单机多线程

Per-thread rowsrun timePer-thread selectTotal-selectTotal rowsthreads
100000072138881388810000001
10000001297751775191000000010
10000005541805902525000000050
1000000112189289206100000000100
1000000225644388652200000000200

b)      客户端:分布式多线程

程序部署在39台机器上

Per-thread rowsrun timePer-thread selectTotal-selectTotal rowsthreads
100000017357805780*39=2234701000000*391
100000014027137132*39=27814810000000*3910
50000014063557112*39=27736810000000*3920
20000014331396978*39=27214210000000*3950

2) Replica Set 模式

Insert

Per-thread rowsrun timePer-thread insertTotal-insertTotal rowsthreads
100000040250002500010000001
3000000117256412564130000001
5000000211236962369650000001
8000000289276812768180000001
100000003882577325773100000001
100000083120482409620000002
100000021047622380950000005

Update

Per-thread rowsrun timePer-thread updateTotal-updateTotal rowsthreads
100000028357143571410000001
300000083361443614430000001
100000014668492054730000003
100000026238161908350000005

Select

以”_id”字段为key，返回整条记录

a)      客户端:单机多线程

Per-thread rowsrun timePer-thread selectTotal-selectTotal rowsthreads
10000001985050505010000001
10000002643787378781000000010
100000043622931146785000000050
10000007541326132625100000000100
10000001526655131061200000000200

b)      客户端:分布式多线程

程序部署在39台机器上

Per-thread rowsrun timePer-thread selectTotal-selectTotal rowsthreads
100000021646294629*39=1805311000000*391
100000013757297293*39=28442710000000*3910
50000014693406807*39=26547310000000*3920
20000015611286406*39=24983410000000*3950

3) Sharding 模式

Insert

Per-thread rowsrun timePer-thread insertTotal-insertTotal rowsthreads
100000058172411724110000001
3000000180166661666630000001
5000000373134041340450000001
200000023485471709440000002
2000000447447422371100000005

Update

Per-thread rowsrun timePer-thread updateTotal-updateTotal rowsthreads
100000038263152631510000001
3000000115260862608630000001
100000064156254687530000003
100000093107525376350000005

Select

以”_id”字段为key，返回整条记录

a)      客户端:单机多线程

Per-thread rowsrun timePer-thread selectTotal-selectTotal rowsthreads
10000002773610361010000001
10000004562192219291000000010
10000001158863431775000000050
1000000229943443497100000000100

b)      客户端:分布式多线程

程序部署在39台机器上

Per-thread rowsrun timePer-thread selectTotal-selectTotal rowsthreads
100000065915171517*39= 591631000000*391
100000085401171170*39=4563010000000*3910

小结:

Mongodb在M-S和Repl-Set模式下查询效率还是不错的，区别在于Repl-Set模式如果有primary节点挂掉，系统自己会选举出另一个primary节点，不会影响后续的使用，原来的主节点恢复后自动成为secondary节点,而M-S模式一旦master 节点挂掉需要手工将别的slaves 节点修改成master,另外Repl-Set模式最多只能有7个节点.

由于sharding模式查询速度下降明显，耗时太长,所以只测试了2轮,估计他的威力应该在数据量非常大的环境下才能体现出来吧,以上数据仅供参考，现在只是简单的进行了测试，接下来会对源码进行一下研究，欢迎和感兴趣的同学多多交流！



cleanfield
关注
MongoDB数据库：MongoDB初探
AI天才研究院
09-05 1905
作者：禅与计算机程序设计艺术 1.简介 随着互联网、移动互联网、云计算、大数据等新兴技术的不断发展，基于非关系型数据库的NoSQL数据库越来越火热。其中，最流行、功能最强大的数据库就是MongoDB。本文将从MongoDB的历史及其优势出发，介绍其理论基础、概念架构、核心算法原理及应用场景，并结合实际案
nosql数据库的发展和应用研究
12-05
nosql数据库的发展和应用研究
NoSQL之 MongoDB 简介和应用
weixin_33825683的博客
01-16 129
2019独角兽企业重金招聘Python工程师标准>>> ...
nosql数据库的应用探讨
12-05
nosql数据库的发展和应用研究
NoSQL数据库_MongoDB_MongoDB 文档与集合
迎难而上
09-27 685
本文根据极客 整理而成 MongoDB与传统关系型数据库的对比     MongoDB的更新操作等,不做完整性检查.数据的完整性需要靠客户端进行检查,即程序内维持主表与从表的数据一致性关系。
NoSql数据库初探-mongoDB环境搭建
12-14
MongoDB是一种流行的NoSQL数据库系统，它以文档存储为核心，采用BSON（Binary JSON）格式存储数据，具有高度灵活性和扩展性。MongoDB的主要特点是面向文档存储，支持全索引，具备高效的同步机制和高访问性，支持自动...
MongoDB初探：NoSQL数据库的基础知识
## 第一章：NoSQL数据库概述 ### 1.1 传统关系型数据库与NoSQL数据库的区别 传统的关系型数据库是基于表结构的，使用 SQL（Structured Query Language）进行数据操作，具有严格的 ACID（原子性、一致性、隔离性、...
MongoDB初探：NoSQL数据库在JavaScript应用中的应用
本章中，我们将对传统关系型数据库与NoSQL数据库进行对比，并介绍NoSQL数据库的分类与特点。让我们一起来深入了解NoSQL数据库的基本概念。 # 2. MongoDB简介 2.1 MongoDB的起源与发展 2.2 MongoDB的基本概念与...
什么是MongoDB数据库？初探NoSQL数据库概念
NoSQL数据库是一种非关系型数据库，适用于大数据和实时Web应用程序，弥补了传统关系型数据库在大规模数据存储和高并发访问方面的不足。 ## 1.3 MongoDB数据库的发展历程 MongoDB是一个基于分布式文件存储的数据库，...
浅谈NoSQL之MongoDB数据库
weixin_30609331的博客
12-13 95
对于SQL数据库（关系型数据库）我们大家都有所了解，比如MySQL，sqlserver，oracle等数据库。在日常的开发过程中我们遇到服务器端的数据存储时几乎第一反应就是使用SQL据库像我们最常见的Mysql数据库。 数据库存在的意义就是存储和读取数据，SQL数据库用二维表存储数据，在使用过程中我们会觉得这种存储方式可以很形象的表示出数据之间的关系。尤其是SQL语句的出现使得SQL数据库的使用...
NOSQL《一》之MongoDB的理解
Mr_li13的博客
05-23 5815
问题？MongoDB的理解 一、MongoDB是什么？ 二、MongoDB的应用范围 三、搭建MongoDB 四、MongoDB的总结
NoSQL数据库MongoDB的日常使用小结（一）
xinke0802的专栏
11-20 1089
NoSQL数据库MongoDB的日常使用小结（一）MongoDB系列文章主要是本人自己在平时项目中使用MongoDB的一些经验小结，一方面为了留档方便以后的查看，另一方面也希望跟大家多多交流使用心得，一起进步。 本文主要记录在对MongoDB数据库进行数据更新的一些基本操作和方法，如有错误，烦请批评指正。背景： MongoDB中有160W+数据 需要在每一条数据后面新增一个字段，字段数据不一致 解决
MongoDB 主从复制
小春的博客
12-07 661
主从复制是mongodb最常用的复制方式,这种方式很灵活.可用于备份,故障恢复,读扩展等. 一、 主从复制配置 服务器环境：CentOS6.6 64位系统  mongodb-master：172.32.2.131 mongodb-slave ：172.32.2.132 1. 配置mongodb主库 vim /etc/mongod.conf修改配置文件内容如下： l
mongoDB-延迟复制集成员
ssehs的博客
04-02 516
延迟成员包含一套复制集的数据集的复制。然而,延迟成员的数据集反映了先前的,或推迟的复制集状态。例如，如果当前时间是09:52并且成员已经延迟一个小时，延迟成员没有比08:52更近的操作。 因为延迟成员是数据集的“滚动备份”或运行的“历史”快照，所以它们可以帮助您从各种人为错误中恢复。例如，延迟的成员可以从失败的应用程序升级和操作员错误(包括丢失的数据库和集合)中恢复。 注意事项 要求 延迟成员： ...
MongoDB笔记整理5 - 主从复制+集群
Sevieryang/FinTech/Statistics/Quant
03-20 901
MongoDB主从复制+集群 1、读写分离的概念 1、读写分离的概念 读写分离，基本的原理是让主数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。 读写分离的目的是为了实现高并发场景下的请求分流，避免对数据库的访问过于集中，导致性能下降甚至是宕机。 2、主从...
mongodb master slave设置主从
feiying00544的博客
09-06 2205
  1.命令行 ./mongod --master --config "主库配置" ./mongod --slave --source &lt;masterhostname&gt;&lt;:&lt;port&gt;&gt; --config "从库配置" 注：可以在启动从时加以下常用参数 –slavedelay 10 #延时复制 单位为秒 –autoresync #自动重新同步 –o...
MongoDB集群运维笔记
weixin_34080951的博客
01-02 370
  前面的文章介绍了MongoDB副本集和分片集群的做法，下面对MongoDB集群的日常维护操作进行小总结：         MongDB副本集故障转移功能得益于它的选举机制。选举机制采用了Bully算法，可以很方便从分布式节点中选出主节点。Bully算法是一种协调者(主节点)竞选算法，主要思想是集群的每个成员都可以声明它是主节点并通知其他节点。别的节点可以选择接受这个声称或是拒绝并进入主节点竞争...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值