首页 > 数据库 >龙蜥8部署mongodb7分片集群

龙蜥8部署mongodb7分片集群

时间：2024-09-30 10:47:31浏览次数：10  
标签：apprun mongodb shard Server 集群 mongodb7 分片 config 节点

环境描述：

Anolis OS release 8.6

mongodb-org-7.0.9-1

服务器规划：

主机名 IP地址 Mongos Server组件端口 Config Server组件端口 Shard Server组件端口
mongodb01 192.168.109.137 27017 27018

主节点：27019

副本节点：27020

仲裁节点：27021
mongodb02 192.168.109.138 27017 27018

仲裁节点：27019

主节点：27020

副本节点：27021
mongodb03 192.168.109.139 27017 27018

副本节点：27019

仲裁节点：27020

主节点：27021

 

 

 

 

 

 

 

 

 

 

 

结构图：

各组件功能说明：

 

数据库集群请求的入口，所有请求都通过mongos server进行协调，不需在应用程序添加路由选择器，mongos server自己就是一个请求分发中心，它负责把数据请求请求转发到对应的shard服务器上。
在生产环境通常需要设置多mongos server作为请求入口，防止其中一个挂掉所有的mongodb请求都没法操作
Mongos Server功能说明： 
配置服务器，存储所有数据库元信息（路由、分片）的配置。
mongos server本身没有物理存储分片服务器和数据路由信息，只是缓存在内存里，配置服务器则实际存储这些数据。
mongos server第一次启动或者关掉重启就会从config server加载配置信息，以后如果配置服务器信息变化会通知到所有的mongos server更新自己的状态，这样mongos server就能继续准确路由。
在生产环境中通常需要设置多个config server，因为它存储了分片路由的元数据，防止单点数据丢失。
Config Server功能说明： 
分片（sharding）是指将数据库拆分，将其分散在不同的机器上的过程。
将数据分散到不同的机器上，不需要功能强大的服务器就可以存储更多的数据和处理更大的负载。
基本思想就是将集合切成小块，这些块分散到若干片里，每个片只负责总数据的一部分，最后通过一个均衡器来对各个分片进行均衡（数据迁移）。
Shard Server功能说明： 
在复制集中，最多只能拥有一个主节点，主节点是唯一能够接收写请求的节点。
MongoDB在主节点进行写操作，并将这些操作记录到主节点的oplog中。
而副节点将会从oplog复制到其本机，并将这些操作应用到自己的数据集上。
主节点（Primary）功能说明： 
副本节点通过应用主节点传来的数据变动操作来保持其数据集与主节点一致。
副本节点也可以通过增加额外参数配置来对应特殊需求。
例如，副本节点可以是non-voting或是priority 0
副本节点（Secondary） 
仲裁节点即投票节点，其本身并不包含数据集，且也无法晋升为主节点。
但是，一旦当前的主节点不可用时，投票节点就会参与到新的主节点选举的投票中。
仲裁节点使用最小的资源并且不要求单独的硬件设备。
投票节点的存在使得复制集可以以偶数个节点存在，而无需为复制集再新增节点。
在生产环境中不要将投票节点运行在复制集的主节点或副本节点机器上。
投票节点与其他复制集节点的交流仅有：选举过程中的投票，心跳检测和配置数据，这些交互都是不加密的。
仲裁节点（Arbiter）功能说明：

 

 

一、部署：各节点基础配置

apprun用户操作、运行程序
三台主机hosts配置：

sudo vim /etc/hosts 
192.168.109.137    mongodb01
192.168.109.138    mongodb02
192.168.109.139    mongodb03
1.主机hosts配置： 
cat >> /etc/security/limits.conf << EOF
mongodb soft nproc 65535
mongodb hard nproc 65535
mongodb soft nofile 81920
mongodb hard nofile 81920
EOF
2.设置ulimit进程资源限制参数

3.关闭防火墙、关闭selinux、配置时间同步、免密认证~等...

4.新增用户apprun、设置sudoers权限

