MongoDB集群搭建及Sharding的实现思路

转载 2016年08月29日 17:43:15

MongoDB集群搭建及Sharding的实现思路

2014-03-28 09:35 zuzhou 51CTO博客 我要评论(0) 字号:T | T
一键收藏,随时查看,分享好友!

选择一个合适索引而减少索引量,这种索引叫做重复索引,能够在索引中直接查找到所有要查询的索引,叫做覆盖索引,能够满足覆盖索引的条件并且排序次序又能够与索引的次序相同,这种次序是"3星"的,所以任何时候创建索引的目的一定要与搜索码完全匹配,至少保持一致.

AD:51CTO 网+ 第十二期沙龙:大话数据之美_如何用数据驱动用户体验

MongoDB集群搭建

MongoDB的复制集群类型:

·主从模式(master/slave)

·副本集模式(replica set)

副本及模式至少3个节点(一主二从),从节点负责复制主节点的oplog到本地并且应用到本地从而实现冗余。

(·arbiter:仅参与选举,但不持有任何数据

·0优先级:可以触发选举,但是不能被选举成为主节点

·可以使用repiset来定义集群名称)

1.编译安装MongDB

准备环境:

系统:Debian 7.2 64位

mongodb:mongodb-linux-x86_64-2.4.5.tgz(官网有下)

  1. root@namenode1:/usr/local/tools# tar xfmongodb-linux-x86_64-2.4.5.tgz   
  2. root@namenode1:/usr/local/tools# mv mongodb-linux-x86_64-2.4.5 /usr/local/  
  3. root@namenode1:/usr/local/tools# cd /usr/local/  
  4. root@namenode1:/usr/local# ln -s /usr/local/mongodb-linux-x86_64-2.4.5//usr/local/mongodb  
  5. root@namenode1:/usr/local# ll | grep mongo  
  6. lrwxrwxrwx  1 root   staff    38  3月 17 15:35 mongodb ->/usr/local/mongodb-linux-x86_64-2.4.5/  
  7. drwxr-sr-x  3 root   staff  4096  3月 17 15:08 mongodb-linux-x86_64-2.4.5 

#创建用户

  1. root@namenode1:~# groupadd -r mongod  
  2. root@namenode1:~# useradd -M -r -g mongod -d /data/db -s /bin/false -c mongodmongod 

#建立目录

  1. root@namenode1:~# mkdir -p /var/log/mongo/  
  2. root@namenode1:~# mkdir -p /mongo/data  
  3. root@namenode1:~# chown mongod /mongo/data /var/log/mongo/  
  4.  
  5.  
  6. root@namenode1:~# ll /var/log/ | grep mongo  
  7. drwxr-xr-x 2mongod           root          4096 Mar 17 15:25mongo  
  8. root@namenode1:~# ll /mongo/  
  9. total 4  
  10. drwxr-xr-x 2 mongod root 4096 Mar 17 15:27 data 

#将LC_ALL="C"加入环境变量,以防启动出错

  1. root@namenode1:~# echo ‘export LC_ALL="C"’ >> /etc/profile 

#创建配置文件(将之前rpm包安装mongodb后的配置文件拷贝过来即可)

  1. root@namenode1:~# cat /etc/mongod.conf  
  2. # mongo.conf  
  3.  
  4. #where to log  
  5. logpath=/var/log/mongo/mongod.log  
  6.  
  7. logappend=true 
  8.  
  9. # fork and run in background  
  10. fork = true 
  11.  
  12. #port = 27017 
  13.  
  14. dbpath=/mongo/data  
  15.  
  16. # location of pidfile  
  17. pidfilepath = /var/run/mongodb/mongod.pid  
  18.  
  19. # Disables write-ahead journaling  
  20. nojournal = true 
  21.  
  22. # Enables periodic logging of CPU utilization and I/O wait  
  23. #cpu = true 
  24.  
  25. # Turn on/off security.  Off is currently the default  
  26. #noauth = true 
  27. #auth = true 
  28.  
  29. # Verbose logging output.  
  30. #verbose = true 
  31.  
  32. # Inspect all client data for validity on receipt (useful for  
  33. # developing drivers)  
  34. #objcheck = true 
  35.  
  36. # Enable db quota management  
  37. #quota = true 
  38.  
  39. # Set oplogging level where n is  
  40. #   0=off (default)  
  41. #   1=W 
  42. #   2=R 
  43. #   3=both 
  44. #   7=W+some reads  
  45. #diaglog = 0 
  46.  
  47. # Ignore query hints  
  48. #nohints = true 
  49.  
  50. # Disable the HTTP interface (Defaults to localhost:27018).  
  51. #nohttpinterface = true 
  52.  
  53. # Turns off server-side scripting.  This will result in greatly limited  
  54. # functionality  
  55. #noscripting = true 
  56.  
  57. # Turns off table scans.  Any query that would do a table scan fails.  
  58. #notablescan = true 
  59.  
  60. # Disable data file preallocation.  
  61. #noprealloc = true 
  62.  
  63. # Specify .ns file size for new databases.  
  64. nssize = <size> 
  65.  
  66. # Accout token for Mongo monitoring server.  
  67. #mms-token = <token> 
  68.  
  69. # Server name for Mongo monitoring server.  
  70. #mms-name = <server-name> 
  71.  
  72. # Ping interval for Mongo monitoring server.  
  73. #mms-interval = <seconds> 
  74.  
  75. # Replication Options  
  76.  
  77. # in replicated mongo databases, specify here whether this is a slave or master  
  78. #slave = true 
  79. #source = master.example.com  
  80. # Slave only: specify a single database to replicate  
  81. #only = master.example.com  
  82. # or  
  83. #master = true 
  84. #source = slave.example.com 

