Redis 安装与使用

Redis 安装与使用

Redis 介绍

Redis 是由 Salvatore Sanfilippo 写的 key-value 存储系统，是一个跨平台的非关系型数据库（NoSQL）。

Redis 是用C语言开发完全开源，基于内存的高性能数据库，理论读速度110000次/s,写速度81000次/s 。

安装

下载

可以从 Redis 官网下载最新版本，或从 https://github.com/redis/redis-hashes/ 选择自己需要的版本下载。

安装

# 1、安装C语言和环境
yum install gcc-c++
# 2、解压Redis安装包
tar -zxvf redis-3.0.0.tar.gz
# 3、进入解压目录并编译
cd redis-3.0.0/
make
# 4、安装到指定目录
make install PREFIX=/usr/local/redis

基本使用

启动和关闭

前端启动

该方法在启动后会占用当前窗口。

在 redis/bin/ 目录下直接运行 redis-server，使用默认配置文件启动

./redis-server

显示如下界面：

关闭当前命令窗口会使 redis-server 结束运行，或使用Ctrl + C命令结束 redis-server 进程。

后端启动

• 进入安装包解压目录中，有一份配置文件 redis.conf，将其拷贝到 redis/bin 目录下

  cp redis.conf  /usr/local/redis/bin
  

• 修改 /usr/local/redis/bin 下的 redis.conf，将daemonize由no改为yes

  ################################ GENERAL  #####################################
  
  # By default Redis does not run as a daemon. Use 'yes' if you need it.
  
  # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
  
  daemonize yes
  
  

• 使用 redis.conf 配置文件启动

  ./redis-server redis.conf
  

关闭

在 redis/bin/ 目录下，执行 redis-cli -p [port] shutdown

./redis-cli -p [port] shutdown

基本命令

redis客户端命令 redis-cli 控制连接 redis 服务：

# 直接运行 redis-cli，则默认ip 127.0.0.1，默认端口 6379
[root@localhost bin]# ./redis-cli
127.0.0.1:6379> 

redis支持远程访问：

# -h [host] -p [port] -a [password]
[root@localhost bin]# ./redis-cli -h 192.168.233.134 -p 6379
192.168.233.134:6379> 

键（Key）命令

• **keys *** ：

  查看当前库中所有的 key

• exists ：

  检查 key 是否存在，存在返回 1，不存在返回 0

• expire ：

  设置 key 的过期时间（s）

• ttl ：

  查看 key 的剩余生存时间（s）

• type ：

  返回 key 存储的 value 的数据类型

五种数据类型

数据类型	赋值	取值	删除
string	set key value	get key	del key
hash	hset key field value	hget key field	hdel key field...
list	lpush key value...	lrange key start stop	lrem key count value
set	sadd key value...	smembers key	srem key value...
sorted set（zset）	zadd key score value...	zrange key start stop [withscores]	zrem key value...

• string

  127.0.0.1:6379> set str 666
  OK
  127.0.0.1:6379> get str
  "666"
  

  自增（incr）、自减（decr）

  # incr 使存储的数字数据自增
  127.0.0.1:6379> incr str
  (integer) 667
  
  # decr 使存储的数字数据自减
  127.0.0.1:6379> decr str
  (integer) 666
  

• hash

  127.0.0.1:6379> hset user name zhangsan
  (integer) 1
  127.0.0.1:6379> hset user age 35
  (integer) 1
  
  # hgetall 获取key的所有字段和值
  127.0.0.1:6379> hgetall user
  1) "name"
  2) "zhangsan"
  3) "age"
  4) "35"
  
  # 一年过去了
  127.0.0.1:6379> hset user age 36
  (integer) 0
  127.0.0.1:6379> hgetall user
  1) "name"
  2) "zhangsan"
  3) "age"
  4) "36"
  

• list

  元素有序，可重复

  # lpush 从左（表头）插入元素，rpush 从右（表尾）插入元素
  127.0.0.1:6379> lpush list 1 2
  (integer) 2
  127.0.0.1:6379> rpush list 3 4
  (integer) 4
  
  # lrange key 0 -1 遍历所有元素
  127.0.0.1:6379> lrange list 0 -1
  1) "2"
  2) "1"
  3) "3"
  4) "4"
  

  lrem key count value 删除 key 中 count 个为 value 的元素

  127.0.0.1:6379> rpush list 3
  (integer) 5
  127.0.0.1:6379> lrange list 0 -1
  1) "2"
  2) "1"
  3) "3"
  4) "4"
  5) "3"
  
  # count = 0，删除所有值为 3 的元素
  127.0.0.1:6379> lrem list 0 3
  (integer) 2
  127.0.0.1:6379> lrange list 0 -1
  1) "2"
  2) "1"
  3) "4"
  

