数据库-redis与mongo

03 Redis数据库服务应用

Redis缓存型数据库服务：读取数据/存储数据，都会在内存空间进行操作（加快数据库数据读写效率）

作为MySQL数据库服务缓存设备，将不重要数据会放在Redis中进行处理（减少MySQL并发访问压力）
还可以将Redis服务做消息队列进行应用（消息队列）

1) Redis服务如何安装部署(209)

步骤一：安装Redis服务程序

bash 复制代码

# 下载Redis软件包为源码包
wget https://download.redis.io/releases/redis-6.2.10.tar.gz

cd /usr/local
tar xf redis-6.2.10.tar.gz
ln -s redis-6.2.10 redis

# 安装编译依赖
yum install -y gcc automake autoconf libtool make

# 编译安装
cd redis
make

步骤二：对Redis服务进行配置

bash 复制代码

# 配置环境变量
vim /etc/profile
# 添加以下内容
export PATH=/usr/local/mysql/bin:/usr/local/redis/src:$PATH

# 加载配置
source /etc/profile

# 测试启动
redis-server &

Redis服务配置文件编写：

bash 复制代码

# 创建数据目录
mkdir -p /data/6379

# 创建配置文件
cat >/data/6379/redis.conf<<EOF
daemonize yes
-- 表示定义服务程序在后台以守护进程方式运行
port 6379
-- 表示定义服务的默认端口
logfile /data/6379/redis.log
-- 表示服务运行日志存放路径
dir /data/6379
-- 表示定义数据目录路径，用于持久化应用时存储数据
dbfilename dump.rdb
-- 表示持久化存储的数据文件名称(RDB方式完成Redis持久化)
EOF

或者使用简化方式：

bash 复制代码

cat >/data/6379/redis.conf<<EOF
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename dump.rdb
EOF

步骤三：启动运行Redis服务

bash 复制代码

redis-server /data/6379/redis.conf

测试Redis：

bash 复制代码

[root@oldboy-db01 redis]# redis-cli
127.0.0.1:6379> set username xiaoA
OK
127.0.0.1:6379> get username
"xiaoA"

2) Redis服务基础管理

安全功能配置（远程功能）

bash 复制代码

vim /data/6379/redis.conf
# 添加或修改以下内容
bind 10.0.0.209 127.0.0.1
requirepass 123456

注意：目前只有209这台机器配置了Redis，所以自己连自己

远程连接测试：

bash 复制代码

# 实现远程管理
redis-cli -h 10.0.0.209 -p 6379

# 实现远程登录时，做密码验证
redis-cli -h 10.0.0.209 -p 6379 -a 123456

# 进行登录验证
auth 密码信息

数据库持久化功能配置

RDB持久化存储 ：

可以在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）
缺陷：Redis中的数据信息，不会实现实时存储

RDB存储配置（默认）：

自动保存配置信息：

bash 复制代码

"save"
"3600 1 300 100 60 10000"   # 触发RDB备份时间和存储量信息

60（1分钟）10000（key-value数据量）→ 自动触发RDB快照保存机制
300（5分钟）100（key-value数据量）→ 自动触发RDB快照保存机制
3600（1小时）1（key-value数据量）→ 自动触发RDB快照保存机制

意思：在3600秒（1小时）内，如果至少有1个键发生变化，则触发一次快照保存。

手动保存配置信息：

bash 复制代码

save 命令     # 立刻马上将Redis中数据做保存

应用场景：

实现主从同步过程，可以应用RDB文件，将主库数据迁移恢复到从节点

优点：

主从复制：正如你所说，主节点首次同步数据给从节点时，会先生成一个RDB文件，然后传输给从节点。从节点加载这个RDB文件来完成初始数据的同步

缺点：

可能丢失数据：这是最大的问题。如果配置为每5分钟保存一次，那么一旦服务器宕机，你会丢失最近5分钟内的数据。

AOF持久化存储 ：

