Redis配置与优化

一. Redis 简介

Redis（Remote Dictionary Server，远程字典服务器）是一个开源的、使用 C 语言编写的 NoSQL 数据库。Redis 基于内存运行并支持持久化，采用 key-value（键值对）的存储形式，是目前分布式架构中不可或缺的一环。

Redis 服务器程序是单进程模型，也就是在一台服务器上可以同时启动多个 Redis 进程， 而 Redis 的实际处理速度则是完全依靠于主进程的执行效率。若在服务器上只运行一个 Redis 进程，当多个客户端同时访问时，服务器的处理能力是会有一定程度的下降；若在同一台服务器上开启多个 Redis 进程，Redis 会提高并发处理能力的同时会给服务器的 CPU 造成很大压力。也就是说在实际生产环境中，需要根据实际的需求来决定开启多少个 Redis 进程。若对高并发要求更高一些，可能会考虑在同一台服务器上开启多个进程；若 CPU 资源比较紧张，采用单进程即可。

Redis 具有以下几个优点：

  • 具有极高的数据读写速度，数据读取的速度最高可达到 110000 次/s，数据写入速度最高可达到 81000 次/s。
  • 支持丰富的数据类型，不仅仅支持简单的 key-value 类型的数据，还支持 Strings, Lists, Hashes, Sets 及 Ordered Sets 等数据类型操作。
  • 支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
  • 原子性，Redis 所有操作都是原子性的。
  • 支持数据备份，即 master-salve 模式的数据备份。

Redis 作为基于内存运行的数据库，缓存是其最常应用的场景之一，除此之外，Redis 常见应用场景还包括：获取最新 N 个数据的操作、排行榜类应用、计数器应用、存储关系、实时分析系统、日志记录。

二. Redis 安装部署

Redis 的安装相对于其他服务比较简单，首先需要到 Redis 官网（https://www.redis.io） 下载相应的源码软件包，然后上传至 Linux 系统的服务器中进行解压、安装。

通常情况下在 Linux 系统中进行源码编译安装，需要先执行./configure 进行环境检查与配置，从而生成 Makefile 文件，再执行 make && make install 命令进行编译安装。而 Redis 源码包中直接提供了 Makefile 文件，所以在解压完软件包后，可直接进入解压后的软件包目录，执行 make 与 make install 命令进行安装。

  1. ##下载并解压
  2. [root@master01 ~]# wget -c http://download.redis.io/releases/redis-5.0.7.tar.gz
  3. [root@master01 ~]# tar zxvf redis-5.0.7.tar.gz -C /usr/src/
  4. [root@master01 ~]# cd /usr/src/redis-5.0.7/
  6. ## 安装
  7. [root@master01 redis-5.0.7]# make 
  8. [root@master01 redis-5.0.7]# make PREFIX=/usr/local/redis install
  10. ## 创建链接文件
  11. [root@master01 redis-5.0.7]# ln -s /usr/local/redis/bin/* /usr/local/bin/

make install 只是安装了二进制文件到系统中，并没有启动脚本和配置文件。

  1. [root@master01 redis-5.0.7]# groupadd -g 994 redis
  2. [root@master01 redis-5.0.7]# useradd -g 994 -s /sbin/nologin redis
  3. [root@master01 redis-5.0.7]# mkdir /etc/redis/
  4. [root@master01 redis-5.0.7]# chown redis:redis /etc/redis/
  5. [root@master01 redis-5.0.7]# cp redis.conf /etc/redis/
  6. [root@master01 redis-5.0.7]# vim /etc/redis/redis.conf
  7. ##绑定地址
  8. bind 127.0.0.1 192.168.154.101   #后台守护进程启动
  9. ##后台守护进程启动
  10. daemonize yes  
  11. ## 存储目录
  12. dir /etc/redis/
  14. ##生成systemd启动脚本
  15. [root@master01 ~]# vim /usr/lib/systemd/system/redis.service 
  16. [Unit]
  17. Description=Redis persistent key-value database
  18. After=network.target
  19. After=network-online.target
  20. Wants=network-online.target
  22. [Service]
  23. ExecStart=/usr/local/redis/bin/redis-server /etc/redis/redis.conf --supervised systemd
  24. ExecStop=/usr/bin/pkill redis-server
  25. Type=notify
  26. User=redis
  27. Group=redis
  28. RuntimeDirectory=redis
  29. RuntimeDirectoryMode=0755
  31. [Install]
  32. WantedBy=multi-user.target
  34. [root@master01 ~]# systemctl daemon-reload
  35. [root@master01 ~]# systemctl start redis.service

消除Redis-server的警告信息

  1. [root@master01 redis-5.0.7]# echo never > /sys/kernel/mm/transparent_hugepage/enabled
  3. [root@master01 redis-5.0.7]# vim /etc/sysctl.conf
  4. vm.overcommit_memory = 1
  5. net.core.somaxconn= 1024
  6. [root@master01 redis-5.0.7]# sysctl -p

三. 主要配置参数

