redis配置（持久化RDB，AOF，数据类型，队列---模式，redis-cli常用命令 ）性能_freeredis zadd

一. redis 配置

端口6379

bind 0.0.0.0     #监听地址，可以用空格隔开后多个监听 IP

protected-mode yes #redis3.2 在没有设置 bind IP 和密码的时候只允许访问127.0.0.1:6379

port 6379 #监听端口

# TCP 监听的最大容纳数量
#
# 在高并发的环境下，你需要把这个值调高以避免客户端连接缓慢的问题。
# Linux 内核会一声不响的把这个值缩小成 /proc/sys/net/core/somaxconn 对应的值，
# 所以你要修改这两个值才能达到你的预期。
tcp-backlog 511 #三次握手的时候 server 端收到 client ack 确认号之后的队列值。

timeout 0 #客户端和 Redis 服务端的连接超时时间，默认是 0，表示永不超时。

tcp-keepalive 300 #tcp 会话保持时间

daemonize no #认情况下 redis 不是作为守护进程运行的，让它在后台运行yes,会写一个 pid 到 /var/run/redis.pid 文件里面

supervised systemd #和操作系统相关参数，可以设置 upstart 和 systemd 
	管理 Redis 守护进程，centos 7以后都使用 systemd

pidfile /var/run/redis_6379.pid #pid 文件路


	#服务端日志的级别。级别包括：
	debug（很多信息，方便开发、测试），
	verbose（许多有用的信息，但是没有debug级别信息多），
	notice（适当的日志级别，适合生产环境），
	warn（只有非常重要的信息）
loglevel notice 


logfile "" #日志路径
	#logfile "/usr/local/redis/logs/redis_6379.log" 

databases 16 #设置 db 库数量，默认 16 个库
	切换库	SELECT 0-15
	
always-show-logo yes #在启动 redis 时是否显示 log

save 900 1 #在 900 秒内有一个键内容发生更改就出就快照机制
save 300 10   #可以写多个
save 60 10000

stop-writes-on-bgsave-error no #快照出错时是否禁止，写入操作
rdbcompression yes #持久化到 RDB 文件时，是否压缩，"yes"为压缩，"no"则反之
rdbchecksum yes #是否开启 RC64 校验，默认是开启
dbfilename dump.rdb #快照文件名
dir ./ #快照文件保存路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

			数据同步
replica-serve-stale-data yes 
或者（不同版本，不一样）
slave-serve-stale-data yes
#当从库同主库失去连接或者复制正在进行，从机库有两种运行方式：
  1) 如果 replica-serve-stale-data 设置为 yes(默认设置)，从库会继续响应客户端的读请求。
  2) 如果 replicaserve-stale-data 设置为 no，除去指定的命令之外的任何请求都会返回一个错误"SYNC with master in progress"。

replica-read-only yes #是否设置从库只读

repl-diskless-sync no #是否使用 socket 方式复制数据，目前 redis 复制提供两种方式，disk 和 socket，
	如果新的 slave 连上来或者重连的 slave 无法部分同步，就会执行全量同步，master 会生成 rdb 文件，
  有 2 种方式：
  	1. disk 方式是 master 创建一个新的进程把 rdb 文件保存到磁盘，再把磁盘上的 rdb 文件传递给 slave，
  	2. socket 是 master 创建一个新的进程，直接把 rdb 文件以 socket 的方式发给 slave，
  	   disk 方式的时候，当一个 rdb 保存的过程中，多个 slave 都能共享这个 rdb 文件，
  	   socket 的方式就是一个个 slave顺序复制，只有在磁盘速度缓慢但是网络相对较快的情况下才使用 socket 方式，
  	 默认的 disk方式

repl-diskless-sync-delay 30 #diskless 复制的延迟时间，设置 0 为关闭，
一旦复制开始还没有结束之前，master 节点不会再接收新 slave 的复制请求，直到下一次开始

repl-ping-slave-period 10 #slave 根据 master 指定的时间进行周期性的 PING 监测

