mongodb 简单部署方案及实例

第一节准备工作

一安装mongodb

 我这里选用rehl 5.6作为其运行载体。

 1. 下载mongodb的linux版本(注意32位和64位的区别)，下载地址：http://www.mongodb.org/downloads

  # wgethttp://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.3.tgz

 2. 将下载的mongodb安装文件 mongodb-linux-x86_64-2.6.3.tgz 放到/local/下

 3. 解压

  # tar -zxvfmongodb-linux-x86_64-2.6.3.tgz

  重命名

  # mvmongodb-linux-x86_64-2.6.3.tgz /local/mongodb

 4. 创建数据库文件目录， # mkdir -p /local/mongodbdata,我把数据库文件目录放在当前文件夹下，# mkdir -p db,创建日志目录 #mkdir -p logs

 

二启动

 首先用命令进入到bin目录下：cd /local/mongodb/bin

 

 方式一：直接运行命令启动

 ./mongod --port=10000 --fork--logpath=/local/mongodbdata/logs/mongodb.log --logappend--dbpath=/local/mongodbdata/db

 

 方式二：通过配置文件方式启动（推荐）。

 1.在服务器上新建mongodb.conf配置文件(建议用命令生成，放在mongodb同一个目录下)

 内容为：

 port=10000 #端口号

 fork=true #以守护进程的方式运行，创建服务器进程

 #master=true #单主从配置时设为主服务器

 #salve=true ##单主从配置时设为从服务器

 logpath=/local/mongodbdata/logs/mongodb.log#日志输出文件路径

 logappend=true #日志输出方式

 dbpath=/local/mongodbdata/db #数据库路径

 replSet=blort #设置富本集的名字

 shardsvr=true #设置是否分片

 2.运行./mongod --config ~/.mongodb.conf 命令(--config可以直接写成-f)。

 输出:

 all output going to: /ocal/mongodb/logs/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，默认目录/ocal/configdb

   --shardsvr                     # 声明这是一个集群的分片,默认端口27018

   --noMoveParanoia               # 关闭偏执为moveChunk数据保存? 

 

三查询进程和关闭数据库

 1. 运行 ps -ef | grep mongod 命令查询服务器进程

 2. 运行 kill -9 9870命令kill掉9870的进程

 

四进入数据库并简单操作数据库

 1.运行./mongo �Cport 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）

 2.vi /etc/sysconfig/iptables

-A INPUT -p tcp -m state --state NEW -mtcp --dport 1000 -j ACCEPT

-A INPUT -p tcp -m state --state NEW -mtcp --dport 2000 -j ACCEPT

-A INPUT -p tcp -m state --state NEW -mtcp --dport 3000 -j ACCEPT

 

-A INPUT -p tcp -m state --state NEW -mtcp --dport 3001 -j ACCEPT

-A INPUT -p tcp -m state --state NEW -mtcp --dport 3002 -j ACCEPT

-A INPUT -p tcp -m state --state NEW -mtcp --dport 3003 -j ACCEPT

-A INPUT -p tcp -m state --state NEW -mtcp --dport 3004 -j ACCEPT

-A INPUT -p tcp -m state --state NEW -mtcp --dport 3005 -j ACCEPT

 

第二节副本集

简单的说，副本集就是有自动故障恢复功能的主从集群，副本集没有固定的"主节点"，集群会通过投票选举一个"主节点"。当主节点岩机时，会变更到其他节点。副本集布在不同机器上时，至少要启动三个（单数）数据库服务器进程，否则启动时投票不成功会一直初始化不了。

 

一以配置文件方式启动三台机器上的数据库服务器

 1. 三台服务器的配置文件：

  port=10000 #端口号

  fork=true #以守护进程的方式运行，创建服务器进程

 logpath=local/mongodbdata/logs/mongodb.log #日志输出文件路径

  logappend=true #日志输出方式

  dbpath=/local/mongodbdata/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. 通命令启动三台数据库服务器

  /local/mongodb/bin/mongod -f/local/mongodbdata/blort1/config.conf

  /local/mongodb/bin/mongod -f/local/mongodbdata/blort2/config.conf

 /local/mongodb/bin/mongod -f/local/mongodbdata/blort3/config.conf

 

