MongoDB 副本集的原理、搭建、应用

概念：

在了解了这篇文章之后，可以进行该篇文章的说明和测试。MongoDB 副本集（Replica Set）是有自动故障恢复功能的主从集群，有一个Primary节点和一个或多个Secondary节点组成。类似于MySQL的MMM架构。更多关于副本集的介绍请见官网。也可以在google、baidu上查阅。

副本集中数据同步过程：Primary节点写入数据，Secondary通过读取Primary的oplog得到复制信息，开始复制数据并且将复制信息写入到自己的oplog。如果某个操作失败，则备份节点停止从当前数据源复制数据。如果某个备份节点由于某些原因挂掉了，当重新启动后，就会自动从oplog的最后一个操作开始同步，同步完成后，将信息写入自己的oplog，由于复制操作是先复制数据，复制完成后再写入oplog，有可能相同的操作会同步两份，不过MongoDB在设计之初就考虑到这个问题，将oplog的同一个操作执行多次，与执行一次的效果是一样的。简单的说就是：

当Primary节点完成数据操作后，Secondary会做出一系列的动作保证数据的同步：
1：检查自己local库的oplog.rs集合找出最近的时间戳。
2：检查Primary节点local库oplog.rs集合，找出大于此时间戳的记录。
3：将找到的记录插入到自己的oplog.rs集合中，并执行这些操作。

副本集的同步和主从同步一样，都是异步同步的过程，不同的是副本集有个自动故障转移的功能。其原理是：slave端从primary端获取日志，然后在自己身上完全顺序的执行日志所记录的各种操作（该日志是不记录查询操作的），这个日志就是local数据库中的oplog.rs表，默认在64位机器上这个表是比较大的，占磁盘大小的5%，oplog.rs的大小可以在启动参数中设定：--oplogSize 1000,单位是M。

注意：在副本集的环境中，要是所有的Secondary都宕机了，只剩下Primary。最后Primary会变成Secondary，不能提供服务。

一：环境搭建

1：准备服务器

192.168.200.25



192.168.200.245



192.168.200.252

2：安装

http://www.cnblogs.com/zhoujinyi/archive/2013/06/02/3113868.html

3：修改配置，只需要开启：replSet 参数即可。格式为：

192.168.200.252: --replSet = mmm/192.168.200.245:27017  # mmm是副本集的名称，192.168.200.25:27017 为实例的位子。



192.168.200.245: --replSet = mmm/192.168.200.252:27017



192.168.200.25: --replSet = mmm/192.168.200.252:27017,192.168.200.245:27017

4：启动

启动后会提示：

replSet info you may need to run replSetInitiate -- rs.initiate() in the shell -- if that is not already done

说明需要进行初始化操作，初始化操作只能执行一次。

5：初始化副本集

登入任意一台机器的MongoDB执行：因为是全新的副本集所以可以任意进入一台执行；要是有一台有数据，则需要在有数据上执行；要多台有数据则不能初始化。

zhoujy@zhoujy:~$ mongo --host=192.168.200.252

MongoDB shell version: 2.4.6

connecting to: 192.168.200.252:27017/test

> rs.initiate({"_id":"mmm","members":[

... {"_id":1,

... "host":"192.168.200.252:27017",

... "priority":1

... },

... {"_id":2,

... "host":"192.168.200.245:27017",

... "priority":1

... }

... ]})

{

    "info" : "Config now saved locally.  Should come online in about a minute.",

    "ok" : 1

}

######
"_id": 副本集的名称
"members": 副本集的服务器列表
"_id": 服务器的唯一ID
"host": 服务器主机
"priority": 是优先级，默认为1，优先级0为被动节点，不能成为活跃节点。优先级不位0则按照有大到小选出活跃节点。
"arbiterOnly": 仲裁节点，只参与投票，不接收数据，也不能成为活跃节点。
 > rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T04:03:53Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 76,

            "optime" : Timestamp(1392696191, 1),

            "optimeDate" : ISODate("2014-02-18T04:03:11Z"),

            "self" : true

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 35,

            "optime" : Timestamp(1392696191, 1),

            "optimeDate" : ISODate("2014-02-18T04:03:11Z"),

            "lastHeartbeat" : ISODate("2014-02-18T04:03:52Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T04:03:53Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        }

    ],

    "ok" : 1

}

6：日志

查看252上的日志：

Tue Feb 18 12:03:29.334 [rsMgr] replSet PRIMARY

…………

…………

Tue Feb 18 12:03:40.341 [rsHealthPoll] replSet member 192.168.200.245:27017 is now in state SECONDARY

至此，整个副本集已经搭建成功了。

上面的的副本集只有2台服务器，还有一台怎么添加？除了在初始化的时候添加，还有什么方法可以后期增删节点？

二：维护操作

1：增删节点。

把25服务加入到副本集中：

rs.add("192.168.200.25:27017")

mmm:PRIMARY> rs.add("192.168.200.25:27017")

{ "ok" : 1 }

mmm:PRIMARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T04:53:00Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 3023,

            "optime" : Timestamp(1392699177, 1),

            "optimeDate" : ISODate("2014-02-18T04:52:57Z"),

            "self" : true

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 2982,

            "optime" : Timestamp(1392699177, 1),

            "optimeDate" : ISODate("2014-02-18T04:52:57Z"),

            "lastHeartbeat" : ISODate("2014-02-18T04:52:59Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T04:53:00Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 6,

            "stateStr" : "UNKNOWN",             #等一会就变成了 SECONDARY 

            "uptime" : 3,

            "optime" : Timestamp(0, 0),

            "optimeDate" : ISODate("1970-01-01T00:00:00Z"),

            "lastHeartbeat" : ISODate("2014-02-18T04:52:59Z"),

            "lastHeartbeatRecv" : ISODate("1970-01-01T00:00:00Z"),

            "pingMs" : 0,

            "lastHeartbeatMessage" : "still initializing"

        }

    ],

    "ok" : 1

}

把25服务从副本集中删除：

rs.remove("192.168.200.25:27017")

mmm:PRIMARY> rs.remove("192.168.200.25:27017")

Tue Feb 18 13:01:09.298 DBClientCursor::init call() failed

Tue Feb 18 13:01:09.299 Error: error doing query: failed at src/mongo/shell/query.js:78

Tue Feb 18 13:01:09.300 trying reconnect to 192.168.200.252:27017