启动mongodb

  1. export LC_ALL="C" 
  2. root@namenode2:/usr/local/mongodb/bin# mongod -f /etc/mongod.conf   

2.安装Rockmongo

RockMongo 是一个PHP5写的MongoDB管理工具。主要特征:使用宽松的New BSD License协议,速度快,安装简单,与mysql的phpmyadmin相似

  1. root@namenode1:~# apt-get install apache2 php5 php5-dev php5-cli  
  2. root@namenode1:/etc/apache2# cd /var/www/  
  3. root@namenode1:/var/www# wgethttp://rock-php.googlecode.com/files/rockmongo-v1.0.11.zip  
  4. root@namenode1:/var/www# unzip rockmongo-v1.0.11.zip 

#二次编译php模块

  1. root@namenode1:/var/www/mongo-php-driver-master# phpize   
  2. root@namenode1:/var/www/mongo-php-driver-master# ./configure    
  3. root@namenode1:/var/www/mongo-php-driver-master# make && makeinstall 

#找到php模块所在路径

  1. root@namenode1:/var/www/mongo-php-driver-master#  php -i | grepextension_dir  
  2. extension_dir => /usr/lib/php5/20100525 => /usr/lib/php5/20100525  
  3. root@namenode1:/var/www/mongo-php-driver-master# ll /usr/lib/php5/20100525  
  4. total 2084  
  5. -rwxr-xr-x 1 root root 2016810 Mar 17 16:35 mongo.so  
  6. -rw-r--r-- 1 root root  113072 Dec 12 16:53 pdo.so 

#php在debian系统所安装的路径在以下的位置,如果是其他系统需根据相对路径进行查找

  1. root@namenode1:/var/www/mongo-php-driver-master# ll/etc/php5/apache2/php.ini  
  2. -rw-r--r-- 1 root root 65755 Dec 12 16:53 /etc/php5/apache2/php.ini  
  3. root@namenode1:/var/www/mongo-php-driver-master# vi/etc/php5/apache2/php.ini  

在733行加入内容,并保存退出  

  1. 733 extension = mongo.so   

重启apache并查看url是否生效

  1. root@namenode1:/etc/init.d/apache restart 

访问以下地址

  1. http://172.23.214.50/rockmongo/index.php?action=index.login 

可以看到如下图所示,已经可以正常显示mongodb的管理登陆界面,默认情况下用户名与密码默认都为admin

wKioL1MvyOqwnHOrAAC211s4F84914.jpg

确认用户名和密码,登陆成功,如下所示

wKiom1MvyRHQs9ikAAN5XB0vooI322.jpg

部署MongoDB主从复制:

1.规划如下:

服务器IP

服务器角色

172.23.214.47

Master

172.23.214.50

Slave

2.配置主从

编辑Master配置文件:

  1. root@namenode2:/var/log/mongo# grep -v "#" /etc/mongod.conf |grep -v "^$"  
  2.  
  3. logpath=/var/log/mongo/mongod.log  
  4.  
  5. logappend=true 
  6.  
  7. fork = true 
  8.  
  9. port = 27017 
  10.  
  11. dbpath=/mongo/data  
  12.  
  13. pidfilepath = /var/run/mongodb/mongod.pid  
  14.  
  15. rest = true 
  16.  
  17. maxConns=1024 
  18.  
  19. master=true                           #将指定其为master  
  20.  
  21. oplogSize=2048 

编辑Slave配置文件

  1. root@namenode1:/etc# cat mongod.conf.bak_slave  | grep -v "#" | grep -v"^$"  
  2.  
  3. logpath=/var/log/mongo/mongod.log  
  4.  
  5. logappend=true 
  6.  
  7. fork = true 
  8.  
  9. port = 27017 
  10.  
  11. dbpath=/mongo/data  
  12.  
  13. maxConns = 1024 
  14.  
  15. slave = true                         #指定其为slave  
  16.  
  17. source = 172.23.214.47:27017         #指定master的主机地址及端口号  
  18.  
  19. autoresync = true 
  20.  
  21. pidfilepath = /var/run/mongodb/mongod.pid  

编辑好配置文件,双方启动mongodb

  1. root@namenode1: mongod --f /etc/mongod.conf 

主库查看日志信息:

  1. root@namenode2:/var/log/mongo# cat mongod.log  
  2.  
  3. Tue Mar 18 13:24:32.115 [initandlisten] connection accepted from172.23.214.50:57356 #2 (1 connection now open)  

从库查看日志信息

  1. root@namenode1:/var/log/mongo# tail mongod.log  | grep 47  
  2. Tue Mar 18 13:24:30.025 [initandlisten] options: { autoresync:"true", config: "/etc/mongod.conf", dbpath:"/mongo/data", fork: "true", logappend: "true",logpath: "/var/log/mongo/mongod.log", maxConns: 1024, pidfilepath:"/var/run/mongodb/mongod.pid", port: 27017, slave: "true",source: "172.23.214.47:27017" }  
  3. Tue Mar 18 13:24:31.188 [replslave] repl: syncingfrom host:172.23.214.47:27017 