会记录服务器执行的所有写操作命令，并在服务器启动时，通过重新执行这些命令来还原数据集（类似binlog）
缺陷：恢复加载持久化数据信息会比较慢，AOF持久化存储数据的文件，数据量较大

AOF存储配置（做设置）：

bash 复制代码

appendonly yes    # 开启AOF持久化存储功能

appendfsync配置（AOF文件记录Redis操作记录方式）：

always：每完成一个操作都会记录 → 安全
everysec：每间隔一秒钟做一次记录 → 推荐
no：实现数据信息持久化保存，由系统进行控制 → 性能

应用场景：

可以实现数据信息恢复操作

3) Redis数据库主从架构搭建

作用：

可以实现缓存数据信息备份
可以实现缓存数据库服务高可用（哨兵服务）
可以实现缓存数据库服务负载均衡（集群服务）

原理：

在从库上进行主从配置（slaveof 主库地址主库端口），然后会在配置之后向主库发送SYNC信息
主库收到SYNC请求建立连接消息后，会对请求客户端做验证
主库对客户端的请求验证通过，会立即触发BGSAVE（立刻进行RDB文件保存），将主库RDB文件信息发送给从节点
从库会加载RDB文件数据，快速恢复主库中的缓存数据信息
主库会将新增数据（key-values），不断同步传输给从节点

实践：

实现主从同步命令：

slaveof 主数据库地址主数据库端口 → Redis 5.0.0版本之前实现主从方式
replicaof 主数据库地址主机数据库端口 → Redis 5.0.0版本之后实现主从方式

步骤一：准备主从Redis数据库服务（多实例）都在同一台节点实现

bash 复制代码

# 创建数据目录
mkdir -p /data/638{0..2}        # 51 redis 6380, 52 redis 6381, 6382

创建主库配置文件（6380）：

bash 复制代码

cat >>/data/6380/redis.conf <<EOF
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
requirepass 123
masterauth 123
bind （主库IP地址） 127.0.0.1
EOF

创建从库配置文件（6381）：

bash 复制代码

cat >>/data/6381/redis.conf <<EOF
port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
requirepass 123
masterauth 123
bind 从库IP地址 127.0.0.1
EOF

创建从库配置文件（6382）：

bash 复制代码

cat >>/data/6382/redis.conf <<EOF
port 6382
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
requirepass 123
masterauth 123
bind 从库IP地址 127.0.0.1
EOF

启动Redis实例：

bash 复制代码

redis-server /data/6380/redis.conf
redis-server /data/6381/redis.conf
redis-server /data/6382/redis.conf

步骤二：实现Redis服务主从同步

bash 复制代码

# 6381实例从库做主从连接配置
redis-cli -p 6381 -a 123 slaveof 127.0.0.1 6380

# 6382实例从库做主从连接配置
redis-cli -p 6382 -a 123 slaveof 127.0.0.1 6380

步骤三：测试主从数据是否同步

bash 复制代码

# 在Redis主库上，确认主从是否建立成功
redis-cli -p 6380 -a 123 info replication

# 输出示例：
# Replication
# role:master
# connected_slaves:2
# slave0:ip=127.0.0.1,port=6381,state=online,offset=154,lag=1
# slave1:ip=127.0.0.1,port=6382,state=online,offset=154,lag=1
# master_repl_offset:154

# 在Redis从库上，确认主从是否建立成功
redis-cli -p 6381 -a 123 info replication

# 输出示例：
# Replication
# role:slave
# master_host:127.0.0.1
# master_port:6380
# master_link_status:up

步骤四：停止主从同步数据

bash 复制代码

[root@master ~]# redis-cli -p 6382 -a 123 slaveof no one
# 或者
[root@master ~]# redis-cli -p 6382 -a 123 replicaof no one

4) Redis数据库高可用架构搭建

实践：

步骤一：搭建Redis主从架构环境（省略）

