mongodb分片集群，你会了么

超、凢脫俗 2022-12-17 14:59 198阅读 0赞

## 前言 ##

mongoDB 作为非关系型数据的典型代码，使用的场景还是非常多的，所以也成了我们必备技能，但是只会简单的CURD 又有什么用呢？又怎能体现出我们价值。所以这篇文章带领大家手把手搭建一个 MongoDB 分片集群的环境。让大家对 mongoDB 有更强的动手的能力，可以直接投入项目中使用。

学习本文 您将了解到：

1.  config 集群配置
2.  shard 集群配置
3.  路由节点配置
4.  权限控制
5.  整合 springboot

我们这次的整体要完成搭建的结构如下，和我们正式环境使用的算是非常接近啦。

![image-20200924133938989][]

功能需求：搭建MongoDB分片集群，具体要求如下：

1、配置节点集群（17011，17013，17015）

2、搭建一个分片集群，要求每个分片节点中的复制集含有一个仲裁节点。

分片节点1：37011，37013，37015，37017（仲裁节点）

分片节点2：47011，47013，47015，47017（仲裁节点）

分片节点3：57011，57013，57015，57017（仲裁节点）

分片节点4：58011，58013，58015，58017（仲裁节点）

3、搭建路由节点（27017）

4、使用权限控制，建立要访问的数据库 test\_user，这个账号名字是 test、密码是 123abc 这个账号对数据库有读写权限

5、使用SpringBoot 进行访问分片集群，对 test\_user 库中的 test\_user\_datas 进行增加和查询操作

## 配置 config 集群 ##

配置服务器。存储所有数据库元信息（路由、分片）的配置。

1、在根目录下创建一个 config 目录。创建三个节点的config 文件。当然正式环境每个节点部署一天机器上是比较好的，我这里没有这么多机器，所以就全部署在一台机器上了。

![image-20200924135954102][]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center]

我们创建 config-17011.conf、config-17013.conf、config-17015.conf 这三个文件，文件内容如下：

config-17011.conf

# 数据库文件位置
    dbpath=config/config1
    #日志文件位置
    logpath=config/logs/config1.log
    #以追加方式写入日志
    logappend=true
    # 是否以守护进程方式运行
    fork = true
    bind_ip=0.0.0.0
    port = 17011
    #表示是一个配置服务器
    configsvr=true
    #配置服务器副本集名称
    replSet=configsvr

config-17013.conf

# 数据库文件位置
    dbpath=config/config2
    #日志文件位置
    logpath=config/logs/config2.log
    #以追加方式写入日志
    logappend=true
    # 是否以守护进程方式运行
    fork = true
    bind_ip=0.0.0.0
    port = 17013
    #表示是一个配置服务器
    configsvr=true
    #配置服务器副本集名称
    replSet=configsvr

config-17015.conf

# 数据库文件位置
    dbpath=config/config3
    #日志文件位置
    logpath=config/logs/config3.log
    #以追加方式写入日志
    logappend=true
    # 是否以守护进程方式运行
    fork = true
    bind_ip=0.0.0.0
    port = 17015
    #表示是一个配置服务器
    configsvr=true
    #配置服务器副本集名称
    replSet=configsvr

可以看到其实配置都是一样的，只是绑定的端口，数据文件位置，日志文件路径不一样。另外我们还需要创建好 config1、config2、config3 以及 logs 文件夹。不然指定文件启动的时候会报错的说找不到指定目录的。

2、这样我们 config 节点就配置差不多了，当然等启动之后还需要修改配置，接下来我们启动他们

./bin/mongod -f config/config-17011.conf 
    ./bin/mongod -f config/config-17013.conf 
    ./bin/mongod -f config/config-17015.conf

3、我们随便进入一个config 节点吧

./bin/mongo --port 17011

![image-20200924145500349][]

4、切换到 admin 库 配置节点信息如下：正式环境注意改成 config 节点的链接信息。

use admin 
    var cfg ={"_id":"configsvr", 
    "members":[ 
    {"_id":1,"host":"127.0.0.1:17011"}, 
    {"_id":2,"host":"127.0.0.1:17013"}, 
    {"_id":3,"host":"127.0.0.1:17015"}] 
    };
    rs.initiate(cfg)

![image-20200924145846768][]

可以看到初始化完成后，会变成多个节点，我们这里的config 是一主两从。主节点是 PRIMARY .

我们可以通过来查看节点的状态。

rs.status()

![image-20200924145956151][]