Tue Feb 18 13:01:09.301 reconnect 192.168.200.252:27017 ok

mmm:PRIMARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T05:01:19Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 3522,

            "optime" : Timestamp(1392699669, 1),

            "optimeDate" : ISODate("2014-02-18T05:01:09Z"),

            "self" : true

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 10,

            "optime" : Timestamp(1392699669, 1),

            "optimeDate" : ISODate("2014-02-18T05:01:09Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:01:19Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:01:18Z"),

            "pingMs" : 0,

            "lastHeartbeatMessage" : "syncing to: 192.168.200.252:27017",

            "syncingTo" : "192.168.200.252:27017"

        }

    ],

    "ok" : 1

}

192.168.200.25 的节点已经被移除。

2：查看复制的情况

db.printSlaveReplicationInfo()

mmm:PRIMARY> db.printSlaveReplicationInfo()

source:   192.168.200.245:27017

     syncedTo: Tue Feb 18 2014 13:02:35 GMT+0800 (CST)

         = 145 secs ago (0.04hrs)

source:   192.168.200.25:27017

     syncedTo: Tue Feb 18 2014 13:02:35 GMT+0800 (CST)

         = 145 secs ago (0.04hrs)

source：从库的ip和端口。

syncedTo：目前的同步情况，以及最后一次同步的时间。

从上面可以看出，在数据库内容不变的情况下他是不同步的，数据库变动就会马上同步。

3：查看副本集的状态

rs.status()

mmm:PRIMARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T05:12:28Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 4191,

            "optime" : Timestamp(1392699755, 1),

            "optimeDate" : ISODate("2014-02-18T05:02:35Z"),

            "self" : true

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 679,

            "optime" : Timestamp(1392699755, 1),

            "optimeDate" : ISODate("2014-02-18T05:02:35Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:12:27Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:12:27Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 593,

            "optime" : Timestamp(1392699755, 1),

            "optimeDate" : ISODate("2014-02-18T05:02:35Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:12:28Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:12:28Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        }

    ],

    "ok" : 1

}

4:副本集的配置

rs.conf()/rs.config()

mmm:PRIMARY> rs.conf()

{

    "_id" : "mmm",

    "version" : 4,

    "members" : [

        {

            "_id" : 1,

            "host" : "192.168.200.252:27017"

        },

        {

            "_id" : 2,

            "host" : "192.168.200.245:27017"

        },

        {

            "_id" : 3,

            "host" : "192.168.200.25:27017"

        }

    ]

}

5：操作Secondary

默认情况下，Secondary是不提供服务的，即不能读和写。会提示：
error: { "$err" : "not master and slaveOk=false", "code" : 13435 }

在特殊情况下需要读的话则需要：
rs.slaveOk() ，只对当前连接有效。

mmm:SECONDARY> db.test.find()

error: { "$err" : "not master and slaveOk=false", "code" : 13435 }

mmm:SECONDARY> rs.slaveOk()

mmm:SECONDARY> db.test.find()

{ "_id" : ObjectId("5302edfa8c9151a5013b978e"), "a" : 1 }

6：更新ing

三：测试

1：测试副本集数据复制功能

在Primary（192.168.200.252:27017）上插入数据：

mmm:PRIMARY> for(var i=0;i<10000;i++){db.test.insert({"name":"test"+i,"age":123})}

mmm:PRIMARY> db.test.count()

10001

在Secondary上查看是否已经同步：

mmm:SECONDARY> rs.slaveOk()

mmm:SECONDARY> db.test.count()

10001

数据已经同步。

2：测试副本集故障转移功能

关闭Primary节点，查看其他2个节点的情况：

mmm:PRIMARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T05:38:54Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 5777,

            "optime" : Timestamp(1392701576, 2678),

            "optimeDate" : ISODate("2014-02-18T05:32:56Z"),

            "self" : true

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 2265,

            "optime" : Timestamp(1392701576, 2678),

            "optimeDate" : ISODate("2014-02-18T05:32:56Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:38:54Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:38:53Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 2179,

            "optime" : Timestamp(1392701576, 2678),

            "optimeDate" : ISODate("2014-02-18T05:32:56Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:38:54Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:38:53Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        }

    ],

    "ok" : 1

}



#关闭

mmm:PRIMARY> use admin

switched to db admin

mmm:PRIMARY> db.shutdownServer()



#进入任意一台：

mmm:SECONDARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T05:47:41Z"),

    "myState" : 2,

    "syncingTo" : "192.168.200.25:27017",

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 0,

            "state" : 8,

            "stateStr" : "(not reachable/healthy)",

            "uptime" : 0,

            "optime" : Timestamp(1392701576, 2678),

            "optimeDate" : ISODate("2014-02-18T05:32:56Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:47:40Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:45:57Z"),

            "pingMs" : 0

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 5888,

            "optime" : Timestamp(1392701576, 2678),

            "optimeDate" : ISODate("2014-02-18T05:32:56Z"),

            "errmsg" : "syncing to: 192.168.200.25:27017",

            "self" : true

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 2292,

            "optime" : Timestamp(1392701576, 2678),

            "optimeDate" : ISODate("2014-02-18T05:32:56Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:47:40Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:47:39Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        }

    ],

    "ok" : 1

}

看到192.168.200.25:27017 已经从 SECONDARY 变成了 PRIMARY。具体的信息可以通过日志文件得知。继续操作：

在新主上插入：

mmm:PRIMARY> for(var i=0;i<10000;i++){db.test.insert({"name":"test"+i,"age":123})}

mmm:PRIMARY> db.test.count()

20001

重启启动之前关闭的192.168.200.252:27017

mmm:SECONDARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T05:45:14Z"),

    "myState" : 2,

    "syncingTo" : "192.168.200.245:27017",

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 12,

            "optime" : Timestamp(1392702168, 8187),

            "optimeDate" : ISODate("2014-02-18T05:42:48Z"),

            "errmsg" : "syncing to: 192.168.200.245:27017",

            "self" : true

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 11,

            "optime" : Timestamp(1392702168, 8187),

            "optimeDate" : ISODate("2014-02-18T05:42:48Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:45:13Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:45:12Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.25:27017"

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 9,

            "optime" : Timestamp(1392702168, 8187),

            "optimeDate" : ISODate("2014-02-18T05:42:48Z"),

            "lastHeartbeat" : ISODate("2014-02-18T05:45:13Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T05:45:13Z"),

            "pingMs" : 0

        }

    ],

    "ok" : 1

}