步骤二：搭建Redis哨兵服务环境（只需在主库配置哨兵）

bash 复制代码

# 创建哨兵目录
mkdir /data/26380

# 创建哨兵配置文件
cat >/data/26380/sentinel.conf<<EOF
port 26380
dir "/data/26380"
daemonize yes
-- 实现哨兵服务可以守护进程方式运行
sentinel monitor mymaster 127.0.0.1 6380 1
-- 监控集群架构中主库服务状态（数值1表示发现主库异常的票数，当发现有1票提出主库宕机，就立刻切换）
sentinel down-after-milliseconds mymaster 5000
-- 当主库进行监控心跳检测时，如果5s内没有反馈，就认为主库服务已经宕机
sentinel auth-pass mymaster 123
-- 设置连接主库服务的认证密码信息
EOF

或者使用简化方式：

bash 复制代码

cat >/data/26380/sentinel.conf<<EOF
port 26380
dir "/data/26380"
daemonize yes
sentinel monitor mymaster 127.0.0.1 6380 1
sentinel down-after-milliseconds mymaster 5000
sentinel auth-pass mymaster 123
EOF

启动哨兵服务：

bash 复制代码

redis-sentinel /data/26380/sentinel.conf &>/tmp/sentinel.log

步骤三：进行高可用切换测试

bash 复制代码

# 关闭主库
redis-cli -p 6380 -a 123 shutdown

# 检查新的主库
redis-cli -p 6381 -a 123 info replication

# 输出示例：
# Replication
# role:master
# connected_slaves:1
# slave0:ip=127.0.0.1,port=6382,state=online,offset=10014,lag=1

步骤四：恢复原来的主节点并重新加入集群

bash 复制代码

# 1. 重新启动原主节点6380
redis-server /data/6380/redis.conf

# 2. 检查节点状态（此时6380会自动成为从节点）
redis-cli -p 6380 -a 123 info replication
# 应该显示为从节点，连接到当前的主节点

5) Redis服务集群架构搭建

实践：

步骤一：创建Redis集群节点服务

bash 复制代码

# 创建数据目录
mkdir /data/700{0..7}

创建第一个节点配置文件（7000）：

bash 复制代码

cat >/data/7000/redis.conf <<EOF
port 7000
daemonize yes
pidfile /data/7000/redis.pid
loglevel notice
logfile "/data/7000/redis.log"
dbfilename dump.rdb
dir /data/7000
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

实例01节点配置信息（主库，7001）：

bash 复制代码

cat >/data/7001/redis.conf <<EOF
port 7001
daemonize yes
pidfile /data/7001/redis.pid
loglevel notice
logfile "/data/7001/redis.log"
dbfilename dump.rdb
dir /data/7001
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

实例02节点配置信息（主库，7002）：

bash 复制代码

cat >/data/7002/redis.conf <<EOF
port 7002
daemonize yes
pidfile /data/7002/redis.pid
loglevel notice
logfile "/data/7002/redis.log"
dbfilename dump.rdb
dir /data/7002
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

实例03节点配置信息（主库，7003）：

bash 复制代码

cat >/data/7003/redis.conf <<EOF
port 7003
daemonize yes
pidfile /data/7003/redis.pid
loglevel notice
logfile "/data/7003/redis.log"
dbfilename dump.rdb
dir /data/7003
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

实例04节点配置信息（从库，7004）：

bash 复制代码

cat >/data/7004/redis.conf <<EOF
port 7004
daemonize yes
pidfile /data/7004/redis.pid
loglevel notice
logfile "/data/7004/redis.log"
dbfilename dump.rdb
dir /data/7004
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

实例05节点配置信息（从库，7005）：

bash 复制代码

cat >/data/7005/redis.conf <<EOF
port 7005
daemonize yes
pidfile /data/7005/redis.pid
loglevel notice
logfile "/data/7005/redis.log"
dbfilename dump.rdb
dir /data/7005
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

启动所有Redis实例：

