金沙棋牌简单部署方案及实例,的使用及仓储设

2019-10-06 13:03 来源:未知

简单的介绍一下,我使用MongoDB的场景。

mongodb 简单部署方案及实例

我们现在的物联网环境下,有部分数据,采样频率为2000条记录/分钟,这样下来一天24*60*2000=2880000约等于300万条数据,以后必然还会增加。之前数据库使用的是mssql,对于数据库的压力很大,同时又需要保证历史查询的响应速度,这种情况下,在单表中数据量大,同时存在读写操作。不得已采用MongoDB来存储数据。如果使用MongoDB,则至少需要三台机器,两台实现读写分离,一台作为仲裁(当然条件不允许也可以不用),每台机器的内存暂时配置在16G,公司小,没办法,据说,使用这个MongoDB需要机器内存最少92G,我没有验证过,但是吃内存是公认的,所以内存绝对要保证,就算保证了,也不一定完全就没有意外发生。我们上面的这些特殊的数据是允许少量的丢失的,这些只是做分析使用的,几个月了,暂时还没出现数据丢失的情况,可能最新版本早就修复了吧,新手使用建议多看下官网上的说明。下面直接奔入主题:

转载:http://my.oschina.net/zhuzhu0129/blog/53290

一、安装部署和配置环境

 

1.安装部署mongo-server(V3.4)

参考

这个时候不要启动,接着配置config文件

 

2.配置Config文件

dbpath=C:/Program Files/MongoDB/Server/3.4/bin/data/db 

logpath=C:/Program Files/MongoDB/Server/3.4/bin/data/log/master.log 

pidfilepath=C:/Program Files/MongoDB/Server/3.4/bin/master.pid 

directoryperdb=true 

logappend=true 

replSet=testrs 

bind_ip=10.1.5.25

port=27016 

oplogSize=10000

noauth = true

 

storageEngine = wiredTiger

wiredTigerCacheSizeGB = 2

syncdelay = 30

wiredTigerCollectionBlockCompressor = snappy

 

以上是详细的配置参数,其中路径部分根据需要更改, 这里设置的oplogsize大小为10G,根据业务场景进行调整,另外auth权限为null,因为设置权限会增加服务开销,影响效率,最下面几行是内存引擎,可以控制副本集同步及内存限制,防止内存泄露。

第一节 准备工作
 一 安装mongodb
  我这里选用rehl 5.6作为其运行载体。
  1. 下载mongodb的linux版本(注意32位和64位的区别),下载地址:
   # wget 
  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 参数

3.启动mongo-server

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

4.添加副本集配置

conf=

{

    "_id" : "testrs",

    "members" : [

        { "_id" : 0,  "host" : "10.1.5.25:27016"  },

        { "_id" : 1,  "host" : "10.1.5.26:27016"  },

        { "_id" : 2,  "host" : "10.1.5.27:27016"  }

    ]

}

 

rs.initiate(conf)

此时副本集集群配置已经完成,然后在命令行中输入:rs.status(),查看副本集状态,需要查看同步情况,可以输入命令:db.serverStatus().

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

5.设置副本集可读写

Rs.slaveOk()

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

6..NET操作mongo

连接设置,请参考个人封装Unitoon.Mongo代码所示。

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

7.性能对比

读写速度:Redis>Mongo>Mssqlserver

可容纳数据量:Mssqlserver~Mongo>Redis

存储数据类型:Mongo>Mssqlserver>Redis

 

Note:内存持续上升,内部没有内存回收机制,若限制内存 ,则可能出现查询速度变慢,数据丢失等问题,建议优化查询效率,建立索引

Db.test.ensureIndex({"username":1, "age":-1})

强制释放内存命令:db.runCommand({closeAllDatabases:1})

 

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

二、仓储设计

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

1.基类BaseEntity

