NoSQL非关系型数据库

一、NoSQL

NoSQL，泛指非关系型的数据库。随着互联网[web2.0](https://baike.baidu.com/item/web2.0/97695)网站的兴起，传统的关系数据库在处理web2.0网站，特别是超大规模和高并发的[SNS](https://baike.baidu.com/item/SNS/10242)类型的web2.0纯[动态网](https://baike.baidu.com/item/动态网)站已经显得力不从心，出现了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，特别是大数据应用难题。

NoSQL基础含义：

NoSQL最常见的解释是“non-relational”， “Not Only SQL”也被很多人接受。NoSQL仅仅是一个概念，泛指非关系型的数据库，区别于关系数据库，它们不保证关系数据的ACID特性。NoSQL是一项全新的数据库革命性运动，其拥护者们提倡运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。

NoSQL有如下优点：易扩展，NoSQL数据库种类繁多，但是一个共同的特点都是去掉关系数据库的关系型特性。数据之间无关系，这样就非常容易扩展。无形之间也在架构的层面上带来了可扩展的能力。大数据量，高性能，NoSQL数据库都具有非常高的读写性能，尤其在大数据量下，同样表现优秀。这得益于它的无关系性，数据库的结构简单。

 NoSQL数据库分类和特点： 

分类相关产品应用场景数据模型优点缺点
键值数据库 Redis、Memcached、Riak 内容缓存，如会话、配置文件、参数等； 频繁读写、拥有简单数据模型的应用 <key,value> 键值对，通过散列表来实现 扩展性好，灵活性好，大量操作时性能高 数据无结构化，通常只被当做字符串或者二进制数据，只能通过键来查询值
列族数据库 Bigtable、HBase、Cassandra 分布式数据存储与管理 以列族式存储，将同一列数据存在一起 可扩展性强，查找速度快，复杂性低 功能局限，不支持事务的强一致性
文档数据库 MongoDB、CouchDB Web 应用，存储面向文档或类似半结构化的数据 <key,value> value 是 JSON 结构的文档 数据结构灵活，可以根据 value 构建索引 缺乏统一查询语法
图形数据库 Neo4j、InfoGrid 社交网络、推荐系统，专注构建关系图谱 图结构 支持复杂的图形算法 复杂性高，只能支持一定的数据规模

二、Memcached分布式内存缓存服务器

Memcached简介

Memcached是一个开源的、支持高性能的、高并发的分布式内存缓存系统。前三个字符单词Mem就是内存的意思，接下来后5个字符的单词Cache就是缓存的意思，最后一个d，是deamon的意思，代表服务器端守护进程模式服务。

服务端与客户端的区别

memcached是服务端下载的、memcache是客户端下载的。

Memcached的作用

通过在自身内存中缓存关系型数据库查询结果，来减少数据库自身访问的次数，以提高动态Web应用的速度、提高网站架构的并发能力和扩展性。

应用场景

例如：sns类网站、blog类网站、bbs类网站以及im后台服务。

Linux下安装Memcached

下载memcached

[root@memcached ~]# yum install -y memcached libmemcached libevent[root@memcached ~]# systemctl start memcached

解释：

libmemcached 是一个 memcached 的库，客户端库，C 和 C++ 语言实现的客户端库，具有低[内存占用率](https://baike.baidu.com/item/内存占用率/7797253)、[线程安全](https://baike.baidu.com/item/线程安全/9747724)、并提供对memcached功能的全面支持。

Libevent 是一个用[C语言](https://baike.baidu.com/item/C语言/105958)[编写](https://baike.baidu.com/item/编写/1517598)的、轻量级的开源高性能事件通知库

开启服务

[root@memcached ~]# systemctl start memcached

查看memcached运行状态

[root@memcached ~]# memcached-tool 127.0.0.1:11211 stats
...
#nc：ncat
[root@memcached ~]# yum install -y nc
[root@memcached ~]# echo stats |nc 127.0.0.1 11211
...
[root@memcached ~]# memstat --servers=127.0.0.1:11211
...

 memcached配置文件在这里vim /etc/sysconfig/memcached

Memcached命令

# 下载远程链接命令
[root@memcached ~]# telnet 127.0.0.1 11211
#连接memcached
[root@memcached ~]# telnet 127.0.0.1 11211
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
#命令解释
set foo 0 0 3         //保存命令
bar                    //数据
STORED                //结果
get foo                //取得命令
VALUE foo 0 3         //数据
END                    //结束行
quit                //退出

 储存命令

 set、add存储命令

set key flags exptime bytes [noreply]
value
    或
add key flags exptime bytes [noreply]
value

命令解释：

- key：键值key-value机构中的key，用于查找缓存值。
- flages：可以包括简直对的整形参数，客户机使用它储存关于键值对的额外信息。
- exptime：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
- bytes：在缓存中存储的字节数
- **noreply（可选）**： 该参数告知服务器不需要返回数据
- **value**：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）

例如：

set gm 0 900 9        //储存名gm、参数0、900秒、9个字节
gmgmgmgmg            //存储的信息（信息不能超过字节数要不就会报错）
STORED                //保存成功后输出。如果是ERROR：在保存失败后输出。

 replace修改存储信息命令

#add 储存数据
add new_two 0 900 5
mykey
STORED
#get 查询数据
get new_two 0 5
VALUE new_two 0 5
mykey
END
#replace 修改以存储的命令
replace new_two 0 900 10
mySQLNOSQL        
STORED
#get 查询数据
get new_two 0 10
VALUE new_two 0 10
mySQLNOSQL
END

append命令是在存储信息后加字符。

prepend命令是在存储信息前加字符。

CAS命令

cas key flags exptime bytes unique_cas_token [noreply]
value

命令解释：

- unique_cas_token：通过 gets 命令获取的一个唯一的64位值。

实例：

set tp 0 900 9
sdfstlsit
STORED
#想要使用CAS命令必须gets到8值、这个值是随机的。
gets tp 
VALUE tp 0 9 8
sdfstlsit
END

cas tp 0 9000 5 8
sjsow
STORED
#查看tp下的信息
get tp 0 8
VALUE tp 0 5
sjsow
END
get tp 0 5
VALUE tp 0 5
sjsow
END

 查找命令

get命令

add new_two 0 900 5
mykey
STORED
#多个可空格隔开
get new_two 0 5
VALUE new_two 0 5
mykey
END 

gets命令

set tp 0 900 9
sdfstlsit
STORED
#在使用gets命令的输出结果中，在最后一列的数字8代表了key为tp 的CAS令牌。
gets tp 
VALUE tp 0 9 8
sdfstlsit
END

 delete刪除命令

set tp 0 900 9
sdfstlsit
STORED

delete tp     
DELETED

  • DELETED：删除成功。

  • ERROR：语法错误或删除失败。

  • NOT_FOUND：key 不存在。

incr/decr命令

incr增加数值命令
set insall 0 900 2
10
STORED

get insall 0 2
VALUE insall 0 2
10
END

incr insall 5
15

get insall 0 2
VALUE insall 0 2
15
END
 decr减少数值命令
decr insall 10
5

get insall 0 2
VALUE insall 0 1
5
END

统计命令

stats统计命令

stats
STAT pid 2277
...
END
代码解释：

- **pid**： memcache服务器进程ID
- **uptime**：服务器已运行秒数
- **time**：服务器当前Unix时间戳
- **version**：memcache版本
- **pointer_size**：操作系统指针大小
- **rusage_user**：进程累计用户时间
- **rusage_system**：进程累计系统时间
- **curr_connections**：当前连接数量
- **total_connections**：Memcached运行以来连接总数
- **connection_structures**：Memcached分配的连接结构数量
- **cmd_get**：get命令请求次数
- **cmd_set**：set命令请求次数
- **cmd_flush**：flush命令请求次数
- **get_hits**：get命令命中次数
- **get_misses**：get命令未命中次数
- **delete_misses**：delete命令未命中次数
- **delete_hits**：delete命令命中次数
- **incr_misses**：incr命令未命中次数
- **incr_hits**：incr命令命中次数
- **decr_misses**：decr命令未命中次数
- **decr_hits**：decr命令命中次数
- **cas_misses**：cas命令未命中次数
- **cas_hits**：cas命令命中次数
- **cas_badval**：使用擦拭次数
- **auth_cmds**：认证命令处理的次数
- **auth_errors**：认证失败数目
- **bytes_read**：读取总字节数
- **bytes_written**：发送总字节数
- **limit_maxbytes**：分配的内存总大小（字节）
- **accepting_conns**：服务器是否达到过最大连接（0/1）
- **listen_disabled_num**：失效的监听数
- **threads**：当前线程数
- **conn_yields**：连接操作主动放弃数目
- **bytes**：当前存储占用的字节数
- **curr_items**：当前存储的数据总数
- **total_items**：启动以来存储的数据总数
- **evictions**：LRU释放的对象数目
- **reclaimed**：已过期的数据条目来存储新数据的数目
代码解释

stats items命令

命令用于显示各个 slab 中 item 的数目和存储时长(最后一次访问距离现在的秒数)。

stats items
...
END

stats slabs命令

命令用于显示各个slab的信息，包括chunk的大小、数目、使用情况等。

stats sizes命令

命令用于显示所有item的大小和个数。该信息返回两列，第一列是 item 的大小，第二列是 item 的个数。

flush_all命令

命令用于显示所有item的大小和个数。

该信息返回两列，第一列是 item 的大小，第二列是 item 的个数。

例：

set runoob 0 900 9
memcached
STORED

get runoob
VALUE runoob 0 9
memcached
END

flush_all
OK

get runoob
END

链接PHP服务

#挂在阿里云镜像
[root@memcached ~]# curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
#下载php包
[root@memcached ~]# yum install -y php php-devel zlib-devel php cc gcc
#下载memche客户端的包
[root@memcached ~]# wget http://pecl.php.net/get/memcache-2.2.7.tgz
[root@memcached ~]# tar -zxvf memcache-2.2.7.tgz
[root@memcached ~]# cd memcache-2.2.7
[root@memcached memcache-2.2.7]# phpize
#编译安装
[root@memcached memcache-2.2.7]# ./configure --with-php-config=/usr/bin/php-config && make && make install

 出现这就代表编译安装没问题。

[root@memcached ~]# vim /etc/php.ini
在这个文件下添加下图代码

[root@memcached ~]# php -m |grep memcache
memcache
[root@memcached ~]# vim 1.php
[root@memcached ~]# php 1.php
fasa

这就成功了。

memcached中储存session

httpd也可以使用nginx

[root@memcached ~]# yum install -y httpd    //下载httpd
[root@memcached ~]# systemctl start httpd    //开启

[root@memcached ~]# cd /var/www/html/
[root@memcached html]# vim session.php
<?php
        session_start();
        $_SESSION['name']='test';    
        echo session_id()."<br/>";        
        echo $_SESSION['name'];
?>
[root@memcached html]# php session.php 
PHP Notice:  session_start(): Server 192.168.200.200 (tcp 0) failed with: Failed to parse address "192.168.200.200" (0) in /var/www/html/session.php on line 2
tv54hkv3lkt9b060jichbbibs0<br/>test[root@memcached html]#

出现这个就代表成功了。

 页面访问：

三、Redis数据库

Redis简介

Redis 是完全开源免费的，遵守 BSD 协议，是一个灵活的高性能 key-value 数据结构存储，可以用来作为数据库、缓存和消息队列。

Redis 比其他 key-value 缓存产品有以下三个特点：

  • - Redis 支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载到内存使用。
  • - Redis 不仅支持简单的 key-value 类型的数据，同时还提供 list，set，zset，hash 等数据结构的存储。
  • - Redis 支持主从复制，即 master-slave 模式的数据备份。

Redis 的特点

高性能、持久化、数据结构、原子操作、支持的语言多、主/从复制、分片、可移植。

安装Redis

#安装到这个目录中
[root@redis src]# pwd
/usr/local/src
[root@redis src]# yum install gcc tcl -y
[root@redis redis-6.2.6]#  wget http://download.redis.io/releases/redis-6.2.6.tar.gz

[root@redis src]# tar -zxf redis-6.2.6.tar.gz 
[root@redis src]# cd redis-6.2.6
[root@redis redis-6.2.6]# make && make install

执行完 make 命令后，redis-6.0.8 目录下会出现编译后的 redis 服务程序 `redis-server`，还有用于测试的客户端程序 `redis-cli`，两个程序位于安装目录 src 目录下：

下面启动 redis 服务：

#启动的前台服务，操作不了命令（Ctrl+C退出）
[root@redis redis-6.2.6]# redis-server

 

#备份一下配置文件
[root@redis redis-6.2.6]# cp redis.conf redis.conf.bck
[root@redis redis-6.2.6]# vim redis.conf
#允许范围的地址，默认为127.0.0.1，只能本地来访问。0.0.0.0都可以来访问。服务向外开放的时候千万别0.0.0.0
bind 0.0.0.0
#守护进程
daemonize yes
#设置密码
requirepass 123456

 redis常用配置文件例子 redis.conf

#默认端口6379
port 6379
#绑定ip，如果是内网可以直接绑定 127.0.0.1, 或者忽略, 0.0.0.0是外网
bind 0.0.0.0
#守护进程启动
daemonize yes
#超时
timeout 300
loglevel notice
#分区
databases 16
save 900 1
save 300 10
save 60 10000
rdbcompression yes
#存储文件
dbfilename dump.rdb
#密码 abcd123
requirepass abcd123

 停止服务

#停止服務來配置文件（-U是密碼）
[root@redis redis-6.2.6]# redis-cli -u 123456 shutdown

 配置开机自启

[root@redis redis-6.2.6]# vim /etc/systemd/system/redis.service    #编写redis.service文件

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/bin/redis-server /usr/local/src/redis-6.2.6/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

#重启服务系统
[root@redis redis-6.2.6]# systemctl daemon-reload

此时就可以用一下命令来进行开机关机了。

# 启动
systemctl start redis
# 停止
systemctl stop redis
# 重启
systemctl restart redis
# 查看状态
systemctl status redis
# 设置开机自启
systemctl enable redis

redis客户端登录

#客户端进行登录（-h：指定链接redis节点 -p：redis的端口 -a：redis的访问密码）
#这样登录只能查看不能进行修改和添加
[root@redis redis-6.2.6]# redis-cli -h 127.0.0.1 -p 6379 -a 123456
127.0.0.1:6379> 
127.0.0.1:6379> set name liwebo
(error) NOAUTH Authentication required.
#上去直接写会提示让你身份认证。下面这个就是用来认证的，显示ok就表示成功了
127.0.0.1:6379> auth "123456"
OK
127.0.0.1:6379> set new_two ccc
OK

数据类型

string

例：

[root@redis ~]# redis-cli
127.0.0.1:6379> auth "123456"
127.0.0.1:6379> auth "123456"
OK
127.0.0.1:6379> set mykey "aminibnoll@11"
OK
127.0.0.1:6379> get mykey
"aminibnoll@11"
127.0.0.1:6379> mset key1 1 key2 d key3 p
OK
127.0.0.1:6379> mget key1 kye2 key3
1) "1"
2) (nil)
3) "p"
127.0.0.1:6379>