Redis 主配置文件由注释行与设置行两部分组成。与大多数Linux配置文件一样，注释性的文字以“#”开始，包含了对相关配置内容进行的说明和解释。除了注释行与空行以外的内容即为设置行。可根据生产环境的需求调整相关参数，如：

  1. #vim /etc/redis/6379.conf
  2. bind 127.0.0.1 192.168.10.161 //监听的主机地址 
  3. port 6379 //端口 
  4. daemonize yes //启用守护进程 
  5. pidfile /var/run/redis_6379.pid //指定 PID 文件 
  6. loglevel notice //日志级别 
  7. logfile /var/log/redis_6379.log //指定日志文件

除了上述配置参数外，Redis主配置文件中还包含很多其它的配置参数:

  • timeout 300：当客户端闲置多长时间后关闭连接，如果指定为 0，表示 关闭该功能
  • dbfilename dump.rdb：指定本地数据库文件名，默认值为 dump.rdb
  • dir /var/lib/redis/6379：指定本地数据库存放目录
  • maxclients 10000：设置同一时间最大客户端连接数，默认为10000，Redis 可以同时打开的客户端连接数为 Redis 进程可以打开的 最大文件描述符数，如果设置 maxclients 0，表示不限制，当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息；
  • rdbcompression yes：指定存储至本地数据库时是否压缩数据，默认为 yes， Redis 采用 LZF 压缩，如果为了节省 CPU 资源，可以关闭 该选项，但会导致数据库文件变的巨大
  • slaveof ：当本机为 slav 从服务器时，设置 maste 服务的 IP 地址及端口，在 Redis 启动时，它会自动从 master 进行 数据同步
  • masterauth ：当 master 服务设置了密码保护时，slav 服务连接 master 的密码
  • requirepass foobared ：设置Redis连接密码，如果配置了连接密码，客户端在连接 Redis 时需要通过 AUTH 命令提供密码，默认关闭
  • maxmemory ：指定 Redis 最大内存限制，Redis 在启动时会把数据加载到内存中，达到最大内存后，Redis 会先尝试清除已到期或即将到期的Key，当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。 Redis 新的 vm 机制，会把 Key 存放内存，Value 会存放在 swap 区
  • appendonly no ：指定是否在每次更新操作后进行日志记录，Redis 在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在 断电时导致一段时间内的数据丢失。因为 redis 本身同 步数据文件是按上面 save 条件来同步的，所以有的数据 会在一段时间内只存在于内存中。默认为 no
  • appendfilename appendonly.aof ：指定更新日志文件名，默认为 appendonly.aof
  • appendfsync everysec
    ：指定更新日志条件，共有3个可选值：
    • no：表示等操作系统进行数据缓存同步到磁盘（快）
    • always：表示每次更新操作后手动调用 fsync()将数据写到磁盘（慢，安全）
    • everysec：表示每秒同步一次（折衷，默认值）
  • activerehashing yes 指定是否激活重置哈希，默认为开启
  • include /path/to/local.conf：指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件。

四. Redis 命令工具

Redis 软件提供了多个命令工具，当 Redis 安装时，所包含的软件工具会同时被安装到 系统中，在系统中可以直接使用。这些命令工具的作用分别如下所示。

  • redis-server：用于启动 Redis 的工具。
  • redis-benchmark：用于检测 Redis 在本机的运行效率。
  • redis-check-aof:修复 AOF 持久化文件
  • redis-check-rdb：修复 RDB 持久化文件
  • redis-cli:是 Redis 命令行工具
  • redis-setinel：是 redis-server 文件的软链接

4.1 redis-cli 命令行工具

Redis 数据库系统也是一个典型的 C/S（客户端/服务器端）架构的应用，要访问 Redis 数据库需要使用专门的客户端软件。Redis 服务的客户端软件就是其自带的 redis-cli 命令行工具。使用 redis-cli 连接指定数据库，连接成功过后会进入提示符为“远程主机 IP 地 址：端口号>”的数据库操作环境。用户可以输入各种操作语句对数据库进行管理。如执行 ping 命令可以检测 redis 服务是否启动。

  1. [root@master01 ~]# redis-cli   #连接本机的redis数据库
  2. 127.0.0.1:6379> ping           #检测redis服务是否启动
  3. PONG
  4. 127.0.0.1:6379>

还可以使用一些参数：

  • -h : 指定连接主机
  • -p ：指定连接端口
  • -a ：指定连接密码
  1. [root@master01 ~]# redis-cli -h 192.168.154.101 -p 6379
  2. 192.168.154.101:6379> ping
  3. PONG
  4. 192.168.154.101:6379> info  #查看服务器信息
  5. # Server
  6. redis_version:5.0.7
  7. redis_git_sha1:00000000
  8. redis_git_dirty:0
  9. redis_build_id:5961f2cbc47b96ca
  10. redis_mode:standalone
  11. os:Linux 3.10.0-1062.el7.x86_64 x86_64
  12. arch_bits:64
  13. multiplexing_api:epoll
  14. atomicvar_api:atomic-builtin
  15. gcc_version:4.8.5
  16. process_id:19067
  17. run_id:b41f99c65c6f660019b084856e77597cbd64ea1b
  18. tcp_port:6379
  19. uptime_in_seconds:2535
  20. uptime_in_days:0
  21. hz:10
  22. configured_hz:10
  23. lru_clock:4177861
  24. executable:/usr/local/redis/bin/redis-server
  25. config_file:/etc/redis/redis.conf
  26. ......  #省略部分内容
  27. 192.168.154.101:6379> quit #或者exit
  28. [root@master01 ~]#

