redis

wuxingge

已于 2022-09-04 10:15:22 修改

阅读量309

点赞数

分类专栏： redis 文章标签： redis 缓存 lua

于 2020-06-02 08:34:16 首次发布

本文链接：https://blog.csdn.net/wuxingge/article/details/106487649

版权

redis 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

redis

http://www.redis.io/documentation

http://www.redis.cn/

http://doc.redisfans.com/

http://redisdoc.com/

http://download.redis.io/releases/

redis可视化工具
https://redis.com/redis-enterprise/redis-insight/

吞吐量和响应时间评价网站性能
并发指的是连接数
距离硬盘越近，速度越慢
距离用户越远，速度越慢
读缓存
写缓冲
缓冲区是磁盘的一块区域空间
CPU写到缓冲区，它就认为写完成

redis介绍

redis是一个开源的使用ANSI C语言编写的key-value内存数据库
读写性能强，支持多种数据类型
把数据存储在内存中的高速缓存

特点

速度快
支持多种数据结构
持久化
主从复制（集群）
支持过期时间
支持事务
消息队列
支持分布式分片集群

Redis应用场景

数据缓存

     提高访问性能，使用的方式与memcache相同。

会话缓存（Session Cache）

      保存web会话信息

排行榜/计数器

       Nginx+lua+Redis计数器进行IP自动封禁。

消息队列

     构建实时消息系统，聊天，群聊。

安装配置

** 依赖**

yum install gcc gcc-c++ automake autoconf jemalloc jemalloc-devel hiredis-devel

** 安装**

mv redis-3.2.12 /usr/local/
ln -s /usr/local/redis-3.2.12/ /usr/local/redis
cd /usr/local/redis
make

cat /etc/profile.d/redis.sh

export PATH="/usr/local/redis/src:$PATH"

** 启动**

redis-server &

连接

redis-cli

** 停止**

127.0.0.1:6379> shutdown

配置文件

mkdir /data/6379

vim /data/6379/redis.conf

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename dump.rdb

启动

redis-server /data/6379/redis.conf

登录认证

vim /data/6379/redis.conf

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename dump.rdb
bind 10.0.0.51 127.0.0.1
requirepass  123456

[root@db01 ~]# redis-cli
127.0.0.1:6379> AUTH 123456
OK

redis-cli -a 123

** 保护模式**

protected-mode yes
requirepass 123456

运行配置

获取当前配置

CONFIG GET *

变更运行配置

CONFIG SET requirepass 123456

sysctl vm.overcommit_memory=1

启动

redis-server /application/redis/conf/redis.conf &

‘vm.overcommit_memory = 1’ to /etc/sysctl.conf and then reboot

or run the command

sysctl vm.overcommit_memory=1

停止

redis-cli shutdown

登录操作

127.0.0.1:6379> set no002 oldboy

OK

127.0.0.1:6379> get no002

"oldboy"

** Redis数据存储**

持久化

http://doc.redisfans.com/topic/persistence.html

** RDB**

RDB 持久化可以在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）

/etc/redis.conf

daemonize  yes
bind 10.0.0.51
port 6379
appendonly yes
logfile /data/6379/redis.log
dbfilename dump.rdb
dir /data/6379
protected-mode yes
requirepass 123456
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes 
rdbchecksum yes

说明：

900秒（15分钟）内有1个更改
300秒（5分钟）内有10个更改
60秒内有10000个更改

后台备份进程出错时,主进程停不停止写入? 主进程不停止容易造成数据不一致
导出的rdb文件是否压缩如果rdb的大小很大的话建议这么做

导入rbd恢复时数据时,要不要检验rdb的完整性验证版本是不是一致

#配置文件

[root@db01 redis]# vim /etc/redis/6379/redis.conf

#持久化数据文件存储位置
dir /etc/redis/6379
#rdb持久化数据文件名
dbfilename dump.rdb
#900秒（15分钟）内有1个更改
save 900 1
#300秒（5分钟）内有10个更改
save 300 10
#60秒（1分钟）内有10000个更改
save 60 10000

cat /data/6379/redis.conf

daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
dbfilename dump.rdb
bind 127.0.0.1
requirepass  123
save 900 1
save 300 10
save 60 1000

#高级配置

[root@db01 redis]# vim /etc/redis/6379/redis.conf

#后台备份进程出错时,主进程停不停止写入? 主进程不停止容易造成数据不一致

stop-writes-on-bgsave-error yes

#导出的rdb文件是否压缩如果rdb的大小很大的话建议这么做

rdbcompression yes

#导入rbd恢复时数据时,要不要检验rdb的完整性验证版本是不是一致

rdbchecksum yes

** AOF**

AOF 持久化记录服务器执行的所有写操作命令，并在服务器启动时，通过重新执行这些命令来还原数据集。
AOF 文件中的命令全部以 Redis 协议的格式来保存，新命令会被追加到文件的末尾。 Redis 还可以在后台对 AOF 文件进行重写（rewrite），使得 AOF 文件的体积不会超出保存数据集状态所需的实际大小

appendonly yes
appendfilename "appendonly.aof"

#以下配置三选一：

appendfsync always
appendfsync everysec
appendfsync no

#配置文件

[root@db01 redis]# vim /etc/redis/6379/redis.conf

#是否打开AOF日志功能
appendonly yes/no
#每一条命令都立即同步到AOF
appendfsync always
#每秒写一次
appendfsync everysec
#写入工作交给操作系统,由操作系统判断缓冲区大小,统一写入到AOF
appendfsync no

cat /etc/redis/6379/redis.conf

daemonize yes
port 6379
logfile /etc/redis/6379/redis.log
dir /etc/redis/6379
dbfilename dump.rdb
bind 127.0.0.1
requirepass  123
appendonly yes
appendfsync always

#高级配置

[root@db01 redis]# vim /etc/redis/6379/redis.conf

#正在导出rdb快照的过程中,要不要停止同步aof

no-appendfsync-on-rewrite yes/no

