2.分片集群

2.1 分片概念

分片（sharding）是一种跨多台机器分布数据的方法， MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署。

换句话说：分片(sharding)是指将数据拆分，将其分散存在不同的机器上的过程。有时也用分区(partitioning)来表示这个概念。将数据分散到不同的机器上，不需要功能强大的大型计算机就可以储存更多的数据，处理更多的负载。

具有大型数据集或高吞吐量应用程序的数据库系统可以会挑战单个服务器的容量。例如，高查询率会耗尽服务器的CPU容量。工作集大小大于系统的RAM会强调磁盘驱动器的I / O容量。

有两种解决系统增长的方法：垂直扩展和水平扩展。
垂直扩展意味着增加单个服务器的容量，例如使用更强大的CPU，添加更多RAM或增加存储空间量。可用技术的局限性可能会限制单个机器对于给定工作负载而言足够强大。此外，基于云的提供商基于可用的硬件配置具有硬性上限。结果，垂直缩放有实际的最大值。

水平扩展意味着划分系统数据集并加载多个服务器，添加其他服务器以根据需要增加容量。虽然单个机器的总体速度或容量可能不高，但每台机器处理整个工作负载的子集，可能提供比单个高速大容量服务
器更高的效率。扩展部署容量只需要根据需要添加额外的服务器，这可能比单个机器的高端硬件的总体成本更低。权衡是基础架构和部署维护的复杂性增加。

MongoDB支持通过分片进行水平扩展。

2.2 分片集群包含的组件

MongoDB分片群集包含以下组件：

  • 分片（存储）：每个分片包含分片数据的子集。 每个分片都可以部署为副本集。
  • mongos（路由）：mongos充当查询路由器，在客户端应用程序和分片集群之间提供接口。
  • config servers（“调度”的配置）：配置服务器存储群集的元数据和配置设置。 从MongoDB 3.4开始，必须将配置服务器部署为副本集（CSRS）。

下图描述了分片集群中组件的交互：

image.png

MongoDB在集合级别对数据进行分片，将集合数据分布在集群中的分片上。
27018 if mongod is a shard member；
27019 if mongod is a config server member

2.3 分片集群架构目标

两个分片节点副本集（3+3）+一个配置节点副本集（3）+两个路由节点（2），共11个服务节点。

image.png

2.4 分片（存储）节点副本集的创建

所有的的配置文件都直接放到 sharded_cluster 的相应的子目录下面，默认配置文件名字：mongod.conf

2.4.1 第一套副本集
准备存放数据和日志的目录：

 #-----------myshardrs01 
mkdir -p /mongodb/sharded_cluster/myshardrs01_27018/log \ &
mkdir -p /mongodb/sharded_cluster/myshardrs01_27018/data/db \& 

mkdir -p /mongodb/sharded_cluster/myshardrs01_27118/log \ &
mkdir -p /mongodb/sharded_cluster/myshardrs01_27118/data/db \&
 
mkdir -p /mongodb/sharded_cluster/myshardrs01_27218/log \ &
mkdir -p /mongodb/sharded_cluster/myshardrs01_27218/data/db

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf

myshardrs01_27018：


 systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myshardrs01_27018/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
 storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
    dbPath: "/mongodb/sharded_cluster/myshardrs01_27018/data/db"
    journal:
       #启用或禁用持久性日志以确保数据文件保持有效和可恢复
       enabled: true
 processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
    pidFilePath: "/mongodb/sharded_cluster/myshardrs01_27018/log/mongod.pid"
 net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
    #bindIpAll: true
    #服务实例绑定的IP
    bindIp: localhost,192.168.1.114
    #bindIp #绑定的端口
    port: 27018
 replication:
    #副本集的名称
    replSetName: myshardrs01
 sharding:
    #分片角色
    clusterRole: shardsvr

sharding.clusterRole：

image.png

注意：
设置sharding.clusterRole需要mongod实例运行复制。 要将实例部署为副本集成员，请使用replSetName设置并指定副本集的名称。

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf

myshardrs01_27118：

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myshardrs01_27118/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 storage: 
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。 
    dbPath: "/mongodb/sharded_cluster/myshardrs01_27118/data/db" 
    journal: 
       #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myshardrs01_27118/log/mongod.pid" 
 net:
    #服务实例绑定所有IP 
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.0.2 
    #绑定的端口 
    port: 27118 
 replication: 
    replSetName: myshardrs01 
 sharding: 
    clusterRole: shardsvr

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf

myshardrs01_27218：

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myshardrs01_27218/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 storage: 
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。 
    dbPath: "/mongodb/sharded_cluster/myshardrs01_27218/data/db" 
    journal: 
   #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myshardrs01_27218/log/mongod.pid" 
 net:
    #服务实例绑定的IP 
    bindIp: localhost,192.168.0.2 
    #绑定的端口
    port: 27218 
 replication: 
    replSetName: myshardrs01 
 sharding: 
    clusterRole: shardsvr

启动第一套副本集：一主一副本一仲裁
依次启动三个mongod服务：

[root@host bin] mongod -f /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123223 
child process started successfully, parent exiting

[root@host bin] mongod -f /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123292 
child process started successfully, parent exiting 
[root@bobohost bin]# /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123326 
child process started successfully, parent exiting

查看服务是否启动：

[root@host bin]# ps -ef |grep mongod 
polkitd 61622 61604 0 7月31 ? 00:04:29 mongod --bind_ip_all 
root 123223 1 1 01:10 ? 00:00:01 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf 
root 123292 1 4 01:11 ? 00:00:00 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf 
root 123326 1 6 01:11 ? 00:00:00 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf

