Redis.md

rpm 包安装

CentOS 系列系统安装redis可以通过第三方提供的rpm包进行安装：

# yum install -y epel-release
# yum install -y redis

源码安装

安装依赖程序

# yum install -y gcc gcc-c++ wget

获取源码并安装

# wget http://download.redis.io/releases/redis-3.2.6.tar.gz
# tar xf redis-3.2.6.tar.gz
# cd redis-3.2.6
# make
# make install

运行配置

# cd utils/
# ./install_server.sh
Welcome to the redis service installer
This script will help you easily set up a running redis server

Please select the redis port for this instance: [6379]
Selecting default: 6379
Please select the redis config file name [/etc/redis/6379.conf]
Selected default - /etc/redis/6379.conf
Please select the redis log file name [/var/log/redis_6379.log]
Selected default - /var/log/redis_6379.log
Please select the data directory for this instance [/var/lib/redis/6379]
Selected default - /var/lib/redis/6379
Please select the redis executable path [/usr/local/bin/redis-server]
Selected config:
Port           : 6379
Config file    : /etc/redis/6379.conf
Log file       : /var/log/redis_6379.log
Data dir       : /var/lib/redis/6379
Executable     : /usr/local/bin/redis-server
Cli Executable : /usr/local/bin/redis-cli
Is this ok? Then press ENTER to go on or Ctrl-C to abort.
Copied /tmp/6379.conf => /etc/init.d/redis_6379
Installing service...
Successfully added to chkconfig!
Successfully added to runlevels 345!
Starting Redis server...
Installation successful!
[root@localhost utils]# ss -tnl
State       Recv-Q Send-Q                         Local Address:Port                                        Peer Address:Port
LISTEN      0      128                                127.0.0.1:6379                                                   *:*
LISTEN      0      128                                        *:22                                                     *:*
LISTEN      0      100                                127.0.0.1:25                                                     *:*
LISTEN      0      128                                       :::22                                                    :::*
LISTEN      0      100                                      ::1:25                                                    :::

在源码中自带的一个安装脚本可以很快的配置好redis服务。

学习资源

官方网站
中文网站

命令

安装redis 后会生成以下几个命令：

• redis-benchmark：用于检查Redis的性能。

• redis-check-aof：持久化存储时的aof 文件损坏时使用。

• redis-check-rdb：持久化存储时的rdb 文件损坏时使用。

• redis-cli：redis：连接server的客户端。

• redis-sentinel：是Redis Sentinel可执行文件（监视和故障转移）。

• redis-server：运行redis server 服务。

redis-cli

• -h <hostname>：Server hostname (default: 127.0.0.1).

• -p <port>：Server port (default: 6379).

• -s <socket>：服务器套接字（覆盖主机名和端口）。

• -a <password>：连接到服务器时使用的密码。

• -r <repeat>：执行指定的命令N次。

• -i <interval>：当使用-r时，每个命令等待秒。可以指定亚秒级时间，如-i 0.1。

• -n <db>：Database number.

• -x：从STDIN读取最后一个参数。

• -d <delimiter>：用于原始格式化的多批量分隔符（默认值：\ n）。

• -c：启用群集模式（遵循-ASK和-MOVED重定向）。

• --raw：对回复使用原始格式（默认情况下STDOUT为不是tty）。

• --no-raw：强制格式化输出，即使STDOUT不是tty。

• --csv：Output in CSV format.

• --stat：打印有关服务器的滚动统计信息：mem，clients，...

• --latency：输入特殊模式连续采样延迟。

• --latency-history：像--latency但跟踪延迟随时间而变化。默认时间间隔为15秒。 使用-i更改它。

• --latency-dist：将延迟显示为频谱，需要xterm 256色。默认时间间隔为1秒。 使用-i更改它。

• --lru-test <keys>：使用80-20分布模拟高速缓存工作负载。

• --slave：模拟从站显示从主站接收的命令。

• --rdb <filename>：将RDB转储从远程服务器传输到本地文件。

• --pipe：将原始Redis协议从stdin传输到服务器。

• --pipe-timeout <n>：在管道模式下，如果在发送所有数据后中止发生错误。在<n>秒内未收到回复。 默认超时：30。使用0永远等待。

• --bigkeys：示例Redis键寻找bigkeys。

• --scan：使用SCAN命令列出所有键。

• --pattern <pat>：用于--scan指定扫描模式。

• --intrinsic-latency <sec>：运行测试以测量内部系统延迟。测试将运行指定的秒数。

• --eval <file>：使用<file>处的Lua脚本发送EVAL命令。

• --ldb：与--eval启用Redis Lua调试器一起使用。

• --ldb-sync-mode：像--ldb，但使用同步Lua调试器这种模式下服务器被阻塞和脚本更改是不从服务器内存回滚。

redis-benchmark

• -h <hostname>：Server hostname (default 127.0.0.1)

• -p <port>：Server port (default 6379)

• -s <socket>：Server socket (overrides host and port)

• -a <password>：Password for Redis Auth

• -c <clients>：并行连接数（默认50）

• -n <requests>：请求总数（默认为100000）

• -d <size>：SET / GET值的数据大小（以字节为单位）（默认为2）

• -dbnum <db>：SELECT指定的数据库号（默认为0）

• -k <boolean>：1 =保持活动0 =重新连接（默认值1）

• -P <numreq>：管道<numreq>请求。 默认值1（no pipeline）。

• -e：如果服务器回复错误，请在stdout上显示它们。（显示每秒不超过1个错误）

• -q：Quiet。 只显示query / sec值

• --csv：Output in CSV format

• -l：循环。 永远运行测试

• -t <tests>：只运行逗号分隔的测试列表。 测试名称与作为输出生成的名称相同。

• -I：空闲模式。 只需打开N个空闲连接并等待。

配置文件说明

GENERAL

daemonize no

daemonize no 默认情况下，redis不是在后台运行的，如果需要在后台运行，把该项的值更改为yes。

pidfile /var/run/redis.pid

当redis在后台运行的时候，Redis默认会把pid文件放在/var/run/redis.pid，你可以配置到其他地址。当运行多个redis服务时，需要指定不同的pid文件和端口。

port 6379

指定redis运行的端口，默认是6379。

bind 127.0.0.1

指定redis只接收来自于该IP地址的请求，如果不进行设置，那么将处理所有请求，在生产环境中最好设置该项。

timeout 0
tcp-keepalive 0

设置客户端连接时的超时时间，单位为秒。当客户端在这段时间内没有发出任何指令，那么关闭该连接，0是关闭此设置。