list

list是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等。操作中key理解为链表的名字。

例：

127.0.0.1:6379> LPUSH list1 "adminamind"
(integer) 1
127.0.0.1:6379> LPUSH list1 "123"
(integer) 2
127.0.0.1:6379> LPUSH list1 "aaa ccc"
(integer) 3
127.0.0.1:6379> LRANGE list1 0 -1
1) "aaa ccc"
2) "123"
3) "adminamind"
127.0.0.1:6379> LPOP list1
"aaa ccc"

set

set是集合，和我们数学中的集合概念相似，对集合的操作有添加删除元素，有对多个集合求交并差等操作。

例：

127.0.0.1:6379> sadd set1 a
(integer) 1
127.0.0.1:6379> sadd set1 b
(integer) 1
127.0.0.1:6379> sadd set1 c
(integer) 1
127.0.0.1:6379> sadd set1 d
(integer) 1
127.0.0.1:6379> smembers set1
1) "d"
2) "b"
3) "a"
4) "c"
127.0.0.1:6379> srem set1 c        //刪除c
(integer) 1
127.0.0.1:6379> smembers set1
1) "d"
2) "b"
3) "a"
127.0.0.1:6379> sadd set2 a 2 b
(integer) 3
127.0.0.1:6379> sinter set1 set2    //交集
1) "b"
2) "a"
127.0.0.1:6379> sunion set1 set2    //并集
1) "a"
2) "b"
3) "d"
4) "2"
127.0.0.1:6379> sdiff set1 set2        //差集
1) "d"

sorted set

sorted set是有序集合，它比set多了一个权重参数score，使得集合中的元素能够按 score 进行有序排列。

例：

127.0.0.1:6379> zadd set3 12 abc
(integer) 1
127.0.0.1:6379> zadd set3 12 "cde 123"
(integer) 1
127.0.0.1:6379> zadd set3 12 "dwd-123"
(integer) 1
127.0.0.1:6379> zrange set3 0 -1
1) "abc"
2) "cde 123"
3) "dwd-123"
#下面这个是倒序
127.0.0.1:6379> zrevrange set3 0 -1
1) "dwd-123"
2) "cde 123"
3) "abc"

hash

例：