• set

  元素无序，不可重复

  127.0.0.1:6379> sadd set1 1 2 3 4
  (integer) 4
  127.0.0.1:6379> sadd set2 1 2 
  (integer) 2
  
  # 为 set2 添加一个 2
  127.0.0.1:6379> smembers set2
  1) "1"
  2) "2"
  127.0.0.1:6379> sadd set2 2 
  (integer) 0
  127.0.0.1:6379> smembers set2
  1) "1"
  2) "2"
  

  集合间的差值

  # set1 - set2
  127.0.0.1:6379> sdiff set1 set2
  1) "3"
  2) "4"
  
  # set2 - set1
  127.0.0.1:6379> sdiff set2 set1
  (empty list or set)
  
  # 移除 set1 中的 3、4
  127.0.0.1:6379> srem set1 3 4
  (integer) 2
  127.0.0.1:6379> smembers set1
  1) "1"
  2) "2"
  127.0.0.1:6379> sdiff set1 set2
  (empty list or set)
  

• sorted set（zset）

  元素有序，不可重复

  127.0.0.1:6379> zadd student 59 zhangsan 60 lisi 65 wangwu
  (integer) 3
  127.0.0.1:6379> zrange student 0 -1 withscores
  1) "zhangsan"
  2) "59"
  3) "lisi"
  4) "60"
  5) "wangwu"
  6) "65"
  
  # 将 "zhangsan" 的分数改为 60
  127.0.0.1:6379> zadd student 60 zhangsan
  (integer) 0
  127.0.0.1:6379> zrange student 0 -1 withscores
  1) "lisi"
  2) "60"
  3) "zhangsan"
  4) "60"
  5) "wangwu"
  6) "65"
  

切换数据库

redis 默认有 16 个数据库（由 redis.conf 文件中的 databases 配置），通过索引标识，不能设置名称。

连接 redis 时，默认会连接到数据库 [0]。

• 使用 select [0-15] 切换数据库。

127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> select 2
OK
127.0.0.1:6379[2]> 

• 数据库间的数据相互独立，只能访问修改当前数据库下的数据

# 之前在数据库[0]创建有 str ：666
# 在数据库[2]获取 str
127.0.0.1:6379[2]> get str
(nil)
# 在数据库[2]设置 str ：lisi
127.0.0.1:6379[2]> set str lisi
OK
127.0.0.1:6379[2]> get str
"lisi"
# 回到数据库[0]，获取 str 依然为 666
127.0.0.1:6379[2]> select 0
OK
127.0.0.1:6379> get str
"666"

• 清空数据库的数据

  FLUSHDB ：清空当前数据库的数据

  # 数据库[0]
  127.0.0.1:6379> keys *
  1) "student"
  2) "list"
  3) "set1"
  4) "set2"
  5) "str"
  6) "user"
  # 数据库[2]
  127.0.0.1:6379[2]> keys *
  1) "str"
  # 在数据库[0]使用 FLUSHDB 命令
  127.0.0.1:6379> flushdb
  OK
  127.0.0.1:6379> keys *
  (empty list or set)
  
  # 数据库[2]的数据没有被清除
  127.0.0.1:6379> select 2
  OK
  127.0.0.1:6379[2]> keys *
  1) "str"
  

  FLUSHALL ：清空所有数据库的数据

  # 在数据库[0]、[1]各创建一个数据
  127.0.0.1:6379> keys *
  1) "db0"
  127.0.0.1:6379[1]> keys *
  1) "db1"
  127.0.0.1:6379[2]> keys *
  1) "str"
  
  # 在任意数据库运行 FLUSHALL 命令
  127.0.0.1:6379[1]> flushall
  OK
  127.0.0.1:6379> keys *
  (empty list or set)
  127.0.0.1:6379[1]> keys *
  (empty list or set)
  127.0.0.1:6379[2]> keys *
  (empty list or set)
  

持久化

Redis 的所有数据都存储在内存中，为了使 Redis 在重启之后仍能访问到上次的数据，需要将数据从内存中同步到硬盘中，这一过程就是持久化。

Redis 支持两种持久化方式，RDB和AOF，可以单独使用或结合使用。

RDB持久化

Redis 默认的持久化方案，通过快照（snapshotting）创建 dump.rdb 文件将数据保存到磁盘

RDB配置项：

save 900 1     #900秒内如果超过1个key被修改，则发起快照保存
save 300 10    #300秒内如超过10个key被修改，则发起快照保存
save 60 10000  #60秒内如果超过10000个key被修改，则发起快照保存

stop-writes-on-bgsave-error yes  #如果最近一次快照文件创建失败则停止 redis 的数据写入操作
rdbcompression yes   #压缩快照文件
dbfilename dump.rdb  #文件名
dir ./               #创建文件路径

Redis 启动后会读取RDB快照文件，将数据从硬盘载入到内存。

