MongoDB快速精通2

曾经终败给现在 2024-02-29 03:30 54阅读 0赞

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

## 一、副本集-Replica Sets ##

### 1.简介 ###

MongoDB中的副本集（Replica Set）是一组维护相同数据集的mongod进程服务。 副本集可提供冗余和高可用性，是所有生产部署的基础。副本集类似于有自动故障恢复功能的主从集群。是多台机器进行同一数据的异步同步，从而使多台机器拥有同一数据的多个副本，并且当主库挂掉时在不需要用户干预的情况下自动切换其他备份服务器做主库。而且还可以利用副本服务器做只读服务器，实现读写分离，提高负载。

*  冗余和数据可用性
    
     *  复制提供了冗余并增加了数据可用性。对于不同数据库服务器上的多个数据副本，复制为防止单台数据库服务器故障提供了一定程度的容错能力。
 *  MongoDB的复制
    
     *  副本集是一组维护相同数据集合的mongod实例。副本集包含多个数据承载节点和一个可选的仲裁节点。在数据承载节点中，有且仅有一个成员为主节点，其他节点为从节点。

### 2.副本集成员 ###

MongoDB 的副本集是一组提供冗余和高可用性的mongod进程。一个副本集成员有：

*  主节点
 *  从节点

![在这里插入图片描述][19d1e8145ef64129b5257491dea862e9.png]

### 3.副本集的类型和角色 ###

副本集有两种类型三种角色：

*  两种类型：
    
     *  主节点（Primary）类型：数据操作的主要连接点，可读写。
     *  次要（辅助、从）节点（Secondaries）类型：数据冗余备份节点，可以读或选举。
 *  三种角色：
    
     *  主节点（Primary）：主要接收所有写操作。
     *  副本成员（Replicate）：从主节点通过复制操作以维护相同的数据集，即备份数据，不可写操作，但可以读操作（但需要配置）。是默认的一种从节点类型。
     *  仲裁者（Arbiter）：不保留任何数据的副本，只具有投票选举作用。当然也可以将仲裁服务器维护为副本集的一部分，即副本成员同时也可以是仲裁者。也是一种从节点类型。
        
        ![image-20230126161539472][]

### 4.副本集的搭建 ###

需要准备三个MongoDB实例

*  主节点：27017
 *  副本节点：27018
 *  仲裁节点：27019

#### 4.1创建主节点 ####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/replica_sets/27017/log
        mkdir -p /usr/local/mongodb/replica_sets/27017/data/db
 *  新建配置文件mongod.conf
    
        vim /usr/local/mongodb/replica_sets/27017/mongod.conf
    
        systemLog:
          #MongoDB发送所有日志输出的目标指定为文件
          #The path of the log file to which mongod or mongos should send all diagnostic logging information
          destination: file
          #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
          path: "/usr/local/mongodb/replica_sets/27017/log/mongod.log"
          #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
          logAppend: true
        storage:
          #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
          ##The directory where the mongod instance stores its data.Default Value is "/data/db".
          dbPath: "/usr/local/mongodb/replica_sets/27017/data/db"
          journal:
            #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
            enabled: true
        processManagement:
          #启用在后台运行mongos或mongod进程的守护进程模式。
          fork: true
          #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
          pidFilePath: "/usr/local/mongodb/replica_sets/27017/log/mongod.pid"
        net:
          #服务实例绑定的IP，默认是localhost
          bindIp: 192.168.222.135
          #bindIp
          #绑定的端口，默认是27017
          port: 27017
        replication:
          #副本集的名称
          replSetName: mongo_rs
 *  启动节点服务
    
        /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/replica_sets/27017/mongod.conf

#### 4.2创建副本节点 ####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/replica_sets/27018/log
        mkdir -p /usr/local/mongodb/replica_sets/27018/data/db
 *  新建配置文件mongod.conf
    
        vim /usr/local/mongodb/replica_sets/27018/mongod.conf
    
        systemLog:
          #MongoDB发送所有日志输出的目标指定为文件
          #The path of the log file to which mongod or mongos should send all diagnostic logging information
          destination: file
          #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
          path: "/usr/local/mongodb/replica_sets/27018/log/mongod.log"
          #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
          logAppend: true
        storage:
          #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
          ##The directory where the mongod instance stores its data.Default Value is "/data/db".
          dbPath: "/usr/local/mongodb/replica_sets/27018/data/db"
          journal:
            #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
            enabled: true
        processManagement:
          #启用在后台运行mongos或mongod进程的守护进程模式。
          fork: true
          #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
          pidFilePath: "/usr/local/mongodb/replica_sets/27018/log/mongod.pid"
        net:
          #服务实例绑定的IP，默认是localhost
          bindIp: 192.168.222.135
          #bindIp
          #绑定的端口，默认是27017
          port: 27018
        replication:
          #副本集的名称
          replSetName: mongo_rs
 *  启动服务
    
        /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/replica_sets/27018/mongod.conf

#### 4.3创建仲裁节点 ####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/replica_sets/27019/log
        mkdir -p /usr/local/mongodb/replica_sets/27019/data/db
 *  新建配置文件mongod.conf
    
        vim /usr/local/mongodb/replica_sets/27019/mongod.conf
    
        systemLog:
          #MongoDB发送所有日志输出的目标指定为文件
          #The path of the log file to which mongod or mongos should send all diagnostic logging information
          destination: file
          #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
          path: "/usr/local/mongodb/replica_sets/27019/log/mongod.log"
          #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
          logAppend: true
        storage:
          #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
          ##The directory where the mongod instance stores its data.Default Value is "/data/db".
          dbPath: "/usr/local/mongodb/replica_sets/27019/data/db"
          journal:
            #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
            enabled: true
        processManagement:
          #启用在后台运行mongos或mongod进程的守护进程模式。
          fork: true
          #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
          pidFilePath: "/usr/local/mongodb/replica_sets/27019/log/mongod.pid"
        net:
          #服务实例绑定的IP，默认是localhost
          bindIp: 192.168.222.135
          #bindIp
          #绑定的端口，默认是27017
          port: 27019
        replication:
          #副本集的名称
          replSetName: mongo_rs
 *  启动服务
    
        /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/replica_sets/27019/mongod.conf

#### 4.4初始化主节点和副本集 ####

*  先用mongosh连接上主节点
    
        /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=27017
    
     *  连接上去之后，需要先做副本集初始化才行，不初始化很多命令都不能用
        
            #使用默认的初始化方式即可，如果需要定制化初始化，参考官方文档
            rs.initiate()
        
        ![image-20230126164514771][]

#### 4.5查看副本集的配置内容 ####