loglevel notice

指定日志记录级别Redis总共支持四个级别：debug、verbose、notice、warning.

• debug 记录很多信息，用于开发和测试

• varbose 有用的信息，不像debug会记录那么多

• notice 普通的verbose，常用于生产环境

• warning 只有非常重要或者严重的信息会记录到日志

logfile ""

配置log文件地址默认值为stdout，标准输出，若后台模式会输出到/dev/null。

database 16

可用数据库数，默认值为16，默认数据库为0，数据库范围在0-（database-1）之间。

SNAPSHOTTING

save 900 1
save 300 10
save 60 10000

保存数据到磁盘，格式如下:
save <seconds> <changes>
指出在多长时间内，有多少次更新操作，就将数据同步到数据文件rdb。相当于条件触发抓取快照，这个可以多个条件配合。比如默认配置文件中的设置，就设置了三个条件：

#   save 900 1  900秒内至少有1个key被改变
#   save 300 10  300秒内至少有300个key被改变
#   save 60 10000  60秒内至少有10000个key被改变

rdbcompression yes

存储至本地数据库时（持久化到rdb文件）是否压缩数据，默认为yes

dbfilename dump.rdb

本地持久化数据库文件名，默认值为dump.rdb

dir ./

工作目录， 数据库镜像备份的文件放置的路径。这里的路径跟文件名要分开配置是因为redis在进行备份时，先会将当前数据库的状态写入到一个临时文件中，等备份完成时，再把该该临时文件替换为上面所指定的文件，而这里的临时文件和上面所配置的备份文件都会放在这个指定的路径当中。AOF文件也会存放在这个目录下面注意这里必须制定一个目录而不是文件。

REPLICATION

slaveof <masterip><masterport>

主从复制. 设置该数据库为其他数据库的从数据库。设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步。

masterauth <master-password>

当master服务设置了密码保护时(用requirepass制定的密码)。slav服务连接master的密码。

slave-server-stale-data yes

当从库同主机失去连接或者复制正在进行，从机库有两种运行方式：

1. 如果slave-serve-stale-data设置为yes(默认设置)，从库会继续相应客户端的请求

2. 如果slave-serve-stale-data是指为no，出去INFO和SLAVOF命令之外的任何请求都会返回一个错误"SYNC with master in progress"

repl-ping-slave-period 10

从库会按照一个时间间隔向主库发送PINGs.可以通过repl-ping-slave-period设置这个时间间隔，默认是10秒。

repl-timeout 60

repl-timeout 设置主库批量数据传输时间或者ping回复时间间隔，默认值是60秒，一定要确保repl-timeout大于repl-ping-slave-period。

SECURITY

requirepass foobared

设置客户端连接后进行任何其他指定前需要使用的密码。警告：因为redis速度相当快，所以在一台比较好的服务器下，一个外部的用户可以在一秒钟进行150K次的密码尝试，这意味着你需要指定非常非常强大的密码来防止暴力破解。

rename-command CONFIG ""

命令重命名.在一个共享环境下可以重命名相对危险的命令。比如把CONFIG重名为一个不容易猜测的字符。举例:

rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52

如果想删除一个命令，直接把它重命名为一个空字符""即可，如下：

LIMITS

maxclients 10000

设置同一时间最大客户端连接数，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数， 如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息

manxmenory <bytes>

指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，Redis同时也会移除空的list对象。当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。
注意：Redis新的vm机制，会把Key存放内存，Value会存放在swap区。maxmemory的设置比较适合于把redis当作于类似memcached的缓存来使用，而不适合当做一个真实的DB。当把Redis当做一个真实的数据库使用的时候，内存使用将是一个很大的开销。

maxmemory-policy volative-lru

当内存达到最大值的时候Redis会选择删除哪些数据？有五种方式可供选择

# volatile-lru -> 利用LRU算法移除设置过过期时间的key (LRU:最近使用 Least Recently Used )
# allkeys-lru -> 利用LRU算法移除任何key
# volatile-random -> 移除设置过过期时间的随机key
# allkeys->random -> remove a random key, any key
# volatile-ttl -> 移除即将过期的key(minor TTL)
# noeviction -> 不移除任何可以，只是返回一个写错误

注意：对于上面的策略，如果没有合适的key可以移除，当写的时候Redis会返回一个错误。

maxmemory-samples 3

LRU 和 minimal TTL 算法都不是精准的算法，但是相对精确的算法(为了节省内存)，随意你可以选择样本大小进行检测。Redis默认的灰选择3个样本进行检测，你可以通过maxmemory-samples进行设置。

APPEND ONLY MODE

appendonly no

默认情况下，redis会在后台异步的把数据库镜像备份到磁盘，但是该备份是非常耗时的，而且备份也不能很频繁，如果发生诸如拉闸限电、拔插头等状况，那么将造成比较大范围的数据丢失。所以redis提供了另外一种更加高效的数据库备份及灾难恢复方式。开启append only模式之后，redis会把所接收到的每一次写操作请求都追加到appendonly.aof文件中，当redis重新启动时，会从该文件恢复出之前的状态。但是这样会造成appendonly.aof文件过大，所以redis还支持了BGREWRITEAOF指令，对appendonly.aof 进行重新整理。你可以同时开启asynchronous dumps 和 AOF。
appendfilename "appendonly.aof"
AOF文件名称 (默认: "appendonly.aof")。

# appendfsync always
appendfsync everysec
# appendfsync no

Redis支持三种同步AOF文件的策略:

• no: 不进行同步，系统去操作 . Faster.

• always: always表示每次有写操作都进行同步. Slow, Safest.

• everysec: 表示对写操作进行累积，每秒同步一次. Compromise.

默认是"everysec"，按照速度和安全折中这是最好的。如果想让Redis能更高效的运行，你也可以设置为"no"，让操作系统决定什么时候去执行。或者相反想让数据更安全你也可以设置为"always"。如果不确定就用 "everysec".

no-appendfsync-on-write no

AOF策略设置为always或者everysec时，后台处理进程(后台保存或者AOF日志重写)会执行大量的I/O操作。在某些Linux配置中会阻止过长的fsync()请求。注意现在没有任何修复，即使fsync在另外一个线程进行处理。为了减缓这个问题，可以设置下面这个参数no-appendfsync-on-rewrite。

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