在操作数据库时，可以使用 SAVE / BGSAVE 和 CONFIG GET dir 命令手动保存或读取RDB快照文件，在读取RDB文件时要使文件名、文件路径与配置文件中保持一致。

一般我们会使用 RDB 的自动持久化策略：

• 优点：减少 IO 操作，确保 redis 的高性能
• 缺点：Redis 一旦发生故障，极易造成数据丢失，无法保证数据完整性

AOF持久化

AOF（Append Only File）仅追加的文件，会将执行过的写指令追加到 AOF 文件，redis 重启后再将所有指令执行一遍。

AOF 默认是关闭的，需要配置 redis.conf 文件的 appendonly yes 开启

appendonly yes                 #开启 AOF
appendfilename appendonly.aof  #文件名，保存路径和 RDB 文件一致

#appendfsync always    #每次有数据修改时，写入 AOF 文件。
appendfsync everysec   # AOF 默认策略，每秒写入一次。
#appendfsync no        #从不写入。

auto-aof-rewrite-percentage 100  #自动重写的增长比例阈值
auto-aof-rewrite-min-size 64mb   #自动重写的最小文件大小

重写是指：将指令集压缩到可以恢复数据的最小指令集。

开启 AOF 持久化后，当 AOF 文件的大小大于 64M，且当前大小比上一次重写后的大小增长比例高于阈值，才会进行重写。

• 优点：保证了数据的完整性
• 缺点：大量的 IO 操作，严重影响 redis 性能

主从复制

持久化保证了 Redis 重启后不会丢失数据，但如果硬盘损坏了怎么办。主从复制就可以避免这类问题。

主从复制：将主Redis服务器（master）的数据，复制到从Redis服务器（slave）。

• 只能有一个 master，可以有多个 slave，一主多从。

• 数据只能由 master 复制到 slave。

• 主从数据实时同步，master 写入数据时通过主从复制机制，将数据复制到 slave。

• 主从复制时不会阻塞 master 的服务进程，master 依然可以处理 Client 请求。

• 一个 Redis 可以即是主又是从，（Redis1 是 Redis3/4 的主，是 Redis 的从）：

  

主从复制过程

复制过程：

1、slave 建立和 master 的连接，发送sync 命令。

2、master 启动一个后台进程将数据库保存到 RDB 文件中

3、master 发送RDB文件给 slave

4、slave 接收文件保存到磁盘，然后加载到内存

5、master 把缓存的写命令同步给 slave

• 注意：主如果宕机，从只能读

主从复制的配置

• 主Redis无需额外配置。

• 配置从Redis (slave) 的 redis.conf 中的 slaveof：slaveof <masterip> <masterport>，例：

  slaveof 192.168.233.134 6379
  

在主Redis中创建一条数据 str 666，启动从Redis 查看

slave 127.0.0.1:6380> keys *
slave 1) "str"

在主Redis存入数据，查看效果

master 127.0.0.1:6379> set master 123
master OK

# 从Redis同步了数据
slave 127.0.0.1:6380> keys *
slave 1) "str"
slave 2) "master"
slave 127.0.0.1:6380> get master
slave "123"
# 尝试在从Redis存入数据
slave 127.0.0.1:6380> set user zhangsan
slave (error) READONLY You can't write against a read only slave.

关闭主Redis，查看从Redis情况

# 从Redis可以正常读取数据
slave 127.0.0.1:6380> keys *
slave 1) "str"
slave 2) "master"
# 从Redis依然不可写入数据
slave 127.0.0.1:6380> set user zhangsan
slave (error) READONLY You can't write against a read only slave.

集群

主从复制避免了磁盘损坏导致的数据丢失问题，还可以对读操作进行负载均衡，但写操作就只能完全由 master 执行，无法应对写操作的负载均衡问题，并且一台服务器的数据存储终究是有限的，数据过高时该如何解决。

Redis 集群架构

• 所有的redis节点彼此互联(PING-PONG机制)
• 节点是否fail，通过集群中超过半数的节点检测失效时才生效：

• 连接任一节点都可以存取数据，但集群中有一个节点fail，整个集群都会fail

  Redis 集群中内置了 16384 个哈希槽，这些哈希槽会大致均等的分布在 Redis 节点上。

  当需要在Redis 集群中放置一个 key-value 时，redis 先对 key 使用 crc16 算法得到一个结果，然后把结果对 16384 求余，使每个 key 对应一个编号在 0-16383 之间的哈希槽。

搭建集群

Redis 集群中至少有三个节点。要保证集群的高可用，还需要每个节点有一个备份机。

也就是说 Redis 集群至少需要6台服务器。

搭建伪分布式

使用一台虚拟机运行6个 Redis 实例。