#aof文件大小比起上次重写时的大小,增长率100%时重写,缺点:业务开始的时候，会重复重写多次

auto-aof-rewrite-percentage 100

#aof文件,至少超过64M时,重写

auto-aof-rewrite-min-size 64mb

Redis 还可以同时使用 AOF 持久化和 RDB 持久化。在这种情况下，当 Redis 重启时，它会优先使用 AOF 文件来还原数据集，因为 AOF 文件保存的数据集通常比 RDB 文件所保存的数据集更完整。
你甚至可以关闭持久化功能，让数据只在服务器运行时存在。

持久化策略

日志文件

appendonly yes/no
save 900 1
save 300 10
save 60 10000

分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改，即将数据写入硬盘。

压缩

dbcompression yes
- 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大

同步

appendfsync everysec

 no：表示等操作系统进行数据缓存同步到磁盘（快）

always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）

everysec：表示每秒同步一次（折衷，默认值）

AOF文件损坏修复

redis-check-aof --fix /etc/redis/6379/appendonly.aof

AOF和RDB之间的相互作用

在版本号大于等于 2.4 的 Redis 中， BGSAVE 执行的过程中，不可以执行 BGREWRITEAOF 。反过来说，在 BGREWRITEAOF 执行的过程中，也不可以执行 BGSAVE。这可以防止两个 Redis 后台进程同时对磁盘进行大量的 I/O 操作。

如果 BGSAVE 正在执行，并且用户显示地调用 BGREWRITEAOF 命令，那么服务器将向用户回复一个 OK 状态，并告知用户， BGREWRITEAOF 已经被预定执行：一旦 BGSAVE 执行完毕， BGREWRITEAOF 就会正式开始。当 Redis 启动时，如果 RDB 持久化和 AOF 持久化都被打开了，那么程序会优先使用 AOF 文件来恢复数据集，因为 AOF 文件所保存的数据通常是最完整的。

备份redis数据

在阅读这个小节前，请牢记下面这句话: 确保你的数据由完整的备份. 磁盘故障，节点失效，诸如此类的问题都可能让你的数据消失不见，不进行备份是非常危险的。

Redis 对于数据备份是非常友好的，因为你可以在服务器运行的时候对 RDB 文件进行复制： RDB 文件一旦被创建，就不会进行任何修改。当服务器要创建一个新的 RDB 文件时，它先将文件的内容保存在一个临时文件里面，当临时文件写入完毕时，程序才使用 rename(2) 原子地用临时文件替换原来的 RDB 文件。

这也就是说，无论何时，复制 RDB 文件都是绝对安全的。

创建一个定期任务（cron job），每小时将一个 RDB 文件备份到一个文件夹，并且每天将一个 RDB 文件备份到另一个文件夹。
确保快照的备份都带有相应的日期和时间信息，每次执行定期任务脚本时，使用 find 命令来删除过期的快照：比如说，你可以保留最近 48 小时内的每小时快照，还可以保留最近一两个月的每日快照。
至少每天一次，将 RDB 备份到你的数据中心之外，或者至少是备份到你运行 Redis 服务器的物理机器之外

shell下操作redis

[root@lb01 ~]# redis-cli -h 10.0.0.5 -p 6379 **set** no001 zhangsan

OK

[root@lb01 ~]# redis-cli -h 10.0.0.5 -p 6379 **get** no001 

"zhangsan"

[root@lb01 ~]# redis-cli **del** no001

(integer) 1

[root@lb01 ~]# redis-cli **get** no001                    

(nil)

** 修改配置文件**

vim /etc/redis/6379.conf

**bind 172.16.1.51**

protected-mode yes

port 6379

tcp-backlog 511

timeout 0

tcp-keepalive 300

**daemonize yes**

supervised no

pidfile /var/run/redis_6379.pid

loglevel notice

**logfile "/usr/local/redis_6379/log/redis.log"**

databases 16

save 900 1

save 300 10

save 60 10000

stop-writes-on-bgsave-error yes

rdbcompression yes

rdbchecksum yes

dbfilename dump.rdb

**dir /usr/local/redis_6379/data/**

slave-serve-stale-data yes

slave-read-only yes

repl-diskless-sync no

repl-diskless-sync-delay 5

repl-disable-tcp-nodelay no

slave-priority 100

appendonly no

appendfilename "appendonly.aof"

appendfsync everysec

no-appendfsync-on-rewrite no

auto-aof-rewrite-percentage 100

auto-aof-rewrite-min-size 64mb

aof-load-truncated yes

lua-time-limit 5000

slowlog-log-slower-than 10000

slowlog-max-len 128

latency-monitor-threshold 0

notify-keyspace-events ""

hash-max-ziplist-entries 512

hash-max-ziplist-value 64

list-max-ziplist-size -2

list-compress-depth 0

set-max-intset-entries 512

zset-max-ziplist-entries 128

zset-max-ziplist-value 64

hll-sparse-max-bytes 3000

activerehashing yes

client-output-buffer-limit normal 0 0 0

client-output-buffer-limit slave 256mb 64mb 60

client-output-buffer-limit pubsub 32mb 8mb 60

hz 10

aof-rewrite-incremental-fsync yes

** 修改启动文件**

cat /etc/init.d/redis_6379

#!/bin/sh
#
# Simple Redis init.d script conceived to work on Linux systems
# as it does use of the /proc filesystem.
REDISPORT=6379
EXEC=/usr/local/redis_6379/bin/redis-server
CLIEXEC=/usr/local/redis_6379/bin/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 -h 172.16.1.51 shutdown
                while [ -x /proc/${PID} ]
                do
                    echo "Waiting for Redis to shutdown ..."
                    sleep 1
                done
                echo "Redis stopped"
        fi
        ;;
    *)
        echo "Please use start or stop as first argument"
        ;;
esac

** 启动**

/etc/init.d/redis_6379 start

netstat -lntup |grep 6379

** 登录**

[root@db01 log]# **/usr/local/redis_6379/bin/redis-cli -h 172.16.1.51 -p 6379**