mkdir -pv /apprun/mongo7.0/{logs,yaml,data,pki,bin,pidfile} 
mkdir -pv /apprun/mongo7.0/data/{config_svr,shard-1,shard-2,shard-3}
mkdir -pv /apprun/mongo7.0/logs/{mongos,config_svr,shard-1,shard-2,shard-3}
5.创建工作目录

6.添加yum源，yum安装mongodb7

[mongodb-org-7.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/7.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-7.0.asc
sudo vim /etc/yum.repos.d/mongodb-org-7.0.repo

sudo yum -y module disable mongodb

sudo yum install -y mongodb-org

关闭开机自启：sudo systemctl disable mongod.service         #yum安装防止mongodb用户自启干扰

vim /etc/profile.d/mongodb.sh
export MONGODB_HOME=/apprun/mongo7.0


source /etc/profile


[apprun@mongodb02 ~]$ mongod --version
db version v7.0.9
Build Info: {
    "version": "7.0.9",
    "gitVersion": "3ff3a3925c36ed277cf5eafca5495f2e3728dd67",
    "openSSLVersion": "OpenSSL 1.1.1k  FIPS 25 Mar 2021",
    "modules": [],
    "allocator": "tcmalloc",
    "environment": {
        "distmod": "rhel80",
        "distarch": "x86_64",
        "target_arch": "x86_64"
    }
}
[apprun@mongodb02 ~]$
7.添加MongoDB环境变量

sudo cp /usr/bin/mongod /apprun/mongodb/bin/

二、生成mongo-keyfile认证文件

1.在mongodb01节点上执行

openssl rand -base64 756 > ${MONGODB_HOME}/pki/mongo.keyfile

sudo chmod 600 ${MONGODB_HOME}/pki/mongo.keyfile

cd ${MONGODB_HOME}/pki/
rsync -avz --progress -e 'ssh -p 22' ${MONGODB_HOME}/mongo.keyfile mongodb02:${MONGODB_HOME}/pki/
rsync -avz --progress -e 'ssh -p 22' ${MONGODB_HOME}/mongo.keyfile mongodb03:${MONGODB_HOME}/pki/
2. 将mongo.keyfile拷贝至其他mongodb节点

 

三、创建Config Server组件集群

cat > ${MONGODB_HOME}/yaml/config_svr.yml << EOF
processManagement:
  fork: true
  pidFilePath: /apprun/mongo7.0/pidfile/config_svr.pid
net:
  bindIpAll: true
  port: 27018
  ipv6: true
  maxIncomingConnections: 20000
  unixDomainSocket:
    enabled: true
    pathPrefix: /apprun/mongo7.0/
storage:
  dbPath: /apprun/mongo7.0/data/config_svr
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
systemLog:
  destination: file
  path: /apprun/mongo7.0/logs/config_svr/config_svr.log
  logAppend: true
sharding:
  clusterRole: configsvr
replication:
  oplogSizeMB: 1000
  replSetName: configsvr_rs
#security:
#  authorization: enabled
#  keyFile: /apprun/mongo7.0/pki/mongo.keyfile
#  clusterAuthMode: keyFile
setParameter:
  connPoolMaxConnsPerHost: 20000
EOF
1. 在mongodb01节点创建config_svr.yml 
cd ${MONGODB_HOME}/yaml/
rsync -avz --progress -e 'ssh -p 22' ${MONGODB_HOME}/config_svr.yml mongodb02:${MONGODB_HOME}/yaml/
rsync -avz --progress -e 'ssh -p 22' ${MONGODB_HOME}/config_svr.yml mongodb03:${MONGODB_HOME}/yaml/
2. 将config_srv.yml拷贝至其他mogodb节点

3.  创建Config Server启动文件，并将启动文件拷贝到其他Config Server节点

[Unit]
Description=MongoDB Config Server
After=network.target

[Service]
Type=forking
User=apprun
Group=apprun
PIDFile=/apprun/mongo7.0/pidfile/config_svr.pid
ExecStart=/apprun/mongo7.0/bin/mongod --config /apprun/mongo7.0/yaml/config_svr.yml
ExecStop=/apprun/mongo7.0/bin/mongod --shutdown --config /apprun/mongo7.0/yaml/config_svr.yml

[Install]
WantedBy=multi-user.target
sudo vim /usr/lib/systemd/system/mongodb-config.service

复制到其他Config Server节点

4.  在Config Server各节点启动Config Server服务

sudo systemctl daemon-reload
sudo systemctl start mongodb-config.service
sudo systemctl status mongodb-config.service
sudo systemctl enable mongodb-config.service
sudo netstat -ntlp

5. 在mongodb01上初始化配置Config Server副本集

mongosh --host localhost --port 27018

use admin

config = {_id: "configsvr_rs", members: [ {_id: 0, host: "mongodb01:27018"},

{_id: 1, host: "mongodb02:27018"},

{_id: 2, host: "mongodb03:27018"} ] }

#注：_id: "configsvr_rs"应与config_svr.yml配置文件中的replSetName名称一致，"members" 中的 "host" 为三个节点的IP/主机名和Config Server Port

初始化副本集：

admin> rs.initiate(config)

 

{ ok: 1 }

查看此时状态：

configsvr_rs [direct: other] admin> rs.status()

 

 

 四、创建Shard Server组件集群

1.  在mongodb01节点创建Shard Server01、02、03三个副本集的配置文件

cat > ${MONGODB_HOME}/yaml/shard-1.yml << EOF
processManagement:
  fork: true
  pidFilePath: ${MONGODB_HOME}/pidfile/shard-1.pid
net:
  bindIpAll: true
  port: 27019
  ipv6: true
  maxIncomingConnections: 20000
  unixDomainSocket:
    enabled: true
    pathPrefix: ${MONGODB_HOME}/
storage:
  dbPath: ${MONGODB_HOME}/data/shard-1
  wiredTiger:
    engineConfig:
      cacheSizeGB: 5
systemLog:
  destination: file
  path: ${MONGODB_HOME}/logs/shard-1/shard-1.log
  logAppend: true
sharding:
  clusterRole: shardsvr
replication:
  oplogSizeMB: 1000
  replSetName: shardsvr_rs1
#security:
#  authorization: enabled
#  keyFile: ${MONGODB_HOME}/pki/mongo.keyfile
#  clusterAuthMode: keyFile
setParameter:
  connPoolMaxConnsPerHost: 20000
  maxNumActiveUserIndexBuilds: 6
EOF
1.1 创建Shard Server 01副本集 
cat > ${MONGODB_HOME}/yaml/shard-2.yml << EOF
processManagement:
  fork: true
  pidFilePath: ${MONGODB_HOME}/pidfile/shard-2.pid
net:
  bindIpAll: true
  port: 27020
  ipv6: true
  maxIncomingConnections: 20000
  unixDomainSocket:
    enabled: true
    pathPrefix: ${MONGODB_HOME}/
storage:
  dbPath: ${MONGODB_HOME}/data/shard-2
  wiredTiger:
    engineConfig:
      cacheSizeGB: 5
systemLog:
  destination: file
  path: ${MONGODB_HOME}/logs/shard-2/shard-2.log
  logAppend: true
sharding:
  clusterRole: shardsvr
replication:
  oplogSizeMB: 1000
  replSetName: shardsvr_rs2
#security:
#  authorization: enabled
#  keyFile: ${MONGODB_HOME}/pki/mongo.keyfile
#  clusterAuthMode: keyFile
setParameter:
  connPoolMaxConnsPerHost: 20000
  maxNumActiveUserIndexBuilds: 6
EOF
1.2 创建Shard Server 02副本集 
cat > ${MONGODB_HOME}/yaml/shard-3.yml << EOF
processManagement:
  fork: true
  pidFilePath: ${MONGODB_HOME}/pidfile/shard-3.pid
net:
  bindIpAll: true
  port: 27021
  ipv6: true
  maxIncomingConnections: 20000
  unixDomainSocket:
    enabled: true
    pathPrefix: ${MONGODB_HOME}/
storage:
  dbPath: ${MONGODB_HOME}/data/shard-3
  wiredTiger:
    engineConfig:
      cacheSizeGB: 5
systemLog:
  destination: file
  path: ${MONGODB_HOME}/logs/shard-3/shard-3.log
  logAppend: true
sharding:
  clusterRole: shardsvr
replication:
  oplogSizeMB: 1000
  replSetName: shardsvr_rs3
#security:
#  authorization: enabled
#  keyFile: ${MONGODB_HOME}/pki/mongo.keyfile
#  clusterAuthMode: keyFile
setParameter:
  connPoolMaxConnsPerHost: 20000
  maxNumActiveUserIndexBuilds: 6
EOF
1.3 创建Shard Server 03副本集

 2. 将三个副本集配置文件拷贝至其他Shard Server节点

cd ${MONGODB_HOME}/yaml/

rsync -avz --progress -e 'ssh -p 22' ${MONGODB_HOME}/shard-*.yml mongodb02:${MONGODB_HOME}/yaml/
rsync -avz --progress -e 'ssh -p 22' ${MONGODB_HOME}/shard-*.yml mongodb03:${MONGODB_HOME}/yaml/

3. 在mongodb01节点创建Shard Server01、02、03三个副本集的启动文件

sudo vim /usr/lib/systemd/system/mongodb-shard-1.service
[Unit]
Description=MongoDB Shard Server One
After=mongodb-config.service network.target

[Service]
Type=forking
User=apprun
Group=apprun
PIDFile=/apprun/mongo7.0/pidfile/shard-1.pid
ExecStart=/apprun/mongo7.0/bin/mongod --config /apprun/mongo7.0/yaml/shard-1.yml
ExecStop=/apprun/mongo7.0/bin/mongod --shutdown --config /apprun/mongo7.0/yaml/shard-1.yml

[Install]
WantedBy=multi-user.target
3.1 创建Shard Server 01副本集启动文件 
sudo vim /usr/lib/systemd/system/mongodb-shard-2.service
[Unit]
Description=MongoDB Shard Server Two
After=mongodb-config.service network.target

[Service]
Type=forking
User=apprun
Group=apprun
PIDFile=/apprun/mongo7.0/pidfile/shard-2.pid
ExecStart=/apprun/mongo7.0/bin/mongod --config /apprun/mongo7.0/yaml/shard-2.yml
ExecStop=/apprun/mongo7.0/bin/mongod --shutdown --config /apprun/mongo7.0/yaml/shard-2.yml

[Install]
WantedBy=multi-user.target
3.2 创建Shard Server 02副本集启动文件 
sudo vim /usr/lib/systemd/system/mongodb-shard-3.service
[Unit]
Description=MongoDB Shard Server Three
After=mongodb-config.service network.target

[Service]
Type=forking
User=apprun
Group=apprun
PIDFile=/apprun/mongo7.0/pidfile/shard-3.pid
ExecStart=/apprun/mongo7.0/bin/mongod --config /apprun/mongo7.0/yaml/shard-3.yml
ExecStop=/apprun/mongo7.0/bin/mongod --shutdown --config /apprun/mongo7.0/yaml/shard-3.yml

[Install]
WantedBy=multi-user.target
3.3 创建Shard Server 03副本集启动文件

3.4 将三个Shard Server副本集的启动文件拷贝至其他Shard Server节点[略]

4.  在mongodb各节点启动三个Shard Server服务

sudo systemctl daemon-reload
sudo systemctl start mongodb-shard-1
sudo systemctl start mongodb-shard-2
sudo systemctl start mongodb-shard-3
sudo systemctl status mongodb-shard-1
sudo systemctl status mongodb-shard-2
sudo systemctl status mongodb-shard-3

sudo netstat -ntlp

sudo systemctl enable mongodb-shard-1
sudo systemctl enable mongodb-shard-2
sudo systemctl enable mongodb-shard-3

mongosh --host mongodb01 --port 27019

使用admin数据库，定义副本集配置：

use admin

定义config变量,"arbiterOnly":true 代表其为仲裁节点：
config = {_id: "shardsvr_rs1", members: [
    {_id: 0, host: "mongodb01:27019"},
    {_id: 1, host: "mongodb02:27019"},
    {_id: 2, host: "mongodb03:27019",arbiterOnly:true},
  ]
}

注：_id: "shardsvr_rs1"应与shard-1.yml配置文件中的replSetName名称一致，
        "members" 中的 "host" 为三个节点的IP/主机名和Shard Server 1 Port
        
初始化副本集：
rs.initiate(config);
查看此时状态：
admin> rs.status()
5. 在mongodb01上初始化配置Shard Server 01副本集 
mongosh --host mongodb02 --port 27020

使用admin数据库，定义副本集配置：

use admin

定义config变量,"arbiterOnly":true 代表其为仲裁节点：
config = {_id: "shardsvr_rs2", members: [
    {_id: 0, host: "mongodb01:27020",arbiterOnly:true},
    {_id: 1, host: "mongodb02:27020"},
    {_id: 2, host: "mongodb03:27020"},
  ]
}

注：_id: "shardsvr_rs2"应与shard-2.yml配置文件中的replSetName名称一致，
        "members" 中的 "host" 为三个节点的IP/主机名和Shard Server 2 Port
        
初始化副本集：
rs.initiate(config);
查看此时状态：
admin> rs.status()
6. 在mongodb02上初始化配置Shard Server 02副本集 
mongosh --host mongodb03 --port 27021

使用admin数据库，定义副本集配置：

use admin

定义config变量,"arbiterOnly":true 代表其为仲裁节点：
config = {_id: "shardsvr_rs3", members: [
    {_id: 0, host: "mongodb01:27021"},
    {_id: 1, host: "mongodb02:27021",arbiterOnly:true},
    {_id: 2, host: "mongodb03:27021"},
  ]
}

注：_id: "shardsvr_rs3"应与shard-3.yml配置文件中的replSetName名称一致，
        "members" 中的 "host" 为三个节点的IP/主机名和Shard Server 3 Port
        
初始化副本集：
rs.initiate(config);
查看此时状态：
admin> rs.status()
7. 在mongodb03上初始化配置Shard Server 03副本集

 

五、创建Mongos Server路由服务器集群

cat > ${MONGODB_HOME}/yaml/mongos.yml << EOF
processManagement:
  fork: true
  pidFilePath: ${MONGODB_HOME}/pidfile/mongos.pid
net:
  bindIpAll: true
  port: 27017
  ipv6: true
  maxIncomingConnections: 20000
  unixDomainSocket:
    enabled: true
    pathPrefix: ${MONGODB_HOME}/
systemLog:
  destination: file
  path: ${MONGODB_HOME}/logs/mongos/mongos.log
  logAppend: true
#security:
#  keyFile: ${MONGODB_HOME}/pki/mongo.keyfile
#  clusterAuthMode: keyFile
sharding:
  configDB: configsvr_rs/mongodb01:27018,mongodb02:27018,mongodb03:27018
EOF
1. 在Mongos Server 01 [mongodb01] 上创建mongos配置文件 
sudo vim /usr/lib/systemd/system/mongodb-mongos-server.service
[Unit]
Description=MongoDB Mongos Server
#After=mongodb-config.service mongodb-shard-1.service mongodb-shard-2.service mongodb-shard-3.service network.target
After=local-fs.target swap.target

[Service]
Type=forking
User=apprun
Group=apprun
PIDFile=/apprun/mongo7.0/pidfile/mongos.pid
ExecStart=/apprun/mongo7.0/bin/mongos --config /apprun/mongo7.0/yaml/mongos.yml
ExecStop=/apprun/mongo7.0/bin/mongos --shutdown --config /apprun/mongo7.0/yaml/mongos.yml

[Install]
WantedBy=multi-user.target
2. 在Mongos Server 01 [mongodb01] 上创建mongos启动文件

3.  将mongos的配置文件拷贝至其他Mongos Server节点

cd /apprun/mongo7.0/yaml/

rsync -avz --progress -e 'ssh -p 22' ./mongos.yml mongodb02:/apprun/mongo7.0/yaml/
rsync -avz --progress -e 'ssh -p 22' ./mongos.yml mongodb03:/apprun/mongo7.0/yaml/

4.  将mongos的启动文件拷贝至其他Mongos Server节点（略）

5.在Mongos Server各节点启动Mongos服务

sudo cp /usr/bin/mongos /apprun/mongo7.0/bin/

sudo systemctl daemon-reload
sudo systemctl start mongodb-mongos-server
sudo systemctl status mongodb-mongos-server

sudo netstat -ntlp
sudo systemctl enable mongodb-mongos-server

 

mongosh --host localhost --port 27017
使用admin数据库，定义副本集配置：
use admin
添加各个分片集群
sh.addShard("shardsvr_rs1/mongodb01:27019,mongodb02:27019,mongodb03:27019")
sh.addShard("shardsvr_rs2/mongodb01:27020,mongodb02:27020,mongodb03:27020")
sh.addShard("shardsvr_rs3/mongodb01:27021,mongodb02:27021,mongodb03:27021")

注：添加各集群分片是如提示
MongoServerError[OperationFailed]: Cannot add shardsvr_rs1/mongo-01:27019,mongo-02:27019,mongo-03:27019 
as a shard since the implicit default write concern on this shard is set to {w : 1},
 because number of arbiters in the shard's configuration caused the number of writable voting members not to be strictly more than the voting majority. 
 Change the shard configuration or set the cluster-wide write concern using the setDefaultRWConcern command and try again.

这是因为在mongos实例中我们使用命令db.adminCommand({ "getDefaultRWConcern": 1 }) 
可以查看到当前mongos默认设置的写入安全机制defaultWriteConcern，默认是 majority （多数确认），这是mongodb5.0后开始的默认设置 ，
这意味着当进行写操作时，至少要有超过大多数的数据节点确认写操作成功，才会返回成功的响应，
目前我们是3个节点，mongo系统定义的一半节点数是 （3+1）/2=2，需要超过2，也就是至少要有3个节点写入成功才行，
但是我们设置了一个 仲裁节点，导致3个shard节点中，只有2个可写数据的节点，怎么也不会写成功了，所以导致失败

解决方法，将写入安全级别调低，然后再添加分片
db.adminCommand({  "setDefaultRWConcern" : 1,  "defaultWriteConcern" : {    "w" : 1  }})
sh.addShard("shardsvr_rs1/mongodb01:27019,mongodb02:27019,mongodb03:27019")
sh.addShard("shardsvr_rs2/mongodb01:27020,mongodb02:27020,mongodb03:27020")
sh.addShard("shardsvr_rs3/mongodb01:27021,mongodb02:27021,mongodb03:27021")

"w" : 1 只要主节点写入成功，就直接返回成功的响应，而不管副节点的同步情况
"w" : majority 超过节点半数【(节点数+1)/2】写入成功，才返回成功响应
"w" : 0 不等待任何节点确认写操作，只需写入到内存就返回成功，这是最低级别的写安全级别，这个配置可以提供写入性能，但也有一定的风险
"w" : 等待指定数量的节点确认写成功
6.在任一台Mongos Server上启用分片机制

 

六、开启集群认证功能

1. 在mongos中创建认证用户

创建一个名为admin的超级管理员用户，该用户对所有数据库管理有root权限，可使用db.dropUser("admin")删除该用户

mongosh --host mongodb01 --port 27017
use admin
db.createUser({user: "admin", pwd: "Hz@10086", roles: [{ role: "root", db: "admin" }]})
账号验证操作：
admin> db.auth("admin", "Hz@10086")
{ ok: 1 }


权限说明：
Read：允许用户读取指定数据库。
readWrite：允许用户读写指定数据库。
dbAdmin：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile。
userAdmin：允许用户向system.users集合写入，可以找指定数据库里创建、删除和管理用户。
clusterAdmin：只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限。
readAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读权限。
readWriteAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读写权限。
userAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限。
dbAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限。
root：只在admin数据库中可用。超级账号，超级权限。
创建admin的超级管理员用户

2. 分别在Shard Server 01、02、03的Primary节点，添加admin用户

mongosh --host mongodb01 --port 27019
use admin
db.createUser({user: "admin", pwd: "Hz@10086", roles: [{ role: "root", db: "admin" }]})
2.1 在Shard Server 01上添加 
mongosh --host mongodb02 --port 27020
use admin
db.createUser({user: "admin", pwd: "Hz@10086", roles: [{ role: "root", db: "admin" }]})
2.2 在Shard Server 02上添加 
mongosh --host mongodb03 --port 27021
use admin
db.createUser({user: "admin", pwd: "Hz@10086", roles: [{ role: "root", db: "admin" }]})
2.3 在Shard Server 03上添加

 

七、开启各组件安全认证机制

cat > /apprun/clear_annotate.sh << EOF
#!/bin/bash
path="/apprun/mongo7.0/yaml/"
files=("config_svr.yml" "shard-1.yml" "shard-2.yml" "shard-3.yml" "mongos.yml")

# 遍历文件列表
for file in "${files[@]}"
do
    # 检查文件是否存在
    if [ -f "${path}${file}" ]; then
        # 移除指定行前的#号
        sed -i '/security:/{s/^#//}' "${path}${file}"
        sed -i '/authorization:/{s/^#//}' "${path}${file}"
        sed -i '/keyFile:/{s/^#//}' "${path}${file}"
        sed -i '/clusterAuthMode:/{s/^#//}' "${path}${file}"
    else
        echo "文件 ${path}${file} 不存在."
    fi
done

echo "处理完成."

EOF
1. 创建并在各mongodb各节点运行此脚本去除Config Server、Shard Server、MONGOS SERVER各组件配置文件中安全认证部分的#注释号 
sudo systemctl stop mongodb-mongos-server
sudo systemctl stop mongodb-shard-3
sudo systemctl stop mongodb-shard-2
sudo systemctl stop mongodb-shard-1
sudo systemctl stop mongodb-config.service

sudo netstat -ntlp
2.关闭所有节点的所有MongoDB组件 
集群重启顺序：
1 config 集群 > 2 shard 集群 > 3 mongos 集群
shard 集群最好分开起，避免shard server 1、2、3的主都在第一台上；shard server 1在第一台先起，那么shard server 2就在第二台先起...
sudo systemctl restart mongodb-config.service
sudo systemctl status mongodb-config.service

sudo systemctl restart mongodb-shard-1
sudo systemctl status mongodb-shard-1

sudo systemctl restart mongodb-shard-2
sudo systemctl status mongodb-shard-2

sudo systemctl restart mongodb-shard-3
sudo systemctl status mongodb-shard-3

sudo systemctl restart mongodb-mongos-server
sudo systemctl status mongodb-mongos-server

sudo netstat -ntlp
3.按顺序重启所有节点的所有MongoDB组件

注：在启动Shard Server组件时，至少需要两个Config Server节点起来，也就是Config Server集群可用才行

4.使用admin用户登录mongos，创建普通用户

创建一个名为testuser的普通用户，该用户对testdb数据库有读写权限，可使用db.dropUser("testuser")删除该用户
mongosh -u admin -p Hz@10086 mongodb01:27017/admin
use testdb
db.createUser({user:"testuser", pwd:"Hzyh@10085", roles:[{role:"readWrite",db:"testdb"}]});
账号验证操作：
testdb> db.auth("testuser", "Hzyh@10085")
{ ok: 1 }

 5. 客户端连接mongodb集群

mongosh mongodb://'testuser':'Hzyh@10085'@192.168.109.137:27017,192.168.109.138:27017,192.168.109.139:27017/testdb?authSource=testdb
客户端连接多个mongos

 

标签：apprun,mongodb,shard,Server,集群,mongodb7,分片,config,节点
From： https://www.cnblogs.com/NGames/p/18194415

相关文章

  • Rancher迁移(单点到集群&集群到集群迁移)
    Rancher迁移概述：本文用于记录rancher从docker迁移到HA架构、从HA架构到HA架构的过程，便于后续回溯。一、部署架构1、dockerrun运行rancher直接使用（不推荐生产，单节点发生故障，则其他节点上将没有可用的集群数据副本，并且你可能会丢失RancherServer上的数据。）2、使用HA模......
  • [Redis][集群][下]详细讲解
    目录1.集群搭建(基于Docker)2.主节点宕机1.宕机后会发生什么？2.处理流程1.故障判定2.故障迁移3.集群扩容0.前言1.把新的主节点加入到集群2.重新分配slots3.给新的主节点添加从节点1.集群搭建(基于Docker)拓扑结构如下：创建目录和配置：创建redis-cluster⽬录，内......
  • 高可用集群 KEEPALIVED ubuntu使用
    1Keepalived架构和安装2.1Keepalived架构 Keepalived进程树Keepalived<--Parentprocessmonitoringchildren\_Keepalived<--VRRPchild\_Keepalived<--Healthcheckingchild2.2Keepalived环境准备#环境准备#两台keepalive机器分别配一个单独网卡......
  • springboot+vue+elementui大文件分片上传
    工具类方法：/***大文件分片上传*@paramfileName文件名*@paramfile文件*@paramfileKey文件key*@paramshardIndex当前分片下标*@paramshardTotal分片总量*/publicstaticvoidbigUpload(StringfileNam......
  • Karmada新版本发布，支持联邦应用跨集群滚动升级
    本文分享自华为云社区《Karmadav1.11版本发布！新增应用跨集群滚动升级能力》，作者：云容器大未来。Karmada是开放的多云多集群容器编排引擎，旨在帮助用户在多云环境下部署和运维业务应用。凭借兼容Kubernetes原生API的能力，Karmada可以平滑迁移单集群工作负载，并且仍可保持与K......
  • 手动搭建高可用的 kubernetes 集群(v1.31)
    手动搭建高可用的kubernetes集群(v1.31)目录1、环境准备1.1集群规划（节约资源，可按需配置）1.2安装依赖包（双节点执行）1.3配置映射（双节点执行）1.4免密登录（master节点执行）1.5环境准备（双节点执行）2、安装containerd（双节点执行）3、安装Kubernetes3.1安装Kubernetes组件（双节点执行）3.2......
  • 反问面试官：如何实现集群内选主
    面试官经常喜欢问什么zookeeper选主原理、什么CAP理论、什么数据一致性。经常都被问烦了，我就想问问面试官，你自己还会实现一个简单的集群内选主呢？估计大部分面试官自己也写不出来。本篇使用Java和Netty实现简单的集群选主过程的示例。这个示例展示了多个节点通过投票选举一......
  • 构建读写分离的数据库集群
    三、构建读写分离的数据库集群1、案例目标（1）了解Mycat提供的读写分离功能。（2）了解MySQL数据库的主从架构。（3）构建以Mycat为中间件的读写分离数据库集群。2、案例分析读写分离的基本原理：让主数据库处理事务性增、改、删除操作，而从库处理查询操作2.1准备三台虚拟机设置如下：......
  • redis集群增加减少节点
    redis集群故障切换方案步骤：1、增加临时节点并加入集群2、将故障节点槽位移动到新节点3、剔除故障节点4、备份故障节点配置下架更换5、更换后按照1-3步骤将临时节点剔除，将原故障节点重新加入集群#测试环境为3主3从，有5个keyredis-cli-c-p8102-h172.17.0.89-a123456d......
  • semi-sync原主库加入集群阻塞问题分析
    问题现象客户在一个一主两从的半同步复制环境下做了手工切换，然后尝试把原主库加入集群中，结果发现新集群中的数据一直无法同步到slave（原主库）中来，查看slave（原主库）同步状态，IO线程和SQL线程都是YES状态，但是Seconds_Behind_Master大于0.查看showprocesslist状态,发现SQL线程一......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99