`
wbj0110
  • 浏览: 1610074 次
  • 性别: Icon_minigender_1
  • 来自: 上海
文章分类
社区版块
存档分类
最新评论

mongodb分布式集群架构

MongDB 
阅读更多

一、关于mongodb

 

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。 MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

 

二、mongodb分布式应用原理

 

MongoDB集群包括一定数量的mongod（分片存储数据）、mongos（路由处理）、config server（配置节点）、clients（客户端）、arbiter（仲裁节点：为了选举某个分片存储数据节点那台为主节点）。

 

 

  1. 1、shards：一个shard为一组mongod，通常一组为两台，主从或互为主从，这一组mongod中的数据时相同的，具体可见《mongodb分布式之数据复制》。数据分割按有序分割方式，每个分片上的数据为某一范围的数据块，故可支持指定分片的范围查询，这同google的BigTable 类似。数据块有指定的最大容量，一旦某个数据块的容量增长到最大容量时，这个数据块会切分成为两块；当分片的数据过多时，数据块将被迁移到系统的其他分片中。另外，新的分片加入时，数据块也会迁移。

  2. 2、mongos：可以有多个，相当于一个控制中心，负责路由和协调操作，使得集群像一个整体的系统。mongos可以运行在任何一台服务器上，有些选择放在shards服务器上，也有放在client 服务器上的。mongos启动时需要从config servers上获取基本信息，然后接受client端的请求，路由到shards服务器上，然后整理返回的结果发回给client服务器。

  3. 3、config server：存储集群的信息，包括分片和块数据信息。主要存储块数据信息，每个config server上都有一份所有块数据信息的拷贝，以保证每台config server上的数据的一致性。

  4. 4、shard key：为了分割数据集，需要制定分片key的格式，类似于用于索引的key格式，通常由一个或多个字段组成以分发数据，比如：

  5. { name : 1 }

  6. { _id : 1 }

  7. { lastname : 1, firstname : 1 }

  8. { tag : 1, timestamp : -1 }

  9. mongoDB的分片为有序存储(1为升序，-1为降序)，shard key相邻的数据通常会存在同一台服务

  10. （数据块）上。

三、mongodb分布式部署方式

服务器部署可以有多种方式。首先，每台config server、mongos、mongod都可以是单独的服务器，但这样会导致某些服务器的浪费，比如config server。下图为物理机共享的集群部署，不需要额外加机器。

 

 

当然也有其他的方案，比如把mongos部署在所有的mongod（server1-6）上，又或者在每个运用服务器（server7）上部署mongos。这样部署有个好处在于，appserver和mongos之间的通信建立在localhost interface上，减少了通信成本。当然，此乃官方说法，但本人有想法，尽管减少了appserver和mongos之间的通信成本，但mongos与mongod之间的通信成本却增加了，而且把mongos部署在appserver上并不是很利于sa管理，mongoDB应该是一个相对独立的系统，与应用的耦合度应该尽量降到最低，万一应用想要换数据库，也能多少减少些工作量。

 

四、mongodb分布式的安装

1、下载

  1. wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.0.4.tgz

2、安装

  1. tar zxvf mongodb-linux-2.0.4.tgz

  2. cp -fr mongodb-linux-*2.0.4/* /data/mongodb/

  3. mkdir -p /data/mongodb/data/                                     #创建数据存储目录

  4. mkdir -p /data/mongodb/log/                                      #创建日志存储目录

  5. mkdir -p /data/mongodb/config/                                   #创建配置存储目录

  6. mkdir -p /data/mongodb/arbiter/                                  #创建仲裁节点存储目录

3、单机模式以及个参数说明

  1. mongod --fork --bind_ip 127.0.0.1 --port 11811 --dbpath /data0/mongodb/data --directoryperdb --logpath /data0/mongodb/log/db1.log --logappend  --nohttpinterface

  2. netstat -ntlp|grep mongod

 

  1. 简单的参数说明：

  2. –logpath 日志文件路径

  3. –master 指定为主机器

  4. –slave 指定为从机器

  5. –source 指定主机器的IP地址

  6. –pologSize 指定日志文件大小不超过64M.因为resync是非常操作量大且耗时，最好通过设置一个足够大的oplogSize来避免resync(默认的 oplog大小是空闲磁盘大小的5%)。

  7. –logappend 日志文件末尾添加

  8. –port 启用端口号

  9. –fork 在后台运行

  10. –only 指定只复制哪一个数据库

  11. –slavedelay 指从复制检测的时间间隔

  12. –auth 是否需要验证权限登录(用户名和密码)

  13. –noauth 不需要验证权限登录(用户名和密码)

五、集群模式mongos,mongod,configsvr

  1. 1.Shard分片--

  2. 第一组分片  

  3. 192.168.200.226:    

  4. /data/mongodb/bin/mongod --replSet rep1 --fork --port 11813 --maxConns 65535 --dbpath /data/mongodb/data --directoryperdb --logpath /data/mongodb/log/db.log --logappend --nohttpinterface

  5. #启动rep1分片的一个数据节点

  6. /data/mongodb/bin/mongos --configdb 192.168.201.226:11812 --port 11811 --fork --chunkSize 256 --logpath /data/mongodb/log/ms.log   #启动路由节点，读取201.226上的配置节点的配置文件，（在配置节点启动后启动）

  7. /data/mongodb/bin/mongod --replSet rep1 --fork --port 11814 --dbpath /data/mongodb/arbiter --directoryperdb --logpath /data/mongodb/log/arbiter.log --logappend --nohttpinterface

  8. #启动分片的仲裁节点

  9. 192.168.201.226:    

  10. /data/mongodb/bin/mongod --replSet rep1 --fork --port 11813 --maxConns 65535 --dbpath /data/mongodb/data --directoryperdb --logpath /data/mongodb/log/db.log --logappend --nohttpinterface

  11. #启动rep1分片的第二个数据节点

  12. /data/mongodb/bin/mongos --configdb 192.168.201.226:11812 --port 11811 --fork --chunkSize 256 --logpath /data/mongodb/log/ms.log

  13. #启动第二个路由节点 （在配置节点启动后启动）

  14. 2.ConfigServer---

  15.    #启动config server  

  16.    192.168.201.226:    

  17.        /data/mongodb/bin/mongod --configsvr --dbpath /data/mongodb/config --port 11812 --fork --logpath /data/mongodb/log/mc.log

  18. #启动配置节点，注意配置节点应该优先启动，不然路由节点读取不到配置节点信息则会启动失败。

  19. 3.Mongos路由---

  20.    #启动mongos，指定config server, chunkSize 256M

  21.    192.168.201.226:

  22.        /data/mongodb/bin/mongos --configdb 192.168.201.226:11812 --port 11811 --fork --chunkSize 256 --logpath /data/mongodb/log/ms.log

  23. #启动路由节点

由于机器有限，只配置了一个shard分片，该分片里有2个节点，新增加分片只需对应改replSet 名称即可。

  1. 4.配置replSet: 连接任一mongod members

  2. mongo 192.168.201.226:11813

  3. config = {_id: 'rep1', members: [

  4. {_id: 0, host: '192.168.200.226:11813', priority: 2},                    #priority 为定义优先级，默认为1，高优先级会被认为是主节点优先启用。

  5. {_id: 1, host: '192.168.201.226:11813'},

  6. {_id: 2, host: '192.168.200.226:11814', arbiterOnly: true}]

  7. }

  8.    rs.initiate(config);

  9.    rs.status()

 

  1. 5.连接mongos增加shard 80G

  2.    mongo 192.168.201.226:11811/admin

  3.    show dbs

  4.    use admin

  5.    db.runCommand({addshard:'rep1/192.168.201.226:11813,192.168.200.226:11813',maxsize:81920})

  6.    db.runCommand({listshards:1})

 

  1. 6.连接mongos增加创建test库和c1集合，并测试

  2.    mongo 192.168.201.226:11811/admin

  3.    db.runCommand({enablesharding:'test'})

  4.    printShardingStatus()

  5.    db.runCommand({shardcollection:'test.auto_increment_id', key:{_id:1}, unique : true})

  6.    db.runCommand({shardcollection:'test.c1', key:{_id:1}, unique : true})

  7.    for (var i = 1; i <= 100; i++)db.c1.save({id:i,value1:"1234567890",value2:"1234567890",value3:"1234567890",value4:"1234567890"})

  8.    db.c1.stats()

  9. db.createCollection("cap_coll", {capped:true, size:100000, max:100});

  10. db.mycoll.validate();

  11.  

  12. 7.检查： db.printCollectionStats()

  13.  

  14. 8.管理: mongo 127.0.0.1:11811

  15. show dbs

  16. use admin

  17. show collections

  18. db.serverStatus()

  19. db.shutdownServer()

  20. exit

 

  1. 9.索引：

  2. db.product_data.ensureIndex({data_id: 1}, {unique: true,dropDups: true}); #创建索引

  3. db.product_data.dropIndexes();                                           #删除索引

 

至此，mongodb的分布式架构就架起来了，并且通过测试和log的分析，可看服务是否正常，下面就需要php客户端的支持，和程序的运行，之后加到监控里，就可以在线上部署使用了。

 

六、PHP的MongoDB拓展的安装

  1. # wget http://pecl.php.net/get/mongo-1.2.6.tgz    

  2. # tar zxvf mongo-1.2.6.tgz    

  3. # cd mongo-1.2.6    

  4. # /usr/local/php5/bin/phpize    

  5. # ./configure --enable-mongo=share--with-php-config=/usr/local/php5/bin/php-config    

  6. # make && make installl  

PHP支持mongodb

  1. 将生成的拓展mongo.so文件添加到php.ini中，重启php-fpm，或者apache，然后查看下phpinfo()

  2. 请编辑php.ini文件。添加如下一行：

  3. extension=mongo.so

  4. 然后用php输出:phpinfo，就可以看到mongo的信息了。。这样就说明你安装成功的了！

 

七、监控配置：

     早在去年已经出现MongoDB和Redis的Cacti模板，使用它，你可以对你的MongoDB和Redis服务进行流量监控。cacti的模板一直在更新，若企业已经用到nosql这种非关系数据库如mongodb和redis。可按照以下教程，对mongodb和redis进行监控。

该模板可以监控以下资源：

mongodb：

redis：

 

一、下载模板：

wget http://mysql-cacti-templates.googlecode.com/files/better-cacti-templates-1.1.8.tar.gz

二、配置ssh公私钥无需密码登录：

因为cacti监控mongodb是需要登录到mongodb的服务端运行mongo的状态获取命令，所以需要ssh连接登录。

所以需要配置非交互式帐号密码登录。这里采用公私钥模式。

先在监控服务器生成一对公私钥。

 

  1. ssh-keygen ##如果是root用户，生成的默认目录为/root/.ssh下2个文件id_rsa（公钥） id_rsa.pub（私钥）

  2. cd /root/.ssh/ && chmod 600 id_rsa*     把这2个文件修改权限，为600

  3. ssh-copy-id -i /root/.ssh/id_rsa root@192.168.200.1  #加被监控节点公私钥认证

把id_rsa.pub复制出来，放到被监控机器上，然后公钥的内容追加到需要被监控的主机也就是mongodb和redis的服务端。追加到.ssh/authorized_keys

然后用ssh连接你所安装mongodb或者redis的服务端，如果不需输密码连接上。则正常。下面就可以开始添加监控文件了。

三、配置监控脚本：

 

  1. mongodb或redis的监控所需到的是你下载目录中的better-cacti-templates-1.1.8\scripts下的

  2. ss_get_by_ssh.php 这个脚本 这个脚本需要放在cacti的服务端。

  3. 如果你cacti是装到/var/www/html/cacti/目录下。

  4. 把该文件放在其下面的scripts目录下。别忘了看下权限。要有执行权限。

然后修改该文件。主要修改一下选项，大概在40行。

  1. # ============================================================================

  2. $ssh_user   = 'root';                          # SSH username

  3. $ssh_port   = 22;                               # SSH port

  4. $ssh_iden   = '-i /root/.ssh/id_rsa';     # SSH identity

  5. ##修改根据你的配置，你的ssh连接用户，还有认证私钥的位置。

大该在50行，还可以修改其默认的去探测的端口（如果redis不是正常默认端口启动需要修改这些）。

  1. $memcache_port = 11211;                   # Which port memcached listens on

  2. $redis_port    = 6379;                    # Which port redis listens on

如果是mongodb不是正常端口启动，则需要这样修改。找到以下字段，添加红色字段，这里注意mongo这个命令一定要找对。

  1. function mongodb_cmdline ( $options ) {

  2. return “echo \”db._adminCommand({serverStatus:1, repl:1})\” | /usr/local/mongo/mongodb/bin/mongo –port 10000″;

  3. }

配置完后保存退出。

可以先用测试命令测一下。语法如下：

  1. php /var/www/html/scripts/ss_get_by_ssh.php --type mongodb --host 192.168.200.1 --items c,de,df,dg,dh,di,dj,dk,dl,dm,dn,do,dp,dq,dr,ds,dt,du

如果有数据输出。则表示正常。

 

四、在cacti里添加mongodb和redis模板：

4.1 模板导入

模板目录为better-cacti-templates-1.1.8\templates

4.2 导入后对被监控机添加模板：

4.3 添加后为其绘图：

五：实际效果测试：

 

 

 

 

other:http://hi.baidu.com/lzpsky/item/d19f872ad8fe8385ae48f527

http://ylw6006.blog.51cto.com/470441/1123826

=========================================================================================

 MongoDB的部署方案如下：

采用Replica Sets的集群方案，这个方案与Master-Slave Replication的集群方案类
似，数据服务器也有主从的区别。优点是主数据服务器或从数据服务器挂掉后，会自动
切换主数据库，不用人工干预，稳定性比Master-Slave Replication。缺点是需要客户
端的驱动支持，因为客户端在与主服务器连接失败后，会向集群的其他服务器发一条特
殊的指令询问，谁是新的主数据服务器。集群的服务器在不做分区的前提下，分成三
种，主数据服务器，从数据服务器，选举服务器（只做投票不存储数据），若做数据分
区还有配置服务器。

具体服务器部署分配如下：

192.168.56.73（windows）：部署一个选举服务器的服务
192.168.56.71(Linux)：主数据服务器
192.168.56.72(Linux)：从数据服务器



部署方法：
步骤一：在三台服务器启动mongodb服务，Windows和Linux都类似，只是文件路径有部

分差别。指令如下：mongod --replSet car(集群名称) --port 25017(端口) --dbpath

/usr/local/mongodb/bin/mongod --replSet car --port 25017 --dbpath=/data/mongodb --logpath /var/log/mongo/mongodb_log --oplogSize=512 &

E:\mongodb-test\data1(数据文件路径)
步骤二：用mongo命令行工具连接mongo服务器，并配置集群服务，指令如下：
config = {_id:'car',members:[ {_id:0,host:'192.168.6.71:25017'},{_id:1,host:'192.168.56.72:25017',initialSync : { state : 1}},{_id:2,host:'192.168.56.73:25017',arbiterOnly : true}]}


rs.initiate(config)
rs.status()

步骤三：修改客户端的连接字符串：

value="mongodb://192.168.56.71:25017,
192.168.56.72::25017/?connect=replicaSet;replicaSet=car" />

最后提醒mongodb旧的 1.6.5不支持 集群的一些参数例如 initialSync arbiterOnly等等.

最好用最新版本.

===============================================================================================================================

 

 

第一节 准备工作
 一 安装mongodb
  我这里选用rehl 5.6作为其运行载体。
  1. 下载mongodb的linux版本(注意32位和64位的区别)，下载地址：http://www.mongodb.org/downloads
   # wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.0.4.tgz
  2. 将下载的mongodb安装文件 mongodb-linux-x86_64-2.0.4.tgz 放到/usr/local/下
  3. 解压 
   # tar -zxvf mongodb-linux-x86_64-2.0.4.tgz
   重命名 
   # mv mongodb-linux-x86_64-2.0.4 /usr/local/mongodb
  4. 创建数据库文件目录， # mkdir -p /data/mongodb,我把数据库文件目录放在当前文件夹下，# mkdir -p data/db,创建日志目录 #mkdir -p log
  
 二 启动
  首先用命令进入到bin目录下：cd /usr/local/mongodb/bin
  
  方式一：直接运行命令启动
  ./mongod –port 10000 –fork –logpath= logpath=/data/mongodb/log/mongodb.log -- logappend -- dbpath=/data/mongodb/data/db
  
  方式二：通过配置文件方式启动（推荐）。
  1.在服务器上新建mongodb.conf配置文件(建议用命令生成，放在mongodb同一个目录下)
  内容为：
  port=10000 #端口号
  fork=true #以守护进程的方式运行，创建服务器进程
  #master=true #单主从配置时设为主服务器
  #salve=true ##单主从配置时设为从服务器
  logpath=/data/mongodb/log/mongodb.log #日志输出文件路径
  logappend=true #日志输出方式
  dbpath=/data/mongodb/data/db #数据库路径
  replSet=blort #设置富本集的名字
  shardsvr=true #设置是否分片
  2.运行./mongod –config ~/.mongodb.conf 命令(--config可以直接写成-f)。
  输出:
  all output going to: /data/mongodb/log/mongodb.log
  forked process: 5315
  
  mongodb 启动参数
    --quiet                              # 安静输出 
    --port arg                        # 指定服务端口号，默认端口27017 
    --bind_ip arg                  # 绑定服务IP，若绑定127.0.0.1，则只能本机访问，不指定默认本地所有IP 
    --logpath arg                  # 指定MongoDB日志文件，注意是指定文件不是目录 
    --logappend                   # 使用追加的方式写日志 
    --pidfilepath arg             # PID File 的完整路径，如果没有设置，则没有PID文件 
    --keyFile arg                   # 集群的私钥的完整路径，只对于Replica Set 架构有效 
    --unixSocketPrefix arg  # UNIX域套接字替代目录,(默认为 /tmp) 
    --fork                                 # 以守护进程的方式运行MongoDB，创建服务器进程 
    --auth                                # 启用验证 
    --cpu                                 # 定期显示CPU的CPU利用率和iowait 
    --dbpath arg                     # 指定数据库路径 
    --diaglog arg                    # diaglog选项 0=off 1=W 2=R 3=both 7=W+some reads 
    --directoryperdb              # 设置每个数据库将被保存在一个单独的目录 
    --journal                            # 启用日志选项，MongoDB的数据操作将会写入到journal文件夹的文件里 
    --journalOptions arg       # 启用日志诊断选项 
    --ipv6                                 # 启用IPv6选项 
    --jsonp                              # 允许JSONP形式通过HTTP访问（有安全影响） 
    --maxConns arg             # 最大同时连接数 默认2000 
    --noauth                           # 不启用验证 
    --nohttpinterface             # 关闭http接口，默认关闭27018端口访问 
    --noprealloc                     # 禁用数据文件预分配(往往影响性能) 
    --noscripting                    # 禁用脚本引擎 
    --notablescan                  # 不允许表扫描 
    --nounixsocket                # 禁用Unix套接字监听 
    --nssize arg (=16)           # 设置信数据库.ns文件大小(MB) 
    --objcheck                        # 在收到客户数据,检查的有效性， 
    --profile arg                      # 档案参数 0=off 1=slow, 2=all 
    --quota                              # 限制每个数据库的文件数，设置默认为8 
    --quotaFiles arg               #  number of files allower per db, requires --quota 
    --rest                                  # 开启简单的rest API 
    --repair                              # 修复所有数据库run repair on all dbs 
    --repairpath arg               # 修复库生成的文件的目录,默认为目录名称dbpath 
    --slowms arg (=100)       # value of slow for profile and console log 
    --smallfiles                       # 使用较小的默认文件 
    --syncdelay arg (=60)    # 数据写入磁盘的时间秒数(0=never,不推荐) 
    --sysinfo                           # 打印一些诊断系统信息 
    --upgrade                        # 如果需要升级数据库
    
    * Replicaton 参数

   --------------------------------------------------------------------------------

    --fastsync                      # 从一个dbpath里启用从库复制服务，该dbpath的数据库是主库的快照，可用于快速启用同步 
    --autoresync                 # 如果从库与主库同步数据差得多，自动重新同步， 
    --oplogSize arg            # 设置oplog的大小(MB) 
    
    * 主/从参数

   --------------------------------------------------------------------------------

    --master                        # 主库模式 
    --slave                           # 从库模式 
    --source arg                 # 从库 端口号 
    --only arg                      # 指定单一的数据库复制 
    --slavedelay arg          # 设置从库同步主库的延迟时间 
     
    * Replica set(副本集)选项：

   --------------------------------------------------------------------------------

    --replSet arg                   # 设置副本集名称 
    
    * Sharding(分片)选项

   --------------------------------------------------------------------------------

    --configsvr                       # 声明这是一个集群的config服务,默认端口27019，默认目录/data/configdb 
    --shardsvr                        # 声明这是一个集群的分片,默认端口27018 
    --noMoveParanoia        # 关闭偏执为moveChunk数据保存? 
 


 三 查询进程和关闭数据库
  1. 运行 ps -ef|grep mongo 命令查询服务器进程
  2. 运行 kill -2 5315命令kill掉5315的进程
  
 四 进入数据库并简单操作数据库
  1.运行./mongo –port 1000进入刚刚启动的端口号为10000的数据库
  2.使用use test可以切换集合（相当于数据库表）,这里切换到了test集合
  3.使用db.test.insert("a","b");向集合插入数据
  4.使用db.test.find();查询集合里的数据
  5.更多shell命令请查阅相关文档

 五 注意事项
  1. 防火墙设置（测试时可直接关闭linux关闭防火墙：立即但不永久生效：service iptables stop重启永久生效：chkconfig iptables off）

第二节 副本集
 简单的说，副本集就是有自动故障恢复功能的主从集群，副本集没有固定的"主节点"，集群会通过投票选举一个"主节点"。当主节点岩机时，会变更到其他节点。副本集布在不同机器上时，至少要启动三个（单数）数据库服务器进程，否则启动时投票不成功会一直初始化不了。
 
 一 以配置文件方式启动三台机器上的数据库服务器
  1. 三台服务器的配置文件：
   port=10000 #端口号
   fork=true #以守护进程的方式运行，创建服务器进程
   logpath=/data/mongodb/log/mongodb.log #日志输出文件路径
   logappend=true #日志输出方式
   dbpath=/data/mongodb/data/db #数据库路径
   replSet=blort #设置富本集的名字为blort,replSet是让服务器知道在这个"blort"副本集中还有别的机器
   # replSet=blort /10.10.112.181:10000, 10.10.112.191:10000#设置富本集的名字,这种方式也可以，意思就是"blort"副本集其他机器，位置在10.10.112.181:10000和10.10.112.191:10000，但不推荐
  
  2. 通命令启动三台数据库服务器
   /usr/local/mongodb/bin/mongod -f /data/mongodb/blort/config.conf
   /usr/local/mongodb/bin/mongod -f /data/mongodb/blort2/config.conf
   /usr/local/mongodb/bin/mongod -f /data/mongodb/blort3/config.conf
  
 二 初始化副本集（只能初始化一次）
  /usr/local/mongodb/bin/mongo --port 30001
  use admin
  方法一：
  db.runCommand({"replSetInitiate":{"_id":"blort","members":[{"_id":0,"host":"10.10.113.122:30001"},{"_id":1,"host":"10.10.113.122:30002"},{"_id":2,"host":"10.10.113.122:30003","arbiterOnly":true}]}})
  
  方法二：
  config={_id:'blort',members:[{"_id":0,host:'10.10.113.122:30001},{"_id":1,host:'10.10.113.122:30002'},{"_id":2,"host":"10.10.113.122:30003","arbiterOnly":true}]};
  rs.initiate(config);

 三 增加和设置副本集
  有几种不同类型的节点可以存在于副本集：
  Standard ：存在于副本，参与投票，有可能成为活跃节点（即主节点）
  Passive :存储了完整的数据副本，参与投票，不能成为活跃节点
  Arbiter:仲裁者，只参与投票，不能成为活跃节点
  Priority：优先级，（投票会投优先级高的，如果相同，则投数据最新的）
  以上类型可以通过以下命令对副本集合进行修改或者增加服务器
  db.runCommand({"replSetReconfig":{"_id":"test3","version":2,"members":[{"_id":0,"host":"10.10.113.122:30001"},{"_id":1,"host":"10.10.113.122:30002"},{"_id":2,"host":"10.10.113.122:30003","arbiterOnly":true}]}})
  
  增加副本服务器
  在增加一个从服务器节点
  a．以相同副本集名字启动一台服务器
  b.通过rs.add命令往system.replset添加新的从服务器成员
  rs.add("10.10.113.122:30005"); 或者rs.add({"_id":4,"host":"10.10.113.122:30005"}) 
  添加仲裁
  rs.addArb("10.10.113.122:30004");

 四 读扩展
  待研究
  
 五 用户校验
  未成功
  use test;
  db.addUser("test","123456");
  db.auth("test","123456");
  db.system.users.find();
  db.system.users.remove("test","123456");
  
第二节 replica sets + shard (双机方案，单机模拟)
 
 一 准备
  mkdir -p /data/mongodb/shard1-1/db/
  mkdir -p /data/mongodb/shard1-1/log/
  
  /data/mongodb/shard1-1/config.conf
   port=30001   #端口号
   fork=true   #以守护进程的方式运行，创建服务器进程
   #nohttpinterface=true   # 关闭http接口，默认关闭27018端口访问 port + 1000
   rest = true  #http接口 启动rest 使能访问 。与nohttpinterface 对应 只开一个
   shardsvr=true  #启动分片
   #oplogSize=100  #复制日志大小 MB
   logpath=/data/mongodb/shard1-1/log/shard1-1.log   #日志输出文件路径
   logappend=true   #日志输出方式
   dbpath=/data/mongodb/shard1-1/db   #数据库路径
   directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录 
   replSet=shard1   #设置富本集的名字为shard1,replSet是让服务器知道在这个"shard1"副本集中还有别的机器

   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/shard1-1a/db/
  mkdir -p /data/mongodb/shard1-1a/log/
  /data/mongodb/shard1-1a/config.conf
   port=30002   #端口号
   fork=true   #以守护进程的方式运行，创建服务器进程
   #nohttpinterface=true   # 关闭http接口，默认关闭27018端口访问 port + 1000
   rest = true  #http接口 启动rest 使能访问 。与nohttpinterface 对应 只开一个
   shardsvr=true  #启动分片
   #oplogSize=100  #复制日志大小 MB
   logpath=/data/mongodb/shard1-1a/log/shard1-1a.log   #日志输出文件路径
   logappend=true   #日志输出方式
   dbpath=/data/mongodb/shard1-1a/db   #数据库路径
   directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录 
   replSet=shard1   #设置富本集的名字为shard1,replSet是让服务器知道在这个"shard1"副本集中还有别的机器

   #auth=true # 启用验证
  
  
  mkdir -p /data/mongodb/shard1-2/db/
  mkdir -p /data/mongodb/shard1-2/log/
  /data/mongodb/shard1-2/config.conf
   port=30003   #端口号
   fork=true   #以守护进程的方式运行，创建服务器进程
   #nohttpinterface=true   # 关闭http接口，默认关闭27018端口访问 port + 1000
   rest = true  #http接口 启动rest 使能访问 。与nohttpinterface 对应 只开一个
   shardsvr=true  #启动分片
   #oplogSize=100  #复制日志大小 MB
   logpath=/data/mongodb/shard1-2/log/shard1-2.log   #日志输出文件路径
   logappend=true   #日志输出方式
   dbpath=/data/mongodb/shard1-2/db   #数据库路径
   directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录 
   replSet=shard1   #设置富本集的名字为shard1,replSet是让服务器知道在这个"shard1"副本集中还有别的机器

   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/shard2-1/db/
  mkdir -p /data/mongodb/shard2-1/log/
  /data/mongodb/shard2-1/config.conf
   port=32001   #端口号
   fork=true   #以守护进程的方式运行，创建服务器进程
   #nohttpinterface=true   # 关闭http接口，默认关闭27018端口访问 port + 1000
   rest = true  #http接口 启动rest 使能访问 。与nohttpinterface 对应 只开一个
   shardsvr=true  #启动分片
   #oplogSize=100  #复制日志大小 MB
   logpath=/data/mongodb/shard2-1/log/shard2-1.log   #日志输出文件路径
   logappend=true   #日志输出方式
   dbpath=/data/mongodb/shard2-1/db   #数据库路径
   directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录 
   replSet=shard2   #设置富本集的名字为shard2,replSet是让服务器知道在这个"shard2"副本集中还有别的机器

   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/shard2-1a/db/
  mkdir -p /data/mongodb/shard2-1a/log/
  /data/mongodb/shard2-1a/config.conf
   port=32002   #端口号
   fork=true   #以守护进程的方式运行，创建服务器进程
   #nohttpinterface=true   # 关闭http接口，默认关闭27018端口访问 port + 1000
   rest = true  #http接口 启动rest 使能访问 。与nohttpinterface 对应 只开一个
   shardsvr=true  #启动分片
   #oplogSize=100  #复制日志大小 MB
   logpath=/data/mongodb/shard2-1a/log/shard2-1a.log   #日志输出文件路径
   logappend=true   #日志输出方式
   dbpath=/data/mongodb/shard2-1a/db   #数据库路径
   directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录 
   replSet=shard2   #设置富本集的名字为shard2,replSet是让服务器知道在这个"shard2"副本集中还有别的机器

   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/shard2-2/db/
  mkdir -p /data/mongodb/shard2-2/log/
  /data/mongodb/shard2-2/config.conf
   port=32003   #端口号
   fork=true   #以守护进程的方式运行，创建服务器进程
   #nohttpinterface=true   # 关闭http接口，默认关闭27018端口访问 port + 1000
   rest = true  #http接口 启动rest 使能访问 。与nohttpinterface 对应 只开一个
   shardsvr=true  #启动分片
   #oplogSize=100  #复制日志大小 MB
   logpath=/data/mongodb/shard2-2/log/shard2-2.log   #日志输出文件路径
   logappend=true   #日志输出方式
   dbpath=/data/mongodb/shard2-2/db   #数据库路径
   directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录 
   replSet=shard2   #设置富本集的名字为shard2,replSet是让服务器知道在这个"shard2"副本集中还有别的机器

   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/config1/db/
  mkdir -p /data/mongodb/config1/log/
  /data/mongodb/config1/config.conf
   dbpath = /data/mongodb/config1/db
   configsvr = true
   port = 40001
   logpath =/data/mongodb/config1/log/config1.log
   logappend = true
   fork = true
   
   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/config2/db/
  mkdir -p /data/mongodb/config2/log/
  /data/mongodb/config2/config.conf
   dbpath = /data/mongodb/config2/db
   configsvr = true
   port = 40002
   logpath =/data/mongodb/config2/log/config2.log
   logappend = true
   fork = true
   
   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/config3/db/
  mkdir -p /data/mongodb/config3/log/
  /data/mongodb/config3/config.conf
   dbpath = /data/mongodb/config3/db
   configsvr = true
   port = 40003
   logpath =/data/mongodb/config3/log/config3.log
   logappend = true
   fork = true
   
   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/mongos1/log/
  /data/mongodb/mongos1/config.conf
   configdb =10.10.113.122:40001,10.10.113.122:40002,10.10.113.122:40003
   port = 50001
   chunkSize = 1
   logpath =/data/mongodb/mongos1/log/mongos1.log
   logappend = true
   fork = true

   #auth=true # 启用验证
  
  mkdir -p /data/mongodb/mongos2/log/
  /data/mongodb/mongos2/config.conf
   configdb =10.10.113.122:40001,10.10.113.122:40002,10.10.113.122:40003
   port = 50002
   chunkSize = 1
   logpath =/data/mongodb/mongos2/log/mongos2.log
   logappend = true
   fork = true

   #auth=true # 启用验证

 二 启动
 
  shard1 副本 启动
  /usr/local/mongodb/bin/mongod -f /data/mongodb/shard1-1/config.conf
  /usr/local/mongodb/bin/mongod -f /data/mongodb/shard1-1a/config.conf
  /usr/local/mongodb/bin/mongod -f /data/mongodb/shard1-2/config.conf
  
  /usr/local/mongodb/bin/mongo --port 30001
  
  use admin
  db.runCommand({"replSetInitiate":{"_id":"shard1","members":[{"_id":0,"host":"10.10.113.122:30001"},{"_id":1,"host":"10.10.113.122:30002","arbiterOnly":true},{"_id":2,"host":"10.10.113.122:30003"}]}})
  
  shard2 副本 启动
  /usr/local/mongodb/bin/mongod -f /data/mongodb/shard2-1/config.conf
  /usr/local/mongodb/bin/mongod -f /data/mongodb/shard2-1a/config.conf
  /usr/local/mongodb/bin/mongod -f /data/mongodb/shard2-2/config.conf
  
  /usr/local/mongodb/bin/mongo --port 31001
  
  use admin
  db.runCommand({"replSetInitiate":{"_id":"shard2","members":[{"_id":0,"host":"10.10.113.122:32001"},{"_id":1,"host":"10.10.113.122:32002","arbiterOnly":true},{"_id":2,"host":"10.10.113.122:32003"}]}})
 
  config1 启动
  /usr/local/mongodb/bin/mongod -f /data/mongodb/config1/config.conf
  config2 启动
  /usr/local/mongodb/bin/mongod -f /data/mongodb/config2/config.conf
  config3 启动
  /usr/local/mongodb/bin/mongod -f /data/mongodb/config3/config.conf
  
  mongos1 启动
  /usr/local/mongodb/bin/mongos -f /data/mongodb/mongos1/config.conf
  mongos2 启动
  /usr/local/mongodb/bin/mongos -f /data/mongodb/mongos2/config.conf
  
  
  /usr/local/mongodb/bin/mongo --port 50001
  use admin
  db.runCommand({addshard:"shard1/10.10.113.122:30001,10.10.113.122:30003",name:"shard1", maxsize:100})
  db.runCommand({addshard:"shard2/10.10.113.122:32001,10.10.113.122:32003",name:"shard2", maxsize:100})
  
  db.runCommand({listshards:1})
  
  use test
  db.test.insert({"aaa":"bbb"});

第三节 replica sets + shard （3机高可用 ， 一主双备份）
 一 方案
  每个分片3服务器，前期采用三台，日后服务器的增加考虑灾备，服务增加的基数最少为三台（或才有双机方案）。
  Server1 10.10.113.122 Server1 10.10.113.132 Server3 10.10.113.133
  

  类型    服务器   用途       系统   说明
   
  存储/数据   Server1    Shard1/Shard2/Shard3  Linux 64位  Shard1:10001;Shard2:10002,Shard3:10003;
       Server2   Shard1/Shard2/Shard3  Linux 64位  Shard1:10001;Shard2:10002,Shard3:10003;
       Server3   Shard1/Shard2/Shard3  Linux 64位  Shard1:10001;Shard2:10002,Shard3:10003;
   
  配置    Server1   Config1      Linux 64位  Config1:20000;
       Server2   Config2      Linux 64位  Config2:20000; 
       Server3   Config3      Linux 64位  Config3:20000;
   
  路由    Server1   Mongos1      Linux 64位  Mongos:30000;
       Server2   Mongos2      Linux 64位  Mongos:30000;
       Server3   Mongos3      Linux 64位  Mongos:30000;
 
 二 准备
  安装mongodb 参照第一节
  
  
  linux 传文件
  # scp mongodb-linux-x86_64-2.0.4.tgz root@10.10.113.132:/root
  # ssh 10.10.113.132
  
  删除目录
  # rm -r -f /data/mongodb
 
 
  创建配置、日志、分片、key文件存储目录及验证文件
  
  mkdir /data/mongodb/configsvr/ -p
  
  mkdir /data/mongodb/log/ -p
  
  mkdir /data/mongodb/shard1/ -p
  
  mkdir /data/mongodb/shard2/ -p
  
  mkdir /data/mongodb/shard3/ -p
  
  mkdir /data/mongodb/key/ -p
  
  mkdir /data/mongodb/conf/security/ -p
  mkdir /data/mongodb/conf/nosecurity/ -p
  
  创建配置文件
   1、 创建验证文件security于/data/mongodb/key/目录，关赋予可读权限，命令如下：
   cd /data/mongodb/key/
   echo 'hycloudmongodbkey' > security
   chmod 600 security
   
   2、 创建shard1.conf、shard2.conf、shard3.conf、configsvr.conf、mongos.conf于/data/mongodb/conf/security/ 和 /data/mongodb/conf/nosecurity/的目录，内容分别如下：
   shard1.conf
   
dbpath = /data/mongodb/shard1

directoryperdb = true

shardsvr = true

replSet = shard1

#bind_ip = 10.10.113.122,localhost

port = 10001

oplogSize = 100

logpath =/data/mongodb/log/shard1.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   shard2.conf
dbpath = /data/mongodb/shard2

directoryperdb = true

shardsvr = true

replSet = shard2

#bind_ip = 10.10.113.122,localhost

port = 10002

oplogSize = 100

logpath = /data/mongodb/log/shard2.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   shard3.conf
dbpath = /data/mongodb/shard3

directoryperdb = true

shardsvr = true

replSet = shard3

#bind_ip = 10.10.113.122,localhost

port = 10003

oplogSize = 100

logpath = /data/mongodb/log/shard3.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   configsvr.conf
dbpath = /data/mongodb/configsvr

directoryperdb = true

configsvr = true

port = 20000

logpath =/data/mongodb/log/configsvr.log

logappend = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   mongos.conf
configdb =10.10.113.122:20000, 10.10.113.132:20000, 10.10.113.133:20000

port = 30000

chunkSize = 1  #单位 mb 生成环境请使用 200 或删除

logpath =/data/mongodb/log/mongos.log

logappend = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
   
  分片配置
   说明：分片要在无验证环境中配置，否则会出现无权限等异常。采用以下命令启动Server1\Server2\Server3上的shard1\shard2\shard3：

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/shard1.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/shard2.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/shard3.conf

   以下命令查看是否正常启动：

   # netstat -lnpt # 或 ps -ef | grep mongo

   启动后连接到shard1\shard2\shard3分别进行配置，在任意一台服务器即可，以下是具体配置过程：

   # /usr/local/mongodb/bin/mongo --port 10001
   
   >use admin
   
   >config = {_id:"shard1", members: [

           {_id: 0, host:"10.10.113.122:10001"},

           {_id: 1, host:"10.10.113.132:10001"},

           {_id: 2, host:"10.10.113.133:10001"}]

        };

   >rs.initiate(config)

   >exit

   # /usr/local/mongodb/bin/mongo --port 10002

   >use admin
   
   >config = {_id:"shard2", members: [

           {_id: 0, host:"10.10.113.132:10002"},

           {_id: 1, host:"10.10.113.133:10002"},

           {_id: 2, host:"10.10.113.122:10002"}]

     };

   >rs.initiate(config)

   >exit

   # /usr/local/mongodb/bin/mongo --port 10003
   
   >use admin

   >config = {_id:"shard3", members: [

           {_id: 0, host:"10.10.113.133:10003"},

           {_id: 1, host:"10.10.113.122:10003"},

           {_id: 2, host:"10.10.113.132:10003"}]

     };

   >rs.initiate(config)

   至此，已完成分片配置
   
  路由设置
   路由是能过config来连接分片服务器，在启动路由进程时，先启动配置进程，路由配置过程如下：

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/configsvr.conf

   # /usr/local/mongodb/bin/mongos -f /data/mongodb/conf/nosecurity/mongos.conf

   启动后，连接路由进行分片添加，只需配置一台路由。注：分片操作需在admin库下进行，另外必需在无验证要求下进行，即采用前面创建于nosecurity文件夹下的配置。

   # /usr/local/mongodb/bin/mongo --port 30000

   mongos> use admin

   mongos> db.runCommand({addshard:"shard1/10.10.113.122:10001,10.10.113.132:10001,10.10.113.133:10001",name:"shard1", maxsize:20480} )

   mongos> db.runCommand({addshard:"shard2/10.10.113.122:10002,10.10.113.132:10002,10.10.113.133:10002",name:"shard2", maxsize:20480} )

   mongos> db.runCommand({addshard:"shard3/10.10.113.122:10003,10.10.113.132:10003,10.10.113.133:10003",name:"shard3", maxsize:20480} )

   命令检查分片添加情况，如出现以下结果则表示配置成功：

   mongos> db.runCommand( {listshards : 1 } )
  
  
  权限控制
   MongoDB默认为验证模式。如需对数据库进行权限控制，需先采用无验证模式登录，进入admin库创建管理员用户后，再采用验证模式登录。通过前面创建的管理员帐号进行数据库与用户的创建。MongoDB集群的权限与单台的权限控制的不同之处在于，单台是通过-auth属性，集群是通过keyFile来进行服务器间的验证。以下介绍配置全过程。

   前面的所有步骤，都是在nosecurity模式下进行。如果没有采用非验证模式的需要将所有进程（分片、配置、mongos）停止，将切换到无验证模式。

   步骤一：先进行登录，并切换进admin库创建管理员帐号

   # /usr/local/mongodb/bin/mongo --port 30000

   mongos>use admin

   mongos>db.addUser('admin','123456')

   {

     "singleShard" :"192.168.2.88:20000,192.168.2.89:20000,192.168.2.90:20000",

     "n" : 0,

     "connectionId" : 211,

     "err" : null,

     "ok" : 1

   }

   {

     "_id" :ObjectId("4f6c78ddad912a3ac6833ece"),

     "user" : "admin",

     "readOnly" : false,

     "pwd" :"95ec4261124ba5951720b199908d892b"

   }

   验证用户名与密码

   mongos> db.auth('admin','123456')

   1

   mongos>exit

   步骤二：退出后，将Server1\Server2\Server3服务器上MongoDB的所有进程（分片、配置、mongos）停止，将切换到验证模式。具体命令如下：

   #killall mongod mongos

   #netstat -lnpt

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/shard1.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/shard2.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/shard3.conf

   # netstat -lnpt

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/configsvr.conf

   # /usr/local/mongodb/bin/mongos -f /data/mongodb/conf/security/mongos.conf

   启动后，如对库进行查看，则会报以下异常：

   # /usr/local/mongodb/bin/mongo 10.10.113.122:30000/admin

   MongoDB shell version: 2.0.4

   connecting to:10.10.113.122:30000/admin

   > show dbs

   Fri Mar 23 22:28:28 uncaughtexception: listDatabases failed:{ "ok" : 0, "errmsg" :"unauthorized" }

   以下是正常登录后显示的信息：

   # /usr/local/mongodb/bin/mongo 10.10.113.122:30000/admin

   MongoDB shell version: 2.0.4

   connecting to:10.10.113.122:30000/admin

   >db.auth('admin','123456')

   1

   mongos>

   步骤三：以下是数据库及数据库用户创建的过程：

   mongos> use hello

   switched to db hello

   mongos>db.addUser('sa','sa')

   {

     "singleShard" :"shard2/10.10.113.122:10002,10.10.113.132:10002,10.10.113.133:10002",

     "n" : 0,

     "lastOp" :NumberLong("5723101431532093441"),

     "connectionId" : 38,

     "err" : null,

     "ok" : 1

   }

   {

     "user" : "sa",

     "readOnly" : false,

     "pwd" :"75692b1d11c072c6c79332e248c4f699",

     "_id" :ObjectId("4f6c8a6e9f67b049a20a00de")

   }

   mongos> exit

   bye

   # /usr/local/mongodb/bin/mongo 10.10.113.122:30000/hello -u sa -p

   MongoDB shell version: 2.0.4

   Enter password:

   connecting to:10.10.113.122:30000/hello

   > show collections

   system.indexes

   system.users

   > db.system.users.find()

   { "_id" :ObjectId("4f6c8a6e9f67b049a20a00de"), "user" :"sa", "readOnly" : false, "pwd" :"75692b1d11c072c6c79332e248c4f699" }


  分片
   # /usr/local/mongodb/bin/mongo -port 30000
   
   > use test
   
   导入数据
   > use admin
   > db.runCommand({"enablesharding":"test"})
   > db.runCommand({"shardcollection":"test.doc","key":{"_id":1}})
   
第四节 replica sets + shard （3机高可用 ， 一主一备份一仲裁）
 一 方案
  每个分片3服务器，前期采用三台，日后服务器的增加考虑灾备，服务增加的基数最少为三台（或用有双机方案）。
  Server1 10.10.113.122 Server1 10.10.113.132 Server3 10.10.113.133
  

  类型    服务器   用途       系统   说明
   
  存储/数据   Server1    Shard1/Shard2/Shard3  Linux 64位  Shard1:10001;Shard2:10002,Shard3:10003;
       Server2   Shard1/Shard2/Shard3  Linux 64位  Shard1:10001;Shard2:10002,Shard3:10003;
       Server3   Shard1/Shard2/Shard3  Linux 64位  Shard1:10001;Shard2:10002,Shard3:10003;
   
  配置    Server1   Config1      Linux 64位  Config1:20000;
       Server2   Config2      Linux 64位  Config2:20000; 
       Server3   Config3      Linux 64位  Config3:20000;
   
  路由    Server1   Mongos1      Linux 64位  Mongos:30000;
       Server2   Mongos2      Linux 64位  Mongos:30000;
       Server3   Mongos3      Linux 64位  Mongos:30000;
 
 二 准备
  安装mongodb 参照第一节
  
  
  linux 传文件
  # scp mongodb-linux-x86_64-2.0.4.tgz root@10.10.113.132:/root
  # ssh 10.10.113.132
 
 
  创建配置、日志、分片、key文件存储目录及验证文件
  
  mkdir /data/mongodb/configsvr/ -p
  
  mkdir /data/mongodb/log/ -p
  
  mkdir /data/mongodb/shard1/ -p
  
  mkdir /data/mongodb/shard2/ -p
  
  mkdir /data/mongodb/shard3/ -p
  
  mkdir /data/mongodb/key/ -p
  
  mkdir /data/mongodb/conf/security/ -p
  mkdir /data/mongodb/conf/nosecurity/ -p
  
  创建配置文件
   1、 创建验证文件security于/data/mongodb/key/目录，关赋予可读权限，命令如下：
   cd /data/mongodb/key/
   echo 'hycloudmongodbkey' > security
   chmod 600 /data/mongodb/key/security
   
   2、 创建shard1.conf、shard2.conf、shard3.conf、configsvr.conf、mongos.conf于/data/mongodb/conf/security/ 和 /data/mongodb/conf/nosecurity/的目录，内容分别如下：
   shard1.conf
   
dbpath = /data/mongodb/shard1

directoryperdb = true

shardsvr = true

replSet = shard1

#bind_ip = 10.10.113.122,localhost

port = 10001

oplogSize = 100

logpath =/data/mongodb/log/shard1.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   shard2.conf
dbpath = /data/mongodb/shard2

directoryperdb = true

shardsvr = true

replSet = shard2

#bind_ip = 10.10.113.122,localhost

port = 10002

oplogSize = 100

logpath = /data/mongodb/log/shard2.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   shard3.conf
dbpath = /data/mongodb/shard3

directoryperdb = true

shardsvr = true

replSet = shard3

#bind_ip = 10.10.113.122,localhost

port = 10003

oplogSize = 100

logpath = /data/mongodb/log/shard3.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   configsvr.conf
dbpath = /data/mongodb/configsvr

directoryperdb = true

configsvr = true

port = 20000

logpath =/data/mongodb/log/configsvr.log

logappend = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
    
   mongos.conf
configdb =10.10.113.122:20000, 10.10.113.132:20000, 10.10.113.133:20000

port = 30000

chunkSize = 1  #单位 mb 生成环境请使用 200 或删除

logpath =/data/mongodb/log/mongos.log

logappend = true

fork = true

keyFile = /data/mongodb/key/security  #nosecurity目录将该行删除
   
  分片配置
   说明：分片要在无验证环境中配置，否则会出现无权限等异常。采用以下命令启动Server1\Server2\Server3上的shard1\shard2\shard3：

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/shard1.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/shard2.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/shard3.conf

   以下命令查看是否正常启动：

   # netstat -lnpt # 或 ps -ef | grep mongo

   启动后连接到shard1\shard2\shard3分别进行配置，在任意一台服务器即可，以下是具体配置过程：（注意不能在仲裁机器初始化）

   # /usr/local/mongodb/bin/mongo --port 10001
   
   >use admin
   
   >config = {_id:"shard1", members: [

           {_id: 0, host:"10.10.113.122:10001"},

           {_id: 1, host:"10.10.113.132:10001"},

           {_id: 2, host:"10.10.113.133:10001","arbiterOnly":true}]

        };

   >rs.initiate(config)

   >exit

   # /usr/local/mongodb/bin/mongo --port 10002

   >use admin
   
   >config = {_id:"shard2", members: [

           {_id: 0, host:"10.10.113.132:10002"},

           {_id: 1, host:"10.10.113.133:10002"},

           {_id: 2, host:"10.10.113.122:10002","arbiterOnly":true}]

     };

   >rs.initiate(config)

   >exit
   
   # /usr/local/mongodb/bin/mongo --port 10003
   
   >use admin

   >config = {_id:"shard3", members: [

           {_id: 0, host:"10.10.113.133:10003"},

           {_id: 1, host:"10.10.113.122:10003"},

           {_id: 2, host:"10.10.113.132:10003","arbiterOnly":true}]

     };

   >rs.initiate(config)

   至此，已完成分片配置
   
  路由设置
   路由是能过config来连接分片服务器，在启动路由进程时，先启动配置进程，路由配置过程如下：

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/nosecurity/configsvr.conf

   # /usr/local/mongodb/bin/mongos -f /data/mongodb/conf/nosecurity/mongos.conf

   启动后，连接路由进行分片添加，只需配置一台路由。注：分片操作需在admin库下进行，另外必需在无验证要求下进行，即采用前面创建于nosecurity文件夹下的配置。

   # /usr/local/mongodb/bin/mongo --port 30000

   mongos> use admin
   # maxsize:20480 #单位 mb 分片限制大小 根据实际服务器来定
   mongos> db.runCommand({addshard:"shard1/10.10.113.122:10001,10.10.113.132:10001,10.10.113.133:10001",name:"shard1", maxsize:20480} )

   mongos> db.runCommand({addshard:"shard2/10.10.113.132:10002,10.10.113.133:10002,10.10.113.122:10002",name:"shard2", maxsize:20480} )

   mongos> db.runCommand({addshard:"shard3/10.10.113.133:10003,10.10.113.122:10003,10.10.113.132:10003",name:"shard3", maxsize:20480} )

   命令检查分片添加情况，如出现以下结果则表示配置成功：

   mongos> db.runCommand( {listshards : 1 } )
  
  
  权限控制
   MongoDB默认为验证模式。如需对数据库进行权限控制，需先采用无验证模式登录，进入admin库创建管理员用户后，再采用验证模式登录。通过前面创建的管理员帐号进行数据库与用户的创建。MongoDB集群的权限与单台的权限控制的不同之处在于，单台是通过-auth属性，集群是通过keyFile来进行服务器间的验证。以下介绍配置全过程。

   前面的所有步骤，都是在nosecurity模式下进行。如果没有采用非验证模式的需要将所有进程（分片、配置、mongos）停止，将切换到无验证模式。

   步骤一：先进行登录，并切换进admin库创建管理员帐号

   # /usr/local/mongodb/bin/mongo --port 30000

   mongos>use admin

   mongos>db.addUser('admin','123456')

   {

     "singleShard" :"192.168.2.88:20000,192.168.2.89:20000,192.168.2.90:20000",

     "n" : 0,

     "connectionId" : 211,

     "err" : null,

     "ok" : 1

   }

   {

     "_id" :ObjectId("4f6c78ddad912a3ac6833ece"),

     "user" : "admin",

     "readOnly" : false,

     "pwd" :"95ec4261124ba5951720b199908d892b"

   }

   验证用户名与密码

   mongos> db.auth('admin','123456')

   1

   mongos>exit

   步骤二：退出后，将Server1\Server2\Server3服务器上MongoDB的所有进程（分片、配置、mongos）停止，将切换到验证模式。具体命令如下：

   # killall mongod mongos

   # netstat -lnpt

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/shard1.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/shard2.conf

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/shard3.conf

   # netstat -lnpt # ps -ef | grep mongo

   # /usr/local/mongodb/bin/mongod -f /data/mongodb/conf/security/configsvr.conf

   # /usr/local/mongodb/bin/mongos -f /data/mongodb/conf/security/mongos.conf

   启动后，如对库进行查看，则会报以下异常：

   # /usr/local/mongodb/bin/mongo 10.10.113.122:30000/admin

   MongoDB shell version: 2.0.4

   connecting to:10.10.113.122:30000/admin

   > show dbs

   Fri Mar 23 22:28:28 uncaughtexception: listDatabases failed:{ "ok" : 0, "errmsg" :"unauthorized" }

   以下是正常登录后显示的信息：

   # /usr/local/mongodb/bin/mongo 10.10.113.122:30000/admin

   MongoDB shell version: 2.0.4

   connecting to:10.10.113.122:30000/admin

   >db.auth('admin','123456')

   1

   mongos>

   步骤三：以下是数据库及数据库用户创建的过程：

   mongos> use hello

   switched to db hello

   mongos>db.addUser('sa','sa')

   {

     "singleShard" :"shard2/10.10.113.122:10002,10.10.113.132:10002,10.10.113.133:10002",

     "n" : 0,

     "lastOp" :NumberLong("5723101431532093441"),

     "connectionId" : 38,

     "err" : null,

     "ok" : 1

   }

   {

     "user" : "sa",

     "readOnly" : false,

     "pwd" :"75692b1d11c072c6c79332e248c4f699",

     "_id" :ObjectId("4f6c8a6e9f67b049a20a00de")

   }

   mongos> exit

   bye

   # /usr/local/mongodb/bin/mongo 10.10.113.122:30000/hello -u sa -p

   MongoDB shell version: 2.0.4

   Enter password:

   connecting to:10.10.113.122:30000/hello

   > show collections

   system.indexes

   system.users

   > db.system.users.find()

   { "_id" :ObjectId("4f6c8a6e9f67b049a20a00de"), "user" :"sa", "readOnly" : false, "pwd" :"75692b1d11c072c6c79332e248c4f699" }


  分片
   # /usr/local/mongodb/bin/mongo -port 30000
   
   > use admin
   > db.runCommand({"enablesharding":"test"})
   > db.runCommand({"shardcollection":"test.doc","key":{"_id":1}})
   > db.runCommand({"shardcollection":"test.txt","key":{"_id":1}})
   索引
   > use test
   > db.fs.chunks.ensureIndex({files_id: 1});  
   > use admin
   > db.runCommand({ shardcollection : "test.fs.chunks", key : { files_id : 1 }}) 

   
   索引
   > use test
   
   > db.doc.ensureIndex({"letter":1})
   
   导入数据
   
   查询数据
   
   分片管理
   > use config
   > show collections
   > db.shards.find()
   > db.databases.find()
   > db.chunks.find()
   
   > db.printShardingStatus()

===============================================================================================================================

 

 

#下载编译好的版本

wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.2.3.tgz
tar vxzf mongodb-linux-x86_64-2.2.3.tgz
cd mongodb-linux-x86_64-2.2.3

 

#创建3个mongodb实例的目录

mkdir -p /home/mongodb/rs0-0 /home/mongodb/rs0-1 /home/mongodb/rs0-2

#启动3个mongodb实例，参数--replSet用来配置replica group

./mongod --port 27017 --dbpath /home/mongodb/rs0-0 --replSet rs0 &
./mongod --port 27018 --dbpath /home/mongodb/rs0-1 --replSet rs0 &
./mongod --port 27019 --dbpath /home/mongodb/rs0-2 --replSet rs0 &

#启动客户端

./mongo --port 27017

#配置replica信息，添加3节点，请在1分钟内配置完成

>rsconf = { _id: "rs0", members: [ { _id: 0, host: "192.168.2.100:27017" } ] }
>rs.initiate( rsconf )
>rs.add("192.168.2.100:27018")
>rs.add("192.168.2.100:27019")
#查看配置结果
>rs.conf()

上面的过程如下

[root@ghost-rider bin]# ./mongo --port 27017
MongoDB shell version: 2.2.3
connecting to: 127.0.0.1:27017/test
> rsconf = { _id: "rs0", members: [ { _id: 0, host: "192.168.2.100:27017" } ] }
{
	"_id" : "rs0",
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.2.100:27017"
		}
	]
}
> rs.initiate( rsconf )
{
	"info" : "Config now saved locally.  Should come online in about a minute.",
	"ok" : 1
}
> rs.conf()
{
	"_id" : "rs0",
	"version" : 1,
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.2.100:27017"
		}
	]
}
rs0:STARTUP2> rs.add("192.168.2.100:27018")
{
	"errmsg" : "exception: need most members up to reconfigure, not ok : 192.168.2.100:27018",
	"code" : 13144,
	"ok" : 0
}
rs0:PRIMARY> rs.add("192.168.2.100:27019")
{ "ok" : 1 }
rs0:PRIMARY> rs.conf()
{
	"_id" : "rs0",
	"version" : 2,
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.2.100:27017"
		},
		{
			"_id" : 1,
			"host" : "192.168.2.100:27019"
		}
	]
}
rs0:PRIMARY> rs.add("192.168.2.100:27018")
{ "down" : [ "192.168.2.100:27018" ], "ok" : 1 }
rs0:PRIMARY> rs.conf()
{
	"_id" : "rs0",
	"version" : 3,
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.2.100:27017"
		},
		{
			"_id" : 1,
			"host" : "192.168.2.100:27019"
		},
		{
			"_id" : 2,
			"host" : "192.168.2.100:27018"
		}
	]
}
rs0:PRIMARY> rs.status()
{
	"set" : "rs0",
	"date" : ISODate("2013-03-12T07:26:48Z"),
	"myState" : 1,
	"members" : [
		{
			"_id" : 0,
			"name" : "192.168.2.100:27017",
			"health" : 1,
			"state" : 1,
			"stateStr" : "PRIMARY",
			"uptime" : 210,
			"optime" : Timestamp(1363073190000, 1),
			"optimeDate" : ISODate("2013-03-12T07:26:30Z"),
			"self" : true
		},
		{
			"_id" : 1,
			"name" : "192.168.2.100:27019",
			"health" : 1,
			"state" : 2,
			"stateStr" : "SECONDARY",
			"uptime" : 41,
			"optime" : Timestamp(1363073190000, 1),
			"optimeDate" : ISODate("2013-03-12T07:26:30Z"),
			"lastHeartbeat" : ISODate("2013-03-12T07:26:47Z"),
			"pingMs" : 0
		},
		{
			"_id" : 2,
			"name" : "192.168.2.100:27018",
			"health" : 0,
			"state" : 8,
			"stateStr" : "(not reachable/healthy)",
			"uptime" : 0,
			"optime" : Timestamp(0, 0),
			"optimeDate" : ISODate("1970-01-01T00:00:00Z"),
			"lastHeartbeat" : ISODate("1970-01-01T00:00:00Z"),
			"pingMs" : 0,
			"errmsg" : "socket exception [CONNECT_ERROR] for 192.168.2.100:27018"
		}
	],
	"ok" : 1
}
rs0:PRIMARY>

#编译相应包，1.3源码编译出来的没有此jar包，需自己下载编译并放置到plugin/mongodb目录

git clone git://github.com/mongodb/mongo-java-driver.git
mvn clean package -Dmaven.test.skip=true

#编译输出：mongo-java-driver-2.11.0-SNAPSHOT.jar

#放置jar包：mongo-java-driver-2.11.0-SNAPSHOT.jar到插件目录下面
#最终插件的目录下：

C:\Projects\elasticsearch-rtf.0.19.4\plugins\mongodb>ls
elasticsearch-river-mongodb-1.3.0-SNAPSHOT.jar
mongo-java-driver-2.11.0-SNAPSHOT.jar

#fiddler创建mongodb-river的meta信息，一个collection，一个river配置

curl  -XPUT http://192.168.2.100:9200/_river/mongodb/_meta -d'
{ 
    "type": "mongodb", 
    "mongodb": {
 "servers":
    [
      { "host": "192.168.2.100", "port": 27017 },
      { "host": "192.168.2.100", "port": 27018 },      
      { "host": "192.168.2.100", "port": 27019 }
    ],
 
        "db": "testmongo", 
        "collection": "person"
    }, 
    "index": {
        "name": "mongoindex", 
        "type": "person" 
    }
}'

#创建另外一个collection的river配置

curl -XPUT http://192.168.2.100:9200/_river/mongodb_your_name/_meta -d'
{ 
    "type": "mongodb", 
    "mongodb": {
 "servers":
    [
      { "host": "192.168.2.100", "port": 27017 },
      { "host": "192.168.2.100", "port": 27018 },      
      { "host": "192.168.2.100", "port": 27019 }
    ],
 
        "db": "mydatabase", 
        "collection": "your_collection"
    }, 
    "index": {
        "name": "mongo-xxx", 
        "type": "your_type" 
    }
}
'

#往mongodb里面保存数据

use testmongo
var p = {firstName: "John", lastName: "Doe"}
db.person.save(p)
 
use mydatabase
var p = {firstName: "John", lastName: "Doe"}
db.your_collection.save(p)

#从elasticsearch里面查询数据

curl -XGET 'http://localhost:9200/mongoindex/_search?q=firstName:John'

#返回结果如下：

{
    "took": 12,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 2,
        "max_score": 1,
        "hits": [
            {
                "_index": "mongoindex",
                "_type": "person",
                "_id": "513ef017c1243708e42b6355",
                "_score": 1,
                "_source": {
                    "_id": "513ef017c1243708e42b6355",
                    "firstName": "John",
                    "lastName": "medcl"
                }
            },
            {
                "_index": "mongoindex",
                "_type": "person",
                "_id": "513edd36e0813607bee3b468",
                "_score": 1,
                "_source": {
                    "_id": "513edd36e0813607bee3b468",
                    "firstName": "John",
                    "lastName": "Doe"
                }
            }
        ]
    }
}

都来自于

https://github.com/richardwilly98/elasticsearch-river-mongodb

https://github.com/richardwilly98/elasticsearch-river-mongodb/wiki

http://satishgandham.com/2012/09/a-complete-guide-to-integrating-mongodb-with-elastic-search/

http://docs.mongodb.org/manual/tutorial/deploy-replica-set/

本文来自: mongodb&mongodb-river（elasticsearch）部署

 

 

大家可以加我个人微信号：scccdgf

 

 

或者关注soledede的微信公众号：soledede
微信公众号：
分享到：
| Top 20 Nginx WebServer Best Security Pra ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    基于MongoDB分布式集群架构的日志系统及分片方法.docx

    【基于MongoDB分布式集群架构的日志系统及分片方法】 MongoDB是一种流行的开源文档数据库，以其灵活性、可扩展性和高性能而被广泛应用于日志管理、大数据处理和其他领域。本技术方案涉及利用MongoDB的分布式集群...

    深入了解MongoDB 分布式集群

    MongoDB 分布式集群是MongoDB数据库系统中的一个重要特性，它允许数据库跨越多个服务器，以提供水平扩展、高可用性和故障恢复能力。MongoDB的分布式设计使得它能够处理大规模的数据存储和复杂的查询操作，适合于...

    MongoDB分布式搭建执行文件（直接可运行）搭建MongoDB分布式集群

    （3） 请在报告中使用文字和截图详细描述MongoDB分片集群搭建及配置的主要步骤： - 搭建配置集服务器（Mongod） - 搭建分片集服务器（Mongod） - 搭建路由节点服务器（Mongos） - 添加分片集到集群 - 创建数据库...

    MongoDB分布式集群搭建

    ### MongoDB分布式集群搭建详解 #### 一、集群与分布式概念 **集群(Cluster)**与**分布式(Distributed)**是两种常见的架构设计模式，用于提高系统的可用性、可伸缩性和性能。 1. **集群(Cluster)** - **定义**：...

    Linux安装ElasticSearch与MongoDB分布式集群环境下数据同步

    ### Linux安装ElasticSearch与MongoDB分布式集群环境下数据同步 #### 概述 在现代的大数据处理场景下，为了提高数据处理效率以及更好地利用资源，通常会采用多种数据库技术组合的方式来构建系统架构。Elastic...

    毕业设计后端 - 基于MongoDB分布式数据库集群的斗鱼弹幕采集系统设计.zip

    该毕业设计项目主要关注的是构建一个基于...综上所述，这个毕业设计项目涵盖了MongoDB分布式数据库的使用、实时数据采集、Node.js后端开发、Web系统架构等多个核心IT技术，对于学习和掌握这些技能提供了实战平台。

    MongoDB集群架构.pptx

    以下是对MongoDB集群架构的详细说明，包括复制集和分片集群的关键概念和最佳实践。 1. **复制集**： - **读写设置**：复制集的主要目的是提供高可用性。默认情况下，所有写操作都会发送到Primary节点，读操作也...

    58同城高级系统架构师带你实战MongoDB集群分布式存储

    #### 二、MongoDB集群架构设计 MongoDB支持多种部署模式，包括单机部署、主从复制、副本集和分片等。其中，**集群**主要是指通过**分片（Sharding）**和**副本集（Replica Set）**两种技术实现的数据分布和高可用...

    PHP高级工程师必知必会Nginx+keepalived+MongoDB+haproxy+Sphinx实现分布式集群部署实战视频

    本文将围绕“Nginx + keepalived + MongoDB + haproxy + Sphinx”这一技术栈，详细介绍如何实现一个稳定的分布式集群部署方案。 #### 二、关键技术解析 ##### 1. Nginx **定义**：Nginx是一款高性能的HTTP和反向...

    基于DBAF算法的MongoDB负载均衡策略.docx

    一、 MongoDB 分布式集群架构 MongoDB 的分布式集群架构由多个副本集、路由服务器以及配置服务器构成。在该架构中，副本集中的主节点服务器参与用户的访问，次节点作为主节点的备用节点增加整个系统的鲁棒性，配置...

    java面试 分布式 集群 mongodb redis

    ### Java面试中的分布式集群关键技术：MongoDB与Redis #### 心跳机制详解 在分布式系统中，为了确保各个节点间的连接稳定性和及时发现并处理断线情况，通常会使用心跳机制来保持通信链路的活跃状态。心跳机制的...

    基于MongoDB云计算下GML分布式集群环境搭建研究.pdf

    根据提供的文件内容，这篇文章主要探讨了在云计算环境下，如何基于MongoDB搭建GML（Geography Markup Language）分布式集群环境。接下来，我们将详细解析文章中涉及的关键知识点。 ### 分布式系统与分布式开发 ...

    大型分布式网站架构设计与实践.带目录书签.完整版

    《大型分布式网站架构设计与实践》是一本深入探讨如何构建高效、可扩展、高可用性的分布式网站架构的专业书籍。在当今互联网行业中，随着用户数量的急剧增长和业务复杂度的不断提升，传统的单体架构已无法满足需求，...

    基于MongoDB的高可用性分布式数据库集群技术研究.pdf

    特别是对于需要高并发处理能力和大数据量处理能力的应用场景，MongoDB的分布式架构可以提供显著的优势。同时，MongoDB支持动态查询、模式自由、完整的索引支持等特性，使得开发者能够灵活地构建各种复杂的应用。 在...

    mongodb分布式理解

    #### 一、MongoDB 集群架构 MongoDB 的分布式部署涉及多种服务组件，这些组件协同工作以提供高度可扩展且具有容错能力的数据存储解决方案。 **1.1 配置服务（Config Server）** 配置服务负责存储集群的元数据信息...

Magicbox
Global site tag (gtag.js) - Google Analytics