172.16.1.51:6379> 

172.16.1.51:6379> set name linux

OK

172.16.1.51:6379> get name

"linux"

172.16.1.51:6379> keys *

1) "name"

172.16.1.51:6379> exists name

(integer) 1

172.16.1.51:6379> type name

string

172.16.1.51:6379> del name

(integer) 1

172.16.1.51:6379> exists name

(integer) 0

** redis 内存**

maxmemory 50m

经验值: 10G-30G之间 SAS盘如果是SSD盘。可以更大。60G

数据类型

常规操作

KEYS * 查看KEY支持通配符

DEL 删除给定的一个或多个key

DEL age

EXISTS 检查是否存在

EXPIRE 设定生存时间

EXPIRE lidao 10

PEXPIRE 取消生存时间

RENAME 变更KEY名

TTL 以秒为单位返回过期时间

DUMP RESTORE 序例化与反序列化

PEXIRE PTTL PERSIST 以毫秒为单位

SORT 键值排序

TYPE 返回键所存储值的类型

127.0.0.1:6379> set guo 12345

OK

127.0.0.1:6379> exists guo

(integer) 1

127.0.0.1:6379> EXPIRE guo 30

(integer) 1

127.0.0.1:6379> GET guo

"12345"

127.0.0.1:6379> ttl guo

(integer) 20

127.0.0.1:6379> ttl guo

(integer) 18

127.0.0.1:6379> ttl guo

(integer) 18

127.0.0.1:6379> ttl guo

(integer) 17

127.0.0.1:6379> ttl guo

(integer) 16

127.0.0.1:6379> ttl guo

(integer) 15

127.0.0.1:6379> ttl guo

(integer) 11

127.0.0.1:6379> ttl guo

(integer) 10

127.0.0.1:6379> get guo

"12345"

127.0.0.1:6379> get guo

"12345"

127.0.0.1:6379> get guo

"12345"

127.0.0.1:6379> get guo

(nil)

字符串

应用场景

常规计数：微博数，粉丝数等

设置

SET name "guohz“

Get name

一个键最大能存储512MB

RENAME 变更KEY名

RENAME name mingzi

GETSET 先取值，再设置值

Mget mset 同时设置一个或多个键值对

Append 将 value 追加到 key 原来的值的末尾

APPEND name bgx

STRLEN 返回字符串长度

STRLEN name

INCR DECR 将值增或减1

INCRBY DECRBY 减去指定量

DECRBY count 20

INCRBYFLOAT fans 0.6 浮点数增加

TTL 以秒为单位返回过期时间

查看值的部分

GETRANGE name 0 4

修改值部分

SETRANGE name 3 m

删除key

DEL fans

127.0.0.1:6379> set guo 12345

OK

127.0.0.1:6379> append guo hello

(integer) 10

127.0.0.1:6379> get guo

"12345hello"

mset bq wangbaoqiang yf chengyufan

OK

mget bq yf

1) "wangbaoqiang"

2) "chengyufan"

hash（哈希）— 字典

Redis hash 是一个键值对集合。

Redis hash 是一个string类型的field和value的映射表

hash特别适合用于存储对象。

每个 hash 可以存储 2^32 -1 键值对

应用场景：

存储部分变更的数据，如用户信息等。

HSET HGET 设置返回单个值

HMSET HMGET 设置返回多个值

Hmset user name guo sex male age 22

HGETALL 返回KEY的所有键值

HEXSITS HLEN

HKEYS HVALS 获取所有字段或值

HDEL 删除key 中的一个或多个指定域

172.16.1.51:6379> hset car price 500

(integer) 1

172.16.1.51:6379> hset car name bmw

(integer) 1

172.16.1.51:6379> hset car date 1982

(integer) 1

172.16.1.51:6379> hget car name

"bmw"

172.16.1.51:6379> hgetall car

1) "price"

2) "500"

3) "name"

4) "bmw"

5) "date"

6) "1982"

10.0.0.51:6379> hmset stu id 1 name zhangsan age 20 gender male

OK

10.0.0.51:6379> hmget stu id name age gender

1) "1"

2) "zhangsan"

3) "20"

4) "male"

10.0.0.51:6379> hgetall stu

1) "id"

2) "1"

3) "name"

4) "zhangsan"

5) "age"

6) "20"

7) "gender"

8) "male"

stu1:

 id   name  age gender    filed

 1    2      3    4   value

hmset stu id 1 name zhang3 age 20 gender male

hmget stu  id name age gender 

hgetall stu

增

hset myhash field1 "s"

若字段field1不存在,创建该键及与其关联的Hashes, Hashes中,key为field1 ,并设value为s ，若存在会覆盖原value

hsetnx myhash field1 s

若字段field1不存在,创建该键及与其关联的Hashes, Hashes中,key为field1 ,并设value为s，若字段field1存在,则无效

hmset myhash field1 "hello" field2 "world    一次性设置多个字段

删

hdel myhash field1        删除 myhash 键中字段名为 field1 的字段

del myhash        删除键

改

hincrby myhash field 1      给field的值加1

查

hget myhash field1        获取键值为 myhash,字段为 field1 的值

hlen myhash         获取myhash键的字段数量

hexists myhash field1         判断 myhash 键中是否存在字段名为 field1 的字段

hmget myhash field1 field2 field3     一次性获取多个字段

hgetall myhash         返回 myhash 键的所有字段及其值

hkeys myhash        获取myhash 键中所有字段的名字

hvals myhash

list（列表）

Redis列表是简单的字符串列表。

按照插入顺序排序每个

LIST可以存储 2^32 -1 键值对

LPUSH 将一个或多个值插入到列表头部

RPUSH 将一个或多个值插入到列表尾部

LPOP/RPOP 移除表头/尾的元素

LLEN 返回列表长度

LRANGE 返回指定的元素

LREM greet 2 morning 删除前两个morning

LREM greet -1 morning 删除后一个morning