*  查看副本集配置内容
    
        #如果没有configuration，不传用默认的即可
        rs.conf(configuration)
        rs.conf()
    
        mongo_rs [direct: primary] test> rs.conf()
        {
              
          _id: 'mongo_rs',
          version: 1,
          term: 1,
          members: [
            {
              
              _id: 0,
              host: '192.168.222.135:27017',
              arbiterOnly: false,
              buildIndexes: true,
              hidden: false,
              priority: 1,
              tags: {
              },
              secondaryDelaySecs: Long("0"),
              votes: 1
            }
          ],
          protocolVersion: Long("1"),
          writeConcernMajorityJournalDefault: true,
          settings: {
              
            chainingAllowed: true,
            heartbeatIntervalMillis: 2000,
            heartbeatTimeoutSecs: 10,
            electionTimeoutMillis: 10000,
            catchUpTimeoutMillis: -1,
            catchUpTakeoverDelayMillis: 30000,
            getLastErrorModes: {
              },
            getLastErrorDefaults: {
               w: 1, wtimeout: 0 },
            replicaSetId: ObjectId("63d1f53f40e8619ef4fbbdf6")
          }
        }
        mongo_rs [direct: primary] test>
    
     *  配置说明
        
         *  \_id: ‘mongo\_rs’ ：副本集的配置数据存储的主键值，默认就是副本集的名字
         *  members ：副本集成员数组，此时只有一个： host: ‘192.168.222.135:27017’
         *  arbiterOnly: false。该成员不是仲裁节点
         *  priority: 1。优先级（权重值）
         *  settings：副本集的参数配置。
     *  rs.conf() 副本集配置的查看命令，本质上是查看system.replset表中的数据
        
            mongo_rs [direct: primary] test> use local
            switched to db local
            mongo_rs [direct: primary] local> show collections
            oplog.rs
            replset.election
            replset.initialSyncId
            replset.minvalid
            replset.oplogTruncateAfterPoint
            startup_log
            system.replset
            system.rollback.id
            system.tenantMigration.oplogView  [view]
            system.views
            mongo_rs [direct: primary] local> db.system.replset.find()
            [
              {
                    
                _id: 'mongo_rs',
                version: 1,
                term: 1,
                members: [
                  {
                    
                    _id: 0,
                    host: '192.168.222.135:27017',
                    arbiterOnly: false,
                    buildIndexes: true,
                    hidden: false,
                    priority: 1,
                    tags: {
                    },
                    secondaryDelaySecs: Long("0"),
                    votes: 1
                  }
                ],
                protocolVersion: Long("1"),
                writeConcernMajorityJournalDefault: true,
                settings: {
                    
                  chainingAllowed: true,
                  heartbeatIntervalMillis: 2000,
                  heartbeatTimeoutSecs: 10,
                  electionTimeoutMillis: 10000,
                  catchUpTimeoutMillis: -1,
                  catchUpTakeoverDelayMillis: 30000,
                  getLastErrorModes: {
                    },
                  getLastErrorDefaults: {
                     w: 1, wtimeout: 0 },
                  replicaSetId: ObjectId("63d1f53f40e8619ef4fbbdf6")
                }
              }
            ]

#### 4.6查看副本集状态 ####

*  查看副本集的状态:从副本集的其他成员发送的心跳包中获得的数据反映副本集的状态。
    
        rs.status()
    
        mongo_rs [direct: primary] local> rs.status()
        {
              
          set: 'mongo_rs',
          date: ISODate("2023-01-26T03:43:36.824Z"),
          myState: 1,
          term: Long("1"),
          syncSourceHost: '',
          syncSourceId: -1,
          heartbeatIntervalMillis: Long("2000"),
          majorityVoteCount: 1,
          writeMajorityCount: 1,
          votingMembersCount: 1,
          writableVotingMembersCount: 1,
          optimes: {
              
            lastCommittedOpTime: {
               ts: Timestamp({
               t: 1674704611, i: 1 }), t: Long("1") },
            lastCommittedWallTime: ISODate("2023-01-26T03:43:31.607Z"),
            readConcernMajorityOpTime: {
               ts: Timestamp({
               t: 1674704611, i: 1 }), t: Long("1") },
            appliedOpTime: {
               ts: Timestamp({
               t: 1674704611, i: 1 }), t: Long("1") },
            durableOpTime: {
               ts: Timestamp({
               t: 1674704611, i: 1 }), t: Long("1") },
            lastAppliedWallTime: ISODate("2023-01-26T03:43:31.607Z"),
            lastDurableWallTime: ISODate("2023-01-26T03:43:31.607Z")
          },
          lastStableRecoveryTimestamp: Timestamp({
               t: 1674704601, i: 1 }),
          electionCandidateMetrics: {
              
            lastElectionReason: 'electionTimeout',
            lastElectionDate: ISODate("2023-01-26T03:36:31.446Z"),
            electionTerm: Long("1"),
            lastCommittedOpTimeAtElection: {
               ts: Timestamp({
               t: 1674704191, i: 1 }), t: Long("-1") },
            lastSeenOpTimeAtElection: {
               ts: Timestamp({
               t: 1674704191, i: 1 }), t: Long("-1") },
            numVotesNeeded: 1,
            priorityAtElection: 1,
            electionTimeoutMillis: Long("10000"),
            newTermStartDate: ISODate("2023-01-26T03:36:31.466Z"),
            wMajorityWriteAvailabilityDate: ISODate("2023-01-26T03:36:31.483Z")
          },
          members: [
            {
              
              _id: 0,
              name: '192.168.222.135:27017',
              health: 1,
              state: 1,
              stateStr: 'PRIMARY',
              uptime: 659,
              optime: {
               ts: Timestamp({
               t: 1674704611, i: 1 }), t: Long("1") },
              optimeDate: ISODate("2023-01-26T03:43:31.000Z"),
              lastAppliedWallTime: ISODate("2023-01-26T03:43:31.607Z"),
              lastDurableWallTime: ISODate("2023-01-26T03:43:31.607Z"),
              syncSourceHost: '',
              syncSourceId: -1,
              infoMessage: '',
              electionTime: Timestamp({
               t: 1674704191, i: 2 }),
              electionDate: ISODate("2023-01-26T03:36:31.000Z"),
              configVersion: 1,
              configTerm: 1,
              self: true,
              lastHeartbeatMessage: ''
            }
          ],
          ok: 1,
          '$clusterTime': {
              
            clusterTime: Timestamp({
               t: 1674704611, i: 1 }),
            signature: {
              
              hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
              keyId: Long("0")
            }
          },
          operationTime: Timestamp({
               t: 1674704611, i: 1 })
        }
        mongo_rs [direct: primary] local>
    
     *  说明：
        
         *  set: ‘mongo\_rs’：副本集的名字
         *  myState: 1：状态正常
         *  members: 副本集成员数组
            
             *  name: ‘192.168.222.135:27017’ 成员只有一个
             *  health: 1。健康节点
             *  stateStr: ‘PRIMARY’ 角色

#### 4.7添加副本从节点 ####