AOF 自动重写，当AOF文件增长到一定大小的时候Redis能够调用 BGREWRITEAOF 对日志文件进行重写。它是这样工作的：Redis会记住上次进行些日志后文件的大小(如果从开机以来还没进行过重写，那日志大小在开机的时候确定)。基础大小会同现在的大小进行比较。如果现在的大小比基础大小大制定的百分比，重写功能将启动。同时需要指定一个最小大小用于AOF重写，这个用于阻止即使文件很小但是增长幅度很大也去重写AOF文件的情况。设置 percentage 为0就关闭这个特性。

SLOW LOG

slowlog-log-slower-than 10000

Redis Slow Log 记录超过特定执行时间的命令。执行时间不包括I/O计算比如连接客户端，返回结果等，只是命令执行时间。可以通过两个参数设置slow log：一个是告诉Redis执行超过多少时间被记录的参数slowlog-log-slower-than(微秒)，另一个是slow log 的长度。当一个新命令被记录的时候最早的命令将被从队列中移除。下面的时间以微秒为单位，因此1000000代表一分钟。
注意制定一个负数将关闭慢日志，而设置为0将强制每个命令都会记录。

slowlog-max-len 128

对日志长度没有限制，只是要注意它会消耗内存。可以通过 SLOWLOG RESET 回收被慢日志消耗的内存。

hash-max-ziplist-entries 512
hash-max-ziplist-value 64

当hash中包含超过指定元素个数并且最大的元素没有超过临界时，hash将以一种特殊的编码方式（大大减少内存使用）来存储，这里可以设置这两个临界值。Redis Hash对应Value内部实际就是一个HashMap，实际这里会有2种不同实现，这个Hash的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会采用真正的HashMap结构，对应的value redisObject的encoding为zipmap，当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。

list-max-ziplist-entries 512
list-max-ziplist-value 64

list数据类型多少节点以下会采用去指针的紧凑存储格式。list数据类型节点值大小小于多少字节会采用紧凑存储格式。

set-max-intset-entries 512

set数据类型内部数据如果全部是数值型，且包含多少节点以下会采用紧凑格式存储。

zset-max-ziplist-entries 128
zset-max-ziplist-value 64

zsort数据类型多少节点以下会采用去指针的紧凑存储格式。zsort数据类型节点值大小小于多少字节会采用紧凑存储格式。

activerehashing yes

Redis将在每100毫秒时使用1毫秒的CPU时间来对redis的hash表进行重新hash，可以降低内存的使用。 当你的使用场景中，有非常严格的实时性需要，不能够接受Redis时不时的对请求有2毫秒的延迟的话，把这项配置为no。 如果没有这么严格的实时性要求，可以设置为yes，以便能够尽可能快的释放内存

命令说明

连接操作相关的命令

• quit：关闭连接（connection）

• auth：简单密码认证

对value操作的命令

• exists(key)：确认一个key是否存在

• del(key)：删除一个key

• type(key)：返回值的类型

• keys(pattern)：返回满足给定pattern的所有key

• randomkey：随机返回key空间的一个key

• rename(oldname, newname)：将key由oldname重命名为newname，若newname存在则删除newname表示的key

• dbsize：返回当前数据库中key的数目

• expire：设定一个key的活动时间（s）

• ttl：获得一个key的活动时间

• select(index)：按索引查询

• move(key, dbindex)：将当前数据库中的key转移到有dbindex索引的数据库

• flushdb：删除当前选择数据库中的所有key

• flushall：删除所有数据库中的所有key

对String操作的命令

• set(key, value)：给数据库中名称为key的string赋予值value

• get(key)：返回数据库中名称为key的string的value

• getset(key, value)：给名称为key的string赋予上一次的value

• mget(key1, key2,…, key N)：返回库中多个string（它们的名称为key1，key2…）的value

• setnx(key, value)：如果不存在名称为key的string，则向库中添加string，名称为key，值为value

• setex(key, time, value)：向库中添加string（名称为key，值为value）同时，设定过期时间time

• mset(key1, value1, key2, value2,…key N, value N)：同时给多个string赋值，名称为key i的string赋值value i

• msetnx(key1, value1, key2, value2,…key N, value N)：如果所有名称为key i的string都不存在，则向库中添加string，名称key i赋值为value i

• incr(key)：名称为key的string增1操作

• incrby(key, integer)：名称为key的string增加integer

• decr(key)：名称为key的string减1操作

• decrby(key, integer)：名称为key的string减少integer

• append(key, value)：名称为key的string的值附加value

• substr(key, start, end)：返回名称为key的string的value的子串

对List操作的命令

• rpush(key, value)：在名称为key的list尾添加一个值为value的元素

• lpush(key, value)：在名称为key的list头添加一个值为value的 元素

• llen(key)：返回名称为key的list的长度

• lrange(key, start, end)：返回名称为key的list中start至end之间的元素（下标从0开始，下同）

• ltrim(key, start, end)：截取名称为key的list，保留start至end之间的元素

• lindex(key, index)：返回名称为key的list中index位置的元素

• lset(key, index, value)：给名称为key的list中index位置的元素赋值为value

• lrem(key, count, value)：删除count个名称为key的list中值为value的元素。count为0，删除所有值为value的元素，count>0从头至尾删除count个值为value的元素，count<0从尾到头删除|count|个值为value的元素。 lpop(key)：返回并删除名称为key的list中的首元素 rpop(key)：返回并删除名称为key的list中的尾元素 blpop(key1, key2,… key N, timeout)：lpop命令的block版本。即当timeout为0时，若遇到名称为key i的list不存在或该list为空，则命令结束。如果timeout>0，则遇到上述情况时，等待timeout秒，如果问题没有解决，则对keyi+1开始的list执行pop操作。

• brpop(key1, key2,… key N, timeout)：rpop的block版本。参考上一命令。

• rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部

对Set操作的命令

• sadd(key, member)：向名称为key的set中添加元素member

• srem(key, member) ：删除名称为key的set中的元素member

• spop(key) ：随机返回并删除名称为key的set中一个元素

• smove(srckey, dstkey, member) ：将member元素从名称为srckey的集合移到名称为dstkey的集合

• scard(key) ：返回名称为key的set的基数

• sismember(key, member) ：测试member是否是名称为key的set的元素

• sinter(key1, key2,…key N) ：求交集

• sinterstore(dstkey, key1, key2,…key N) ：求交集并将交集保存到dstkey的集合

• sunion(key1, key2,…key N) ：求并集

• sunionstore(dstkey, key1, key2,…key N) ：求并集并将并集保存到dstkey的集合

• sdiff(key1, key2,…key N) ：求差集

• sdiffstore(dstkey, key1, key2,…key N) ：求差集并将差集保存到dstkey的集合

• smembers(key) ：返回名称为key的set的所有元素