repl-timeout 60 #复制链接超时时间，需要大于 repl-ping-slave-period，否则会经常报超时

repl-disable-tcp-nodelay no #在 socket 模式下是否在 slave 套接字发送 SYNC 之后禁用 TCP_NODELAY，
	如果你选择“yes”Redis 将使用更少的 TCP 包和带宽来向 slaves 发送数据。但是这将使数据传输到 slave
 上有延迟，Linux 内核的默认配置会达到 40 毫秒，
	如果你选择了 "no" 数据传输到 salve 的延迟将会减少但要使用更多的带宽
	
repl-backlog-size 1mb #复制缓冲区大小，只有在 slave 连接之后才分配内存。

repl-backlog-ttl 3600 #多次时间 master 没有 slave 连接，就清空 backlog 缓冲区。

	replica-priority 100 #当 master 不可用，Sentinel 会根据 slave 的优先级选举一个 master。
    最低的优先级的 slave，当选 master。而配置成 0，永远不会被选举。

requirepass foobared #设置 redis 连接密码
 		-a   指定密码

rename-command #重命名一些高危命令

maxclients 10000 #最大连接客户端

maxmemory #最大内存，单位为 bytes 字节，8G 内存的计算方式 8(G)*1024(MB)*1024(KB)*1024(Kbyte)，
需要注意的是 slave 的输出缓冲区是不计算在 maxmemory 内。

appendonly no #是否开启 AOF 日志记录，默认 redis 使用的是 rdb 方式持久化，
这种方式在许多应用中已经足够用了。但是 redis 如果中途宕机，会导致可能有几分钟的数据丢失，根据 save 来策略进行持久化，
Append Only File（AOF）是另一种持久化方式，可以提供更好的持久化特性。Redis 会把每次写入的数据在接收后
都写入 appendonly.aof 文件，每次启动时 Redis 都会先把这个文件的数据读入内存里，先忽略 RDB 文件。

appendfilename "appendonly.aof" #AOF 文件名
appendfsync everysec #aof 持久化策略的配置,
	no 表示不执行 fsync,由操作系统保证数据同步到磁盘,
	always 表示每次写入都执行 fsync，以保证数据同步到磁盘,
	everysec 表示每秒执行一次 fsync，可能会导致丢失这 1s 数据。
no-appendfsync-on-rewrite no #在 aof rewrite 期间,是否对 aof 新记录的 append 暂缓使用文件同步策略,
	主要考虑磁盘 IO 开支和请求阻塞时间。默认为 no,表示"不暂缓",新的 aof 记录仍然会被立即同步，
	Linux 的默认 fsync 策略是 30 秒，如果为 yes 可能丢失 30 秒数据，
	但由于 yes 性能较好而且会避免出现阻塞因此比较推荐。

auto-aof-rewrite-percentage 100 # 当 Aof log 增长超过指定百分比例时，重写 log file， 
	设置为 0 表示不自动重写 Aof 日志，重写是为了使 aof 体积保持最小，而确保保存最完整的数据。

auto-aof-rewrite-min-size 64mb #触发 aof rewrite 的最小文件大小

aof-load-truncated yes #是否加载由于其他原因导致的末尾异常的 AOF 文件(主进程被 kill/断电等)

aof-use-rdb-preamble yes #redis4.0 新增 RDB-AOF 混合持久化格式，在开启了这个功能之后，
	AOF 重写产生的文件将同时包含 RDB 格式的内容和 AOF 格式的内容，其中 RDB 格式的内容用于记录已有的数据，
	而 AOF 格式的内存则用于记录最近发生了变化的数据，这样Redis 就可以同时兼有 RDB 持久化和
	AOF 持久化的优点（既能够快速地生成重写文件，也能够在出现问题时，快速地载入数据）。

lua-time-limit 5000 #lua 脚本的最大执行时间，单位为毫秒



				集群


cluster-enabled yes #是否开启集群模式，默认是单机模式

cluster-config-file nodes-6379.conf #由 node 节点自动生成的集群配置文件

cluster-node-timeout 15000 #集群中 node 节点连接超时时间