*  从主节点添加从节点，将其他成员加入到副本集
    
        rs.add(host, arbiterOnly)
 *  将27018添加为从节点
    
        rs.add("192.168.222.135:27018")
    
        mongo_rs [direct: other] test> rs.add("192.168.222.135:27018")
        {
              
          ok: 1,
          '$clusterTime': {
              
            clusterTime: Timestamp({
               t: 1674705770, i: 1 }),
            signature: {
              
              hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
              keyId: Long("0")
            }
          },
          operationTime: Timestamp({
               t: 1674705770, i: 1 })
        }
        mongo_rs [direct: primary] test>
 *  查看副本集状态
    
        rs.status()
    
        mongo_rs [direct: primary] test> rs.status()
        {
              
          set: 'mongo_rs',
          date: ISODate("2023-01-26T04:03:52.625Z"),
          myState: 1,
          term: Long("1"),
          syncSourceHost: '',
          syncSourceId: -1,
          heartbeatIntervalMillis: Long("2000"),
          majorityVoteCount: 2,
          writeMajorityCount: 2,
          votingMembersCount: 2,
          writableVotingMembersCount: 2,
          optimes: {
              
            lastCommittedOpTime: {
               ts: Timestamp({
               t: 1674705827, i: 1 }), t: Long("1") },
            lastCommittedWallTime: ISODate("2023-01-26T04:03:47.788Z"),
            readConcernMajorityOpTime: {
               ts: Timestamp({
               t: 1674705827, i: 1 }), t: Long("1") },
            appliedOpTime: {
               ts: Timestamp({
               t: 1674705827, i: 1 }), t: Long("1") },
            durableOpTime: {
               ts: Timestamp({
               t: 1674705827, i: 1 }), t: Long("1") },
            lastAppliedWallTime: ISODate("2023-01-26T04:03:47.788Z"),
            lastDurableWallTime: ISODate("2023-01-26T04:03:47.788Z")
          },
          lastStableRecoveryTimestamp: Timestamp({
               t: 1674705807, i: 1 }),
          electionCandidateMetrics: {
              
            lastElectionReason: 'electionTimeout',
            lastElectionDate: ISODate("2023-01-26T04:02:37.742Z"),
            electionTerm: Long("1"),
            lastCommittedOpTimeAtElection: {
               ts: Timestamp({
               t: 1674705757, i: 1 }), t: Long("-1") },
            lastSeenOpTimeAtElection: {
               ts: Timestamp({
               t: 1674705757, i: 1 }), t: Long("-1") },
            numVotesNeeded: 1,
            priorityAtElection: 1,
            electionTimeoutMillis: Long("10000"),
            newTermStartDate: ISODate("2023-01-26T04:02:37.766Z"),
            wMajorityWriteAvailabilityDate: ISODate("2023-01-26T04:02:37.778Z")
          },
          members: [
            {
              
              _id: 0,
              name: '192.168.222.135:27017',
              health: 1,
              state: 1,
              stateStr: 'PRIMARY',
              uptime: 112,
              optime: {
               ts: Timestamp({
               t: 1674705827, i: 1 }), t: Long("1") },
              optimeDate: ISODate("2023-01-26T04:03:47.000Z"),
              lastAppliedWallTime: ISODate("2023-01-26T04:03:47.788Z"),
              lastDurableWallTime: ISODate("2023-01-26T04:03:47.788Z"),
              syncSourceHost: '',
              syncSourceId: -1,
              infoMessage: '',
              electionTime: Timestamp({
               t: 1674705757, i: 2 }),
              electionDate: ISODate("2023-01-26T04:02:37.000Z"),
              configVersion: 3,
              configTerm: 1,
              self: true,
              lastHeartbeatMessage: ''
            },
            {
              
              _id: 1,
              name: '192.168.222.135:27018',
              health: 1,
              state: 2,
              stateStr: 'SECONDARY',
              uptime: 61,
              optime: {
               ts: Timestamp({
               t: 1674705827, i: 1 }), t: Long("1") },
              optimeDurable: {
               ts: Timestamp({
               t: 1674705827, i: 1 }), t: Long("1") },
              optimeDate: ISODate("2023-01-26T04:03:47.000Z"),
              optimeDurableDate: ISODate("2023-01-26T04:03:47.000Z"),
              lastAppliedWallTime: ISODate("2023-01-26T04:03:47.788Z"),
              lastDurableWallTime: ISODate("2023-01-26T04:03:47.788Z"),
              lastHeartbeat: ISODate("2023-01-26T04:03:50.979Z"),
              lastHeartbeatRecv: ISODate("2023-01-26T04:03:51.473Z"),
              pingMs: Long("0"),
              lastHeartbeatMessage: '',
              syncSourceHost: '192.168.222.135:27017',
              syncSourceId: 0,
              infoMessage: '',
              configVersion: 3,
              configTerm: 1
            }
          ],
          ok: 1,
          '$clusterTime': {
              
            clusterTime: Timestamp({
               t: 1674705827, i: 1 }),
            signature: {
              
              hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
              keyId: Long("0")
            }
          },
          operationTime: Timestamp({
               t: 1674705827, i: 1 })
        }
    
     *  从信息中可以看到，第二个节点信息角色为stateStr: ‘SECONDARY’

#### 4.8添加仲裁节点 ####