二初始化副本集（只能初始化一次）

/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");

 

四读扩展

 待研究

 

五用户校验

 未成功  (在admin里设置ok)

 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/local/mongodbdata/shard1-1/db/

 mkdir -p/local/mongodbdata/shard1-1/logs/

 

 /local/mongodbdata/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=/local/mongodbdata/shard1-1/logs/shard1-1.log   #日志输出文件路径

  logappend=true   #日志输出方式

 dbpath=/local/mongodbdata/shard1-1/db   #数据库路径

  directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录

  replSet=shard1   #设置富本集的名字为shard1,replSet是让服务器知道在这个"shard1"副本集中还有别的机器

 

  #auth=true # 启用验证

 

  mkdir -p/local/mongodbdata/shard1-1a/db/

  mkdir -p/local/mongodbdata/shard1-1a/logs/

 /local/mongodbdata/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=/local/mongodbdata/shard1-1a/logs/shard1-1a.log   #日志输出文件路径

  logappend=true   #日志输出方式

  dbpath= /local/mongodbdata/shard1-1a/db  #数据库路径

  directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录

  replSet=shard1   #设置富本集的名字为shard1,replSet是让服务器知道在这个"shard1"副本集中还有别的机器

 

  #auth=true # 启用验证

  

 mkdir -p/local/mongodbdata/shard1-2/db/

 mkdir -p/local/mongodbdata/shard1-2/logs/

 /local/mongodbdata/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=/local/mongodbdata/shard1-2/logs/shard1-2.log   #日志输出文件路径

  logappend=true   #日志输出方式

 dbpath=/local/mongodbdata/shard1-2/db   #数据库路径

  directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录

  replSet=shard1   #设置富本集的名字为shard1,replSet是让服务器知道在这个"shard1"副本集中还有别的机器

 

  #auth=true # 启用验证

 

 mkdir -p/local/mongodbdata/shard2-1/db/

 mkdir -p/local/mongodbdata/shard2-1/logs/

 /local/mongodbdata/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=/local/mongodbdata/shard2-1/logs/shard2-1.log   #日志输出文件路径

  logappend=true   #日志输出方式

 dbpath=/local/mongodbdata/shard2-1/db   #数据库路径

  directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录

  replSet=shard2   #设置富本集的名字为shard2,replSet是让服务器知道在这个"shard2"副本集中还有别的机器

 

  #auth=true # 启用验证

 

 mkdir -p/local/mongodbdata/shard2-1a/db/

 mkdir -p/local/mongodbdata/shard2-1a/logs/

 /local/mongodbdata/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=/local/mongodbdata/shard2-1a/logs/shard2-1a.log   #日志输出文件路径

  logappend=true   #日志输出方式

 dbpath=/local/mongodbdata/shard2-1a/db   #数据库路径

  directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录

  replSet=shard2   #设置富本集的名字为shard2,replSet是让服务器知道在这个"shard2"副本集中还有别的机器

 

  #auth=true # 启用验证

 

 mkdir -p/local/mongodbdata/shard2-2/db/

 mkdir -p/local/mongodbdata/shard2-2/logs/

 /local/mongodbdata/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=/local/mongodbdata/shard2-2/logs/shard2-2.log   #日志输出文件路径

  logappend=true   #日志输出方式

 dbpath=/local/mongodbdata/shard2-2/db   #数据库路径

  directoryperdb=true  # 设置每个数据库将被保存在一个单独的目录

  replSet=shard2   #设置富本集的名字为shard2,replSet是让服务器知道在这个"shard2"副本集中还有别的机器

 

  #auth=true # 启用验证

 

 mkdir -p /local/mongodbdata/config1/db/

 mkdir -p/local/mongodbdata/config1/logs/

 /local/mongodbdata/config1/config.conf

  dbpath =/local/mongodbdata/config1/db

  configsvr = true

  port = 40001

  logpath=/local/mongodbdata/config1/logs/config1.log

  logappend = true

  fork = true

 

  #auth=true # 启用验证

 

 mkdir -p/local/mongodbdata/config2/db/

 mkdir -p/local/mongodbdb/config2/logs/

 /local/mongodbdata/config2/config.conf

  dbpath =/local/mongodbdata/config2/db

  configsvr = true

  port = 40002

  logpath=/local/mongodbdata/config2/logs/config2.log

  logappend = true

  fork = true

 

  #auth=true # 启用验证

 

 mkdir -p/local/mongodbdata/config3/db/

 mkdir -p/local/mongodbdata/config3/logs/

 /local/mongodbdata/config3/config.conf

  dbpath = /local/mongodb/config3/db

  configsvr = true

  port = 40003

  logpath=/local/mongodbdata/config3/logs/config3.log

  logappend = true

  fork = true

 

  #auth=true # 启用验证

 

 mkdir -p /local/mongodbdata /mongos1/logs/

 /local/mongodbdata/mongos1/config.conf

  configdb=10.10.113.122:40001,10.10.113.122:40002,10.10.113.122:40003

  port = 50001

  chunkSize = 1

  logpath=/local/mongodbdata/mongos1/logs/mongos1.log

  logappend = true

  fork = true

 

  #auth=true # 启用验证

 

 mkdir -p/local/mongodbdata/mongos2/logs/

 /local/mongodbdata/mongos2/config.conf

  configdb=10.10.113.122:40001,10.10.113.122:40002,10.10.113.122:40003

  port = 50002

  chunkSize = 1

  logpath=/local/mongodbdata/mongos2/logs/mongos2.log

  logappend = true

  fork = true

 

  #auth=true # 启用验证

 