这样我们的 config 集群就已经搭建好了。

## 配置 shard 集群 ##

上面要求有四个分片，每个分片有四个节点，一主两从一仲裁节点。我这里就详细讲解下其中一个分片的部署吧，其他分片都是一样的。

1、首先根目录下创建 shard 目录，创建 shard1-37011.conf、shard1-37013.conf、shard1-37015.conf、shard1-37017.conf 文件。我这里还是所有的节点都在一台机器上，正式环境不说每个节点在一台机器上，最起码每个分片是在不同的机器上的。

![image-20200924141113035][]

shard1-37011.conf

# 数据库文件位置
    dbpath=shard/shard1/shard1-37011
    # 远程访问
    bind_ip=0.0.0.0
    # 端口
    port=37011
    # 是否以守护进程方式运行
    fork=true
    #日志文件位置
    logpath=shard/shard1/shard1-37011.log
    #指定的节点名称
    replSet=shard1
    ## 表示是一个分片服务器
    shardsvr=true

shard1-37013.conf

# 数据库文件位置
    dbpath=shard/shard1/shard1-37013
    # 远程访问
    bind_ip=0.0.0.0
    # 端口
    port=37013
    # 是否以守护进程方式运行
    fork=true
    #日志文件位置
    logpath=shard/shard1/shard1-37013.log
    #指定的节点名称
    replSet=shard1
    ## 表示是一个分片服务器
    shardsvr=true

可以看到同一个分片上的不同节点的配置，就数据库文件位置，端口，日志文件路径不一样，其他的都是一样的。

不同分片上的节点，指定的节点名称是不一样的。如下：

shard2-47011.conf

# 数据库文件位置
    dbpath=shard/shard2/shard2-47011
    # 远程访问
    bind_ip=0.0.0.0
    # 端口
    port=47011
    # 是否以守护进程方式运行
    fork=true
    #日志文件位置
    logpath=shard/shard2/shard2-47011.log
    #指定的节点名称
    replSet=shard2
    ## 表示是一个分片服务器
    shardsvr=true

2、其他的分片节点的配置文件都差不多，大伙照着配置就可以啦。这样我们 shard 也初步配置好了，接下来我们启动他们。每个分片的节点需要联系起来，就和上面的 config 是一样的。

./bin/mongod -f shard/shard1-37011.conf 
    ./bin/mongod -f shard/shard1-37013.conf 
    ./bin/mongod -f shard/shard1-37015.conf
    ./bin/mongod -f shard/shard1-37017.conf 
    ./bin/mongod -f shard/shard2-47011.conf 
    ./bin/mongod -f shard/shard2-47013.conf 
    ./bin/mongod -f shard/shard2-47015.conf
    ./bin/mongod -f shard/shard2-47017.conf
    ./bin/mongod -f shard/shard3-57011.conf 
    ./bin/mongod -f shard/shard3-57013.conf 
    ./bin/mongod -f shard/shard3-57015.conf
    ./bin/mongod -f shard/shard3-57017.conf 
    ./bin/mongod -f shard/shard4-58011.conf 
    ./bin/mongod -f shard/shard4-58013.conf 
    ./bin/mongod -f shard/shard4-58015.conf
    ./bin/mongod -f shard/shard4-58017.conf

我们以启动一个分片为例吧，其他的分片都是一样哒。

3、进行初始化，我们进入其中一个分片为例

./bin/mongo --port 37011

var cfg ={
    "_id":"shard1", 
    "protocolVersion" : 1, 
    "members":[ 
    {"_id":1,"host":"127.0.0.1:37011"}, 
    {"_id":2,"host":"127.0.0.1:37013"}, 
    {"_id":3,"host":"127.0.0.1:37015"}, 
    ]};
    rs.initiate(cfg)

![image-20200924151637886][]

4、我们还有一个37017的节点没有挂上去，是用来做仲裁节点的，我们需要到主节点上执行如下：

rs.addArb("127.0.0.1:37017")

![image-20200924151746627][]

我们可以通过下面命令查看节点的状态

rs.status()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center 1]

可以看到我们 37017 节点的角色为ARBITER 。说明我们配置成功啦。

其他分片的配置也是一样的，这里我们就不具体操作了，就把每个分片的操作贴出来吧。

分片2：

var cfg ={
    "_id":"shard2", 
    "protocolVersion" : 1, 
    "members":[ 
    {"_id":1,"host":"127.0.0.1:47011"}, 
    {"_id":2,"host":"127.0.0.1:47013"}, 
    {"_id":3,"host":"127.0.0.1:47015"}, 
    ]};
    rs.initiate(cfg)
    rs.addArb("127.0.0.1:47017")