cluster-replica-validity-factor 10 #在执行故障转移的时候可能有些节点和 master 断开一段时间数据比较旧，
	这些节点就不适用于选举为 master，超过这个时间的就不会被进行故障转移

cluster-migration-barrier 1 #一个主节点拥有的至少正常工作的从节点，
	即如果主节点的 slave 节点故障后会将多余的从节点分配到当前主节点成为其新的从节点。

cluster-require-full-coverage no #集群槽位覆盖，如果一个主库宕机且没有备库就会出现集群槽位不全，
	yes时 redis 集群槽位验证不全就不再对外提供服务，
	no 则可以继续使用但是会出现查询数据查不到的情况(因为有数据丢失)。

Slow log  #是 Redis 用来记录查询执行时间的日志系统，slow log 保存在内存里面，读写速度非常快，
	因此你可以放心地使用它，不必担心因为开启 slow log 而损害 Redis 的速度。
	
slowlog-log-slower-than 10000 #以微秒为单位的慢日志记录，为负数会禁用慢日志，
	为 0 会记录每个命令操作。
	
slowlog-max-len 128 #记录多少条慢日志保存在队列，超出后会删除最早的，以此滚动删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

127.0.0.1:6379> slowlog len
(integer) 44
127.0.0.1:6379> slowlog get
	1) 1) (integer) 14
	 2) (integer) 1544690617
	 3) (integer) 4
	 4) 1) "slowlog"
127.0.0.1:6379> SLOWLOG reset
OK
1
2
3
4
5
6
7
8
9

要注意的选项：都要设置

requirepass foobared #设置 redis 连接密码
 		redis -h IP -a passwd


maxclients 10000 #最大连接客户端

maxmemory #最大内存，单位为 bytes 字节，8G 内存的计算方式 8(G)*1024(MB)*1024(KB)*1024(Kbyte)，
需要注意的是 slave 的输出缓冲区是不计算在 maxmemory 内。
   尽量不要超过内存的一半
1
2
3
4
5
6
7
8
9

二. redis 持久化

redis 是一个内存级别的缓存程序，即 redis 是使用内存进行数据的缓存的，但是其可以将内存的数据按照一定的策略保存到硬盘上，从而实现数据持久保存的目的，redis 支持两种不同方式的数据
持久化保存机制，分别是 RDB 和 AOF

RDB 模式

RDB：基于时间的快照，只保留当前最新的一次快照，特点是执行速度比较快，缺点是可能会丢失从上次快照到当前快照未完成之间的数据。
RDB 实现的具体过程 Redis 从主进程先 fork 出一个子进程，使用写时复制机制，子进程将内存的数据保存为一个临时文件，比如 dump.rdb.temp，当数据保存完成之后再将上一次保存的 RDB 文件替换掉，
然后关闭子进程，这样可以保存每一次做 RDB 快照的时候保存的数据都是完整的，因为直接替换 RDB文件的时候可能会出现突然断电等问题而导致 RDB 文件还没有保存完整就突然关机停止保存而导致数据丢失的情况，可以手动将每次生成的 RDB 文件进程备份，这样可以最大化保存历史数据。

优点：

1. RDB 快照保存了某个时间点的数据，可以通过脚本执行 bgsave(非阻塞)或者 save(阻塞)命令自定义时间点备份，可以保留多个备份，当出现问题可以恢复到不同时间点的版本。
2. 可以最大化 o 的性能，因为父进程在保存 RDB 文件的时候唯一要做的是 fork 出一个子进程，然后的操作都会有这个子进程操作，父进程无需任何的 IO 操作
3. RDB 在大量数据比如几个 G 的数据，恢复的速度比 AOF 的快

缺点： 不能时时的保存数据，会丢失自上一次执行 RDB 备份到当前的内存数据，数据量非常大的时候，从父进程 fork 的时候需要一点时间，可能是毫秒或者秒

AOF 模式

