devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

三、MongoDB复制集，分片集群_mongodb 复制集 & 分片

作者：Monodyee | 2024-05-04 08:45:42

赞

踩

mongodb 复制集 & 分片

一、MongoDB 高可用复制集架构

MongoDB 复制集

MongoDB复制集的主要意义在于实现服务高可用，类似于Redis中的哨兵模式

 

它主要提供两个方面的功能

1. 数据写入主节点（Primary）时将数据复制到另一个副本节（Secondary）点上

2. 主节点发生故障时自动选举出一个新的替代节点

在实现高可用的同时，复制集实现了其他几个作用

数据分发：将数据从一个区域复制到另一个区域，减少另一个区域的读延迟

读写分离：不同类型的压力分别在不同的节点上执行

异地容灾：在数据中心故障时快速切换到异地

 

典型复制集结构

一个典型的复制集由三个或三个以上具有投票权的节点组成，其中一个主节点（Primary）：接收写入操作，读操作和选举时投票，两个或多个从节点(Secondary)：复制主节点上的新数据和选举时投票

 

数据是如何复制的？

当一个修改操作，无论是插入，更新或删除，到达主节点时，它对数据的操作将被记录下来（经过一些必要的转换）。这些记录称为oplog

从节点通过从主节点上不断获取新进入主节点的oplog，并在自己的数据上回放，以此保持跟主节点的数据一致。

0

 

通过选举完成故障恢复

具有投票权的节点之间两两互相发送心跳；

当5次心跳未收到时判断为节点失联

如果失联的是主机点，从节点会发起选举，选出新的主节点

如果失联的是从节点则不会产生新的选举

选举基于RAFT一致性算法实现，选举成功的必要条件是大多数投票节点存活

复制集中最多可以有50个节点，但具有投票权的节点最多7个

 

影响选举的因素

整个集群必须有大多数节点存活

被选举为主节点的节点必须

1.能够与多数节点建立连接

2.具有较新的oplog

3.具有较高的优先级（如果有配置）

 

复制集节点有以下的选配项

是否具有投票权（v 参数）： 有则参与投票

优先级（priority参数）：优先级越高的节点越优先成为主节点。优先级为0的节点无法成为主节点,默认值为1。

隐藏（hidden参数）：复制数据，但对应用不可见。隐藏节点可以具有投票权，但优先级必须为0

延迟（slaveDelay参数）：复制 n 秒之前的数据，保持与主节点的时间差

从节点不建立索引( buildIndexes)

 

复制集注意事项

硬件：

因为正常的复制集节点都有可能成为主节点，它们的地位是一样的，因此硬件配置上必须一致

为了保证节点不会同时宕机，各节点的硬件必须具有独立性。

软件：

复制集各节点软件版本必须一致，以避免出现不可预知的问题

增加节点不会增加系统写性能

 

复制集搭建

1. 创建数据目录文件

Linux系统

mkdir -p /data/db{1,2,3}

3. 准备每个数据库的配置文件

复制集的每个mongod进程应该位于不同的服务器。我们现在在一台服务器上运行三个实例，所以要为它们各自配置

1.不同的端口： 28017， 28018，28019.

2.不同的数据目录

data/db1,data/db2,data/db3

3. 不同的日志文件路径。实例中使用

/data/db1/mongod.log

/data/db2/mongod.log

/data/db3/mongod.log

 

data/db1/mongod.conf

  1. systemLog:
  2.   destination: file
  3.   path: /data/db1/mongod.log
  4.   logAppend: true
  5. storage:
  6.   dbPath: /data/db1
  7. net:
  8.   bindIp: 0.0.0.0
  9.   port: 28017
  10. replication:
  11.   replSetName: rs0
  12. processManagement:
  13.   fork: true

/data/db2/mongod.conf

  1. systemLog:
  2.   destination: file
  3.   path: /data/db2/mongod.log
  4.   logAppend: true
  5. storage:
  6.   dbPath: /data/db2
  7. net:
  8.   bindIp: 0.0.0.0
  9.   port: 28018
  10. replication:
  11.   replSetName: rs0
  12. processManagement:
  13.   fork: true