启动之前的主，发现其变成了SECONDARY，在新主插入的数据，是否已经同步：

mmm:SECONDARY> db.test.count()

Tue Feb 18 13:47:03.634 count failed: { "note" : "from execCommand", "ok" : 0, "errmsg" : "not master" } at src/mongo/shell/query.js:180

mmm:SECONDARY> rs.slaveOk()

mmm:SECONDARY> db.test.count()

20001

已经同步。

注意：

所有的Secondary都宕机、或则副本集中只剩下一个节点，则该节点只能为Secondary节点，也就意味着整个集群智能进行读操作而不能进行写操作，当其他的恢复时，之前的primary节点仍然是primary节点。

当某个节点宕机后重新启动该节点会有一段的时间（时间长短视集群的数据量和宕机时间而定）导致整个集群中所有节点都成为secondary而无法进行写操作（如果应用程序没有设置相应的ReadReference也可能不能进行读取操作）。

官方推荐的最小的副本集也应该具备一个primary节点和两个secondary节点。两个节点的副本集不具备真正的故障转移能力。

四：应用

1：手动切换Primary节点到自己给定的节点
上面已经提到过了优先集priority，因为默认的都是1，所以只需要把给定的服务器的priority加到最大即可。让245 成为主节点，操作如下：

mmm:PRIMARY> rs.conf() #查看配置

{

    "_id" : "mmm",

    "version" : 6,  #每改变一次集群的配置，副本集的version都会加1。 "members" : [

        {

            "_id" : 1,

            "host" : "192.168.200.252:27017"

        },

        {

            "_id" : 2,

            "host" : "192.168.200.245:27017"

        },

        {

            "_id" : 3,

            "host" : "192.168.200.25:27017"

        }

    ]

}

mmm:PRIMARY> rs.status() #查看状态

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T07:25:51Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 47,

            "optime" : Timestamp(1392708304, 1),

            "optimeDate" : ISODate("2014-02-18T07:25:04Z"),

            "lastHeartbeat" : ISODate("2014-02-18T07:25:50Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T07:25:50Z"),

            "pingMs" : 0,

            "lastHeartbeatMessage" : "syncing to: 192.168.200.25:27017",

            "syncingTo" : "192.168.200.25:27017"

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 47,

            "optime" : Timestamp(1392708304, 1),

            "optimeDate" : ISODate("2014-02-18T07:25:04Z"),

            "lastHeartbeat" : ISODate("2014-02-18T07:25:50Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T07:25:51Z"),

            "pingMs" : 0,

            "lastHeartbeatMessage" : "syncing to: 192.168.200.25:27017",

            "syncingTo" : "192.168.200.25:27017"

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 13019,

            "optime" : Timestamp(1392708304, 1),

            "optimeDate" : ISODate("2014-02-18T07:25:04Z"),

            "self" : true

        }

    ],

    "ok" : 1

}
mmm:PRIMARY> cfg=rs.conf() # { "_id" : "mmm", "version" : 4, "members" : [ { "_id" : 1, "host" : "192.168.200.252:27017" }, { "_id" : 2, "host" : "192.168.200.245:27017" }, { "_id" : 3, "host" : "192.168.200.25:27017" } ] }

mmm:PRIMARY> cfg.members[1].priority=2 #修改priority

2

mmm:PRIMARY> rs.reconfig(cfg) #重新加载配置文件，强制了副本集进行一次选举，优先级高的成为Primary。在这之间整个集群的所有节点都是secondary 

mmm:SECONDARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T07:27:38Z"),

    "myState" : 2,

    "syncingTo" : "192.168.200.245:27017",

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 71,

            "optime" : Timestamp(1392708387, 1),

            "optimeDate" : ISODate("2014-02-18T07:26:27Z"),

            "lastHeartbeat" : ISODate("2014-02-18T07:27:37Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T07:27:38Z"),

            "pingMs" : 0,

            "lastHeartbeatMessage" : "syncing to: 192.168.200.245:27017",

            "syncingTo" : "192.168.200.245:27017"

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 71,

            "optime" : Timestamp(1392708387, 1),

            "optimeDate" : ISODate("2014-02-18T07:26:27Z"),

            "lastHeartbeat" : ISODate("2014-02-18T07:27:37Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T07:27:38Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.25:27017"

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 13126,

            "optime" : Timestamp(1392708387, 1),

            "optimeDate" : ISODate("2014-02-18T07:26:27Z"),

            "errmsg" : "syncing to: 192.168.200.245:27017",

            "self" : true

        }

    ],

    "ok" : 1

}

这样，给定的245服务器就成为了主节点。

2：添加仲裁节点

把25节点删除，重启。再添加让其为仲裁节点：

rs.addArb("192.168.200.25:27017")

mmm:PRIMARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-18T08:14:36Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 795,

            "optime" : Timestamp(1392711068, 100),

            "optimeDate" : ISODate("2014-02-18T08:11:08Z"),

            "lastHeartbeat" : ISODate("2014-02-18T08:14:35Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T08:14:35Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.245:27017"

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" : "PRIMARY",

            "uptime" : 14703,

            "optime" : Timestamp(1392711068, 100),

            "optimeDate" : ISODate("2014-02-18T08:11:08Z"),

            "self" : true

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 7,

            "stateStr" : "ARBITER",

            "uptime" : 26,

            "lastHeartbeat" : ISODate("2014-02-18T08:14:34Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-18T08:14:34Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        }

    ],

    "ok" : 1

}

mmm:PRIMARY> rs.conf()

{

    "_id" : "mmm",

    "version" : 9,

    "members" : [

        {

            "_id" : 1,

            "host" : "192.168.200.252:27017"

        },

        {

            "_id" : 2,

            "host" : "192.168.200.245:27017",

            "priority" : 2

        },

        {

            "_id" : 3,

            "host" : "192.168.200.25:27017",

            "arbiterOnly" : true

        }

    ]

}

上面说明已经让25服务器成为仲裁节点。副本集要求参与选举投票(vote)的节点数为奇数，当我们实际环境中因为机器等原因限制只有两个(或偶数)的节点，这时为了实现 Automatic Failover引入另一类节点：仲裁者（arbiter），仲裁者只参与投票不拥有实际的数据，并且不提供任何服务，因此它对物理资源要求不严格。