127.0.0.1:6379> hset hash1 name aming
(integer) 1
127.0.0.1:6379> hget hash1 name
"aming"
127.0.0.1:6379> hset hash1 age 20
(integer) 1
127.0.0.1:6379> hget hash1 age
"20"
127.0.0.1:6379> hgetall hash1
1) "name"
2) "aming"
3) "age"
4) "20"

redis常用操作

 基础操作

#相当于在cart文件夹中创建了一个user01里又创建了一个itm01。里存的一个appla
127.0.0.1:6379> set cart:user01:itm01 apple
OK
127.0.0.1:6379> get cart:user01:itm01
"apple"

 设置key的实效时间

#设置10秒好实效
127.0.0.1:6379> set code test ex 10
OK
127.0.0.1:6379> ttl code
(integer) 5        //实效时间
127.0.0.1:6379> ttl code
(integer) -2    //已失效
#设置永不实效
127.0.0.1:6379> set code test 
OK
127.0.0.1:6379> ttl code
(integer) -1    //-1就是永不实效
#给已存在的code设置实效时间
127.0.0.1:6379> expire code 10
(integer) 1
127.0.0.1:6379> ttl code
(integer) 5
127.0.0.1:6379> ttl code
(integer) -2
#必须code已经存在的情况下使用xx，要不就为空。nx是code不存在的情况下
127.0.0.1:6379> set code test px 10000 xx
(nil)
127.0.0.1:6379> set code test px 10000 nx
OK

 通用删除

127.0.0.1:6379> set new dasd
OK
127.0.0.1:6379> get new
"dasd"
127.0.0.1:6379> del new
(integer) 1
127.0.0.1:6379> get new
(nil)

安全设置

#配置文件
[root@redis ~]# vim /usr/local/src/redis-6.2.6/redis.conf
bind 127.0.0.1 192.168.200.200     //多个IP可空格隔开
port 1600    //设置监听端口
redis-cle -a 'aming>com'    //设置密码
renanme-command CONGIG aming    //将config改名
renam-command CONFIG        //禁用config

 日志查询

#redis配置文件
vim /usr/local/src/redis-6.2.6/redis.conf
#进入redis输的命令
slowlog get //列出所有的慢查询日志
slowlog get 2 //只列出2条
slowlog len //查看慢查询日志条数

 

PHP链接redis

#挂载阿里云镜像
[root@redis ~]# curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
#下载php包
[root@redis ~]# yum install -y php php-devel zlib-devel php cc gcc
[root@redis ~]# yum install -y httpd
[root@redis ~]# systemctl start httpd
[root@redis ~]# cd /usr/local/src
[root@redis src]# wget https://pecl.php.net/get/redis-4.0.1.tgz
[root@redis src]# tar -zxvf redis-4.0.1.tgz 
[root@redis stc]# cd redis-4.0.1
[root@redis redis-4.0.1]# /usr/bin/phpize
[root@redis redis-4.0.1]# ./configure --with-php-config=/usr/bin/php-config
[root@redis redis-4.0.1]# make && make install
[root@redis redis-4.0.1]# vim /etc/php.ini        //因为我是yum安装php所有php.ini在etc目录下
添加 extension=redis.so

#看是否有redis模块
[root@redis redis-4.0.1]# /usr/bin/php -m|grep redis

 

存储session 

[root@redis ~]# vim /etc/php.ini
session.save_handler = "redis" 
session.save_path = "tcp://127.0.0.1:6379" 
[root@redis ~]# cd /var/www/html/
[root@redis html]# vim session.php
<?php
        session_start();
        $_SESSION['name']='test';    
        echo session_id()."<br/>";        
        echo $_SESSION['name'];
?>
[root@redis html]# php session.php

页面显示的是key值：

Redis 缓存持久化

Redis 的所有数据都保存在内存中，如果没有配置持久化功能，Redis重启后数据就会全部丢失，所以需要开启 Redis 的持久化功能，将数据保存到磁盘上，当然 Redis 重启后，可以从磁盘中恢复数据。Redis 提供两种方式进行持久化，一种是 RDB 持久化，另一种是 AOF 持久化。

RDB 持久化

RDB 持久化是在指定时间间隔内定时地将数据写入磁盘，把内存中的数据保存到 RDB 文件中，是默认的持久化方式。默认情况下 Redis 会把快照文件存储在当前目录下一个名为 dump.rdb 的文件内。如果想要修改文件位置可通过 redis.conf 配置文件的 dbfilename 参数来和 dir 参数来实现。

配置RDB

#查看数据保存位置
127.0.0.1:6379> config get dir
1) "dir"
2) "/root/redis-6.2.6"
  •  RDB 保存点 
    save 900 1                    #900s 后至少1个key值有变化，就保存快照文件
save 300 10                    #300s 后至少10个key值有变化，就保存快照文件
save 60 1000                #60s 后至少1000个key值有变化，就保存快照文件
  • 手动升生成快照 
    127.0.0.1:6379> save
OK
127.0.0.1:6379> bgsave
Background saving started
  • 报错处理 
    默认值为yes
stop-writes-on-bgsave-error yes
  • 数据压缩 
    默认值为yes
rdbchecksum yes
  • 数据效验 
    默认值为yes
rdbchecksum yes

配置 AOF

启用 AOF 持久化
在 redis.conf 中将 appendonly 设置为 yes即可

 

文件路径跟 RDB 文件共用。

可靠性：

在 redis.conf 配置文件中可以通过 appendfsync 选项指定写入策略，有三个选择项。

  • always：每次收到 Redis 客户端的写命令就立即强制写入到 AOF 文件。
  • everysec：每秒向 AOF 文件写入一次 Redis 客户端的写操作
  • no：由操作系统来决定什么时候写入 AOF 文件，一般情况下30秒左右一次，
日志重写

修改配置文件 redis.conf 的 auto-aof-rewrite-percentage 100 (意思就是：距离上次从写扩大100倍的时候 redis 执行日志重写) 、auto-aof-rewrite-min-size 64MB。

想要关闭就把上面的 100 改为 0 即可。

数据损坏修复

使用命令 redis-check-aof --fix

从 RDB 切换到 AOF
redis-cli config set appendonly yes
redis-cli config set save ""

 

Redis 过期 Key 清除策略

redis 对过期 key 用三种清除策略。

  • 被动清除：当读/写一个已经过期的 key 值时，会触发惰性清除策略，直接清除这个过期key。
  • 主动清除：由于惰性清除无法保证冷数据被及时清除，因此 Redis 会定期主动清除一部分已过期的 key。
  • 当前已用内存超过 maxmemory 限定时，触发主动清除策略。

在 redis 中，允许用户设置最大使用内存大小为 maxmemory (需要配合 maxmemory-policy使用)，设置 0 表示不限制。

Redis集群环境部署

Redis读写速度都很快，但是一定程度上也会造成一定延时。为了解决访问量大的问题，通常会采取的一种方式是主从复制。Master以写为主，Slave以读为主，Master更新后根据配置自动同步到Slave。

1.Redis主从复制

主从复制也叫主从模式，当用户向 Master 写入数据时，Master 通过Redis同步机制将数据文件发送至 Slave ，Slave 也会通过 Redis 同步机制将数据文件发送至 Master 以确保数据一致，从而实现 Redis 的主从复制。如果 Master 和 Slave 中间断开，Slave可以自动重连 Master ，但是链接成功后，将自动执行一次完全同步。

配置主从复制后，Master 可以负责读写服务，Slave 只负责读服务。Redis 复制在  Master 这一端是非阻塞的。也就是说在和 Slave 同步数据时，Master 仍然可以执行客户端的命令而不受任何影响。

主从复制的特点

（1）同一个 Master 可以拥有多个 Slave。

（2）Master 下的 Slave 还可以接受同一架构中其他 Slave 的链接与同步请求，实现数据的级联复制。

（3）Master 以非阻塞的方式同步数据至 Slave，这就意味着 Master 会继续处理一个或多个 Slave 的读写请求。

（4）主从复制不会阻塞 Master，当一个 Slave 与 Master 进行初次同步时，Master 可以继续处理客户端发过来的请求。

（5）主从复制具有可宽展性。

（6）通过禁用 Master 的持久机制，将数据的持久机制交给 Slave完成，从而来得到 Master 的最高价值。

主从复制的优势

  • 避免 Redis 的节点故障。
  • 做到读写分离，构建读写分离结构，瞒足读多写少的场景。

读写分离环境使用

操作系统 端口 IP地址 角色
CentOS 7 6379　 192.168.200.20 Master
CentOS 7 6379 192.168.200.30 Slave1
CentOS 7 6379 192.168.200.40 Slave2

Master 和 Slave 节点先安装上 Redis。

Master节点

[root@master ~]# vim /usr/local/src/redis-6.2.6/redis.conf
bind 127.0.0.1 192.168.200.20