分片3：

var cfg ={
    "_id":"shard3", 
    "protocolVersion" : 1, 
    "members":[ 
    {"_id":1,"host":"127.0.0.1:57011"}, 
    {"_id":2,"host":"127.0.0.1:57013"}, 
    {"_id":3,"host":"127.0.0.1:57015"}, 
    ]};
    rs.initiate(cfg)
    rs.addArb("127.0.0.1:57017")

分片4：

var cfg ={
    "_id":"shard4", 
    "protocolVersion" : 1, 
    "members":[ 
    {"_id":1,"host":"127.0.0.1:58011"}, 
    {"_id":2,"host":"127.0.0.1:58013"}, 
    {"_id":3,"host":"127.0.0.1:58015"}, 
    ]};
    rs.initiate(cfg)
    rs.addArb("127.0.0.1:58017")

好了，到此为止我们的配置集群和分片集群都搭建好啦，接下来我配置路由节点。

## 配置路由节点 ##

1、配置路由节点，也差不多一样的思路，根目录下创建 route目录，然后创建 route-27017.conf

![image-20200924143043759][]

route-27017.conf 内容如下：

# 端口
    port=27017
    # 远程访问
    bind_ip=0.0.0.0
    # 后台启动
    fork=true
    # 日志路径
    logpath=route/logs/route.log
    #配置的节点信息
    configdb=configsvr/127.0.0.1:17011,127.0.0.1:17013,127.0.0.1:17015

这里注意的是 configdb 配置的是我们配置节点的连接信息，如果是不同服务器记得改成对应的ip 。**还又一点需要注意，上面这些依赖的目录啊，都需要我们手动创建好才行，不然到时候我们启动会报错的。**

2、接下来我们启动 路由。

./bin/mongos -f route/route-27017.conf

这里需要注意的是启动 路由的命令是 mongos 。

![image-20200924153838245][]

3、启动成功后我们进入路由。

./bin/mongo --port 27017

我们进来后，可以看看初始的路由状态。

![image-20200924154356869][]

4、接下来我们需要将我们的分片集群添加到路由中。

sh.addShard("shard1/127.0.0.1:37011,127.0.0.1:37013,127.0.0.1:37015,127.0.0.1:37017"); 
    sh.addShard("shard2/127.0.0.1:47011,127.0.0.1:47013,127.0.0.1:47015,127.0.0.1:47017");
    sh.addShard("shard3/127.0.0.1:57011,127.0.0.1:57013,127.0.0.1:57015,127.0.0.1:57017"); 
    sh.addShard("shard4/127.0.0.1:58011,127.0.0.1:58013,127.0.0.1:58015,127.0.0.1:58017");

![image-20200924154643170][]

接下来我们再看看路由的状态。发现添加了分片的信息。看是你可以发现我们的每个分片中的仲裁节点其实配路由剔除了的，因为仲裁节点不存储数据，只起到监控作用。

![image-20200924154728896][]

5、接下来，我们需要开启数据库和集合的分片。

#为数据库开启分片功能 
    sh.enableSharding("test_user") 
    
    #为指定集合开启分片功能 
    sh.shardCollection("test_user.test_user_datas",{"name":"hashed"})

![image-20200924155611196][]

这样我们的路由的配置就基本完成啦，如果不加权限校验的话，我们现在就可以使用了，但是在正式环境，还是需要增加权限控制的，所以我们这里接下来做权限控制。

## 权限控制 ##

1、创建管理员用户和普通用户。我们还是在路由节点中先创建管理员账户和我们测试的账户。

use admin
    db.createUser({user:"root",pwd:"123456",roles:[{role:"root",db:"admin"}]})
    db.createUser({user:"zlf",pwd:"123",roles:[{role:"readWrite",db:"test_user"}]})
    
    use test_user
    db.createUser({user:"test",pwd:"123abc",roles:[{role:"readWrite",db:"test_user"}]})

![image-20200924160224912][]

![image-20200924173753141][]

补充用户操作：

# 查看全局用户
    db.system.users.find().pretty()
    
    # 查看当前库用户
    show users
    
    # 删除用户
    db.dropUser("用户名")
    
    # 修改密码
    db.changeUserPassword( 'root' , 'rootNew' );
    
    #添加角色
    db.grantRolesToUser( '用户名' , [{ role: '角色名' , db: '数据库名'}])