*  从主节点添加仲裁节点，将其他成员加入到副本集
    
        rs.addArb(host)
 *  手动设置写关注
    
        db.adminCommand({
               "setDefaultRWConcern": 1, "defaultWriteConcern": {
               "w": "majority" } })
    
        #这是5版本以后需要做的操作，如果你还是老版本，可以不用这步，具体参见官方默认写关注
    
    ![image-20230126175603616][]
 *  将27019添加为仲裁节点
    
        rs.addArb("192.168.222.135:27019")
    
        mongo_rs [direct: primary] test> rs.addArb("192.168.222.135:27019")
        {
              
          ok: 1,
          '$clusterTime': {
              
            clusterTime: Timestamp({
               t: 1674706211, i: 1 }),
            signature: {
              
              hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
              keyId: Long("0")
            }
          },
          operationTime: Timestamp({
               t: 1674706211, i: 1 })
        }
 *  查看副本集状态
    
        rs.status()
    
        mongo_rs [direct: primary] test> rs.status()
        {
              
          set: 'mongo_rs',
          date: ISODate("2023-01-26T04:25:47.503Z"),
          myState: 2,
          term: Long("2"),
          syncSourceHost: '192.168.222.135:27018',
          syncSourceId: 1,
          heartbeatIntervalMillis: Long("2000"),
          majorityVoteCount: 2,
          writeMajorityCount: 2,
          votingMembersCount: 3,
          writableVotingMembersCount: 2,
          optimes: {
              
            lastCommittedOpTime: {
               ts: Timestamp({
               t: 1674707146, i: 1 }), t: Long("2") },
            lastCommittedWallTime: ISODate("2023-01-26T04:25:46.409Z"),
            readConcernMajorityOpTime: {
               ts: Timestamp({
               t: 1674707146, i: 1 }), t: Long("2") },
            appliedOpTime: {
               ts: Timestamp({
               t: 1674707146, i: 1 }), t: Long("2") },
            durableOpTime: {
               ts: Timestamp({
               t: 1674707146, i: 1 }), t: Long("2") },
            lastAppliedWallTime: ISODate("2023-01-26T04:25:46.409Z"),
            lastDurableWallTime: ISODate("2023-01-26T04:25:46.409Z")
          },
          lastStableRecoveryTimestamp: Timestamp({
               t: 1674707136, i: 1 }),
          electionParticipantMetrics: {
              
            votedForCandidate: true,
            electionTerm: Long("2"),
            lastVoteDate: ISODate("2023-01-26T04:25:26.389Z"),
            electionCandidateMemberId: 1,
            voteReason: '',
            lastAppliedOpTimeAtElection: {
               ts: Timestamp({
               t: 1674707116, i: 1 }), t: Long("1") },
            maxAppliedOpTimeInSet: {
               ts: Timestamp({
               t: 1674707116, i: 1 }), t: Long("1") },
            priorityAtElection: 1,
            newTermStartDate: ISODate("2023-01-26T04:25:26.396Z"),
            newTermAppliedDate: ISODate("2023-01-26T04:25:27.346Z")
          },
          members: [
            {
              
              _id: 0,
              name: '192.168.222.135:27017',
              health: 1,
              state: 2,
              stateStr: 'SECONDARY',
              uptime: 1427,
              optime: {
               ts: Timestamp({
               t: 1674707146, i: 1 }), t: Long("2") },
              optimeDate: ISODate("2023-01-26T04:25:46.000Z"),
              lastAppliedWallTime: ISODate("2023-01-26T04:25:46.409Z"),
              lastDurableWallTime: ISODate("2023-01-26T04:25:46.409Z"),
              syncSourceHost: '192.168.222.135:27018',
              syncSourceId: 1,
              infoMessage: '',
              configVersion: 4,
              configTerm: 2,
              self: true,
              lastHeartbeatMessage: ''
            },
            {
              
              _id: 1,
              name: '192.168.222.135:27018',
              health: 1,
              state: 1,
              stateStr: 'PRIMARY',
              uptime: 31,
              optime: {
               ts: Timestamp({
               t: 1674707146, i: 1 }), t: Long("2") },
              optimeDurable: {
               ts: Timestamp({
               t: 1674707146, i: 1 }), t: Long("2") },
              optimeDate: ISODate("2023-01-26T04:25:46.000Z"),
              optimeDurableDate: ISODate("2023-01-26T04:25:46.000Z"),
              lastAppliedWallTime: ISODate("2023-01-26T04:25:46.409Z"),
              lastDurableWallTime: ISODate("2023-01-26T04:25:46.409Z"),
              lastHeartbeat: ISODate("2023-01-26T04:25:47.441Z"),
              lastHeartbeatRecv: ISODate("2023-01-26T04:25:46.436Z"),
              pingMs: Long("0"),
              lastHeartbeatMessage: '',
              syncSourceHost: '',
              syncSourceId: -1,
              infoMessage: '',
              electionTime: Timestamp({
               t: 1674707126, i: 1 }),
              electionDate: ISODate("2023-01-26T04:25:26.000Z"),
              configVersion: 4,
              configTerm: 2
            },
            {
              
              _id: 2,
              name: '192.168.222.135:27019',
              health: 1,
              state: 7,
              stateStr: 'ARBITER',
              uptime: 31,
              lastHeartbeat: ISODate("2023-01-26T04:25:47.440Z"),
              lastHeartbeatRecv: ISODate("2023-01-26T04:25:46.437Z"),
              pingMs: Long("0"),
              lastHeartbeatMessage: '',
              syncSourceHost: '',
              syncSourceId: -1,
              infoMessage: '',
              configVersion: 4,
              configTerm: 2
            }
          ],
          ok: 1,
          '$clusterTime': {
              
            clusterTime: Timestamp({
               t: 1674707146, i: 1 }),
            signature: {
              
              hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
              keyId: Long("0")
            }
          },
          operationTime: Timestamp({
               t: 1674707146, i: 1 })
        }
        mongo_rs [direct: secondary] test>
    
     *  从信息中可以看到，第三个节点信息角色为stateStr: ‘ARBITER’

#### 4.9副本集的数据读写操作 ####

*  登录主节点
    
     *  执行写操作
        
         *  登录进MongoDB服务
            
                /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=27018
         *  创建sytest数据库
            
                mongo_rs [direct: secondary] test> use sytest
                switched to db sytest
         *  插入数据
            
                db.products.insertOne( {
                           _id: 10, "item" : "packing peanuts", "qty" : 200 } );
            
                mongo_rs [direct: primary] sytest> db.products.insertOne( {
                           _id: 10, "item" : "packing peanuts", "qty" : 200 } );
                {
                           acknowledged: true, insertedId: 10 }
                mongo_rs [direct: primary] sytest>
     *  执行读操作
        
         *  查询数据
            
                db.products.find()
            
                mongo_rs [direct: primary] sytest> db.products.find()
                [ {
                           _id: 10, item: 'packing peanuts', qty: 200 } ]
 *  登录从节点
    
     *  登录进从节点
        
            /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=27017
     *  执行读写操作
        
         *  切换数据库
            
                use sytest
         *  执行写操作
            
                db.products.insertOne( {
                           _id: 11, "item" : "packing peanuts", "qty" : 200 } );
            
                mongo_rs [direct: secondary] sytest> db.products.insertOne( {
                           _id: 11, "item" : "packing peanuts", "qty" : 200 } );
                MongoServerError: not primary
                mongo_rs [direct: secondary] sytest>
            
             *  **从执行结果中看见，不能执行写操作**
         *  读取集合数据
            
                db.products.find()
            
                mongo_rs [direct: secondary] sytest> db.products.find()
                MongoServerError: not primary and secondaryOk=false - consider using db.getMongo().setReadPref() or readPreference in the connection string
            
             *  从执行结果发现，不能读取数据，
             *  当前从节点只是一个备份，不是奴隶节点，无法执行写、读取操作
     *  修改从节点可读权限
        
         *  设置读操作权限
            
                #该命令是 db.getMongo().setSlaveOk() 的简化命令
                #旧版本 rs.slaveOk() 或 rs.slaveOk(true)
                #新版本是 db.getMongo().secondaryOk() 的简化命令
                rs.secondaryOk()
            
                #再次执行查询OK，但是写操作还是报错，记住需要切换到sytest库
            
                mongo_rs [direct: secondary] sytest> db.products.find()
                [ {
                           _id: 10, item: 'packing peanuts', qty: 200 } ]
                mongo_rs [direct: secondary] sytest> db.products.insertOne( {
                           _id: 11, "item" : "packing peanuts", "qty" : 200 } );
                MongoServerError: not primary
 *  登录仲裁节点
    
     *  登录仲裁节点
        
            /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=27019
     *  查看拥有的数据库
        
            mongo_rs [direct: arbiter] test> show dbs
            MongoServerError: node is not in primary or recovering state
     *  从中可以看见，仲裁节点不保存任何业务数据。不过仲裁节点存放了副本集配置数据。
        
            mongo_rs [direct: arbiter] test> use local
            switched to db local
            mongo_rs [direct: arbiter] local> show collections
            replset.election
            replset.minvalid
            replset.oplogTruncateAfterPoint
            startup_log
            system.replset
            system.rollback.id
            system.tenantMigration.oplogView  [view]
            system.views

