概念:

MongoDB分片是应用八个服务器存款和储蓄数据的艺术,以援助巨大的数额存款和储蓄和对数据开始展览仓储

MongoDB分片简述

前言

逻辑图

优势:

1、减弱了各样分片需啊哟处理的伸手数,群集能够增进本身的囤积容积和吞吐量

二、收缩了各类分片存款和储蓄的多寡

高数据量和吞吐量的数据库应用会对单机的天性造成较大压力,大的查询量会将单机的
CPU
耗尽,大的数据量对单机的存款和储蓄压力较大,最后会耗尽系统的内部存款和储蓄器而将压力转换成磁盘
IO 上。

近些年因为工作的案由,在求学应用mongodb数据库,mongodb是最常用的nodql数据库,在数据库排行中早就上涨到了前6。那篇小说介绍怎么样搭建高可用的mongodb(分片+副本)集群,分享出去供大家参考学习,上边话不多说了,来一同看看详细的牵线:

澳门金沙国际 1

四个重点组件:

shard:分片服务器,用于存储实际的数据块,由多台服务器组成一个复制集承担,防止主机单点故障

config server:配置服务器,存储整个分片群集的配置信息,包括块信息

routers:前端路由,客户端由此进入,让整个群集看上去像单一数据库

MongoDB自学记录,用心描述。怎么样计划MongoDB分片群集!!!

MongoDB
分片是采用多少个服务器存款和储蓄数据的主意,以援助巨大的数目存款和储蓄和对数据开始展览操作。分片技术能够满足MongoDB 数据量多量增进的供给,当一台 MongoDB
服务器不足以存款和储蓄海量数据或不足以提供可接受的读写吞吐量时,大家就足以因此在多台服务器上划分数据,使得数据库系统能储存和拍卖愈多的数量。

在搭建集群以前,供给首先领悟多少个概念:路由,分片、副本集、配置服务器等。

image.png

1、安装MongoDB三.二版本包和openssl-devel包
[root@localhost ~]# yum install openssl-devel -y

[root@localhost ~]# mkdir /abc
[root@localhost ~]# mount.cifs //192.168.200.1/orc /abc
Password for root@//192.168.200.1/orc:  
[root@localhost ~]# cd /abc
[root@localhost abc]# ls
mongodb-linux-x86_64-3.2.1.tgz  //MongoDB 3.2版本
[root@localhost abc]# tar zxvf mongodb-linux-x86_64-3.2.1.tgz -C /opt
[root@localhost abc]# cd /opt
[root@localhost opt]# ls
mongodb-linux-x86_64-3.2.1  rh
[root@localhost opt]# mv mongodb-linux-x86_64-3.2.1/ /usr/local/mongodb                 

[root@localhost opt]# cd /usr/local/bin/
[root@localhost bin]# ln -s /usr/local/mongodb/bin/mongo /usr/bin/mongo //建立软连接
[root@localhost bin]# ln -s /usr/local/mongodb/bin/mongod /usr/bin/mongod

[root@localhost bin]# mkdir -p /data/mongodb/mongodb{1,2,3,4}
[root@localhost bin]# mkdir /data/mongodb/logs
[root@localhost bin]# touch /data/mongodb/logs/mongodb{1,2,3,4}.log
[root@localhost bin]# chmod -R 777 /data/mongodb/logs/*.log

[root@localhost bin]# ulimit -n 25000   //打开文件数量
[root@localhost bin]# ulimit -u 25000    //进程并发数

MongoDB分片优势

连锁概念

如上海体育地方,MongoDB分片集群首要由三有个别构成:

2、计划安排服务器

编纂mongodb壹.conf布署文件,端口为37017,设置configsvr=true,运营配置服务器

[root@localhost bin]# vim mongodb1.con
port=37017
dbpath=/data/mongodb/mongodb1
logpath=/data/mongodb/logs/mongodb1.log
logappend=true
fork=true
maxConns=5000
storageEngine=mmapv1
configsvr=true                //开启配置服务器

分片为应对高吞吐量与大数据量提供了法子:

先来看一张图:

·shard:mongodb分片,是将数据库中蕴藏的多寡开始展览拆分到不相同的服务器,那样能够减轻每台服务器的压力,同时它扶助复制集的款式

叁、某节点内存不足,从其余节点分配内部存储器
[root@localhost bin]# sysctl -w vm.zone_reclaim_mode=0
vm.zone_reclaim_mode = 0
[root@localhost bin]# echo never > /sys/kernel/mm/transparent_hugepage/enabled
[root@localhost bin]# echo never > /sys/kernel/mm/transparent_hugepage/defrag

[root@localhost bin]# mongod -f mongodb1.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 6895
child process started successfully, parent exiting
  1. 运用分片收缩了各种分片供给处理的请求数,由此,通过水平扩展,群集能够抓好协调的积存容积。比如,当插入一条数据时,应用只要求拜访存款和储蓄那条数据的分片。
  2. 利用分片减弱了各种分片村存款和储蓄的数量。

澳门金沙国际 2

澳门金沙国际,shard: Each shard contains a subset of the sharded data. Each shard
can be deployed as a replica set.

四、陈设分片服务器

编辑mongodb二.conf陈设文件,端口为470一柒,设置shardsvr=true;编辑mongodb叁.conf配置文件,端口为4701八,运行七个分片服务器