LREM greet 0 hello 删除所有hello

Lindex 返回列表 key 中下标为 index 的元素.

LSET key index value

将列表 key 下标为 index 的元素的值设置为 value

LINSERT 插入数据位于某元素之前或之后。

LINSERT key BEFORE|AFTER pivot value

应用场景

消息队列系统

比如sina微博:

在Redis中我们的最新微博ID使用了常驻缓存，这是一直更新的。

但是做了限制不能超过5000个ID，因此获取ID的函数会一直询问Redis。

只有在start/count参数超出了这个范围的时候，才需要去访问数据库。

系统不会像传统方式那样“刷新”缓存，Redis实例中的信息永远是一致的。

SQL数据库（或是硬盘上的其他类型数据库）只是在用户需要获取“很远”的数据时才会被触发，

而主页或第一个评论页是不会麻烦到硬盘上的数据库了。

172.16.1.51:6379> lpush list aaaaaaa

(integer) 1

172.16.1.51:6379> lpush list bbbbbbb

(integer) 2

172.16.1.51:6379> lpush list ccccccc

(integer) 3

172.16.1.51:6379> lpush list ddddddd

(integer) 4

172.16.1.51:6379> llen list

(integer) 4

172.16.1.51:6379> lpop list

"ddddddd"

172.16.1.51:6379> rpop list

"aaaaaaa"

172.16.1.51:6379> lindex list 0

"ccccccc"

172.16.1.51:6379> lindex list -1

"bbbbbbb"

172.16.1.51:6379> lrange list 0 1

1) "ccccccc"

2) "bbbbbbb"

10.0.0.51:6379> LPUSH weibo 'today is bad day'

(integer) 5

10.0.0.51:6379> LPUSH weibo 'today is happy day'

(integer) 6

10.0.0.51:6379> LRANGE weibo 0 -1

1) "today is happy day"

2) "today is bad day"

3) "day"

4) "nice"

5) "is"

6) "today"

增

从左边或者右边，一个一个插入

lpush mykey a b     若key不存在,创建该键及与其关联的List,依次插入a ,b， 若List类型的key存在,则插入value中

lpushx mykey2 e     若key不存在,此命令无效， 若key存在,则插入value中

linsert mykey before a a1   在 a 的前面插入新元素 a1

linsert mykey after e e2    在e 的后面插入新元素 e2

rpush mykey a b    在链表尾部先插入b,在插入a

rpushx mykey e     若key存在,在尾部插入e, 若key不存在,则无效

rpoplpush mykey mykey2    将mykey的尾部元素弹出,再插入到mykey2 的头部(原子性的操作)

删

del mykey      删除已有键 

lrem mykey 2 a      从头部开始找,按先后顺序,值为a的元素,删除数量为2个,若存在第3个,则不删除

ltrim mykey 0 2     从头开始,索引为0,1,2的3个元素,其余全部删除

LPOP list1

RPOP list1

改

lset mykey 1 e      从头开始, 将索引为1的元素值,设置为新值 e,若索引越界,则返回错误信息

rpoplpush mykey mykey    将 mykey 中的尾部元素移到其头部

查

lrange mykey 0 -1    取链表中的全部元素，其中0表示第一个元素,-1表示最后一个元素。

lrange mykey 0 2      从头开始,取索引为0,1,2的元素

lrange mykey 0 0      从头开始,取第一个元素,从第0个开始,到第0个结束

lpop mykey            获取头部元素,并且弹出头部元素,出栈

lindex mykey 6        从头开始,获取索引为6的元素 若下标越界,则返回nil

LLEN   查看列表长度

set（集合)

无序性

唯一性

Redis的Set是string类型的无序集合。

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

Redis 中集合是通过哈希表实现的。

应用场景：

案例：

在微博应用中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。

Redis还为集合提供了求交集、并集、差集等操作，可以非常方便的实现如共同关注、共同喜好、二度好友等功能.

对上面的所有集合操作，你还可以使用不同的命令选择将结果返回给客户端还是存集到一个新的集合中。

SADD key member [member …]

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。

SCARD key 返回集合KEY的基数

SDIFF key1 key2

返回一个集合的全部成员，该集合是所有给定集合之间的差集，注意前后顺序。比较后Sdiffstore进行存储

SMEMBERS key 查看成员的值

SUNION 返回一个集合的全部成员，该集合是所有给定集合的并集。SUNIONSTORE

SINTER key [key …]

返回一个集合的全部成员，该集合是所有给定集合的交集。SINTERSTORE

SISMEMBER 判断是否属于该集合

SMOVE source destination member

将 member 元素从 source 集合移动到 destination 集合。

SPOP SRANDMEMBER 移出或读取一个随机元素。

SREM 移除集合中一个或多个元素

SRANDMEMBER 随机读取集合中的一个元素

SRANDMEMBER set1 2

172.16.1.51:6379> sadd hehe a b c

(integer) 3

172.16.1.51:6379> smembers hehe

1) "a"

2) "c"

3) "b"

172.16.1.51:6379> sadd haha a d e

(integer) 3

172.16.1.51:6379> smembers haha

1) "a"

2) "e"

3) "d"

172.16.1.51:6379> sdiff hehe haha

1) "b"

2) "c"

172.16.1.51:6379> sunion hehe haha

1) "a"

2) "e"

3) "b"

4) "c"

5) "d"

增

sadd myset a b c

若key不存在,创建该键及与其关联的set,依次插入a ,b,若key存在,则插入value中,若a 在myset中已经存在,则插入了 d 和 e 两个新成员。

删

spop myset     尾部的b被移出,事实上b并不是之前插入的第一个或最后一个成员

srem myset a d f    若f不存在, 移出 a、d ,并返回2

SPOP set1 1

改

smove myset myset2 a     将a从 myset 移到 myset2，

查

sismember myset a      判断 a 是否已经存在，返回值为 1 表示存在。

smembers myset      查看set中的内容

scard myset       获取Set 集合中元素的数量