验证:主库创建库,并在从库查看

  1. > db.testcoll.find()  
  2. > show collections  
  3. > db.testcoll.insert ( {name:"tom"})  
  4. > show collections  
  5. system.indexes  
  6. testcoll  
  7. > db.testcoll.find()  
  8. { "_id" : ObjectId("5327dabc9d62778b7a74ccab"),"name" : "tom" } 

在从库上查看

  1. >show dbs;  
  2. local     0.078125GB  
  3. testdb     0.203125GB  
  4. > use testdb;  
  5. switched to db testdb  
  6. > db.testcoll.find()  
  7. { "_id" : ObjectId("5327dabc9d62778b7a74ccab"),"name" : "tom" } 

查看从库日志

  1. root@namenode1:/var/log/mongo# tail mongod.log  
  2. Tue Mar 18 13:33:48.042 [replslave] build index testdb.testcoll { _id: 1 }  
  3. Tue Mar 18 13:33:48.042 [replslave]      fastBuildIndexdupsToDrop:0  
  4. Tue Mar 18 13:33:48.043 [replslave] build index done.  scanned 1 totalrecords. 0 secs  
  5. Tue Mar 18 13:33:48.062 [replslave] resync: done with initial clone for db:testdb  
  6. Tue Mar 18 13:34:55.757 [initandlisten] connection accepted from127.0.0.1:32942 #1 (1 connection now open)  
  7. Tue Mar 18 13:35:53.979 [replslave] repl:   checkpoint applied 15operations  
  8. Tue Mar 18 13:35:53.979 [replslave] repl:   syncedTo: Mar 18 13:35:445327db30:1  
  9. Tue Mar 18 13:38:06.018 [conn1] end connection 127.0.0.1:32942 (0 connectionsnow open)  
  10. Tue Mar 18 13:38:23.981 [replslave] repl:   checkpoint applied 15operations  
  11. Tue Mar 18 13:38:23.982 [replslave] repl:   syncedTo: Mar 18 13:38:145327dbc6:1 

登录主库管理页面,查看其状态信息(master:1)

wKiom1MvyTWxMctVAAIMcTTMsYk485.jpg

2.mongodb副本集部署

准备环境

服务器IP

服务器角色

系统环境

172.23.214.47

master

DeBian 7

172.23.214.50

Slave

DeBian 7

172.23.215.61

Slave

DeBian 7

首先屏蔽掉配置文件中的master/slave这等敏感信息,将配置文件还原为最初状态

最好配置hosts,如果不指hosts则写ip也可以

编辑配置文件:

3台主机配置文件都相同

  1. root@namenode1:~# grep -v "#" /etc/mongod.conf | grep -v"^$"  
  2.  
  3. logpath=/var/log/mongo/mongod.log  
  4. logappend=true 
  5. fork = true 
  6. port = 27017 
  7. dbpath=/mongo/data  
  8. pidfilepath = /var/run/mongodb/mongod.pid  
  9. replSet = true              #副本集的名字  
  10. rest = true 
  11. maxConns=1024 
  12. oplogSize=2048 

先将master节点启动起来,登录想成为master的主机,启动mongod

  1. root@ namenode2:~# mongod -f /etc/mongod.conf  

进入mongo

  1. root@namenode2:/mongo/data# mongo 

初始化副本集:

  1. >rs.initiate() 