在数据库操作环境中，使用 help 命令可以获取命令类型的帮助。其中。有三种获取命 令帮助的方式。

  • help @：获取中的命令列表
  • help ：获取某个命令的帮助
  • help ：获取可能帮助的主题列表
  1. [root@master01 ~]# redis-cli 
  2. 127.0.0.1:6379> help @list  #查看所有与List数据类型的相关命令
  4.   BLPOP key [key ...] timeout
  5.   summary: Remove and get the first element in a list, or block until one is available
  6.   since: 2.0.0
  8.   BRPOP key [key ...] timeout
  9.   summary: Remove and get the last element in a list, or block until one is available
  10.   since: 2.0.0
  11.   .....  #省略部分内容
  13. 127.0.0.1:6379> help set  #查看set命令的命令帮助
  15.   SET key value [expiration EX seconds|PX milliseconds] [NX|XX]
  16.   summary: Set the string value of a key
  17.   since: 1.0.0
  18.   group: string
  20. 127.0.0.1:6379>

4.2 redis-benchmark 测试工具

redis-benchmark 是官方自带的 Redis 性能测试工具，可以有效的测试 Redis 服务的性能。基本的测试语法为 redis-benchmark [option] [option value]。常用选项如下所示。

  • -h：指定服务器主机名
  • -p：指定服务器端口
  • -s：指定服务器 socket
  • -c：指定并发连接数
  • -n：指定请求数
  • -d：以字节的形式指定 SET/GET 值的数据大小
  • -k：1=keep alive 0=reconnect
  • -r：SET/GET/INCR 使用随机 key, SADD 使用随机值
  • -P：通过管道传输请求
  • -q：强制退出 redis。仅显示 query/sec 值
  • –csv ：以 CSV 格式输出
  • -l：生成循环，永久执行测试
  • -t：仅运行以逗号分隔的测试命令列表。
  • -I：Idle 模式。仅打开N个idle连接并等待。

结合上述选项，可以针对某台 Redis 服务器进行性能检测，如执行 redis-benchmark -h 192.168.154.101 -p 6379 -c 100 -n 100000 命令即可向 IP 地址为 192.168.154.101、端口为 6379 的 Redis 服务器发送 100 个并发连接与 100000 个请求测试性能。

  1. [root@master01 ~]# redis-benchmark -h 192.168.154.101 -p 6379 -c 100 -n 100000
  2. ....#过程省略
  4. 0.01% <= 1 milliseconds
  5. 3.03% <= 2 milliseconds
  6. 77.58% <= 3 milliseconds
  7. 98.30% <= 4 milliseconds
  8. 99.63% <= 5 milliseconds
  9. 99.81% <= 6 milliseconds
  10. 99.87% <= 7 milliseconds
  11. 99.91% <= 8 milliseconds
  12. 99.95% <= 9 milliseconds
  13. 99.98% <= 10 milliseconds
  14. 100.00% <= 11 milliseconds
  15. 19223.38 requests per second
  17. ====== MSET (10 keys) ======
  18.   100000 requests completed in 0.88 seconds
  19.   100 parallel clients
  20.   3 bytes payload
  21.   keep alive: 1
  23. 97.81% <= 1 milliseconds
  24. 99.78% <= 2 milliseconds
  25. 100.00% <= 3 milliseconds
  26. 100.00% <= 3 milliseconds
  27. 113378.68 requests per second
  • 执行redis-benchmark -h 192.168.154.101 -p 6379 -q -d 100 命令的作用是测试存取大小为 100 字节的数据包的性能;
  • 执行redis-benchmark -t set,lpush -n 100000 -q 命令的作用是测试本机上Redis服务在进行set与lpush操作时的性能。

五. Redis 数据库常用命令

Redis 数据库采用 key-value（键值对）的数据存储形式。所使用的命令是 set 与 get 命令。

  • set：存放数据，基本的命令格式为 set key value。
  • get：获取数据，基本的命令格式为 get key。

例如在 Redis 的命令行模式下执行”set teacher mike”，表示在当前数据库下存放一个 key 为 teacher，value 为 mike 的数据，而执行“get teacher“命令即可查看刚才存放的数据。

  1. [root@master01 ~]# redis-cli 
  2. 127.0.0.1:6379> set teacher mike
  3. OK
  4. 127.0.0.1:6379> get teacher
  5. "mike"
  6. 127.0.0.1:6379>