[root@localhost bin]# cp -p mongodb1.conf mongodb2.conf 

[root@localhost bin]# vim mongodb2.conf 
port=47017                   //修改端口
dbpath=/data/mongodb/mongodb2
logpath=/data/mongodb/logs/mongodb2.log
logappend=true
fork=true
maxConns=5000
storageEngine=mmapv1
shardsvr=true                //开启分片服务器

[root@localhost bin]# cp -p mongodb2.conf mongodb3.conf
[root@localhost bin]# vim mongodb3.conf 
port=47018
dbpath=/data/mongodb/mongodb3
logpath=/data/mongodb/logs/mongodb3.log
logappend=true
fork=true
maxConns=5000
storageEngine=mmapv1
shardsvr=true

[root@localhost bin]# mongod -f mongodb2.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 7080
child process started successfully, parent exiting
[root@localhost bin]# mongod -f mongodb3.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 7107
child process started successfully, parent exiting

[root@localhost bin]# netstat -antp | grep mongod
tcp        0      0 0.0.0.0:37017           0.0.0.0:*               LISTEN      god         
tcp        0      0 0.0.0.0:47017           0.0.0.0:*               LISTEN      god         
tcp        0      0 0.0.0.0:47018           0.0.0.0:*               LISTEN      god  

分片的优势在于提供类似线性增进的架构,提升数据可用性,提升大型数据库查询服务器的品质。当MongoDB单点数据库服务器存款和储蓄成为瓶颈、单点数据库服务器的性质成为瓶颈或索要配置大型应用以丰盛利用内部存款和储蓄器时,能够利用分片技术。

从图中能够看看有多个零件:mongos、config server、shard、replica set。

·mongos:为使用和集群之间提供查询路由的接口,数据库集群请求的进口,全部的央求都由此mongos进行和谐,在生养条件壹般有多mongos作为请求的输入,幸免内部2个挂掉全数的mongodb请求都并未有艺术操作。

五、运转路由服务器

./mongos
–help命令能够查看路由有关参数消息。chunkSize为多少块大小,暗许为200M,那里将值设为1

[root@localhost bin]# ./mongos --port 27017 --fork --logpath=/usr/local/mongodb/bin/route.log --configdb 192.168.200.142:37017 --chunkSize 1

MongoDB分片群集的组合

mongos,数据库集群请求的输入,全体的呼吁都经过mongos举行协调,不要求在应用程序添加三个路由选取器,mongos本人正是1个伸手分发中央,它承担把相应的数额请求请求转发到对应的shard服务器上。在生养环境1般有多mongos作为请求的输入,防止内部2个挂掉全数的mongodb请求都未有办法操作。

mongos: The mongos acts as a query router, providing an interface
between client applications and the sharded cluster.

六、启用分片服务器
mongos> sh.addShard("192.168.200.142:47017")
{ "shardAdded" : "shard0000", "ok" : 1 }
mongos> sh.addShard("192.168.200.142:47018")
{ "shardAdded" : "shard0001", "ok" : 1 }
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("5b4f68599dcf397cc4e7c598")
}
  shards:                 //分片服务器开启
    {  "_id" : "shard0000",  "host" : "192.168.200.142:47017" }
    {  "_id" : "shard0001",  "host" : "192.168.200.142:47018" }
  active mongoses:
    "3.2.1" : 1
  balancer:
    Currently enabled:  yes
    Currently running:  no
    Failed balancer rounds in last 5 attempts:  0
    Migration Results for the last 24 hours: 
        No recent migratio

MongoDB分片群集首要有如下四个零部件:

config
server,顾名思义为布局服务器,存款和储蓄全体数据库元消息(路由、分片)的布置。mongos自个儿并没有物理存款和储蓄分片服务器和数据路由消息,只是缓存在内部存款和储蓄器里,配置服务器则实在存款和储蓄这么些多少。mongos第一遍开发银行恐怕关闭重启就会从
config server 加载配置音信,现在如果布署服务器消息变化会通告到持有的
mongos 更新本身的事态,那样 mongos
就能持续规范路由。在生养环境一般有两个 config server
配置服务器,因为它存款和储蓄了分片路由的元数据,幸免数据丢失!

·config
server:首要囤积一些元数据和一些配置消息,mongos第三遍开发银行大概关闭重启就会从
config server 加载配置音信,以往只要安插服务器音信变化会公告到拥有的
mongos 更新本人的情况,那样 mongos
就能继承规范路由。在生养环境一般有多个 config server
配置服务器,因为它存款和储蓄了分片路由的元数据,防止数据丢失!从mongodb叁.肆版本起,它必须作为复制集实行安插

柒、分片成效
[root@localhost bin]# mongo
mongos> use school
switched to db school

mongos> for(var i=1;i<=10000;i++)db.users.insert({"id":i,"name":"jack"+i})           
WriteResult({ "nInserted" : 1 })

mongos> show dbs
config  0.031GB
school  0.078GB             

mongos> use school
switched to db school

mongos> show collections
system.indexes
users

mongos> db.users.find().limit(10)  //查看头十行内容
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4ae"), "id" : 1, "name" : "jack1" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4af"), "id" : 2, "name" : "jack2" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b0"), "id" : 3, "name" : "jack3" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b1"), "id" : 4, "name" : "jack4" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b2"), "id" : 5, "name" : "jack5" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b3"), "id" : 6, "name" : "jack6" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b4"), "id" : 7, "name" : "jack7" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b5"), "id" : 8, "name" : "jack8" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b6"), "id" : 9, "name" : "jack9" }
{ "_id" : ObjectId("5b4f6a24ef33d588c0dbc4b7"), "id" : 10, "name" : "jack10" }