[root@master ~]# systemctl restart redis

如果 Rdis 主服务器只绑定了 127.0.0.1，那么跨服务器IP地址访问就会失败，也就是只有本机才能访问，外部请求会被过滤掉，这是由 Linux 的网络策略管理的。如果只绑定IP地址只有 192.168.200.20 ，那么本机通过 localhost 和 127.0.0.1，或者直接输入命令 redis-cli 登录本机 Redis 就会失败。

Slave1、Slave2节点

slave1 和 slave2 都是这样。

[root@slave1 ~]# vim /usr/local/src/redis-6.2.6/redis.conf
添加：
slaveof 192.168.200.20 6379
修改：
bind 0.0.0.0
daemonize yes
requirepass 123456
replicaof 192.168.200.20 6379
masterauth "123456"
[root@master ~]# systemctl restart redis

这两个很重要

 

可以通过 info replication 命令来查看节点角色.

Master:

 Slave:

测试主从读写分离

Master节点操作如下：

[root@master ~]# redis-cli -h 127.0.0.1 -a 123456
127.0.0.1:6379> set name xinping
OK

Slave1节点操作：

[root@slave1 ~]# redis -h 127.0.0.1 -a 123456
127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> get name
"xinping"

Slave2操作：

[root@slave12 ~]# redis-cli -h 127.0.0.1 -a 12456
127.0.0.1:6379> get name
"xinping"

这样就证明是正确的。

测试主节点宕机

首先 down 掉主节点：

[root@master ~]# redis-cli -h 127.0.0.1 -a 123456
127.0.0.1:6379> shutdown
not connected>

然后来查看slave两个节点的状态（你会发现 Masker down掉之后 Slave 还可以查数据）：

哨兵模式

灾备切换 Sentinel 的使用

哨兵(Sentinel)进程监控 Redis 集群中 Master 主服务器的工作状态，在 Master 发生故障的时候，可以实现 Master 个 Slave 的切换，保证系统的高可用性。

哨兵模式的概念

哨兵那就肯定是来监控主节点和从节点的，如果主节点宕机，从节点就会成为新的主节点。

哨兵进程的作用

  • 监控：哨兵进程会不断的检查 Master 和 Slave 是否运作正常。
  • 提醒：当被监控的某个几点出现问题时，哨兵进程可以通过 API 向管理员或者其他应用程序发送通知。
  • 自动故障迁移：当 Master 不能正常工作是，哨兵进程会开始一次自动故障迁移操作，它将会实效 Master 的其中一个 Slave 升级成为新的 Master ，并让实效的 Master 的其他 Slave 改为复制新的 Master。当客户试图链接失败的 Master 时，Redis 集群也会向客户端发送新的 Master 地址，使得 Redis 集群可以使用现在的 Master 替换实效 Master。
  • 配置提供者：哨兵模式下，客户端在初始化时链接的是哨兵节点集合，从中获取主节点的信息。

Redis Sentinel 的安装与配置

与上面主从复制的基础上，在每个IP端都做一个哨兵。

 端口  操作系统 IP  角色 
3679  CentOS 7 x86_64  192.168.200.20  Master 
3679 CentOS 7 x86_64  192.168.200.30  Slave1 
3679  CentOS 7 x86_64  192.168.200.40  Slave2 
26379   CentOS 7 x86_64   192.168.200.20 Sentinel1
26379  CentOS 7 x86_64  192.168.200.30 Sentinel2
26379  CentOS 7 x86_64  192.168.200.40 Sentinel3
Master节点：
[root@master ~]# cd /usr/local/src/redis-6.2.6
[root@master redis-6.2.6]# cp sentinel.conf sentinel.conf.fz 
#清除 sentinel.conf 文件的所有带井号的和空格行
[root@master redis-6.2.6]# cat sentinel.conf.fz | grep -v "#" | grep-v "^$" > sentinel.conf
[root@master redis-6.2.6]# cat sentinel.conf         
port 26379
daemonize no
pidfile /var/run/redis-sentinel.pid
logfile "26379.log"
dir /usr/local/src/redis-6.2.6/data
sentinel monitor master01 192.168.200.20 6379 2
sentinel auth-pass master01 123456
sentinel down-after-milliseconds master01 150000
acllog-max-len 128
sentinel parallel-syncs master01 1
sentinel failover-timeout master01 180000
sentinel deny-scripts-reconfig yes
SENTINEL resolve-hostnames no
SENTINEL announce-hostnames no

 1 port 26379
 2 哨兵监听的端口
 3 daemonize yes
 4 后台启动
 5 protected-mode no
 6 关闭保护模式
 7 sentinel monitor master01 10.0.0.68 6379 2
 8 该行的意思是：监控的master的名字叫做master01（自定义）,地址为10.0.0.68:6379（主节点的ip与端口），行尾最后的一个2代表在sentinel集群中，多少个sentinel认为masters死了，才能真正认为该master不可用了。
 9 sentinel auth-pass master01 000000
10 连接密码
11 sentinel down-after-milliseconds master01 15000
12 sentinel会向master发送心跳PING来确认master是否存活，如果master在“一定时间范围”内不回应PONG 或者是回复了一个错误消息，那么这个sentinel会主观地(单方面地)认为这个master已经不可用了(subjectively down, 也简称为SDOWN)。而这个down-after-milliseconds就是用来指定这个“一定时间范围”的，单位是毫秒
13 sentinel failover-timeout master01 120000
14 failover过期时间，当failover开始后，在此时间内仍然没有触发任何failover操作，当前sentinel将会认为此次failoer失败。
15 
16 sentinel parallel-syncs master01 1
17 在发生failover主备切换时，这个选项指定了最多可以有多少个slave同时对新的master进行同步，这个数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为replication而不可用。可以通过将这个值设为 1来保证每次只有一个slave处于不能处理命令请求的状态。
18 ————————————————
19 版权声明：本文为CSDN博主「喵喵睡大觉」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
20 原文链接：https://blog.csdn.net/liang_operations/article/details/89434341
代码解释

 使用 redis-cli 命令链接到 Sentinel 节点。输入 info sentinel 命令返回如下信息：cat 

#启动 Sentinel
[root@master redis-6.2.6]# redis-sentinel sentinel.conf
[root@master redis-6.2.6]# redis-cli -p 26379
127.0.0.1:26379> info sention
(error) ERR unknown command `sention`, with args beginning with: 
127.0.0.1:26379> info sentinel
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=master1,status=ok,address=192.168.200.20:6379,slaves=2,sentinels=1
 Slave 节点:

（两个节点都要做，注意修改IP）

[root@master ~]# cd /usr/local/src/redis-6.2.6
[root@slave1 redis-6.2.6]# cp sentinel.conf sentinel.conf.fz
[root@slave1 redis-6.2.6]# cat sentinel.conf.fz |grep -v "#" |grep -v "^$" > sentinel.conf
[root@slave1 redis-6.2.6]# cat sentinel.conf
port 26379
daemonize yes
pidfile /var/run/redis-sentinel.pid
logfile ""
dir /tmp
sentinel monitor master2 192.168.200.30 6379 2
sentinel auth-pass master2 123456
sentinel down-after-milliseconds master2 30000
acllog-max-len 128
sentinel parallel-syncs master2 1
sentinel failover-timeout master2 180000
sentinel deny-scripts-reconfig yes
SENTINEL resolve-hostnames no
SENTINEL announce-hostnames no
#启动 Sentinel
[root@slave1 redis-6.2.6]# redis-sentinel sentinel.conf
[root@slave1 redis-6.2.6]# redis-cli -p 26379
127.0.0.1:26379> info sentinel
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=master2,status=sdown,address=192.168.200.30:6379,slaves=0,sentinels=1

测试主从切换

在 Redis 客户端使用 info repolication 命令查看集群信息。

[root@master ~]# redis-cli -h 127.0.0.1 -a 123456
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=192.168.200.40,port=6379,state=online,offset=1204499,lag=1
slave1:ip=192.168.200.30,port=6379,state=online,offset=1204499,lag=0
master_failover_state:no-failover
master_replid:ceed6c1d4035053939567289ca9a1849bb59016d
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:1204641
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:156066
repl_backlog_histlen:1048576
查看进程
[root@master ~]# ps -ef | grep redis
root       6939      1  0 11:27 ?        00:00:29 /usr/local/bin/redis-server 192.168.200.20:6379
root       6963      1  0 11:32 ?        00:00:32 redis-sentinel *:26379 [sentinel]
root       8115   2398  0 16:18 pts/1    00:00:00 grep --color=autoredis
[root@master ~]# kill -9 6939

使用 Slave 节点查看 Master 是否更换。可以很清楚的看见 Master 已经变成了 Slave2 节点的 IP 了。