二启动

 

 shard1 副本启动

 /local/mongodb/bin/mongod -f/local/mongodbdata/shard1-1/config.conf

 /local/mongodb/bin/mongod -f/local/mongodbdata/shard1-1a/config.conf

 /local/mongodb/bin/mongod -f/local/mongodbdata/shard1-2/config.conf

 

/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 副本启动

 /local/mongodb/bin/mongod -f/local/mongodbdata/shard2-1/config.conf

 /local/mongodb/bin/mongod -f/local/mongodbdata/shard2-1a/config.conf

 /local/mongodb/bin/mongod -f/local/mongodbdata/shard2-2/config.conf

 

/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 启动

 /local/mongodb/bin/mongod -f /local/mongodbdata/config1/config.conf

 config2 启动

 /local/mongodb/bin/mongod -f /local/mongodbdata/config2/config.conf

 config3 启动

 /local/mongodb/bin/mongod -f /local/mongodbdata/config3/config.conf

 

 mongos1 启动

 /local/mongodb/bin/mongos -f /local/mongodbdata/mongos1/config.conf

 mongos2 启动

 /local/mongodb/bin/mongos -f /local/mongodbdata/mongos2/config.conf

  

 /local/mongodb/bin/mongo --port50001

 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 Server210.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 [email protected]:/root

 # ssh 10.10.113.132

 

 删除目录

 # rm -r -f  /local/mongodbdata

 

 创建配置、日志、分片、key文件存储目录及验证文件

 

 mkdir /local/mongodbdata/configsvr/ -p

 

 mkdir  /local/mongodbdata/logs/-p

 

 mkdir  /local/mongodbdata/shard1/-p

 

 mkdir /local/mongodbdata/shard2/-p

 

 mkdir /local/mongodbdata/shard3/ -p

 

 mkdir  /local/mongodbdata/key/-p

 

 mkdir /local/mongodbdata/conf/security/ -p

 mkdir /local/mongodbdata/conf/nosecurity/ -p

 

 创建配置文件

  1、创建验证文件security于 /local/mongodbdata/key/目录，关赋予可读权限，命令如下：

  cd  /local/mongodbdata/key/

  echo 'hycloudmongodbkey' >security

  chmod 600 security

 

  2、创建shard1.conf、shard2.conf、shard3.conf、configsvr.conf、mongos.conf于 /local/mongodbdata/conf/security/ 和  /local/mongodbdata/conf/nosecurity/的目录，内容分别如下：