• srandmember(key) ：随机返回名称为key的set的一个元素

对zset（sorted set）操作的命令

• zadd(key, score, member)：向名称为key的zset中添加元素member，score用于排序。如果该元素已经存在，则根据score更新该元素的顺序。

• zrem(key, member) ：删除名称为key的zset中的元素member

• zincrby(key, increment, member) ：如果在名称为key的zset中已经存在元素member，则该元素的score增加increment；否则向集合中添加该元素，其score的值为increment

• zrank(key, member) ：返回名称为key的zset（元素已按score从小到大排序）中member元素的rank（即index，从0开始），若没有member元素，返回“nil”

• zrevrank(key, member) ：返回名称为key的zset（元素已按score从大到小排序）中member元素的rank（即index，从0开始），若没有member元素，返回“nil”

• zrange(key, start, end)：返回名称为key的zset（元素已按score从小到大排序）中的index从start到end的所有元素

• zrevrange(key, start, end)：返回名称为key的zset（元素已按score从大到小排序）中的index从start到end的所有元素

• zrangebyscore(key, min, max)：返回名称为key的zset中score >= min且score <= max的所有元素 zcard(key)：返回名称为key的zset的基数 zscore(key, element)：返回名称为key的zset中元素element的score zremrangebyrank(key, min, max)：删除名称为key的zset中rank >= min且rank <= max的所有元素 zremrangebyscore(key, min, max) ：删除名称为key的zset中score >= min且score <= max的所有元素

• zunionstore / zinterstore(dstkeyN, key1,…,keyN, WEIGHTS w1,…wN, AGGREGATE SUM|MIN|MAX)：对N个zset求并集和交集，并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score，在进行AGGREGATE运算前，都要乘以对于的WEIGHT参数。如果没有提供WEIGHT，默认为1。默认的AGGREGATE是SUM，即结果集合中元素的score是所有集合对应元素进行SUM运算的值，而MIN和MAX是指，结果集合中元素的score是所有集合对应元素中最小值和最大值。

对Hash操作的命令

• hset(key, field, value)：向名称为key的hash中添加元素field<—>value

• hget(key, field)：返回名称为key的hash中field对应的value

• hmget(key, field1, …,field N)：返回名称为key的hash中field i对应的value

• hmset(key, field1, value1,…,field N, value N)：向名称为key的hash中添加元素field i<—>value i

• hincrby(key, field, integer)：将名称为key的hash中field的value增加integer

• hexists(key, field)：名称为key的hash中是否存在键为field的域

• hdel(key, field)：删除名称为key的hash中键为field的域

• hlen(key)：返回名称为key的hash中元素个数

• hkeys(key)：返回名称为key的hash中所有键

• hvals(key)：返回名称为key的hash中所有键对应的value

• hgetall(key)：返回名称为key的hash中所有的键（field）及其对应的value

持久化

• save：将数据同步保存到磁盘

• bgsave：将数据异步保存到磁盘

• lastsave：返回上次成功将数据保存到磁盘的Unix时戳

• shundown：将数据同步保存到磁盘，然后关闭服务

远程服务控制

• info：提供服务器的信息和统计

• monitor：实时转储收到的请求

• slaveof：改变复制策略设置

• config：在运行时配置Redis服务器

命令参考
命令参考

高级应用

安全性

在使用Redis 的时候需要从下面几点做好安全保护：

• 绑定在内网或者本地回环地址上。

• 机器如果有公网IP 则做好iptables 方面的防火墙。

• Redis 做auth 认证。

系统默认配置文件是将redis 绑定在机器的127.0.0.1 上面，这么做是出于安全的考虑。但是实际使用中很多人为了方便会把redis 绑定在0.0.0.0上，这么做很危险。如果机器是内网的还好说但是机器是公网的，并且还没有做auth 认证，那你的机器就是一个裸奔的机器。及其不建议这么使用。即使是做了用户认证但是以一个外部用户可以再一秒钟进行150W次访问所以还是不建议机器绑定在公网IP上。
下面是介绍如何在配置文件中修改相关的配置：

bind 192.168.5.193

上面是配置文件中关于redis 绑定的IP地址。

requirepass passwd

上面是redis 的认证密码。
配置好后我们登录需要指定登录的IP和端口才能登录：

# redis-cli -h 192.168.5.193 -p 6379
192.168.5.193:6379>

而登录后则需要先进行认证才能使用：

192.168.5.193:6379> set ds heixian
(error) NOAUTH Authentication required.
192.168.5.193:6379> AUTH passwd
OK
192.168.5.193:6379> set ds heixian
OK

事务处理

redis对事务的支持还比较简单，redis只能保证一个client发起的事务中的命令可以连续执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务的上下文，连接后续命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中的所有命令。

192.168.5.193:6379> set age 20
OK
192.168.5.193:6379> MULTI
OK
192.168.5.193:6379> set age 22
QUEUED
192.168.5.193:6379> set age 25
QUEUED
192.168.5.193:6379> EXEC
1) OK
2) OK
192.168.5.193:6379> get age
"25"

WATCH：乐观锁；在EXEC命令执行之前，用于监视指定数量键；如果监视中的某任意键数据被修改，则服务器拒绝执行事务；

持久化

Redis有两种持久化的方式：快照（RDB文件）和追加式文件（AOF文件）

• RDB: snapshot，二进制格式；按事先定制的策略，周期性地将数据保存至磁盘；数据文件默认为dump.rdb; 客户端也可显式使用SAVA或BGSAVE命令启动快照保存机制；其中SAVE: 同步，在主线程中保存快照；此时会阻塞所有客户端请求；不建议在线上机器上使用。BGSAVE：异步。

• AOF：Append Only File，记录每一次写操作至指定的文件尾部实现持久化；当redis重启时，可通过重新执行文件中的命令在内存重建数据库；

RDB相关的配置

• save 900 1：在900秒（15分钟）后如果至少1个键改变

• save 300 10：在300秒（5分钟）后如果至少10个键改变

• save 60 10000：60秒后如果至少10000个键更改

• stop-writes-on-bgsave-error yes：默认情况下，如果Redis在后台生成快照的时候失败，那么就会停止接收数据，目的是让用户能知道数据没有持久化成功。但是如果你有其他的方式可以监控到Redis及其持久化的状态，那么可以把这个功能禁止掉。
  rdbcompression yes：默认Redis会采用LZF对数据进行压缩。如果你想节省点CPU的性能，你可以把压缩功能禁用掉，但是数据集就会比没压缩的时候要大。