通过实际测试发现，当整个副本集集群中达到50%的节点（包括仲裁节点）不可用的时候，剩下的节点只能成为secondary节点，整个集群只能读不能写。比如集群中有1个primary节点，2个secondary节点，加1个arbit节点时：当两个secondary节点挂掉了，那么剩下的原来的 primary节点也只能降级为secondary节点；当集群中有1个primary节点，1个secondary节点和1个arbit节点，这时即使 primary节点挂了，剩下的secondary节点也会自动成为primary节点。因为仲裁节点不复制数据，因此利用仲裁节点可以实现最少的机器开销达到两个节点热备的效果。

3：添加备份节点

hidden（成员用于支持专用功能）：这样设置后此机器在读写中都不可见，并且不会被选举为Primary，但是可以投票，一般用于备份数据。

把25节点删除，重启。再添加让其为hidden节点：

mmm:PRIMARY> rs.add({"_id":3,"host":"192.168.200.25:27017","priority":0,"hidden":true})

{ "down" : [ "192.168.200.25:27017" ], "ok" : 1 }

mmm:PRIMARY> rs.conf()

{

    "_id" : "mmm",

    "version" : 17,

    "members" : [

        {

            "_id" : 1,

            "host" : "192.168.200.252:27017"

        },

        {

            "_id" : 2,

            "host" : "192.168.200.245:27017"

        },

        {

            "_id" : 3,

            "host" : "192.168.200.25:27017",

            "priority" : 0, "hidden" : true

        }

    ]

}

测试其能否参与投票：关闭当前的Primary，查看是否自动转移Primary

关闭Primary（252）：

mmm:PRIMARY> use admin

switched to db admin

mmm:PRIMARY> db.shutdownServer()



连另一个链接察看：

mmm:PRIMARY> rs.status()

{

    "set" : "mmm",

    "date" : ISODate("2014-02-19T09:11:45Z"),

    "myState" : 1,

    "members" : [

        {

            "_id" : 1,

            "name" : "192.168.200.252:27017",

            "health" : 1,

            "state" : 1,

            "stateStr" :"(not reachable/healthy)",

            "uptime" : 4817,

            "optime" : Timestamp(1392801006, 1),

            "optimeDate" : ISODate("2014-02-19T09:10:06Z"),

            "self" : true

        },

        {

            "_id" : 2,

            "name" : "192.168.200.245:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "PRIMARY",

            "uptime" : 401,

            "optime" : Timestamp(1392801006, 1),

            "optimeDate" : ISODate("2014-02-19T09:10:06Z"),

            "lastHeartbeat" : ISODate("2014-02-19T09:11:44Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-19T09:11:43Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        },

        {

            "_id" : 3,

            "name" : "192.168.200.25:27017",

            "health" : 1,

            "state" : 2,

            "stateStr" : "SECONDARY",

            "uptime" : 99,

            "optime" : Timestamp(1392801006, 1),

            "optimeDate" : ISODate("2014-02-19T09:10:06Z"),

            "lastHeartbeat" : ISODate("2014-02-19T09:11:44Z"),

            "lastHeartbeatRecv" : ISODate("2014-02-19T09:11:43Z"),

            "pingMs" : 0,

            "syncingTo" : "192.168.200.252:27017"

        }

    ],

    "ok" : 1

}

上面说明Primary已经转移，说明hidden具有投票的权利，继续查看是否有数据复制的功能。

#####

mmm:PRIMARY> db.test.count()

20210

mmm:PRIMARY> for(var i=0;i<90;i++){db.test.insert({"name":"test"+i,"age":123})}

mmm:PRIMARY> db.test.count()

20300 Secondady:

mmm:SECONDARY> db.test.count()

Wed Feb 19 17:18:19.469 count failed: { "note" : "from execCommand", "ok" : 0, "errmsg" : "not master" } at src/mongo/shell/query.js:180

mmm:SECONDARY> rs.slaveOk()

mmm:SECONDARY> db.test.count()

20300

上面说明hidden具有数据复制的功能

后面大家可以在上面进行备份了，后一篇会介绍如何备份、还原以及一些日常维护需要的操作。

4：添加延迟节点

Delayed（成员用于支持专用功能）：可以指定一个时间延迟从primary节点同步数据。主要用于处理误删除数据马上同步到从节点导致的不一致问题。

把25节点删除，重启。再添加让其为Delayed节点：

mmm:PRIMARY> rs.add({"_id":3,"host":"192.168.200.25:27017","priority":0,"hidden":true,"slaveDelay":60})  #语法

{ "down" : [ "192.168.200.25:27017" ], "ok" : 1 }



mmm:PRIMARY> rs.conf()

{

    "_id" : "mmm",

    "version" : 19,

    "members" : [

        {

            "_id" : 1,

            "host" : "192.168.200.252:27017"

        },

        {

            "_id" : 2,

            "host" : "192.168.200.245:27017"

        },

        {

            "_id" : 3,

            "host" : "192.168.200.25:27017",

            "priority" : 0,  "slaveDelay" : 60, "hidden" : true

        }

    ]

}

测试：操作Primary，看数据是否60s后同步到delayed节点。

mmm:PRIMARY> db.test.count()

20300

mmm:PRIMARY> for(var i=0;i<200;i++){db.test.insert({"name":"test"+i,"age":123})}

mmm:PRIMARY> db.test.count()

20500



Delayed：

mmm:SECONDARY> db.test.count()

20300 #60秒之后

mmm:SECONDARY> db.test.count()

20500

上面说明delayed能够成功的把同步操作延迟60秒执行。除了上面的成员之外，还有：

Secondary-Only:不能成为primary节点，只能作为secondary副本节点，防止一些性能不高的节点成为主节点。

Non-Voting：没有选举权的secondary节点，纯粹的备份数据节点。

具体成员信息如下：

	成为primary	对客户端可见	参与投票	延迟同步	复制数据
Default	√	√	√	∕	√
Secondary-Only	∕	√	√	∕	√
Hidden	∕	∕	√	∕	√
Delayed	∕	√	√	√	√
Arbiters	∕	∕	√	∕	∕
Non-Voting	√	√	∕	∕	√

5：读写分离

MongoDB副本集对读写分离的支持是通过Read Preferences特性进行支持的，这个特性非常复杂和灵活。

应用程序驱动通过read reference来设定如何对副本集进行读取操作，默认的,客户端驱动所有的读操作都是直接访问primary节点的，从而保证了数据的严格一致性。

支持五种的read preference模式：官网说明

primary

主节点，默认模式，读操作只在主节点，如果主节点不可用，报错或者抛出异常。

primaryPreferred

首选主节点，大多情况下读操作在主节点，如果主节点不可用，如故障转移，读操作在从节点。

secondary

从节点，读操作只在从节点， 如果从节点不可用，报错或者抛出异常。

secondaryPreferred

首选从节点，大多情况下读操作在从节点，特殊情况（如单主节点架构）读操作在主节点。

nearest

最邻近节点，读操作在最邻近的成员，可能是主节点或者从节点，关于最邻近的成员请参考

注意：2.2版本之前的MongoDB对Read Preference支持的还不完全，如果客户端驱动采用primaryPreferred实际上读取操作都会被路由到secondary节点。

因为读写分离是通过修改程序的driver的，故这里就不做说明，具体的可以参考这篇文章或则可以在google上查阅。

验证：（Python）

通过python来验证MongoDB ReplSet的特性。

1：主节点断开，看是否影响写入

脚本：

#coding:utf-8

import time

from pymongo import ReplicaSetConnection

conn = ReplicaSetConnection("192.168.200.201:27017,192.168.200.202:27017,192.168.200.204:27017", replicaSet="drug",read_preference=2, safe=True)

#打印Primary服务器
#print conn.primary
#打印所有服务器
#print conn.seeds
#打印Secondary服务器
#print conn.secondaries

#print conn.read_preference
#print conn.server_info()


for i in xrange(1000):

    try:

        conn.test.tt.insert({"name":"test" + str(i)})

        time.sleep(1)

        print conn.primary

        print conn.secondaries

    except:

        pass

脚本执行打印出的内容：

zhoujy@zhoujy:~$ python test.py 

(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])



(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])



