redis/Redis缓存集群.md

1646 lines
70 KiB
Markdown
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Redis缓存集群
redis缓存服务 缓存数据库
缓存
读取数据
cpu
L1 L2 L3 L4
一级缓存 二级缓存
cs context switch 上下文交换
free -m
buffer cache
mysql服务器
缓存 表缓存 数据缓存
nginx
expire 1d
304响应码
200
301
302
304
403
404
500
502
503
yum缓存
yum clean all
cdn 内容分发网络
web缓存
专业缓存服务器 缓存数据库
memcached
redis
memcache 已经过时
memcached 现在
本身不支持集群
缓存堆
```
# yum install memcached -y
# vim /etc/sysconfig/memcached
64
```
面试题:
redis和memcached的区别
redis的优势
## Memcached
**安装软件**
```bash
#yum install memcached -y
```
**修改配置文件:**
```bash
# vim /etc/sysconfig/memcached
PORT="11211" //同台机器有多个memcached做多实例可用编译安装的方式改变端口
USER="memcached"
MAXCONN="1024"
CACHESIZE="1500"
OPTIONS="-l 192.168.26.11" //监听网卡
```
```bash
[root@server 1802]# systemctl start memcached.service
[root@server 1802]# ps aux | grep memca
memcach+ 20212 0.0 0.0 325564 1180 ? Ssl 10:15 0:00 /usr/bin/memcached -u memcached -p 11211 -m 1500 -c 1024
```
**编译安装的memcached启动方法**
```bash
# /usr/local/memcached/bin/memcached -u memcached -p 11211 -m 1500 -c 1024
```
**编译安装的memcached开机启动方案**
```bash
方式1.把启动命令写到rc.local里面
# chmod a+x /etc/rc.d/rc.local
# echo '/usr/local/memcached/bin/memcached -u memcached -p 11211 -m 1500 -c 1024' >> /etc/rc.d/rc.local
# systemctl enable rc-local
方式2.编写shell启动脚本
```
**如何部署分布式缓存服务器**
```
1.使用什么软件
2.用多少台机器,每台机器多大内存
3.如果是redis对硬盘要求也很高
4.安装软件
```
**测试memcached**
使用memcached的原始命令
```bash
# yum install telnet
# telnet 10.18.44.126 11211
Trying 10.18.44.126...
Connected to 10.18.44.126.
Escape character is '^]'.
set name 0 900 5 //设置名称为name的key
wing //给name的值
get name //查询key为name的值
set 设置key
name key的名字 自己定义
0 key的id号需要和其他的key不一样
900 缓存过期时间
5 字符串最大长度
```
**关于php扩展包**
```
官方地址http://pecl.php.net/
```
php和memcached不在同一台机器上则需要在php上安装php的memcache扩展包
```bash
#vim mem_php.sh
#!/bin/bash
wget -c http://soft.vpser.net/web/memcache/memcache-3.0.8.tgz
tar zxvf memcache-3.0.8.tgz
cd memcache-3.0.8/
/usr/local/php/bin/phpize
./configure --with-php-config=/usr/local/php/bin/php-config
make && make install
```
```bash
#vim redis_php.sh
wget -c http://pecl.php.net/get/redis-2.2.5.tgz
tar zxf redis-2.2.5.tgz
cd redis-2.2.5/
/usr/local/php/bin/phpize
./configure --with-php-config=/usr/local/php/bin/php-config
make && make install
cd ../
sed -i '/the dl()/i extension = "redis.so"' /usr/local/php/etc/php.ini
```
多实例
```ini
目的:最大化利用物理资源
在同一台机器上启动同一个应用
不能yum安装
编译安装 改端口
```
## Redis
### Redis介绍
redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。目前Vmware在资助着redis项目的开发和维护。
name=lilei
name
age=28
age
key 键
value 值
键值对
nosql数据库
redis mongodb memcached
关系型数据库
sql 标准结构化查询语言
oracle mysql mariadb sqlserver db2
**官网**
redis.io
注:域名后缀io属于国家域名是british Indian Ocean territory即英属印度洋领地
**作者**
[![file://C:/Users/86186/AppData/Local/Temp/.5XAVO1/1.png](assets/1-16571578999821.png)]()
Salvatore Sanfilippo来自意大利的西西里岛现在居住在卡塔尼亚。目前供职于Pivotal公司。
他使用的网名是antirez如果你有兴趣可以去他的博客逛逛地址是antirez.com当然也可以去follow他的github地址是http://github.com/antirez。
**谁在使用redis**
Blizzard、digg、stackoverflow、github、flickr …
### 安装redis
本文档适用于rhel79通用
从redis.io下载最新版redis-X.Y.Z.tar.gz后解压然后进入redis-X.Y.Z文件夹后直接make即可
```bash
# wget http://download.redis.io/releases/redis-4.0.9.tar.gz
# tar xzf redis-4.0.9.tar.gz
# cd redis-4.0.9
# yum install make gcc -y
# make
如果是Centos9用需要带上参数 MALLOC=libc
# make MALLOC=libc
```
注意如果因为缺包而报错在安装完缺失的包之后需要重新解压新的安装包进行make安装
**启动redis服务**
默认以非daemon形式启动
二进制文件是编译完成后创建在src目录下通过下面的命令启动Redis服务
```bash
# ./src/redis-server
# ./src/redis-server ../redis.conf //指定配置文件位置启动服务
启动的时候发现warning:
# WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot
解决方法:
# vim /etc/rc.local
echo never > /sys/kernel/mm/transparent_hugepage/enabled
# chmod +x /etc/rc.d/rc.local
# systemctl enable rc-local
```
**配置以daemon方式运行redis**
编写启动脚本:注意修改脚本内需要修改的部分,并且给予其可执行权限
centos7之前initd
centos7/8: systemd (现在不适用于stream 9)
```bash
# vim /etc/init.d/redis
#!/bin/sh
# chkconfig: 2345 10 90
# description: Start and Stop redis
REDISPORT=6379
EXEC=/redis-4.0.9/src/redis-server
CLIEXEC=/redis-4.0.9/src/redis-cli
PIDFILE=/var/run/redis_${REDISPORT}.pid
CONF="/etc/redis/${REDISPORT}.conf"
case "$1" in
start)
if [ -f $PIDFILE ]
then
echo "$PIDFILE exists, process is already running or crashed"
else
echo "Starting Redis server..."
$EXEC $CONF &
fi
;;
stop)
if [ ! -f $PIDFILE ]
then
echo "$PIDFILE does not exist, process is not running"
else
PID=$(cat $PIDFILE)
echo "Stopping ..."
$CLIEXEC -p $REDISPORT shutdown
while [ -x /proc/${PID} ]
do
echo "Waiting for Redis to shutdown ..."
sleep 1
done
echo "Redis stopped"
fi
;;
restart)
"$0" stop
sleep 3
"$0" start
;;
*)
echo "Please use start or stop as first argument"
;;
esac
```
**将redis脚本加入chkconfig开机启动**
```bash
#chkconfig --add redis
#chkconfig redis on
rhel6里的启动方式
# /etc/init.d/redis start
# service redis start
rhel7、8里的启动方式
# systemctl daemon-reload
# systemctl status redis
# /etc/init.d/redis start
# service redis start
# systemctl start redis
```
**Centos stream9 redis服务管理**
```bash
centos stream9 上redis服务管理配置
# vim /usr/lib/systemd/system/redis.service
[Unit]
Description=redis
After=syslog.target
After=network.target
[Service]
Environment="CONFFILE=/redis-7.2.4/redis.conf"
ExecStart=/redis-7.2.4/src/redis-server $CONFFILE
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
Restart=on-failure
RestartSec=30s
[Install]
WantedBy=multi-user.target
# systemctl daemon-reload
# systemctl status redis
# systemctl start redis
```
**端口**
默认服务端口为6379
**客户端命令连接redis**
你可以使用内置的客户端命令redis-cli进行使用
```bash
[root@redis1 redis-4.0.9]# ./src/redis-cli
127.0.0.1:6379> set name wing
OK
127.0.0.1:6379> get name
"wing"
127.0.0.1:6379> save //保存数据到磁盘
127.0.0.1:6379> shutdown //通过客户端来关闭redis服务端 禁用
```
**各种redis工具**
```bash
# find ./src -type f -executable
./redis-benchmark //用于进行redis性能测试的工具
./redis-check-dump //用于修复出问题的dump.rdb文件
./redis-cli //redis的客户端
./redis-server //redis的服务端
./redis-check-aof //用于修复出问题的AOF文件
./redis-sentinel //用于集群管理
```
### php的redis扩展
```bash
1.安装redis
2.启动redis
3.安装php redis extention
php的扩展包 官方网站 pecl.php.net
centos stream 9
# yum install php-cli* -y
# yum install php-devel -y
# pecl install redis
修改php的配置文件
# vim /etc/php.ini
# ...the dl()...
extension = "redis.so"
4.编写测试代码
# cat test.php
<?php
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->set('name', 'leizi');
echo $redis->get('name');
?>
5.测试
# php test.php
leizi
==================================
centos7
直接yum安装redis和redis扩展
# yum install epel-release -y
# yum install redis php php-pecl-redis
```
### Redis数据结构(扩展)
redis是一种高级的key:value存储系统其中value支持五种数据类型
1.字符串 strings
2.字符串列表lists
3.字符串集合sets
4.有序字符串集合sorted sets
5.哈希hashes
**关于key需要注意几点**
1.key不要太长尽量不要超过1024字节这不仅消耗内存而且会降低查找的效率
2.key也不要太短太短的话key的可读性会降低
3.在一个项目中key最好使用统一的命名模式例如user:10000:passwd。
**redis数据结构 strings**
如果只使用redis中的字符串类型且不使用redis的持久化功能那么redis就和memcache非常非常的像了。这说明strings类型是一个很基础的数据类型也是任何存储系统都必备的数据类型。
简单的例子:
```bash
set mystr "hello world!" //设置字符串类型
get mystr //读取字符串类型
```
字符串类型的用法就是这么简单
还可以通过字符串类型进行数值操作在遇到数值操作时redis会将字符串类型转换成数值。
```sql
127.0.0.1:6379> set mynum "2"
OK
127.0.0.1:6379> get mynum
"2"
127.0.0.1:6379> incr mynum
(integer) 3
127.0.0.1:6379> get mynum
"3"
```
由于INCR等指令本身就具有原子操作的特性所以完全可以利用redis的INCR、INCRBY、DECR、DECRBY等指令来实现原子计数的效果假如在某种场景下有3个客户端同时读取了mynum的值值为2然后对其同时进行了加1的操作那么最后mynum的值一定是5。不少网站都利用redis的这个特性来实现业务上的统计计数需求。
**redis数据结构 lists**
首先要明确一点redis中的lists在底层实现上并不是数组而是链表也就是说对于一个具有上百万个元素的lists来说在头部和尾部插入一个新元素其时间复杂度是常数级别的比如用LPUSH在10个元素的lists头部插入新元素和在上千万元素的lists头部插入新元素的速度应该是相同的。
虽然lists有这样的优势但同样有其弊端那就是链表型lists的元素定位会比较慢而数组型lists的元素定位就会快得多。
lists的常用操作包括LPUSH、RPUSH、LRANGE等。我们可以用LPUSH在lists的左侧插入一个新元素用RPUSH在lists的右侧插入一个新元素用LRANGE命令从lists中指定一个范围来提取元素。我们来看几个例子
```sql
新建一个list叫做mylist,并在列表头部插入元素"1"
127.0.0.1:6379> lpush mylist "1"
(integer) 1 //返回当前mylist中的元素个数
127.0.0.1:6379> rpush mylist "2" //mylist右侧插入元素"2"
(integer) 2
127.0.0.1:6379> lpush mylist "0" //mylist左侧插入元素"0"
(integer) 3
0 1 2
127.0.0.1:6379> lrange mylist 0 1 //列出mylist中从编号0到编号1的元素
1) "0"
2) "1"
127.0.0.1:6379> lrange mylist 0 -1 //列出mylist中从编号0到倒数第一个元素
1) "0"
2) "1"
3) "2"
```
lists的应用相当广泛举几个例子
1.我们可以利用lists来实现一个消息队列而且可以确保先后顺序不必像MySQL那样还需要通过ORDER BY来进行排序。
2.利用LRANGE还可以很方便的实现分页的功能。
3.在博客系统中每片博文的评论也可以存入一个单独的list中。
**redis数据结构 集合set **
redis的集合是一种无序的集合集合中的元素没有先后顺序。
集合相关的操作也很丰富,如添加新元素、删除已有元素、取交集、取并集、取差集等。
例子:
```sql
//向集合myset中加入一个新元素"one"
127.0.0.1:6379> sadd myset "one"
(integer) 1
127.0.0.1:6379> sadd myset "two"
(integer) 1
//列出集合myset中的所有元素
127.0.0.1:6379> smembers myset
1) "one"
2) "two"
//判断元素1是否在集合myset中,返回1表示存在
127.0.0.1:6379> sismember myset "one"
(integer) 1
//判断元素3是否在集合myset中,返回0表示不存在
127.0.0.1:6379> sismember myset "three"
(integer) 0
//新建一个新的集合yourset
127.0.0.1:6379> sadd yourset "1"
(integer) 1
127.0.0.1:6379> sadd yourset "2"
(integer) 1
127.0.0.1:6379> smembers yourset
1) "1"
2) "2"
//对两个集合求并集 集合 几何
127.0.0.1:6379> sunion myset yourset
1) "1"
2) "one"
3) "2"
4) "two"
```
对于集合的使用也有一些常见的方式比如QQ有一个社交功能叫做“好友标签”大家可以给你的好友贴标签比如“大美女”、“土豪”、“欧巴”等等这时就可以使用redis的集合来实现把每一个用户的标签都存储在一个集合之中。
**redis数据结构 有序集合**
redis不但提供了无序集合sets还很提供了有序集合sorted sets。有序集合中的每个元素都关联一个序号score这便是排序的依据。
很多时候我们都将redis中的有序集合叫做zsets这是因为在redis中有序集合相关的操作指令都是以z开头的比如zrange、zadd、zrevrange、zrangebyscore等等
例子:
```sql
//新增一个有序集合myzset,并加入一个元素baidu.com,给它赋予的序号是1
127.0.0.1:6379> zadd myzset 1 baidu.com
(integer) 1
//myzset中新增一个元素360.com,赋予它的序号是3
127.0.0.1:6379> zadd myzset 3 360.com
(integer) 1
//myzset中新增一个元素google.com,赋予它的序号是2
127.0.0.1:6379> zadd myzset 2 google.com
(integer) 1
//列出myzset的所有元素,同时列出其序号,可以看出myzset已经是有序的了
127.0.0.1:6379> zrange myzset 0 -1 with scores
1) "baidu.com"
2) "1"
3) "google.com"
4) "2"
5) "360.com"
6) "3"
//只列出myzset的元素
127.0.0.1:6379> zrange myzset 0 -1
1) "baidu.com"
2) "google.com"
3) "360.com"
```
**redis数据结构 哈希hash**
hashes即哈希。哈希是从redis-2.0.0版本之后才有的数据结构。
hashes存的是字符串和字符串值之间的映射比如一个用户要存储其全名、姓氏、年龄等等就很适合使用哈希。
例子:
```
//建立哈希,并赋值
127.0.0.1:6379> HMSET user:001 username antirez password P1pp0 age 28
OK
//列出哈希的内容
127.0.0.1:6379> HGETALL user:001
1) "username"
2) "antirez"
3) "password"
4) "P1pp0"
5) "age"
6) "34"
//更改哈希中的某一个值
127.0.0.1:6379> HSET user:001 password 12345
(integer) 0
//再次列出哈希的内容
127.0.0.1:6379> HGETALL user:001
1) "username"
2) "antirez"
3) "password"
4) "12345"
5) "age"
6) "34"
```
有关hashes的操作同样很丰富需要时可从这里https://redis.io/commands#hash查询。
### Redis事务处理(了解)
众所周知,事务是指"一个完整的动作,要么全部执行,要么什么也没有做"。
在聊redis事务处理之前要先和大家介绍四个redis指令即MULTI、EXEC、DISCARD、WATCH。这四个指令构成了redis事务处理的基础。
1.MULTI用来组装一个事务
2.EXEC用来执行一个事务
3.DISCARD用来取消一个事务
4.WATCH用来监视一些key一旦这些key在事务执行之前被改变则取消事务的执行。
一个MULTI和EXEC的例子
```
redis> MULTI //标记事务开始
OK
redis> INCR user_id //多条命令按顺序入队
QUEUED
redis> INCR user_id
QUEUED
redis> INCR user_id
QUEUED
redis> PING
QUEUED
redis> EXEC //执行
1) (integer) 1
2) (integer) 2
3) (integer) 3
4) PONG
```
在上面的例子中看到了QUEUED的字样这表示我们在用MULTI组装事务时每一个命令都会进入到内存队列中缓存起来如果出现QUEUED则表示我们这个命令成功插入了缓存队列在将来执行EXEC时这些被QUEUED的命令都会被组装成一个事务来执行。
对于事务的执行来说如果redis开启了AOF持久化的话那么一旦事务被成功执行事务中的命令就会通过write命令一次性写到磁盘中去如果在向磁盘中写的过程中恰好出现断电、硬件故障等问题那么就可能出现只有部分命令进行了AOF持久化这时AOF文件就会出现不完整的情况这时可以使用redis-check-aof工具来修复这一问题这个工具会将AOF文件中不完整的信息移除确保AOF文件完整可用。
有关事务,经常会遇到的是两类错误:
1.调用EXEC之前的错误
2.调用EXEC之后的错误
“调用EXEC之前的错误”有可能是由于语法有误导致的也可能时由于内存不足导致的。只要出现某个命令无法成功写入缓冲队列的情况redis都会进行记录在客户端调用EXEC时redis会拒绝执行这一事务。这时2.6.5版本之后的策略。在2.6.5之前的版本中redis会忽略那些入队失败的命令只执行那些入队成功的命令。我们来看一个这样的例子
```
127.0.0.1:6379> multi
OK
127.0.0.1:6379> haha //一个明显错误的指令
(error) ERR unknown command 'haha'
127.0.0.1:6379> ping
QUEUED
127.0.0.1:6379> exec
```
//redis无情的拒绝了事务的执行原因是“之前出现了错误”
(error) EXECABORT Transaction discarded because of previous errors.
而对于“调用EXEC之后的错误”redis则采取了完全不同的策略即redis不会理睬这些错误而是继续向下执行事务中的其他命令。这是因为对于应用层面的错误并不是redis自身需要考虑和处理的问题所以一个事务中如果某一条命令执行失败并不会影响接下来的其他命令的执行。我们也来看一个例子
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set age 23
QUEUED
//age不是集合所以如下是一条明显错误的指令
127.0.0.1:6379> sadd age 15
QUEUED
127.0.0.1:6379> set age 29
QUEUED
127.0.0.1:6379> exec //执行事务时redis不会理睬第2条指令执行错误
\1) OK
\2) (error) WRONGTYPE Operation against a key holding the wrong kind of value
\3) OK
127.0.0.1:6379> get age
"29" //可以看出第3条指令被成功执行了
最后一个指令“WATCH”这是一个很好用的指令它可以帮我们实现类似于“乐观锁”的效果即CAScheck and set
WATCH本身的作用是“监视key是否被改动过”而且支持同时监视多个key只要还没真正触发事务WATCH都会尽职尽责的监视一旦发现某个key被修改了在执行EXEC时就会返回nil表示事务无法触发。
127.0.0.1:6379> set age 23
OK
127.0.0.1:6379> watch age //开始监视age
OK
127.0.0.1:6379> set age 24 //在EXEC之前age的值被修改了
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set age 25
QUEUED
127.0.0.1:6379> get age
QUEUED
127.0.0.1:6379> exec //触发EXEC
(nil) //事务无法被执行
### Redis持久化
开启持久化功能后重启redis时数据会自动通过持久化文件恢复
**redis提供了两种持久化的方式**
```ini
RDBRedis DataBase
在不同的时间点将redis存储的数据生成快照并存储到磁盘等介质上
AOFAppend Only File
AOF则是换了一个角度来实现持久化那就是将redis执行过的所有写指令记录下来在下次redis重新启动时只要把这些写指令从前到后再重复执行一遍即可实现数据恢复。
```
mysql备份数据的方法
mysqldump 1 2 3 name表 每次备份的都是“完整的数据”
binlog日志 1 2(从第一次结束到现在的数据) 3从第二次结束到现在的数据
RDB和AOF两种方式也可同时使用在这种情况下如果redis重启则会优先采用AOF方式来进行数据恢复因为AOF方式的数据恢复完整度更高。
如果你没有数据持久化的需求可关闭RDB和AOFredis将变成一个纯内存数据库就像memcached一样。
**redis持久化 RDB**
RDB方式是将redis某一时刻的数据持久化到磁盘中是一种快照式的持久化方法。
```idl
redis在进行数据持久化的过程中会先将数据写入到一个临时文件中待持久化过程都结束了才会用这个临时文件替换上次持久化好的文件。这种特性让我们可随时进行备份因为快照文件总是完整可用的。
对于RDB方式redis会单独创建fork一个子进程来进行持久化而主进程是不会进行任何IO操作的这样就确保了redis极高的性能。
```
如果需要进行大规模数据的恢复且对于数据恢复的完整性不是非常敏感那RDB方式要比AOF方式更加的高效。
虽然RDB有不少优点但它的缺点也是不容忽视的。如果你对数据的完整性非常敏感那么RDB方式就不太适合你因为即使你每5分钟都持久化一次当redis故障时仍然会有近5分钟的数据丢失。所以redis还提供了另一种持久化方式那就是AOF。
**redis持久化 AOF**
AOF英文是Append Only File即只允许追加不允许改写的文件。
```
AOF方式是将执行过的写指令记录下来在数据恢复时按照从前到后的顺序再将指令都执行一遍。
```
通过配置redis.conf中的appendonly yes就可以打开AOF功能。如果有写操作如SET等redis就会被追加到AOF文件的末尾。
```
默认的AOF持久化策略是每秒钟fsync一次fsync是指把缓存中的写指令记录到磁盘中因为在这种情况下redis仍然可以保持很好的处理性能即使redis故障也只会丢失最近1秒钟的数据。
```
```
如果在追加日志时恰好遇到磁盘空间满、inode满或断电等情况导致日志写入不完整也没有关系redis提供了redis-check-aof工具可以用来进行日志修复。
```
```
因为采用了追加方式如果不做任何处理的话AOF文件会变得越来越大为此redis提供了AOF文件重写rewrite机制即当AOF文件的大小超过所设定的阈值时redis就会启动AOF文件的内容压缩只保留可以恢复数据的最小指令集。
```
举个例子或许更形象假如我们调用了100次INCR指令在AOF文件中就要存储100条指令但这明显是很低效的完全可以把这100条指令合并成一条SET指令这就是重写机制的原理。
在进行AOF重写时仍然是采用先写临时文件全部完成后再替换的流程所以断电、磁盘满等问题都不会影响AOF文件的可用性这点可以放心。
AOF方式的另一个好处我们通过一个"场景再现"来说明。某同学在操作redis时不小心执行了FLUSHALL导致redis内存中的数据全部被清空了这是很悲剧的事情。不过这也不是世界末日只要redis配置了AOF持久化方式且AOF文件还没有被重写rewrite我们就可以用最快的速度暂停redis并编辑AOF文件将最后一行的FLUSHALL命令删除然后重启redis就可以恢复redis的所有数据到FLUSHALL之前的状态了。是不是很神奇这就是AOF持久化方式的好处之一。但是如果AOF文件已经被重写了那就无法通过这种方法来恢复数据了。
```
虽然优点多多但AOF方式也同样存在缺陷比如在同样数据规模的情况下AOF文件要比RDB文件的体积大。而且AOF方式的恢复速度也要慢于RDB方式。
```
如果你直接执行BGREWRITEAOF命令那么redis会生成一个全新的AOF文件其中便包括了可以恢复现有数据的最少的命令集。
如果运气比较差AOF文件出现了被写坏的情况redis并不会贸然加载这个有问题的AOF文件而是报错退出。这时可以通过以下步骤来修复出错的文件
```
1.备份被写坏的AOF文件
2.运行redis-check-aof --fix进行修复
3.用diff -u来看下两个文件的差异确认问题点
4.重启redis加载修复后的AOF文件
```
**AOF重写内部运行原理**
```
在重写即将开始之际redis会创建fork一个“重写子进程”这个子进程会首先读取现有的AOF文件并将其包含的指令进行分析压缩并写入到一个临时文件中。
与此同时主工作进程会将新接收到的写指令一边累积到内存缓冲区中一边继续写入到原有的AOF文件中这样做是保证原有的AOF文件的可用性避免在重写过程中出现意外。
当“重写子进程”完成重写工作后它会给父进程发一个信号父进程收到信号后就会将内存中缓存的写指令追加到新AOF文件中。
当追加结束后redis就会用新AOF文件来代替旧AOF文件之后再有新的写指令就都会追加到新的AOF文件中了。
```
**redis持久化 如何选择RDB和AOF**
对于我们应该选择RDB还是AOF官方的建议是**两个同时使用**。这样可以提供更可靠的持久化方案。
写入速度快 恢复速度慢 AOF
写入速度慢 恢复速度快 RDB
### Redis主从
像MySQL一样redis是支持主从同步的而且也支持一主多从以及多级从结构。
主从结构一是为了纯粹的冗余备份二是为了提升读性能比如很消耗性能的SORT就可以由从服务器来承担。
redis的主从同步是异步进行的这意味着主从同步不会影响主逻辑也不会降低redis的处理性能。
主从架构中,可以考虑关闭主服务器的数据持久化功能,只让从服务器进行持久化,这样可以提高主服务器的处理性能。
在主从架构中从服务器通常被设置为只读模式这样可以避免从服务器的数据被误修改。但是从服务器仍然可以接受CONFIG等指令所以还是不应该将从服务器直接暴露到不安全的网络环境中。如果必须如此那可以考虑给重要指令进行重命名来避免命令被外人误执行。
**同步原理**
```nim
从服务器会向主服务器发出SYNC指令当主服务器接到此命令后就会调用BGSAVE指令来创建一个子进程专门进行数据持久化工作也就是将主服务器的数据写入RDB文件中。在数据持久化期间主服务器将执行的写指令都缓存在内存中。
在BGSAVE指令执行完成后主服务器会将持久化好的RDB文件发送给从服务器从服务器接到此文件后会将其存储到磁盘上然后再将其读取到内存中。这个动作完成后主服务器会将这段时间缓存的写指令再以redis协议的格式发送给从服务器。
```
即使有多个从服务器同时发来SYNC指令主服务器也只会执行一次BGSAVE然后把持久化好的RDB文件发给多个下游。在redis2.8版本之前如果从服务器与主服务器因某些原因断开连接的话都会进行一次主从之间的全量的数据同步而在2.8版本之后redis支持了效率更高的增量同步策略这大大降低了连接断开的恢复成本。
主服务器会在内存中维护一个缓冲区缓冲区中存储着将要发给从服务器的内容。从服务器在与主服务器出现网络瞬断之后从服务器会尝试再次与主服务器连接一旦连接成功从服务器就会把“希望同步的主服务器ID”和“希望请求的数据的偏移位置replication offset”发送出去。主服务器接收到这样的同步请求后首先会验证主服务器ID是否和自己的ID匹配其次会检查“请求的偏移位置”是否存在于自己的缓冲区中如果两者都满足的话主服务器就会向从服务器发送增量内容。
增量同步功能需要服务器端支持全新的PSYNC指令。这个指令只有在redis-2.8之后才具有。
### **Redis哨兵模式**
Sentinel(哨兵)是用于监控redis集群中Master状态的工具其已经被集成在redis2.4+的版本中
**作用**
```nim
1、Master状态检测
2、如果Master异常则会进行Master-Slave切换将其中一个Slave作为Master将之前的Master作为Slave
3、Master-Slave切换后master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变即master_redis.conf中会多一行slaveof的配置sentinel.conf的监控目标会随之调换
```
**工作方式**
```nim
1、每个Sentinel以每秒钟一次的频率向它所知的MasterSlave以及其他 Sentinel 实例发送一个 PING 命令
2、如果一个实例instance距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值, 则这个实例会被 Sentinel 标记为主观下线。
3、如果一个Master被标记为主观下线则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。
4、当有足够数量的 Sentinel大于等于配置文件指定的值在指定的时间范围内确认Master的确进入了主观下线状态 则Master会被标记为客观下线
5、在一般情况下, 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有MasterSlave发送 INFO 命令
6、当Master被 Sentinel 标记为客观下线时Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次
7、若没有足够数量的 Sentinel 同意 Master 已经下线, Master 的客观下线状态就会被移除。
Master 重新向 Sentinel PING 命令返回有效回复 Master 的主观下线状态就会被移除。
```
主观下线和客观下线
```bash
主观下线Subjectively Down简称 SDOWN指的是当前 Sentinel 实例对某个redis服务器做出的下线判断。
客观下线Objectively Down 简称 ODOWN指的是多个 Sentinel 实例在对Master Server做出 SDOWN 判断,并且通过 SENTINEL is-master-down-by-addr 命令互相交流之后得出的Master Server下线判断然后开启failover.
```
### Redis主从+哨兵模式实验
消除redis的单节点故障
3台机器
1主
2从
关闭防火墙和selinux
时间 一致
1.自己部署时间服务器
2.直接使用公网时间服务器
主机名称修改
解析
互相ping通
每台机器安装Redis
**主从配置**
```bash
master:
bind 0.0.0.0 //监控本地所有网卡IP
protected-mode no
客户端连到服务器查看复制信息:
> info replication
slave1:
bind 0.0.0.0
#slaveof master_ip master_port //修改master_ip和port 6.0以前redis版本的写法
replicaof master_ip master_port
protected-mode no
客户端连到服务器查看复制信息:
> info replication
slave2:
bind 0.0.0.0
#slaveof master_ip master_port
replicaof master_ip master_port
protected-mode no
客户端连到服务器查看复制信息:
> info replication
```
**哨兵模式1主2从做好 最少3台机器**
配置哨兵模式:
每台机器上修改redis主配置文件设置bind 0.0.0.0
每台机器上修改**sentinel.conf**配置文件:**添加**如下配置
```bash
sentinel monitor mymaster 10.0.0.137 6379 1
sentinel down-after-milliseconds mymaster 3000
sentinel failover-timeout mymaster 10000 # slave认为master挂掉之后10秒钟开始故障转移
protected-mode no
每台机器启动服务:
# ./src/redis-sentinel sentinel.conf
```
配置解析:
**sentinel monitor mymaster 10.0.0.137 6379** 2
这一行代表sentinel监控的master的名字叫做mymaster,地址为10.0.0.137行尾最后的一个2代表什么意思呢我们知道网络是不可靠的有时候一个sentinel会因为网络堵塞而误以为一个master redis已经死掉了当sentinel集群式解决这个问题的方法就变得很简单只需要多个sentinel互相沟通来确认某个master是否真的死了这个2代表**当集群中有2个sentinel认为master死了时才能真正认为该master已经不可用了**。sentinel集群中各个sentinel也有互相通信通过gossip协议
**sentinel down-after-milliseconds mymaster 3000**
sentinel会向master发送心跳PING来确认master是否存活如果master在“一定时间范围”内不回应PONG 或者是回复了一个错误消息,**那么这个sentinel会主观地(单方面地)认为这个master已经不可用了**(subjectively down, 也简称为SDOWN)。而这个down-after-milliseconds就是用来指定这个“一定时间范围”的单位是**毫秒**。
### Redis配置文件
加载配置文件
可以在启动redis-server时指定应该加载的配置文件方法如下
\# ./redis-server /path/to/redis.conf
**度量单位**
\# 1k => 1000 bytes
\# 1kb => 1024 bytes
\# 1m => 1000000 bytes
\# 1mb => 1024*1024 bytes
\# 1g => 1000000000 bytes
\# 1gb => 1024*1024*1024 bytes
redis配置中对单位的大小写不敏感1GB、1Gb和1gB都是相同的。redis只支持bytes不支持bit单位。
**引入外部配置文件**
很像C/C++中的include指令比如
include /path/to/other.conf
**redis配置文件被分成了几大块区域**
1.通用generalgeneration
**2.快照snapshotting**
**3.复制replication**
4.安全security
5.限制limits)
**6.追加模式append only mode)**
7.LUA脚本lua scripting)
**8.慢日志slow log)**
9.事件通知event notification
**redis配置 -通用**
默认redis不是以daemon形式来运行的。通过daemonize配置项可以控制redis的运行形式如果改为yes那么redis就会以daemon形式运行
daemonize no
当以daemon形式运行时redis会生成一个pid文件默认会生成在/var/run/redis.pid。可通过pidfile来指定pid文件生成的位置比如
pidfile /path/to/redis.pid
默认redis会响应本机所有可用网卡的连接请求。当然redis允许你通过bind配置项来指定要绑定的IP比如
bind 192.168.1.2 10.8.4.2
bind 0.0.0.0 //表示监听所有网卡
redis的默认服务端口是6379你可以通过port配置项来修改。如果端口设置为0的话redis便不会监听端口了。
port 6379
"如果redis不监听端口还怎么与外界通信呢"redis还支持通过unix socket方式来接收请求。可通过unixsocket配置项来指定unix socket文件的路径并通过unixsocketperm来指定文件的权限。
unixsocket /tmp/redis.sock
unixsocketperm 755
当一个redis-client一直没有请求发向server端那么server端有权主动关闭这个连接可以通过timeout来设置"空闲超时时限"0表示永不关闭。
timeout 0
TCP连接保活策略可以通过tcp-keepalive配置项来进行设置单位为秒假如设置为60秒则server端会每60秒向连接空闲的客户端发起一次ACK请求以检查客户端是否已经挂掉对于无响应的客户端则会关闭其连接。所以关闭一个连接最长需要120秒的时间。如果设置为0则不会进行保活检测。
tcp-keepalive 0
redis支持通过loglevel配置项设置日志等级共分四级即debug、verbose、notice、warning。
loglevel notice
通过logfile配置项来设置日志文件的生成位置。如果设置为空字符串则redis会将日志输出到标准输出。假如你在daemon情况下将日志设置为输出到标准输出则日志会被写到/dev/null中。
logfile ""
如果希望日志打印到syslog中通过syslog-enabled来控制。另外syslog-ident还可以让你指定syslog里的日志标志比如
syslog-ident redis
而且还支持指定syslog设备值可以是USER或LOCAL0-LOCAL7。
syslog-facility local0
设置数据库的总数量假如你希望一个redis包含16个数据库那么设置如下
databases 16
这16个数据库的编号将是0到15。默认的数据库是编号为0的数据库。用户可以使用select <DBid>来选择相应的数据库。
**redis配置 快照**
快照主要涉及的是redis的RDB持久化相关的配置
用如下的指令来让数据保存到磁盘上即控制RDB快照功能
save <seconds> <changes>
举例
save 900 1 //表示每15分钟且至少有1个key改变就触发一次持久化
save 300 10 //表示每5分钟且至少有10个key改变就触发一次持久化
save 60 10000 //表示每60秒至少有10000个key改变就触发一次持久化
内存
如果想禁用RDB持久化的策略只要不设置任何save指令就可以或者给save传入一个空字符串参数也可以达到相同效果就像这样
save ""
如果用户开启了RDB快照功能那么在redis持久化数据到磁盘时如果出现失败默认情况下redis会停止接受所有的写请求。这样做的好处在于可以让用户很明确的知道内存中的数据和磁盘上的数据已经存在不一致了。如果redis不顾这种不一致一意孤行的继续接收写请求就可能会引起一些灾难性的后果。
如果下一次RDB持久化成功redis会自动恢复接受写请求。
当然如果你不在乎这种数据不一致或者有其他的手段发现和控制这种不一致的话你完全可以关闭这个功能以便在快照写入失败时也能确保redis继续接受新的写请求。配置项如下
stop-writes-on-bgsave-error yes
对于存储到磁盘中的快照可以设置是否进行压缩存储。如果是的话redis会采用LZF算法进行压缩。如果你不想消耗CPU来进行压缩的话可以设置为关闭此功能但是存储在磁盘上的快照会比较大。
rdbcompression yes
在存储快照后我们还可以让redis使用CRC64算法来进行数据校验但是这样做会增加大约10%的性能消耗,如果你希望获取到最大的性能提升,可以关闭此功能。
rdbchecksum yes
设置快照文件的名称,默认配置:
dbfilename dump.rdb
设置这个快照文件存放的路径。默认设置就是当前文件夹:
dir ./
**redis配置 复制**
redis提供了主从同步功能。
通过slaveof配置项可以控制某一个redis作为另一个redis的从服务器通过指定IP和端口来定位到主redis的位置。一般情况下建议用户为从redis设置一个不同频率的快照持久化的周期或者为从redis配置一个不同的服务端口等等。
slaveof <masterip> <masterport>
如果主redis设置了验证密码使用requirepass来设置则在从redis的配置中要使用masterauth来设置校验密码否则主redis会拒绝从redis的访问请求。
masterauth <master-password>
当从redis失去了与主redis的连接或者主从同步正在进行中时redis该如何处理外部发来的访问请求呢这里从redis可以有两种选择
第一种选择如果slave-serve-stale-data设置为yes默认则从redis仍会继续响应客户端的读写请求。
第二种选择如果slave-serve-stale-data设置为no则从redis会对客户端的请求返回“SYNC with master in progress”当然也有例外当客户端发来INFO请求和SLAVEOF请求从redis还是会进行处理。
你可以控制一个从redis是否可以接受写请求。将数据直接写入从redis一般只适用于那些生命周期非常短的数据因为在主从同步时这些临时数据就会被清理掉。自从redis2.6版本之后默认从redis为只读。
slave-read-only yes
只读的从redis并不适合直接暴露给不可信的客户端。为了尽量降低风险可以使用rename-command指令来将一些可能有破坏力的命令重命名避免外部直接调用。比如
rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
从redis会周期性的向主redis发出PING包。你可以通过repl_ping_slave_period指令来控制其周期。默认是10秒。
repl-ping-slave-period 10
在主从同步时,可能在这些情况下会有超时发生:
1.以从redis的角度来看当有大规模IO传输时。
2.以从redis的角度来看当数据传输或PING时主redis超时
3.以主redis的角度来看在回复从redis的PING时从redis超时
用户可以设置上述超时的时限不过要确保这个时限比repl-ping-slave-period的值要大否则每次主redis都会认为从redis超时。
repl-timeout 60
我们可以控制在主从同步时是否禁用TCP_NODELAY。如果开启TCP_NODELAY那么主redis会使用更少的TCP包和更少的带宽来向从redis传输数据。但是这可能会增加一些同步的延迟大概会达到40毫秒左右。如果你关闭了TCP_NODELAY那么数据同步的延迟时间会降低但是会消耗更多的带宽。
repl-disable-tcp-nodelay no
还可以设置同步队列长度。队列长度backlog)是主redis中的一个缓冲区在与从redis断开连接期间主redis会用这个缓冲区来缓存应该发给从redis的数据。这样的话当从redis重新连接上之后就不必重新全量同步数据只需要同步这部分增量数据即可。
repl-backlog-size 1mb
如果主redis等了一段时间之后还是无法连接到从redis那么缓冲队列中的数据将被清理掉。我们可以设置主redis要等待的时间长度。如果设置为0则表示永远不清理。默认是1个小时。
repl-backlog-ttl 3600
可以给众多的从redis设置优先级在主redis持续工作不正常的情况优先级高的从redis将会升级为主redis。而编号越小优先级越高。比如一个主redis有三个从redis优先级编号分别为10、100、25那么编号为10的从redis将会被首先选中升级为主redis。当优先级被设置为0时这个从redis将永远也不会被选中。默认的优先级为100。
slave-priority 100
假如主redis发现有超过M个从redis的连接延时大于N秒那么主redis就停止接受外来的写请求。这是因为从redis一般会每秒钟都向主redis发出PING而主redis会记录每一个从redis最近一次发来PING的时间点所以主redis能够了解每一个从redis的运行情况。
min-slaves-to-write 3
min-slaves-max-lag 10
上面这个例子表示假如有大于等于3个从redis的连接延迟大于10秒那么主redis就不再接受外部的写请求。上述两个配置中有一个被置为0则这个特性将被关闭。默认情况下min-slaves-to-write为0而min-slaves-max-lag为10。
**redis配置 安全**
可以要求redis客户端在向redis-server发送请求之前先进行密码验证。当你的redis-server处于一个不太可信的网络环境中时相信你会用上这个功能。由于redis性能非常高所以每秒钟可以完成多达15万次的密码尝试所以你最好设置一个足够复杂的密码否则很容易被黑客破解。
requirepass zhimakaimen
这里我们通过requirepass将密码设置成:"芝麻开门"。
redis允许我们对redis指令进行更名比如将一些比较危险的命令改个名字避免被误执行。比如可以把CONFIG命令改成一个很复杂的名字这样可以避免外部的调用同时还可以满足内部调用的需要
rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c89
可以禁用掉CONFIG命令那就是把CONFIG的名字改成一个空字符串
rename-command CONFIG ""
但需要注意的是如果你使用AOF方式进行数据持久化或者需要与从redis进行通信那么更改指令的名字可能会引起一些问题。
**redis配置 -限制**
可以设置redis同时可以与多少个客户端进行连接。默认情况下为10000个客户端。当你无法设置进程文件句柄限制时redis会设置为当前的文件句柄限制值减去32因为redis会为自身内部处理逻辑留一些句柄出来。
如果达到了此限制redis则会拒绝新的连接请求并且向这些连接请求方发出"max number of clients reached"以作回应。
maxclients 10000
设置redis可以使用的内存量。一旦到达内存使用上限redis将会试图移除内部数据移除规则可以通过maxmemory-policy来指定。
如果redis无法根据移除规则来移除内存中的数据或者我们设置了“不允许移除”那么redis则会针对那些需要申请内存的指令返回错误信息比如SET、LPUSH等。但是对于无内存申请的指令仍然会正常响应比如GET等。
maxmemory <bytes>
注意如果你的redis是主redis说明你的redis有从redis那么在设置内存使用上限时需要在系统中留出一些内存空间给同步队列缓存只有在你设置的是"不移除"的情况下,才不用考虑这个因素。
对于内存移除规则来说redis提供了多达6种的移除规则。他们是
1.volatile-lru使用LRU算法移除过期集合中的key
2.allkeys-lru使用LRU算法移除key
3.volatile-random在过期集合中移除随机的key
4.allkeys-random移除随机的key
5.volatile-ttl移除那些TTL值最小的key即那些最近才过期的key。
6.noeviction不进行移除。针对写操作只是返回错误信息。
无论使用上述哪一种移除规则如果没有合适的key可以移除的话redis都会针对写请求返回错误信息。
maxmemory-policy volatile-lru
LRU算法和最小TTL算法都并非是精确的算法而是估算值。所以你可以设置样本的大小。假如redis默认会检查三个key并选择其中LRU的那个那么你可以改变这个key样本的数量。
maxmemory-samples 3
**redis支持的写指令包括了如下这些**
set setnx setex append
incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
getset mset msetnx exec sort
**redis配置 追加模式**
默认情况下redis会异步的将数据持久化到磁盘。这种模式在大部分应用程序中已被验证是很有效的但是在一些问题发生时比如断电则这种机制可能会导致数分钟的写请求丢失。
追加文件Append Only File是一种更好的保持数据一致性的方式。即使当服务器断电时也仅会有1秒钟的写请求丢失当redis进程出现问题且操作系统运行正常时甚至只会丢失一条写请求。
建议AOF机制和RDB机制同时使用不会有任何冲突。
appendonly no
我们还可以设置aof文件的名称
appendfilename "appendonly.aof"
fsync()调用,用来告诉操作系统立即将缓存的指令写入磁盘。一些操作系统会"立即"进行,而另外一些操作系统则会“尽快”进行。
redis支持三种不同的模式
1.no不调用fsync()。而是让操作系统自行决定sync的时间。这种模式下redis的性能会最快。
2.always在每次写请求后都调用fsync()。这种模式下redis会相对较慢但数据最安全。
3.everysec每秒钟调用一次fsync()。这是性能和安全的折衷。
默认为everysec。
appendfsync everysec
当fsync方式设置为always或everysec时如果后台持久化进程需要执行一个很大的磁盘IO操作那么redis可能会在fsync()调用时卡住。目前尚未修复这个问题这是因为即使我们在另一个新的线程中去执行fsync(),也会阻塞住同步写调用。
为了缓解这个问题我们可以使用下面的配置项这样的话当BGSAVE或BGWRITEAOF运行时fsync()在主进程中的调用会被阻止。这意味着当另一路进程正在对AOF文件进行重构时redis的持久化功能就失效了就好像我们设置了“appendsync none”一样。如果你的redis有时延问题那么请将下面的选项设置为yes。否则请保持no因为这是保证数据完整性的最安全的选择。
no-appendfsync-on-rewrite no
我们允许redis自动重写aof。当aof增长到一定规模时redis会隐式调用BGREWRITEAOF来重写log文件以缩减文件体积。
redis是这样工作的redis会记录上次重写时的aof大小。假如redis自启动至今还没有进行过重写那么启动时aof文件的大小会被作为基准值。这个基准值会和当前的aof大小进行比较。如果当前aof大小超出所设置的增长比例则会触发重写。另外你还需要设置一个最小大小是为了防止在aof很小时就触发重写。
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
如果设置auto-aof-rewrite-percentage为0则会关闭此重写功能。
**redis配置 慢日志**
redis慢日志是指一个系统进行日志查询超过了指定的时长。这个时长不包括IO操作比如与客户端的交互、发送响应内容等而仅包括实际执行查询命令的时间。
针对慢日志,你可以设置两个参数,一个是执行时长,单位是微秒,另一个是慢日志的长度。当一个新的命令被写入日志时,最老的一条会从命令日志队列中被移除。
单位是微秒即1000000表示一秒。负数则会禁用慢日志功能而0则表示强制记录每一个命令。
slowlog-log-slower-than 10000
慢日志最大长度可以随便填写数值没有上限但要注意它会消耗内存。你可以使用SLOWLOG RESET来重设这个值。
slowlog-max-len 128
## Redis Cluster
### 一、设计
Redis集群搭建的方式有多种例如使用zookeeper等但从redis 3.0之后版本支持redis-cluster集群Redis-Cluster采用无中心结构每个节点保存数据和整个集群状态每个节点都和其他所有节点连接。其redis-cluster架构图如下
![file://c:\users\86186\appdata\local\temp\tmpvy1n0l\1.png](assets/1-16346954723901.png)
### 二、redis-cluster的优势  
  1、官方推荐
  2、去中心化集群最大可增加1000个节点性能随节点增加而线性扩展。
  3、管理方便后续可自行增加或摘除节点移动分槽等等。
  4、简单易上手。
Redis Cluster在设计的时候就考虑到了去中心化去中间件也就是说集群中的每个节点都是平等的关系都是对等的每个节点都保存各自的数据和整个集群的状态。每个节点都和其他所有节点连接而且这些连接保持活跃这样就保证了我们只需要连接集群中的任意一个节点就可以获取到其他节点的数据。
Redis 集群没有使用传统的一致性哈希来分配数据,而是采用另外一种叫做哈希槽 (hash slot)的方式来分配的。
**同步原理:**
Redis cluster 默认分配了 16384 个slot当我们set一个key 时会用CRC16算法来取模得到所属的slot然后将这个key 分到哈希槽区间的节点上具体算法是CRC16(key) % 16384。所以我们在测试的时候看到set 和 get 的时候直接跳转到了7000端口的节点。
Redis 集群会把数据存在一个 master 节点,然后在这个 master 和其对应的salve 之间进行数据同步。当读取数据时,也根据一致性哈希算法到对应的 master 节点获取数据。只有当一个master挂掉之后才会启动一个对应的 salve 节点,充当 master 。
### 三、redis-cluster架构
  1、master  主节点、
  2、slave   从节点
  3、slot   一共有16384数据分槽分布在集群的所有主节点中。
![image-20200906193846766](assets/image-20200906193846766.png)
图中描述的是六个redis实例构成的集群
```nim
6379 端口为客户端通讯端口
16379 端口为集群总线端口
```
集群内部划分为16384个数据分槽分布在三个主redis中。
从redis中没有分槽不会参与集群投票也不会帮忙加快读取数据仅仅作为主机的备份。
三个主节点中平均分布着16384数据分槽的三分之一每个节点中不会存有有重复数据仅仅有自己的从机帮忙冗余。
架构细节:
(1)所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.
(2)节点的fail是通过集群中超过半数的节点检测失效时才生效.
(3)客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可
(4)redis-cluster把所有的物理节点映射到[0-16383]slot上cluster负责维护node<->slot<->value
18 slave2 name wing
redis-cluster选举:容错
![file://c:\users\86186\appdata\local\temp\tmpvy1n0l\3.png](assets/3-16346954891162.png)
(1) 选举过程是集群中所有master参与,如果半数以上master节点与master节点通信超过(cluster-node-timeout),认为当前master节点挂掉.
(2) 什么时候整个集群不可用(cluster_state:fail),当集群不可用时,所有对集群的操作做都不可用,收到((error) CLUSTERDOWN The cluster is down)错误
a:如果集群任意master挂掉,且当前master没有slave.集群进入fail状态,也可以理解成集群的slot映射[0-16383]不完成时进入fail状态.
b:如果集群超过半数以上master挂掉无论是否有slave集群进入fail状态.
### 四、集群部署
**搭建redis集群建议至少需要准备3台服务器共搭建6个节点3个master,3个slave并且要求3个master节点不能全部跑到同一台服务器上保证节点安全3台服务器的配置相同**对应的端口是7000/7001/7002端口
环境为三台服务器:centos7.4
集群分配如下,**每个节点运行两个端口。第一列做主库,第二列做备库**
**记得选出控制节点**
redis1=====192.168.3.41:7000 192.168.3.41:7001 **同时也是集群的控制节点**
redis2=====192.168.3.59:7001 192.168.3.59:7002
redis3=====192.168.3.128:7002 192.168.3.128:7000
1.在安装集群之前需要在服务器上安装ruby环境**(三台机器相同操作)**
```
安装ruby yum源会在/etc/yum.repos.d/目录下多出一个CentOS-SCLo-scl-rh.repo源
[root@redis1 ~]# yum install centos-release-scl-rh //centos8上不用做这一步
[root@redis1 ~]# yum install rh-ruby24 -y
刷新ruby环境变量
[root@redis1 ~]# scl enable rh-ruby24 bash //centos8上不用做这一步
[root@wing ~]# ruby -v
ruby 2.4.6p354 (2019-04-01 revision 67394) [x86_64-linux]
[root@wing ~]# gem install redis
Fetching: redis-4.5.1.gem (100%)
Successfully installed redis-4.5.1
Parsing documentation for redis-4.5.1
Installing ri documentation for redis-4.5.1
Done installing documentation for redis after 0 seconds
1 gem installed
centos8安装ruby直接使用yum安装
```
2.安装redis **(三台机器相同操作)**
```bash
[root@redis1 ~]# wget http://download.redis.io/releases/redis-4.0.9.tar.gz
[root@redis1 ~]# tar xzf redis-4.0.9.tar.gz -C /data/application/
[root@redis1 ~]# cd /data/application/
[root@redis1 application]# mv redis-4.0.9/ redis
[root@redis1 application]# cd redis/
[root@redis1 redis]# make //centos7
或者
[root@redis1 redis]# make MALLOC=libc //centos8上 需要加这个参数
[root@redis1 redis]# mkdir /data/application/redis/data 创建存放数据的目录
```
3.创建节点目录 **(三台机器相同操作,注意端口号的不一样)**
```bash
[root@redis1 redis]# pwd //cd 到安装目录里面
/data/application/redis
[root@redis1 redis]# mkdir cluster 创建集群目录
[root@redis1 redis]# cd cluster/
[root@redis1 cluster]# mkdir 7000 7001
[root@redis2 redis]# mkdir cluster
[root@redis2 redis]# cd cluster/
[root@redis2 cluster]# mkdir 7001 7002
[root@redis3 redis]# mkdir cluster
[root@redis3 redis]# cd cluster/
[root@redis3 cluster]# mkdir 7002 7000
```
4.拷贝配置文件 (**控制节点操作**)
[root@redis1 cluster]# cd ..
[root@redis1 redis]# cp redis.conf cluster/7000
[root@redis1 redis]# cp redis.conf cluster/7001
[root@redis1 redis]# scp redis.conf 192.168.3.59:/data/application/redis/cluster/7001/
redis.conf
[root@redis1 redis]# scp redis.conf 192.168.3.59:/data/application/redis/cluster/7002/
redis.conf
[root@redis1 redis]# scp redis.conf 192.168.3.128:/data/application/redis/cluster/7002/
redis.conf
[root@redis1 redis]# scp redis.conf 192.168.3.128:/data/application/redis/cluster/7000/
redis.conf
5.修改集群配置文件(**主要是端口和ip**,三台机器相同操作)
[root@redis1 redis]# cd cluster/
[root@redis1 cluster]# cd 7000/
[root@redis1 7000]# cp redis.conf redis.conf.bak
[root@redis1 7000]# vim redis.conf 没有添加,全部为修改或者打开注释
bind 192.168.3.41 # **绑定局域网ip使得三台服务器可相互访问**
daemonize yes // redis后台运行
pidfile /var/run/redis_7000.pid // pid文件**运行多个实例时需要指定不同的pid文件**
port 7000 // 监听端口,**运行多个实例时,需要指定不同的端口**
tcp-backlog 511
tcp-keepalive 0
loglevel notice // 日志等级
logfile /var/log/redis_7000.log // 日志文件位置 **运行多实例时,需要修改不同的端口**
databases 16 // 可用数据库数
dir /data/application/redis/data //存放数据的目录
appendonly yes // redis会把所接收到的每一次写操作请求都追加到appendonly.aof文件中当redis重新启动时会从该文件恢复出之前的状态。
appendfilename "appendonly.aof" // AOF文件名称
appendfsync everysec // 表示对写操作进行累积,每秒同步一次
no-appendfsync-on-rewrite yes // AOF 自动重写--详解见文档底部扩展部分
auto-aof-rewrite-percentage 80-100 // 重写百分比
auto-aof-rewrite-min-size 64mb
打开注释并修改的如下:
\#如下为集群配置
cluster-enabled yes #启用集群
cluster-config-file nodes-7000.conf #集群配置文件由redis自动更新不需要手动配置**运行多实例时请注修改为对应端口**
cluster-node-timeout 5000 #集群节点超时时间即集群中主从节点断开连接时间阈值超过该值则认为主节点不可以从节点将有可能转为master
cluster-slave-validity-factor 10 #在进行故障转移的时候全部slave都会请求申请为master但是有些slave可能与master断开连接一段时间了导致数据过于陈旧不应该被提升为master。该参数就是用来判断slave节点与master断线的时间是否过长注意新版本此选项为cluster-replica-validity-factor
计算方法为cluster-node-timeout * cluster-slave-validity-factor此处为5000 * 10 毫秒)
\#cluster-migration-barrier 1
cluster-require-full-coverage yes #集群中的所有slot16384个全部覆盖才能提供服务
**提示:
可以在一台服务器上面修改好了scp到每台服务器对应的目录下面然后修改ip和端口还有pid号日志存放文件和配置文件中的cluster-config-file nodes-7000.conf对应不同的端口**
==============================================================================
**6.启动三台机器上面的每个节点**(**三台机器相同操作)**
控制节点:
[root@redis1 ~]# cd /data/application/redis/src/
[root@redis1 src]# ./redis-server ../cluster/7000/redis.conf
[root@redis1 src]# ./redis-server ../cluster/7001/redis.conf
![file://c:\users\86186\appdata\local\temp\tmpvy1n0l\4.png](assets/4.png)
被控制节点;
[root@redis2 ~]# cd /data/application/redis/src/
[root@redis2 src]# ./redis-server ../cluster/7001/redis.conf
[root@redis2 src]# ./redis-server ../cluster/7002/redis.conf
![file://c:\users\86186\appdata\local\temp\tmpvy1n0l\5.png](assets/5.png)
![file://c:\users\86186\appdata\local\temp\tmpvy1n0l\6.png](assets/6.png)
**所有启动的端口均为master端口提前规划好了启动的时候按规划好的端口顺序启动**
==============================================================
7.创建集群(**在控制节点上面操作即可,剩余机器不用操作**)
注意由于redis.conf文件使用的都是相对路径并且生成的一些文件如aof文件是不能覆盖重复的因此标准的开启redis-server的操作是进入到7000/7001/7002等目录中执行../redis-server redis.conf这样各个实例生成的文件就在各自的目录下互不干扰当然如果修改redis.conf的配置文件目录则可以实现在不同的目录下执行redis-server这个可以灵活掌握和运用
redis节点搭建起来后需要完成redis cluster集群搭建搭建集群过程中需要保证6个redis实例都是运行状态。
**Redis是根据IP和Port的顺序确定master和slave的所以要排好序再执行。**
输出如下:
[root@redis1 ~]# cd /data/application/redis/src/
[root@redis1 src]# ./redis-trib.rb create --replicas 1 192.168.3.41:7000 192.168.3.41:7001 192.168.3.59:7001 192.168.3.59:7002 192.168.3.128:7002 192.168.3.128:7000
新版本6.0redis命令发生变化如下:
[root@redis1 src]# ./redis-cli --cluster create 192.168.26.30:7000 192.168.26.30:7001 192.168.26.31:7001 192.168.26.31:7002 192.168.26.32:7002 192.168.26.32:7000 --cluster-replicas 1
![file://c:\users\86186\appdata\local\temp\tmpvy1n0l\7.png](assets/7.png)
![file://c:\users\86186\appdata\local\temp\tmpvy1n0l\8.png](assets/8.png)
============================================================
8.查看集群状态可连接集群中的任一节点此处连接了集群中的节点192.168.3.41:7000
**登录集群客户端,-c标识以集群方式登录**
[root@redis1 src]# ./redis-cli -h 192.168.3.41 -c -p 7000
192.168.3.41:7000> **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:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:1363
cluster_stats_messages_pong_sent:1353
cluster_stats_messages_sent:2716
cluster_stats_messages_ping_received:1348
cluster_stats_messages_pong_received:1363
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:2716
检查集群状态:任意服务器都可以检查
[root@redis1 src]# **./redis-trib.rb check 192.168.3.41:7000**
新版本redis6.0命令如下:
[root@redis1 src]#**./redis-cli --cluster check 192.168.26.30:7000**
\>>> Performing Cluster Check (using node 192.168.3.41:7000)
M: 6001349939422f034a13dd26633a60707b863f9d 192.168.3.41:7000
slots:0-5460 (5461 slots) master
1 additional replica(s)
M: e8e01a8ffc8349776e39d834539c3178ccfc332d 192.168.3.59:7001
slots:5461-10922 (5462 slots) master
1 additional replica(s)
S: 9e47791b5fef915a0831be8d337d63feaae7b1a7 192.168.3.41:7001
slots: (0 slots) slave
replicates 1df3e83e26460c0235e6c56d7582db293ff48188
M: 1df3e83e26460c0235e6c56d7582db293ff48188 192.168.3.128:7002
slots:10923-16383 (5461 slots) master
1 additional replica(s)
S: 376df6767b995aef49b82a5391f4fcbf407446e1 192.168.3.59:7002
slots: (0 slots) slave
replicates 6001349939422f034a13dd26633a60707b863f9d
S: 9f47751526121106b9cad55d9cab2a980186c3e8 192.168.3.128:7000
slots: (0 slots) slave
replicates e8e01a8ffc8349776e39d834539c3178ccfc332d
[OK] All nodes agree about slots configuration.
\>>> Check for open slots...
\>>> Check slots coverage...
[OK] All 16384 slots covered.
测试连接数据库查询数据:
[root@redis1 src]# ./redis-cli -h 192.168.3.41 -c -p 7000
192.168.3.41:7000> cluster meet 127.0.0.1 7000
OK
192.168.3.41:7000>
==========================================================================
9.设置集群开机启动
## 扩展
关于redis中AOF的no-appendfsync-on-rewrite参数
```
redis提供了两种持久化机制rdb和aof。
关于aof的原理类似于预写日志不再解释。其中几个选项如下
  appendfsync always总是写入aof文件并完成磁盘同步
  appendfsync everysec每一秒写入aof文件并完成磁盘同步
  appendfsync no写入aof文件不等待磁盘同步。
可见从持久化角度讲always是最安全的。从效率上讲no是最快的。而redis默认设置进行了折中选择了everysec。合情合理。
bgrewriteaof机制在一个子进程中进行aof的重写从而不阻塞主进程对其余命令的处理同时解决了aof文件过大问题。
现在问题出现了同时在执行bgrewriteaof操作和主进程写aof文件的操作两者都会操作磁盘而bgrewriteaof往往会涉及大量磁盘操作这样就会造成主进程在写aof文件的时候出现阻塞的情形现在no-appendfsync-on-rewrite参数出场了。如果该参数设置为no是最安全的方式不会丢失数据但是要忍受阻塞的问题。如果设置为yes呢这就相当于将appendfsync设置为no这说明并没有执行磁盘操作只是写入了缓冲区因此这样并不会造成阻塞因为没有竞争磁盘但是如果这个时候redis挂掉就会丢失数据。丢失多少数据呢在linux的操作系统的默认设置下最多会丢失30s的数据。
因此如果应用系统无法忍受延迟而可以容忍少量的数据丢失则设置为yes。如果应用系统无法忍受数据丢失则设置为no。
```
redis小结
1.redis的作用 应用场景
2.redis和同类产品的区别 缓存服务器方向 Nosql方向
3.redis数据类型
4.持久化存储 分类 区别
5.redis部署
6.主从+哨兵
7.redis集群
## 击穿、穿透、雪崩问题
一、缓存击穿问题
对于一些设置了过期时间的key如果这些key可能会在某些时间点被超高并发地访问是一种非常“热点”的数据。这个时候需要考虑一个问题缓存被“击穿”的问题这个和缓存雪崩的区别在于这里**针对某一key缓存**前者则是很多key。
解决方案:
1.加锁:在未命中缓存时,通过加锁避免大量请求访问数据库
2.不允许过期:物理不过期,也就是不设置过期时间。而是逻辑上定时在后台异步的更新数据。
3.采用二级缓存L1缓存失效时间短L2缓存失效时间长。请求优先从L1缓存获取数据如果 未命中则加锁保证只有一个线程去数据库中读取数据然后再更新到L1和L2中。然后其他线 程依然在L2缓存获取数据。
二、缓存穿透问题
缓存穿透是指查询一个一定**不存在的数据**由于缓存是不命中时被动写的并且出于容错考虑如果从存储层查不到数据则不写入缓存这将导致这个不存在的数据每次请求都要到存储层去查询失去了缓存的意义。在流量大时可能DB就挂掉了要是有人利用不存在的key频繁攻击我们的应用这就是漏洞。
解决方案:
如果一个查询返回 的数据为空(不管是数据不存在,还是系统故障),我们仍然把这个空结果进行缓存,但它的过期时间会很短,最长不超过五分钟。
三、缓存雪崩
存雪崩是指在我们设置缓存时采用了相同的过期时间,导致**缓存在某一时刻同时失效**请求全部转发到DBDB瞬时压力过重雪崩。
解决方案:
1、缓存失效时的雪崩效应对底层系统的冲击非常可怕。大多数系统设计者考虑用加锁或者队列的方式保证缓存的单线程进程从而避免失效时大量的并发请求落到底层存储系统上。这里分享一个简单方案就时讲缓存失效时间分散开比如我们可以在原有的失效时间基础上增加一个随机值比如1-5分钟随机这样每一个缓存的过期时间的重复率就会降低就很难引发集体失效的事件。
2、事前这种方案就是在发生雪崩前对缓存集群实现高可用如果是使用 Redis可**以使用主从+哨兵 Redis Cluster 来避免 Redis 全盘崩溃的情况**。
3、事中使用 Hystrix进行限流&降级 比如一秒来了5000个请求我们可以设置假设只能有一秒2000个请求能通过这个组件那么其他剩余的3000请求就会走限流逻辑。然后去调用我们自己开发的降级组件降级比如设置的一些默认值呀之类的。以此来保护最后的 MySQL 不会被大量的请求给打死。
4、事后开启Redis持久化机制尽快恢复缓存集群
这3个概念要理解着备一下 面试可能会被问到