除了数据存储与获取命令，Redis 数据库还包含其它常见的数据管理命令。

5.1 key 相关命令

在 Redis 数据库中，与 key 相关的命令主要包含以下几种。

5.1.1 keys

使用 keys 命令可以取符合规则的键值列表，通常情况可以结合*、？等选项来使用。

  1. [root@master01 ~]# redis-cli 
  2. 127.0.0.1:6379> set k1 1
  3. OK
  4. 127.0.0.1:6379> set k2 2
  5. OK
  6. 127.0.0.1:6379> set k3 3
  7. OK
  8. 127.0.0.1:6379> set k4 4
  9. OK
  10. 127.0.0.1:6379> set k5 5
  11. OK
  12. 127.0.0.1:6379> keys *   #查看当前数据库中所有键
  13.  1) "k4"
  14.  2) "k5"
  15.  3) "password"
  16.  4) "key:__rand_int__"
  17.  5) "counter:__rand_int__"
  18.  6) "username"
  19.  7) "myset:__rand_int__"
  20.  8) "k1"
  21.  9) "k2"
  22. 10) "mylist"
  23. 11) "k3"
  24. 12) "teacher"
  25. 127.0.0.1:6379> set v22 5
  26. OK
  27. 127.0.0.1:6379> keys k*  #查看当前数据库中所有以k开头的键
  28. 1) "k4"
  29. 2) "k5"
  30. 3) "key:__rand_int__"
  31. 4) "k1"
  32. 5) "k2"
  33. 6) "k3"
  34. 127.0.0.1:6379> keys k?  #查看当前数据库中以k开头后面包含任意一位的数据
  35. 1) "k4"
  36. 2) "k5"
  37. 3) "k1"
  38. 4) "k2"
  39. 5) "k3"
  40. 127.0.0.1:6379> keys v??  #查看当前数据库中以k开头后面包含任意2位的数据
  41. 1) "v22"
  42. 127.0.0.1:6379>

5.1.2 exists

exists 命令可以判断键值是否存在。

  1. 127.0.0.1:6379> EXISTS teacher
  2. (integer) 1      #返回1表示存在
  3. 127.0.0.1:6379> EXISTS tea
  4. (integer) 0      #返回0表示不存在
  5. 127.0.0.1:6379>

5.1.3 del

del 命令可以删除当前数据库的指定 key。

  1. 127.0.0.1:6379> del k1
  2. (integer) 1
  3. 127.0.0.1:6379> del k1
  4. (integer) 0
  5. 127.0.0.1:6379>

5.1.4 type

使用type命令可以获取key对应的value值类型。

  1. 127.0.0.1:6379> type username
  2. string

5.1.5 rename

rename 命令是对已有key进行重命名，其命令格式为：rename 源key 目标key。使用 rename 命令进行重命名时，无论目标key是否存在都进行重命名，且源key的值会覆盖目标key的值。在实际使用过程中，建议先用exists命令查看目标key是否存在，然后再决定是否执行rename命令，以避免覆盖重要数据。

  1. 127.0.0.1:6379> keys v*
  2. 1) "v22"
  3. 127.0.0.1:6379> rename v22 v2
  4. OK
  5. 127.0.0.1:6379> keys v*
  6. 1) "v2"
  7. 127.0.0.1:6379> get v2
  8. "5"
  9. 127.0.0.1:6379>

5.1.6 renamenx

renamenx命令的作用是对已有key进行重命名，并检测新名是否存在。其命令格式与rename的命令格式除命令关键字不同外基本相同， renamenx 源key 目标key。使用renamenx命令进行重命名时，如果目标key存在则不进行重命名。

  1. 127.0.0.1:6379> keys k*
  2. 1) "k4"
  3. 2) "k5"
  4. 3) "key:__rand_int__"
  5. 4) "k2"
  6. 5) "k3"
  7. 127.0.0.1:6379> renamenx k4 k40
  8. (integer) 1
  9. 127.0.0.1:6379> get k40
  10. "4"
  11. 127.0.0.1:6379> get k4
  12. (nil)
  13. 127.0.0.1:6379> renamenx k2 k3 
  14. (integer) 0               #目标key存在，则没有成功
  15. 127.0.0.1:6379> keys k*
  16. 1) "k40"
  17. 2) "k5"
  18. 3) "key:__rand_int__"
  19. 4) "k2"
  20. 5) "k3"
  21. 127.0.0.1:6379>

5.1.7 dbsize

dbsize命令的作用是查看当前数据库中key的数目

  1. 127.0.0.1:6379> dbsize
  2. (integer) 13
  3. 127.0.0.1:6379>

5.2 多数据库常用命令

5.2.1 多数据库间切换

Redis支持多数据库，Redis在没有任何改动的情况下默认包含16个数据库，数据库名称是用数字0-15来依次命名的。使用Select命令可以进行Redis的多数据库之间的切换，命令格式为：select index,其中index表示数据库的序号。而使用redis-cli连接Redis数据库后，默认使用的是序号为0的数据库。