bash 复制代码

redis-server /data/7000/redis.conf
redis-server /data/7001/redis.conf
redis-server /data/7002/redis.conf
redis-server /data/7003/redis.conf
redis-server /data/7004/redis.conf
redis-server /data/7005/redis.conf

步骤二：构建集群环境

bash 复制代码

# 创建3主3从集群（--cluster-replicas 1表示每个主节点有1个从节点）
redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 --cluster-replicas 1

查看集群节点信息：

bash 复制代码

# 查看主节点信息
redis-cli -p 7001 cluster nodes | grep master

# 输出示例：
# 547891556922d36eeb7d2422ab7c30590e512c62 127.0.0.1:7001@17001 myself,master - 0 1756206444000 2 connected 5461-10922
# 05355e5799d2ee9f3a65db170947b85bdc7dc3ad 127.0.0.1:7000@17000 master - 0 1756206444486 1 connected 0-5460
# 83de9d92a3c80f16cf3c62a7c925b66cc43c2c16 127.0.0.1:7002@17002 master - 0 1756206445000 3 connected 10923-16383

# 查看从节点信息
redis-cli -p 7001 cluster nodes|grep slave

# 输出示例：
# 47416d1507deea65d85cf14682003f1dd44cbe6d 127.0.0.1:7004@17004 slave 547891556922d36eeb7d2422ab7c30590e512c62 0 1756206467627 2 connected
# b3f7755a4b77b2a28a032475ff07774f8a9f37bd 127.0.0.1:7003@17003 slave 05355e5799d2ee9f3a65db170947b85bdc7dc3ad 0 1756206466520 1 connected
# 4048ea4c7e9fce254042afbdf199193dacc7bf1f 127.0.0.1:7005@17005 slave 83de9d92a3c80f16cf3c62a7c925b66cc43c2c16 0 1756206467000 3 connected

步骤三：日常集群维护管理

添加新的集群节点：

1）创建新的Redis集群节点实例（7006-主，7007-从）

bash 复制代码

# 创建7006主节点配置文件
cat >/data/7006/redis.conf <<EOF
port 7006
daemonize yes
pidfile /data/7006/redis.pid
loglevel notice
logfile "/data/7006/redis.log"
dbfilename dump.rdb
dir /data/7006
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

# 创建7007从节点配置文件
cat >/data/7007/redis.conf <<EOF
port 7007
daemonize yes
pidfile /data/7007/redis.pid
loglevel notice
logfile "/data/7007/redis.log"
dbfilename dump.rdb
dir /data/7007
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

# 启动实例
redis-server /data/7006/redis.conf
redis-server /data/7007/redis.conf

2）添加新的Redis实例节点

bash 复制代码

# 添加主节点
redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000
# -- 添加新的节点到集群中（127.0.0.1:7000：只是指定一个集群中的任意节点作为入口点，Redis会通过这个节点发现整个集群拓扑）

给新节点分配槽位：

bash 复制代码

redis-cli --cluster reshard 127.0.0.1:7000

# 交互式输出：
# How many slots do you want to move (from 1 to 16384)?  200
# 将多少槽位数量进行转移存储

# What is the receiving node ID?  [输入7006节点的ID]
# c1f9bdcc798562b84a1d3cbf3b165dd548da71fb 127.0.0.1:7006@17006 master - 0 1756206563238 0 connected
# 转移后槽位信息由哪个节点接收

# Please enter all the source node IDs.[输入移除卡槽的节点---]这里我用7001移除卡槽吧
# 从哪个原有集群节点移出槽位信息

# Type 'all' to use all the nodes as source nodes for the hash slots.
# Type 'done' once you entered all the source nodes IDs.
# Source node #1: all
# -- 所有集群节点都统一移出相应槽位信息
# ！all和done的区别，all是所有主节点平均抽取槽位，done是手动指定源节点抽取

查看所有节点的卡槽分布：

bash 复制代码