### 5.主节点的选举 ###

#### 5.1选举触发条件 ####

MongoDB在副本集中，会自动进行主节点的选举，主节点选举的触发条件：

*  主节点故障
 *  主节点网络不可达（默认心跳信息为10秒）
 *  人工干预（rs.stepDown(600)）

#### 5.2选举规则 ####

*  票数最高，且获得了“大多数”成员的投票支持的节点获胜。
    
     *  “大多数”：假设副本集内投票成员数量为N，则大多数为 N/2 + 1。例如：3个投票成员，则大多数的值是2。
     *  当副本集内存活成员数量不足大多数时，整个复制集将无法选举出Primary，复制集将无法提供写服务，处于只读状态。
 *  若票数相同，且都获得了“大多数”成员的投票支持的，数据新的节点获胜。
    
     *  数据的新旧是通过操作日志oplog来对比的。
 *  优先级（priority）参数对获取票数有很大影响：
    
     *  可以通过设置优先级（priority）来设置额外票数
        
         *  优先级即权重，取值为0-1000，相当于可额外增加0-1000的票数，优先级的值越大，就越可能获得多数成员的投票（votes）数。
         *  指定较高的值可使成员更有资格成为主节点。
     *  优先级默认值：1
 *  查看当前节点信息,可以看到各节点优先级信息
    
        rs.conf()
    
     *  注意：从信息中可以看见，主节点和从节点优先级都等于1，而仲裁节点优先级等于0，所以仲裁节点不具备选举权，不过具备投票权。

#### 5.3修改优先级 ####

在实际开发中会存在一种场景，公司为了节约成本，提供的机器中，某一台性能很好，但是其它机器是凑数的，就是作为一种备份的，此时可以通过设置性能较好的机器的优先级高一点。

*  修改优先级(注意：此操作必须在主节点操作)
    
     *  获取配置数据
        
            cfg=rs.conf()
     *  修改从节点的优先级
        
            cfg.members[0].priority=2
     *  重新加载配置
        
            rs.reconfig(cfg)

### 6.MongoDBCompass 连接副本集 ###

*  开放端口
    
        firewall-cmd --zone=public --add-port=27018/tcp --permanent
        firewall-cmd --zone=public --add-port=27019/tcp --permanent
        firewall-cmd --reload
 *  工具连接
    
    ![image-20230126231809406][]

### 7.SpringBoot连接副本集 ###

*  配置
    
        mongodb://192.168.222.128:27017,192.168.222.128:27018,192.168.222.128:27019/articleData?replicaSet=mongo_rs
 *  **注意：一定要保证MongoDB的服务版本和SpirngDataMongoDb的兼容，如果不兼容会出现我们讲解过程中的问题。**

## 二、分片集群-Sharded Cluster ##

### 1.简介 ###

现在实际开发中常用来解决系统增长的方法有两种：

*  垂直扩展：
    
     *  垂直扩展意味着增加单个服务器的性能，例如使用更强大的CPU，添加更多RAM或增加存储空间量。可用技术的局限性可能会限制单个机器对于给定工作负载而言足够强大。此外，基于云的提供商基于可用的硬件配置具有硬性上限。结果，垂直缩放有实际的最大值。
     *  缺点：硬件设备具有限制。
 *  水平扩展
    
     *  水平扩展意味着将系统数据集划分加载到多个服务器，添加其他服务器以根据需要增加容量。虽然单个机器的总体速度或容量可能不高，但每台机器处理整个工作负载的子集，可能提供比单个高速大容量服务器更高的效率。扩展部署容量只需要根据需要添加额外的服务器，这可能比单个机器的高端硬件的总体成本更低。
     *  缺点：基础架构和部署维护的复杂性增加。

分片（sharding）是一种跨多台机器分布数据的方法， MongoDB使用分片来支持具有非常大的数据集

和高吞吐量操作的部署。通俗易懂的说，分片是指将数据拆分，将其分散存在不同的机器上的过程。

### 2.分片集群成员 ###

MongoDB分片群集包含以下成员：

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

### 3.分片集群分片副本集搭建 ###

所有的内容全部放在sharded\_cluster 目录下面

#### 3.1副本集1 ####

##### a) 配置准备 #####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28018/log
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28018/data/db
        
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28118/log
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28118/data/db
        
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28218/log
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28218/data/db
 *  新建配置文件mongod.conf
    
     *  28018配置文件
        
            vim /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28018/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28018/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28018/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28018/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 28018
            replication:
              #副本集的名称
              replSetName: shardrs1
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: shardsvr
     *  28118配置文件
        
            vim /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28118/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28118/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28118/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28118/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 28118
            replication:
              #副本集的名称
              replSetName: shardrs1
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: shardsvr
     *  28218配置文件
        
            vim /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28218/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28218/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28218/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28218/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 28218
            replication:
              #副本集的名称
              replSetName: shardrs1
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: shardsvr

##### b) 启动服务 #####

*  启动副本集1（主、从、仲裁节点）
    
     *  启动服务
        
         *  28018
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28018/mongod.conf
         *  28118
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28118/mongod.conf
         *  28218
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/shardrs1/myshardrs_28218/mongod.conf
     *  初始化副本集创建主节点
        
         *  使用mongosh 连接上28018节点
            
                /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=28018
         *  初始化副本集
            
                rs.initiate()
            
                test> rs.initiate()
                {
                          
                  info2: 'no configuration specified. Using a default configuration for the set',
                  me: '192.168.222.135:28018',
                  ok: 1
                }
         *  查看副本集状态(参考副本集的搭建)
            
                rs.status()
         *  查看主节点配置
            
                rs.conf()
         *  添加副本节点
            
                rs.add("192.168.222.135:28118")
            
                shardrs1 [direct: primary] test> rs.add("192.168.222.135:28118")
                {
                          
                  ok: 1,
                  '$clusterTime': {
                          
                    clusterTime: Timestamp({
                           t: 1674723566, i: 1 }),
                    signature: {
                          
                      hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
                      keyId: Long("0")
                    }
                  },
                  operationTime: Timestamp({
                           t: 1674723566, i: 1 })
                }
         *  添加仲裁节点
            
                rs.addArb("192.168.222.135:28218")
         *  查看目前副本集的状态
            
                rs.conf()

#### 3.2副本集2 ####