AOF:按照操作顺序依次将操作添加到指定的日志文件当中，特点是数据安全性相对较高，缺点是即使有些操作是重复的也会全部记录。
AOF 和 RDB 一样使用了写时复制机制，AOF 默认为每秒钟 fsync 一次，即将执行的命令保存到 AOF 文件当中，这样即使 redis 服务器发生故障的话顶多也就丢失 1 秒钟之内的数据，也可以设置不同的 fsync策略，或者设置每次执行命令的时候执行 fsync，fsync 会在后台执行线程，所以主线程可以继续处理用户的正常请求而不受到写入 AOF 文件的 IO 影响

优缺点
AOF 的文件大于 RDB 格式的文件
根据所使用的 fsync 策略(fsync 是同步内存中 redis 所有已经修改的文件到存储设备)，默认是appendfsync everysec 即每秒执行一次 fsync

三. redis 数据类型

http://www.redis.cn/topics/data-types.html

1.字符串(string)

字符串是所有编程语言中最常见的和最常用的数据类型，而且也是 redis 最基本的数据类型之一，而且 redis 中所有的 key 的类型都是字符串。
添加一个 key：

redis-lic -h IP -a passwd

set key1 value1

get key1

TYPE key1

# 设置自动过期时间(ex 多少秒过期)
SET name2 jack2 ex 3  
1
2
3
4
5
6
7
8
9
10

获取一个 key 的内容：

127.0.0.1:6379> get key1
1

删除一个 key：

127.0.0.1:6379> DEL key1
1

批量设置多个 key：

127.0.0.1:6379> MSET key1 value1 key2 value2
1

批量获取多个 key：

127.0.0.1:6379> MSET key1 value1 key2 value2
1

追加数据：

127.0.0.1:6379> APPEND key1 append
(integer) 12
127.0.0.1:6379> get key1
"value1append"
1
2
3
4

数值递增： INCR

127.0.0.1:6379> set num 10
OK

#自增  INCR
127.0.0.1:6379> INCR num
(integer) 11
127.0.0.1:6379> get num
"11"
1
2
3
4
5
6
7
8

数值递减： DECR

127.0.0.1:6379> set num 10
OK

127.0.0.1:6379> DECR num
(integer) 9
127.0.0.1:6379> get num
"9"
1
2
3
4
5
6
7

返回字符串 key 长度：
127.0.0.1:6379> STRLEN key1
(integer) 12

2.列表(list)

列表是一个双向可读写的管道，其头部是左侧尾部是右侧，一个列表最多可以包含 2^32-1 个元素即4294967295 个元素。

生成列表并插入数据： LPUSH

127.0.0.1:6379> LPUSH list1 jack tom qon
(integer) 3
127.0.0.1:6379> TYPE list1
list
1
2
3
4

向列表追加数据：

#左侧追加
127.0.0.1:6379> LPUSH list1 tom
(integer) 2

#右侧追加
127.0.0.1:6379> RPUSH list1 jack
(integer) 3
1
2
3
4
5
6
7

获取列表长度： LLEN

127.0.0.1:6379> LLEN list1
(integer) 3
1
2

移除列表数据：

127.0.0.1:6379> RPOP list1    #最后一个
"jack"
127.0.0.1:6379> LPOP list1    #第一个
"tom"
1
2
3
4

3.集合(set)

Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

生成集合 key:

127.0.0.1:6379> SADD set1 v1 
(integer) 1
127.0.0.1:6379> SADD set2 v2 v4
(integer) 2
127.0.0.1:6379> TYPE set1
set
127.0.0.1:6379> TYPE set2
set
1
2
3
4
5
6
7
8

追加数值：
追加的时候不能追加已经存在的数值

127.0.0.1:6379> SADD set1 v2 v3 v4
(integer) 3
127.0.0.1:6379> SADD set1 v2 #没有追加成功
(integer) 0
127.0.0.1:6379> TYPE set1
set
127.0.0.1:6379> TYPE set2
set
1
2
3
4
5
6
7
8

查看集合的所有数据： smembers

127.0.0.1:6379> SMEMBERS set1
1) "v4"
2) "v1"
3) "v3"
4) "v2"
127.0.0.1:6379> SMEMBERS set2
1) "v4"
2) "v2"
1
2
3
4
5
6
7
8