namespace UnitoonIot.Mongo
{
    /// <summary>
    /// 实体基类,方便生成ObjId
    /// </summary>
    [Serializable]
    [ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
   //[ProtoInclude(10, typeof(NormalHistory))]
    public class BaseEntity
    {
        //[BsonRepresentation(BsonType.ObjectId)]
        public ObjectId Id { get; set; }

        /// <summary>
        /// 数据库名称
        /// </summary>
        public string DbName { get; set; }

        /// <summary>
        /// 给对象初值
        /// </summary>
        public BaseEntity()
        {
           // this.ObjId = ObjectId.GenerateNewId().ToString();
            //this.Id = ObjectId.NewObjectId().ToString();
        }
    }
}

这里需要注意时间格式,MongoDB默认时间格式为国际时间,所以在写入数据时和读取数据时,时间格式要一致,此例中没有对时间进行特殊处理,由传入的时间格式确定。

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

2.Repository继承接口IMongoRepository

 

namespace UnitoonIot.Mongo
{
   public interface IMongoRepository<TEntity> where TEntity : class
    {
    }
}

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

3.MongoRepository

using MongoDB.Driver;
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver.Linq;
using System.Configuration;
using System.IO;
using UnitoonIot.AppSetting;

namespace UnitoonIot.Mongo
{

    public class MongoDb
    {
        private static  string ConnectionStringHost ;
        private static  string UserName ;
        private static  string Password;
        private static IMongoDatabase _db = null;
        private static readonly object LockHelper = new object();
        /// <summary>
        /// mongodb初始化
        /// </summary>
        public static void Init()
        {
            ConnectionStringHost = "10.1.5.24:27016,10.1.5.24:27016,10.1.5.26:27017";
            //AppSettings.GetConfigValue("MongoHost");//"10.1.5.24:27016";
            UserName = AppSettings.GetConfigValue("MongoUserName");
            Password = AppSettings.GetConfigValue("MongoPwd");
        }
        static MongoDb()
        {

        }
       public static IMongoDatabase GetDb(string dbName,string options=null)
        {

            if (_db != null) return _db;
            lock (LockHelper)
            {

                if (_db != null) return _db;
                var database = dbName;
                var userName = UserName;
                var password = Password;
                var authentication = string.Empty;
                var host = string.Empty;
                if (!string.IsNullOrWhiteSpace(userName))
                {
                    authentication = string.Concat(userName, ':', password, '@');
                }
                if (!string.IsNullOrEmpty(options) && !options.StartsWith("?"))
                {
                    options = string.Concat('?', options);
                }



                host = string.IsNullOrEmpty(ConnectionStringHost) ? "localhost" : ConnectionStringHost;
                database = database ?? "testdb";
                //mongodb://[username:password@]host1[:port1][,host2[:port2],…[,hostN[:portN]]][/[database][?options]]

                var conString = options!=null? $"mongodb://{authentication}{host}/{database}{options}"
                    : $"mongodb://{authentication}{host}/{database}";

                var url = new MongoUrl(conString);
                var mcs = MongoClientSettings.FromUrl(url);
                mcs.MaxConnectionLifeTime = TimeSpan.FromMilliseconds(1000);
                var client = new MongoClient(mcs);

                _db = client.GetDatabase(url.DatabaseName);
            }
            return _db;
        }
    }
    /// <summary>
    /// MongoDb 数据库操作类
    /// </summary>
    public class MongoRepository<T>: IMongoRepository<T> where T :  BaseEntity
    {
        #region readonly field
        /// <summary>
        /// 表名
        /// </summary>
        private readonly IMongoCollection<T> _collection = null;
        /// <summary>
        /// 数据库对象
        /// </summary>
        private readonly IMongoDatabase _database;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public MongoRepository()
        {
            this._database = MongoDb.GetDb(Activator.CreateInstance<T>().DbName, "readPreference =secondaryPreferred ");//primaryPreferred/secondaryPreferred/nearest
            _collection = _database.GetCollection<T>(typeof(T).Name);
        }


        #region 增加
        /// <summary>
        /// 插入对象
        /// </summary>
        /// <param name="t">插入的对象</param>
        public virtual T Insert(T t)
        {
           // var flag = ObjectId.GenerateNewId();
           // t.GetType().GetProperty("Id").SetValue(t, flag);    
            //t.Time = DateTime.Now;

            _collection.InsertOne(t);
            return t;
        }
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="ts">要插入的对象集合</param>
        public virtual IEnumerable<T> InsertBatch(IEnumerable<T> ts)
        {
            _collection.InsertMany(ts);
            return ts;
        }