[root@slave1 redis-6.2.6]# redis-cli -h 127.0.0.1 -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
127.0.0.1:6379> info replication
# Replication
role:slave
master_host:192.168.200.40
master_port:6379
master_link_status:up
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_read_repl_offset:1228656
slave_repl_offset:1228656
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:a24b286f54db40ebc629121caa39fe69c0b37c5b
master_replid2:ceed6c1d4035053939567289ca9a1849bb59016d
master_repl_offset:1228656
second_repl_offset:1224048
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1139198
repl_backlog_histlen:89459

通过上面的配置，可以看出哨兵模式是基于主从模式的，哨兵模式具有主从模式的所有优点。哨兵模式是主从模式的升级，实现了自动化的故障恢复。但哨兵模式的缺点也很明显，Redis 较难实现在线扩容，在集群容量达到上限是在集群扩容会很复杂。实现哨兵模式的配置也不简单，甚至有点繁琐，于是就有了 Redis 集群。

Redis集群环境

Redis 集群要求：

  • 主节点不能少于总节点的一般。
  • 主节点至少3个。
Redis 集群环境
IP地址 端口 版本 操作系统
192.168.200.20 8001 Redis-6.2.6 CentOS 7 64位
8002
8003
8004
8005
8006

开始 Redis 集群搭建

基础配置
[root@redis ~]# yum install -y gcc-c++ tcl wget
[root@redis ~]# wget http://download.redis.io/releases/redis-6.2.6.tar.gz
[root@redis ~]# tar -zxf redis-6.2.6.tar.gz 
[root@redis ~]# cd redis-6.2.6
[root@redis redis-6.2.6]# make && make install
[root@redis redis-6.2.6]# mkdir 8001 8002 8003 8004 8005 8006
[root@redis redis-6.2.6]# cp redis.conf 8001
修改配置文件

密码先别设置，如果设置了很如何报错

[root@redis 8001]# vim redis.conf
daemonize yes
port 8001
dir /root/redis-6.2.6/8001/
cluster-enabled yes
cluster-config-file nodes-8001.conf 
cluster-node-timeout 5000
bind 192.168.200.20
protected-mode no
appendonly yes
requirepass 123456
masterauth 123456
 1 daemonize yes：开启 Redis 的守护进程。开启 Redis 的守护进程后，Redis 后在后台一直运行，除非 kill 来杀掉进程。
 2 port 8001：端口。
 3 dir /usr/local/src/redis-cluster/8001：数据文件存放位置。
 4 cluster-enabled yes：启动集群模式。
 5 cluster-config-file nodes-8001.conf：集群节点信息文件。
 6 cluster-node-timeout 5000：集群节点的超时时限，单位毫秒。
 7 bind 192.168.200.20：修改为主机IP地址，默认IP地址是127.0.0.1，如果不修改则无法创建集群。
 8 protected-mode no：关闭保护模式。
 9 appendoly yes：开启 AOF 持久化。
10 requirepass 123456：设置 Redis 访问密码。
11 masterauth 123456：设置集群节点间的访问密码。
命令解释

将修改好的文件复制到 8002-8006 文件夹中，然后进行修改端口和文件位置。

#将 8001-8005 都开启
[root@redis redis-6.2.6]# redis-server 8001/redis.conf
......
#查看进程
[root@redis redis-6.2.6]# ps -ef | grep redis                         root       8127      1  0 10:29 ?        00:00:01 redis-server 192.168.200.20:8001
root       8135      1  0 10:31 ?        00:00:01 redis-server 192.168.200.20:8002
root       8149      1  0 10:32 ?        00:00:01 redis-server 192.168.200.20:8004
root       8156      1  0 10:33 ?        00:00:01 redis-server 192.168.200.20:8005
root       8255      1  0 11:00 ?        00:00:00 redis-server 192.168.200.20:8006
root       8261   8066  0 11:00 pts/0    00:00:00 grep --color=auto redis
#嫌麻烦的话可以写脚本来开启
[root@redis redis-6.2.6]# touch startRedis.sh
[root@redis redis-6.2.6]# chmod +x startRedis.sh 
[root@redis redis-6.2.6]# cat startRedis.sh
#!/bin/bash
redis-server 8001/redis.conf
redis-server 8002/redis.conf
redis-server 8002/redis.conf
redis-server 8003/redis.conf
redis-server 8004/redis.conf 
redis-server 8005/redis.conf
redis-server 8006/redis.conf
创建集群

还要输入 yes

[root@redis redis-6.2.6]# redis-cli --cluster create --cluster-replicas 1 192.168.200.20:8001 192.168.200.20:8002 192.168.200.20:8003 192.168.200.20:8004 192.168.200.20:8005 192.168.200.20:8006
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 192.168.200.20:8005 to 192.168.200.20:8001
Adding replica 192.168.200.20:8006 to 192.168.200.20:8002
Adding replica 192.168.200.20:8004 to 192.168.200.20:8003
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001
   slots:[0-5460] (5461 slots) master
M: 9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002
   slots:[5461-10922] (5462 slots) master
M: fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003
   slots:[10923-16383] (5461 slots) master
S: b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004
   replicates fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f
S: defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005
   replicates d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45
S: 9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006
   replicates 9e8acdb9764b6308001539b86be67b76c1d2fab4
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
.
>>> Performing Cluster Check (using node 192.168.200.20:8001)
M: d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006
   slots: (0 slots) slave
   replicates 9e8acdb9764b6308001539b86be67b76c1d2fab4
S: b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004
   slots: (0 slots) slave
   replicates fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f
M: 9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005
   slots: (0 slots) slave
   replicates d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
#启动 Redis 集群某个节点命令命令
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8001 -c
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8002 -c
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8003 -c
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8004 -c
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8005 -c
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8006 -c
1 -a：表示 Redis 服务器密码（我做的时候没有设置密码）
2 -c：表示链接 Redis 集群
3 -h：表示集群节点 IP
4 -p：表示 Redis 集群节点的端口号
redis 参数解释 
端口 8001 8002 8003 8004 8005 8006
角色 Master Master Master Slave Slave Slave
测试集群正常

cluster nodes 可以查看 Redis 集群里面有几个主节点几个从节点。