获取集合的差集： sdiff
差集：已属于 A 而不属于 B 的元素称为 A 与 B 的差（集）

127.0.0.1:6379> SDIFF set1 set2
1) "v1"
2) "v3"
1
2
3

获取集合的交集： sinter
交集：已属于 A 且属于 B 的元素称为 A 与 B 的交（集）

127.0.0.1:6379> SINTER set1 set2
1) "v4"
2) "v2"
1
2
3

获取集合的并集： sunion
并集：已属于 A 或属于 B 的元素为称为 A 与 B 的并（集）

127.0.0.1:6379> SUNION set1 set2
1) "v2"
2) "v4"
3) "v1"
4) "v3"
1
2
3
4
5

4.sorted set(有序集合):

Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员，不同的是每个元素都会关联一个 double(双精度浮点型)类型的分数，redis 正是通过分数来为集合中的成员进行从小到大的排序，有序集合的成员是唯一的,但分数(score)却可以重复，集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)， 集合中最大的成员数为 2^32 - 1 (4294967295, 每个集合可存储 40 多亿个成员)。

生成有序集合： ZADD

						分数   值
127.0.0.1:6379> ZADD zset1 1 v1 
(integer) 1
127.0.0.1:6379> ZADD zset1 2 v2
(integer) 1
127.0.0.1:6379> ZADD zset1 2 v3
(integer) 1
127.0.0.1:6379> ZADD zset1 3 v4
(integer) 1
127.0.0.1:6379> TYPE zset1
zset
127.0.0.1:6379> TYPE zset2
zset
1
2
3
4
5
6
7
8
9
10
11
12
13

排行案例：

192.168.7.104:6379> ZADD paihangbang 10 key1 20 key2 30 key3
(integer) 3
192.168.7.104:6379> ZREVRANGE paihangbang 0 -1 withscores #显示指定集合内所有 key 和得分情况
1) "key3"
2) "30"
3) "key2"
4) "20"
5) "key1"
6) "10"
1
2
3
4
5
6
7
8
9

批量添加多个数值： ZADD

127.0.0.1:6379> ZADD zset2 1 v1 2 v2 4 v3 5 v5
(integer) 4
1
2

获取集合的长度数： ZCARD

127.0.0.1:6379> ZCARD zset1 
(integer) 4
127.0.0.1:6379> ZCARD zset2
(integer) 4
1
2
3
4

基于索引返回数值： ZEANGE

127.0.0.1:6379> ZRANGE zset1 1 3
1) "v2"
2) "v3"
3) "v4"
127.0.0.1:6379> ZRANGE zset1 0 2
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> ZRANGE zset1 2 2
1) "v3"
1
2
3
4
5
6
7
8
9
10

返回某个数值的索引：

127.0.0.1:6379> ZRANK zset1 v2
(integer) 1
127.0.0.1:6379> ZRANK zset1 v3
(integer) 2
1
2
3
4

5.哈希(hash)

hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象,Redis 中每个 hash 可以存储 232 - 1 键值对（40 多亿）。
生成 hash key：

127.0.0.1:6379> HSET hset1 name tom age 18
(integer) 1
127.0.0.1:6379> TYPE hset1
hash
1
2
3
4

获取 hash key 字段值：

127.0.0.1:6379> HGET hset1 name
"tom"
127.0.0.1:6379> HGET hset1 age
"18"
1
2
3
4

删除一个 hash key 的字段：

127.0.0.1:6379> HDEL hset1 age
(integer) 1
1
2

获取所有 hash 表中的字段：

127.0.0.1:6379> HSET hset1 name tom age 19
(integer) 1
127.0.0.1:6379> HKEYS hset1
1) "name"
2) "age"
1
2
3
4
5

四. 队列

1.生产者消费者模式

队列当中的 消息由不同的生产者写入也会有不同的消费者取出进行消费处理，但是一个消息一定是只能被取出一次也就是被消费一次。

