MongoDB数据库单机和集群搭建过程
一，mongodb单机版搭建
// 通过WGET下载Linux版本的MongoDB
[bigdata@linux ~]$ wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel62-3.4.3.tgz
// 将压缩包解压到指定目录
[bigdata@linux backup]$ tar -xf mongodb-linux-x86_64-rhel62-3.4.3.tgz -C ~/
// 将解压后的文件移动到最终的安装目录
[bigdata@linux ~]$ mv mongodb-linux-x86_64-rhel62-3.4.3/ /usr/local/mongodb
// 在安装目录下创建data文件夹用于存放数据和日志
[bigdata@linux mongodb]$ mkdir /usr/local/mongodb/data/
// 在data文件夹下创建db文件夹，用于存放数据
[bigdata@linux mongodb]$ mkdir /usr/local/mongodb/data/db/
// 在data文件夹下创建logs文件夹，用于存放日志
[bigdata@linux mongodb]$ mkdir /usr/local/mongodb/data/logs/
// 在logs文件夹下创建log文件
[bigdata@linux mongodb]$ touch /usr/local/mongodb/data/logs/ mongodb.log
// 在data文件夹下创建mongodb.conf配置文件
[bigdata@linux mongodb]$ touch /usr/local/mongodb/data/mongodb.conf
在mongodb.conf文件中输入如下内容
[bigdata@linux mongodb]$ vim ./data/mongodb.conf
#端口号port = 27017
#数据目录
dbpath = /usr/local/mongodb/data/db
#日志目录
logpath = /usr/local/mongodb/data/logs/mongodb.log
#设置后台运行
fork = true
#日志输出方式
logappend = true
#开启认证
#auth = true
完成MongoDB的安装后，启动MongoDB服务器
// 启动MongoDB服务器
[bigdata@linux mongodb]$ sudo /usr/local/mongodb/bin/mongod -config /usr/local/mongodb/data/mongodb.conf
// 访问MongoDB服务器
[bigdata@linux mongodb]$ /usr/local/mongodb/bin/mongo
// 停止MongoDB服务器
[bigdata@linux mongodb]$ sudo /usr/local/mongodb/bin/mongod -shutdown -config /usr/local/mongodb/data/mongodb.conf
二，mongodb单机版开启认证模式
一般默认安装mongoDB到电脑的时候，默认数据库是没有设置管理员账号密码的。
所以为了安全问题，必须需要设置一下
-
进入mongo（不需要账号验证）
mongo -
查看数据库 show dbs
show dbs -
切换到admin数据库 use admin
-
创建超级管理员账户 db.createUser()
use admin db.createUser({ user:"设置管理员账号", pwd:"设置管理员密码", roles:["root"] }) -
切换到blog数据库 use blog
-
创建普通账号 db.createUser()
普通账号可指定管理某个数据库use blog db.createUser({ user:"普通账号", pwd:"设置密码", roles:["readWrite"] })roles属性是设置该账号对mongoDB数据库的权限
mongodb 一共有哪些权限:-
数据库用户角色：read、readWrite;
-
数据库管理角色：dbAdmin、dbOwner、userAdmin；
-
集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；
-
备份恢复角色：backup、restore；
-
所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
-
超级用户角色：root
// 这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）
- 内部角色：__system
read:允许用户读取指定数据库
readWrite:允许用户读写指定数据库
dbAdmin：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile
userAdmin：允许用户向system.users集合写入，可以找指定数据库里创建、删除和管理用户
clusterAdmin：只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限。
readAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读权限
readWriteAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读写权限
userAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限
dbAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限。
root：只在admin数据库中可用。超级账号，超级权限
-
-
退出mongo服务
-
停止mongo服务
-
修改mongo.conf配置文件，开启auth认证
#开启认证 auth = true -
重新启动mongodb
客户端登录命令如下
/usr/local/mongodb/bin/mongo admin -u 用户账号 -p 用户密码
三，mongodb集群版（主从 + 分片）搭建
MongoDB有三种集群部署模式，分别是主从复制(Master-Slave)、副本集(ReplicaSet)、分片集(Sharding)。采用集群架构复制的目的：保证数据生产部署时的冗余和可靠性，采用不同的机器来保存副本，数据不会因为单点故障而丢失。读写分离，提高数据的读取能力。故障转移、故障恢复。
MongoDB核心组件
💥Mongod： 处理所有的数据请求、管理数据的增删改查操作。默认的数据目录/data/db，默认端口27017，默认主机地址localhost。
💥Mongo：MongoDB提供的一个Mongo shell客户端，便于用户与MongoDB之间的交互。启动Mongo默认连接到localhost:270127的test数据库。
💥Mongos： 用于MongoDB分片集的路由选择，对来自于应用层的查询请求进行处理，平判断所请求的数据位于分片集的哪个位置。
主从复制
1️⃣主从复制模式的集群只能有一个主节点，主节点提供所有的增删改查服务，从节点不提供服务，但是可以通过设置从节点提供查询服务，这样可以减少主节点的压力。2️⃣此外，每个从节点都要知道主节点的地址以及主节点的各个操作，从节点定期轮询主节点获取操作，并对自己的数据副本进行这些操作，从而保证主从节点数据的一致性。3️⃣主节点出现故障，只能人工介入指定新的主节点，在此期间整个集群数据只能被读而无法修改。
副本集
Primary主节点：与主从复制一样，副本集中也只能有一个主节点，向外对客户端提供数据读写的服务，执行的写操作信息保存在oplog中。不同的是，副本集中的主节点发生故障时，仲裁节点触发选举，在所有的从节点中选出一个作为新的主节点，即使后续旧的主节点恢复正常，也会以从节点的身份加入到集群。
Secondary从节点：从节点只提供读数据的服务，并且从节点定期轮询oplog日志文件，根据日志内容同步更新自身的数据，使之保持与主节点一致。
Arbiter仲裁节点：仲裁节点不存储任何数据，只记录集群的节点数以及主节点发生故障时触发选举机制进行仲裁。仲裁节点和其他节点之间的唯一通信就是选举期间的投票、心跳信息。
分片集
副本集可以解决主节点发生故障所导致的数据丢失或不可用的问题，但遇到需要存储海量数据的情况，副本集就无法解决了。此时就用到了MongoDB的分片集操作，所谓分片就是将数据拆分并分散存储在不同机器上的过程。
什么时间进行分片操作：1.单个节点的磁盘空间不足时。2.单个mongod已经不能满足写数据的性能要求，通过分片让写压力分散到各个分片服务器上。3.把大量数据放到内存里提高性能，通过分片利用多台分片服务器的内存资源。
Shard Server分片服务器：每一个分片服务器都是一个mongod进程，用于存储实际的数据块。实际生产中，一个分片服务器往往有多台机器组成一个副本集来共同承担，防止因主节点的单点故障而崩溃整个系统。
Config Server配置服务器：同样是一个mongod进程，用来保存集群和分片的元数据，在集群启动的最开始时建立。
Route Server路由服务器：是一个独立的mongos进程(即不储存数据的mongod进程)，启动时要从配置服务器加载集群信息到缓存中(分片集群要首先启动配置服务器的原因)，并将客户端的请求路由给每个分片服务器，在各分片服务器返回结果后进行聚合并返回客户端。
以下部署内容转载自：https://www.cnblogs.com/hsyw/p/13419947.html
一、部署环境
1、MongoDB机器信息
| 192.168.47.188 | 192.168.47.189 | 192.168.47.190 |
|---|---|---|
| mongos | mongos | mongos |
| config server | config server | config server |
| shard server1 主节点 | shard server1 副节点 | shard server1 仲裁 |
| shard server2 仲裁 | shard server2 主节点 | shard server2 副节点 |
| shard server3 副节点 | shard server3 仲裁 | shard server3 主节点 |
系统：centos7.6
DB版本：mongodb-linux-x86_64-rhel62-4.2.1.tgz
二、安装MongoDB
2.1、安装MongoDB（三台主机均操作）
[root@t1 ~]# tar -zxvf mongodb-linux-x86_64-rhel62-4.2.1.tgz -C /app/
[root@t1 ~]# cd /app && mv mongodb-linux-x86_64-rhel62-4.2.1/ mongodb && cd mongodb
#分别在每台机器建立conf、mongos、config、shard1、shard2、shard3六个目录，因为mongos不存储数据，只需要建立日志文件目录即可。
[root@t1 mongodb]# mkdir conf \
mkdir -p config/{data,log} \
mkdir -p shard1/{data,log} \
mkdir -p shard2/{data,log} \
mkdir -p shard3/{data,log} \
配置环境变量
vim /etc/profile
# MongoDB 环境变量内容
export MONGODB_HOME=/app/mongodb
export PATH=$MONGODB_HOME/bin:$PATH
####
source /etc/profile
2.2、配置config server服务器
[root@t1 mongodb]# vim conf/config.conf
pidfilepath = /app/mongodb/config/log/configsrv.pid
dbpath = /app/mongodb/config/data
logpath = /app/mongodb/config/log/congigsrv.log
logappend = true
bind_ip = 0.0.0.0
port = 21000
fork = true
#declare this is a config db of a cluster;
configsvr = true
#副本集名称
replSet = configs
#设置最大连接数
maxConns = 20000
#启动三台服务器的config server（三台）
[root@t2 ~]# /app/mongodb/bin/mongod -f /app/mongodb/conf/config.conf
about to fork child process, waiting until server is ready for connections.
forked process: 3154
child process started successfully, parent exiting
#登录任意一台配置服务器，初始化配置副本集
#连接 MongoDB
[root@t2 ~]# /app/mongodb/bin/mongo --port 21000
#config 变量
config = {
_id : "configs",
members : [
{_id : 0, host : "192.168.47.188:21000" },
{_id : 1, host : "192.168.47.189:21000" },
{_id : 2, host : "192.168.47.190:21000" }
]
}
#初始化副本集
rs.initiate(config)
其中，"_id" : "configs"应与配置文件中配置的 replicaction.replSetName 一致，"members" 中的 "host" 为三个节点的 ip 和 port
响应内容如下
> config = {
... _id : "configs",
... members : [
... {_id : 0, host : "192.168.47.188:21000" },
... {_id : 1, host : "192.168.47.189:21000" },
... {_id : 2, host : "192.168.47.190:21000" }
... ]
... }
{
"_id" : "configs",
"members" : [
{
"_id" : 0,
"host" : "192.168.47.188:21000"
},
{
"_id" : 1,
"host" : "192.168.47.189:21000"
},
{
"_id" : 2,
"host" : "192.168.47.190:21000"
}
]
}
> rs.initiate(config)
{
"ok" : 1,####注意看状态
"$gleStats" : {
"lastOpTime" : Timestamp(1596357707, 1),
"electionId" : ObjectId("000000000000000000000000")
},
"lastCommittedOpTime" : Timestamp(0, 0),
"$clusterTime" : {
"clusterTime" : Timestamp(1596357707, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1596357707, 1)
}
configs:SECONDARY>
此时会发现终端上的输出已经有了变化。
//从单个一个
>
//变成了
configs:SECONDARY>
查询状态
configs:PRIMARY> rs.status()
- 配置分片副本集
3.1 设置第一个分片副本集
设置第一个分片副本集(三台机器均操作)
配置文件
[root@t1 ~]# vim /app/mongodb/conf/shard1.conf
#配置文件内容
#——————————————–
pidfilepath = /app/mongodb/shard1/log/shard1.pid
dbpath = /app/mongodb/shard1/data
logpath = /app/mongodb/shard1/log/shard1.log
logappend = true
bind_ip = 0.0.0.0
port = 27001
fork = true
#副本集名称
replSet = shard1
#declare this is a shard db of a cluster;
shardsvr = true
#设置最大连接数
maxConns = 20000
启动三台服务器的shard1 server
[root@t1 ~]# /app/mongodb/bin/mongod -f /app/mongodb/conf/shard1.conf
about to fork child process, waiting until server is ready for connections.
forked process: 13708
child process started successfully, parent exiting
登陆任意一台服务器，初始化副本集(除了192.168.47.190）
连接 MongoDB
[root@t1 ~]# /app/mongodb/bin/mongod -f /app/mongodb/conf/shard1.conf
#连接数据库
[root@t1 ~]# /app/mongodb/bin/mongo --port 27001
#使用admin数据库
use admin
#定义副本集配置
config = {
_id : "shard1",
members : [
{_id : 0, host : "192.168.47.188:27001" },
{_id : 1, host : "192.168.47.189:27001" },
{_id : 2, host : "192.168.47.190:27001" , arbiterOnly: true }
]
}
#初始化副本集配置
rs.initiate(config)
响应内容如下
> use admin
switched to db admin
> config = {
... _id : "shard1",
... members : [
... {_id : 0, host : "192.168.47.188:27001" },
... {_id : 1, host : "192.168.47.189:27001" },
... {_id : 2, host : "192.168.47.190:27001" , arbiterOnly: true }
... ]
... }
{
"_id" : "shard1",
"members" : [
{
"_id" : 0,
"host" : "192.168.47.188:27001"
},
{
"_id" : 1,
"host" : "192.168.47.189:27001"
},
{
"_id" : 2,
"host" : "192.168.47.190:27001",
"arbiterOnly" : true
}
]
}
> rs.initiate(config)
此时会发现终端上的输出已经有了变化。
//从单个一个
>
//变成了
shard1:SECONDARY>
//查询状态
shard1:SECONDARY> rs.status()
3.2 设置第二个分片副本集
设置第二个分片副本集（三台）
配置文件
[root@t1 ~]# vim /app/mongodb/conf/shard2.conf
#配置文件内容
#——————————————–
pidfilepath = /app/mongodb/shard2/log/shard2.pid
dbpath = /app/mongodb/shard2/data
logpath = /app/mongodb/shard2/log/shard2.log
logappend = true
bind_ip = 0.0.0.0
port = 27002
fork = true
#副本集名称
replSet=shard2
#declare this is a shard db of a cluster;
shardsvr = true
#设置最大连接数
maxConns=20000
#启动三台服务器的shard2 server
[root@t1 ~]# /app/mongodb/bin/mongod -f /app/mongodb/conf/shard2.conf
about to fork child process, waiting until server is ready for connections.
forked process: 14533
child process started successfully, parent exiting
登陆任意一台服务器，初始化副本集(除了192.168.47.188）
连接 MongoDB
#连接 MongoDB
[root@t1 ~]# /app/mongodb/bin/mongo --port 27002
#使用admin数据库
use admin
#定义副本集配置
config = {
_id : "shard2",
members : [
{_id : 0, host : "192.168.47.188:27002" , arbiterOnly: true },
{_id : 1, host : "192.168.47.189:27002" },
{_id : 2, host : "192.168.47.190:27002" }
]
}
#初始化副本集配置
rs.initiate(config)
3.3 设置第三个分片副本集
设置第三个分片副本集（三台）
配置文件
[root@t1 ~]# vim /app/mongodb/conf/shard3.conf
#配置文件内容
#——————————————–
pidfilepath = /app/mongodb/shard3/log/shard3.pid
dbpath = /app/mongodb/shard3/data
logpath = /app/mongodb/shard3/log/shard3.log
logappend = true
bind_ip = 0.0.0.0
port = 27003
fork = true
replSet=shard3
shardsvr = true
maxConns=20000
#启动三台服务器的shard3 server
[root@t1 ~]# /app/mongodb/bin/mongod -f /app/mongodb/conf/shard3.conf
about to fork child process, waiting until server is ready for connections.
forked process: 15799
child process started successfully, parent exiting
登陆任意一台服务器，初始化副本集(除了192.168.47.189）
连接 MongoDB
#连接 MongoDB
[root@t1 ~]# /app/mongodb/bin/mongo --port 27003
#使用admin数据库
use admin
#定义副本集配置
config = {
_id : "shard3",
members : [
{_id : 0, host : "192.168.47.188:27003" },
{_id : 1, host : "192.168.47.189:27003" , arbiterOnly: true},
{_id : 2, host : "192.168.47.190:27003" }
]
}
#初始化副本集配置
rs.initiate(config)
响应内容如下
> use admin
switched to db admin
> config = {
... _id : "shard3",
... members : [
... {_id : 0, host : "192.168.47.188:27003" },
... {_id : 1, host : "192.168.47.189:27003" , arbiterOnly: true},
... {_id : 2, host : "192.168.47.190:27003" }
... ]
... }
{
"_id" : "shard3",
"members" : [
{
"_id" : 0,
"host" : "192.168.47.188:27003"
},
{
"_id" : 1,
"host" : "192.168.47.189:27003",
"arbiterOnly" : true
},
{
"_id" : 2,
"host" : "192.168.47.190:27003"
}
]
}
> rs.initiate(config)
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1596360929, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1596360929, 1)
}
shard3:OTHER>
3.4 配置路由服务器 mongos
先启动配置服务器和分片服务器,后启动路由实例启动路由实例:（三台机器）
vim /app/mongodb/conf/mongos.conf
#内容
pidfilepath = /app/mongodb/mongos/log/mongos.pid
logpath = /app/mongodb/mongos/log/mongos.log
logappend = true
bind_ip = 0.0.0.0
port = 20000
fork = true
#监听的配置服务器,只能有1个或者3个 configs为配置服务器的副本集名字
configdb = configs/192.168.47.188:21000,192.168.47.189:21000,192.168.47.190:21000
#设置最大连接数
maxConns = 20000
启动三台服务器的mongos server
[root@t3 ~]# mkdir -p /app/mongodb/mongos/log
[root@t3 logs]# /app/mongodb/bin/mongos -f /app/mongodb/conf/mongos.conf
about to fork child process, waiting until server is ready for connections.
forked process: 9226
child process started successfully, parent exiting
4. 串联路由服务器
目前搭建了mongodb配置服务器、路由服务器，各个分片服务器，不过应用程序连接到mongos路由服务器并不能使用分片机制，还需要在程序里设置分片配置，让分片生效。
登陆任意一台mongos
[root@t1 conf]# /app/mongodb/bin/mongo --port 20000
#使用admin数据库
use admin
#串联路由服务器与分配副本集
sh.addShard("shard1/192.168.47.188:27001,192.168.47.189:27001,192.168.47.190:27001");
sh.addShard("shard2/192.168.47.188:27002,192.168.47.189:27002,192.168.47.190:27002");
sh.addShard("shard3/192.168.47.188:27003,192.168.47.189:27003,192.168.47.190:27003");
#查看集群状态
sh.status()
响应内容如下
mongos> use admin
switched to db admin
mongos> sh.addShard("shard1/192.168.47.188:27001,192.168.47.189:27001,192.168.47.190:27001");
{
"shardAdded" : "shard1",
"ok" : 1,
"operationTime" : Timestamp(1596361773, 6),
"$clusterTime" : {
"clusterTime" : Timestamp(1596361773, 6),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
mongos> sh.addShard("shard2/192.168.47.188:27002,192.168.47.189:27002,192.168.47.190:27002");
{
"shardAdded" : "shard2",
"ok" : 1,
"operationTime" : Timestamp(1596361780, 4),
"$clusterTime" : {
"clusterTime" : Timestamp(1596361780, 4),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
mongos> sh.addShard("shard3/192.168.47.188:27003,192.168.47.189:27003,192.168.47.190:27003");
{
"shardAdded" : "shard3",
"ok" : 1,
"operationTime" : Timestamp(1596361785, 2),
"$clusterTime" : {
"clusterTime" : Timestamp(1596361785, 2),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
mongos> sh.status()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"minCompatibleVersion" : 5,
"currentVersion" : 6,
"clusterId" : ObjectId("5f267c56fa6ddb9a93f6d800")
}
shards:
{ "_id" : "shard1", "host" : "shard1/192.168.47.188:27001,192.168.47.189:27001", "state" : 1 }
{ "_id" : "shard2", "host" : "shard2/192.168.47.189:27002,192.168.47.190:27002", "state" : 1 }
{ "_id" : "shard3", "host" : "shard3/192.168.47.188:27003,192.168.47.190:27003", "state" : 1 }
active mongoses:
"4.2.1" : 3
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:
{ "_id" : "config", "primary" : "config", "partitioned" : true }
config.system.sessions
shard key: { "_id" : 1 }
unique: false
balancing: true
chunks:
shard1 1
{ "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : shard1 Timestamp(1, 0)
5. 启用集合分片生效
目前配置服务、路由服务、分片服务、副本集服务都已经串联起来了，但我们的目的是希望插入数据，数据能够自动分片。连接在mongos上，准备让指定的数据库、指定的集合分片生效。
登陆任意一台mongos
[root@t1 ~]# /app/mongodb/bin/mongo --port 20000
#使用admin数据库
use admin
指定testdb分片生效
mongos> db.runCommand( { enablesharding :"testdb"});
或
mongos> sh.enablesharding("testdb")
mongos> db.runCommand( { enablesharding :"testdb"});
{
"ok" : 1,
"operationTime" : Timestamp(1596362245, 4),
"$clusterTime" : {
"clusterTime" : Timestamp(1596362245, 4),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
指定数据库里需要分片的集合和片键，哈希name分片
db.runCommand( { shardcollection : "testdb.table1",key : {"name": "hashed"} } );
或
mongos> sh.shardcollection("testdb.table1", {"name": "hashed"})
mongos> db.runCommand( { shardcollection : "testdb.table1",key : {"name": "hashed"} } );
{
"collectionsharded" : "testdb.table1",
"collectionUUID" : UUID("15567b49-f3c4-4ebb-a08f-62afe78da4e6"),
"ok" : 1,
"operationTime" : Timestamp(1596362380, 39),
"$clusterTime" : {
"clusterTime" : Timestamp(1596362380, 39),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
六、测试
# 任意一节点操作
mongo --port 20000
use admin
db.runCommand( { enablesharding : "testdb1"});
db.runCommand( { shardcollection : "testdb1.tab1",key : {id: 1} } )
exit
# 创建一个testdb1库，指定该库分片
# 分配testdb1库的需要分片的集合和键
# 任意一节点操作
mongo 127.0.0.1:20000
use testdb1;
for(var i=1;i<=100;i++) db.tab1.save({id:i,"test1":"testval1"});
exit
# 任意一节点操作
mongo 127.0.0.1:20000
use testdb1;
db.tab1.stats();
exit
# 使用testdb1库
# 循环插入数据到testdb1库的tab1集合中的键id中
# 该库对应的该集合对应的该键被设置成了分片
七、启动
启动
mongodb的启动顺序是，先启动配置服务器，在启动分片，最后启动mongos.
mongod -f /app/mongodb/conf/config.conf
mongod -f /app/mongodb/conf/shard1.conf
mongod -f /app/mongodb/conf/shard2.conf
mongod -f /app/mongodb/conf/shard3.conf
mongod -f /app/mongodb/conf/mongos.conf
关闭时，直接killall杀掉所有进程
killall mongod
killall mongos
参考：https://www.jianshu.com/p/e7e70ca7c7e5
可能遇到的问题：
MongoDB Could not find host matching read preference { mode: “primary” } for set shard1解决方案：https://blog.csdn.net/qq_39045558/article/details/111867459
四，mongodb集群版（主从 + 分片）开启认证模式（TODO）
五，mongodb集群版（主从）搭建
搭建MongoDB一主二从的架构（副本集）可以按照以下步骤进行：
1. 安装MongoDB
（省略）
2. 配置MongoDB服务
在每台机器上编辑MongoDB的配置文件（通常位于/etc/mongod.conf），添加以下内容：
replication:
replSetName: "myReplSet" # 设置副本集名称
3. 启动MongoDB服务
在所有三台机器上启动MongoDB服务：
sudo systemctl restart mongod
4. 初始化副本集
连接到主节点的MongoDB实例，初始化副本集：
mongo
rs.initiate({
_id: "myReplSet",
members: [
{ _id: 0, host: "primary_host:27017" }, # 主节点
{ _id: 1, host: "secondary1_host:27017" }, # 从节点1
{ _id: 2, host: "secondary2_host:27017" } # 从节点2
]
})
5. 验证副本集状态
在主节点的MongoDB shell中输入以下命令，检查副本集的状态：
rs.status()
如果一切顺利，你将看到包含主节点和从节点的状态信息。
6. 测试数据同步
在主节点上创建一些数据，然后在从节点上检查数据是否同步：
use testdb
db.createCollection("test")
db.test.insert({id:1})
在从节点上，使用以下命令查看数据是否同步：
rs.secondaryOk()
use testdb
db.test.find()
通过以上步骤，你可以成功搭建一个MongoDB一主二从的架构。
六，mongodb集群版（主从）开启认证模式
对于一个只有一主二从的MongoDB副本集（没有分片），开启认证模式的步骤相对简单。以下是详细步骤：
1. 创建密钥文件
在所有服务器上创建密钥文件，并确保所有服务器上的密钥文件内容一致。
openssl rand -base64 756 > keyfile
chmod 400 keyfile
然后将密钥文件分发到其他两台服务器上，确保路径一致。
2. 修改配置文件
在所有MongoDB实例的配置文件中添加密钥文件和认证相关配置。
假设你的配置文件名为 mongod.conf，内容如下：
# mongod.conf
# for documentation of all options, see:
# http://docs.mongodb.org/manual/reference/configuration-options/
# Where and how to store data.
storage:
dbPath: /var/lib/mongodb
journal:
enabled: true
# where to write logging data.
systemLog:
destination: file
logAppend: true
path: /var/log/mongodb/mongod.log
# network interfaces
net:
port: 27017
bindIp: 0.0.0.0
# how the process runs
processManagement:
timeZoneInfo: /usr/share/zoneinfo
# replication
replication:
replSetName: myReplSet
# security
security:
keyFile: /path/to/keyfile
authorization: enabled
keyFile：指定密钥文件的路径。authorization：启用认证。
3. 重启MongoDB服务
在所有服务器上重启MongoDB服务，使配置生效。
sudo systemctl restart mongod
或者，如果你使用的是其他启动方式，确保按照相应的方式重启服务。
4. 创建管理员用户
连接到主节点，创建管理员用户。
mongosh --port 27017
use admin
db.createUser({user: "myroot", pwd: "123456", roles: ["root"]})
5. 配置客户端认证
在客户端连接配置中添加用户名和密码，以进行身份认证。
使用命令行连接
mongosh -u myroot -p 123456 --authenticationDatabase admin --host <primary_host>:27017
在应用程序中配置
如果你使用的是MongoDB的驱动程序，确保在连接字符串中添加用户名和密码，例如：
const { MongoClient } = require('mongodb');
const uri = "mongodb://myroot:123456@<primary_host>:27017/?authSource=admin";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
async function run() {
try {
await client.connect();
console.log("Connected successfully to server");
} finally {
await client.close();
}
}
run().catch(console.dir);
6. 验证配置
连接到MongoDB实例，验证认证是否生效。
mongosh -u myroot -p 123456 --authenticationDatabase admin --host <primary_host>:27017
use admin
db.auth("myroot", "123456")
如果认证成功，你将能够正常访问数据库。
注意事项
- 密钥文件路径：确保所有服务器上的密钥文件路径一致，并且文件权限为
400。 - 配置文件路径：确保配置文件路径正确，并且所有服务器上的配置文件内容一致。
- 网络问题：确保所有服务器之间网络畅通，能够相互访问。
通过以上步骤，你可以为MongoDB副本集开启认证模式，确保只有通过身份验证的用户才能访问数据库。
七，Mongodb常用sql
MongoDB 是一个基于文档的 NoSQL 数据库，它使用 BSON 格式存储数据，而不是传统的 SQL 数据库所使用的表格结构。因此，MongoDB 的查询语言与 SQL 有所不同。尽管如此，MongoDB 提供了强大的查询功能，能够满足大多数数据操作需求。以下是一些常用的 MongoDB 查询和操作示例，类似于 SQL 的功能。
创建数据库
use myDatabase
查看所有数据库
show dbs
切换到数据库
use myDatabase
删除数据库
db.dropDatabase()
------------------------------------------------------------------------------------------------
创建集合
db.createCollection("myCollection")
查看所有集合
show collections
删除集合
db.myCollection.drop()
------------------------------------------------------------------------------------------------
插入单个文档
db.myCollection.insertOne({ name: "Alice", age: 25, city: "New York" })
插入多个文档
db.myCollection.insertMany([
{ name: "Bob", age: 30, city: "Los Angeles" },
{ name: "Charlie", age: 35, city: "Chicago" }
])
查询带条件的文档
db.myCollection.find({ age: { $gt: 30 } }) // 查询年龄大于30的文档
查询特定字段
db.myCollection.find({}, { name: 1, age: 1 }) // 只返回 name 和 age 字段
使用正则表达式查询
db.myCollection.find({ name: { $regex: /^A/ } }) // 查询名字以"A"开头的文档
查询并排序
db.myCollection.find().sort({ age: 1 }) // 按年龄升序排序
查询并限制返回数量
db.myCollection.find().limit(5) // 只返回前5个文档
更新单个文档
db.myCollection.updateOne(
{ name: "Alice" }, // 查询条件
{ $set: { age: 26 } } // 更新操作
)
更新多个文档
db.myCollection.updateMany(
{ city: "New York" },
{ $set: { city: "NYC" } }
)
替换文档
db.myCollection.replaceOne(
{ name: "Bob" },
{ name: "Robert", age: 31, city: "Los Angeles" }
)
删除单个文档
db.myCollection.deleteOne({ name: "Charlie" })
删除多个文档
db.myCollection.deleteMany({ age: { $lt: 30 } }) // 删除年龄小于30的文档
基本聚合查询
db.myCollection.aggregate([
{ $match: { age: { $gt: 20 } } }, // 筛选条件
{ $group: { _id: "$city", averageAge: { $avg: "$age" } } } // 按城市分组并计算平均年龄
])
------------------------------------------------------------------------------------------------
创建索引
db.myCollection.createIndex({ name: 1 }) // 为 name 字段创建升序索引
查看索引
db.myCollection.getIndexes()
删除索引
db.myCollection.dropIndex("indexName") // 删除指定名称的索引
计数文档数量
db.myCollection.countDocuments() // 计算集合中的文档数量
检查文档是否存在
db.myCollection.findOne({ name: "Alice" }) !== null // 检查文档是否存在
------------------------------------------------------------------------------------------------
开始事务
const session = db.getMongo().startSession();
session.startTransaction();
提交事务
session.commitTransaction();
取消事务
session.abortTransaction();
------------------------------------------------------------------------------------------------
导入数据
mongoimport --db myDatabase --collection myCollection --file data.json
导出数据
mongoexport --db myDatabase --collection myCollection --out data.json
导出csv文件
mongoexport -d myDB -c user -f _id,name,password,adress --csv -o ./user.csv
导出csv文件时并筛选数据
mongoexport -d myDB -c user -q '{"name": "xxx"}' -f _id,name,password,adress --csv -o /home/user.csv
-------------------------------------------
个性签名：独学而无友，则孤陋而寡闻。做一个灵魂有趣的人！
如果觉得这篇文章对你有小小的帮助的话，记得在右下角点个“推荐”哦，博主在此感谢！
万水千山总是情，打赏一分行不行，所以如果你心情还比较高兴，也是可以扫码打赏博主，哈哈哈(っ•̀ω•́)っ✎⁾⁾！
浙公网安备 33010602011771号