• rdbchecksum yes：从版本5的RDB的开始，一个CRC64的校验码会放在文件的末尾。这样更能保证文件的完整性，但是在保存或者加载文件时会损失一定的性能（大概10%）。如果想追求更高的性能，可以把它禁用掉，这样文件在写入校验码时会用0替代，加载的时候看到0就会直接跳过校验。

• dbfilename dump.rdb：持久化的文件名。

• dir /var/lib/redis/6379：持久化文件存放的路径。

在配置中我们一般主要修改存放的文件名和存放路径。关于保存的的设置需要根据实际需求进行设计。如果想禁用快照保存的功能，可以通过注释掉所有"save"配置达到，或者在最后一条"save"配置后添加如下的配置save ""。

AOF相关的配置

• appendonly no：启用AOF

• appendfilename "appendonly.aof"：文件路径和名称

• appendfsync always：每当有新命令追加到AOF的时候调用fsync。速度最慢，但是最安全。

• appendfsync everysec：每秒fsync一次。速度快（2.4版本跟快照方式速度差不多），安全性不错（最多丢失1秒的数据）。

• appendfsync no：从不fsync，交由系统去处理。这个方式速度最快，但是安全性没有保证。

• no-appendfsync-on-rewrite no：在日志重写时，不进行命令追加操作，而只是将其放在缓冲区里，避免与命令的追加造成DISK IO上的冲突。设置为yes表示rewrite期间对新写操作不fsync,暂时存在内存中,等rewrite完成后再写入，默认为no。

• auto-aof-rewrite-percentage 100：Redis会记住自从上一次重写后AOF文件的大小（如果自Redis启动后还没重写过，则记住启动时使用的AOF文件的大小）。 如果当前的文件大小比起记住的那个大小超过指定的百分比，则会触发重写。

• auto-aof-rewrite-min-size 64mb：同时需要设置一个文件大小最小值，只有大于这个值文件才会重写，以防文件很小，但是已经达到百分比的情况。

注意事项

• 持久本身不能取代备份；还应该制定备份策略，对redis数据库定期进行备份；

• RDB与AOF同时启用，BGSAVE和BGREWRITEAOF不会同时执行；在Redis服务器启动用于恢复数据时，会优先使用AOF；

• 关闭数据库最后使用redis 中的shutdown命令，如果使用Linux 系统的kill -9 杀死进程会带来数据的丢失。

• 数据损坏之后请先备份下数据然后使用redis-check-aof或者 redis-check-rdb命令针对相关的文件进行修复。

• 如果你要想提供很高的数据保障性，那么建议你同时使用两种持久化方式。

• 数据的持久化还可以通过Replication 进行保存。

扩展学习

主从复制

Redis复制很简单易用，它通过配置允许slave Redis Servers或者Master Servers的复制品。接下来有几个关于redis复制的非常重要特性：

• 一个Master可以有多个Slaves。

• Slaves能过接口其他slave的链接，除了可以接受同一个master下面slaves的链接以外，还可以接受同一个结构图中的其他slaves的链接。

• redis复制是在master段是非阻塞的，这就意味着master在同一个或多个slave端执行同步的时候还可以接受查询。
  复制在slave端也是非阻塞的，假设你在redis.conf中配置redis这个功能，当* slave在执行的新的同步时，它仍可以用旧的数据信息来提供查询，否则，你可以配置当redis slaves去master失去联系是，slave会给发送一个客户端错误。

• 为了有多个slaves可以做只读查询，复制可以重复2次，甚至多次，具有可扩展性（例如：slaves对话与重复的排序操作，有多份数据冗余就相对简单了）。

• 通过复制可以避免master全量写硬盘的消耗：只要配置 master 的配置文件redis.conf来“避免保存”（注释掉所有”save”命令），然后连接一个用来持久化数据的slave即可。但是这样要确保masters 不会自动重启（更多内容请阅读下段）

参考

应用举例
下面的配置是没有基于auth 认证的主。
主服务上查看验证的数据：

# redis-cli -h 192.168.5.193 -p 6379
192.168.5.193:6379> keys *
1) "dota"
2) "ds"
3) "age"
4) "sa"
5) "web"
6) "a"
7) "sv"
192.168.5.193:6379> info Replication
# Replication
role:master
connected_slaves:0
master_repl_offset:505
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:504

从服务器做以下操作：

# redis-cli -h 192.168.5.194 -p 6379
192.168.5.194:6379> FLUSHALL
192.168.5.194:6379> keys *
192.168.5.194:6379> info Replication
# Replication
role:master
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
192.168.5.194:6379> SLAVEOF 192.168.5.193 6379
OK
192.168.5.194:6379> keys *
1) "web"
2) "a"
3) "ds"
4) "dota"
5) "sa"
6) "age"
7) "sv"
192.168.5.194:6379> info Replication
# Replication
role:slave
master_host:192.168.5.193
master_port:6379
master_link_status:up
master_last_io_seconds_ago:8
master_sync_in_progress:0
slave_repl_offset:757
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

查看从节点同步日志：

7953:S 24 Jan 17:29:11.970 * SLAVE OF 192.168.5.193:6379 enabled (user request from 'id=2 addr=192.168.5.194:56288 fd=5 name= age=77 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=slaveof')
7953:S 24 Jan 17:29:12.890 * Connecting to MASTER 192.168.5.193:6379
7953:S 24 Jan 17:29:12.891 * MASTER <-> SLAVE sync started
7953:S 24 Jan 17:29:12.891 * Non blocking connect for SYNC fired the event.
7953:S 24 Jan 17:29:12.891 * Master replied to PING, replication can continue...
7953:S 24 Jan 17:29:12.892 * Partial resynchronization not possible (no cached master)
7953:S 24 Jan 17:29:12.896 * Full resync from master: b97c96b0fae1177981c4d2c2a83e3ba3c841857f:547
7953:S 24 Jan 17:29:12.937 * MASTER <-> SLAVE sync: receiving 191 bytes from master
7953:S 24 Jan 17:29:12.937 * MASTER <-> SLAVE sync: Flushing old data
7953:S 24 Jan 17:29:12.937 * MASTER <-> SLAVE sync: Loading DB in memory
7953:S 24 Jan 17:29:12.937 * MASTER <-> SLAVE sync: Finished with success

带认证的主从复制。
主节点的配置做auth 认证的设置：

requirepass redhat

重启主节点的Redis：