#shard1.conf

dbpath =  /local/mongodbdata/shard1

directoryperdb = true

shardsvr = true

replSet = shard1

#bind_ip = 10.10.113.122,localhost

port = 10001

oplogSize = 100

logpath = /local/mongodbdata/logs/shard1.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile= /local/mongodbdata/key/security  #nosecurity目录将该行删除

 

#shard2.conf

dbpath =  /local/mongodbdata/shard2

directoryperdb = true

shardsvr = true

replSet = shard2

#bind_ip = 10.10.113.122,localhost

port = 10002

oplogSize = 100

logpath = /local/mongodbdata/logs/shard2.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /local/mongodbdata/key/security  #nosecurity目录将该行删除

 

#shard3.conf

dbpath =  /local/mongodbdata/shard3

directoryperdb = true

shardsvr = true

replSet = shard3

#bind_ip = 10.10.113.122,localhost

port = 10003

oplogSize = 100

logpath = /local/mongodbdata/logs/shard3.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile = /local/mongodbdata/key/security  #nosecurity目录将该行删除

 

#configsvr.conf

dbpath = /local/mongodbdata/configsvr

directoryperdb = true

configsvr = true

port = 20000

logpath= /local/mongodbdata/logs/configsvr.log

logappend = true

fork = true

keyFile =  /local/mongodbdata/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= /local/mongodbdata/logs/mongos.log

logappend = true

fork = true

keyFile= /local/mongodbdata/key/security  #nosecurity目录将该行删除

 

分片配置

  说明：分片要在无验证环境中配置，否则会出现无权限等异常。采用以下命令启动Server1\Server2\Server3上的shard1\shard2\shard3：

 

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

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

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

 

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

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

 

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

  # /local/mongodb/bin/mongo --port10001

 

  >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

  # /local/mongodb/bin/mongo --port10002

  >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

 

  # /local/mongodb/bin/mongo --port10003

  >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来连接分片服务器，在启动路由进程时，先启动配置进程，路由配置过程如下：

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

  # /local/mongodb/bin/mongos -f /local/mongodbdata/conf/nosecurity/mongos.conf

 

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

  # /local/mongodb/bin/mongo --port30000

  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库创建管理员帐号

  # /local/mongodb/bin/mongo --port30000

  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

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

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

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

  # netstat -lnpt

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

  # /local/mongodb/bin/mongos -f /local/mongodbdata/conf/security/mongos.conf

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

  # /local/mongodb/bin/mongo10.10.113.122:30000/admin

  MongoDB shell version: 2.0.4

  connectingto:10.10.113.122:30000/admin

  > show dbs

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

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

  # /local/mongodb/bin/mongo10.10.113.122:30000/admin

  MongoDB shell version: 2.0.4

  connectingto: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

 

  # /local/mongodb/bin/mongo10.10.113.122:30000/hello -u sa -p

  MongoDB shell version: 2.0.4

  Enter password:

  connectingto: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" }

 

 

  分片

  # /local/mongodb/bin/mongo -port30000

  > 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 Server110.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 [email protected]:/root

 # ssh 10.10.113.132

 

 

 创建配置、日志、分片、key文件存储目录及验证文件

 mkdir /local/mongodbdata/configsvr/ -p

 mkdir  /local/mongodbdata/logs/-p

 mkdir  /local/mongodbdata/shard1/-p

 mkdir  /local/mongodbdata/shard2/-p

 mkdir  /local/mongodbdata/shard3/-p

 mkdir  /local/mongodbdata/key/-p

 mkdir  /local/mongodbdata/conf/security/-p

 mkdir /local/mongodbdata/conf/nosecurity/-p

 

 创建配置文件

  1、创建验证文件security于 /local/mongodbdata/key/目录，关赋予可读权限，命令如下：

  cd  /local/mongodbdata/key/

  echo 'hycloudmongodbkey' >security

  chmod 600 /local/mongodbdata/key/security

 

  2、创建shard1.conf、shard2.conf、shard3.conf、configsvr.conf、mongos.conf于 /local/mongodbdata/conf/security/ 和 /local/mongodbdata/conf/nosecurity/的目录，内容分别如下：

  shard1.conf

 