使用select命令切换数据库后，会在前端的提示符中显示当前所在的数据库序号如“127.0.0.1:6379[10]>”表示当前使用的是序号为10的数据库；若当前使用的数据库是序号为0的数据库，提示符中则不显示序号，如“127.0.0.1:6379>”表示当前使用的是序号为0的数据库。

  1. 127.0.0.1:6379> select 10
  2. OK
  3. 127.0.0.1:6379[10]> select 15
  4. OK
  5. 127.0.0.1:6379[15]> select 0
  6. OK
  7. 127.0.0.1:6379> select 16
  8. (error) ERR DB index is out of range
  9. 127.0.0.1:6379>

5.2.2 多数据库间移动数据

Redis的多数据库在一定程度上是相对独立的，例如在数据库0上面存放的k1的数据，在其它的1-15的数据库上是无法查看到的。

Redis数据库提供了一个move的命令，可以进行多数据库的数据移动。命令的基本语法格式为：move key dbindex。其中“key”表示当前数据库的目标键，“dbindex”表示目标数据库的序号。

  1. 127.0.0.1:6379> select 10
  2. OK
  3. 127.0.0.1:6379[10]> keys *
  4. (empty list or set)
  5. 127.0.0.1:6379[10]> select 0
  6. OK
  7. 127.0.0.1:6379> keys k?
  8. 1) "k5"
  9. 2) "k2"
  10. 3) "k3"
  11. 127.0.0.1:6379> move k2 10   #移动k2到数据库10
  12. (integer) 1
  13. 127.0.0.1:6379> get k2
  14. (nil)
  15. 127.0.0.1:6379> select 10
  16. OK
  17. 127.0.0.1:6379[10]> keys *
  18. 1) "k2"
  19. 127.0.0.1:6379[10]> get k2
  20. "2"
  21. 127.0.0.1:6379[10]>

5.2.3 清除数据库内数据

  • flushdb：清空当前数据库的数据
  • flushall：清空所有数据库的数据，生产环境要慎用

六. redis 持久化

Redis是一种高级key-value数据库。它跟memcached类似，不过数据可以持久化，而且支持的数据类型很丰富。有字符串、链表、集合和有序集合。支持在服务器端计算集合的并、交和补集(difference)等，还支持多种排序功能。所以Redis也可以被看成是一个数据结构服务器。

Redis的数据都存放在内存中，如果没有配置持久化，redis重启后数据就全丢失了，于是需要开启redis的持久化功能，将数据保存到磁盘上，当redis重启后，可以从磁盘中恢复数据。redis提供两种方式进行持久化，一种是RDB持久化（原理是将Reids在内存中的数据库记录定时dump到磁盘上），另外一种是AOF（append only file）持久化（原理是将Reids的操作日志以追加的方式写入文件）。

6.1 RDB和AOF的区别

RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是fork一个子进程，先将数据集写入临时文件，写入成功后，再替换之前的文件，用二进制压缩存储。

AOF持久化以日志的形式记录服务器所处理的每一个写、删除操作，查询操作不会记录，以文本的方式记录，可以打开文件看到详细的操作记录。

6.2 RDB和AOF的优缺点

6.2.1 RDB存在哪些优势

  • 一旦采用该方式，那么你的整个Redis数据库将只包含一个文件，这对于文件备份而言是非常完美的。比如，你可能打算每个小时归档一次最近24小时的数据，同时还要每天归档一次最近30天的数据。通过这样的备份策略，一旦系统出现灾难性故障，我们可以非常容易的进行恢复。
  • 对于灾难恢复而言，RDB是非常不错的选择。因为我们可以非常轻松的将一个单独的文件压缩后再转移到其它存储介质上。
  • 性能最大化。对于Redis的服务进程而言，在开始持久化时，它唯一需要做的只是fork出子进程，之后再由子进程完成这些持久化的工作，这样就可以极大的避免服务进程执行IO操作了。
  • 相比于AOF机制，如果数据集很大，RDB的启动效率会更高。

6.2.2 RDB存在哪些劣势

  • 如果你想保证数据的高可用性，即最大限度的避免数据丢失，那么RDB将不是一个很好的选择。因为系统一旦在定时持久化之前出现宕机现象，此前没有来得及写入磁盘的数据都将丢失；
  • 由于RDB是通过fork子进程来协助完成数据持久化工作的，因此，如果当数据集较大时，可能会导致整个服务器停止服务几百毫秒，甚至是1秒钟。