redis-cli --cluster check 127.0.0.1:7000

给新的节点分配存储缓存数据的槽位信息

bash 复制代码

# 添加从节点-----添加7007作为7006的从节点
redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7000 --cluster-slave --cluster-master-id c1f9bdcc798562b84a1d3cbf3b165dd548da71fb（7006的ID）

删除原有集群节点该如何操作：以删除7006主节点和7007从节点为例

删除主节点：

bash 复制代码

redis-cli --cluster reshard 127.0.0.1:7000
# -- 将删除节点槽位缓存数据移动给其他节点---把刚刚从7001移除来的的卡槽点再还给它

# 查看所有节点的卡槽分布：别忘记了7000代表是一个集群的入口而已
redis-cli --cluster check 127.0.0.1:7000

# 删除节点信息
redis-cli --cluster del-node 127.0.0.1:7006 c1f9bdcc798562b84a1d3cbf3b165dd548da71fb（7006的ID）

删除从节点（先清空卡槽）：

bash 复制代码

redis-cli --cluster del-node 127.0.0.1:7007 547891556922d36eeb7d2422ab7c30590e512c62（7007的ID）

02 MongoDB数据库服务应用

1) 安装部署MongoDB软件程序

步骤一：下载安装MongoDB软件

bash 复制代码

# 配置透明大页（优化性能）
vi /etc/rc.local
# 添加以下内容：
if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
echo never > /sys/kernel/mm/transparent_hugepage/enabled
fi
if test -f /sys/kernel/mm/transparent_hugepage/defrag; then
echo never > /sys/kernel/mm/transparent_hugepage/defrag
fi

# 使得配置信息生效
sh /etc/rc.local

安装MongoDB到/usr/local：

bash 复制代码

cd /usr/local/
tar xf mongodb-linux-x86_64-rhel70-4.2.24.tgz
ln -s mongodb-linux-x86_64-rhel70-4.2.24 mongodb

配置环境变量：

bash 复制代码

vim /etc/profile
# 添加
export PATH=/usr/local/mysql/bin:/usr/local/redis/src:/usr/local/mongodb/bin:$PATH

source /etc/profile

系统环境准备：

bash 复制代码

mkdir /mongodb/data -p
mkdir /mongodb/log/ -p
mkdir -p /mongodb/conf

启动MongoDB（启动命令参数）：

bash 复制代码

mongod --dbpath=/mongodb/data --logpath=/mongodb/log/mongodb.log --port=27017 --logappend --fork

验证端口：

bash 复制代码

netstat -lntup|grep mongod

编写MongoDB数据库配置文件，实现MongoDB数据库服务运行启动：

bash 复制代码

cat >/mongodb/conf/mongo.conf<<EOF
systemLog:
   destination: file
   path: "/mongodb/log/mongodb.log"   # 日志存储位置
   logAppend: true                    # 日志以追加模式记录
# 数据存储有关配置
storage:
   journal:
       enabled: true
   dbPath: "/mongodb/data"                     # 数据路径的位置
# 进程控制有关配置
processManagement:
   fork: true                                                 # 后台守护进程
   pidFilePath: <string>                             # pid文件的位置，一般不用配置，可以去掉这行，自动生成到data中
# 网络信息有关配置
net:
   port: 27017                                             # 端口号，默认不配置端口号，是27017
   bindIp: 192.168.30.101,127.0.0.1         # 监听地址
# 安全验证有关配置
security:
   authorization: enabled                         # 是否打开用户名密码验证
EOF

或者使用简化方式：

bash 复制代码

cat > /mongodb/conf/mongo.conf << 'EOF'
systemLog:
   destination: file
   path: "/mongodb/log/mongodb.log"
   logAppend: true
storage:
   journal:
       enabled: true
   dbPath: "/mongodb/data"
processManagement:
   fork: true
EOF

启动MongoDB：

bash 复制代码

mongod -f /mongodb/conf/mongo.conf
mongo