dbpath = /local/mongodbdata/shard1

directoryperdb = true

shardsvr = true

replSet = shard1

#bind_ip = 10.10.113.122,localhost

port = 10001

oplogSize = 100

logpath= /local/mongodbdata/logs/shard1.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile =  /local/mongodbdata/key/security #nosecurity目录将该行删除

 

  shard2.conf

dbpath =  /local/mongodbdata/shard2

directoryperdb = true

shardsvr = true

replSet = shard2

#bind_ip = 10.10.113.122,localhost

port = 10002

oplogSize = 100

logpath= /local/mongodbdata/logs/shard2.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile =  /local/mongodbdata/key/security #nosecurity目录将该行删除

 

  shard3.conf

dbpath = /local/mongodbdata/shard3

directoryperdb = true

shardsvr = true

replSet = shard3

#bind_ip = 10.10.113.122,localhost

port = 10003

oplogSize = 100

logpath =  /local/mongodbdata/logs/shard3.log

logappend = true

profile = 1

slowms = 5

rest = true

fork = true

keyFile =  /local/mongodbdata/key/security #nosecurity目录将该行删除

 

configsvr.conf

dbpath =  /local/mongodbdata/configsvr

directoryperdb = true

configsvr = true

port = 20000

logpath= /local/mongodbdata/logs/configsvr.log

logappend = true

fork = true

keyFile =  /local/mongodbdata/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 = /local/mongodbdata/logs/mongos.log

logappend = true

fork = true

keyFile =  /local/mongodbdata/key/security #nosecurity目录将该行删除

 

 分片配置

  说明：分片要在无验证环境中配置，否则会出现无权限等异常。采用以下命令启动Server1\Server2\Server3上的shard1\shard2\shard3：

 

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

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

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

 

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

 

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

 

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

 

  # /local/mongodb/bin/mongo --port10001

  >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

 

  # /local/mongodb/bin/mongo --port10002

  >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

  # /local/mongodb/bin/mongo --port10003

  >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来连接分片服务器，在启动路由进程时，先启动配置进程，路由配置过程如下：

 

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

  # /local/mongodb/bin/mongos -f  /local/mongodbdata/conf/nosecurity/mongos.conf

 

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

 

  # /local/mongodb/bin/mongo --port30000

 

  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库创建管理员帐号

 

  # /local/mongodb/bin/mongo --port30000

  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')

  mongos>exit

 

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

 

  # killall mongod mongos

  # netstat -lnpt

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

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

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

  # netstat -lnpt # ps -ef | grepmongo

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

  # /local/mongodb/bin/mongos -f  /local/mongodbdata/conf/security/mongos.conf

 

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

 

  # /local/mongodb/bin/mongo10.10.113.122:30000/admin

  MongoDB shell version: 2.0.4

  connectingto:10.10.113.122:30000/admin

  > show dbs

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

 

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

 

  # /local/mongodb/bin/mongo10.10.113.122:30000/admin

  MongoDB shell version: 2.0.4

  connectingto: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

 

  # /local/mongodb/bin/mongo10.10.113.122:30000/hello -u sa -p

  MongoDB shell version: 2.0.4

  Enter password:

  connectingto: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" }

 

 分片

  # /local/mongodb/bin/mongo -port30000

 

  > 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()

  