srandmember myset    随机的返回某一成员

sdiff myset1 myset2 myset3   1和2得到一个结果,拿这个集合和3比较,获得每个独有的值

sdiffstore diffkey myset myset2 myset3   3个集和比较,获取独有的元素,并存入diffkey 关联的Set中

sinter myset myset2 myset3      获得3个集合中都有的元素

sinterstore interkey myset myset2 myset3  把交集存入interkey 关联的Set中

sunion myset myset2 myset3      获取3个集合中的成员的并集

sunionstore unionkey myset myset2 myset3  把并集存入unionkey 关联的Set中

SortedSet（有序集合）

Sorted sets,类似Sets,但是每个字符串元素都关联到一个叫score浮动数值（floating number value）。里面的元素总是通过score进行着排序

有序集合的成员是唯一的,但分数(score)却可以重复

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。

每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

应用场景：

排行榜应用，取TOP N操作

这个需求与上面需求的不同之处在于，前面操作以时间为权重，这个是以某个条件为权重，比如按顶的次数排序，

这时候就需要我们的sorted set出马了，将你要排序的值设置成sorted set的score，将具体的数据设置成相应的value，

每次只需要执行一条ZADD命令即可。

ZADD key score member

ZCARD 返回有序集 key 的基数 

ZCOUNT key min max

ZCOUNT salary 2000 5000 计算2000到5000之间的数 

ZSCORE key member 返回值 

ZINCRBY key increment member

为score 值加上增量 increment，负数为减法

ZINCRBY salary 2000 tom

ZRANGE key start stop 返回指定区间成员 

ZRANGE salary 0 -1 WITHSCORES 显示所有

ZRANGEBYSCORE

有序集成员按 score 值递增(从小到大)次序排列。

ZRANGEBYSCORE salary -inf +inf WITHSCORES

ZRANK key member 显示排名 

ZRANGE salary 0 -1 WITHSCORES

ZRANGE salary tom

ZREM key member 移除一个或多个成员。 

ZREMRANGEBYRANK ZREMRANGEBYSCORE 移除 

ZREVRANGE key start stop [WITHSCORES]

递减返回值

zadd top10  1000 tm 2000 by

zadd top10 6000000 bjjsxh  

ZINCRBY top10 10000000000 by     

ZREVRANGE top10 0 -1 withscores

增

zadd myzset 2 "two" 3 "three"     添加两个分数分别是 2 和 3 的两个成员

zadd score 100 'zls' 0 'lidao' 10 'xudao'

zadd zset1 100 'a'  200 'b'  300 'c' 400 'd' 500 'e'

删

zrem myzset one two      删除多个成员变量,返回删除的数量

改

zincrby myzset 2 one      将成员 one 的分数增加 2，并返回该成员更新后的分数

查

zrange myzset 0 -1 WITHSCORES    返回所有成员和分数,不加WITHSCORES,只返回成员

zrank

ZRANK zset1 b    # 获取 成员b在有序集合中的位置（索引值）

zcard myzset 获取 myzset 键中成员的数量

zcount myzset 1 2 获取分数满足表达式 1 <= score <= 2 的成员的数量

zscore myzset three 获取成员 three 的分数

ZSCORE score lidao

zrangebyscore myzset 1 2 获取分数满足表达式 1 < score <= 2 的成员

#-inf 表示第一个成员，+inf最后一个成员

#limit限制关键字

#2 3 是索引号

zrangebyscore myzset -inf +inf limit 2 3 返回索引是2和3的成员

zremrangebyscore myzset 1 2 删除分数 1<= score <= 2 的成员，并返回实际删除的数量

zremrangebyrank myzset 0 1 删除位置索引满足表达式 0 <= rank <= 1 的成员

zrevrange myzset 0 -1 WITHSCORES 按位置索引从高到低,获取所有成员和分数

#原始成员:位置索引从小到大

  one  0  

  two  1

#执行顺序:把索引反转

  位置索引:从大到小

  one 1

  two 0

#输出结果: two

one

zrevrange myzset 1 3 获取位置索引,为1,2,3的成员

#相反的顺序:从高到低的顺序

zrevrangebyscore myzset 3 0 获取分数 3>=score>=0的成员并以相反的顺序输出

zrevrangebyscore myzset 4 0 limit 1 2 获取索引是1和2的成员,并反转位置索引

高级应用

** 生产消费模型**

** 消息模式**

发布消息通常有两种模式：队列模式（queuing）和发布-订阅模式(publish-subscribe)。

队列模式中，consumers可以同时从服务端读取消息，每个消息只被其中一个consumer读到。

发布-订阅模式中消息被广播到所有的consumer中，topic中的消息将被分发到组中的一个成员中。同一组中的consumer可以在不同的程序中，也可以在不同的机器上。

** Redis 发布订阅**

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。

Redis 客户端可以订阅任意数量的频道。

订阅发布实例

SUBSCRIBE mq1

发布

PUBLISH mq1 "Redis is a great caching technique"

订阅任意多个

PSUBSCRIBE

psubscribe news.* tech.*

PUBLISH channel message

将信息 message 发送到指定的频道 channel 。返回值代表消费者数量

pubsub channels 显示订阅频道

PUBSUB NUMSUB news.it 打印各频道订阅者数量

PUNSUBSCRIBE 退订多个频道

SUBSCRIBE 订阅给定的一个或多个频道的信息。

UNSUBSCRIBE 退订频道

PUBLISH channel msg

将信息 message 发送到指定的频道 channel?

SUBSCRIBE channel [channel …]

订阅频道，可以同时订阅多个频道

UNSUBSCRIBE [channel …]

取PSUBSCRIBE消订阅指定的频道, 如果不指定频道，则会取消订阅所有频道

pattern [pattern …]

订阅一个或多个符合给定模式的频道，每个模式以 * 作为匹配符，比如 it* 匹配所有以 it 开头的频道( it.news 、 it.blog 、 it.tweets 等等)， news.* 匹配所有以 news. 开头的频道( news.it 、 news.global.today 等等)，诸如此类