构建对象

  1. {  
  2.     "_id" : "ture",                                         #副本集的名字,要与配置文件对应  
  3.     "members" : [                                           #指定副本集成员  
  4.          {  
  5.              "_id" : 0,                          #指定副本集成员的id号  
  6.              "host" : 172.23.214.47:27017"       #先将master添加进来而后再依次将其他成员添加进副本集  
  7.          }  
  8.     ]  

等待大约30秒钟

  1. > rs.initiate( rsconf )  
  2. {  
  3.     "info" : "Config now savedlocally.  Should come online in about a minute.",       #提示需要等待大约1分钟,如果及时查看副本集内容很可能报错  
  4.     "ok" : 1 

查看副本集

  1. > rs.conf()   

添加slave

  1. true:PRIMARY> rs.add("172.23.214.47:27017")  
  2. { "ok" : 1 }  
  3.  
  4. true:PRIMARY> rs.add("172.23.215.61:27017")  
  5. { "ok" : 1 } 

分别在slave上执行:

  1. true:RECOVERING> rs.slaveOk() 

验证:

在master上创建库:

  1. true:PRIMARY> use testdb;  
  2. switched to db testdb  
  3.  
  4. true:PRIMARY> for(i=1;i<=100;i++) db.testcoll.insert({Name:"User"+i,Age:i,Gender:"M",preferbook:["bluebook","yellow book"]})  

在slave节点上查看数据库,可以看到已经被通过到本地

  1. true:RECOVERING> show dbs;  
  2. local     2.0771484375GB  
  3. testdb    0.203125GB  
  4.  
  5. rs.initiate()//先初始化,再通过rs.add等方法修改  
  6. 这里的config_object会记录在local.system.replset这个集合内,这个集合会自动的在副本集成员之间广播,而且我们不能直接修改他们,需要使用命令来改变它,例如(replSetInitiate 命令)。 

设定某节点的优先级

将一个普通数据节点修改为passive节点,也就是能同步数据、投票,但是不能成为primay 
除了仲裁节点,其他每个节点都有个优先权,我们可以通过设置优先权来决定谁的成为primay的权重最大,MongoDB replica sets中通过设置priority的值来决定优先权的大小,这个值的范围是0--100,值越大,优先权越高。如果值是0,那么不能成为prima

如下所示:

(#这个环境是之前保留的镜像副本,以Host_Name进行添加的)

  1. true:PRIMARY> rs.conf()  
  2. {  
  3.     "_id" : "true",  
  4.     "version" : 3,  
  5.     "members" : [  
  6.          {  
  7.              "_id" : 0,  
  8.              "host" : "namenode1:27017"  
  9.          },  
  10.          {  
  11.              "_id" : 1,  
  12.              "host" : "namenode2:27017"  
  13.          },  
  14.          {  
  15.              "_id" : 2,  
  16.              "host" : "datanode1:27017"  
  17.          }  
  18.     ]  

设置优先级别

#参考http://www.cnblogs.com/Amaranthus/p/3616951.html

  1. true:PRIMARY> cfg.members[0].priority=2   
  2.  
  3. true:PRIMARY> rs.conf()  
  4. {  
  5.     "_id" : "true",  
  6.     "version" : 3,  
  7.     "members" : [  
  8.          {  
  9.              "_id" : 0,  
  10.              "host" : "namenode1:27017"  
  11.  
  12. "priority": 2  
  13.          },  
  14.          {  
  15.              "_id" : 1,  
  16.              "host" : "namenode2:27017"  
  17.          },  
  18.          {  
  19.              "_id" : 2,  
  20.              "host" : "datanode1:27017"  
  21.          }  
  22.     ]  

节点变更

如果需要对副本集进行扩容,例如加入一台mongodb服务器进入副本集,需要先启动这个节点(最好是将数据事先拷贝一份启动,不然一个新的空的数据库进来同步可能会复制过多的数据而导致应用崩溃)

比如我们想将节点datanode1:27017 移除从而新加入节点test:27017

那么首先将集群中的datanode1:27017节点移除

查看节点

  1. true:PRIMARY> rs.status()  
  2. {  
  3.     "set" : "true",  
  4.     "date" : ISODate("2014-03-19T04:38:52Z"),  
  5.     "myState" : 1,  
  6.     "members" : [  
  7.          {  
  8.              "_id" : 0,  
  9.              "name" : "namenode1:27017",  
  10.              "health" : 1,  
  11.              "state" : 1,  
  12.              "stateStr" : "PRIMARY",  
  13.              "uptime" : 9510,  
  14.              "optime" : Timestamp(1395197587, 1),  
  15.              "optimeDate" : ISODate("2014-03-19T02:53:07Z"),  
  16.              "self" : true  
  17.          },  
  18.          {  
  19.              "_id" : 1,  
  20.              "name" : "namenode2:27017",  
  21.              "health" : 1,  
  22.              "state" : 2,  
  23.              "stateStr" : "SECONDARY",  
  24.              "uptime" : 9183,  
  25.              "optime" : Timestamp(1395197587, 1),  
  26.              "optimeDate" : ISODate("2014-03-19T02:53:07Z"),  
  27.              "lastHeartbeat" : ISODate("2014-03-19T04:38:51Z"),  
  28.              "lastHeartbeatRecv" : ISODate("2014-03-19T04:38:51Z"),  
  29.              "pingMs" : 0,  
  30.              "syncingTo" : "namenode1:27017"  
  31.          },  
  32.          {  
  33.              "_id" : 2,                 
  34.              "name" : "datanode1:27017",     #将这个节点删除  
  35.              "health" : 1,  
  36.              "state" : 2,  
  37.              "stateStr" : "SECONDARY",  
  38.              "uptime" : 6345,  
  39.              "optime" : Timestamp(1395197587, 1),  
  40.              "optimeDate" : ISODate("2014-03-19T02:53:07Z"),  
  41.              "lastHeartbeat" : ISODate("2014-03-19T04:38:50Z"),  
  42.              "lastHeartbeatRecv" : ISODate("2014-03-19T04:38:51Z"),  
  43.              "pingMs" : 0,  
  44.              "syncingTo" : "namenode1:27017"  
  45.          }  
  46.     ],  
  47.     "ok" : 1  

移除节点

  1. true:PRIMARY> rs.remove("datanode1:27017")  
  2. Wed Mar 19 12:40:44.497 DBClientCursor::init call() failed  
  3. Wed Mar 19 12:40:44.498 JavaScript execution failed: Error: error doing query:failed at src/mongo/shell/query.js:L78  
  4. Wed Mar 19 12:40:44.498 trying reconnect to 127.0.0.1:27017  
  5. Wed Mar 19 12:40:44.498 reconnect 127.0.0.1:27017 ok 

再次查看副本集状态,发现datanode1已经没有了

  1. true:PRIMARY> rs.status()  
  2. {  
  3.     "set" : "true",  
  4.     "date" : ISODate("2014-03-19T04:41:03Z"),  
  5.     "myState" : 1,  
  6.     "members" : [  
  7.          {  
  8.              "_id" : 0,  
  9.              "name" : "namenode1:27017",  
  10.              "health" : 1,  
  11.              "state" : 1,  
  12.              "stateStr" : "PRIMARY",  
  13.              "uptime" : 9641,  
  14.              "optime" : Timestamp(1395204044, 1),  
  15.              "optimeDate" : ISODate("2014-03-19T04:40:44Z"),  
  16.              "self" : true  
  17.          },  
  18.          {  
  19.              "_id" : 1,  
  20.              "name" : "namenode2:27017",  
  21.              "health" : 1,  
  22.              "state" : 2,  
  23.              "stateStr" : "SECONDARY",  
  24.              "uptime" : 19,  
  25.              "optime" : Timestamp(1395204044, 1),  
  26.              "optimeDate" : ISODate("2014-03-19T04:40:44Z"),  
  27.              "lastHeartbeat" : ISODate("2014-03-19T04:41:02Z"),  
  28.              "lastHeartbeatRecv" : ISODate("2014-03-19T04:41:03Z"),  
  29.              "pingMs" : 0,  
  30.              "lastHeartbeatMessage" : "syncing to: namenode1:27017",  
  31.              "syncingTo" : "namenode1:27017"  
  32.          }  
  33.     ],  
  34.     "ok" : 1  

接着配置启动test节点并启动,配置文件是相同的,启动之后它会自动复制数据。如果数据量过大,还是建议事先通过其它机制同步数据

在master加入新节点

  1. true:PRIMARY> rs.add("test:27017")  
  2. { "ok" : 1 } 

查看状态

  1. true:PRIMARY> rs.status()  
  2. {  
  3.     "set" : "true",  
  4.     "date" : ISODate("2014-03-19T04:43:08Z"),  
  5.     "myState" : 1,  
  6.     "members" : [  
  7.          {  
  8.              "_id" : 0,  
  9.              "name" : "namenode1:27017",  
  10.              "health" : 1,  
  11.              "state" : 1,  
  12.              "stateStr" : "PRIMARY",  
  13.              "uptime" : 9766,  
  14.              "optime" : Timestamp(1395204185, 1),  
  15.              "optimeDate" : ISODate("2014-03-19T04:43:05Z"),  
  16.              "self" : true  
  17.          },  
  18.          {  
  19.              "_id" : 1,  
  20.              "name" : "namenode2:27017",  
  21.              "health" : 1,  
  22.              "state" : 2,  
  23.              "stateStr" : "SECONDARY",  
  24.              "uptime" : 144,  
  25.              "optime" : Timestamp(1395204185, 1),  
  26.              "optimeDate" : ISODate("2014-03-19T04:43:05Z"),  
  27.              "lastHeartbeat" : ISODate("2014-03-19T04:43:06Z"),  
  28.              "lastHeartbeatRecv" : ISODate("2014-03-19T04:43:07Z"),  
  29.              "pingMs" : 0,  
  30.              "syncingTo" : "namenode1:27017"  
  31.          },  
  32.          {  
  33.              "_id" : 2,  
  34.              "name" : "test:27017",  
  35.              "health" : 1,  
  36.              "state" : 6,  
  37.              "stateStr" : "UNKNOWN",  
  38.              "uptime" : 3,  
  39.              "optime" : Timestamp(0, 0),  
  40.              "optimeDate" : ISODate("1970-01-01T00:00:00Z"),  
  41.              "lastHeartbeat" : ISODate("2014-03-19T04:43:07Z"),  
  42.              "lastHeartbeatRecv" : ISODate("1970-01-01T00:00:00Z"),  
  43.              "pingMs" : 0,  
  44.              "lastHeartbeatMessage" : "still initializing"  
  45.          }  
  46.     ],  
  47.     "ok" : 1  

切换至test节点查看数据库

  1. root@test:/var/log/mongo# mongo  
  2. MongoDB shell version: 2.4.5  
  3. connecting to: test  
  4. true:SECONDARY> show dbs;  
  5. admin     (empty)  
  6. local     2.0771484375GB  
  7. testdb    0.203125GB  
  8. true:SECONDARY> rs.slaveOk() 

部署Sharding集群

sharding通过将数据集分布于多个也称作分片(shard)的节点上来降低单节点的访问压力。每个分片都是一个独立的数据库,所有的分片组合起来构成一个逻辑上的完整意义的数据库。因此,分片机制降低了每个分片的数据操作量及需要存储的数据量

sharding的实现思路

选择一个合适索引而减少索引量,这种索引叫做重复索引

能够在索引中直接查找到所有要查询的索引,叫做覆盖索引,能够满足覆盖索引的条件并且排序次序又能够与索引的次序相同,这种次序是"3星"的

所以任何时候创建索引的目的一定要与搜索码完全匹配,至少保持一致

mongodb中可以使用db.mycoll.find().hint().explain()

来显示索引的查询过程mysql中可以使用 explain select XXX

副本集的集群在刚开始配置的时候有以下几个细节:

1、初始化:根据定义好的配置文件初始化,也可以让其系统本身进行简单初始化

2、简单初始化只是将同一个repiset节点的信息添加进来,但默认只初始化当前节点信息

如果想重新配置这个集群的话,可以实现将现有的配置信息读取出来而后在里面做设置之后并重新让后续的配置生效,而也可以在后续新增节点到集群中也可以将已经运行的节点从集群中移除出去,不管是新增和移除它们之间都会进行选举操作的

mongodb shard架构

1、config server : 元数据服务器,3台,1台为单点故障,而如果使用2台在选举时候,会无法得到分布式  (zookeeper)在实验环境中有一个即可

2、mongos:路由,默认端口27017 ,启动的时候必须制定其config server为其指路

3、shard:能够存储分片的服务,可以是独立的服务器,也可以是replica set(副本集,生成环境建议使用此类型),因此生成环境中,一般都需要部署这样的集群

sharding集群

sharding目的:

·当单个节点所持有的数据太大,单个节点无法存储下的时候需要做shard

·如果某个单节点所持有的数据集太大,一个节点无法存储下的时候,则需要做shard

·如果某个单节点承载的读写并发请求过大时

·可预见的时间内,单个节点索引、经常被访问数据量,难在内存容纳下的时候,意味着可能用到swap,如果使用swap那么性能显著下降,对于此种情况需要用到shard

sharding主要做法无非将一个数据分割为多块,平局分布在各个节点,为了保证读写的性能,那么读的操作则不做离散,而写操作需要做离散操作

所以,mongodb主要是根据sharding key来决定分片切割的:

sharding key就是collection的索引,而collection的索引(sharding key)的选择至关重要。通常是第一个shard,也就是主shard

在shard上使用索引

使用顺序索引:

使用顺序插入时,写操作会集中在有限的shard上这样写操作很难均匀分布

使用离散索引:

会被分散到各节点中去,很难提高读性能

如何使用sharding key

假设我们数据库中有个表,表内数据分别为name,Age,Gender, 那么假设将一个collection 按照name切割,而name上创建的索引而是顺序索引,那就意味着是按范围进行切割的,那切割完成之后,那我们经常按照name查询,一般问题不大,查询的请求只交给config server即可,config server可以帮我们完成路由,而name则是charding key。

config server中保存的是每个shard和它所持有的数据的key的范围

以Age为例

如果是范围分区的话,那么我们想查询年龄在0-30岁的时候,则在哪个shard上则会保存在config server上?如果找不到响应的内容,那么则要对其进行全shard扫描

如果是离散的话,那么30在哪个服务器 40在哪里 。。等 config server全都会有记录

对应的key条目和它所对应的shard映射信息就是元数据,就在config server上

那如果我们对name来创建的,那么非常明显config server上所创建的就是某个名字和shard的映关系

所以如果按照age来进行查找的话,则没有办法去查找,那么这时则全shard扫描

如果大多数查询都是根据age来查询,而我们非选择sharding key为name 那么麻烦就大了

所以选择sharding key至关重要

真正选择shard的话 需要根据业务模型来选择的,一定要明白选择标准是什么。

sharding选择思路:

如果选择一个sharding key之后 有可能导致写不均匀,但做shard主要目的是离散写入均匀,所以我们在选择key的时候尽可能

1、尽可能范围选择shard

2、一旦落在某个shard以后仍然会变得过大,我们可以再进行将各chunk分布出去,则可以使用自合索引,比如:

将name和age同时当做sharding key 来使用

{name:1,age: 1}  #先根据name做分区,意味着作为name的范围匹配了之后落在同一个shard上会根据age再次分区,如果内容量过大的话,会再次分割开的而不会单独在这shard上操作

3、也可以使用三级索引

{name:1,age: 1,preferbooks} 有时我们存储了大量的数据进去,其会先对name进行分割发现落在某个shard的量过大,它会根据age再次分割,而后再次根据prefer books再次分割 这样可以使得写操作均匀分布,同样如果根据name范围查找的话,本来第一次分割是根据name分割的,很显然在一个范围内的用户通常会落在有限的shard上,所以读操作也做到了集中

在真正集群业务中并不是每个表都可以做shard的

比如有时候做shard可能带来很多问题

以博客为例:

我们以用户名做了shard 结果不同的用户可能被切割到不同shard中去,一个用户所发布的博文信息以及每个博文下的评论信息,每个用户发布的评论可能被存放在当前用户的shard上,当某个用户想查看自己博文下的所有评论信息的时候,那么评论的shard可能来自于多个用户,那么我对用户做了shard,也就意味着这些信息是根据用户所存储的 对应的用户所发布的评论也就有可能分布到多个shard上去 由此某个用户想查看自己博文下的所有评论,那么则会对其做全shard扫描,因此根据name来切割则是行不通的

以上的这种情况只能使用多个键

先根据文章和评论进行切割再根据用户名进行切割,意味着文章为标准,但同一个用户则放在有限的shard上去,这就是组合索引的好处

(尽可能保证前端的查询操作过于分散,这样就可以保证可以查询同一个或有限的shard)

如果文章与评论不是同一类的话:

那么既要考虑用户 又要考虑文章与评论 既然做分区了,如果用户本身信息量不是特别大的话,那么可以将一些有关联的表单独存放在一个库中

分片最主要的因素是选择sharding key

选择sharding key的标准:

1、应该在哪存数据

2、应该在哪得到希望的数据 

读数据尽可能来自同一个点,写数据尽可能分散处理

夸分片做查询,比单个分片查询性能要差 但是只要不是太多的分片(2-3个)那么让读只落在有限的分片

总结:sharing基本法则

1、sharing key 应该是主键

2、选择分sharding key的时候应该选择那些避免跨分片查询,但是又得保证写是均匀的

3、将有关联的表放置在独立库中

部署分片集群

规划:

服务器IP

服务器角色

操作系统

172.23.215.61

config server、mongos、mongod

Debian GNU/Linux 7.2

172.23.214.50

config server、mongos、mongod

Debian GNU/Linux 7.2

172.23.214.47

mongos、mongod

Debian GNU/Linux 7.2

配置文件路径:

  1. /mongo/etc/configsvr.conf  
  2.  
  3. /mongo/etc/mongod.conf  
  4.  
  5. /mongo/etc/mongos.conf 

日志路径:

  1. config server      /var/log/mongo/mongod_config_server.log  
  2.  
  3. mongod             /var/log/mongo/mongod.log  
  4.  
  5. mongos             /var/log/mongo/mongos.log 

数据存放路径:

  1. /mongo/data/configdb  
  2.  
  3. /mongo/data/configsvr  
  4.  
  5. /mongo/data/mongod 

1.建立副本集

修改各节点配置文件,如下所示:

  1. root@datanode1:/mongo/etc# cat mongod.conf  | grep -v "#"  
  2. logpath=/var/log/mongo/mongod.log  
  3. logappend=true 
  4. fork = true 
  5. port = 27017 
  6. dbpath=/mongo/data  
  7. pidfilepath = /var/run/mongodb/mongod.pid  
  8. replSet = rs0 
  9. rest = true 
  10. maxConns=1024 
  11. oplogSize=2048 

启动各个节点mongod

  1. root@datanode1:/mongo/etc# mongod -f mongod.conf  

将master添加进副本集

  1. root@datanode1:/mongo/etc# mongo> rsconf = { _id: "rs0",members: [ { _id: 0, host: "172.23.215.61:27017" } ] }  
  2.  
  3. {  
  4.     "_id" : "rs0",  
  5.     "members" : [  
  6.          {  
  7.              "_id" : 0,  
  8.              "host" : "172.23.215.61:27017"  
  9.          }  
  10.     ]  
  11. }  
  12.  

激活副本集

  1. > rs.initiate( rsconf )  
  2. {  
  3.     "info" : "Config now savedlocally.  Should come online in about a minute.",  
  4.     "ok" : 1  
  5. }  
  6. > rs.conf()  
  7. {  
  8.     "_id" : "rs0",  
  9.     "version" : 1,  
  10.     "members" : [  
  11.          {  
  12.              "_id" : 0,  
  13.              "host" : "172.23.215.61:27017"  
  14.          }  
  15.     ]  
  16. }  

陆续添加mongod节点

  1. rs0:PRIMARY> rs.add("172.23.214.50:27017")  
  2.  
  3. rs0:PRIMARY> rs.add("172.23.214.47:27017") 

查看成员

  1. rs0:PRIMARY> rs.conf()  
  2.  
  3. {  
  4.  
  5.     "_id" :"rs0",  
  6.  
  7.     "version" : 3,  
  8.  
  9.     "members" : [  
  10.  
  11.         {  
  12.  
  13.              "_id" : 0,  
  14.  
  15.              "host" :"172.23.215.61:27017"  
  16.  
  17.         },  
  18.  
  19.         {  
  20.  
  21.              "_id" : 1,  
  22.  
  23.              "host" :"172.23.214.50:27017"  
  24.  
  25.         },  
  26.  
  27.         {  
  28.  
  29.              "_id" : 2,  
  30.  
  31.              "host" :"172.23.214.47:27017"  
  32.  
  33.         }  
  34.  
  35.     ]  
  36.  

测试:

新建集合并插入数据,在从库查看是否同步

  1. rs0:PRIMARY> use test11;  
  2. switched to db test11  
  3. rs0:PRIMARY> for(i=1;i<=100;i++)db.testcoll.insert({Name:"User"+i,Age:i,Gender:"M",preferbook:["bluebook","yellow book"]}) 

去从库查看

  1. rs0:SECONDARY> show dbs;  
  2. local     2.0771484375GB  
  3. test11     0.203125GB  
  4. testdb     0.203125GB 

2.配置config server

新建立配置文件,各节点内容相同

  1. root@datanode1:/mongo/etc# cat configsvr.conf   
  2. configsvr=true 
  3. dbpath=/mongo/data/configdb/  
  4. port=27019 
  5. logpath=/var/log/mongo/mongod_config_server.log  
  6. logappend=true 
  7. fork=true 

启动config server

  1. root@datanode1:/mongo/etc# mongod -f configsvr.conf 

查看端口是否被监听

  1. root@datanode1:/mongo/etc# netstat -lnt | grep 27  
  2.  
  3. tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN       
  4.  
  5. tcp        0      0 127.0.0.1:25            0.0.0.0:*               LISTEN       
  6.  
  7. tcp        0      0 0.0.0.0:27017           0.0.0.0:*               LISTEN       
  8.  
  9. tcp        0      0 0.0.0.0:27019           0.0.0.0:*               LISTEN  

3.配置mongos

  1. root@datanode1:/mongo/etc# cat mongos.conf   
  2.  
  3. # mongo.conf  
  4.  
  5. port=27020 
  6.  
  7. configdb=172.23.215.61:27019,172.23.214.47:27019,172.23.214.50:27019       #指定各config server的ip地址或hostname,以及端口  
  8.  
  9. fork = true 
  10.  
  11. logpath=/var/log/mongo/mongos.log  
  12.  
  13. chunkSize = 100 
  14.  
  15. logappend = true 

启动路由(mongos)

  1. root@datanode1:/mongo/etc# mongos -f mongos.conf 

使用mongo命令连入mongos实例

  1. root@datanode1:/mongo/etc#  mongo 172.23.215.61:27020 

向分区集群中添加各shard服务器或副本集,如果添加的shard是副本集,则需要使用如下格式:

  1. mongos> sh.addShard("rs0/172.23.215.61:27017")  
  2.  
  3. { "shardAdded" : "rs0", "ok" : 1 }  

查看状态

  1. mongos>  sh.status()  
  2. --- Sharding Status ---   
  3.  sharding version: {  
  4.     "_id" : 1,  
  5.     "version" : 3,  
  6.     "minCompatibleVersion" : 3,  
  7.     "currentVersion" : 4,  
  8.     "clusterId" :ObjectId("532fa07065574826130abfbf")  
  9. }  
  10.  shards:  
  11.     {  "_id" : "rs0", "host" :"rs0/172.23.214.47:27017,172.23.214.50:27017,172.23.215.61:27017" }  
  12.  databases:  
  13.     {  "_id" : "admin", "partitioned" : false,  "primary" : "config"}  
  14.     {  "_id" : "test11", "partitioned" : false,  "primary" : "rs0" }  
  15.     {  "_id" : "testdb", "partitioned" : false,  "primary" : "rs0" } 

4.启用sharding功能

mongodb的shard功能实现于collection级别,但若要在collection上启动shard,还需要事先其相关的数据库上启用之。在数据库上启用shard功能后,MongoDB会为其指定一个主shard。

激活数据库分片

  1. switched to db adminmongos  
  2.  
  3. mongos> db.runCommand( { enablesharding : "test11" } );  
  4. { "ok" : 1 }  
  5. mongos> db.runCommand( { enablesharding : "testdb" } );  
  6. { "ok" : 1 }  

激活collection分片

  1. mongos> use test11  
  2.  
  3. mongos> show collections  
  4. system.indexes  
  5. testcoll           #将此表进行激活  

进入admin库,激活collection分片并配置shard key唯一

  1. >use admin  
  2.  
  3. mongos> db.runCommand( { shardcollection : "test11.testcoll",key : {_id : 1 } , unique : true  } )  
  4. { "collectionsharded" : "test11.testcoll", "ok" :1 }  

查看分片状态信息

  1. mongos> db.printShardingStatus();  
  2. --- Sharding Status ---   
  3.  sharding version: {  
  4.     "_id" : 1,  
  5.     "version" : 3,  
  6.     "minCompatibleVersion" : 3,  
  7.     "currentVersion" : 4,  
  8.     "clusterId" :ObjectId("532fa07065574826130abfbf")  
  9. }  
  10.  shards:  
  11.     {  "_id" : "rs0", "host" :"rs0/172.23.214.47:27017,172.23.214.50:27017,172.23.215.61:27017" }  
  12.  databases:  
  13.     {  "_id" : "admin", "partitioned" : false,  "primary" : "config"}  
  14.     {  "_id" : "test11", "partitioned" : true,  "primary" : "rs0" }  
  15.          test11.testcoll  
  16.              shard key: { "_id" : 1 }  
  17.              chunks:  
  18.                   rs0     1  
  19.              { "_id" : { "$minKey" : 1 } } -->> { "_id": { "$maxKey" : 1 } } on : rs0 Timestamp(1, 0)   
  20.     {  "_id" : "testdb", "partitioned" : true,  "primary" : "rs0" }  
  21.     {  "_id" : "test", "partitioned" : false,  "primary" : "rs0" } 

博文链接:http://yijiu.blog.51cto.com/433846/1382239

【编辑推荐】

相关文章推荐

采用Replica Sets + Sharding方式搭建MongoDB高可用集群

3.搭建 3.1环境准备   在 Mongo 的官网下载 Linux 版本安装包,然后解压到对应的目录下;由于资源有限,我们采用 Replica Sets + Sharding 方...
  • xincai
  • xincai
  • 2017年04月19日 13:55
  • 286

mongodb集群(Replica Sets+Sharding)

Shard:    使用replica sets,确保每个数据结点都具有备份、自动容错转移、自动恢复能力。 Config:    使用3个配置服务器,确保元数据完整性; Route: 使用3个路由进程...

mongodb分片集群(sharding with replica set)配置

一共有4台机器,各自挂接一个存储,希望实现:尽量节约存储高可用性存储大量数据配置方案:每一台机器做一个分片的主数据库每一台机器做一个分片的后备数据库每一台机器做一个分片的仲裁服务两个两个一组交叉作对方...

Mongodb集群配置(sharding with replica set)

长期以来我就对分布式系统原理与实践非常感兴趣,对于Mongodb我一直很好奇,最近终于有时间能动手实验一把!我在一台Windows机器下搭建了一个 Replica Sets + Sharding 测试...

转:mongodb分片集群(sharding with replica set)配置

一共有4台机器,各自挂接一个存储,希望实现:尽量节约存储高可用性存储大量数据配置方案:每一台机器做一个分片的主数据库每一台机器做一个分片的后备数据库每一台机器做一个分片的仲裁服务两个两个一组交叉作对方...

MongoDB集群搭建

  • 2016年06月29日 11:25
  • 393KB
  • 下载

利用Mongodb的复制集搭建高可用分片,Replica Sets + Sharding的搭建过程

http://blog.itpub.net/26230597/viewspace-1098147/ 参考资料 reference:  http://mongodb.b...

MongoDB集群搭建过程

  • 2012年07月16日 16:04
  • 17KB
  • 下载

高可用mongodb集群搭建

  • 2017年04月06日 15:12
  • 411KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:MongoDB集群搭建及Sharding的实现思路
举报原因:
原因补充:

(最多只允许输入30个字)