(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])



(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])



(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])



('192.168.200.202', 27017)                                          ##Primary宕机，选举产生新Primary

set([(u'192.168.200.204', 27017)])



('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017)])



('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017)])



('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017)])



('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017)])



('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])     ##开启之前宕机的Primary，变成了Secondary



('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])



('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])

View Code

体操作如下：

在执行脚本的时候，模拟Primary宕机，再把其开启。看到其从201（Primary）上迁移到202上，201变成了Secondary。查看插入的数据发现其中间有一段数据丢失了。

{ "name" : "GOODODOO15" }

{ "name" : "GOODODOO592" }

{ "name" : "GOODODOO593" }

其实这部分数据是由于在选举过程期间丢失的，要是不允许数据丢失，则把在选举期间的数据放到队列中，等到找到新的Primary，再写入。

上面的脚本可能会出现操作时退出，这要看xrange()里的数量了，所以用一个循环修改（更直观）：

#coding:utf-8

import time

from pymongo import ReplicaSetConnection

conn = ReplicaSetConnection("192.168.200.201:27017,192.168.200.202:27017,192.168.200.204:27017", replicaSet="drug",read_preference=2, safe=True)



#打印Primary服务器

#print conn.primary

#打印所有服务器

#print conn.seeds

#打印Secondary服务器

#print conn.secondaries



#print conn.read_preference

#print conn.server_info()



while True:

    try:

        for i in xrange(100):

            conn.test.tt.insert({"name":"test" + str(i)})

            print "test" + str(i)

            time.sleep(2)

            print conn.primary

            print conn.secondaries

            print '\n'

    except:

        pass

上面的实验证明了：在Primary宕机的时候，程序脚本仍可以写入，不需要人为的去干预。只是期间需要10s左右（选举时间）的时间会出现不可用，进一步说明，写操作时在Primary上进行的。

2：主节点断开，看是否影响读取

脚本：

#coding:utf-8

import time

from pymongo import ReplicaSetConnection

conn = ReplicaSetConnection("192.168.200.201:27017,192.168.200.202:27017,192.168.200.204:27017", replicaSet="drug",read_preference=2, safe=True)



#打印Primary服务器

#print conn.primary

#打印所有服务器

#print conn.seeds

#打印Secondary服务器

#print conn.secondaries



#print conn.read_preference

#print conn.server_info()



for i in xrange(1000):

    

    time.sleep(1)

    obj=conn.test.tt.find({},{"_id":0,"name":1}).skip(i).limit(1)

    for item in obj:

        print item.values()

    print conn.primary

    print conn.secondaries

脚本执行打印出的内容：

zhoujy@zhoujy:~$ python tt.py 

[u'GOODODOO0']

(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])

[u'GOODODOO1']

(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])

[u'GOODODOO2']

(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])

…………

…………

[u'GOODODOO604']

(u'192.168.200.201', 27017)

set([('192.168.200.202', 27017), (u'192.168.200.204', 27017)])

[u'GOODODOO605']                                                       ##主宕机（201），再开启，没有影响，继续读取下一条

('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])

[u'GOODODOO606']

('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])

[u'GOODODOO607']

('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])

…………

…………

[u'test8']

('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])

[u'test9']

('192.168.200.202', 27017)

set([(u'192.168.200.204', 27017), (u'192.168.200.201', 27017)])    

[u'test10']                                                            ##主再次宕机，不开启，没有影响，继续读取下一条

(u'192.168.200.204', 27017)

set([(u'192.168.200.201', 27017)])

[u'test11']

(u'192.168.200.204', 27017)

set([(u'192.168.200.201', 27017)])

[u'test12']

(u'192.168.200.204', 27017)

set([(u'192.168.200.201', 27017)])

View Code

具体操作如下：

在执行脚本的时候，模拟Primary宕机，再把其开启。看到201（Primary）上迁移到202上，201变成了Secondary，读取数据没有间断。再让Primary宕机，不开启，读取也不受影响。

上面的实验证明了：在Primary宕机的时候，程序脚本仍可以读取，不需要人为的去干预。一进步说明，读取是在Secondary上面。

总结：

刚接触MongoDB，能想到的就这些，后期发现一些新的知识点会不定时更新该文章。

http://www.cnblogs.com/magialmoon/p/3261849.html

http://www.cnblogs.com/magialmoon/p/3268963.html

http://www.lanceyan.com/tech/mongodb/mongodb_cluster_1.html

http://www.lanceyan.com/tech/mongodb/mongodb_repset1.html

http://m.blog.csdn.net/blog/lance_yan/19332981

读写分离：

http://blog.chinaunix.net/uid-15795819-id-3075952.html

http://blog.csdn.net/kyfxbl/article/details/12219483

你可能感兴趣的:(mongodb)

MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 error react mongodb 数据库
背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
springboot整合MongoDB时碰到的问题生产队队长 Database Spring All mongodb spring
1.账号总是不对，导致查不出数据，报错Auth…权鉴错误这次，我也是第一次接触MongoDB，非常的生疏springboot整合MongoDB，要在properties文件中配置账号mongodb基本语法：useDATABASE_NAME;--创建数据库showdbs;--查看我们所有的库，注意，我们刚创建的库，如果没有数据，是不会被显示的showusers;--查看当前库所有拥有的账号db.cr
java mongodb group分组使用 yank1225 mongodb java mongodb group
mongodb的关键字及介绍.mongodb的查询是有一定规则的,刚开始接触老是各种错误,参照以下内容有很多帮助https://docs.mongodb.com/manual/reference/sql-aggregation-comparison/另外出现这种错误时Apipelinestagespecificationobjectmustcontainexactlyonefield是因为条件不对
MongoDB Atlas与LangChain集成指南 afTFODguAKBF mongodb langchain 数据库 python
引言MongoDBAtlas是一款全托管的云数据库解决方案,可在AWS、Azure和GCP上使用。最新版本支持在MongoDB文档数据上进行原生向量搜索。本文将介绍如何使用LangChain将MongoDBAtlas与语言模型集成,以实现高效的向量搜索和语义缓存。安装和设置1.安装langchain-mongodb包pipinstalllangchain-mongodb向量存储LangChain提
数据库管理的利器Navicat —— 全面测评与热门产品推荐界面开发小八哥数据库 Navicat 数据库开发 sql mysql
在数据库管理领域，Navicat无疑是一款深受欢迎的软件。作为一个强大的数据库管理和开发工具，它支持多种数据库类型，包括MySQL、MariaDB、MongoDB、SQLServer、Oracle、PostgreSQL等。本文将全面测评Navicat的核心功能，同时推荐几款热门的Navicat产品。Navicat的主要特点1.跨平台支持：Navicat支持Windows、Mac和Linux平台，可
MongoDB C++库编译，windows平台+VS2015（QT中也可以用） hp_cpp C++
编译准备工作：（1）mongo-c-driver下载地址：https://github.com/mongodb/mongo-c-driver/releases下载最新版：mongo-c-driver1.12.0的Soucecode版（2）mongodb/mongo-cxx-driver下载地址：https://github.com/mongodb/mongo-cxx-driver/releases
使用docker部署MongoDB数据库数据小白的进阶之路数据库 docker mongodb
最近由于工作需要搭建MongoDB数据库：将解析的车端采集的数据写入到数据库，由于MongoDB高可用、海量扩展、灵活数据的模型，因此选用MongoDB数据库；由于现公司只有服务器，因此考虑容器化部署MongoDB数据，特此记录一下~一、镜像拉取使用如下命令拉取最新MongoDB镜像dockerpullmongo二、创建MongoDB容器2.1创建宿主机目录执行如下代码：mkdir-p/home/
MongoDB数据库 weixin_34104341 数据库 json shell
一简介MongoDB是一款强大、灵活、且易于扩展的通用型数据库1.易用性MongoDB是一个面向文档（document-oriented）的数据库，而不是关系型数据库。不采用关系型主要是为了获得更好得扩展性。当然还有一些其他好处，与关系数据库相比，面向文档的数据库不再有“行“（row）的概念取而代之的是更为灵活的“文档”（document）模型。通过在文档中嵌入文档和数组，面向文档的方法能够仅使用
【Docker】MongoDB 容器化部署轻云UC 运维部署 mongodb docker 数据库
MongoDBdocker容器化部署MongoDB标准软件基于BitnamiMongoDB构建。当前版本未7.0.5你可以通过轻云UC部署工具直接安装部署，也可以手动按如下文档操作配置文件地址:https://gitee.com/qingplus/qingcloud-platformQinghubStudio在线体验初始化一个新实例使用Docker容器网络，应用程序容器可以轻松访问容器内运行的Mo
MongoDB ：第五章：MongoDB 插入更新删除查询文档 2401_84558091 作者\/mongodb 数据库
“_id”:ObjectId(“56064f89ade2f21f36b03136”),“title”:“MongoDB”,“description”:“MongoDB是一个Nosql数据库”,“by”:“菜鸟教程”,“url”:“http://www.runoob.com”,“tags”:[“mongodb”,“database”,“NoSQL”],“likes”:100}可以看到标题(title
数据库有关c语言 h海棠溪数据库学习 c语言 linux
数据库的概念SQL（StructuredQueryLanguage）是一种专门用来与数据库进行交互的编程语言，它允许用户查询、更新和管理关系型数据库中的数据。关系型数据库是基于表（Table）的数据库，其中表由行（Row）和列（Column）组成，每一行代表一个记录（Record），每一列代表一个字段（Field）。非关系型数据库MongoDB1、分类：大型中型小型ORACLEMYSQL/MSSQ
使用 MongoDB 构建 AI：Patronus 如何自动进行大语言模型评估来增强对生成式 AI 的信心 MongoDB 数据平台 AI应用客户案例人工智能 mongodb
大语言模型可能不可靠，这几乎算不上头条新闻。对于某些用例，这可能会带来不便。而对于其他行业，尤其是受监管行业，后果则要严重得多。于是，业内首个大语言模型自动评估平台PatronusAI应运而生。PatronusAI由MetaAI和MetaRealityLabs的机器学习专家创立，旨在增强企业对生成式AI应用程序的信心，在塑造值得信赖的AI生态方面处于领先地位。Patronus联合创始人兼首席技术官
MongoDB-副本集PSA架构搭建配置手册玩亚索的小孔 MongoDB MongoDB 副本集 PSA
1安装配置------------------------------------------------------------------------------------机器准备：•系统：RedHatEnterpriseLinuxServerrelease7.3(Maipo)•MongoDB版本：mongodb-linux-x86_64-rhel70-3.4.16•下载地址:http://
解决方案| MongoDB PSA 架构痛点以及如何应对？ MongoDB中文社区 MongoDB mongodb 架构数据库
一.背景最近MongoDB群里面有群友遇到2次重启MongoDB后一直处于实例恢复状态(应用OPLOG)，多达几天甚至更长才完成重启，通常MongoDB副本集三个实例作为标准，重启主库会发生重新选出新主节点(通常在12s内完成)重新对外服务，通常不符合官方标准化或者内部发生异常导致的。经过了解副本集采用PSA架构且存在一个数据从节点不可达的情况(甚至有的从节点宕机几个月没有发现)，来分析这些情况以
MongoDB之写关注及PSA架构相关问题吃饭端住碗 MongoDB mongodb 架构数据库
MongoDB的写关注主要指定了写入操作的确认级别。具体来讲就是客户端在向MongoDB执行比如delete、insert、update等相关写入操作时，MongoDB的写入行为，比如是否立刻刷盘、是否需要等待Secondary节点确认等。写关注说明写关注配置主要包含以下3个字段：{w:,j:,wtimeout:}w选项指定了写入操作需要等待确认的副本集成员个数。取值如下：“majority”：写
mongoDB 对一个做了索引的字段，要不要给默认值？ hongkid mongodb 数据库
引言在设计数据库模式时，如何处理字段的默认值是一个值得深入探讨的话题。对于MongoDB这样的NoSQL数据库来说，灵活性是其一大特点，但这同时也意味着开发者需要更加谨慎地考虑数据的一致性和完整性。本文将探讨在一个已创建索引的字段上，在插入文档时是否应该显式设置默认值的问题，并给出具体的建议。MongoDB中的索引与字段设置在MongoDB中，索引可以帮助提高查询性能，特别是在处理大规模数据集时。
MongoDB-聚合查询操作介绍侯晓阳丶 MongoDB mongodb 数据库 linux dba 经验分享
目录前言db.collection.aggregate()db.collection.aggregate()示例一db.collection.aggregate()示例二复杂的聚合操作通过mongoimport导入测试数据复杂的聚合操作示例聚合操作的偏好设置-project函数聚合操作的偏好设置-unwind函数前言MongoDB聚合操作相当于关系型数据库SQL语句的"groupby"、“orde
Docker搭建MongoDB Replica Set高可用集群+数据丢失&被黑解决+自动备份与恢复脚本+持久化慢查询记录秋风お亦冷运维企业实战笔录运维 docker mongodb 数据库
文章目录引节点规划配置文件创建持久化目录创建并推送证书启动临时容器修改配置文件单节点参考mongod.confdocker-compose.ymlReplicaSet参考mongod.confdocker-compose.yml部署与配置部署集群配置集群验证集群增删节点增加节点删除节点查看节点常用命令重置集群备份数据关闭服务删除持久化数据启动集群配置集群验证集群创建用户验证集群用户管理权限说明创建
vue+jsonrpc+mongoDB文件传输解决方案（任意格式文件） weideng_san 前端 java 文件传输 jsonrpc mongoDB vue
环境及需求：前端采用vue；后端采用spring，但是只用到了spring的对象注入功能，未使用springweb相关功能。前后端通信采用jsonrpc，现需要在前端选中文件（格式未知，上传到后端，后端将其存储在mongoDB中）。背景：springweb可以直接使用controller接受MultipartFile对象；但是jsonrpc不能直接传输文件类型，jsonrpc是轻量级通信框架，擅长
mongodb 在 Windows 环境下迁移数据库的问题 Eagsen CEO 数据库 mongodb
mongodb是一款非常优秀的文档数据库，它的社区版本是免费的。但是mongodb的迁移和其他传统的关系数据库不太一样，通过官方提供的图形化的客户端工具无法备份和迁移，需要下载命令行工具进行。首先下载命令行工具：DownloadMongoDBCommandLineDatabaseTools|MongoDBWindows安装后，使用管理员身份打开cmd命令窗口，导航到安装目录的bin目录下，如果是默
python网络爬虫（五）——爬取天气预报光电的一只菜鸡 python python 爬虫开发语言
1.注册高德天气key 点击高德天气，然后按照开发者文档完成key注册；作为爬虫练习项目之一。从高德地图json数据接口获取天气，可以获取某省的所有城市天气，高德地图的这个接口还能获取县城的天气。其天气查询API服务地址为https://restapi.amap.com/v3/weather/weatherInfo?parameters，若要获取某城市的天气推荐2.安装MongoDB Mong
Spring常用中间件贺仙姑 spring 中间件 java
1.数据库中间件（1）MySQL:常用的关系型数据库，支持JDBC和JPA。（2）PostgreSQL:功能强大的开源关系型数据库，支持复杂查询。（3）MongoDB:NoSQL数据库，适合存储非结构化数据。（4）Redis:内存数据结构存储，常用于缓存和消息队列。2.消息队列（1）RabbitMQ:开源消息代理，支持多种消息协议，适合异步处理。（2）Kafka:分布式流处理平台，适合处理大规模数
Node.js 数据库操作详解：构建高效的数据持久化层 Switch616 前端 node.js 数据库运维服务器系统架构前端框架前端
Node.js数据库操作详解：构建高效的数据持久化层目录MongoDB使用mongoose连接MongoDB定义模型和数据验证实现CRUD操作️MySQL使用mysql或mysql2模块连接MySQL执行SQL查询处理结果和错误SQLite使用sqlite3模块连接SQLite执行SQL查询处理事务MongoDB使用mongoose连接MongoDBmongoose是一个为MongoDB提供对象数
MongoDB的WiredTiger存储引擎云掣YUNCHE mongodb 数据库
作者：太阳从MongoDB3.2开始，MongoDB实例默认的存储引擎为WiredTiger，WiredTiger存储引擎具体以下几大优点：文档级并发将数据持久化到磁盘快照和checkpoint数据压缩本地数据加密一、文档级别并发1、WiredTiger使用文档级别并发，意味着在同一时间，MongoDB实例允许多个对不同文档间的写操作并发执行（复制应用oplog时同样可以做到文档级并发应用）。2、
mongodb中常用的运算符和正则表达式手搓二十四种设计模式 mongodb
在mongodb中不能>=，----$gt=----$gte<=----$lte!==----$ne例如：查询id比三大的所有记录db.students.find({id:{$gt:3}});2.逻辑运算符：$or逻辑或例如：查询年龄为十岁或九岁的数据db.students.find({$or:[{age:10},{age:9}]});$and逻辑与：例如：查询年龄大于十一岁且小于二十四的db.s
SpringCloud 结合 MongoTemplate 打印执行语句log kikiki1
在调度MongoTemplate的时候，我们无法确定我们写的方法是否能发出正确的语句,这时候我们需要将语句给打印出来。springcloud使用方法在application.yml文件中增加如下配置即可logging:level:org.springframework.data.mongodb.core.MongoTemplate:DEBUG
2024年Python最新Python爬虫教程-新浪微博分布式爬虫分享(2) 2401_84584682 程序员 python 爬虫新浪微博
开发语言：Python2.7开发环境：64位Windows8系统，4G内存，i7-3612QM处理器。数据库：MongoDB3.2.0、Redis3.0.501（Python编辑器：Pycharm；MongoDB管理工具：MongoBooster；Redis管理工具：RedisStudio）爬虫框架使用Scrapy，使用scrapy_redis和Redis实现分布式。分布式中有一台机充当Maste
java Illegal overloaded getter method with ambiguous type for propert的解决 zwllxs java jdk
好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
IT人应当知道的10个行业小内幕 beijingjava 工作互联网
10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
java 实现自定义链表 CrazyMizzz java 数据结构
1.链表结构链表是链式的结构 2.链表的组成链表是由头节点，中间节点和尾节点组成节点是由两个部分组成： 1.数据域 2.引用域 3.链表的实现 &nbs
web项目发布到服务器后图片过一会儿消失麦田的设计者 struts2 上传图片永久保存
作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
CodeIgniter框架Cart类 name 不能设置中文的解决方法 IT独行者 CodeIgniter Cart 框架　
今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。在CI手册里也有说明，如下： $data = array( 'id' => 'sku_123ABC', 'qty' => 1, '
linux回收站 _wy_ linux 回收站
今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
jquery回到页面顶端知了ing html jquery css
html代码： <h1 id="anchor">页面标题</h1> <div id="container">页面内容</div> <p><a href="#anchor" class="topLink">回到顶端</a><
B树、B-树、B+树、B*树矮蛋蛋 B树
原文地址： http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html B树即二叉搜索树： 1.所有非叶子结点至多拥有两个儿子（Left和Right）； &nb
数据库连接池 alafqq 数据库连接池
http://www.cnblogs.com/xdp-gacl/p/4002804.html @Anthor:孤傲苍狼数据库连接池用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
java泛型百合不是茶 java泛型
泛型在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患泛型的特点：消除强制转换确保类型安全向后兼容简单泛型的定义：泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 class fan
javascript闭包[两个小测试例子] bijian1013 JavaScript JavaScript
一.程序一 <script> var name = "The Window"; var Object_a = { 　　name : "My Object", 　　getNameFunc : function(){ var that = this; 　　　　return function(){ 　　　　
探索JUnit4扩展：假设机制（Assumption） bijian1013 java Assumption JUnit 单元测试
一.假设机制（Assumption）概述理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
【Gson四】范型POJO的反序列化 bit1129 POJO
在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 String str = new Gson().toJson(data); 得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO import com.google.gson.Gson; import java.
【Spark八十五】Spark Streaming分析结果落地到MySQL bit1129 Stream
几点总结： 1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
NGINX + LUA实现复杂的控制 ronin47 nginx lua
安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
java-递归判断数组是否升序 bylijinnan java
public class IsAccendListRecursive { /*递归判断数组是否升序 * if a Integer array is ascending,return true * use recursion */ public static void main(String[] args){ IsAccendListRecursiv
Netty源码学习-DefaultChannelPipeline2 bylijinnan java netty
Netty3的API http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 里面提到ChannelPipeline的一个“pitfall”：如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB）来
Java工具之JPS chinrui java
JPS使用熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
window.print分页打印 ctrain window
function init() { var tt = document.getElementById("tt"); var childNodes = tt.childNodes[0].childNodes; var level = 0; for (var i = 0; i < childNodes.length; i++) {
安装hadoop时执行jps命令Error occurred during initialization of VM daizj jdk hadoop jps
在安装hadoop时，执行JPS出现下面错误 [slave16][email protected]:/tmp/hsperfdata_hdfs# jps Error occurred during initialization of VM java.lang.Error: Properties init: Could not determine current working
PHP开发大型项目的一点经验 dcj3sjt126com PHP 重构
一、变量最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
android笔记之--向网络发送GET/POST请求参数 dcj3sjt126com android
使用GET方法发送请求 private static boolean sendGETRequest (String path, Map<String, String> params) throws Exception{ //发送地http://192.168.100.91:8080/videoServi
linux复习笔记之bash shell (3) 通配符 eksliang linux 通配符 linux通配符
转载请出自出处： http://eksliang.iteye.com/blog/2104387 在bash的操作环境中有一个非常有用的功能，那就是通配符。下面列出一些常用的通配符，如下表所示符号意义 * 万用字符，代表0个到无穷个任意字符 ? 万用字符，代表一定有一个任意字符 [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
Android关于短信加密 gqdy365 android
关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）： 1、因为Android有短信收发接口，可以调用接口完成短信收发；发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
asp.net在网站根目录下创建文件夹 hvt .net C#hovertree asp.net Web Forms
假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： string m_keleyiFolderName = Server.MapPath("/hovertree"); if (Directory.Exists(m_keleyiFolderName)) { //文件夹已经存在 return; } else { try { D
一个合格的程序员应该读过哪些书 justjavac 程序员书籍
编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本，你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 很多程序员响应，他们在推荐时也写下自己的评语。以前就有国内网友介绍这个程序员书单，不过都是推荐数
单实例实践跑龙套_az 单例
1、内部类 public class Singleton { private static class SingletonHolder { public static Singleton singleton = new Singleton(); } public Singleton getRes
PO VO BEAN 理解 q137681467 VO DTO po
PO：全称是 persistant object持久对象最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。 BO：全称是 business object:业务对象主要作用是把业务逻辑封装为一个对象。这个对
战胜惰性，暗自努力金笛子努力
偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？我有个朋友是搞技术的，平时嘻嘻哈哈，以
NDK/JNI二维数组多维数组传递 wenzongliang 二维数组 jni NDK
多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata) { jint i,j; int s