shell操作数据库：

 

  1.  超级用户相关：

        1. #进入数据库admin

         useadmin

        2. #增加或修改用户密码

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

        3. #查看用户列表

        db.system.users.find()

        4. #用户认证

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

        5. #删除用户

        db.removeUser('name')

        6. #查看所有用户

         showusers

        7. #查看所有数据库

         show dbs

        8. #查看所有的collection

         showcollections

        9. #查看各collection的状态

        db.printCollectionStats()

       10. #查看主从复制状态

        db.printReplicationInfo()

       11. #修复数据库

        db.repairDatabase()

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

        db.setProfilingLevel(1)

       13. #查看profiling

         showprofile

       14. #拷贝数据库

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

       15. #删除collection

        db.mail_addr.drop()

       16. #删除当前的数据库

        db.dropDatabase()

 

  2. 增删改

        1. #存储嵌套的对象

          db.foo.save({'name':'ysz','address':{'city':'beijing','post':100096},'phone':[138,139]})

        2. #存储数组对象

          db.user_addr.save({'Uid':'[email protected]','Al':['[email protected]','[email protected]']})

        3. #根据query条件修改，如果不存在则插入，允许修改多条记录

          db.foo.update({'yy':5},{'$set':{'xx':2}},upsert=true,multi=true)

        4. #删除yy=5的记录

          db.foo.remove({'yy':5})

        5. #删除所有的记录

          db.foo.remove()

 

  3. 索引

        1. #增加索引：1(ascending),-1(descending)

        2.db.foo.ensureIndex({firstname: 1, lastname: 1}, {unique: true});

        3. #索引子对象

        4.db.user_addr.ensureIndex({'Al.Em': 1})

        5. #查看索引信息

        6.db.foo.getIndexes()

        7.db.foo.getIndexKeys()

        8. #根据索引名删除索引

        9.db.user_addr.dropIndex('Al.Em_1')

 

  4. 查询

       1. #查找所有

       2.db.foo.find()

       3. #查找一条记录

       4.db.foo.findOne()

       5. #根据条件检索10条记录

       6.db.foo.find({'msg':'Hello 1'}).limit(10)

       7. #sort排序

       8. db.deliver_status.find({'From':'[email protected]'}).sort({'Dt',-1})

       9.db.deliver_status.find().sort({'Ct':-1}).limit(1)

       10. #count操作

       11.db.user_addr.count()

       12. #distinct操作,查询指定列，去重复

       13.db.foo.distinct('msg')

       14. #”>=”操作

       15.db.foo.find({"timestamp": {"$gte" : 2}})

       16. #子对象的查找

       17.db.foo.find({'address.city':'beijing'})

 

  5. 管理

        1. #查看collection数据的大小

        2.db.deliver_status.dataSize()

        3. #查看colleciont状态

        4.db.deliver_status.stats()

        5. #查询所有索引的大小

        6.db.deliver_status.totalIndexSize()

 

  6.  advanced queries:高级查询

 

条件操作符

$gt : >

$lt : <

$gte: >=

$lte: <=

$ne : !=、<>

$in : in

$nin: not in

$all: all

$not: 反匹配(1.3.3及以上版本)

 

查询 name <> "bruce" and age>= 18 的数据

db.users.find({name: {$ne:"bruce"}, age: {$gte: 18}});

 

查询 creation_date > '2010-01-01' andcreation_date <= '2010-12-31' 的数据