2、创建完用户之后，需要关闭所有的节点，并增加配置。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center 2]

可以看到有这么多进程，一个个的关很不方便，所以下载一个插件可以。

#安装psmisc 
    yum install psmisc 
    
    #安装完之后可以使用killall 命令 快速关闭多个进程 
    killall mongod
    killall mongos
    killall mongo

![image-20200924175019659][]

3、生成密钥文件 并修改权限

openssl rand -base64 756 > data/mongodb/testKeyFile.file 
    chmod 600 data/mongodb/keyfile/testKeyFile.file

![image-20200924184320716][]

4、配置节点集群和分片节点集群开启权限认证和秘钥文件

auth=true 
    keyFile=data/mongodb/testKeyFile.file

这里我们所有都配置文件中都需要加上记得。

![image-20200924185043188][]

5、路由配置增加安全认证

keyFile=data/mongodb/testKeyFile.file

![image-20200924185826558][]

6、启动所有节点。上面我们以及配置好了这些节点的配置文件，那么我们这里就来启动他们。这里我为了避免一个个的启动，这里我些了一个shell 脚本，依次启动他们，先启动 config，然后启动 shard ,最后启动路由。但是正式环境上，因为部署在不同的服务器上，估计的一个个的启动了。

在跟目录下创建一个 startup.sh 脚本，并增加可执行权限。

![image-20200924144006286][]

内容如下：

./bin/mongod -f config/config-17011.conf 
    ./bin/mongod -f config/config-17013.conf 
    ./bin/mongod -f config/config-17015.conf 
    ./bin/mongod -f shard/shard1-37011.conf 
    ./bin/mongod -f shard/shard1-37013.conf 
    ./bin/mongod -f shard/shard1-37015.conf
    ./bin/mongod -f shard/shard1-37017.conf 
    ./bin/mongod -f shard/shard2-47011.conf 
    ./bin/mongod -f shard/shard2-47013.conf 
    ./bin/mongod -f shard/shard2-47015.conf
    ./bin/mongod -f shard/shard2-47017.conf
    ./bin/mongod -f shard/shard3-57011.conf 
    ./bin/mongod -f shard/shard3-57013.conf 
    ./bin/mongod -f shard/shard3-57015.conf
    ./bin/mongod -f shard/shard3-57017.conf 
    ./bin/mongod -f shard/shard4-58011.conf 
    ./bin/mongod -f shard/shard4-58013.conf 
    ./bin/mongod -f shard/shard4-58015.conf
    ./bin/mongod -f shard/shard4-58017.conf
    ./bin/mongos -f route/route-27017.conf

![image-20200924190418198][]

可以看到都启动成功啦。

## springboot 使用 ##

其实到这里我们整个分片集群就已经搭建好了，但是我们这里先不验证吧，我们先整合springboot ，我们在项目中使用他们。

1、我们创建一个springboot 项目，添加 MongoDB 依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>

2、配置mongodb 的连接信息。我们这里连接我们路由就好了，然后指定我们创建的用户。

spring.data.mongodb.host=192.168.34.75
    spring.data.mongodb.port=27017
    spring.data.mongodb.database=test_user
    spring.data.mongodb.username=test
    spring.data.mongodb.password=123abc

3、创建一个User 实体类。

public class User {
    
        private String id;
        private String name;
        private String city;
        private String birthday;
        private  double  salary;
        private  double  gender;
        
        //getter()和setter() 方法。
    }

4、创建 controller 层。写了三个方法，删除，增加和查找，待会方便我们测试。

@RestController
    @RequestMapping("/mongo")
    public class UserController {
    
        @Autowired
        private MongoTemplate mongoTemplate;
    
    
        @RequestMapping("/insert")
        public String insertResume() {
            for(int i=0;i<1000;i++){
                User user = new User("id_"+i,"test_"+i,"深圳","1999-09-09",100*i,i%2);
                mongoTemplate.insert(user,"test_user_datas");
            }
            return "success";
        }
    
        @RequestMapping("/list")
        public List<User> find() {
           return mongoTemplate.findAll(User.class,"test_user_datas");
        }
    
        @RequestMapping("/delete")
        public String remove(){
            Query query = Query.query(Criteria.where("city").is("深圳"));
            mongoTemplate.remove(query,"test_user_datas");
            return "del success";
        }
    }

## 测试 ##

上面我们就已经都准备好了，接下来我们就来测试一下吧。

首先我们启动我们的项目。然后调用insert 方法。进行数据的插入。