6.2.3 AOF的优势有哪些

  • 该机制可以带来更高的数据安全性，即数据持久性。Redis中提供了3中同步策略， 即每秒同步、每修改同步和不同步。事实上，每秒同步也是异步完成的，其效率也是非常高的，所差的是一旦系统出现宕机现象，那么这一秒钟之内修改的数据将会丢失。而每修改同步，我们可以将其视为同步持久化，即每次发生的数据变化都会被立即记录到磁盘中。这种方式在效率上是最低的；
  • 由于该机制对日志文件的写入操作采用的是append模式，因此在写入过程中即使出现宕机现象，也不会破坏日志文件中已经存在的内容。然而如果我们本次操作只是写入了一半数据就出现了系统崩溃问题，不用担心，在Redis下一次启动之前，我们可以通过redis-check-aof工具来帮助我们解决数据一致性的问题；
  • 如果日志过大，Redis可以自动启用rewrite机制。即Redis以append模式不断的将修改数据写入到老的磁盘文件中，同时Redis还会创建一个新的文件用于记录此期间有哪些修改命令被执行。因此在进行rewrite切换时可以更好的保证数据安全性；
  • AOF包含一个格式清晰、易于理解的日志文件用于记录所有的修改操作。事实上， 我们也可以通过该文件完成数据的重建。

6.2.4 AOF的劣势有哪些

  • 对于相同数量的数据集而言，AOF文件通常要大于RDB文件。RDB在恢复大数据集时的速度比AOF的恢复速度要快；
  • 根据同步策略的不同，AOF在运行效率上往往会慢于RDB。总之，每秒同步策略的效率是比较高的，同步禁用策略的效率和RDB一样高效。

二者选择的标准，就是看系统是愿意牺牲一些性能，换取更高的缓存一致性（AOF），还是愿意写操作频繁的时候，不启用备份来换取更高的性能，待手动运行save的时候，再做备份（RDB）。RDB这个就更有些eventually consistent(最终一致)的意思了。

6.3 Redis持久化配置

6.3.1 RDB持久化配置

Redis会将数据集的快照dump到dump.rdb文件中。此外，我们也可以通过配置文件来修改Redis服务器dump快照的频率：

  1. save 900 1     #在900秒(15分钟)之后，如果至少有1个key发生变化,则dump内存快照。
  2. save 300 10    #在300秒(5分钟)之后，如果至少有10个key发生变化,则dump内存快照。
  3. save 60 10000  #在60秒(1分钟)之后，如果至少有10000个key发生变化,则dump内存快照。

6.3.2 AOF持久化配置

在Redis的配置文件中存在三种同步方式，它们分别是：

  1. appendonly yes         ##开启AOF持久化，默认为no
  2. appendfsync always     ##每次有数据修改发生时都会写入AOF文件
  3. appendfsync everysec   ##每秒钟同步一次，该策略为AOF的缺省策略
  4. appendfsync no         ##从不同步。高效但是数据不会被持久化。

七. 性能管理

redis性能管理需要关注的数据指标有内存使用率、内存碎片率、回收key等。这其中有些数据都可以通过进入redis输入info命令进行查看。需要查看某一项的值就后面跟具体参数，下面查看redis使用内存值:

  1. [root@master01 ~]# redis-cli 
  2. 127.0.0.1:6379> info memory
  3. # Memory
  4. used_memory:574848
  5. used_memory_human:561.38K
  6. used_memory_rss:3747840
  7. used_memory_rss_human:3.57M
  8. used_memory_peak:574848
  9. used_memory_peak_human:561.38K
  10. used_memory_peak_perc:100.01%
  11. used_memory_overhead:562622
  12. used_memory_startup:512928
  13. used_memory_dataset:12226
  14. used_memory_dataset_perc:19.74%
  15. allocator_allocated:1008384
  16. allocator_active:1351680
  17. allocator_resident:8417280
  18. total_system_memory:2076639232
  19. total_system_memory_human:1.93G
  20. used_memory_lua:37888
  21. used_memory_lua_human:37.00K
  22. used_memory_scripts:0
  23. used_memory_scripts_human:0B
  24. number_of_cached_scripts:0
  25. maxmemory:0
  26. maxmemory_human:0B
  27. maxmemory_policy:noeviction
  28. allocator_frag_ratio:1.34
  29. allocator_frag_bytes:343296
  30. allocator_rss_ratio:6.23
  31. allocator_rss_bytes:7065600
  32. rss_overhead_ratio:0.45
  33. rss_overhead_bytes:-4669440
  34. mem_fragmentation_ratio:7.02
  35. mem_fragmentation_bytes:3214016
  36. mem_not_counted_for_evict:0
  37. mem_replication_backlog:0
  38. mem_clients_slaves:0
  39. mem_clients_normal:49694
  40. mem_aof_buffer:0
  41. mem_allocator:jemalloc-5.1.0
  42. active_defrag_running:0
  43. lazyfree_pending_objects:0
  44. 127.0.0.1:6379>

7.1 内存碎片率

上述信息中的mem_fragmentation_ratio给出了内存碎片率的数据指标，它是由操系统分配的内存值used_memory_rss除以redis使用的内存值used_memory 得出的。

used_memory_rss的rss是Resident Set Size的缩写，表示该进程所占物理内存的大小，是操作系统分配给Redis实例的内存大小。除了用户定义的数据和内部开销以外，used_memory_rss指标还包含了内存碎片的开销，内存碎片是由操作系统低效的分配/回收物理内存导致的。操作系统负责分配物理内存给各个应用进程，Redis使用的内存与物理内存的映射是由操作系统上虚拟内存管理分配器完成的。