# redis-cli -h 192.168.5.193 -p 6379
192.168.5.193:6379> SHUTDOWN
#  /etc/init.d/redis_6379 start
# redis-cli -h 192.168.5.193 -p 6379
192.168.5.193:6379> keys *
(error) NOAUTH Authentication required.
192.168.5.193:6379> auth redhat
OK

从节点配置文件做以下修改：

slaveof 192.168.5.193 6379
masterauth redhat

启动从节点的redis：

# /etc/init.d/redis_6379 start

连接从节点并查看数据：

# redis-cli -h 192.168.5.194 -p 6379
192.168.5.194:6379> keys *
1) "sv"
2) "ds"
3) "sa"
4) "a"
5) "age"
6) "web"
7) "dota"
192.168.5.194:6379> info replication
# Replication
role:slave
master_host:192.168.5.193
master_port:6379
master_link_status:up
master_last_io_seconds_ago:7
master_sync_in_progress:0
slave_repl_offset:57
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

从节点配置文件查看：

8064:S 24 Jan 17:50:34.260 * DB loaded from disk: 0.000 seconds
8064:S 24 Jan 17:50:34.260 * The server is now ready to accept connections on port 6379
8064:S 24 Jan 17:50:34.260 * Connecting to MASTER 192.168.5.193:6379
8064:S 24 Jan 17:50:34.261 * MASTER <-> SLAVE sync started
8064:S 24 Jan 17:50:34.289 * Non blocking connect for SYNC fired the event.
8064:S 24 Jan 17:50:34.290 * Master replied to PING, replication can continue...
8064:S 24 Jan 17:50:34.291 * Partial resynchronization not possible (no cached master)
8064:S 24 Jan 17:50:34.294 * Full resync from master: f26ce942ac6a712886d0aacabbc756f5180d5663:1
8064:S 24 Jan 17:50:34.398 * MASTER <-> SLAVE sync: receiving 191 bytes from master
8064:S 24 Jan 17:50:34.399 * MASTER <-> SLAVE sync: Flushing old data
8064:S 24 Jan 17:50:34.399 * MASTER <-> SLAVE sync: Loading DB in memory
8064:S 24 Jan 17:50:34.399 * MASTER <-> SLAVE sync: Finished with success

sentinel

简介
Redis 的 Sentinel 系统用于管理多个 Redis 服务器（instance）， 该系统执行以下三个任务：

• 监控（Monitoring）： Sentinel 会不断地检查你的主服务器和从服务器是否运作正常。

• 提醒（Notification）： 当被监控的某个 Redis 服务器出现问题时， Sentinel 可以通过 API 向管理员或者其他应用程序发送通知。

• 自动故障迁移（Automatic failover）： 当一个主服务器不能正常工作时， Sentinel 会开始一次自动故障迁移操作， 它会将失效主服务器的其中一个从服务器升级为新的主服务器， 并让失效主服务器的其他从服务器改为复制新的主服务器； 当客户端试图连接失效的主服务器时， 集群也会向客户端返回新主服务器的地址， 使得集群可以使用新主服务器代替失效服务器。

启动
当前Redis stable版已经自带了redis-sentinel这个工具。虽然 Redis Sentinel 已经提供了一个单独的可执行文件 redis-sentinel ， 但实际上它只是一个运行在特殊模式下的 Redis实例， 你可以在启动一个普通 Redis实例时通过给定 –sentinel 选项来启动 Redis Sentinel 实例。也就是说：

redis-sentinel /path/to/sentinel.conf

等同于

redis-server /path/to/sentinel.conf --sentinel

其中sentinel.conf是redis的配置文件，Redis sentinel会需要写入配置文件来保存sentinel的当前状态。当配置文件无法写入时，Sentinel启动失败。

环境说明
下面是用三台虚拟机进行搭建，这三台机器同时启动redis-server和Sentinel的服务，同时三台机器信息如下：
192.168.5.192 Master(6379)/Sentinel(26379)
192.168.5.193 Slave(6379)/Sentinel(26379)
192.168.5.194 Slave(6379)/Sentinel(26379)

搭建

Master 主机先安装redis 将配置文件中监听的地址修改为192.168.5.192启动：

# redis-cli -h 192.168.5.192 -p 6379
192.168.5.192:6379>set nginx webserver
OK

下面是两个Slave 的安装配置：

# vim /etc/redis/6379.conf
bind 192.168.5.193
slaveof 192.168.5.192 6379
# /etc/init.d/redis_6379 starts
# redis-cli -h 192.168.5.193 -p 6379
192.168.5.193:6379> get nginx
"webserver"

# vim /etc/redis/6379.conf
bind 192.168.5.194
slaveof 192.168.5.192 6379
# /etc/init.d/redis_6379 start
# redis-cli -h 192.168.5.194 -p 6379
192.168.5.194:6379> get nginx
"webserver"

在主节点查看主从信息：

192.168.5.192:6379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=192.168.5.193,port=6379,state=online,offset=1107,lag=2
slave1:ip=192.168.5.194,port=6379,state=online,offset=1107,lag=1
master_repl_offset:1107
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:1106

然后分别在三台机器上安装Sentinel：

# egrep -v "(^#)|(^$)" /etc/redis/sentinel.conf
bind 192.168.5.192
daemonize yes
logfile /var/log/redis_sentinel.log
port 26379
dir /tmp
sentinel monitor mymaster 192.168.5.192 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000
# redis-sentinel /etc/redis/sentinel.conf
# tail -4 /var/log/redis_sentinel.log
5779:X 08 Feb 18:32:06.129 # Sentinel ID is 101a57f2716b11235ecce23a415073e485d3b63c
5779:X 08 Feb 18:32:06.129 # +monitor master mymaster 192.168.5.192 6379 quorum 2
5779:X 08 Feb 18:32:06.130 * +slave slave 192.168.5.193:6379 192.168.5.193 6379 @ mymaster 192.168.5.192 6379
5779:X 08 Feb 18:32:06.133 * +slave slave 192.168.5.194:6379 192.168.5.194 6379 @ mymaster 192.168.5.192 6379

# egrep -v "(^#)|(^$)" /etc/redis/sentinel.conf
bind 192.168.5.193
daemonize yes
logfile /var/log/redis_sentinel.log
port 26379
dir /tmp
sentinel monitor mymaster 192.168.5.192 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000
# redis-sentinel /etc/redis/sentinel.conf
# tail -5 /var/log/redis_sentinel.log
20816:X 08 Feb 18:33:50.695 # Sentinel ID is d15140bc391e8f78b08c91bcda756fbbfcf7400f
20816:X 08 Feb 18:33:50.695 # +monitor master mymaster 192.168.5.192 6379 quorum 2
20816:X 08 Feb 18:33:50.697 * +slave slave 192.168.5.193:6379 192.168.5.193 6379 @ mymaster 192.168.5.192 6379
20816:X 08 Feb 18:33:50.699 * +slave slave 192.168.5.194:6379 192.168.5.194 6379 @ mymaster 192.168.5.192 6379
20816:X 08 Feb 18:33:51.024 * +sentinel sentinel 101a57f2716b11235ecce23a415073e485d3b63c 192.168.5.192 26379 @ mymaster 192.168.5.192 6379