mongos> sh.status()             //查看数据库分片信息
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("5b4f68599dcf397cc4e7c598")
}
  shards:
    {  "_id" : "shard0000",  "host" : "192.168.200.142:47017" }
    {  "_id" : "shard0001",  "host" : "192.168.200.142:47018" }
  active mongoses:
    "3.2.1" : 1
  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" : "school",  "primary" : "shard0000",  "partitioned" : false }

mongos> sh.enableSharding("school") //启用数据库分片
{ "ok" : 1 }

mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("5b4f68599dcf397cc4e7c598")
}
  shards:
    {  "_id" : "shard0000",  "host" : "192.168.200.142:47017" }
    {  "_id" : "shard0001",  "host" : "192.168.200.142:47018" }
  active mongoses:
    "3.2.1" : 1
  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" : "school",  "primary" : "shard0000",  "partitioned" : true }

mongos> db.users.createIndex({"id":1})  //对users表创建索引
{
    "raw" : {
        "192.168.200.142:47017" : {
            "createdCollectionAutomatically" : false,
            "numIndexesBefore" : 1,
            "numIndexesAfter" : 2,
            "ok" : 1
        }
    },
    "ok" : 1
}

mongos> sh.shardCollection("school.users",{"id":1})//表分片
{ "collectionsharded" : "school.users", "ok" : 1 }

mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("5b4f68599dcf397cc4e7c598")
}
  shards:
    {  "_id" : "shard0000",  "host" : "192.168.200.142:47017" }
    {  "_id" : "shard0001",  "host" : "192.168.200.142:47018" }
  active mongoses:
    "3.2.1" : 1
  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" : "school",  "primary" : "shard0000",  "partitioned" : true }
        school.users
            shard key: { "id" : 1 }
            unique: false
            balancing: true
            chunks:
                shard0000   3
            { "id" : { "$minKey" : 1 } } -->> { "id" : 4682 } on : shard0000 Timestamp(1, 0) 
            { "id" : 4682 } -->> { "id" : 9364 } on : shard0000 Timestamp(1, 1) 
            { "id" : 9364 } -->> { "id" : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 2)        //分片成功
  • Shard:分片服务器,用于存款和储蓄实际的数据块,实际生育环境中二个shard
    server 剧中人物能够由几台服务器组成三个Peplica Set
    承担,幸免主机单点故障。
  • Config
    Server:配置服务器,存款和储蓄了方方面面分片群集的布置音信,在那之中包蕴chunk音讯。
  • Routers:前端路由,客户端因此接入,且让任何群集看上去像单壹数据库,前端采纳能够透明使用。

shard,分片(sharding)是指将数据库拆分,将其疏散在差异的机器上的经过。将数据分散到分裂的机械上,不供给功能强大的服务器就能够储存更加多的数目和处理更大的负载。基本思维正是将集合切成小块,这么些块分散到若干片里,种种片只负责总数据的1有的,最终经过3个均衡器来对一一分片举行均衡(数据迁移)。

config servers: Config servers store metadata and configuration
settings for the cluster. As of MongoDB 3.4, config servers must be
deployed as a replica set (CSRS).

系统环境

replica
set,汉语翻译副本集,其实正是shard的备份,幸免shard挂掉之后数据丢失。复制提供了数额的冗余备份,并在多个服务器上囤积数据副本,升高了多少的可用性,
并能够保障数据的安全性。

三.一 服务器规划

10.202.80.149 10.202.80.150 10.202.80.151
mongos mongos mongos
config server config server config server
shard1(主节点) shard1(从节点) shard1(仲裁节点)
shard2(仲裁节点) shard2(主节点) shard2(从节点)
shard3(从节点) shard3(仲裁节点) shard3(主节点)

注:关于那四个节点介绍,能够参照上边复制集配置文书档案

利用相关端口,一定要记得在防火墙中开放对应端口:

mongos:20000
config server:21000
shard1:27001
shard2:27002
shard3:27003

系统:CentOS 7.4 x86_64

仲裁者(Arbiter),是复制集中的三个MongoDB实例,它并不保留数据。仲裁节点使用最小的财富并且不供给硬件装置,不可能将Arbiter铺排在同3个多少集节点中,能够计划在其他应用服务器只怕监视服务器中,也可配备在单独的虚拟机中。为了保险复制集中有单数的投票成员(包含primary),须求添加仲裁节点做为投票,不然primary不可能运作时不会自动切换primary。

3.2 MongoDB安装

参照MongoDB自学记录【一】(略)

软件版本:四.0

简短驾驭之后,我们得以这么总结一下,应用请求mongos来操作mongodb的增加和删除改查,配置服务器存款和储蓄数据库元消息,并且和mongos做一道,数据最后存入在shard(分片)上,为了以免万1数据丢失同步在副本集中储存了一份,仲裁在数码存款和储蓄到分片的时候决定存款和储蓄到哪些节点。

三.三 创造目录存放文件

在搭建集群环境在此之前,先创制对应目录应用于存放数据和日志,conf文件夹用于存相关安排文件,由于mongos没有数量,所以只开创日志目录