/data/db3/mongod.conf

  1. systemLog:
  2.   destination: file
  3.   path: /data/db3/mongod.log
  4.   logAppend: true
  5. storage:
  6.   dbPath: /data/db3
  7. net:
  8.   bindIp: 0.0.0.0
  9.   port: 28019
  10. replication:
  11.   replSetName: rs0
  12. processManagement:
  13.   fork: true

 

分别启动

mongod -f /data/db1/mongod.conf

mongod -f /data/db2/mongod.conf

mongod -f /data/db3/mongod.conf

 

window没法 fork， 所以只能用前台进程开启， 需要 开3个命令窗口分别启动

 

配置复制集

mongo --port 28017

  1. > rs.initiate({
  2.  
  3. _id:"rs0",
  4. members:[{
  5. _id:0,
  6. host:"localhost:28017"
  7. },{
  8. _id:1,
  9. host:"localhost:28018"
  10. },{
  11. _id:2,
  12. host:"localhost:28019"
  13. }]
  14. })
  15.  
  16. 默认情况下非主节点不允许读数据
  17. 可以通过执行 rs.secondaryOk() 开启读权限

mongo --port 28017 连接到主节点

0

mongo --port 28018 连接到从节点上面

执行

0

二、MongoDB 集群分片机制原理

分片集群

2.1 什么是分片？

将数据水平拆分到不同的服务器上

2.1 为什么要使用分片集群

数据量突破单机瓶颈，数据量大，恢复很慢，不利于数据管理

并发量突破单机性能瓶颈

MongoDB 分片集群由一下几部分组成

0

2.3 分片集群角色：

路由节点： mongos， 提供集群单一入口，转发应用端请求，选择合适的数据节点进行读写，合并多个数据节点的返回。无状态，建议 mongos节点集群部署以提供高可用性。客户请求应发给mongos，而不是 分片服务器，当查询包含分片片键时，mongos将查询发送到指定分片，否则，mongos将查询发送到所有分片，并汇总所有查询结果。

配置节点: 就是普通的mongod进程， 建议以复制集部署，提供高可用

提供集群元数据存储分片数据分布的数据。主节点故障时，配置服务器进入只读模式,

只读模式下，数据段分裂和集群平衡都不可执行。整个复制集故障时，分片集群不可用

数据节点：

以复制集为单位，横向扩展最大1024分片，分片之间数据不重复，所有数据在一起才可以完整工作。

 

2.4 分片键

可以是单个字段， 也可以是复合字段

1. 范围分片

比如 key 的值 从 min - max

可以把数据进行范围分片

2. hash 分片

通过 hash(key ) 进行数据分段

片键值用来将集合中的文档划分为数据段,片键必须对应一个索引或索引前缀（单键、复合键）,可以使用片键的值 或者片键值的哈希值进行分片

 

选择片键

1. 片键值的范围更广（可以使用复合片键扩大范围）

2. 片键值的分布更平衡（可使用复合片键平衡分布）

3. 片键值不要单向增大、减小（可使用哈希片键）

数据段的分裂

当数据段尺寸过大，或者包含过多文档时，触发数据段分裂,只有新增、更新文档时才可能自动触发数据段分裂,数据段分裂通过更新元数据来实现

集群的平衡

后台运行的平衡器负责监视和调整集群的平衡,当最大和最小分片之间的数据段数量相差过大时触发

集群中添加或移除分片时也会触发

MongoDB分片集群特点

1.应用全透明

2.数据自动均衡

3.动态扩容，无需下线

搭建集群环境：

搭建一个2个分片的集群

步骤：

配置第一个 分片集群：

1. 创建数据目录 ： 准备给两个复制集使用，每个复制集有三个实例 ,共 6 个数据节点

mkdir -p /data/shard1    /data/shard1second1     /data/shard1second2     /data/shard2    /data/shard2second1     /data/shard2second2

2. 创建日志文件，共6 个文件

touch  /data/shard1/mongod.log     /data/shard1second1/mongod.log    /data/shard1second2/mongod.log    /data/shard2/mongod.log     /data/shard2second1/mongod.log    /data/shard2second2/mongod.log