        /// <summary>
        /// 插入对象
        /// </summary>
        /// <param name="t">插入的对象</param>
        public virtual  void InsertAsync(T t)
        {
            //var flag = ObjectId.GenerateNewId();
           // t.GetType().GetProperty("Id").SetValue(t, flag);
           // t.Time = DateTime.Now;
             _collection.InsertOneAsync(t);
        }
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="ts">要插入的对象集合</param>
        public virtual void InsertBatchAsync(IEnumerable<T> ts)
        {
             _collection.InsertManyAsync(ts);
        }
        #endregion

        #region 删除
        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public virtual long Delete(T t)
        {
            var filter = Builders<T>.Filter.Eq("Id", t.Id);
            var result = _collection.DeleteOne(filter);
            return result.DeletedCount;          
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public virtual  void DeleteAsync(T t)
        {
            var filter = Builders<T>.Filter.Eq("Id", t.Id);
            _collection.DeleteOneAsync(filter);
        }

        /// <summary>
        /// 按条件表达式删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual long Delete(Expression<Func<T, bool>> predicate)
        {
            var result = _collection.DeleteOne(predicate);
            return result.DeletedCount;
        }
        /// <summary>
        /// 按条件表达式删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual  void DeleteAsync(Expression<Func<T, bool>> predicate)
        {
           _collection.DeleteOneAsync(predicate);
        }


        /// <summary>
        /// 按条件表达式批量删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual long DeleteBatch(Expression<Func<T, bool>> predicate)
        {
            var result = _collection.DeleteMany(predicate);
            return result.DeletedCount;
        }
        /// <summary>
        /// 按条件表达式批量删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual  void DeleteBatchAsync(Expression<Func<T, bool>> predicate)
        {
             _collection.DeleteManyAsync(predicate);
        }

        /// <summary>
        /// 按检索条件删除
        /// 建议用Builders<T>构建复杂的查询条件
        /// </summary>
        /// <param name="filter">条件</param>
        /// <returns></returns>
        public virtual long Delete(FilterDefinition<T> filter)
        {
            var result = _collection.DeleteOne(filter);
            return result.DeletedCount;
        }

        /// <summary>
        /// 按检索条件删除
        /// 建议用Builders<T>构建复杂的查询条件
        /// </summary>
        /// <param name="filter">条件</param>
        /// <returns></returns>
        public virtual  void DeleteAsync(FilterDefinition<T> filter)
        {
             _collection.DeleteOneAsync(filter);
        }
        #endregion

        #region 修改
        /// <summary>
        /// 修改(Id不变)
        /// </summary>    
        /// <returns></returns>
        public virtual long Update(T t)
        {         
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id",t.Id);
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }
        /// <summary>
        /// 修改(Id不变)
        /// </summary>    
        /// <returns></returns>
        public virtual  void UpdateAsync(T t)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", t.Id);
             _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });

        }


        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(Expression<Func<T, bool>> filter, T t)
        {
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }


        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(FilterDefinition<T> filter, T t)
        {
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }
        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(Expression<Func<T, bool>> filter, T t)
        {
            _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });

        }
        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(FilterDefinition<T> filter, T t)
        {
              _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });

        }
        /// <summary>
        /// 根据Id和条件文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="id">对象Id</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(string id, UpdateDefinition<T> update)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var result = _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
            return  result.ModifiedCount;
        }
        /// <summary>
        /// 根据Id和条件文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="id">对象Id</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(string id, UpdateDefinition<T> update)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });       
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void Update(UpdateDefinition<T> update,Expression<Func<T, bool>> filter)
        {
            _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            var result = _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
            _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void  UpdateAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
             _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }

        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual long UpdateBatch(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
            var result = _collection.UpdateMany(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }

        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual long UpdateBatch(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            var result = _collection.UpdateMany(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }
        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateBatchAsync(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
             _collection.UpdateManyAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }

        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateBatchAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            _collection.UpdateManyAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        #endregion

        #region 查询 

        #region GetCollection

        /// <summary>
        /// 获取操作对象的IMongoCollection集合,强类型对象集合
        /// </summary>
        /// <returns></returns>
        public virtual IMongoCollection<T> GetCollection()
        {
            return _database.GetCollection<T>(typeof(T).Name);
        }

        #endregion

        #region GetSingle
        /// <summary>
        /// 查询数据库,检查是否存在指定ID的对象
        /// </summary>
        /// <param name="id">对象的ID值</param>
        /// <returns>存在则返回指定的对象,否则返回Null</returns>
        public virtual T GetById(string id)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var data = _collection.Find(filter).FirstOrDefault();
            return data;
        }
        /// <summary>
        /// 查询数据库,检查是否存在指定ID的对象
        /// </summary>
        /// <param name="id">对象的ID值</param>
        /// <returns>存在则返回指定的对象,否则返回Null</returns>
        public virtual async Task<T> GetAsyncById(string id)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual T Get(FilterDefinition<T> filter)
        {
            return _collection.Find(filter).FirstOrDefault();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">条件表达式</param>
        /// <returns></returns>
        public virtual T Get(Expression<Func<T,bool>> filter)
        {
            return _collection.Find(filter).FirstOrDefault();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual async Task<T> GetAsync(FilterDefinition<T> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">条件表达式</param>
        /// <returns></returns>
        public virtual async Task<T> GetAsync(Expression<Func<T, bool>> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }


        #endregion

        #region GetMany
        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetMany(FilterDefinition<T> filter)
        {
            return _collection.Find(filter).ToEnumerable();
        }

        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">条件表达式</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetMany(Expression<Func<T,bool>> filter)
        {
            //return _collection.AsQueryable().Where(filter).ToList();
            //return _collection.AsQueryable().Where(filter);
            return _collection.Find(filter).ToEnumerable(); //.ToEnumerable(); 
        }

        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<T>> GetManyAsync(FilterDefinition<T> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.ToListAsync();
        }

        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<T>> GetManyAsync(Expression<Func<T, bool>> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.ToListAsync();
        }

        #endregion

        #region GetAll

        /// <summary>
        /// 查询所有记录,复杂查询直接用Linq处理(避免全表扫描)
        /// </summary>
        /// <returns>要查询的对象</returns>
        public virtual IEnumerable<T> GetAll()
        {
            var data = _collection.AsQueryable();
            return data.ToEnumerable();
        }
        /// <summary>
        /// 查询所有记录,复杂查询直接用Linq处理(避免全表扫描)
        /// </summary>
        /// <returns>要查询的对象</returns>
        public virtual async Task<IEnumerable<T>> GetAllAsync()
        {
            var data =  _collection.AsQueryable();
            return await data.ToListAsync();
        }

        /// <summary>
        /// 查询所有记录,复杂查询直接用Linq处理(避免全表扫描)
        /// </summary>
        /// <returns>要查询的对象</returns>
        public virtual IQueryable<T> GetAllQueryable()
        {
            return _collection.AsQueryable();
        }

        #endregion

        #region MapReduce
        /// <summary>  
        ///  MapReduce
        /// </summary>     
       /// <returns>返回一个List列表数据</returns>  
        public IEnumerable<T> GetMap(BsonJavaScript map,BsonJavaScript reduce)
        {
            return  _collection.MapReduce<T>(map,reduce).ToList();
        }


        #endregion

        #endregion
    }

}

好了,就介绍到这里。

 

 三 查询进程和关闭数据库
  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 
  # 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目录将该行删除
   
  分片配置
   说明:分片要在无验证环境中配置,否则会出现无权限等异常。采用以下命令启动Server1Server2Server3上的shard1shard2shard3:

   # /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

   启动后连接到shard1shard2shard3分别进行配置,在任意一台服务器即可,以下是具体配置过程:

   # /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

   步骤二:退出后,将Server1Server2Server3服务器上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

   }

   {

TAG标签:
版权声明:本文由金沙澳门官网4166发布于文物考古,转载请注明出处:金沙棋牌简单部署方案及实例,的使用及仓储设