（1）初始化副本集和创建主节点：
使用客户端命令连接任意一个节点，但这里尽量要连接主节点：

/usr/local/mongodb/bin/mongo --host 192.168.1.114 --port 27018

执行初始化副本集命令：

> rs.initiate() { 
    "info2" : "no configuration specified. Using a default configuration for the set",
   "me" : "192.168.1.114:27018",
   "ok" : 1, 
   "operationTime" : Timestamp(1564593349, 1),
    "$clusterTime" : { 
        "clusterTime" : Timestamp(1564593349, 1), 
       "signature" : { 
              "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
              "keyId" : NumberLong(0)
         } 
     } 
}

"me" : "bobohost.localdomain:27018",

查看副本集情况(节选内容)：

myshardrs01:SECONDARY> rs.status() 
{ 
     "set" : "myshardrs01",
     ......
 }

（2）主节点配置查看：

myshardrs01:PRIMARY> rs.conf() 
{ 
    "_id" : "myshardrs01", 
    "version" : 1, 
     "protocolVersion" : NumberLong(1), 
    "writeConcernMajorityJournalDefault" : true, 
     "members" : [ 
               { 
                    "_id" : 0, 
                    "host" : "192.168.1.114:27018", 
                    "arbiterOnly" : false, 
                    "buildIndexes" : true, 
                    "hidden" : false, 
                    "priority" : 1, 
                    "tags" : { },
                    "slaveDelay" : NumberLong(0), 
                    "votes" : 1 
               } 
      ],

（3）添加副本节点：

myshardrs01:PRIMARY> rs.add("192.168.1.114:27118") 
{ 
   "ok" : 1, 
   "operationTime" : Timestamp(1564593626, 1), 
   "$clusterTime" : {
       "clusterTime" : Timestamp(1564593626, 1), 
       "signature" : { 
           "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
           "keyId" : NumberLong(0)
         }
     } 
}

（4）添加仲裁节点：

myshardrs01:PRIMARY> rs.addArb("192.168.1.114:27218") 
{
    "ok" : 1, 
    "operationTime" : Timestamp(1564593675, 1), 
    "$clusterTime" : { 
        "clusterTime" : Timestamp(1564593675, 1), 
        "signature" : { 
               "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
              "keyId" : NumberLong(0)
           }
       }
 }

查看副本集的配置情况：

myshardrs01:PRIMARY> rs.conf()
 {
     "_id" : "myshardrs01",
     "version" : 3,
     "protocolVersion" : NumberLong(1), 
     "writeConcernMajorityJournalDefault" : true, 
     "members" : [
          { 
            "_id" : 0, 
            "host" : "192.168.1.114:27018", 
            "arbiterOnly" : false, 
            "buildIndexes" : true, 
            "hidden" : false, 
            "priority" : 1, 
            "tags" : { },
            "slaveDelay" : NumberLong(0), 
            "votes" : 1 
          },{ 
            "_id" : 1,
            "host" : "192.168.1.114:27118", 
            "arbiterOnly" : false, 
            "buildIndexes" : true, 
            "hidden" : false, 
            "priority" : 1, 
             "tags" : { },
             "slaveDelay" : NumberLong(0), 
             "votes" : 1 
           },{ 
              "_id" : 2, 
              "host" : "192.168.1.114:27218", 
              "arbiterOnly" : true,
              "buildIndexes" : true, 
              "hidden" : false, 
              "priority" : 0, 
              "tags" : { },
              "slaveDelay" : NumberLong(0), 
              "votes" : 1 
             } 
     ],

2.4.2 第二套副本集
准备存放数据和日志的目录：

#-----------myshardrs02 
mkdir -p /mongodb/sharded_cluster/myshardrs02_27318/log \ &
mkdir -p /mongodb/sharded_cluster/myshardrs02_27318/data/db \& 

mkdir -p /mongodb/sharded_cluster/myshardrs02_27418/log \ &
mkdir -p /mongodb/sharded_cluster/myshardrs02_27418/data/db \&
mkdir -p /mongodb/sharded_cluster/myshardrs02_27518/log \ &
mkdir -p /mongodb/sharded_cluster/myshardrs02_27518/data/db

新建或修改配置文件：

vi /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf

myshardrs02_27318：

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myshardrs02_27318/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true 
 storage: 
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。 
    dbPath: "/mongodb/sharded_cluster/myshardrs02_27318/data/db" 
    journal: 
       #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myshardrs02_27318/log/mongod.pid" 
 net:
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114
    #绑定的端口 
    port: 27318 
 replication: 
    replSetName: myshardrs02 
 sharding: 
    clusterRole: shardsvr

新建或修改配置文件：

vi /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf

myshardrs02_27418：

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myshardrs02_27418/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
    dbPath: "/mongodb/sharded_cluster/myshardrs02_27418/data/db" 
    journal: 
       #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myshardrs02_27418/log/mongod.pid" 
 net:
    #服务实例绑定所有IP 
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114 
    #绑定的端口 
    port: 27418 
 replication: 
    replSetName: myshardrs02
 sharding: 
    clusterRole: shardsvr

新建或修改配置文件：

vi /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf

myshardrs02_27518：

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myshardrs02_27518/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 storage: 
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。 
    dbPath: "/mongodb/sharded_cluster/myshardrs02_27518/data/db"
    journal: 
       #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myshardrs02_27518/log/mongod.pid" 
 net:
     #服务实例绑定所有IP 
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114 
    #绑定的端口 
    port: 27518 
 replication: 
     replSetName: myshardrs02 
 sharding: 
     clusterRole: shardsvr

启动第二套副本集：一主一副本一仲裁
依次启动三个mongod服务：

[root@bobohost bin] mongod -f /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123223 
child process started successfully, parent exiting 

[root@bobohost bin] mongod -f /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123292 
child process started successfully, parent exiting
 
[root@bobohost bin] mongod -f /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123326 
child process started successfully, parent exiting

查看服务是否启动：

[root@bobohost bin]# ps -ef |grep mongod

（1）初始化副本集和创建主节点：
使用客户端命令连接任意一个节点，但这里尽量要连接主节点：

/usr/local/mongodb/bin/mongo --host 192.168.1.114 --port 27318

执行初始化副本集命令：

> rs.initiate()

查看副本集情况(节选内容)：

myshardrs01:SECONDARY> rs.status() { "set" : "myshardrs01", ...... }

（2）主节点配置查看：

myshardrs01:PRIMARY> rs.conf()

（3）添加副本节点：

myshardrs01:PRIMARY> rs.add("192.168.1.114:27418") 
{ 
   "ok" : 1, 
   "operationTime" : Timestamp(1564593626, 1), 
   "$clusterTime" : {
      "clusterTime" : Timestamp(1564593626, 1), 
      "signature" : { 
         "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
         "keyId" : NumberLong(0) 
       }
    } 
}

（4）添加仲裁节点：

myshardrs01:PRIMARY> rs.addArb("192.168.1.114:27518") 
{ 
   "ok" : 1, 
   "operationTime" : Timestamp(1564593675, 1), 
   "$clusterTime" : { 
      "clusterTime" : Timestamp(1564593675, 1), 
      "signature" : {
          "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
          "keyId" : NumberLong(0) 
      } 
   }
 }

查看副本集的配置情况：

myshardrs01:PRIMARY> rs.conf() 
myshardrs01:PRIMARY> rs.status() 

myshardrs02:PRIMARY> rs.status() 
{ 
   "set" : "myshardrs02", 
   "date" : ISODate("2019-07-31T21:38:22.463Z"), 
   "myState" : 1, 
   "term" : NumberLong(1), 
   "syncingTo" : "", 
   "syncSourceHost" : "", 
   "syncSourceId" : -1, 
   "heartbeatIntervalMillis" : NumberLong(2000), 
   "optimes" : { 
      "lastCommittedOpTime" : { 
          "ts" : Timestamp(1564609094, 1),
          "t" : NumberLong(1) 
       },
      "readConcernMajorityOpTime" : { 
          "ts" : Timestamp(1564609094, 1),
          "t" : NumberLong(1) 
      },
      "appliedOpTime" : { 
         "ts" : Timestamp(1564609094, 1),
          "t" : NumberLong(1) 
      },
      "durableOpTime" : { 
         "ts" : Timestamp(1564609094, 1), 
         "t" : NumberLong(1) 
      } 
   },
"lastStableCheckpointTimestamp" : Timestamp(1564609074, 1), 
"members" : [
 { 
   "_id" : 0, 
   "name" : "192.168.1.114:27318", 
   "health" : 1, 
   "state" : 1,
   "stateStr" : "PRIMARY", 
   "uptime" : 5086, 
   "optime" : { 
      "ts" : Timestamp(1564609094, 1), 
      "t" : NumberLong(1)
    },
   "optimeDate" : ISODate("2019-07-31T21:38:14Z"), 
   "syncingTo" : "", 
   "syncSourceHost" : "", 
   "syncSourceId" : -1, 
   "infoMessage" : "", 
   "electionTime" : Timestamp(1564604032, 2), 
   "electionDate" : ISODate("2019-07-31T20:13:52Z"), 
   "configVersion" : 3, 
   "self" : true, 
   "lastHeartbeatMessage" : "" 
},{
   "_id" : 1, 
   "name" : "192.168.1.114:27418", 
   "health" : 1, 
   "state" : 2, 
   "stateStr" : "SECONDARY", 
   "uptime" : 4452, 
   "optime" : { 
      "ts" : Timestamp(1564609094, 1), 
      "t" : NumberLong(1) 
   },
   "optimeDurable" : {
      "ts" : Timestamp(1564609094, 1), 
      "t" : NumberLong(1) 
   },
   "optimeDate" : ISODate("2019-07-31T21:38:14Z"), 
   "optimeDurableDate" : ISODate("2019-07-31T21:38:14Z"),
    "lastHeartbeat" : ISODate("2019-07-31T21:38:21.178Z"),
    "lastHeartbeatRecv" : ISODate("2019-07- 31T21:38:20.483Z"),
    "pingMs" : NumberLong(0), 
    "lastHeartbeatMessage" : "", 
    "syncingTo" : "192.168.1.114:27518",
    "syncSourceHost" : "192.168.1.114:27518", 
    "syncSourceId" : 2, 
    "infoMessage" : "", 
    "configVersion" : 3 
},{ 
   "_id" : 2, 
   "name" : "192.168.1.114:27518", 
   "health" : 1, 
   "state" : 2, 
   "stateStr" : "SECONDARY", 
   "uptime" : 4448, 
   "optime" : { 
      "ts" : Timestamp(1564609094, 1),
      "t" : NumberLong(1) 
    },
   "optimeDurable" : { 
      "ts" : Timestamp(1564609094, 1), 
      "t" : NumberLong(1) 
   },
   "optimeDate" : ISODate("2019-07-31T21:38:14Z"),
   "optimeDurableDate" : ISODate("2019-07-31T21:38:14Z"), 
   "lastHeartbeat" : ISODate("2019-07-31T21:38:21.178Z"),
   "lastHeartbeatRecv" : ISODate("2019-07- 31T21:38:22.096Z"), 
   "pingMs" : NumberLong(0), 
   "lastHeartbeatMessage" : "", 
   "syncingTo" : "192.168.1.114:27318", 
   "syncSourceHost" : "192.168.1.114:27318", 
   "syncSourceId" : 0, 
   "infoMessage" : "", 
   "configVersion" : 3 
} 
],

2.5 配置节点副本集的创建

第一步：准备存放数据和日志的目录：

#-----------configrs #建立数据节点data和日志目录 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27019/log \ & 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27019/data/db \ &
mkdir -p /mongodb/sharded_cluster/myconfigrs_27119/log \ & 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27119/data/db \ &
mkdir -p /mongodb/sharded_cluster/myconfigrs_27219/log \ & 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27219/data/db

新建或修改配置文件：

vi /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf

myconfigrs_27019：

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myconfigrs_27019/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 storage: 
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。 
    dbPath: "/mongodb/sharded_cluster/myconfigrs_27019/data/db"
    journal: 
       #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myconfigrs_27019/log/mongod.pid"
 net:
    #服务实例绑定所有IP 
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114
    #绑定的端口 
    port: 27019 
 replication: 
    replSetName: myconfigrs 
 sharding: 
    clusterRole: configsvr

新建或修改配置文件：

vi /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf

myconfigrs_27119

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myconfigrs_27119/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true 
 storage: 
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。 
    dbPath: "/mongodb/sharded_cluster/myconfigrs_27119/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myconfigrs_27119/log/mongod.pid" 
 net:
    #服务实例绑定所有IP
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114 
    #绑定的端口 
    port: 27119 
 replication: 
    replSetName: myconfigrs 
 sharding: 
    clusterRole: configsvr

新建或修改配置文件：

vi /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf

myconfigrs_27219

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/myconfigrs_27219/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 storage: 
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。 
    dbPath: "/mongodb/sharded_cluster/myconfigrs_27219/data/db"
    journal: 
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
       enabled: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: "/mongodb/sharded_cluster/myconfigrs_27219/log/mongod.pid" 
 net:
    #服务实例绑定所有IP 
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114
    #绑定的端口 
    port: 27219 
 replication: 
    replSetName: myconfigrs 
 sharding: 
    clusterRole: configsvr

启动配置副本集：一主两副本

依次启动三个mongod服务：

[root@bobohost bin] mongod -f /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123223 
child process started successfully, parent exiting 

[root@bobohost bin] mongod -f /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123292 
child process started successfully, parent exiting 

[root@bobohost bin] mongod -f /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123326 
child process started successfully, parent exiting

查看服务是否启动：

[root@bobohost bin]# ps -ef |grep mongod

（1）初始化副本集和创建主节点：
使用客户端命令连接任意一个节点，但这里尽量要连接主节点：

/usr/local/mongodb/bin/mongo --host 192.168.1.114 --port 27019

执行初始化副本集命令：

> rs.initiate()

查看副本集情况(节选内容)：

myshardrs01:SECONDARY> rs.status() { "set" : "myshardrs01", ...... }

（2）主节点配置查看：

myshardrs01:PRIMARY> rs.conf() 
{
   "_id" : "myshardrs01", 
   "version" : 1,
   "protocolVersion" : NumberLong(1), 
   "writeConcernMajorityJournalDefault" : true, 
   "members" : [ 
   { 
      "_id" : 0, 
      "host" : "bobohost.localdomain:27018",
      "arbiterOnly" : false, 
      "buildIndexes" : true, 
      "hidden" : false, 
      "priority" : 1,
      "tags" : { },
      "slaveDelay" : NumberLong(0), 
      "votes" : 1 
  }
 ],

（3）添加两个副本节点：

myshardrs01:PRIMARY> rs.add("192.168.1.114:27119") myshardrs01:PRIMARY> rs.add("192.168.1.114:27219")

查看副本集的配置情况：

myshardrs01:PRIMARY> rs.conf() 
myshardrs01:PRIMARY> rs.status()

2.6 路由节点的创建和操作

2.6.1 第一个路由节点的创建和连接
第一步：准备存放数据和日志的目录：

#-----------mongos01 
mkdir -p /mongodb/sharded_cluster/mymongos_27017/log

mymongos_27017节点：
新建或修改配置文件：

vi /mongodb/sharded_cluster/mymongos_27017/mongos.conf

mongos.conf

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/mymongos_27017/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: /mongodb/sharded_cluster/mymongos_27017/log/mongod.pid" 
 net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip 
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114
    #bindIp #绑定的端口 
    port: 27017 
 sharding: 
    #指定配置节点副本集 
    configDB: myconfigrs/192.168.1.114:27019,192.168.1.114:27119,192.168.1.114:27219

启动mongos：

[root@bobohost bin] mongos -f /mongodb/sharded_cluster/mymongos_27017/mongos.conf 

about to fork child process, waiting until server is ready for connections.
forked process: 129874 
child process started successfully, parent exiting

提示：启动如果失败，可以查看log目录下的日志，查看失败原因。

客户端登录mongos，

  mongo --host 192.168.1.114 --port 27017

此时，写不进去数据，如果写数据会报错：

mongos> use aadb 
switched to db aadb 
mongos> db.aa.insert({aa:"aa"}) 
WriteCommandError({ 
   "ok" : 0,
   "errmsg" : "unable to initialize targeter for write op for collection aa.aa :: caused by :: Database aa not found :: caused by :: No shards found", 
   "code" : 70, 
   "codeName" : "ShardNotFound", 
   "operationTime" : Timestamp(1564600123, 2), 
   "$clusterTime" : { 
      "clusterTime" : Timestamp(1564600123, 2), 
      "signature" : { 
          "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
         "keyId" : NumberLong(0) 
       } 
    } 
 })

原因：
通过路由节点操作，现在只是连接了配置节点，还没有连接分片数据节点，因此无法写入业务数据。

properties配置文件参考：

logpath=/mongodb/sharded_cluster/mymongos_27017/log/mongos.log 
logappend=true 
bind_ip_all=true 
port=27017 
fork=true
configdb=myconfigrs/192.168.1.114:27019,192.168.1.114:27119,192.168.1.114:27219

2.6.2 在路由节点上进行分片配置操作
使用命令添加分片：
（1）添加分片：
语法：

sh.addShard("IP:Port")

将第一套分片副本集添加进来：

mongos> sh.addShard("myshardrs01/192.168.1.114:27018,192.168.1.114:27118,192.168.1.114:27218") 
{ 
   "shardAdded" : "myshardrs01", 
   "ok" : 1,
   "operationTime" : Timestamp(1564611970, 4),
   "$clusterTime" : {
       "clusterTime" : Timestamp(1564611970, 4),
       "signature" : { 
         "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
         "keyId" : NumberLong(0)
        }
    } 
}

查看分片状态情况：

mongos> sh.status() 
--- Sharding Status --- 
sharding version: { 
   "_id" : 1,
   "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("5d4211b798f3f9a48522c68b")
 }
shards:{ 
   "_id" : "myshardrs01",
   "host" : "myshardrs01/192.168.1.114:27018,192.168.1.114:27118",
   "state" : 1 
} 
active mongoses: 
   "4.0.10" : 1 
autosplit: 
   Currently enabled: yes 
balancer: 
   Currently enabled: yes 
   Currently running: no 
Failed balancer rounds in last 5 attempts: 0 
Migration Results for the last 24 hours: 
     No recent migrations 
databases: { "_id" : "config", "primary" : "config", "partitioned" : true }

继续将第二套分片副本集添加进来：

mongos> sh.addShard("myshardrs02/192.168.1.114:27318,192.168.1.114:27418,192.168.1.114:27518") 
{ 
   "shardAdded" : "myshardrs02", 
   "ok" : 1, 
   "operationTime" : Timestamp(1564612147, 5), 
   "$clusterTime" : { 
      "clusterTime" : Timestamp(1564612147, 5), 
      "signature" : {
         "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
         "keyId" : NumberLong(0) 
      } 
   } 
}

查看分片状态：

mongos> sh.status() 
--- Sharding Status --- 
sharding version: { 
   "_id" : 1, 
   "minCompatibleVersion" : 5, 
   "currentVersion" : 6, 
   "clusterId" : ObjectId("5d4211b798f3f9a48522c68b")
 }
shards:{ 
   "_id" : "myshardrs01", 
   "host" : "myshardrs01/192.168.1.114:27018,192.168.1.114:27118", 
   "state" : 1 
} 
{ 
   "_id" : "myshardrs02", 
   "host" : "myshardrs02/192.168.1.114:27318,192.168.1.114:27418", 
   "state" : 1 
} 
active mongoses: 
   "4.0.10" : 1 
autosplit: 
   Currently enabled: yes 
balancer: 
   Currently enabled: yes 
   Currently running: no 
Failed balancer rounds in last 5 attempts: 0 
Migration Results for the last 24 hours: 
       No recent migrations 
databases: { "_id" : "config", "primary" : "config", "partitioned" : true }

提示：如果添加分片失败，需要先手动移除分片，检查添加分片的信息的正确性后，再次添加分片。
移除分片参考(了解)：

 use admin db.runCommand( { removeShard: "myshardrs02" } )

注意：如果只剩下最后一个shard，是无法删除的
移除时会自动转移分片数据，需要一个时间过程。
完成后，再次执行删除分片命令才能真正删除。

（2）开启分片功能：sh.enableSharding("库名")、sh.shardCollection("库名.集合名",{"key":1})
在mongos上的articledb数据库配置sharding:

mongos> sh.enableSharding("articledb") 
{ 
   "ok" : 1, 
   "operationTime" : Timestamp(1564612296, 5), 
   "$clusterTime" : { 
      "clusterTime" : Timestamp(1564612296, 5),
      "signature" : { 
         "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), 
         "keyId" : NumberLong(0) 
      } 
   } 
}

查看分片状态：

mongos> sh.status() 
--- Sharding Status --- 
sharding version: { 
   "_id" : 1, 
   "minCompatibleVersion" : 5, 
   "currentVersion" : 6, 
   "clusterId" : ObjectId("5d4211b798f3f9a48522c68b") 
}
shards:{
   "_id" : "myshardrs01", 
   "host" : "myshardrs01/192.168.1.114:27018,192.168.1.114:27118",
   "state" : 1 
} { 
   "_id" : "myshardrs02", 
   "host" : "myshardrs02/192.168.1.114:27318,192.168.1.114:27418", 
   "state" : 1 
} 
active mongoses: 
   "4.0.10" : 1 
autosplit: 
   Currently enabled: yes 
balancer: 
   Currently enabled: yes 
   Currently running: no 
Failed balancer rounds in last 5 attempts: 0 
Migration Results for the last 24 hours: 
   No recent migrations 
databases: { "_id" : "articledb", "primary" : "myshardrs02", "partitioned" : true, "version" : { "uuid" : UUID("788c9a3b-bb6a-4cc2-a597-974694772986"), "lastMod" : 1 } 
} { 
   "_id" : "config", 
   "primary" : "config", 
   "partitioned" : true 
} 
config.system.sessions 
shard key: { "_id" : 1 } 
unique: false 
balancing: true 
chunks: 
   myshardrs01 1  
{ "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

（3）集合分片
对集合分片，你必须使用 sh.shardCollection() 方法指定集合和分片键。
语法：

sh.shardCollection(namespace, key, unique)

参数：


image.png

对集合进行分片时,你需要选择一个 片键（Shard Key） , shard key 是每条记录都必须包含的,且建立了索引的单个字段或复合字段,MongoDB按照片键将数据划分到不同的 数据块 中,并将 数据块 均衡地分布到所有分片中.为了按照片键划分数据块,MongoDB使用 基于哈希的分片方式（随机平均分配）或者基于范围的分片方式（数值大小分配） 。
用什么字段当片键都可以，如：nickname作为片键，但一定是必填字段。

分片规则一：哈希策略
对于 基于哈希的分片 ,MongoDB计算一个字段的哈希值,并用这个哈希值来创建数据块.
在使用基于哈希分片的系统中,拥有”相近”片键的文档 很可能不会 存储在同一个数据块中,因此数据的分离性更好一些.
使用nickname作为片键，根据其值的哈希值进行数据分片

sh.shardCollection(namespace, key, unique) 
mongos> sh.shardCollection("articledb.comment",{"nickname":"hashed"}) 
{ 
   "collectionsharded" : "articledb.comment", 
   "collectionUUID" : UUID("ddea6ed8-ee61-4693-bd16-196acc3a45e8"), 
   "ok" : 1, 
   "operationTime" : Timestamp(1564612840, 28), 
   "$clusterTime" : { 
      "clusterTime" : Timestamp(1564612840, 28), 
      "signature" : { 
         "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
         "keyId" : NumberLong(0) 
      } 
   }
}

查看分片状态：sh.status()

databases: { 
   "_id" : "articledb", 
   "primary" : "myshardrs02", 
   "partitioned" : true, 
   "version" : { 
      "uuid" : UUID("251436b7-86c2-4cd8-9a88-70874af29364"),
      "lastMod" : 1 
   } 
}
articledb.comment shard key: { "nickname" : "hashed" } unique: false balancing: true chunks: 
myshardrs01 2 
myshardrs02 2 
   { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(1, 0) 
   { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(1, 1) 
   { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(1, 2) 
   { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(1, 3) 
{ "_id" : "config", "primary" : "config", "partitioned" : true } config.system.sessions 
shard key: { "_id" : 1 } 
unique: false 
balancing: true 
chunks: 
    myshardrs01 1 
{ "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

分片规则二：范围策略
对于 基于范围的分片 ,MongoDB按照片键的范围把数据分成不同部分.假设有一个数字的片键:想象一个从负无穷到正无穷的直线,每一个片键的值都在直线上画了一个点.MongoDB把这条直线划分为更短的不重叠的片段,并称之为 数据块 ,每个数据块包含了片键在一定范围内的数据.

在使用片键做范围划分的系统中,拥有”相近”片键的文档很可能存储在同一个数据块中,因此也会存储在同一个分片中.

如使用作者年龄字段作为片键，按照点赞数的值进行分片：

mongos> sh.shardCollection("articledb.author",{"age":1}) 
{ 
   "collectionsharded" : "articledb.author", 
   "collectionUUID" : UUID("9a47bdaa-213a-4039-9c18-e70bfc369df7"), 
   "ok" : 1, 
   "operationTime" : Timestamp(1567512803, 13),
   "$clusterTime" : { 
      "clusterTime" : Timestamp(1567512803, 13), 
      "signature" : { 
         "hash" : BinData(0,"eE9QT5yE5sL1Tyr7+3U8GRy5+5Q="), 
         "keyId" : NumberLong("6732061237309341726") 
       } 
   }
 }

注意的是：
1）一个集合只能指定一个片键，否则报错。
2）一旦对一个集合分片，分片键和分片值就不可改变。 如：不能给集合选择不同的分片键、不能更新分片键的值。
3）根据age索引进行分配数据。
查看分片状态：

articledb.author 
        shard key: { "age" : 1 } 
        unique: false 
        balancing: true 
        chunks: 
              myshardrs01 1
 { "age" : { "$minKey" : 1 } } -->> { "age" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

基于范围的分片方式与基于哈希的分片方式性能对比：
基于范围的分片方式提供了更高效的范围查询,给定一个片键的范围,分发路由可以很简单地确定哪个数据块存储了请求需要的数据,并将请求转发到相应的分片中.不过,基于范围的分片会导致数据在不同分片上的不均衡,有时候,带来的消极作用会大于查询性能的积极作用.比如,如果片键所在的字段是线性增长的,一定时间内的所有请求都会落到某个固定的数据块中,最终导致分布在同一个分片中.在这种情况下,一小部分分片承载了集群大部分的数据,系统并不能很好地进行扩展.

与此相比,基于哈希的分片方式以范围查询性能的损失为代价,保证了集群中数据的均衡.哈希值的随机性使数据随机分布在每个数据块中,因此也随机分布在不同分片中.但是也正由于随机性,一个范围查询很难确定应该请求哪些分片,通常为了返回需要的结果,需要请求所有分片.

如无特殊情况，一般推荐使用 Hash Sharding。

而使用 _id 作为片键是一个不错的选择，因为它是必有的，你可以使用数据文档 _id 的哈希作为片键。

这个方案能够是的读和写都能够平均分布，并且它能够保证每个文档都有不同的片键所以数据块能够很精细。

似乎还是不够完美，因为这样的话对多个文档的查询必将命中所有的分片。虽说如此，这也是一种比较好的方案了。

理想化的 shard key 可以让 documents 均匀地在集群中分布：

image.png

显示集群的详细信息：

mongos> db.printShardingStatus()

查看均衡器是否工作（需要重新均衡时系统才会自动启动，不用管它）：

mongos> sh.isBalancerRunning() 
false

查看当前Balancer状态：

mongos> sh.getBalancerState() 
true

2.6.3 分片后插入数据测试
测试一（哈希规则）：登录mongs后，向comment循环插入1000条数据做测试：

mongos> use articledb 
switched to db articledb 
mongos> for(var i=1;i<=1000;i++) {
db.comment.insert({_id:i+"",nickname:"BoBo"+i})} 
WriteResult({ "nInserted" : 1 }) 
mongos> db.comment.count() 
1000

提示：js的语法，因为mongo的shell是一个JavaScript的shell。
注意：从路由上插入的数据，必须包含片键，否则无法插入。
分别登陆两个片的主节点，统计文档数量
第一个分片副本集：
/usr/local/mongodb/bin/mongo --host 192.168.1.114 --port 27018

myshardrs01:PRIMARY> use articledb 
switched to db articledb 
myshardrs01:PRIMARY> db.comment.count() 
508

第二个分片副本集：
/usr/local/mongodb/bin/mongo --host 192.168.1.114 --port 27318

myshardrs02:PRIMARY> use articledb 
switched to db articledb 
myshardrs02:PRIMARY> db.comment.count() 
493

可以看到，1000条数据近似均匀的分布到了2个shard上。是根据片键的哈希值分配的。
这种分配方式非常易于水平扩展：一旦数据存储需要更大空间，可以直接再增加分片即可，同时提升了性能。

使用db.comment.stats()查看单个集合的完整情况，mongos执行该命令可以查看该集合的数据分片的情况。

使用sh.status()查看本库内所有集合的分片信息。

测试二（范围规则）：登录mongs后，向comment循环插入1000条数据做测试：

mongos> use articledb 
switched to db articledb 
mongos> for(var i=1;i<=20000;i++) {db.author.save({"name":"BoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBo"+i,"age":NumberInt(i%120)})} 
WriteResult({ "nInserted" : 1 }) 
mongos> db.comment.count() 
20000

插入成功后，仍然要分别查看两个分片副本集的数据情况。
分片效果：

articledb.author 
   shard key: { "age" : 1 } 
   unique: false 
   balancing: true 
   chunks: 
        myshardrs01 2 
        myshardrs02 1 
{ "age" : { "$minKey" : 1 } } -->> { "age" : 0 } on : myshardrs02 Timestamp(2, 0) 
{ "age" : 0 } -->> { "age" : 112 } on : myshardrs01 Timestamp(2, 1) 
{ "age" : 112 } -->> { "age" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 3)

提示：
如果查看状态发现没有分片，则可能是由于以下原因造成了：
1）系统繁忙，正在分片中。
2）数据块（chunk）没有填满，默认的数据块尺寸（chunksize）是64M，填满后才会考虑向其他片的数据块填充数据，因此，为了测试，可以将其改小，这里改为1M，操作如下：

use config db.settings.save( { _id:"chunksize", value: 1 } )

测试完改回来：

db.settings.save( { _id:"chunksize", value: 64 } )

注意：要先改小，再设置分片。为了测试，可以先删除集合，重新建立集合的分片策略，再插入数据测试即可。

2.6.4 再增加一个路由节点
文件夹：

#-----------mongos02 
mkdir -p /mongodb/sharded_cluster/mymongos_27117/log

新建或修改配置文件：

 vi /mongodb/sharded_cluster/mymongos_27117/mongos.conf

mongos.conf

 systemLog: 
    #MongoDB发送所有日志输出的目标指定为文件 
    destination: file 
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
    path: "/mongodb/sharded_cluster/mymongos_27117/log/mongod.log" 
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。 
    logAppend: true 
 processManagement: 
    #启用在后台运行mongos或mongod进程的守护进程模式。 
    fork: true 
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID 
    pidFilePath: /mongodb/sharded_cluster/mymongos_27117/log/mongod.pid"
 net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip 
    #bindIpAll: true 
    #服务实例绑定的IP 
    bindIp: localhost,192.168.1.114 
    #bindIp 
    #绑定的端口 
    port: 27117 
 sharding:
    configDB: myconfigrs/192.168.1.114 :27019,192.168.1.114 :27119,192.168.1.114 :27219

启动mongos2：

[root@bobohost bin] mongos -f /mongodb/sharded_cluster/mymongos_27117/mongos.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 129874 
child process started successfully, parent exiting

使用mongo客户端登录27117，发现，第二个路由无需配置，因为分片配置都保存到了配置服务器中了。

2.7 Compass连接分片集群

compass连接：

提示：和连接单机mongod一样。

连接成功后，上方有mongos和分片集群的提示：

2.8 SpringDataMongDB连接分片集群

Java客户端常用的是SpringDataMongoDB，其连接的是mongs路由，配置和单机mongod的配置是一样的。
多个路由的时候的SpringDataMongoDB的客户端配置参考如下：

spring: 
    #数据源配置 
   data: 
      mongodb: 
   # 主机地址 
   # host: 180.76.159.126 
   # 数据库 
   # database: articledb 
   # 默认端口是27017 
   # port: 27017 
   #也可以使用uri连接 
   # uri: mongodb://192.168.40.134:28017/articledb
   # 连接副本集字符串 # uri: mongodb://180.76.159.126:27017,180.76.159.126:27018,180.76.159.126:27019/article db?connect=replicaSet&slaveOk=true&replicaSet=myrs 
#连接路由字符串 
uri: mongodb://180.76.159.126:27017,180.76.159.126:27117/articledb

通过日志发现，写入数据的时候，会选择一个路由写入：

2019-09-03 11:04:09.166 INFO 11816 --- [68.40.141:27117] 
org.mongodb.driver.connection : Opened connection 
[connectionId{localValue:2}] to 180.76.159.126:27117 
2019-09-03 11:04:09.166 INFO 11816 --- [68.40.141:27017] 
org.mongodb.driver.connection : Opened connection 
[connectionId{localValue:1}] to 180.76.159.126:27017 
2019-09-03 11:04:09.529 INFO 11816 --- [ main] 
org.mongodb.driver.connection : Opened connection 
[connectionId{localValue:3}] to 180.76.159.126:27117 
2019-09-03 11:04:09.826 INFO 11816 --- [ main] 
c.i.article.service.CommentServiceTest : Started 
CommentServiceTest in 7.009 seconds (JVM running for 8.043) 2019-09-03 11:04:10.173 INFO 11816 --- [ Thread-2] 
org.mongodb.driver.connection : Closed connection
[connectionId{localValue:3}] to 180.76.159.126:27117 because the

2.9 清除所有的节点数据（备用）

如果在搭建分片的时候有操作失败或配置有问题，需要重新来过的，可以进行如下操作：
第一步：查询出所有的测试服务节点的进程：
根据上述的进程编号，依次中断进程：

[root@bobohost sharded_cluster]# ps -ef |grep mongo 
root 10184 1 0 06:04 ? 00:01:25 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf 
root 10219 1 0 06:04 ? 00:01:25 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf 
root 10253 1 0 06:04 ? 00:00:46 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf 
root 10312 1 0 06:04 ? 00:01:23 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf 
root 10346 1 0 06:05 ? 00:01:23 /usr/local/mongodb/bin/mongod
 -f /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf 
root 10380 1 0 06:05 ? 00:00:44 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf 
root 10414 1 1 06:05 ? 00:01:36 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf 
root 10453 1 1 06:05 ? 00:01:37 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf 
root 10492 1 1 06:05 ? 00:01:38 /usr/local/mongodb/bin/mongod 
-f /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf 
root 11392 1 0 06:15 ? 00:00:24 /usr/local/mongodb/bin/mongos 
--config /mongodb/sharded_cluster/mymongos_27017/mongos.cfg
root 14829 1 0 07:15 ? 00:00:13 /usr/local/mongodb/bin/mongos 
--config /mongodb/sharded_cluster/mymongos_27117/mongos.cfg

根据上述的进程编号，依次中断进程：

kill -2 进程编号

第二步：清除所有的节点的数据：

rm -rf /mongodb/sharded_cluster/myconfigrs_27019/data/db/*.* \ & 
rm -rf /mongodb/sharded_cluster/myconfigrs_27119/data/db/*.* \ &
rm -rf /mongodb/sharded_cluster/myconfigrs_27219/data/db/*.* \ &
rm -rf /mongodb/sharded_cluster/myshardrs01_27018/data/db/*.* \& 
rm -rf /mongodb/sharded_cluster/myshardrs01_27118/data/db/*.* \& 
rm -rf /mongodb/sharded_cluster/myshardrs01_27218/data/db/*.* \& 
rm -rf /mongodb/sharded_cluster/myshardrs02_27318/data/db/*.* \& 
rm -rf /mongodb/sharded_cluster/myshardrs02_27418/data/db/*.* \& 
rm -rf /mongodb/sharded_cluster/myshardrs02_27518/data/db/*.* \& 
rm -rf /mongodb/sharded_cluster/mymongos_27017/data/db/*.* \ &
rm -rf /mongodb/sharded_cluster/mymongos_27117/data/db/*.*

第三步：查看或修改有问题的配置

第四步：依次启动所有节点，不包括路由节点：

/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf
 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf

第五步：对两个数据分片副本集和一个配置副本集进行初始化和相关配置

第六步：检查路由mongos的配置，并启动mongos

/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/mymongos_27017/mongos.cfg
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/mymongos_27017/mongos.cfg

第七步：mongo登录mongos，在其上进行相关操作。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,684评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,143评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,214评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,788评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,796评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,665评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,027评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,679评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 41,346评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,664评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,766评论 1赞 331
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,412评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,015评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,974评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,203评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,073评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,501评论 2赞 343