• 删除源 Redis 的 dump.rdb 和 appendonly.aof 文件，修改 redis.conf 配置文件，取消 cluster-enabled yes 的注释：

• 

• 创建 /usr/local/redis-cluster 目录，复制 6 个 Redis 到该目录下，并修改端口 7001-7006。

• 创建启动和关闭集群的脚本：start-all.sh、shutdown-all.sh 放在 redis-cluster 目录下，并启动：

  # 启动脚本
  [root@localhost redis-cluster]# vim start-all.sh
  
  cd redis-7001/bin/
  ./redis-server redis.conf
  cd ../..
  cd redis-7002/bin/
  ./redis-server redis.conf
  cd ../..
  cd redis-7003/bin/
  ./redis-server redis.conf
  cd ../..
  cd redis-7004/bin/
  ./redis-server redis.conf
  cd ../..
  cd redis-7005/bin/
  ./redis-server redis.conf
  cd ../..
  cd redis-7006/bin/
  ./redis-server redis.conf
  cd ../..
  
  [root@localhost redis-cluster]# chmod 777 start-all.sh
  [root@localhost redis-cluster]# ./start-all.sh
  
  # 关闭脚本
  [root@localhost redis-cluster]# vim shutdown-all.sh
  
  cd redis-7001/bin
  ./redis-cli -p 7001 shutdown
  ./redis-cli -p 7002 shutdown
  ./redis-cli -p 7003 shutdown
  ./redis-cli -p 7004 shutdown
  ./redis-cli -p 7005 shutdown
  ./redis-cli -p 7006 shutdown
  
  [root@localhost redis-cluster]# chmod 777 shutdown-all.sh
  

使用 ruby 搭建集群

• 安装ruby：

  [root@upload ~]# yum install ruby
  [root@upload ~]# yum install rubygems
  [root@upload ~]# gem install redis-3.0.0.gem 
  
  Successfully installed redis-3.0.0
  
  1 gem installed
  
  Installing ri documentation for redis-3.0.0...
  
  Installing RDoc documentation for redis-3.0.0...
  
  [root@localhost ~]# cd redis-3.0.0/src
  [root@localhost src]# ll *.rb
  -rwxrwxr-x. 1 root root 48141 Apr  1  2015 redis-trib.rb
  

• 运行 ruby 脚本搭建集群：

  [root@localhost src]# ./redis-trib.rb create --replicas 1 192.168.233.134:7001 192.168.233.134:7002 192.168.233.134:7003 192.168.233.134:7004 192.168.233.134:7005  192.168.233.134:7006
  >>> Creating cluster
  Connecting to node 192.168.233.134:7001: OK
  Connecting to node 192.168.233.134:7002: OK
  Connecting to node 192.168.233.134:7003: OK
  Connecting to node 192.168.233.134:7004: OK
  Connecting to node 192.168.233.134:7005: OK
  Connecting to node 192.168.233.134:7006: OK
  >>> Performing hash slots allocation on 6 nodes...
  .
  .
  .
  [OK] All nodes agree about slots configuration.
  >>> Check for open slots...
  >>> Check slots coverage...
  [OK] All 16384 slots covered.
  [root@localhost src]# 
  

• 使用 redis-cli -c -p 7001 启动集群模式：

  [root@localhost bin]# ./redis-cli -c -p 7001
  127.0.0.1:7001> set zhangsan 37
  -> Redirected to slot [12767] located at 192.168.233.134:7006
  OK
  

  查看集群信息 cluster info：

  192.168.233.134:7006> 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:9
  cluster_my_epoch:8
  cluster_stats_messages_sent:745
  cluster_stats_messages_received:745
  

  查看集群所有节点及其信息 cluster nodes：

  192.168.233.134:7006> cluster nodes
  d706c3ff4f4f559ca71993491e9e43f5e0cb91f7 192.168.233.134:7005 master - 0 1663762662907 7 connected 5461-10922
  46c0129ff01dd17266ab6c7c7c1b617ba602dfff 192.168.233.134:7001 slave 7d7c537d2a27ab00dc3ca3d00230294485757d19 0 1663762661901 9 connected
  17ebb9266a1cad4eee1037740011fac225f95ceb 192.168.233.134:7003 slave cb261bd5ed6be6532b7bc36d93ae438156e6452b 0 1663762659793 8 connected
  7d7c537d2a27ab00dc3ca3d00230294485757d19 192.168.233.134:7004 master - 0 1663762660887 9 connected 0-5460
  919ee638fcb7fd5d245d0dddd201554608ef9256 192.168.233.134:7002 slave d706c3ff4f4f559ca71993491e9e43f5e0cb91f7 0 1663762659250 7 connected
  cb261bd5ed6be6532b7bc36d93ae438156e6452b 192.168.233.134:7006 myself,master - 0 0 8 connected 10923-16383