举个例子来说，Redis需要分配连续内存块来存储1G的数据集，这样的话更有利，但可能物理内存上没有超过1G的连续内存块，那操作系统就不得不使用多个不连续的小内存块来分配并存储这1G数据，也就导致内存碎片的产生。内存分配器另一个复杂的层面是，它经常会预先分配一些内存块给引用，这样做会加快应用程序的运行。跟踪内存碎片率对理解redis实例的资源性能是非常重要的。内存碎片率稍大于1是合理的，这个值表示内存碎片率比较低，也说明redis没有发生内存交换。但如果内存碎片率超过1.5，那就说明redis 消耗了实际需要物理内存的150%，其中50%是内存碎片率。若是内存碎片率低于1的话，说明Redis内存分配超出了物理内存，操作系统正在进行内存交换。内存交换会引起非常明显的响应延迟。

上述info memory 中内存碎片率达到7.02是因为redis里面没有数据，使用的内存少导致，所以不足为奇。如果生产环境内存碎片率过高，会导致redis性能降低，一般会有三种常见方法解决。

  1. 如果内存碎片率超过1.5，重启redis服务器可以让额外产生的内存碎片失效并重新作为新内存来使用，使操作系统恢复高效的内存管理。额外碎片的产生是由于redis释放了内存块，但内存分配器并没有返回内存给操作系统，这个内存分配器是在编译时指定的，可以是libc、jemalloc或者tcmalloc。
    通过比较used_memory_peak, used_memory_rss和used_memory_metrics 的数据指标值可以检查额外内存碎片的占用。从名字上可以看出，used_memory_peak是过去redis内存使用的峰值，而不是当前使用内存的值。如used_memory_peak和used_memory_rss的值大致上相等，而且二者明显超过了used_memory值，这说明额外的内存碎片正在产生。在重启服务器之前，需要在redis-cli工具上输入shutdown save命令，意思是强制让redis数据库执行保存操作并关闭redis服务，这样做能保证在执行redis关闭时不丢失任何数据。在重启后，redis会从硬盘上加载持久化的文件，以确保数据集持续可用。 

    1. make MALLOC=libc
    2. #或者
    3. make MALLOC=jemalloc

  2. 如果内存碎片率低于1，redis实例可能会把部分数据交换到硬盘上。内存交换会严重影响Redis的性能，所以应该增加可用物理内存或减少redis内存占用。

  3. 修改内存分配，redis支持glibc、jemalloc、tcmalloc三种不同的内存分配器，每个分配器在内存分配和碎片上都有不同的实现。不建议运维人员修改redis默认内存分配器，因为这需要完全理解这几种内存分配器的差异，也要重新编译redis。这个方法更多的是让其了解Redis内存分配器所做的工作。

7.2 内存使用率

内存使用率是redis服务最关键的一部分。如果一个redis实例的内存使用率超过可用最大内存，那么操作系统开始进行内存与swap空间交换，把内存中旧的或不再使用的内容写入硬盘上（硬盘上的这块空间叫swap分区），以便腾出新的物理内存给新页或活动页(page) 使用。

上面used_memory字段数据表示的是由redis分配器分配的内存总量，以字节为单位。 其中used_memory_human上的数据和used_memory是一样的值，它以 M为单位显示，仅为了方便阅读。

used_memory是redis使用的内存总量，它包含了实际缓存占用的内存和redis 自身运行所占用的内存(如元数据、lua)。它是由redis使用内存分配器分配的内存，所以这个数据并没有把内存碎片浪费掉的内存给统计进去。redis默认最大使用内存是可用物理内存剩余的所有内存，0代表没有限制。

在硬盘上进行读写操作要比在内存上进行读写操作慢很多。如果redis进程上发生内存交换，那么redis和依赖redis上数据的应用会受到严重的性能影响。 通过查看used_memory指标可知道redis正在使用的内存情况，如果used_memory大于可用最大内存，那就说明redis实例正在进行内存交换或者已经内存交换完毕。运维人员应该根据这个情况执行相对应的应急措施。

如何避免内存交换发生主要有以下三点：

1. 针对缓存数据大小选择

如果缓存数据小于4GB，就使用32位的Redis实例。因为32位实例上的指针大小只有64位的一半，它的内存空间占用空间会更少些。这有一个坏处就是，假设物理内存超过4GB，那么32位实例能使用的内存仍然会被限制在4GB以下。要是实例同时也共享给其他一些应用使用的话，那可能需要更高效的64位 Redis实例，这种情况下切换到32位是不可取的。不管使用哪种方式，Redis 的dump文件在32位和64位之间是互相兼容的，因此倘若有减少占用内存空间的需求，可以尝试先使用32位，后面再切换到64位上。

2. 尽可能的使用Hash数据结构