[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8001 -c
192.168.200.20:8003> set name xinping
-> Redirected to slot [5798] located at 192.168.200.20:8002
OK
192.168.200.20:8002> get name
"xinping"
192.168.200.20:8001> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6　　          //表示有6个节点
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:2593
cluster_stats_messages_pong_sent:2629
cluster_stats_messages_sent:5222
cluster_stats_messages_ping_received:2624
cluster_stats_messages_pong_received:2593
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:5222
192.168.200.20:8001> cluster nodes
9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002@18002 myself,master - 0 1647416574000 2 connected 5461-10922
9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006@18006 slave 9e8acdb9764b6308001539b86be67b76c1d2fab4 0 1647416575565 2 connected
fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003@18003 master - 0 1647416574538 3 connected 10923-16383
defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005@18005 master - 0 1647416575050 7 connected 0-5460
d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001@18001 slave defe3b5f67edef77423a46ceebd15d9872032e25 0 1647416575565 7 connected
b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004@18004 slave fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 0 1647416574026 3 connected

关掉一个主节点查看是否还可以运行。

[root@redis redis-6.2.6]# ps -ef | grep redis
root       6832      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8001 [cluster]
root       6838      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8002 [cluster]
root       6844      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8003 [cluster]
root       6850      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8004 [cluster]
root       6856      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8005 [cluster]
root       6862      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8006 [cluster]
root       7887   2397  0 15:37 pts/1    00:00:00 grep --color=auto redis
[root@redis redis-6.2.6]# kill -9 6832
[root@redis redis-6.2.6]# ps -ef | grep redis
root       6838      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8002 [cluster]
root       6844      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8003 [cluster]
root       6850      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8004 [cluster]
root       6856      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8005 [cluster]
root       6862      1  0 15:08 ?        00:00:02 redis-server 192.168.200.20:8006 [cluster]
root       7889   2397  0 15:37 pts/1    00:00:00 grep --color=auto redis
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8001
Could not connect to Redis at 192.168.200.20:8001: Connection refused
not connected> 
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8002
192.168.200.20:8002> 
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8002 -c
192.168.200.20:8002> cluster nodes
9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002@18002 myself,master - 0 1647416317000 2 connected 5461-10922
9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006@18006 slave 9e8acdb9764b6308001539b86be67b76c1d2fab4 0 1647416319085 2 connected
fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003@18003 master - 0 1647416319292 3 connected 10923-16383
defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005@18005 master - 0 1647416318270 7 connected 0-5460
d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001@18001 master,fail - 1647416278501 1647416276000 1 disconnected
b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004@18004 slave fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 0 1647416319292 3 connected
测试

你会发现有 Slave 有两个，8001 端口后显示 disconnected，表示已经关闭。

Redis 集群代理

简单来说就是来管理 Redis 的，一个 Redis 代理来管理多个 Redis。

IP地址 端口 版本 操作系统
192.168.200.20 8001 Redis-6.2.6 CentOS 7 64位置
8002
8003
8004
8005
8006
7777 Redis Cluster Proxy 1.0-beta2
安装 Redis 代理

跟着上面的集群做。

[root@redis ~]# curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
[root@redis ~]# yum install -y centos-release-scl
[root@redis ~]# yum install -y devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
[root@redis ~]# scl enable devtoolset-9 bash
[root@redis ~]# echo "source /opt/rh/devtoolset-9/enable" >> /etc/profile
[root@redis ~]# source /etc/profile
#git 是一个分布式控制系统
[root@redis ~]# yum install -y git
[root@redis ~]# mkdir upload
[root@redis ~]# cd upload/
[root@redis ~]# git config --global --unset https.proxy
[root@redis ~]# git clone https://github.com/artix75/redis-cluster-proxy
[root@redis ~]# cd upload/
#git 下载最新版本的 Redis Cluster Proxy 包
[root@redis upload]# git clone https://github.com/artix75/redis-cluster-proxy
#使用 make 命令安装 Redis Cluster Proxy 后面跟的是下载路径
[root@redis redis-cluster-proxy]# make PREFIX=/usr/local/redis_cluster_proxy install
[root@redis redis-cluster-proxy]# mkdir -p /usr/local/redis_cluster_proxy/conf
[root@redis redis-cluster-proxy]# cp proxy.conf /usr/local/redis_cluster_proxy/conf
[root@redis redis-cluster-proxy]# vim /usr/local/redis_cluster_proxy/conf/proxy.conf
修改：
port 7777
daemonize yes
cluster 192.168.200.20:8001
cluster 192.168.200.20:8002
cluster 192.168.200.20:8003
cluster 192.168.200.20:8004
cluster 192.168.200.20:8005
cluster 192.168.200.20:8006
[root@redis redis-cluster-proxy]# vim /etc/profile
添加最后一行：
export PATH=$PATH:/usr/local/redis_cluster_proxy/bin
[root@redis redis-cluster-proxy]# source /etc/profile
启动与使用

与 Redis 集群连接方式不同，在 Redis 集群代理模式下， Redis 客户端可以连接至 Redis 集群几点，而无需知道 Redis 集群自身的详细信息。

[root@redis ~]# redis-cluster-proxy -c /usr/local/redis_cluster_proxy/conf/proxy.conf 
[root@redis ~]# ps -ef | grep redis
root       6838      1  0 15:08 ?        00:00:21 redis-server 192.168.200.20:8002 [cluster]
root       6844      1  0 15:08 ?        00:00:21 redis-server 192.168.200.20:8003 [cluster]
root       6850      1  0 15:08 ?        00:00:18 redis-server 192.168.200.20:8004 [cluster]
root       6856      1  0 15:08 ?        00:00:21 redis-server 192.168.200.20:8005 [cluster]
root       6862      1  0 15:08 ?        00:00:18 redis-server 192.168.200.20:8006 [cluster]
root       7897      1  0 15:42 ?        00:00:16 redis-server 192.168.200.20:8001 [cluster]
root       8699      1  0 19:13 ?        00:00:00 redis-cluster-proxy -c /usr/local/redis_cluster_proxy/conf/proxy.conf
root       8709   8063  0 19:13 pts/1    00:00:00 grep --color=autoredis
[root@redis ~]# redis-cli -h 192.168.200.20 -p 7777
192.168.200.20:7777> sadd books redis
(integer) 1
192.168.200.20:7777> sadd books mysql
(integer) 1
192.168.200.20:7777> smembers books
1) "mysql"
2) "redis"
192.168.200.20:7777>
[root@redis ~]# redis-cli -h 192.168.200.20 -p 8001
192.168.200.20:8001> smembers books
(error) MOVED 15901 192.168.200.20:8003
192.168.200.20:8001> 
[root@redis ~]# redis-cli -h 192.168.200.20 -p 8001 -c
192.168.200.20:8001> DBSIZE
(integer) 1
192.168.200.20:8001> SMEMBERS books
-> Redirected to slot [15901] located at 192.168.200.20:8003
1) "mysql"
2) "redis"
Redis 集群特点

Redis 集群方案采用的是散列分区的“虚拟槽分区”方式，槽范围是 0~16383 ，共用 16384(即2的14次方)个槽。每个节点会维护自身负责的槽即槽所反映的键值对数据。 在 Redis 集群的实际使用中，SET key value 命令会计算列值，从而把 key-value 对储存到的对应的散列槽和主节点中。

槽与节点的对应关系
 槽范围  对应端口
 0~5460 redis-1 主节点 
5461~10922  redis-2 主节点 
10923~16383  redis-3 主节点 

下面这个图是 key 与数据的关系：

查看槽范围
[root@redis ~]# redis-cli -h 192.168.200.20 -p 8001 -c
192.168.200.20:8001> get js
-> Redirected to slot [10773] located at 192.168.200.20:8002
"php"
192.168.200.20:8002> cluster nodes
9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002@18002 myself,master - 0 1647432518000 2 connected 5461-10922
9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006@18006 slave 9e8acdb9764b6308001539b86be67b76c1d2fab4 0 1647432520000 2 connected
fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003@18003 master - 0 1647432519522 3 connected 10923-16383
defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005@18005 master - 0 1647432520030 7 connected 0-5460
d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001@18001 slave defe3b5f67edef77423a46ceebd15d9872032e25 0 1647432521047 7 connected
b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004@18004 slave fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 0 1647432520000 3 connected
 查看集群信息
[root@redis ~]# redis-cli -h 192.168.200.20 -p 8001 -c
192.168.200.20:8001> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:7
cluster_my_epoch:2
cluster_stats_messages_ping_sent:32590
cluster_stats_messages_pong_sent:32488
cluster_stats_messages_meet_sent:1
cluster_stats_messages_auth-ack_sent:1
cluster_stats_messages_sent:65080
cluster_stats_messages_ping_received:32488
cluster_stats_messages_pong_received:32591
cluster_stats_messages_fail_received:1
cluster_stats_messages_auth-req_received:1
cluster_stats_messages_received:65081
192.168.200.20:8001> set age 23
-> Redirected to slot [741] located at 192.168.200.20:8005
OK
1 接受命令 SET age 23
2 通过 key（23）计算出对应的槽，然后根据槽找到对应的节点。（age 应该对应为 741）
3 重定向到对应节点执行命令
age 23 存储槽解释
新增 Redis 集群节点
增加 Redis 主节点
[root@redis ~]# cd redis-6.2.6
[root@redis redis-6.2.6]# mkdir 8007
[root@redis redis-6.2.6]# cp 8001/redis.conf 8007/
#修改配置文件（只需要把 8001 的配置文件该为 8007 即可）
[root@redis redis-6.2.6]# vim 8007/redis.conf 
[root@redis redis-6.2.6]# redis-server 8007/redis.conf
#可以看到 8007 已经开启
[root@redis redis-6.2.6]# ps -ef | grep redis.conf 
root       8924   8888  0 08:16 pts/0    00:00:00 grep --color=autoredis.conf
[root@redis redis-6.2.6]# ps -ef | grep redis
root       6838      1  0 02:59 ?        00:00:28 redis-server 192.168.200.20:8002 [cluster]
root       6844      1  0 02:59 ?        00:00:28 redis-server 192.168.200.20:8003 [cluster]
root       6850      1  0 02:59 ?        00:00:24 redis-server 192.168.200.20:8004 [cluster]
root       6856      1  0 02:59 ?        00:00:28 redis-server 192.168.200.20:8005 [cluster]
root       6862      1  0 02:59 ?        00:00:24 redis-server 192.168.200.20:8006 [cluster]
root       7897      1  0 03:34 ?        00:00:22 redis-server 192.168.200.20:8001 [cluster]
root       8699      1  0 07:04 ?        00:00:00 redis-cluster-proxy -c /usr/local/redis_cluster_proxy/conf/proxy.conf
root       8917      1  0 08:14 ?        00:00:00 redis-server 192.168.200.20:8007 [cluster]
root       8926   8888  0 08:17 pts/0    00:00:00 grep --color=autoredis
#给 8007 添加为 8001 集群中的任何一个节点
[root@redis redis-6.2.6]# redis-cli  --cluster add-node 192.168.200.20:8007 192.168.200.20:8001
1 add-node：添加 Redis 节点
2 192.168.200.20:8007：指定增加的 Redis 主节点
3 192.168.200.20:8001：可以是 Redis 集群中的任何一个 Redis 节点
添加主节点命令解释
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8001 -c
192.168.200.20:8001> cluster nodes
9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002@18002 master - 0 1647476603000 2 connected 5461-10922
d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001@18001 myself,slave defe3b5f67edef77423a46ceebd15d9872032e25 0 1647476604000 7 connected
fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003@18003 master - 0 1647476604531 3 connected 10923-16383
9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006@18006 slave 9e8acdb9764b6308001539b86be67b76c1d2fab4 0 1647476603000 2 connected
defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005@18005 master - 0 1647476604531 7 connected 0-5460
27b7631b0177b1549fbf179b4eb40b4c03a27546 192.168.200.20:8007@18007 master - 0 1647476603520 0 connected
b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004@18004 slave fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 0 1647476603111 3 connected
Redis 主节点分配槽
[root@redis redis-6.2.6]# redis-cli --cluster reshard 192.168.200.20:8007
会弹出来下面的:(第一个是槽数、第二个是ID、all表示所有主节点拿出分裂槽、yes确定)
How many slots do you want to move (from 1 to 16384)?1000
What is the receiving node ID?27b7631b0177b1549fbf179b4eb40b4c03a27546
Source node #1: all
Do you want to proceed with the proposed reshard plan (yes/no)? yes