3. 启动第一个 mongod 分片实例( 一共三个实例)

mongod --bind_ip 0.0.0.0 --replSet shard1 --dbpath /data/shard1 --logpath /data/shard1/mongod.log --port 27010   --fork   --shardsvr
mongod --bind_ip 0.0.0.0 --replSet shard1 --dbpath /data/shard1second1  --logpath /data/shard1second1/mongod.log --port 27011   --fork   --shardsvr
mongod --bind_ip 0.0.0.0 --replSet shard1 --dbpath /data/shard1second2 --logpath /data/shard1second2/mongod.log --port 27012   --fork   --shardsvr

4. 第一个分片的mongod 实例都启动好了后，将其加入到复制集中

  1. rs.initiate(
  2. {_id:"shard1",
  3.     "members":[ 
  4.                 {"_id":0,"host":"192.168.109.200:27010"},
  5.                 {"_id":1,"host":"192.168.109.200:27011"},
  6.                 {"_id":2,"host":"192.168.109.200:27012"}
  7.                 ]
  8. });

等待集群选举

5. 查看状态

rs.status();

配置Config 复制集：一共三个实例

1. 创建数据目录：

mkdir -p /data/config    /data/configsecond1     /data/configsecond2

2. 创建日志文件

touch  /data/config/mongod.log     /data/configsecond1/mongod.log    /data/configsecond2/mongod.log

3. 启动配置复制集

mongod --bind_ip 0.0.0.0 --replSet config --dbpath /data/config  --logpath /data/config/mongod.log --port 37010   --fork   --configsvr 
mongod --bind_ip 0.0.0.0 --replSet config --dbpath /data/configsecond1 --logpath /data/configsecond1/mongod.log --port 37011   --fork   --configsvr 
mongod --bind_ip 0.0.0.0 --replSet config --dbpath /data/configsecond2  --logpath /data/configsecond2/mongod.log --port 37012   --fork   --configsvr

4. 配置复制集进行初始化

  1. rs.initiate(
  2.     {_id:"config",
  3.         "members":[ 
  4.                     {"_id":0,"host":"192.168.109.200:37010"},
  5.                     {"_id":1,"host":"192.168.109.200:37011"},
  6.                     {"_id":2,"host":"192.168.109.200:37012"}
  7.                     ]
  8.     });

配置mongs 路由节点

1. 启动mongos 实例，需要指定配置服务器的地址列表

mongos --bind_ip 0.0.0.0 --logpath /data/mongos/mongos.log --port 4000 --fork --configdb config/111.229.189.98:37010,111.229.189.98:37011,111.229.189.98:37012

其中 configdb 为配置服务器的地址列表

2. 连接到mongos中，并添加分片

直接通过mongo shell 客户端进行连接

mongo --port 4000 本地直连

执行脚本

sh.addShard("shard1/111.229.189.98:27010,111.229.189.98:27011,111.229.189.98:27012");

查看分片状态：

sh.status();

mongos 可以用同样的方式，创建多个

  1. 创建分片表：
  2. 1. MongoDB的分片时基于集合的，就算有分片集群不等于数据会自动分片，需要显示分片表
  3.  
  4. 首先需要 启用数据库分片
  5. sh.enableSharding("库名");
  6. 如： 
  7. sh.enableSharding("order");
  8.  
  9. sh.shardCollection("库名.集合名",{_id: "hashed"});
  10. sh.shardCollection("order.account",{_id: "hashed"});
  11.  
  12. 添加一组数据
  1. for( var i =0;i<100; i++){
  2. db.productdesc.insert({i:i});
  3. }

动态扩容

创建第二个复制集来实现分片

mongod --bind_ip 0.0.0.0 --replSet shard2 --dbpath /data/shard2 --logpath /data/shard2/mongod.log --port 27013   --fork   --shardsvr
mongod --bind_ip 0.0.0.0 --replSet shard2 --dbpath /data/shard2second1  --logpath /data/shard2second1/mongod.log --port 27014   --fork   --shardsvr
mongod --bind_ip 0.0.0.0 --replSet shard2 --dbpath /data/shard2second2 --logpath /data/shard2second2/mongod.log --port 27015   --fork   --shardsvr