因为Redis在储存小于100个字段的Hash结构上，其存储效率是非常高的。所以在不需要集合(set)操作或list的push/pop操作的时候，尽可能的使用Hash结构。比如，在一个web应用程序中，需要存储一个对象表示用户信息，使用单个key表示一个用户，其每个属性存储在Hash的字段里，这样要比给每个属性单独设置一个key-value要高效的多。通常情况下倘若有数据使用string结构，用多个key存储时，那么应该转换成单key多字段的Hash结构。如上述例子中介绍的Hash结构应包含，单个对象的属性或者单个用户各种各样的资料。Hash结构的操作命令是HSET(key,fields,value)和HGET(key,field)，使用它可以存储或从Hash中取出指定的字段。

3. 设置key的过期时间

一个减少内存使用率的简单方法就是，每当存储对象时确保设置key的过期时间。倘若key在明确的时间周期内使用或者旧key不大可能被使用时，就可以用Redis过期时间命令(expire,expireat,pexpire,pexpireat)去设置过期时间，这样Redis会在key过期时自动删除key。假如你知道每秒钟有多少个新key-value被创建，那可以调整key的存活时间，并指定阀值去限制Redis使用的最大内存。

7.3 回收key

当内存使用达到设置的最大阀值时，需要选择一种key的回收策略，可在redis.conf配置文件中修改“maxmemory-policy”属性值。默认情况下回收策略是禁止删除，若是redis数据集中的key都设置了过期时间，那么“volatile-ttl”策略是比较好的选择。但如果key在达到最大内存限制时没能够迅速过期，或者根本没有设置过期时间。那么设置为“allkeys-lru”值比较合适，它允许 Redis从整个数据集中挑选最近最少使用的key进行删除(LRU 淘汰算法)。Redis还提供了一些其他淘汰策略，如下：

  • volatile-lru：使用LRU算法从已设置过期时间的数据集合中淘汰数据。
  • volatile-ttl：从已设置过期时间的数据集合中挑选即将过期的数据淘汰。
  • volatile-random：从已设置过期时间的数据集合中随机挑选数据淘汰。
  • allkeys-lru：使用LRU算法从所有数据集合中淘汰数据。
  • allkeys-random：从数据集合中任意选择数据淘汰。
  • no-enviction：禁止淘汰数据。

info stats信息中的evicted_keys字段显示的是因为maxmemory限制导致key被回收删除的数量。当redis由于内存压力需要回收一个key时，redis首先考虑的不是回收最旧的数据，而是在最近最少使用的key或即将过期的key中随机选择一个key，从数据集中删除：

  1. 127.0.0.1:6379> info stats
  2. # Stats
  3. total_connections_received:1
  4. total_commands_processed:5
  5. instantaneous_ops_per_sec:0
  6. total_net_input_bytes:140
  7. total_net_output_bytes:12709
  8. instantaneous_input_kbps:0.00
  9. instantaneous_output_kbps:0.00
  10. rejected_connections:0
  11. sync_full:0
  12. sync_partial_ok:0
  13. sync_partial_err:0
  14. expired_keys:0
  15. expired_stale_perc:0.00
  16. expired_time_cap_reached_count:0
  17. evicted_keys:0      #因为maxmemory限制导致key被回收的数量
  18. keyspace_hits:0
  19. keyspace_misses:0
  20. pubsub_channels:0
  21. pubsub_patterns:0
  22. latest_fork_usec:0
  23. migrate_cached_sockets:0
  24. slave_expires_tracked_keys:0
  25. active_defrag_hits:0
  26. active_defrag_misses:0
  27. active_defrag_key_hits:0
  28. active_defrag_key_misses:0
  29. 127.0.0.1:6379>

根据key回收定位性能问题是非常重要的，因为通过回收key，可以保证合理分配redis有限的内存资源。如果evicted_keys值经常超过0，那应该会看到客户端命令响应延迟时间增加，因为Redis不但要处理客户端过来的命令请求，还要频繁的回收满足条件的key。需要注意的是，回收key对性能的影响远没有内存交换严重，若是在强制内存交换和设置回收策略做一个选择的话，则放弃设置回收key是比较合理的，因为把内存数据交换到硬盘上对性能影响非常大。既然频繁的回收key也会导致性能问题，需要减少回收key来提升性能，根据经验如果开启快照功能，maxmemory需要设置成物理内存的45%，这几乎不会有引发内存交换的危险。若是没有开启快照功能，设置系统可用内存的95%是比较合理的。

另外一种是分片技术，分片是把数据分割成合适大小，分别存放在不同的 redis实例上，每一个实例都包含整个数据集的一部分。通过分片可以把很多服务器联合起来存储数据，相当于增加总的物理内存，使其在没有内存交换和回收key的策略下也能存储更多的key。假如有一个非常大的数据集，maxmemory已经设置，实际内存使用也已经超过了推荐设置的阀值，通过数据分片能明显减少key的回收，从而提高Redis的性能。

当然redis性能管理远远比上面列出的几种复杂的多，需要多加学习。