生产者消费者模式下，多个消费者同时监听一个队里，但是一个消息只能被最先抢到消息的消费者消费，即消息任务是一次性读取和处理，此模式在分布式业务架构中非常常用，比较常用的软件还有RabbitMQ、Kafka、RocketMQ、ActiveMQ 等

也就是生产者生产出消息后，消费者消费消息—
一个产品只能被一个消费者消费

生产者发布消息： LPUSH

[root@bin ~]# redis-cli
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> LPUSH channel1 msg1 #从管道的左侧写入
(integer) 1
127.0.0.1:6379> LPUSH channel1 msg2
(integer) 2
127.0.0.1:6379> LPUSH channel1 msg3
(integer) 3
127.0.0.1:6379> LPUSH channel1 msg4
(integer) 4
127.0.0.1:6379> LPUSH channel1 msg5
(integer) 5
1
2
3
4
5
6
7
8
9
10
11
12
13

查看队列所有消息： LRANGE

127.0.0.1:6379> LRANGE channel1 0 -1
1) "msg5"
2) "msg4"
3) "msg3"
4) "msg2"
5) "msg1"
1
2
3
4
5
6

消费者消费消息： RPOP

127.0.0.1:6379> RPOP channel1 #从管道的右侧消费
"msg1"
127.0.0.1:6379> RPOP channel1
"msg2"
127.0.0.1:6379> RPOP channel1
"msg3"
127.0.0.1:6379> RPOP channel1
"msg4"
127.0.0.1:6379> RPOP channel1
"msg5"
127.0.0.1:6379> RPOP channel1
(nil)
1
2
3
4
5
6
7
8
9
10
11
12

再次验证队列消息：

127.0.0.1:6379> LRANGE channel1 0 -1 
(empty list or set) #队列中的消息已经被已全部消费完毕
1
2

2.发布者订阅模式

在发布者订阅者模式下，发布者将消息发布到指定的 channel 里面，凡是监听该 channel 的消费者都会收到同样的一份消息，这种模式类似于是收音机模式，即凡是收听某个频道的听众都会收到主持人发布的相同的消息内容。
此模式常用语群聊天、群通知、群公告等场景。
Subscriber：订阅者
Publisher：发布者
Channel：频道

订阅者监听频道： SUBSCRIBE

[root@bin ~]# redis-cli 
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> SUBSCRIBE channel1 #订阅者订阅指定的频道
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1
1
2
3
4
5
6
7
8

发布者发布消息： PUBLISH

127.0.0.1:6379> PUBLISH channel1 test1 #发布者发布消息
(integer) 2
127.0.0.1:6379> PUBLISH channel1 test2
(integer) 2
127.0.0.1:6379>
1
2
3
4
5

各订阅者验证消息

订阅多个频道：
订阅指定的多个频道

> SUBSCRIBE channel1 channel2
1

订阅所有频道：

127.0.0.1:6379> PSUBSCRIBE *
1

订阅匹配的频道：

PSUBSCRIBE chann* #匹配订阅多个频道
1

五. Redis性能

查看Redis内存使用

redis-cli -h 192.168.221.20 -p 6379
info memory
1
2

内存碎片率
操作系统分配的内存值used_memory_rss除以Redis使用的内存值used_memory计算得出;
内存碎片是由操作系统低效的分配/回收物理内存导致的（不连续的物理内存分配）

跟踪内存碎片率对理解Redis实例的资源性能是非常重要的

内存使用率

内回收key
保证合理分配redis有限的内存资源
当达到设置的最大阀值时，需选择一种key的回收策略，默认情况下回收策略是禁止删除

配置文件中修改 maxmemory-policy 属性值：

vim /etc/redis/6379.conf
#---------598取消注释---------------------------------------------------------------------------
maxmemory-policy noenviction
1
2
3
4
5

六. 其他命令

CONFIG：
config 命令用于查看当前 redis 配置、以及不重启更改 redis 配置等

更改最大内存： 只是临时的