初始化复制集

  1. rs.initiate(
  2. {_id:"shard2",
  3.     "members":[ 
  4.                 {"_id":0,"host":"111.229.189.98:27013"},
  5.                 {"_id":1,"host":"111.229.189.98:27014"},
  6.                 {"_id":2,"host":"111.229.189.98:27015"}
  7.                 ]
  8. });

加入到集群分片

  1. mongo --port 4000
  2. sh.addShard("shard2/111.229.189.98:27013,111.229.189.98:27014,111.229.189.98:27015");

异常说明：

https://www.cnblogs.com/lazyboy/archive/2012/11/26/2789401.html

0

前面有数据了， 再分配分片键会报错

 

三、MongoDB 应用与开发实战

MongoDB 应用实战

代码demo下载：mongodb代码demo.zip

最新驱动的地址

https://mongodb.github.io/mongo-java-driver/4.1/driver/

3.1 java 原生客户端

引入maven

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.mongodb</groupId>
  4.         <artifactId>mongodb-driver-sync</artifactId>
  5.         <version>4.1.1</version>
  6.     </dependency>
  7. </dependencies>
  1. public class QuickStart {
  2.  
  3.     public static void main(String[] args) {
  4.         // 连接本地默认端口的Mongod
  5.         // MongoClient mongoClient = MongoClients.create()
  6.         // 连接远程服务的指定端口的Mongod
  7.         // MongoClient mongoClient = MongoClients.create("mongodb://host1:27017");
  8.         // 连接指定端口复制集
  9.         // MongoClient mongoClient = MongoClients.create("mongodb://host1:27017,host2:27017,host3:27017/?replicaSet=myReplicaSet");
  10.         // 连接 mongos路由: 连接一个
  11.         // MongoClient mongoClient = MongoClients.create( "mongodb://localhost:27017" );
  12.         // 连接多个mongos路由
  13.         MongoClient mongoClient = MongoClients.create("mongodb://111.229.189.98:4000");
  14.  
  15.  
  16.         //获取数据库
  17.         MongoDatabase database = mongoClient.getDatabase("productdb");
  18.  
  19.         // 获取集合
  20.         MongoCollection<Document> productdesc=database.getCollection( "productdesc" );
  21.  
  22.         Document doc = new Document("name", "MongoDB")
  23.                 .append("type", "database")
  24.                 .append("count", 1)
  25.                 .append("versions", Arrays.asList("v3.2", "v3.0", "v2.6"))
  26.                 .append("info", new Document("x", 203).append("y", 102));
  27.  
  28.         productdesc.insertOne(doc);
  29.  
  30.  
  31.         Bson eq = eq("name", "MongoDB");
  32.         FindIterable<Document> find = productdesc.find(eq);
  33.         Document first=find.first();
  34.         System.out.println(first);
  35.  
  36.     }
  37. }

3.2 Spring Boot 整合：

https://docs.spring.io/spring-data/mongodb/docs/3.1.2/reference/html/#preface

1. 引入maven

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.    <modelVersion>4.0.0</modelVersion>
  5.    <parent>
  6.       <groupId>org.springframework.boot</groupId>
  7.       <artifactId>spring-boot-starter-parent</artifactId>
  8.       <version>2.4.0</version>
  9.       <relativePath/> <!-- lookup parent from repository -->
  10.    </parent>
  11.    <groupId>com.example</groupId>
  12.    <artifactId>demo</artifactId>
  13.    <version>0.0.1-SNAPSHOT</version>
  14.    <name>demo</name>
  15.    <description>Demo project for Spring Boot</description>
  16.  
  17.    <properties>
  18.       <java.version>1.8</java.version>
  19.    </properties>
  20.  
  21.    <dependencies>
  22.       <dependency>
  23.          <groupId>org.springframework.boot</groupId>
  24.          <artifactId>spring-boot-starter-data-mongodb</artifactId>
  25.       </dependency>
  26.       <dependency>
  27.          <groupId>org.springframework.boot</groupId>
  28.          <artifactId>spring-boot-starter-web</artifactId>
  29.       </dependency>
  30.  
  31.       <dependency>
  32.          <groupId>org.springframework.boot</groupId>
  33.          <artifactId>spring-boot-starter-test</artifactId>
  34.          <scope>test</scope>
  35.       </dependency>
  36.       <dependency>
  37.          <groupId>org.projectlombok</groupId>
  38.          <artifactId>lombok</artifactId>
  39.          <version>1.18.12</version>
  40.       </dependency>
  41.  
  42.  
  43.    </dependencies>
  44.  
  45.    <build>
  46.       <plugins>
  47.          <plugin>
  48.             <groupId>org.springframework.boot</groupId>
  49.             <artifactId>spring-boot-maven-plugin</artifactId>
  50.          </plugin>
  51.       </plugins>
  52.    </build>
  53.  
  54. </project>