PUNSUBSCRIBE [pattern [pattern …]]

退订指定的规则, 如果没有参数则会退订所有规则

PUBSUB subcommand [argument [argument …]]

查看订阅与发布系统状态

注意：使用发布订阅模式实现的消息队列，当有客户端订阅channel后只能收到后续发布到该频道的消息，之前发送的不会缓存，必须Provider和Consumer同时在线。

SUBSCRIBE fm1039

Reading messages... (press Ctrl-C to quit)

1) "subscribe"

2) "fm1039"

3) (integer) 1

1) "message"

2) "fm1039"

3) "hello"

发布

PUBLISH fm1039 hello

redis事务

Redis 事务可以一次执行多个命令

事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

原子性：事务中的命令要么全部被执行，要么全部都不执行。

执行过程

开始事务

命令入队

执行事务

事务命令

MULTI

标记一个事务块的开始。

DISCARD

放弃执行事务块内的所有命令

EXEC

执行所有事务块内的命令

UNWATCH

取消 WATCH 命令对所有 key 的监视。

WATCH key [key …]

监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

窗口1

127.0.0.1:6379> set ticket 1
OK
127.0.0.1:6379> WATCH ticket
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set ticket 0
QUEUED
127.0.0.1:6379> exec
(nil)

窗口2

127.0.0.1:6379> WATCH ticket
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set ticket 0
QUEUED
127.0.0.1:6379> exec
1) OK

** 事务执行**

zadd salary 2000 guohongze 
zadd salary 3000 oldboy 
ZRANGE salary 0 -1 WITHSCORES
MULTI
ZINCRBY salary 1000 guohongze 
zincrby salary -1000 oldboy 
EXEC

服务器命令

Info


Clinet list

Client kill ip:port 


CONFIG RESETSTAT 重置统计 

CONFIG GET/SET 动态修改 

config get *

切换库 0-15

select 1

Dbsize 键的数量

FLUSHDB 清空当前库

FLUSHALL 清空所有数据

监控实时指令

MONITOR

SHUTDOWN 关闭服务器

save 将当前数据保存

SLAVEOF host port 主从配置

SLAVEOF NO ONE

SYNC 主从同步

ROLE返回主从角色

慢日志查询

Slow log 是 Redis 用来记录查询执行时间的日志系统。

slow log 保存在内存里面，读写速度非常快

可以通过改写 redis.conf 文件或者用 CONFIG GET 和 CONFIG SET 命令对它们动态地进行修改

slowlog-log-slower-than 10000 超过多少微秒

CONFIG SET slowlog-log-slower-than 100

CONFIG SET slowlog-max-len 1000 保存多少条慢日志

CONFIG GET slow*

SLOWLOG GET

SLOWLOG RESET

127.0.0.1:6379> CONFIG GET slowlog-log-slower-than

1) "slowlog-log-slower-than"

2) "10000"

数据备份

CONFIG GET dir 获取当前目录

Save 备份（无持久化策略时），生成时在redis当前目录中。

恢复时只需将dump.rdb放入redis当前目录

redis 主从复制

http://redisdoc.com/topic/replication.html

从 Redis 2.8 开始，使用异步复制。

一个主服务器可以有多个从服务器。

从服务器也可以有自己的从服务器。

复制功能不会阻塞主服务器。

可以通过复制功能来让主服务器免于执行持久化操作，由从服务器去执行持久化操作即可。

创建工作目录

mkdir /data/638{0..2}

配置文件

cat >> /data/6380/redis.conf <<EOF
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
requirepass 123
masterauth 123
EOF

cat >>   /data/6381/redis.conf <<EOF
port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
requirepass 123
masterauth 123
EOF

cat >>   /data/6382/redis.conf <<EOF
port 6382
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
requirepass 123
masterauth 123
EOF

启动

redis-server /data/6380/redis.conf
redis-server /data/6381/redis.conf
redis-server /data/6382/redis.conf

配置主从

从库执行

redis-cli -p 6381 -a 123 SLAVEOF 127.0.0.1 6380
redis-cli -p 6382 -a 123 SLAVEOF 127.0.0.1 6380

查询主从状态

redis-cli -p 6380 -a 123 info replication
redis-cli -p 6381 -a 123 info replication
redis-cli -p 6382 -a 123 info replication

主从切换

主库down之后，在一个从库执行

SLAVEOF no one

其它从库重新做主从

SLAVEOF 127.0.0.1 6381

slave-read-only 只读模式

masterauth 主服务器设置密码后需要填写密码

#执行写操作所需的至少从服务器数量

min-slaves-to-write <number of slaves>

#指定网络延迟的最大值

min-slaves-max-lag <number of seconds>

从服务器延迟不大于

CONFIG set slave-read-only yes

Config set masterauth root

INFO replication

SLAVEOF NO ONE 升级至MASTER

查看主从复制信息

127.0.0.1:6382> role
1) "master"
2) (integer) 17179
3) 1) 1) "10.0.0.8"
      2) "6381"
      3) "17179"
   2) 1) "10.0.0.8"
      2) "6380"
      3) "17179"

127.0.0.1:6381> info replication
# Replication
role:slave
master_host:10.0.0.8
master_port:6380
master_link_status:up
master_last_io_seconds_ago:9
master_sync_in_progress:0
slave_repl_offset:4514
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:314
repl_backlog_histlen:3234

生产环境,在从的上面开启持久化，主的关闭持久化

关闭主的持久化

http://doc.redisfans.com/server/info.html

https://github.com/ErikDubbelboer/phpRedisAdmin

https://www.unixhot.com/article/23

主从复制配置过程

主

/data/6380/redis.conf

port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no

从

/data/6381/redis.conf

port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
protected-mode no

从

/data/6382/redis.conf

port 6382
daemonize yes
pidfile /data/6382/redis.pid
loglevel notice
logfile "/data/6382/redis.log"
dbfilename dump.rdb
dir /data/6382
protected-mode no