sudo mkdir -p /usr/local/mongodb/conf  
sudo mkdir -p /usr/local/mongodb/mongos/log  
sudo mkdir -p /usr/local/mongodb/config/data
sudo mkdir -p /usr/local/mongodb/config/log
sudo mkdir -p /usr/local/mongodb/shard1/data
sudo mkdir -p /usr/local/mongodb/shard1/log
sudo mkdir -p /usr/local/mongodb/shard2/data
sudo mkdir -p /usr/local/mongodb/shard2/log
sudo mkdir -p /usr/local/mongodb/shard3/data
sudo mkdir -p /usr/local/mongodb/shard3/log

关闭防火墙及selinux

环境准备

3.4 配置config server

先是添加配置文件config.conf

sudo vim /usr/local/mongodb/conf/config.conf

#日志路径配置以及是否叠加
systemLog:
    path:/usr/local/mongodb/config/log/configsrv.log
        logAppend:true

processManagement:
        fork:true
        pidFilePath:/usr/local/mongodb/config/log/configsrv.pid
#配置ip,port以及最大连接数
net:
    #bindIp: 127.0.0.1
    port: 21000
        maxIncomingConnections:200
#配置存放数据的地方
storage:
        dbPath:/usr/local/mongodb/config/data
#配置复制集
replication:
        replSetName:GridSum
#配置分片集群中的角色:configsvr,shardsvr
sharding:
        clusterRole:configsvr

在叁台服务器都安装好后,分别运行3台服务器的config server

sudo mongod -f /usr/local/mongodb/conf/config.conf

都运转之后,任意选择一台服务器,举行以下操作:

mongo 10.202.80.149:21000

config={
    _id:"GridSum",
    members:[
        {_id:0,host:"10.202.80.149:21000"},
        {_id:1,host:"10.202.80.150:21000"},
        {_id:2,host:"10.202.80.151:21000"}
    ]
}

#初始化副本集
rs.initiate(config)

其中,_id要与事先安插文件中的replSet保持1致

IP地址 路由服务器(Routers) 配置服务器(Config Server) Shard1 Shard2 Shard3
192.168.125.119 27017 27018 27001 27002 27003
192.168.125.120 27017 27018 27001 27002 27003
192.168.125.121 27017 27018 27001 27002 27003
  • 系统系统 centos陆.5
  • 叁台服务器:1玖贰.168.0.75/83/6六
  • 安装包: mongodb-linux-x86_64-3.4.6.tgz

三.伍 分别配备分片副本集(3台机器)

配置分片群集

服务器规划

3.5.1 配置shard1

首先创立布局文件shard一.conf:

sudo vim /usr/local/mongodb/conf/shard1.conf

#日志路径配置以及是否叠加
systemLog:
    path:/usr/local/mongodb/shard1/log/shard1.log
        logAppend:true
processManagement:
        fork:true
        pidFilePath:/usr/local/mongodb/shard1/log/shard1.pid
#配置ip,port以及最大连接数
net:
    #bindIp: 127.0.0.1
    port: 27001
        maxIncomingConnections:200
#配置web监控
        http:
              RESTInterfaceEnabled:true
#配置存放数据的地方
storage:
        dbPath:/usr/local/mongodb/shard1/data
#配置复制集
replication:
        replSetName:shard1
#配置分片集群中的角色:configsvr,shardsvr
sharding:
        clusterRole:shardsvr

配置好后,分别运转叁台服务器的shard1服务,任意选一台服务器(注意:不要接纳即将要安装为决策节点的服务器)

sudo mongod -f /usr/local/mongodb/conf/shard1.conf

mongo 10.202.80.149:27001

config = {
    _id : "shard1",
     members : [
         {_id : 0, host : "10.202.80.149:27001" },
         {_id : 1, host : "10.202.80.150:27001" },
        {_id : 2, host : "10.202.80.151:27001" , arbiterOnly: true }
    ]
 }

rs.initiate(config)

同样,_id要和shard一.conf中的replSet保持①致

三台物理服务器安装及陈设

服务器75 服务器84 服务器86
mongos mongos mongos
config server config server config server
shard server1 主节点 shard server1 副节点 shard server1 仲裁
shard server2 仲裁 shard server2 主节点 shard server2 副节点
shard server3 副节点 shard server3 仲裁 shard server3 主节点

3.5.2 配置shard2

sudo vim /usr/local/mongodb/conf/shard2.conf

#日志路径配置以及是否叠加
systemLog:
    path:/usr/local/mongodb/shard2/log/shard2.log
        logAppend:true
processManagement:
        fork:true
        pidFilePath:/usr/local/mongodb/shard2/log/shard2.pid
#配置ip,port以及最大连接数
net:
    #bindIp: 127.0.0.1
    port: 27002
        maxIncomingConnections:200
#配置web监控
        http:
              RESTInterfaceEnabled:true
#配置存放数据的地方
storage:
        dbPath:/usr/local/mongodb/shard2/data
#配置复制集
replication:
        replSetName:shard2
#配置分片集群中的角色:configsvr,shardsvr
sharding:
        clusterRole:shardsvr

布局好后,分别运营三台服务器的shard二服务,任意选壹台服务器(注意:不要挑选即将要安装为决策节点的服务器)

sudo mongod -f /usr/local/mongodb/conf/shard2.conf

mongo 10.202.80.150:27002