##### a) 配置准备 #####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28318/log
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28318/data/db
        
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28418/log
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28418/data/db
        
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28518/log
        mkdir -p /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28518/data/db
 *  新建配置文件mongod.conf
    
     *  28318配置文件
        
            vim /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28318/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28318/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28318/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28318/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 28318
            replication:
              #副本集的名称
              replSetName: shardrs2
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: shardsvr
     *  28418配置文件
        
            vim /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28418/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28418/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28418/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28418/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 28418
            replication:
              #副本集的名称
              replSetName: shardrs2
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: shardsvr
     *  28518配置文件
        
            vim /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28518/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28518/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28518/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28518/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 28518
            replication:
              #副本集的名称
              replSetName: shardrs2
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: shardsvr

##### b) 启动服务 #####

*  启动副本集1（主、从、仲裁节点）
    
     *  启动服务
        
         *  28318
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28318/mongod.conf
         *  28418
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28418/mongod.conf
         *  28518
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/shardrs2/myshardrs_28518/mongod.conf
     *  初始化副本集创建主节点
        
         *  使用mongosh 连接上28318节点
            
                /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=28318
         *  初始化副本集
            
                rs.initiate()
            
                test> rs.initiate()
                {
                          
                  info2: 'no configuration specified. Using a default configuration for the set',
                  me: '192.168.222.135:28318',
                  ok: 1
                }
         *  查看副本集状态
            
                rs.status()
         *  查看主节点配置
            
                rs.conf()
         *  添加副本节点
            
                rs.add("192.168.222.135:28418")
         *  添加仲裁节点
            
                rs.addArb("192.168.222.135:28518")
         *  查看目前副本集状态
            
                rs.conf()

### 4.分片集群配置副本集搭建 ###

#### 4.1配置副本集 ####

##### a) 配置准备 #####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/sharded_cluster/configrs/configrs_29018/log
        mkdir -p /usr/local/mongodb/sharded_cluster/configrs/configrs_29018/data/db
        
        mkdir -p /usr/local/mongodb/sharded_cluster/configrs/configrs_29118/log
        mkdir -p /usr/local/mongodb/sharded_cluster/configrs/configrs_29118/data/db
        
        mkdir -p /usr/local/mongodb/sharded_cluster/configrs/configrs_29218/log
        mkdir -p /usr/local/mongodb/sharded_cluster/configrs/configrs_29218/data/db
 *  新建配置文件mongod.conf
    
     *  29018配置文件
        
            vim /usr/local/mongodb/sharded_cluster/configrs/configrs_29018/mongod.conf
     *  配置内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29018/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29018/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29018/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 29018
            replication:
              #副本集的名称
              replSetName: configrs
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: configsvr
     *  29118配置文件
        
            vim /usr/local/mongodb/sharded_cluster/configrs/configrs_29118/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29118/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29118/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29118/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 29118
            replication:
              #副本集的名称
              replSetName: configrs
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: configsvr
     *  29218配置文件
        
            vim /usr/local/mongodb/sharded_cluster/configrs/configrs_29218/mongod.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29218/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            storage:
              #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
              ##The directory where the mongod instance stores its data.Default Value is "/data/db".
              dbPath: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29218/data/db"
              journal:
                #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
                enabled: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/configrs/configrs_29218/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 29218
            replication:
              #副本集的名称
              replSetName: configrs
            sharding:
              #分片角色：1：configsvr 配置服务 2：shardsvr 分片服务
              clusterRole: configsvr

##### b) 启动服务 #####

*  一主两副本
    
     *  启动服务
        
         *  29018
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/configrs/configrs_29018/mongod.conf
         *  29118
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/configrs/configrs_29118/mongod.conf
         *  29218
            
                /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/configrs/configrs_29218/mongod.conf
     *  初始化副本集和创建主节点
        
         *  使用mongosh 连接上29018节点
            
                /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=29018
         *  初始化副本集
            
                rs.initiate()
         *  查看副本集状态
            
                rs.status()
         *  查看主节点配置
            
                rs.conf()
         *  添加副本节点29118
            
                rs.add("192.168.222.135:29118")
         *  添加副本节点29228
            
                rs.add("192.168.222.135:29218")
     *  查看副本集配置
        
            rs.conf()
            rs.status()

### 5.分片集群路由节点搭建 ###

#### 5.1配置路由节点1 ####

##### a) 配置准备 #####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/sharded_cluster/router/router_30018/log
 *  新建配置文件mongod.conf
    
     *  30018配置文件
        
            vim /usr/local/mongodb/sharded_cluster/router/router_30018/mongos.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/router/router_30018/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/router/router_30018/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 30018
            sharding:
              configDB: configrs/192.168.222.135:29018,192.168.222.135:29118,192.168.222.135:29218

##### b)启动路由节点 #####

*  启动路由节点
    
     *  30018
        
            /usr/local/mongodb/bin/mongos -f /usr/local/mongodb/sharded_cluster/router/router_30018/mongos.conf
 *  使用mongosh 连接上30018路由节点
    
        /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=30018

#### 5.2配置路由节点2 ####

##### a) 配置准备 #####

*  建立存放数据和日志目录文件
    
        mkdir -p /usr/local/mongodb/sharded_cluster/router/router_30118/log
 *  新建配置文件mongod.conf
    
     *  30118配置文件
        
            vim /usr/local/mongodb/sharded_cluster/router/router_30118/mongos.conf
     *  配置文件内容
        
            systemLog:
              #MongoDB发送所有日志输出的目标指定为文件
              #The path of the log file to which mongod or mongos should send all diagnostic logging information
              destination: file
              #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
              path: "/usr/local/mongodb/sharded_cluster/router/router_30118/log/mongod.log"
              #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
              logAppend: true
            processManagement:
              #启用在后台运行mongos或mongod进程的守护进程模式。
              fork: true
              #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
              pidFilePath: "/usr/local/mongodb/sharded_cluster/router/router_30118/log/mongod.pid"
            net:
              #服务实例绑定的IP，默认是localhost
              bindIp: 192.168.222.135
              #bindIp
              #绑定的端口，默认是27017
              port: 30118
            sharding:
              configDB: configrs/192.168.222.135:29018,192.168.222.135:29118,192.168.222.135:29218

##### b)启动路由节点 #####

*  启动路由节点
    
     *  30118
        
            /usr/local/mongodb/bin/mongos -f /usr/local/mongodb/sharded_cluster/router/router_30118/mongos.conf
 *  使用mongosh 连接上30118路由节点
    
        /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=30118

### 5.写入存在问题 ###

#### 5.1写入数据存在问题 ####