MongoDB命令行的操作：

bash 复制代码

# 执行MongoDB数据库客户端命令，可以进入到数据库服务中
show databases;
# 输出：
# admin   0.000GB
# config  0.000GB
# local   0.000GB

2) 如何管理MongoDB中的数据信息

库操作：

javascript 复制代码

// 创建数据库/切换数据库
use 库名

// 查看数据库
show databases;
// 或者
show dbs;

// 删除数据库
db.dropDatabase()

集合操作：

javascript 复制代码

// 创建集合操作
db.createCollection("集合名称");         // 示例：db.createCollection("t1")

// 查看集合操作
show tables

// 删除集合操作
db.t1.drop()

文档操作：

添加数据信息：

javascript 复制代码

db.集合名称.insert(json信息)
// 示例：
db.studen.insert({name:"xiaoA", age:18, gender:"m"})
db.studen.insert({id:2, name:"xiaoB", gender:"f"})

查看数据信息：

javascript 复制代码

db.集合名称.find()  // 相当于 select * from 表 -- 全表信息查询数据

// 过滤集合中数据信息
db.studen.find({name:"xiaoA"})
// 输出：{ "_id" : ObjectId("68ad5b76e35e679fb3e110d7"), "name" : "xiaoA", "age" : 18, "gender" : "m" }

// 格式化输出一行信息
db.studen.find({id:3}).pretty()

删除数据信息：

javascript 复制代码

db.studen.remove({})   // 将集合中数据清空

db.集合名称.remove({id:3})  // 将集合中id=3的数据行内容删除

数据库中数据信息操作方法：

javascript 复制代码

db.help()          // 展示MongoDB中所有对库或集合的操作函数
db.集合名称.help()  // 展示MongoDB中所有对集合或文档操作函数

3) MongoDB服务基础管理知识

如何实现用户管理

用户管理的前提：MongoDB配置文件有下面部分

yaml 复制代码

security:
  authorization: enabled

创建用户语句信息：

javascript 复制代码

db.createUser(
{
    user: "<name>",                 // 定义创建用户名
    pwd: "<cleartext password>",    // 定义用户密码信息
    roles: [                       // 定义用户权限信息
        { role: "<role>",
        db: "<database>" } | "<role>",
        ...
    ]
})

管理员用户：root角色拥有对所有数据库的完全权限，类似于Unix系统的root或MySQL的root。

javascript 复制代码

use admin
db.createUser(
{
       user: "xiaoA",
       pwd: "xiaoA123",
       roles: [ { role: "root", db: "admin" } ]
}
)

普通用户：首先使用管理员账号登录并切换到目标数据库

javascript 复制代码

use oldboy
db.createUser(
{
       user: "xiaoB",
       pwd: "xiaoB123",
       roles: [ { role: "read", db: "oldboy" } ]
}
)

查看创建用户信息：

javascript 复制代码

use admin
db.system.users.find().pretty()

删除已有用户信息：

javascript 复制代码

use admin
db.dropUser("xiaoB")
// 或者
db.system.users.remove({user:"xiaoB"})

使用创建用户登录管理数据库：

实现本地登录管理：

bash 复制代码

mongo -uxiaoA -pxiaoA123 admin  # 本地管理员登录
mongo -uxiaoB -pxiaoB123 oldboy # 普通用户登录

实现远程登录管理：

bash 复制代码

# 语法：mongo -u <用户名> -p <密码> <远程主机IP:端口>/<数据库> --authenticationDatabase <用户所在的数据库>

修改配置文件支持远程连接：

yaml 复制代码

net:
   port: 27017
   bindIp: 10.0.0.209,127.0.0.1     # 可以控制远程连接
security:
  authorization: enabled            # 可以控制远程连接/还可以限制不同角色用户权限

远程连接测试：

bash 复制代码

mongo -uxiaoA -pxiaoA123 10.0.0.209:27017/admin
# 注意：此时我只有209机器，即本机器安装了MongoDB，所以自己测试自己的远程登入