db.users.find({creation_date:{$gt:newDate(2010,0,1), $lte:new Date(2010,11,31)});

 

查询 age in (20,22,24,26) 的数据

db.users.find({age: {$in:[20,22,24,26]}});

 

查询 age取模10等于0 的数据

db.users.find('this.age % 10 == 0');

或者

db.users.find({age : {$mod : [10, 0]}});

 

匹配所有

db.users.find({favorite_number : {$all :[6, 8]}});

可以查询出{name: 'David', age: 26, favorite_number:[ 6, 8, 9 ] }

可以不查询出{name: 'David', age: 26, favorite_number:[ 6, 7, 9 ] }

 

查询不匹配name=B*带头的记录

db.users.find({name: {$not: /^B.*/}});

查询 age取模10不等于0 的数据

db.users.find({age : {$not: {$mod : [10,0]}}});

 

#返回部分字段

选择返回age和_id字段(_id字段总是会被返回)

db.users.find({}, {age:1});

db.users.find({}, {age:3});

db.users.find({}, {age:true});

db.users.find({ name : "bruce"}, {age:1});

0为false, 非0为true

 

选择返回age、address和_id字段

db.users.find({ name : "bruce"}, {age:1, address:1});

 

排除返回age、address和_id字段

db.users.find({}, {age:0, address:false});

db.users.find({ name : "bruce"}, {age:0, address:false});

 

数组元素个数判断

对于{name: 'David', age: 26, favorite_number:[ 6, 7, 9 ] }记录

匹配db.users.find({favorite_number: {$size:3}});

不匹配db.users.find({favorite_number: {$size:2}});

 

$exists判断字段是否存在

查询所有存在name字段的记录

db.users.find({name: {$exists: true}});

查询所有不存在phone字段的记录

db.users.find({phone: {$exists: false}});

 

$type判断字段类型

查询所有name字段是字符类型的

db.users.find({name: {$type: 2}});

查询所有age字段是整型的

db.users.find({age: {$type: 16}});

 

对于字符字段，可以使用正则表达式

查询以字母b或者B带头的所有记录

db.users.find({name: /^b.*/i});

 

$elemMatch(1.3.1及以上版本)

为数组的字段中匹配其中某个元素

 

Javascript查询和$where查询

查询 age > 18 的记录，以下查询都一样

db.users.find({age: {$gt: 18}});

db.users.find({$where: "this.age >18"});

db.users.find("this.age >18");

f = function() {return this.age > 18}db.users.find(f);

 

排序sort()

以年龄升序asc

db.users.find().sort({age: 1});

以年龄降序desc

db.users.find().sort({age: -1});

 

限制返回记录数量limit()

返回5条记录

db.users.find().limit(5);

返回3条记录并打印信息

db.users.find().limit(3).forEach(function(user){print('my age is ' + user.age)});

结果

my age is 18

my age is 19

my age is 20

 

限制返回记录的开始点skip()

从第3条记录开始，返回5条记录(limit 3, 5)

db.users.find().skip(3).limit(5);

 

查询记录条数count()

db.users.find().count();

db.users.find({age:18}).count();

以下返回的不是5，而是user表中所有的记录数量

db.users.find().skip(10).limit(5).count();

如果要返回限制之后的记录数量，要使用count(true)或者count(非0)

db.users.find().skip(10).limit(5).count(true);

 

分组group()

假设test表只有以下一条数据

{ domain: "www.mongodb.org"

, invoked_at: {d:"2009-11-03",t:"17:14:05"}

, response_time: 0.05

, http_action: "GET/display/DOCS/Aggregation"

}

使用group统计test表11月份的数据count:count(*)、total_time:sum(response_time)、avg_time:total_time/count;

db.test.group(

{ cond: {"invoked_at.d": {$gt:"2009-11", $lt: "2009-12"}}

, key: {http_action: true}

, initial: {count: 0, total_time:0}

, reduce: function(doc, out){ out.count++;out.total_time+=doc.response_time }

, finalize: function(out){ out.avg_time =out.total_time / out.count }

} );

 

[

{

"http_action" : "GET/display/DOCS/Aggregation",

"count" : 1,

"total_time" : 0.05,

"avg_time" : 0.05

}

]

 

Java 应用示例

要使用Java操作MongoDB的话，要到官方网站下载一个驱动包，把包导入后，可以尝试来操作了（记得一定要开着服务器）

首先介绍一下比较常用的几个类

Mongo：连接服务器，执行一些数据库操作的选项，如新建立一个数据库等

DB：对应一个数据库，可以用来建立集合等操作

DBCollection：对应一个集合（类似表），可能是我们用得最多的，可以添加删除记录等

DBObjec：接口和BasicDBObject对象：表示一个具体的记录，BasicDBObject实现了DBObject，因为是key-value的数据结构，所以用起来其实和HashMap是基本一致的

DBCursor：用来遍历取得的数据，实现了Iterable和Iterator接下来实际的操作一下，代码如下：

import java.net.UnknownHostException;

import java.util.List;

import java.util.Set;

import com.mongodb.BasicDBObject;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.DBObject;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

public class MongoDbTest {

 public static void main(String[]args) throws UnknownHostException, MongoException {

   //Mongo m = new Mongo();

//Mongo m = newMongo("localhost");

//获得数据库服务

Mongo m = new Mongo("localhost",27017);

//得到数据库mytest

DB db = m.getDB("mytest");

//得到mytest数据库下所有表名

   Set<String> colls =db.getCollectionNames();

   for (String s : colls) {

      System.out.println(s);

}

//得到testCollection表

DBCollection coll =db.getCollection("testCollection");

//new 一个BasicDBObject对象doc

BasicDBObject doc = new BasicDBObject();

//赋值

   doc.put("name","MongoDB");

   doc.put("type","database");

doc.put("count", 1);

//又new 一个BasicDBObject对象info

   BasicDBObject info = newBasicDBObject();

   info.put("x", 203);

info.put("y", 102);

//把info放入doc

doc.put("info", info);

//向testCollection表中插入一条数据

coll.insert(doc);

//查询一条数据

   DBObject myDoc =coll.findOne();

   System.out.println(myDoc);

 

   //循环插入100条数据到testCollection

   for (int i=0; i < 100;i++) {

     coll.insert(newBasicDBObject().append("i", i));

   }

   //Counting Documents in ACollection

  System.out.println(coll.getCount());

 

   //Using a Cursor to Get Allthe Documents

   DBCursor cur = coll.find();

   while(cur.hasNext()){<span st

 

use java to connect mongodb

 

package cn.itcast.mongodb;

 

import org.bson.types.ObjectId;

import org.junit.Test;

 

import com.mongodb.BasicDBObject;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.DBObject;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

import com.mongodb.WriteResult;

 

public class mongodbtest {

//find all document from mongodb

@Test

public void test1() throws Exception{

Mongo mongo = newMongo("192.168.1.3",27017);

DB db = mongo.getDB("tcl");

DBCollection collection =db.getCollection("user");

DBCursor find = collection.find();

while(find.hasNext()){

//Object next =find.next().get("name");

DBObject next = find.next();

System.out.println(next);

}

mongo.close();

}

 

//remove _id 52de44cde6909fbbb65f6adf user9999

@Test

public void test2() throws Exception,MongoException{

Mongo mongo = newMongo("192.168.1.3",27017);

DB db = mongo.getDB("tcl");

DBCollection collection =db.getCollection("user");

BasicDBObject o = newBasicDBObject("_id",newObjectId("52de44cde6909fbbb65f6adf"));

   //BasicDBObject o = newBasicDBObject("name","user9999"));

WriteResult remove = collection.remove(o);

System.out.println(remove.getN());

DBCursor find = collection.find();

while(find.hasNext()){

//Object next =find.next().get("name");

DBObject next = find.next();

System.out.println(next);

}

mongo.close();

}

// insert into collection {id:10000000name:davy age:25}

@Test

public void test3() throws Exception,MongoException{

Mongo mongo = newMongo("192.168.1.3",27017);

DB db = mongo.getDB("tcl");

DBCollection collection =db.getCollection("user");

BasicDBObject basicDBObject = newBasicDBObject();

basicDBObject.put("id","1000000");

basicDBObject.put("name","davy");

basicDBObject.put("age","25");

collection.insert(basicDBObject);

DBCursor find = collection.find();

while(find.hasNext()){

//Object next =find.next().get("name");

DBObject next = find.next();

System.out.println(next);

}

mongo.close();

}

// update name davy

@Test

public void test4() throws Exception,MongoException{

Mongo mongo = newMongo("192.168.1.3",27017);

DB db = mongo.getDB("tcl");

DBCollection collection =db.getCollection("user");

BasicDBObject obj = newBasicDBObject("name","davy");

DBObject findOne =collection.findOne(obj);

findOne.put("age","50");

collection.update(obj, findOne);

DBCursor find = collection.find();

while(find.hasNext()){

//Object next =find.next().get("name");

DBObject next = find.next();

System.out.println(next);

}

mongo.close();

}

}

我们在做一个共有云的项目，把我们的lab实验环境放到公有云上去供大家学习架构和测试性能。学习如何把你管理的服务器和应用产品上工程化平台统一管理。（参考互联网金融企业，安全性 稳定性 大容量 高可用）。一起共建我们的《云络智慧城市》，欢迎大家和大家的技术发烧友一起加入我们的qq群262407268。。申明该群是一个公益性社区，我们愿意承接一些架构的设计，建设和咨询业务，为您和您的企业改善业务架构。