2. 添加配置类

比如连接上述的 mongos, 使用MongoTemplate 进行数据库操作

  1. package com.example.demo.config;
  2.  
  3. import com.mongodb.client.MongoClient;
  4. import com.mongodb.client.MongoClients;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.data.mongodb.core.MongoTemplate;
  8.  
  9. @Configuration
  10. public class AppConfig {
  11.  
  12.     public @Bean
  13.     MongoClient mongoClient() {
  14.         return MongoClients.create("mongodb://111.229.189.98:4000");
  15.     }
  16.  
  17.     public @Bean
  18.     MongoTemplate mongoTemplate() {
  19.         return new MongoTemplate(mongoClient(), "productdb");
  20.     }
  21. }

3. 测试类

  1. package com.example.demo;
  2.  
  3. public class Person {
  4.  
  5.   private String id;
  6.   private String name;
  7.   private int age;
  8.  
  9.   public Person(String name, int age) {
  10.     this.name = name;
  11.     this.age = age;
  12.   }
  13.  
  14.   public String getId() {
  15.     return id;
  16.   }
  17.   public String getName() {
  18.     return name;
  19.   }
  20.   public int getAge() {
  21.     return age;
  22.   }
  23.  
  24.   @Override
  25.   public String toString() {
  26.     return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
  27.   }
  28.  
  29. }
  30.  
  31. package com.example.demo;
  32.  
  33. import lombok.extern.slf4j.Slf4j;
  34. import org.springframework.beans.factory.annotation.Autowired;
  35. import org.springframework.boot.ApplicationArguments;
  36. import org.springframework.boot.ApplicationRunner;
  37. import org.springframework.data.mongodb.core.MongoTemplate;
  38. import org.springframework.stereotype.Component;
  39.  
  40. import java.util.List;
  41.  
  42. import static org.springframework.data.mongodb.core.query.Criteria.where;
  43. import static org.springframework.data.mongodb.core.query.Query.query;
  44. import static org.springframework.data.mongodb.core.query.Update.update;
  45.  
  46. @Component
  47. @Slf4j
  48. public class ApplicationRunnerTest implements ApplicationRunner{
  49.  
  50.     @Autowired
  51.     private MongoTemplate mongoOps;
  52.  
  53.     @Override
  54.     public void run(ApplicationArguments applicationArguments) throws Exception {
  55.  
  56.         Person p = new Person("Joe", 34);
  57.  
  58.           // 插入文档
  59.         mongoOps.insert(p);
  60.         log.info("Insert: " + p);
  61.  
  62.         // 查询文档
  63.         p = mongoOps.findById(p.getId(), Person.class);
  64.         log.info("Found: " + p);
  65.  
  66.         // 更新文档
  67.         mongoOps.updateFirst(query(where("name").is("Joe")), update("age", 35), Person.class);
  68.         p = mongoOps.findOne(query(where("name").is("Joe")), Person.class);
  69.         log.info("Updated: " + p);
  70.  
  71.         // 删除文档
  72.         mongoOps.remove(p);
  73.  
  74.         // Check that deletion worked
  75.         List<Person> people =  mongoOps.findAll(Person.class);
  76.         log.info("Number of people = : " + people.size());
  77.         mongoOps.dropCollection(Person.class);
  78.     }
  79. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/533643
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号