4) 利用MongoDB服务建立主从环境（副本集）

主从搭建过程：

步骤一：创建MongoDB数据库实例

bash 复制代码

mkdir -p /mongodb/28017/conf /mongodb/28017/data /mongodb/28017/log
mkdir -p /mongodb/28018/conf /mongodb/28018/data /mongodb/28018/log
mkdir -p /mongodb/28019/conf /mongodb/28019/data /mongodb/28019/log
mkdir -p /mongodb/28020/conf /mongodb/28020/data /mongodb/28020/log

创建第一个实例的配置文件（28017）：

bash 复制代码

cat > /mongodb/28017/conf/mongod.conf << EOF
systemLog:
   destination: file
   path: "/mongodb/28017/log/mongodb.log"
   logAppend: true
storage:
   journal:
       enabled: true
   dbPath: "/mongodb/28017/data"
   directoryPerDB: true
   #engine: wiredTiger
   wiredTiger:
        engineConfig:
             cacheSizeGB: 1
             directoryForIndexes: true
        collectionConfig:
             blockCompressor: zlib
        indexConfig:
             prefixCompression: true
processManagement:
   fork: true
net:
   port: 28017
   bindIp: 10.0.0.209,127.0.0.1
replication:
   oplogSizeMB: 2048           # 定义oplog日志存储量，实质是数据库服务的表的大小，因为同步用的日志存储在表中
   replSetName: my_repl        # 表示复制集的名称，要和后面创建的集群名称一致
# 表示设置复制集功能
EOF

复制配置文件到其他实例并修改端口：

bash 复制代码

\cp /mongodb/28017/conf/mongod.conf /mongodb/28018/conf/
\cp /mongodb/28017/conf/mongod.conf /mongodb/28019/conf/
\cp /mongodb/28017/conf/mongod.conf /mongodb/28020/conf/

sed -i 's#28017#28018#g' /mongodb/28018/conf/mongod.conf
sed -i 's#28017#28019#g' /mongodb/28019/conf/mongod.conf
sed -i 's#28017#28020#g' /mongodb/28020/conf/mongod.conf

启动所有MongoDB实例：

bash 复制代码

mongod -f /mongodb/28017/conf/mongod.conf
mongod -f /mongodb/28018/conf/mongod.conf
mongod -f /mongodb/28019/conf/mongod.conf
mongod -f /mongodb/28020/conf/mongod.conf

步骤二：创建主从同步架构

bash 复制代码

# 连接到其中一个实例
mongo --port 28019 admin
# 或者
mongo --host 10.0.0.209 --port 28019

在MongoDB客户端中配置副本集：

javascript 复制代码

config = {_id: 'my_repl', members: [
            {_id: 0, host: '10.0.0.209:28017'},
            {_id: 1, host: '10.0.0.209:28018'},
            {_id: 2, host: '10.0.0.209:28019', priority: 10}]
          };

// 设置优先级，更高的节点更易成为主节点----priority:10

// 初始化副本集
rs.initiate(config);

PS：MongoDB主从同步过程，默认选择主节点时，会根据节点优先级选择，默认所有节点优先级为1，优先级越大越会选择为主节点

查看副本集状态：

javascript 复制代码

rs.status()    // 详细查看副本集状态信息
rs.isMaster()  // 查看主节点详细信息
rs.conf()      // 查看副本集配置信息

步骤三：MongoDB副本集日常维护管理

副本集节点添加：

javascript 复制代码

rs.add("10.0.0.209:28020")

副本集节点调整：

javascript 复制代码

rs.remove("10.0.0.209:28020")

投票节点管理：

javascript 复制代码

// 3个主从节点，从节点异常，2个主从节点，需要投票节点
// 做投票节点添加
rs.addArb("10.0.0.209:28020")

// 做投票节点删除
rs.remove("192.168.30.101:28020")