也可以指定某个端口来分裂槽。

新增 Redis 从节点
[root@redis redis-6.2.6]# mkdir 8008
[root@redis redis-6.2.6]# cp 8001/redis.conf 8008/
[root@redis redis-6.2.6]# vim 8008/redis.conf 
修改文件：
只需要将所有 8001 修改为 8008
[root@redis redis-6.2.6]# redis-server 8008/redis.conf 
[root@redis redis-6.2.6]# ps -au | grep redis
root      10153  0.0  0.0 112828   984 pts/0    S+   15:06   0:00 grep --color=auto redis
[root@redis redis-6.2.6]# ps -au | grep redis.conf     
root      10156  0.0  0.0 112828   996 pts/0    S+   15:07   0:00 grep --color=auto redis.conf
[root@redis redis-6.2.6]# ps -ef |grep redis
root       6838      1  0 02:59 ?        00:01:06 redis-server 192.168.200.20:8002 [cluster]
root       6844      1  0 02:59 ?        00:01:06 redis-server 192.168.200.20:8003 [cluster]
root       6850      1  0 02:59 ?        00:01:00 redis-server 192.168.200.20:8004 [cluster]
root       6856      1  0 02:59 ?        00:01:06 redis-server 192.168.200.20:8005 [cluster]
root       6862      1  0 02:59 ?        00:00:59 redis-server 192.168.200.20:8006 [cluster]
root       7897      1  0 03:34 ?        00:00:59 redis-server 192.168.200.20:8001 [cluster]
root       8699      1  0 07:04 ?        00:00:00 redis-cluster-proxy -c /usr/local/redis_cluster_proxy/conf/proxy.conf
root       8917      1  0 08:14 ?        00:00:33 redis-server 192.168.200.20:8007 [cluster]
root      10147      1  0 15:06 ?        00:00:00 redis-server 192.168.200.20:8008 [cluster]
root      10158   8888  0 15:08 pts/0    00:00:00 grep --color=autoredis
#8008 开启集群
[root@redis redis-6.2.6]# redis-cli --cluster add-node 192.168.200.20:8008 192.168.200.20:8001
#查看 8008 发现是 Master节点
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8001 -c    192.168.200.20:8001> cluster nodes
9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002@18002 master - 0 1647501039584 2 connected 6128-10922
d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001@18001 myself,slave defe3b5f67edef77423a46ceebd15d9872032e25 0 1647501036000 7 connected
fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003@18003 master - 0 1647501039279 3 connected 11590-16383
9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006@18006 slave 9e8acdb9764b6308001539b86be67b76c1d2fab4 0 1647501038000 2 connected
35665b3a8628911ba4800fd81cace8183be59639 192.168.200.20:8008@18008 master - 0 1647501038000 0 connected
defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005@18005 master - 0 1647501039000 7 connected 666-5460
27b7631b0177b1549fbf179b4eb40b4c03a27546 192.168.200.20:8007@18007 master - 0 1647501038667 8 connected 0-665 5461-6127 10923-11589
b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004@18004 slave fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 0 1647501038151 3 connected
#给 8008 指定一个主节点，后面跟的ID是 8007 的ID
[root@redis redis-6.2.6]# redis-cli -c -h 192.168.200.20 -p 8008
192.168.200.20:8008> cluster replicate 27b7631b0177b1549fbf179b4eb40b4c03a27546
OK
192.168.200.20:8008> cluster nodes
9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002@18002 master - 0 1647501235000 2 connected 6128-10922
9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006@18006 slave 9e8acdb9764b6308001539b86be67b76c1d2fab4 0 1647501235546 2 connected
fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003@18003 master - 0 1647501234109 3 connected 11590-16383
35665b3a8628911ba4800fd81cace8183be59639 192.168.200.20:8008@18008 myself,slave 27b7631b0177b1549fbf179b4eb40b4c03a27546 0 1647501234000 8 connected
b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004@18004 slave fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 0 1647501236000 3 connected
d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001@18001 slave defe3b5f67edef77423a46ceebd15d9872032e25 0 1647501235000 7 connected
27b7631b0177b1549fbf179b4eb40b4c03a27546 192.168.200.20:8007@18007 master - 0 1647501234000 8 connected 0-665 5461-6127 10923-11589
defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005@18005 master - 0 1647501235000 7 connected 666-5460
删除 Redis 集群节点
删除从节点
# 后面跟的是 8008 的ID
[root@redis redis-6.2.6]# redis-cli --cluster del-node 192.168.200.20:8008 35665b3a8628911ba4800fd81cace8183be59639
>>> Removing node 35665b3a8628911ba4800fd81cace8183be59639 from cluster 192.168.200.20:8008
>>> Sending CLUSTER FORGET messages to the cluster...
>>> Sending CLUSTER RESET SOFT to the deleted node.
[root@redis redis-6.2.6]# redis-cli -h 192.168.200.20 -p 8001 -c
192.168.200.20:8001> cluster nodes
9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002@18002 master - 0 1647501540000 2 connected 6128-10922
d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001@18001 myself,slave defe3b5f67edef77423a46ceebd15d9872032e25 0 1647501539000 7 connected
fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003@18003 master - 0 1647501540000 3 connected 11590-16383
9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006@18006 slave 9e8acdb9764b6308001539b86be67b76c1d2fab4 0 1647501540000 2 connected
defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005@18005 master - 0 1647501540516 7 connected 666-5460
27b7631b0177b1549fbf179b4eb40b4c03a27546 192.168.200.20:8007@18007 master - 0 1647501540003 8 connected 0-665 5461-6127 10923-11589
b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004@18004 slave fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 0 1647501541026 3 connected
删除主节点

先移走主节点的所有槽然后再删除

[root@redis redis-6.2.6]# redis-cli --cluster reshard 192.168.200.20:8007
>>> Performing Cluster Check (using node 192.168.200.20:8007)
M: 27b7631b0177b1549fbf179b4eb40b4c03a27546 192.168.200.20:8007
   slots:[0-665],[5461-6127],[10923-11589] (2000 slots) master
S: b5a054dbd68cadc819a56d0763861f9f50c18aad 192.168.200.20:8004
   slots: (0 slots) slave
   replicates fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f
M: fa2fa237b65753e9b50efbe4e0ed5a9a0935ac1f 192.168.200.20:8003
   slots:[11590-16383] (4794 slots) master
   1 additional replica(s)
S: 9f0ae423604dfccc9e616a90fef3c4e3f6af8fe8 192.168.200.20:8006
   slots: (0 slots) slave
   replicates 9e8acdb9764b6308001539b86be67b76c1d2fab4
M: 9e8acdb9764b6308001539b86be67b76c1d2fab4 192.168.200.20:8002
   slots:[6128-10922] (4795 slots) master
   1 additional replica(s)
M: defe3b5f67edef77423a46ceebd15d9872032e25 192.168.200.20:8005
   slots:[666-5460] (4795 slots) master
   1 additional replica(s)
S: d0f900dfa44a61b2ce02f3fe93bbbb3e6594bc45 192.168.200.20:8001
   slots: (0 slots) slave
   replicates defe3b5f67edef77423a46ceebd15d9872032e25
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
How many slots do you want to move (from 1 to 16384)? 11589
What is the receiving node ID? 9e8acdb9764b6308001539b86be67b76c1d2fab4
Please enter all the source node IDs.
  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