config = {
    _id : "shard2",
     members : [
         {_id : 0, host : "10.202.80.149:27002" , arbiterOnly: true},
         {_id : 1, host : "10.202.80.150:27002" },
        {_id : 2, host : "10.202.80.151:27002"  }
    ]
 }

rs.initiate(config)

1、下载解压MongoDB

端口分配:

3.5.3 配置shard3

sudo vim /usr/local/mongodb/conf/shard3.conf


#日志路径配置以及是否叠加
systemLog:
    path:/usr/local/mongodb/shard3/log/shard3.log
        logAppend:true
processManagement:
        fork:true
        pidFilePath:/usr/local/mongodb/shard3/log/shard3.pid
#配置ip,port以及最大连接数
net:
    #bindIp: 127.0.0.1
    port: 27003
        maxIncomingConnections:200
#配置web监控
        http:
              RESTInterfaceEnabled:true
#配置存放数据的地方
storage:
        dbPath:/usr/local/mongodb/shard3/data
#配置复制集
replication:
        replSetName:shard3
#配置分片集群中的角色:configsvr,shardsvr
sharding:
        clusterRole:shardsvr

配备好后,分别运行三台服务器的shard三劳动,任意选一台服务器(注意:不要选取即将要设置为决策节点的服务器)

sudo mongod -f /usr/local/mongodb/conf/shard3.conf

mongo 10.202.80.151:27003

config = {
    _id : "shard3",
     members : [
         {_id : 0, host : "10.202.80.149:27003" },
         {_id : 1, host : "10.202.80.150:27003" , arbiterOnly: true},
         {_id : 2, host : "10.202.80.151:27003" }
     ]
 }


rs.initiate(config)
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.0.tgz
tar zxvf mongodb-linux-x86_64-4.0.0.tgz -C /opt
mv /opt/mongodb-linux-x86_64-4.0.0/ /usr/local/mongodb
mongos:20000
config:21000
shard1:27001
shard2:27002
shard3:27003

3.6 配置mongos

先是创建布局文件mongos.conf

sudo vim /usr/local/mongodb/conf/mongos.conf

#日志路径配置以及是否叠加
systemLog:
    path:/usr/local/mongodb/mongos/log/mongos.log
        logAppend:true
processManagement:
        fork:true
        pidFilePath:/usr/local/mongodb/mongos/log/mongos.pid
#配置ip,port以及最大连接数
net:
    #bindIp: 127.0.0.1
    port: 20000
        maxIncomingConnections:200
#监听的配置服务器,只能有1个或者3个 GridSum为配置服务器的副本集名字
sharding:
        configDB:GridSum/10.202.80.149:21000,10.202.80.150:21000,10.202.80.151:21000

安顿之后,3台服务器运转mongos:

sudo mongos -f /usr/local/mongodb/conf/mongos.conf

2、创制路由、配置、分片服务器的数额存放目录及日志管理

集群搭建

3.7 运营分片

时下搭建了mongodb配置服务器、路由服务器,种种分片服务器,不过应用程序连接到mongos路由服务器并不能够动用分片机制,还必要在程序里设置分片配置,让分片生效。

登陆任意1台mongos

mongo 10.202.80.149:20000

mongos>sh.addShard("shard1/10.202.80.149:27001,10.202.80.150:27001,10.202.80.151:27001")
mongos>sh.addShard("shard2/10.202.80.149:27002,10.202.80.150:27002,10.202.80.151:27002")
mongos>sh.addShard("shard3/10.202.80.149:27003,10.202.80.150:27003,10.202.80.151:27003")

然后用sh.status()查看意况,结果如下:

出于决策节点唯有公投权,并不能够拓展数量的操作,所以每一种分片中唯有八个节点

路由服务器不存款和储蓄数据,由此不要求创立数量存款和储蓄目录,日志文件创制完成还需给予权力。

1、安装mongodb

3.8测试

先是制定数据库可以分片,以及怎样分片