http://localhost:8080/mongo/insert

![image-20200924195309732][]

界面上先查询看下：

http://localhost:8080/mongo/list

![image-20200924195344929][]

说明我们插入成功了，但是我们怎么知道我们分片有没有成功呢？接下来我们去路由节点和分片节点看下。

先来路由节点。

./bin/mongo --port 27017

直接操作的话，会提示你没有权限，说明我们的权限配置起作用了。

![image-20200924195633111][]

我们切换到test\_user 库。然后鉴权

use test_user
    db.auth("test","123abc")

![image-20200924195831618][]

最后我们查一下

db.test_user_datas.find()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center 3]

我们查看下路由状态。切刀admin 库并且切换成超级管理员。

use admin
    db.auth("root","123456")
    sh.status()

![image-20200924201710596][]

这里其实就说明我们的分片是成功哒。

接下来我们调用删除方法，删除这些数据。

http://localhost:8080/mongo/delete

![image-20200924202227599][]

![在这里插入图片描述][20201024101358375.png_pic_center]

再查询，灭有数据了，说明数据都删除成功啦。

[image-20200924133938989]: /images/20221122/80d77ba1b32b44eca8bd4433472fc5ff.png
[image-20200924135954102]: /images/20221122/314e64f2dfaa4ad5927ba088903282da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221122/f1d60d25a3084ed9881e6c7812bc0d45.png
[image-20200924145500349]: /images/20221122/6e9b9d62648c4f06a59f84e28ad11cb8.png
[image-20200924145846768]: /images/20221122/a7d88f0d99454fc9b31856b2be2e9306.png
[image-20200924145956151]: /images/20221122/866dba106735400da564ad712cac0ca7.png
[image-20200924141113035]: /images/20221122/ce95537bb6904267adac7f72330da33a.png
[image-20200924151637886]: /images/20221122/62717192ac864246a519171c77613c1c.png
[image-20200924151746627]: /images/20221122/8555ec35b55c44af9a114b9ee0ed45c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221122/326578ae2c054ccaa3b5445757ade1cd.png
[image-20200924143043759]: /images/20221122/ef1d90c99dfa4616a411da81648244cb.png
[image-20200924153838245]: /images/20221122/a82fee20de1343f6b81c41cc17e5f3cb.png
[image-20200924154356869]: /images/20221122/6d641bfbf0ed4fc5998355d948111d6c.png
[image-20200924154643170]: /images/20221122/09202570c5214b8fa97baa91e48160ea.png
[image-20200924154728896]: /images/20221122/997ff3f1c98e4c19bf30e704f71af4bd.png
[image-20200924155611196]: /images/20221122/fa671e2dceb1415a950452b073fbdcc5.png
[image-20200924160224912]: /images/20221122/d5bf87c508ab401f9d1050a2aa148841.png
[image-20200924173753141]: /images/20221122/64d4b117d60948a68412363090d1bddc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221122/947cd5f608ca4195b32878a5726c8ca6.png
[image-20200924175019659]: /images/20221122/4c74814e24044ea1badd3ec8dbc6a96d.png
[image-20200924184320716]: /images/20221122/2f7f2f067f604253af809e3f031a8b37.png
[image-20200924185043188]: /images/20221122/f85d306343b94c5ea20294c2dae3426f.png
[image-20200924185826558]: /images/20221122/cff3f87a09a64161af7ead4cf9ac2733.png
[image-20200924144006286]: /images/20221122/12cff65299ee48e0a5a5eb21bf3a8948.png
[image-20200924190418198]: /images/20221122/55b8b7bbd6e94c2a9c68def015b57d5e.png
[image-20200924195309732]: /images/20221122/3ae3635629354bde9466c3dae51efeb2.png
[image-20200924195344929]: /images/20221122/333f5fd1d01149549813b597883da676.png
[image-20200924195633111]: /images/20221122/d9bb7eeff58641e49ef2e0f9eb995ab7.png
[image-20200924195831618]: /images/20221122/9b3b0f204d364d74842766aa6422d0ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3NzkwMDEx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221122/f12bb0289abe41d0ac01eeb4f9affe94.png
[image-20200924201710596]: /images/20221122/e4122e1737bc40a39c2a19470a80f26f.png
[image-20200924202227599]: /images/20221122/0f6d5dd2e97b463383aa67570961cd0c.png
[20201024101358375.png_pic_center]: /images/20221122/e5c3de2c3c5b421490d73e69084318f5.png