设置主从

[root@db01 ~]# redis-cli -p 6381
127.0.0.1:6381> SLAVEOF 127.0.0.1 6380
OK
127.0.0.1:6381> quit
[root@db01 ~]# redis-cli -p 6382
127.0.0.1:6382> SLAVEOF 127.0.0.1 6380
OK
127.0.0.1:6382> info replication    #查看主从状态

切换为主库

SLAVEOF no one

redis sentinel

http://redisdoc.com/topic/sentinel.html

http://doc.redisfans.com/topic/sentinel.html

命令连接

订阅连接

Redis-Sentinel是Redis官方推荐的高可用性(HA)解决方案，当用Redis做Master-slave的高可用方案时，假如master宕机了，Redis本身(包括它的很多客户端)都没有实现自动进行主备切换，而Redis-sentinel本身也是一个独立运行的进程，它能监控多个master-slave集群，发现master宕机后能进行自动切换。

功能

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

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

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

配置sentinel

mkdir /data/26380
cd /data/26380


vim sentinel.conf
port 26380
dir "/data/26380"
sentinel monitor mymaster 127.0.0.1 6380 1
sentinel down-after-milliseconds mymaster 5000
sentinel auth-pass mymaster 123

启动：

redis-sentinel /data/26380/sentinel.conf &> /tmp/sentinel.log &

配置

cp redis-3.2.6/sentinel.conf 7000/

cp redis-3.2.6/sentinel.conf 7001/

cp redis-3.2.6/sentinel.conf 7002/

cp redis-3.2.6/src/redis-sentinel 7000/

cp redis-3.2.6/src/redis-sentinel 7001/

cp redis-3.2.6/src/redis-sentinel 7002/

** 修改配置文件**

/data/7000/sentinel.conf

port 26380
dir "/tmp"
sentinel monitor mymaster 127.0.0.1 6380 1
sentinel down-after-milliseconds mymaster 10000
sentinel config-epoch mymaster 0

启动监控

/data/7000/redis-sentinel /data/7000/sentinel.conf

哨兵，实现redis主从高可用

构建1主2从redis主从复制

主节点：6380

从节点：6381、6382

mkdir /data/26380

vim /data/26380/sentinel.conf

port 26380
dir "/data/26380/"
sentinel monitor mymaster 127.0.0.1 6380 1
sentinel down-after-milliseconds mymaster 10000

启动

redis-sentinel /data/26380/sentinel.conf &

sentinel.conf配置文件说明

指定监控master

sentinel monitor mymaster 127.0.0.1 6379 2 #sentinel数量

安全信息

sentinel auth-pass mymaster luyx30

超过15000毫秒后认为主机宕机

sentinel down-after-milliseconds mymaster 15000

和当主从切换多久后认为主从切换失败

sentinel failover-timeout mymaster 900000

这两个配置后面的数量主从机需要一样

sentinel leader-epoch mymaster 1

sentinel config-epoch mymaster 1

Sentinel命令

PING ：返回 PONG 。

SENTINEL masters ：列出所有被监视的主服务器

SENTINEL slaves

SENTINEL get-master-addr-by-name ：返回给定名字的主服务器的 IP 地址和端口号。

SENTINEL reset ：重置所有名字和给定模式 pattern 相匹配的主服务器。

SENTINEL failover ：当主服务器失效时，在不询问其他 Sentinel 意见的情况下，强制开始一次自动故障迁移。

redis集群

https://github.com/CodisLabs/codis

https://github.com/CodisLabs/codis/blob/master/doc/unsupported_cmds.md

https://github.com/twitter/twemproxy

https://github.com/CodisLabs/codis/blob/master/doc/tutorial_zh.md

Redis 集群是一个可以在多个 Redis 节点之间进行数据共享的设施（installation）。
Redis 集群不支持那些需要同时处理多个键的 Redis 命令，因为执行这些命令需要在多个 Redis 节点之间移动数据，并且在高负载的情况下，这些命令将降低 Redis 集群的性能，并导致不可预测的行为。
Redis 集群通过分区（partition）来提供一定程度的可用性（availability）：即使集群中有一部分节点失效或者无法进行通讯，集群也可以继续处理命令请求。
将数据自动切分（split）到多个节点的能力。
当集群中的一部分节点失效或者无法进行通讯时，仍然可以继续处理命令请求的能力。

1、客户端分片优势：1、分片很清晰 2、运维不关心

2、redis cluster 1、分片的调度

缺点：客户端不支持，生产案例少

3、proxy codis（使用多） twemproxy

redis-port数据迁移

** redis集群数据共享**

Redis 集群使用数据分片（sharding）而非一致性哈希（consistency hashing）来实现：一个 Redis 集群包含 16384 个哈希槽（hash slot），数据库中的每个键都属于这 16384 个哈希槽的其中一个，集群使用公式 CRC16(key) % 16384 来计算键 key 属于哪个槽，其中 CRC16(key) 语句用于计算键 key 的 CRC16 校验和。

节点 A 负责处理 0 号至 5500 号哈希槽。
节点 B 负责处理 5501 号至 11000 号哈希槽。
节点 C 负责处理 11001 号至 16384 号哈希槽。

** 集群的复制**

为了使得集群在一部分节点下线或者无法与集群的大多数（majority）节点进行通讯的情况下，仍然可以正常运作， Redis 集群对节点使用了主从复制功能：集群中的每个节点都有 1 个至 N 个复制品（replica），其中一个复制品为主节点（master），而其余的 N-1 个复制品为从节点（slave）。
在之前列举的节点 A 、B 、C 的例子中，如果节点 B 下线了，那么集群将无法正常运行，因为集群找不到节点来处理 5501 号至 11000 号的哈希槽。
假如在创建集群的时候（或者至少在节点 B 下线之前），我们为主节点 B 添加了从节点 B1 ，那么当主节点 B 下线的时候，集群就会将 B1 设置为新的主节点，并让它代替下线的主节点 B ，继续处理 5501 号至 11000 号的哈希槽，这样集群就不会因为主节点 B 的下线而无法正常运作了。
```
不过如果节点 B 和 B1 都下线的话， Redis 集群还是会停止运作
```