*  新建数据库testSharded
    
        use testSharded
 *  插入数据
    
        db.sharded.insert({
              test:"true"})
 *  **发现不能插入数据**：因为通过路由节点操作，现在只是连接了配置节点，还没有连接分片数据节点，所以无法写入业务数据
    
        [direct: mongos] test> use testSharded
        switched to db testSharded
        [direct: mongos] testSharded>  db.sharded.insert({
              test:"true"})
        DeprecationWarning: Collection.insert() is deprecated. Use insertOne, insertMany, or bulkWrite.
        Uncaught:
        MongoBulkWriteError: Database testSharded could not be created :: caused by :: No shards found
        Result: BulkWriteResult {
              
          result: {
              
            ok: 1,
            writeErrors: [],
            writeConcernErrors: [],
            insertedIds: [ {
               index: 0, _id: ObjectId("63d263973a24874064d203b5") } ],
            nInserted: 0,
            nUpserted: 0,
            nMatched: 0,
            nModified: 0,
            nRemoved: 0,
            upserted: []
          }
        }

#### 5.2配置分片信息 ####

*  添加分片语法
    
        sh.addShard("IP:Port")
    
     *  添加分片副本集1
        
            sh.addShard("shardrs1/192.168.222.135:28018,192.168.222.135:28118,192.168.222.135:28218")
     *  添加分片副本集2
        
            sh.addShard("shardrs2/192.168.222.135:28318,192.168.222.135:28418,192.168.222.135:28518")
     *  添加时候提示需要设置写关注
        
            db.adminCommand({
                    
              "setDefaultRWConcern" : 1,
              "defaultWriteConcern" : {
                    
                "w" : 2
              }
            })
 *  查看分片状态
    
        sh.status()
    
        [direct: mongos] testSharded> sh.status()
        shardingVersion
        {
              
          _id: 1,
          minCompatibleVersion: 5,
          currentVersion: 6,
          clusterId: ObjectId("63d2540bba514a6062cceaee")
        }
        ---
        shards
        [
          {
              
            _id: 'shardrs1',
            host: 'shardrs1/192.168.222.135:28018,192.168.222.135:28118',
            state: 1,
            topologyTime: Timestamp({
               t: 1674735335, i: 3 })
          },
          {
              
            _id: 'shardrs2',
            host: 'shardrs2/192.168.222.135:28318,192.168.222.135:28418',
            state: 1,
            topologyTime: Timestamp({
               t: 1674735300, i: 4 })
          }
        ]
        ---
        active mongoses
        [ {
               '6.0.4': 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
        [
          {
              
            database: {
               _id: 'config', primary: 'config', partitioned: true },
            collections: {
              }
          }
        ]

### 6.开启分片功能 ###

#### 6.1添加数据库分片 ####

*  配置数据库分片
    
     *  语法
        
            sh.enableSharding("库名")
     *  给sytest添加分片
        
            sh.enableSharding("sytest")
        
            [direct: mongos] testSharded> sh.enableSharding("sytest")
            {
                    
              ok: 1,
              '$clusterTime': {
                    
                clusterTime: Timestamp({
                     t: 1674735596, i: 4 }),
                signature: {
                    
                  hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
                  keyId: Long("0")
                }
              },
              operationTime: Timestamp({
                     t: 1674735596, i: 2 })
            }
     *  查看分片状态
        
            sh.status()
        
            [direct: mongos] testSharded> sh.status()
            shardingVersion
            {
                    
              _id: 1,
              minCompatibleVersion: 5,
              currentVersion: 6,
              clusterId: ObjectId("63d2540bba514a6062cceaee")
            }
            ---
            shards
            [
              {
                    
                _id: 'shardrs1',
                host: 'shardrs1/192.168.222.135:28018,192.168.222.135:28118',
                state: 1,
                topologyTime: Timestamp({
                     t: 1674735335, i: 3 })
              },
              {
                    
                _id: 'shardrs2',
                host: 'shardrs2/192.168.222.135:28318,192.168.222.135:28418',
                state: 1,
                topologyTime: Timestamp({
                     t: 1674735300, i: 4 })
              }
            ]
            ---
            active mongoses
            [ {
                     '6.0.4': 1 } ]
            ---
            autosplit
            {
                     'Currently enabled': 'yes' }
            ---
            balancer
            {
                    
              'Currently running': 'no',
              'Failed balancer rounds in last 5 attempts': 0,
              'Currently enabled': 'yes',
              'Migration Results for the last 24 hours': 'No recent migrations'
            }
            ---
            databases
            [
              {
                    
                database: {
                     _id: 'config', primary: 'config', partitioned: true },
                collections: {
                    
                  'config.system.sessions': {
                    
                    shardKey: {
                     _id: 1 },
                    unique: false,
                    balancing: true,
                    chunkMetadata: [ {
                     shard: 'shardrs1', nChunks: 1024 } ],
                    chunks: [
                      'too many chunks to print, use verbose if you want to force print'
                    ],
                    tags: []
                  }
                }
              },
              {
                    
                database: {
                    
                  _id: 'sytest',
                  primary: 'shardrs2',
                  partitioned: false,
                  version: {
                    
                    uuid: new UUID("992b2dd3-a0b4-4764-9c37-bd732ebe3640"),
                    timestamp: Timestamp({
                     t: 1674735595, i: 1 }),
                    lastMod: 1
                  }
                },
                collections: {
                    }
              }
            ]

#### 6.2添加集合分片 ####

*  添加集合分片
    
     *  语法:对集合分片，你必须使用 sh.shardCollection() 方法指定集合和分片键。
        
            sh.shardCollection(namespace, key, unique)
        
        对集合进行分片时,你需要选择一个 片键（Shard Key） , shard key 是每条记录都必须包含的,且建立了索引的单个字段或复合字段,MongoDB按照片键将数据划分到不同的 数据块 中,并将 数据块均衡地分布到所有分片中.为了按照片键划分数据块,MongoDB使用 基于哈希的分片方式（随机平均分配）或者基于范围的分片方式（数值大小分配） 。
        
        比如可以用一些必填字段做为分片。
     *  分片策略
        
         *  哈希策略：基于哈希的分片 ,MongoDB计算一个字段的哈希值,并用这个哈希值来创建数据块
            
             *  测试：使用实名制姓名作为分片
                
                    sh.shardCollection("sytest.user",{
                                "nickname":"hashed"})
                
                    [direct: mongos] testSharded> sh.shardCollection("sytest.user",{
                                "nickname":"hashed"})
                    {
                                
                      collectionsharded: 'sytest.user',
                      ok: 1,
                      '$clusterTime': {
                                
                        clusterTime: Timestamp({
                                 t: 1674736060, i: 44 }),
                        signature: {
                                
                          hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
                          keyId: Long("0")
                        }
                      },
                      operationTime: Timestamp({
                                 t: 1674736060, i: 40 })
                    }
             *  查看分片状态
                
                    sh.status()
         *  范围策略：基于范围的分片 ,MongoDB按照片键的范围把数据分成不同部分.假设有一个数字的片键:想象一个从负无穷到正无穷的直线,每一个片键的值都在直线上画了一点.MongoDB把这条直线划分为更短的不重叠的片段,并称之为 数据块 ,每个数据块包含了片键在一定范围内的数据
            
             *  测试：使用学生年龄进行分片
                
                    sh.shardCollection("sytest.student",{
                                "age":1})
                
                    [direct: mongos] testSharded> sh.shardCollection("sytest.student",{
                                "age":1})
                    {
                                
                      collectionsharded: 'sytest.student',
                      ok: 1,
                      '$clusterTime': {
                                
                        clusterTime: Timestamp({
                                 t: 1674736369, i: 27 }),
                        signature: {
                                
                          hash: Binary(Buffer.from("0000000000000000000000000000000000000000", "hex"), 0),
                          keyId: Long("0")
                        }
                      },
                      operationTime: Timestamp({
                                 t: 1674736369, i: 23 })
                    }
             *  查看分片状态
                
                    sh.status()
     *  注意：
        
         *  一个集合只能指定一个片键，否则报错
            
                [direct: mongos] testSharded> sh.shardCollection("sytest.user",{
                          "age":1})
                MongoServerError: sharding already enabled for collection sytest.user
         *  一旦对一个集合分片，分片键和分片值就不可改变。

#### 6.3哈希与范围分片对比 ####

*  哈希分片
    
     *  哈希分片优点：
        
         *  集群中数据更加均衡：哈希值的随机性使数据随机分布在每个数据块中
     *  哈希分片缺点：
        
         *  由于随机性，范围查询需要从所有分片中查找
 *  范围分片
    
     *  范围分片使用建议：
        
         *  如果范围查询用得多，建议使用范围分片：对于给定一个片键的范围,分发路由可以很简单地确定哪个数据块存储了请求需要的数据,并将请求转发到相应的分片中
     *  范围分片注意点：
        
         *  基于范围的分片会导致数据在不同分片上的不均衡
         *  比如：如果片键所在的字段是线性增长的,一定时间内的所有请求都会落到某个固定的数据块中,最终导致分布在同一个分片中，此时，某台服务器压力过大
 *  如无特殊情况，一般推荐使用 Hash Sharding。

#### 6.4查看集群信息 ####

*  显示集群详细信息
    
        db.printShardingStatus()
 *  查看均衡器是否工作(需要重新均衡时系统才会自动启动)
    
        sh.isBalancerRunning()
 *  查看当前Balancer状态
    
        sh.getBalancerState()

### 7.测试分片集群 ###

#### 7.1哈希策略 ####

*  测试哈希策略
    
     *  向sytest.user集合中插入500条数据测试
        
            #切换到sytest库
            use sytest
            #插入数据
            for(var i=1;i<=500;i++)
            {
                    db.user.insert({
                    _id:i+"",nickname:"sy"+i})}
            #查看插入数量
            db.user.countDocuments()
     *  登录分片副本集1统计插入数据
        
            /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=28018
        
         *  切换数据库
            
                use sytest
                db.user.countDocuments()
            
                shardrs1 [direct: secondary] sytest> db.user.countDocuments()
                239
     *  登录分片副本集2统计插入数据
        
            /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=28318
        
         *  切换数据库
            
                use sytest
                db.user.countDocuments()
         *  统计数量
            
                shardrs2 [direct: primary] test> use sytest
                switched to db sytest
                shardrs2 [direct: primary] sytest> db.user.countDocuments()
                261
     *  查看分片状态
        
         *  查看单个集合状态信息
            
                db.user.stats()
         *  查看本库所有集合信息
            
                sh.status()

#### 7.2范围策略 ####

*  测试范围策略
    
     *  登录路由节点
        
            /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=30018
     *  切换sytest数据库
        
            use sytest
     *  插入500条数据
        
            for(var i=1;i<=500;i++)
            {
                    db.student.insert({
                    "name":"sy"+i,"age":NumberInt(i%120)})}
     *  查看插入数量
        
            db.user.countDocuments()
     *  分别查看两个机器
        
            shardrs2 [direct: primary] sytest> db.student.countDocuments()
            500
            
            shardrs1 [direct: secondary] sytest> db.student.countDocuments()
            0
        
         *  发现数据集中在分片2中，这是因为，数据块（chunk）没有填满，默认的数据块尺寸（chunksize）是64M，填满后才会考虑向其他片的数据块填充数据
         *  这种会导致部分数据集中在一台机器上，所以实际开发中，建议使用hash分片也是这个原因

### 8.MongoDBCompass 连接分片集群 ###

*  连接前要开放端口
    
        firewall-cmd --zone=public --add-port=30018/tcp --permanent
        firewall-cmd --zone=public --add-port=30118/tcp --permanent
        firewall-cmd --reload
 *  连接如下，和单机一样
    
    ![image-20230127153405710][]

### 9.SpringBoot连接分片集群 ###

Java客户端常用的是SpringDataMongoDB，其连接的是mongs路由，配置和单机mongod的配置是一

样的。

*  多个路由的时候的SpringDataMongoDB的客户端配置参考如下：
    
        spring:
         data:
          mongodb:
        #连接路由字符串
            uri: mongodb://192.168.222.135:30018,192.168.222.135:30118/sytest

\{db.user.insert(\{\_id:i+“”,nickname:“sy”+i\})\}  
\#查看插入数量  
db.user.countDocuments()  
\`\`\`

*  登录分片副本集1统计插入数据
    
        /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=28018
    
     *  切换数据库
        
            use sytest
            db.user.countDocuments()
        
            shardrs1 [direct: secondary] sytest> db.user.countDocuments()
            239
 *  登录分片副本集2统计插入数据
    
        /usr/local/mongosh/bin/mongosh --host=192.168.222.135 --port=28318
    
     *  切换数据库
        
            use sytest
            db.user.countDocuments()
     *  统计数量
        
            shardrs2 [direct: primary] test> use sytest
            switched to db sytest
            shardrs2 [direct: primary] sytest> db.user.countDocuments()
            261
 *  查看分片状态
    
     *  查看单个集合状态信息
        
            db.user.stats()
     *  查看本库所有集合信息
        
            sh.status()

#### 7.2范围策略 ####

### 8.MongoDBCompass 连接分片集群 ###

### 9.SpringBoot连接分片集群 ###

Java客户端常用的是SpringDataMongoDB，其连接的是mongs路由，配置和单机mongod的配置是一

样的。

[19d1e8145ef64129b5257491dea862e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/29/27a4d3a15e0e4532aa7d4da17d516a2a.png
[image-20230126161539472]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/29/7c083ab8f912441b838fae34d31cff87.png
[image-20230126164514771]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/29/63894e663a9d4b269d773967035e4804.png
[image-20230126175603616]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/29/c58f7fa89df347e09453490746270703.png
[image-20230126231809406]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/29/d410d55d27ec4a8ba2919a41876c8ab3.png
[image-20230126235954639]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/29/d9afc1aa9ead49cba9a8fbcb31263a13.png
[image-20230127153405710]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/29/4f5b810b970f44959796a0de0dbc9cf7.png