# egrep -v "(^#)|(^$)" /etc/redis/sentinel.conf
bind 192.168.5.194
daemonize yes
logfile /var/log/redis_sentinel.log
port 26379
dir /tmp
sentinel monitor mymaster 192.168.5.192 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000
# redis-sentinel /etc/redis/sentinel.conf
# tail -6 /var/log/redis_sentinel.log
3608:X 08 Feb 18:34:21.639 # Sentinel ID is cae4a6fc47ade920963d01e40b32dea9ec3ca9d4
3608:X 08 Feb 18:34:21.640 # +monitor master mymaster 192.168.5.192 6379 quorum 2
3608:X 08 Feb 18:34:21.641 * +slave slave 192.168.5.193:6379 192.168.5.193 6379 @ mymaster 192.168.5.192 6379
3608:X 08 Feb 18:34:21.653 * +slave slave 192.168.5.194:6379 192.168.5.194 6379 @ mymaster 192.168.5.192 6379
3608:X 08 Feb 18:34:22.064 * +sentinel sentinel 101a57f2716b11235ecce23a415073e485d3b63c 192.168.5.192 26379 @ mymaster 192.168.5.192 6379
3608:X 08 Feb 18:34:23.285 * +sentinel sentinel d15140bc391e8f78b08c91bcda756fbbfcf7400f 192.168.5.193 26379 @ mymaster 192.168.5.192 6379

查看sentinel相关的信息：

# redis-cli -h 192.168.5.192 -p 26379
192.168.5.192: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=mymaster,status=ok,address=192.168.5.192:6379,slaves=2,sentinels=3

SENTINEL masters
列出所有被监视的主Redis服务实例，以及这些主服务实例的当前状态。

192.168.5.192:26379> sentinel masters
1)  1) "name"
    2) "mymaster"
    3) "ip"
    4) "192.168.5.192"
    5) "port"
    6) "6379"
......

SENTINEL slaves
SENTINEL slaves ：列出给定主服务实例的所有从实例，以及这些从实例的当前状态。

192.168.5.192:26379> sentinel slaves mymaster
1)  1) "name"
    2) "192.168.5.194:6379"
    3) "ip"
    4) "192.168.5.194"
    5) "port"
    6) "6379"
......
2)  1) "name"
    2) "192.168.5.193:6379"
    3) "ip"
    4) "192.168.5.193"
    5) "port"
    6) "6379"
......

SENTINEL get-master-addr-by-name
返回给定名字的主实例的 IP 地址和端口号。 如果这个主实例正在执行故障转移操作， 或者针对这个主实例的故障转移操作已经完成， 那么这个命令返回新的主服务器的 IP 地址和端口号。

192.168.5.192:26379> SENTINEL get-master-addr-by-name mymaster
1) "192.168.5.192"
2) "6379"

SENTINEL reset
重置所有名字和给定模式 pattern 相匹配的主服务器。 pattern 参数是一个 Glob 风格的模式。 重置操作清除该sentinel的所保存的所有状态信息，并进行一次重新的发现过程。
故障迁移

# redis-cli -h 192.168.5.192 -p 6379
192.168.5.192:6379> SHUTDOWN

# redis-cli -h 192.168.5.193 -p 26379
192.168.5.193: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=mymaster,status=ok,address=192.168.5.193:6379,slaves=2,sentinels=3
192.168.5.193:26379> SENTINEL get-master-addr-by-name mymaster
1) "192.168.5.193"
2) "6379"

查看新的master是否能写入数据：

# redis-cli -h 192.168.5.193 -p 6379
192.168.5.193:6379> keys *
1) "nginx"
192.168.5.193:6379> get nginx
"webserver"
192.168.5.193:6379> set httpd webserver
OK
192.168.5.193:6379> get httpd
"webserver"

查看集群信息：

# redis-cli -h 192.168.5.193 -p 6379
192.168.5.193:6379> info replication
# Replication
role:master
connected_slaves:1
slave0:ip=192.168.5.194,port=6379,state=online,offset=17139181,lag=1
master_repl_offset:17139322
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:16090747
repl_backlog_histlen:1048576

如果我们在讲192.168.5.192的redis的节点启动，则其会成为从，并不会成为主节点。

INFO 命令说明

INFO命令以一种易于理解和阅读的格式，返回关于Redis服务器的各种信息和统计数值。
server
记录了 Redis 服务器的信息，它包含以下域：

redis_version : Redis 服务器版本
redis_git_sha1 : Git SHA1
redis_git_dirty : Git dirty flag
os : Redis 服务器的宿主操作系统
arch_bits : 架构（32 或 64 位）
multiplexing_api : Redis 所使用的事件处理机制
gcc_version : 编译 Redis 时所使用的 GCC 版本
process_id : 服务器进程的 PID
run_id : Redis 服务器的随机标识符（用于 Sentinel 和集群）
tcp_port : TCP/IP 监听端口
uptime_in_seconds : 自 Redis 服务器启动以来，经过的秒数
uptime_in_days : 自 Redis 服务器启动以来，经过的天数
lru_clock : 以分钟为单位进行自增的时钟，用于 LRU 管理

clients
记录了已连接客户端的信息，它包含以下域：

connected_clients : 已连接客户端的数量（不包括通过从属服务器连接的客户端）
client_longest_output_list : 当前连接的客户端当中，最长的输出列表
client_longest_input_buf : 当前连接的客户端当中，最大输入缓存
blocked_clients : 正在等待阻塞命令（BLPOP、BRPOP、BRPOPLPUSH）的客户端的数量

memory
记录了服务器的内存信息，它包含以下域：

used_memory : 由 Redis 分配器分配的内存总量，以字节（byte）为单位
used_memory_human : 以人类可读的格式返回 Redis 分配的内存总量
used_memory_rss : 从操作系统的角度，返回 Redis 已分配的内存总量（俗称常驻集大小）。这个值和 top 、 ps 等命令的输出一致。
used_memory_peak : Redis 的内存消耗峰值（以字节为单位）
used_memory_peak_human : 以人类可读的格式返回 Redis 的内存消耗峰值
used_memory_lua : Lua 引擎所使用的内存大小（以字节为单位）
mem_fragmentation_ratio : used_memory_rss 和 used_memory 之间的比率
mem_allocator : 在编译时指定的， Redis 所使用的内存分配器。可以是 libc 、 jemalloc 或者 tcmalloc 。