Do you want to proceed with the proposed reshard plan (yes/no)?yes
#删除节点
[root@redis redis-6.2.6]# redis-cli --cluster del-node 192.168.200.20:8007 27b7631b0177b1549fbf179b4eb40b4c03a27546
>>> Removing node 27b7631b0177b1549fbf179b4eb40b4c03a27546 from cluster 192.168.200.20:8007
>>> Sending CLUSTER FORGET messages to the cluster...
>>> Sending CLUSTER RESET SOFT to the deleted node.

 

MongDB数据库

介绍

MongoDB是一个文档数据库（以JSON为数据模型），由C++语言编辑。是一个非关系型数据库。原则上Oracle和Mysql能做的事情，MongoDB都可以做（包括ACID事务）。

技术优势

MongoDB基于灵活的SON文档模型，非常适合敏捷的快速开发。于此同时，其与生居来的高可用、高水平扩张能力使得他在处理海量、高并发的数据库应用时颇具优势。

  • JSON结构和对象模型接近，开发代码量低

  • JSON的动态模型意味着更容易响应新的业务要求

  • 复制集提供99.999%高可用

  • 分片架构支持海量数据和无缝扩容

适用场景

游戏场景：用户装备、积分....

物流场景：11.11庞大的订单

社交场景：用户朋友圈，地理位置

物联网、视频直播、大数据应用等等.....

应用特征yes
应用不需要复杂/长事务及join支持 yes
应用需要TB甚至PB级别数据库储存 yes
应用发展讯速，需要能快速水平发展 yes
应用需要大量的查询地址信息、文本 yes
应用需要2000-3000以上的读写QPS（更高） yes

满足一点即可。

MongoDB安装

官网:MongoDB Community Download | MongoDB

自己研究的话可以最高的、用生态环境的话用4.4.13

 

[root@mongdb ~]# tar -zxf mongodb-linux-x86_64-rhel70-4.4.13.gz 
[root@mongdb ~]# mv mongodb-linux-x86_64-rhel70-4.4.13 /etc/mongodb
[root@mongdb ~]# cd /etc/mongodb/
[root@mongdb mongodb]# mkdir conf
[root@mongdb mongodb]# mkdir logs
[root@mongdb mongodb]# mkdir data
#配置文件
[root@mongdb mongodb]# vim conf/mongod.conf
port=20017                                    //端口
dbpath=/etc/mongodb                            //创建data目录路径
logpath=/etc/mongodb/logs/mongod.log        //创建日志文件路径
fork=true                                    //让程序后台启动
##如果客户端连接不上，配置文件中增加：bind_ip = 0.0.0.0
#启动mongdb
[root@mongdb mongodb]# ./bin/mongod -f conf/mongod.conf
#关闭mongdb（bin目录下）
[root@mongdb bin]#./mongod --port=20017 --dbpath=/etc/mongodb/data --showtdown
#在库里关闭mongdb
> use admin                //必须在这个用户下关闭
> db.shutdownServer()    //关闭mongdb
> exit                    //退出

#查看是否关闭mongdb
[root@mongdb bin]# ps -ef|grep mongodb
Error parsing command line: unrecognised option '--showtdown'
try './mongod --help' for more information
[root@mongdb bin]# ps -ef|grep mongodb    
root       6139   3812  0 09:38 pts/2    00:00:00 grep --color=auto mongodb

 这样就好了。问题处理百科：linux mongo 安装目录,linux下MongoDB安装_琉璃与大大的博客-CSDN博客

[root@mongdb mongodb]# cd bin/
#mongo进入
[root@mongdb bin]# ./mongo localhost:20017
MongoDB shell version v4.4.13
connecting to: mongodb://localhost:20017/test?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("7e1ada77-51f3-49a6-9abc-42b32b6dfef9") }
MongoDB server version: 4.4.13
---
The server generated these startup warnings when booting: 
        2022-03-10T19:32:08.856+08:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
        2022-03-10T19:32:08.856+08:00: You are running this process as the root user, which is not recommended
        2022-03-10T19:32:08.856+08:00: This server is bound to localhost. Remote systems will be unable to connect to this server. Start the server with --bind_ip <address> to specify which IP addresses it should serve responses from, or with --bind_ip_all to bind to all interfaces. If this behavior is desired, start the server with --bind_ip 127.0.0.1 to disable this warning
        2022-03-10T19:32:08.856+08:00: /sys/kernel/mm/transparent_hugepage/enabled is 'always'. We suggest setting it to 'never'
        2022-03-10T19:32:08.857+08:00: /sys/kernel/mm/transparent_hugepage/defrag is 'always'. We suggest setting it to 'never'
        2022-03-10T19:32:08.857+08:00: Soft rlimits too low
        2022-03-10T19:32:08.857+08:00:         currentValue: 1024
        2022-03-10T19:32:08.857+08:00:         recommendedMinimum: 64000
---
---
        Enable MongoDB's free cloud-based monitoring service, which will then receive and display
        metrics about your deployment (disk utilization, CPU, operation statistics, etc).

        The monitoring data will be available on a MongoDB website with a unique URL accessible to you
        and anyone you share the URL with. MongoDB may use this information to make product
        improvements and to suggest MongoDB products and deployment options to you.

        To enable free monitoring, run the following command: db.enableFreeMonitoring()
        To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
---
>

配置mongodb启动文件

#在之前的配置文件中修改的
[root@mongdb mongodb]# cat conf/mongod.conf 
systemLog:
  destination: file
  path: /etc/mongodb/logs/mongod.log
  logAppend: true
storage:
  dbPath: /etc/mongodb/data
  engine: wiredTiger
  journal:
     enabled: true
net:
  bindIp: 0.0.0.0
  port: 20017
processManagement:
  fork: true
#修改系统配置文件（可以在任何目录使用mongodb命令）
[root@mongdb ~]# cat /etc/profileexport PATH=/etc/mongodb/bin:$PATH
#关闭mongodb
[root@mongdb ~]# mongod -f /etc/mongodb/conf/mongod.conf --shutdown
#开启mongodb
[root@mongdb bin]# ./mongod -f /etc/mongodb/conf/mongod.conf
#进入mongodb
[root@mongdb bin]# mongo localhost:20017

Mongo shell常用命令

命令说明
show dbs |show databases 显示数据库列表
use 数据库名 切换数据库，如果数据库 不存在创建数据库
db.dropDatabase() 删除数据库
show collections | show tables 显示当前数据的集合列表
db.集合名.stats() 查看集合详情
db.集合名.drop() 删除集合
show users 显示当前数据库的用户列表
show roles 显示当前数据库角色列表
show profile 显示最近发生的操作
load("xxx.js") 执行-个JavaScript脚本文件
exit | quit 退出当前shell
help 查看mongodb支持那些命令
db.help() 查询当前数据库支持的方法
db.集合名.help() 显示集合的帮助信息
db.version() 查看数据库版本

集合操作

#查看集合
show collections
#创建集合
db.createCollection("emp")
#删除集合
db.emp.drop()

创建集合语法

db.createCollection(name,id,open)

安全认证

#设置管理员用户名密码需要切换到admin库
use admin
#创建管理员(代码解释：user：名字。pwd:密码。roles:权限)
db.createUser({user:"fox",pwd:"fox",roles:["root"]})
#查看所有用户信息
show users
#删除用户
db.dropUser("fox")
权限名描述
read 允许用户读取指定数据库
readWrite 允许用户读写指定数据库
dbAdmin 允许用户在指定数据库中执行管理函数，如索引创建、删除、查看统计或system.profile
dbOwner 允许用户在指定数据库中执行任意操作增、删、改、查等
userAdmin 允许用户向system.users集合写入，可以在指定数据库里创建、删除和管理用户
clusterAdmin 只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限
readAnyDatabase 只在admin数据库中可用，赋予用户所有数据库的读写权限
readWriteAnyDatabase 只在admin数据库中可用，赋予用户所有数据库的读写权限
userAdminAnyDatabase 只在admin数据库中可用，赋予所有数据库的useraAmin权限
dbAdminAnyDatabase 只在数据库中可用，赋予用户所有数据库的dbAdmin权限
root 只在admin数据库中可用。超级账号，超级权限

实例：

#关闭之前开启的mongodb，以鉴权模式启动mongodb（也叫安全模式）
[root@mongdb bin]# ./mongod -f /etc/mongodb/conf/mongod.conf  --auth
#启用鉴权之后，链接MongoDB的相关操作都需要提供身份让认证
mongo 192.168.200.20:20017 -u fox -p fox --authenticationDatabase=admin
# 也可以这样进入
[root@mongdb bin]# mongo localhost:20017
#这样是添加成功
> db.createUser({user:"fox",pwd:"fox",roles:["root"]})
Successfully added user: { "user" : "fox", "roles" : [ "root" ] }

 

posted @ 2022-03-10 14:51  花花de代码生活  阅读(355)  评论(0)  编辑  收藏  举报