#只有admin才有操作权限
use admin
#指定testdb分片生效
db.runCommand( { enablesharding :"testdb"});
mkdir -p /data/mongodb/config
mkdir -p /data/mongodb/shard{1,2,3}
mkdir -p /data/mongodb/logs
touch /data/mongodb/logs/shard{1,2,3}.log
touch /data/mongodb/logs/mongos.log
touch /data/mongodb/logs/config.log
chmod 777 /data/mongodb/logs/*.log
#解压
tar -xzvf mongodb-linux-x86_64-3.4.6.tgz -C /usr/local/
#改名
mv mongodb-linux-x86_64-3.4.6 mongodb

一.利用限量的分片格局:

#指定数据库里需要分片的集合和片键,1表示自增长
db.runCommand( { shardcollection : "testdb.userid",key : {id: 1} } )

下一场插入数据

use testdb
for(var i=0;i<=1000;i++) db.userid.save({id:i})

用db.userid.stats()查看结果如下:

澳门金沙国际 3

image.png

能够看来分片很不平均,再经过sh.status()查看,能够看看分片规则不均衡:

澳门金沙国际 4

image.png

三、创设管理用户,修改目录权限

分级在每台机械建立conf、mongos、config、shard一、shard贰、shard3三个目录,因为mongos不存款和储蓄数据,只须要树立日志文件目录即可。

2.采用hashed分片

#指定数据库里需要分片的集合和片键,1表示自增长
db.runCommand( { shardcollection : "testdb.username",key : {id: "hashed"} } )

下一场插入数据

use testdb
for(var i=0;i<=1000;i++) db.username.save({id:i})

用db.username.stats()查看结果如下:

澳门金沙国际 5

image.png

能够观察分片相比较均衡,再经过sh.status()查看,能够见到分片规则:

澳门金沙国际 6

image.png

因而建议采用hashed来开始展览分片

参报考博士大学生客:http://www.cnblogs.com/ityouknow/p/7344005.html

useradd -M -s /sbin/nologin mongo
chown -R mongo:mongo /usr/local/mongodb
chown -R mongo:mongo /data/mongodb
mkdir -p /usr/local/mongodb/conf
mkdir -p /usr/local/mongodb/mongos/log
mkdir -p /usr/local/mongodb/config/data
mkdir -p /usr/local/mongodb/config/log
mkdir -p /usr/local/mongodb/shard1/data
mkdir -p /usr/local/mongodb/shard1/log
mkdir -p /usr/local/mongodb/shard2/data
mkdir -p /usr/local/mongodb/shard2/log
mkdir -p /usr/local/mongodb/shard3/data
mkdir -p /usr/local/mongodb/shard3/log

4、添加环境变量,便于使用

布署环境变量

echo 'export MONGODB_HOME=/usr/local/mongodb' >> /etc/profile
echo 'export PATH=$PATH:$MONGODB_HOME/bin' >> /etc/profile
source /etc/profile
vim /etc/profile
# 内容
export MONGODB_HOME=/usr/local/mongodb
export PATH=$MONGODB_HOME/bin:$PATH
# 使立即生效
source /etc/profile

伍、系统参数优化

二、config server配置服务器

ulimit -n 25000  //可以打开的最大文件数量
ulimit -u 25000  //用户最大可用的进程数
sysctl -w vm.zone_reclaim_mode=0 //内存不足时,从其他节点分配内存
# 从CentOS7开始,MongoDB会建议关闭系统的THP特性,否则可能会导致性能下降
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag //*注意*这些优化都是临时的,重启失效

mongodb3.四今后供给配备服务器也创立副本集,不然集群搭建不成功。

安排布署服务器(三台物理服务器配置步骤一样)

添加布置文件

1、写入配置文件,大家能够用scp命令把布置文件发到其余两台物理服务器

vi /usr/local/mongodb/conf/config.conf

## 配置文件内容
pidfilepath = /usr/local/mongodb/config/log/configsrv.pid
dbpath = /usr/local/mongodb/config/data
logpath = /usr/local/mongodb/config/log/congigsrv.log
logappend = true

bind_ip = 0.0.0.0
port = 21000
fork = true

#declare this is a config db of a cluster;
configsvr = true

#副本集名称
replSet=configs

#设置最大连接数
maxConns=20000
# vim config.conf
dbpath=/data/mongodb/config //数据文件存放位置
logpath=/data/logs/config.log  //日志文件
port=27018  //端口号
logappend=true
fork=true
maxConns=5000 
storageEngine=mmapv1
replSet=configs //复制集名称
configsvr=true  //设置参数为true
# mongod -f config.conf //启动config实例
scp /usr/local/mongodb/bin/config.conf root@192.168.125.120:/usr/local/mongodb/bin
scp /usr/local/mongodb/bin/config.conf root@192.168.125.121:/usr/local/mongodb/bin

启航叁台服务器的config server

贰、配置复制集(任意壹台物理机上操作即可)

mongod -f /usr/local/mongodb/conf/config.conf
mongo --port 27018
config={_id:"configs",members:[{_id:0,host:"192.168.125.119:27018"},{_id:1,host:"192.168.125.120:27018"},{_id:2,host:"192.168.125.121:27018"}]}  //创建复制集
rs.initiate(config)        //初始化复制集

报到任意壹台配置服务器,开头化配置副本集

布置分片服务器

#连接
mongo --port 21000
#config变量
config = {
... _id : "configs",
... members : [
...  {_id : 0, host : "192.168.0.75:21000" },
...  {_id : 1, host : "192.168.0.84:21000" },
...  {_id : 2, host : "192.168.0.86:21000" }
... ]
... }

#初始化副本集
rs.initiate(config)

编辑shard{一,2,三}.conf配置文件,端口分别为2700一,27002,2700三,设置shardsvr=true,运转分片服务器

其中,”_id” : “configs”应与安插文件中安插的 replicaction.replSetName
一致,”members” 中的 “host” 为四个节点的 ip 和 port

# vim shard1.conf
dbpath=/data/mongodb/shard1
logpath=/data/logs/shard1.log
port=27001
logappend=true
fork=true
maxConns=5000 
storageEngine=mmapv1
shardsvr=true
# mongod -f shard1.conf
# 与另外两台配置实例配置文件相同,仅端口、数据文件存放及日志文件要改,只需配置完成后启动即可

叁、配置分片副本集(3台机械)

将shard1配置为复制集(这里须要注意的是,预先被设为仲裁节点的服务器上创建复制集会报错。)

安装第3个分片副本集

mongo --port 27001
use admin
config={_id:"shard1",members:[{_id:0,host:"192.168.125.119:27001"},{_id:1,host:"192.168.125.120:27001"},{_id:2,host:"192.168.125.121:27001"}]}  //创建复制集
rs.initiate(config)        //初始化复制集

配备文件

其余两台分片服务器shard二、shard三装置同一,注意端口及裁决节点的难点即可

vi /usr/local/mongodb/conf/shard1.conf

#配置文件内容
#——————————————–
pidfilepath = /usr/local/mongodb/shard1/log/shard1.pid
dbpath = /usr/local/mongodb/shard1/data
logpath = /usr/local/mongodb/shard1/log/shard1.log
logappend = true

bind_ip = 0.0.0.0
port = 27001
fork = true

#打开web监控
httpinterface=true
rest=true

#副本集名称
replSet=shard1

#declare this is a shard db of a cluster;
shardsvr = true

#设置最大连接数
maxConns=20000

配备路由服务器

起首三台服务器的shard一 server

创立布局文件,将配置文件发送到别的物理服务器。注意,路由服务器不需求仓库储存数据目录

mongod -f /usr/local/mongodb/conf/shard1.conf
# vim mongos.conf
logpath=/data/mongodb/logs/mongos.log
logappend = true
port = 27017
fork = true
configdb = configs/192.168.125.119:27018,192.168.125.120:27018,192.168.125.121:27018
maxConns=20000

登6任意1台服务器,开头化副本集

启动mongos实例

mongo --port 27001
#使用admin数据库
use admin
#定义副本集配置,第三个节点的 "arbiterOnly":true 代表其为仲裁节点。
config = {
... _id : "shard1",
... members : [
...  {_id : 0, host : "192.168.0.75:27001" },
...  {_id : 1, host : "192.168.0.84:27001" },
...  {_id : 2, host : "192.168.0.86:27001” , arbiterOnly: true }
... ]
... }
#初始化副本集配置
rs.initiate(config);
mongs -f /usr/local/mongodb/bin/mongos.conf
# 注意,这边启动mongos实例用的是mongos命令

设置第一个分片副本集

运营分片作用

安插文件

mongo //默认进入27017端口
mongos> use admin
mongos> sh.addShard("shard1/192.168.125.119:27001,192.168.125.120:27001,172.16.10.29:27001")
mongos> sh.addShard("shard2/192.168.125.119:27002,192.168.125.120:27002,172.16.10.29:27002")
mongos> sh.status()      //查看群集状态
# 此处为添加两台分片服务器,后续添加的也会均匀分配分片数据
vi /usr/local/mongodb/conf/shard2.conf

#配置文件内容
#——————————————–
pidfilepath = /usr/local/mongodb/shard2/log/shard2.pid
dbpath = /usr/local/mongodb/shard2/data
logpath = /usr/local/mongodb/shard2/log/shard2.log
logappend = true

bind_ip = 0.0.0.0
port = 27002
fork = true

#打开web监控
httpinterface=true
rest=true

#副本集名称
replSet=shard2

#declare this is a shard db of a cluster;
shardsvr = true

#设置最大连接数
maxConns=20000

兑现分片功用

起初3台服务器的shard二 server

设置分片chunk大小

mongod -f /usr/local/mongodb/conf/shard2.conf
mongos> use config
mongos> db.settings.save({"_id":"chunksize","value":1})
# 设置块大小为1M是方便实验,不然需要插入海量数据

登6任意一台服务器,开头化副本集

依傍写入数据

mongo --port 27002
#使用admin数据库
use admin
#定义副本集配置
config = {
... _id : "shard2",
... members : [
...  {_id : 0, host : "192.168.0.75:27002" , arbiterOnly: true },
...  {_id : 1, host : "192.168.0.84:27002" },
...  {_id : 2, host : "192.168.0.86:27002" }
... ]
... }

#初始化副本集配置
rs.initiate(config);
mongos> use school
mongos> show collections
mongos> for(i=1;i<=50000;i++){db.user.insert({"id":i,"name":"jack"+i})}
# 在school库的user表中循环写入五万条数据

设置首个分片副本集

初叶数据库分片

配置文件

mongos>sh.enableSharding("school")
# 我们可以自定义需要分片的库或表
vi /usr/local/mongodb/conf/shard3.conf


#配置文件内容
#——————————————–
pidfilepath = /usr/local/mongodb/shard3/log/shard3.pid
dbpath = /usr/local/mongodb/shard3/data
logpath = /usr/local/mongodb/shard3/log/shard3.log
logappend = true

bind_ip = 0.0.0.0
port = 27003
fork = true

#打开web监控
httpinterface=true
rest=true

#副本集名称
replSet=shard3

#declare this is a shard db of a cluster;
shardsvr = true

#设置最大连接数
maxConns=20000

为school库中的user集合创立索引,然后对表举行分片

运维三台服务器的shard三 server

mongos> db.user.createIndex({"id":1})
# 以"id"作为索引
mongos> sh.shardCollection("school.user",{"id":1})
# 根据"id"对user表进行分片
mongos> sh.status()
# 查看分片情况
mongos> sh.help()
# 查看分片相关的命令
mongod -f /usr/local/mongodb/conf/shard3.conf

如上就是本文的全体内容,希望对咱们的上学抱有支持,也意在大家多多帮助脚本之家。

登六任意1台服务器,开头化副本集

您恐怕感兴趣的小说:

  • MongoDB分片键的选料和案例实例详解
  • MongoDB分片详解
  • mongodb分片技术_引力节点Java高校整理
  • mongodb三.肆集群搭建实战之高可用的分片+副本集
  • 深入精通MongoDB分片的治本
  • MongoDB的分片集群基本配备教程
  • MongoDB分片测试
  • Mongodb
    删除添加分片与非分片表维护
  • MongoDB入门教程之平分秋色技术详解
mongo --port 27003
#使用admin数据库
use admin
#定义副本集配置
config = {
... _id : "shard3",
...  members : [
...   {_id : 0, host : "192.168.0.75:27003" },
...   {_id : 1, host : "192.168.0.84:27003" , arbiterOnly: true},
...   {_id : 2, host : "192.168.0.86:27003" }
...  ]
... }

#初始化副本集配置
rs.initiate(config);

4、配置路由劳务器 mongos

先运维配置服务器和分片服务器,后运维路由实例运维路由实例:(叁台机器)

vi /usr/local/mongodb/conf/mongos.conf

#内容
pidfilepath = /usr/local/mongodb/mongos/log/mongos.pid
logpath = /usr/local/mongodb/mongos/log/mongos.log
logappend = true

bind_ip = 0.0.0.0
port = 20000
fork = true

#监听的配置服务器,只能有1个或者3个 configs为配置服务器的副本集名字
configdb = configs/192.168.0.75:21000,192.168.0.84:21000,192.168.0.86:21000

#设置最大连接数
maxConns=20000

开发银行三台服务器的mongos server

mongod -f /usr/local/mongodb/conf/mongos.conf

伍、启用分片

如今搭建了mongodb配置服务器、路由服务器,各类分片服务器,但是应用程序连接到mongos路由服务器并不能接纳分片机制,还索要在程序里安装分片配置,让分片生效。

登陆任意壹台mongos

mongo --port 20000
#使用admin数据库
user admin
#串联路由服务器与分配副本集
sh.addShard("shard1/192.168.0.75:27001,192.168.0.84:27001,192.168.0.86:27001")
sh.addShard("shard2/192.168.0.75:27002,192.168.0.84:27002,192.168.0.86:27002")
sh.addShard("shard3/192.168.0.75:27003,192.168.0.84:27003,192.168.0.86:27003")
#查看集群状态
sh.status()

6、测试

当前安排服务、路由劳务、分片服务、副本集服务都早已串联起来了,但我们的指标是意在插入数据,数据可见自行分片。连接在mongos上,准备让钦命的数据库、内定的联谊分片生效。

#指定testdb分片生效
db.runCommand( { enablesharding :"testdb"});
#指定数据库里需要分片的集合和片键
db.runCommand( { shardcollection : "testdb.table1",key : {id: 1} } )

大家设置testdb的 table壹 表供给分片,遵照 id 自动分片到 shard1,shard2,shard叁 上边去。要这么设置是因为不是独具mongodb 的数据库和表
都亟需分片!

测试分片配置结果

mongo 127.0.0.1:20000
#使用testdb
use testdb;
#插入测试数据
for (var i = 1; i <= 100000; i++)
db.table1.save({id:i,"test1":"testval1"});
#查看分片情况如下,部分无关信息省掉了
db.table1.stats();

{
  "sharded" : true,
  "ns" : "testdb.table1",
  "count" : 100000,
  "numExtents" : 13,
  "size" : 5600000,
  "storageSize" : 22372352,
  "totalIndexSize" : 6213760,
  "indexSizes" : {
    "_id_" : 3335808,
    "id_1" : 2877952
  },
  "avgObjSize" : 56,
  "nindexes" : 2,
  "nchunks" : 3,
  "shards" : {
    "shard1" : {
      "ns" : "testdb.table1",
      "count" : 42183,
      "size" : 0,
      ...
      "ok" : 1
    },
    "shard2" : {
      "ns" : "testdb.table1",
      "count" : 38937,
      "size" : 2180472,
      ...
      "ok" : 1
    },
    "shard3" : {
      "ns" : "testdb.table1",
      "count" :18880,
      "size" : 3419528,
      ...
      "ok" : 1
    }
  },
  "ok" : 1
}

能够看到数据分到一个分片,各自分片数量为: shard1 “count” : 421八3,shard2“count” : 38九三柒,shard三 “count” : 18880。已经打响了!

前期运行

启航关闭

mongodb的启航顺序是,先运营配置服务器,在运营分片,最终运转mongos.

mongod -f /usr/local/mongodb/conf/config.conf
mongod -f /usr/local/mongodb/conf/shard1.conf
mongod -f /usr/local/mongodb/conf/shard2.conf
mongod -f /usr/local/mongodb/conf/shard3.conf
mongod -f /usr/local/mongodb/conf/mongos.conf

关门时,直接killall杀掉全体进程

killall mongod
killall mongos

总结

上述正是这篇文章的全部内容了,希望本文的内容对大家的学习也许办事能带来一定的支援,倘诺有问号我们能够留言沟通,多谢大家对剧本之家的援救。

参考:

  • 搭建高可用mongodb集群(4)——
    分片
  • MongoDB3.四副本集分片集群搭建
  • Mongodb高可用集群(肆)——分片

您或者感兴趣的篇章:

  • mongodb分片技术_动力节点Java大学整理
  • 长远精通MongoDB分片的管住
  • MongoDB的分片集群基本配备教程
  • MongoDB分片测试
  • Mongodb
    删除添加分片与非分片表维护
  • MongoDB入门教程之平分秋色技术详解
  • MongoDB分片详解

相关文章