** 运行机制**

所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.
节点的fail是通过集群中超过半数的master节点检测失效时才生效.
客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可
把所有的物理节点映射到[0-16383]slot上,cluster 负责维护node<->slot<->key

** 安装环境**

yum install ruby rubygems –y
gem sources -a http://mirrors.aliyun.com/rubygems/
gem sources --remove http://rubygems.org/
gem sources -l
gem install redis -v 3.3.3

mkdir /data/700{0..5} -p

/data/7000/redis.conf

port 7000
daemonize yes
pidfile /data/7000/redis.pid
loglevel notice
logfile "/data/7000/redis.log"
dbfilename dump.rdb
dir /data/7000
protected-mode no
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

启动节点：

redis-server /data/7000/redis.conf 
redis-server /data/7001/redis.conf 
redis-server /data/7002/redis.conf 
redis-server /data/7003/redis.conf 
redis-server /data/7004/redis.conf 
redis-server /data/7005/redis.conf

** 启动集群**

./redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005

redis-5.0.0版本开始才支持"–cluster"

redis-cli --cluster create 10.0.0.51:6380 10.0.0.52:6380 10.0.0.53:6380 10.0.0.51:6381 10.0.0.52:6381 10.0.0.53:6381 --cluster-replicas 1
redis-cli --cluster info 10.0.0.51:6380

集群管理

redis-cli -p 7000 cluster nodes | grep master

集群管理：

集群状态

redis-cli -p 7000 cluster nodes | grep master

故障转移

redis-cli -p 7002 debug segfault

查看状态

redis-cli -p 7000 cluster nodes | grep master

增加新的节点

./redis-trib.rb add-node 127.0.0.1:7006 127.0.0.1:7000

说明：127.0.0.1:7000 是任何一个主节点

删除一个节点

redis-trib  del-node  ip:port  '<node-id>'

删除master节点之前首先要使用reshard移除master的全部slot,然后再删除当前节点

添加一个从节点

redis-trib.rb  add-node  --slave  --master-id MASTERID 127.0.0.1:7005 127.0.0.1:7000

[root@web01 redis]# redis-cli -c -p 7000

127.0.0.1:7000> set foo bar

-> Redirected to slot [12182] located at 127.0.0.1:7002

OK

127.0.0.1:7002> set guo hongze

OK

127.0.0.1:7002> sadd abc 123 456 aaa ddd

-> Redirected to slot [7638] located at 127.0.0.1:7001

(integer) 4

** 重新分片 **

将7002节点上的所有slot（10923-16383，共5461个）

重新分片命令

redis-trib.rb reshard 127.0.0.1:7000

M: b604b84a559e4b02b96af5c15861cd19f2700c87 127.0.0.1:7002

   slots:10923-16383 (5461 slots) master

   1 additional replica(s)

How many slots do you want to move (from 1 to 16384)? 5461


--------------------------------------------------------

-

What is the receiving node ID? [7000的ID]

---------------------------------------------------------

Please enter all the source node IDs.

  Type 'all' to use all the nodes as source nodes for the hash slots.

  Type 'done' once you entered all the source nodes IDs.

Source node #1:[7002的ID]

Source node #2:done

----------------------------------------------

redis API

https://redis.io/clients

php使用redis

wget https://github.com/phpredis/phpredis/archive/2.2.7.tar.gz
tar xf 2.2.7.tar.gz
cd phpredis-2.2.7
bin/phpize
./configure --with-php-config=...bin/php-config
make && make install
echo 'extension="redis.so"' >> etc/php.ini
systemctl restart php-fpm

php连接redis代码

<?php
  $redis = new Redis();
  $redis->connect('127.0.0.1',6379);
  echo "Connection to server successfully";
  echo "Server is running:".$redis->ping();
?>

python使用redis

https://redis.io/clients

yum install ipython
yum install python-pip
pip install redis -i https://mirrors.tuna.tsinghua.edu.cn/
pip install pip
pip upgrade pip
pip --upgrade pip
pip update pip
pip install --upgrade pip
pip install redis

ipython

下载redis-py-master.zip

unzip redis-py-master.zip
cd redis-py-master
python setup.py install

python
>>> import redis
>>> r = redis.StrictRedis(host='10.0.0.51', port=6379, db=0,password='123456')
>>> r.set('foo', 'bar')
True
>>> r.get('foo')
'bar'

** python连接sentinel**

sentinel集群连接并操作

>>> from redis.sentinel import Sentinel  
>>> sentinel = Sentinel([('localhost', 26380)], socket_timeout=0.1)  
>>> sentinel.discover_master('mymaster')  
>>> sentinel.discover_slaves('mymaster')  
>>> master = sentinel.master_for('mymaster', socket_timeout=0.1)  
>>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)  
>>> master.set('oldboy', '123')  
>>> slave.get('oldboy')  
'bar'

** python连接redis cluster**

redis cluster的连接并操作（python2.7以上版本才支持redis cluster）

https://github.com/Grokzen/redis-py-cluster

2、安装redis-cluser的客户端程序

cd redis-py-cluster-unstable

python setup.py install

3、python连接rediscluster集群测试

使用

>>> from rediscluster import StrictRedisCluster  
>>> startup_nodes = [{"host": "127.0.0.1", "port": "7000"}]  
>>> # Note: decode_responses must be set to True when used with python3  
>>> rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)  
>>> rc.set("foo", "bar")  
True  
>>> print(rc.get("foo"))  
'bar'

wuxingge

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
redis

redishttp://www.redis.io/documentationhttp://www.redis.cn/http://doc.redisfans.com/http://redisdoc.com/http://download.redis.io/releases/吞吐量和响应时间评价网站性能并发指的是连接数距离硬盘越近，速度越慢距离用户越远，速度
复制链接

扫一扫