在理想情况下， used_memory_rss 的值应该只比 used_memory 稍微高一点儿。
当 rss > used ，且两者的值相差较大时，表示存在（内部或外部的）内存碎片。
内存碎片的比率可以通过 mem_fragmentation_ratio 的值看出。
当 used > rss 时，表示 Redis 的部分内存被操作系统换出到交换空间了，在这种情况下，操作可能会产生明显的延迟。
当 Redis 释放内存时，分配器可能会，也可能不会，将内存返还给操作系统。
如果 Redis 释放了内存，却没有将内存返还给操作系统，那么 used_memory 的值可能和操作系统显示的 Redis 内存占用并不一致。
查看 used_memory_peak 的值可以验证这种情况是否发生。
persistence
记录了跟 RDB 持久化和 AOF 持久化有关的信息，它包含以下域：

loading : 一个标志值，记录了服务器是否正在载入持久化文件。
rdb_changes_since_last_save : 距离最近一次成功创建持久化文件之后，经过了多少秒。
rdb_bgsave_in_progress : 一个标志值，记录了服务器是否正在创建 RDB 文件。
rdb_last_save_time : 最近一次成功创建 RDB 文件的 UNIX 时间戳。
rdb_last_bgsave_status : 一个标志值，记录了最近一次创建 RDB 文件的结果是成功还是失败。
rdb_last_bgsave_time_sec : 记录了最近一次创建 RDB 文件耗费的秒数。
rdb_current_bgsave_time_sec : 如果服务器正在创建 RDB 文件，那么这个域记录的就是当前的创建操作已经耗费的秒数。
aof_enabled : 一个标志值，记录了 AOF 是否处于打开状态。
aof_rewrite_in_progress : 一个标志值，记录了服务器是否正在创建 AOF 文件。
aof_rewrite_scheduled : 一个标志值，记录了在 RDB 文件创建完毕之后，是否需要执行预约的 AOF 重写操作。
aof_last_rewrite_time_sec : 最近一次创建 AOF 文件耗费的时长。
aof_current_rewrite_time_sec : 如果服务器正在创建 AOF 文件，那么这个域记录的就是当前的创建操作已经耗费的秒数。
aof_last_bgrewrite_status : 一个标志值，记录了最近一次创建 AOF 文件的结果是成功还是失败。

如果 AOF 持久化功能处于开启状态，那么这个部分还会加上以下域：

aof_current_size : AOF 文件目前的大小。
aof_base_size : 服务器启动时或者 AOF 重写最近一次执行之后，AOF 文件的大小。
aof_pending_rewrite : 一个标志值，记录了是否有 AOF 重写操作在等待 RDB 文件创建完毕之后执行。
aof_buffer_length : AOF 缓冲区的大小。
aof_rewrite_buffer_length : AOF 重写缓冲区的大小。
aof_pending_bio_fsync : 后台 I/O 队列里面，等待执行的 fsync 调用数量。
aof_delayed_fsync : 被延迟的 fsync 调用数量。

stats
记录了一般统计信息，它包含以下域：

total_connections_received : 服务器已接受的连接请求数量。
total_commands_processed : 服务器已执行的命令数量。
instantaneous_ops_per_sec : 服务器每秒钟执行的命令数量。
rejected_connections : 因为最大客户端数量限制而被拒绝的连接请求数量。
expired_keys : 因为过期而被自动删除的数据库键数量。
evicted_keys : 因为最大内存容量限制而被驱逐（evict）的键数量。
keyspace_hits : 查找数据库键成功的次数。
keyspace_misses : 查找数据库键失败的次数。
pubsub_channels : 目前被订阅的频道数量。
pubsub_patterns : 目前被订阅的模式数量。
latest_fork_usec : 最近一次 fork() 操作耗费的毫秒数。

replication
主/从复制信息

role : 如果当前服务器没有在复制任何其他服务器，那么这个域的值就是 master ；否则的话，这个域的值就是 slave 。注意，在创建复制链的时候，一个从服务器也可能是另一个服务器的主服务器。
master_host : 主服务器的 IP 地址。
master_port : 主服务器的 TCP 监听端口号。
master_link_status : 复制连接当前的状态， up 表示连接正常， down 表示连接断开。
master_last_io_seconds_ago : 距离最近一次与主服务器进行通信已经过去了多少秒钟。
master_sync_in_progress : 一个标志值，记录了主服务器是否正在与这个从服务器进行同步。
master_sync_left_bytes : 距离同步完成还缺少多少字节数据。
master_sync_last_io_seconds_ago : 距离最近一次因为 SYNC 操作而进行 I/O 已经过去了多少秒。
master_link_down_since_seconds : 主从服务器连接断开了多少秒。
connected_slaves : 已连接的从服务器数量。
slaveXXX : ID、IP 地址、端口号、连接状态

cpu
记录了 CPU 的计算量统计信息，它包含以下域：

used_cpu_sys : Redis 服务器耗费的系统 CPU 。
used_cpu_user : Redis 服务器耗费的用户 CPU 。
used_cpu_sys_children : 后台进程耗费的系统 CPU 。
used_cpu_user_children : 后台进程耗费的用户 CPU 。

commandstats
记录了各种不同类型的命令的执行统计信息，比如命令执行的次数、命令耗费的 CPU 时间、执行每个命令耗费的平均 CPU 时间等等。对于每种类型的命令，这个部分都会添加一行以下格式的信息：

cmdstat_XXX:calls=XXX,usec=XXX,usecpercall=XXX

cluster
记录了和集群有关的信息，它包含以下域：

cluster_enabled : 一个标志值，记录集群功能是否已经开启。

keyspace
记录了数据库相关的统计信息，比如数据库的键数量、数据库已经被删除的过期键数量等。对于每个数据库，这个部分都会添加一行以下格式的信息：

dbXXX:keys=XXX,expires=XXX

官方说明

扩展学习

http://debugo.com/redis-sentinel/
http://www.cnblogs.com/wjoyxt/p/4242184.html
https://segmentfault.com/a/1190000002680804
https://segmentfault.com/a/1190000002685515

中文学习资源：
http://redisdoc.com/index.html
http://www.redis.cn/commands.html