127.0.0.1:6379> CONFIG set maxmemory 8589934592
OK
127.0.0.1:6379> CONFIG get maxmemory 
1) "maxmemory"
2) "8589934592"

#显示出所有的配置项（奇数行----配置项，偶数行----参数）
CONFIG get  *
1
2
3
4
5
6
7
8

设置连接密码：

127.0.0.1:6379> CONFIG SET requirepass 123456
OK
1
2

info 显示当前节点 redis 运行状态信息

SELECT #：切换数据库（看配置中有多少个数据库）

keys * : 查看当前库下的所有 key：

BGSAVE 手动在后台执行 RDB 持久化操作

DBSIZE 返回当前库下的所有 key 数量

FLUSHDB：强制清空当前库中的所有 key

FLUSHALL：强制清空当前 redis 服务器所有数据库中的所有 key，即删除所有数据

AUTH 密码： #相当于-a
设置密码
使用config set requirepass password命令设置密码

服务器相关命令

ping ： 检测连接是否存活
echo： 在命令行打印一些内容
quit、exit： 退出客户端
shutdown： 退出服务器端
info： 返回redis相关信息
config get dir/* 实时传递接收的请求
showlog： 显示慢查询
select n： 切换到数据库n，redis默认有16个数据库（DB 0~DB 15），默认使用的第0个
dbsize： 查看当前数据库大小
move key n： 不同数据库之间数据是不能互通的，move移动键到指定数据库
flushdb： 清空当前数据库中的键值对。
flushall： 清空所有数据库的键值对。

#重启/查看进程
supervisorctl reload ！！！！！千万不要用这个命令加载配置文件，会重启所有进程
重新加载配置
supervisorctl update

查看所有进程状态
supervisorctl status

key相关命令

在redis中无论什么数据类型，在数据库中都是以key-value形式保存，通过进行对Redis-key的操作，来完成对数据库中数据的操作。

常用命令：

keys * ：查看当前数据库中所有的key
dbsize： 键总数
exists key： 检查键是否存在
del key [key …]： 删除键
expire key seconds： 键过期
ttl key： 获取键的有效时长
persist key： 移除键的过期时间
type key： 键的数据结构类型
randomkey： 随机返回数据库中一个键
rename key1 key2 ： 重命名
renamex key1 key2 ： 当key2不存在时，key1重命名
代码示例：

redis-server		用于启动 Redis 的工具
redis-benchmark		用于检测 Redis 在本机的运行效率
redis-check-aof		修复 AOF 持久化文件
redis-check-rdb		修复 RDB 持久化文件
redis-cli	 		Redis命令行工具
1
2
3
4
5

redis-cli 命令行工具

语法：redis-cli -h host -p port -a password
-h 指定远程主机
-n 指定库
-p 指定 Redis 服务的端口号
-a 指定密码，未设置数据库密码可以省略-a 选项
若不添加任何选项表示，则使用 127.0.0.1:6379 连接本机上的 Redis 数据库
例：
redis-cli -h 192.168.221.20 -p 6379
#此时无密码，不需要-a直接登陆
1
2
3
4
5
6
7
8
9

redis-benchmark 测试工具

redis-benchmark 是官方自带的 Redis 性能测试工具，可以有效的测试 Redis 服务的性能。
基本的测试语法

redis-benchmark [选项] [选项值]
1

-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 连接并等待
1
2
3
4
5
6
7
8
9
10
11
12
13
14

向 IP 地址为 192.168.221.20、端口为 6379 的 Redis 服务器发送 100 个并发连接与 100000 个请求测试性能

redis-benchmark -h 192.168.221.20 -p 6379 -c 100 -n 100000
1
2

测试存取大小为 100 字节的数据包的性能

redis-benchmark -h 192.168.221.20 -p 6379 -q -d 100
1

测试本机上 Redis 服务在进行 set 与 lpush 操作时的性能

redis-benchmark -t set,lpush -n 100000 -q
1

Redis中清除某个库中的所有数据

进入redis ：redis-cli -h 192.168.233.132 -p 6380
选择其中某个库(比如2号库)：select 2
输入命令：flushdb