redis

redis在linux的安裝

1.redis安裝方式
    yum安裝（提前配置好yum源）
    yum install  redis -y  #
    源代碼編譯安裝
    rpm包手動安裝
    
    
2.編譯安裝redis 
    創建一個文件夾,存redis(也可以不用創建)
        mkdir linux_redis
        cd linux_redis
    1.在redis目錄下,下載redis源代碼包
        wget http://download.redis.io/releases/redis-4.0.10.tar.gz
    2.解壓縮redis源碼包
    
    3.編譯三部曲 
        指定安裝路徑 ，生成makefile 編譯文件 
            ./configure --prefix=redis的安裝路徑
        開始編譯
            make
        編譯安裝
            make install  
        編譯完成後，預設生成可使用的redis命令
            /usr/local/bin/redis-server     
    4.修改redis的配置文件，支持更安全的啟動方式
        vim redis.conf 
        
    #打開redis密碼的參數
        requirepass 123456789
    #開啟安全模式
        protected-mode yes
    #修改redis的預設啟動埠，以及綁定地址
        bind 0.0.0.0
        port 6800

        
    #過濾出非空行，註釋行的內容，重定向寫入到一個文件中
     grep  -v "^$"  redis.conf |grep  -v "^#"  > linuxredis.conf
    #在配置文件結尾加上後臺啟動參數
    daemonize  yes

    5.啟動redis服務端
     redis-server linuxredis.conf 

    6.驗證redis是否啟動
        netstat -tunlp |grep  redis
        ps -ef|grep redis 
        
    7.指定密碼登錄redis
        [root@localhost redis-5.0.7]# redis-cli -p 6800
        127.0.0.1:6800> ping
        (error) NOAUTH Authentication required
        127.0.0.1:6800> auth 123456789
        OK
        127.0.0.1:6800> ping
        PONG  

redis常用命令

redis的數據類型

字元串（strings）
哈希（hashes）
列表（lists）
集合（sets）
有序集合（sorted sets）

命令練習

基礎命令

keys *         查看所有key
type key      查看key類型
expire key seconds    過期時間
ttl key     查看key過期剩餘時間        -2表示key已經不存在了
persist     取消key的過期時間   -1表示key存在，沒有過期時間

exists key     判斷key存在    存在返回1    否則0
del keys     刪除key    可以刪除多個
dbsize         計算key的數量

strings類型數據相關命令

set 　　設置key
get     獲取key
append  追加string
mset    設置多個鍵值對
mget    獲取多個鍵值對
del     刪除key
incr    遞增+1
decr    遞減-1



127.0.0.1:6800> set name 'bajie' #設置key

127.0.0.1:6800> get name   #獲取key的值
"bajie"

127.0.0.1:6800> set name 'pig'   #覆蓋key
OK
127.0.0.1:6800> get name
"pig"

127.0.0.1:6800> APPEND name 'dsb'  #追加key的string ,不區分大小寫
(integer) 6
127.0.0.1:6800> get name
"pigdsb"

127.0.0.1:6800> mset name1 'monkey' name2 'tangseng' #設置多個鍵值對
OK
127.0.0.1:6800> keys *
1) "name2"
2) "name1"
3) "name"

127.0.0.1:6800> mget name name1 name2  #獲取多個value
1) "pigdsb"
2) "monkey"
3) "tangseng"

127.0.0.1:6800> del name2   #刪除key
(integer) 1  #刪除一個不存在的key,結果為nil
127.0.0.1:6800> keys *
1) "name1"
2) "name"

127.0.0.1:6800> set num 10
OK
127.0.0.1:6800> get num
"10"
#string類型實際上不僅僅包括字元串類型，還包括整型，浮點型。redis可對整個字元串或字元串一部分進行操作，而對於整型/浮點型可進行自增、自減操作。
127.0.0.1:6379> incr num　　　　#給num string 加一 INCR 命令將字元串值解析成整型，將其加一，最後將結果保存為新的字元串值，可以用作計數器
(integer) 11
127.0.0.1:6800> get num　　
"11"
127.0.0.1:6800> decr num　　　　　　#遞減1  
(integer) 10
127.0.0.1:6800> decr num　　　　#遞減1
(integer) 9
127.0.0.1:6800> get num
"9"

hashes哈徐數據相關命令

哈希結構就是  k1   ->  k1 : v1     如同字典 套字典  { k1 : { k2: v2 }  }   ，取出v2 必須  k1，取出k2

hashes即哈希。哈希是從redis-2.0.0版本之後才有的數據結構。

hashes存的是字元串和字元串值之間的映射，比如一個用戶要存儲其全名、姓氏、年齡等等，就很適合使用哈希。

    hset 設置散列值
    hget  獲取散列值
    hmset  設置多對散列值
    hmget  獲取多對散列值
    hsetnx   如果散列已經存在，則不設置（防止覆蓋key）
    hkeys     返回所有keys
    hvals     返回所有values
    hlen      返回散列包含域（field）的數量
    hdel     刪除散列指定的域（field）
    hexists    判斷是否存在

127.0.0.1:6800> hset news title 'first news title'
(integer) 1
#設置第一條新聞 news的id為1，添加數據title的值是"first news title"

127.0.0.1:6800> hset news content 'first news content'
(integer) 1 
#添加一個conntent內容

127.0.0.1:6800> hget news title  #獲取new的標題
"first news title"

127.0.0.1:6800> hget news content  #獲取new的內容
"first news content"

127.0.0.1:6800> hmget news title content  #獲取news的標題和內容
1) "first news title"
2) "first news content"

127.0.0.1:6800> hmset news1 title 'second news title' content 'second content'
OK
127.0.0.1:6800> hmget news1 title content
1) "second news title"
2) "second content"
#分別同時設置標題和內容並獲取標題和內容

127.0.0.1:6800> hkeys news  #獲取news的key
1) "title"
2) "content"

127.0.0.1:6800> hvals news  #獲取news的值
1) "first news title"
2) "first news content"

127.0.0.1:6800> hlen news  #獲取news的長度
(integer) 2

127.0.0.1:6800> hdel news title  #刪除news的標題title
(integer) 1
127.0.0.1:6800> hlen news  #檢查一下長度
(integer) 1

127.0.0.1:6800> HEXISTS news title   #判斷news中是否有title，不存在返回0，存在返回1
(integer) 0

lists列表相關命令

lpush           從列表左邊插
rpush           從列表右邊插
lrange          獲取一定長度的元素  lrange key  start stop
ltrim           截取一定長度列表
lpop            刪除最左邊一個元素
rpop            刪除最右邊一個元素
lpushx/rpushx   key存在則添加值，不存在不處理

127.0.0.1:6800> lpush users 'bajie' 'monkey' 'tagnseng'  #新建一個users，從左邊放入三個元素
(integer) 3  

127.0.0.1:6800> llen users #查看users長度
(integer) 3

127.0.0.1:6800> lrange users 0 -1  #查看users所有元素
1) "tagnseng"
2) "monkey"
3) "bajie"

127.0.0.1:6800> rpush users 'shasha' #從右邊插入shasha
(integer) 4
127.0.0.1:6800> lrange users 0 -1 #查看users的所有元素
1) "tagnseng"
2) "monkey"
3) "bajie"
4) "shasha"

127.0.0.1:6800> lpop users  #刪除左邊第一個元素
"tagnseng"
127.0.0.1:6800> lrange users 0 -1
1) "monkey"
2) "bajie"
3) "shasha"

127.0.0.1:6800> rpop users   #刪除右邊第一個元素
"bajie"

sets集合相關命令

redis的集合，是一種無序的集合，集合中的元素沒有先後順序。

集合相關的操作也很豐富，如添加新元素、刪除已有元素、取交集、取並集、取差集等。我們來看例子：

    sadd/srem         添加/刪除 元素
    sismember         判斷是否為set的一個元素
    smembers          返回集合所有的成員
    sdiff             返回一個集合和其他集合的差異
    sinter            返回幾個集合的交集
    sunion            返回幾個集合的並集

127.0.0.1:6800> sadd class bajie monkey  #添加集合，有三個元素，不加引號就當做字元串處理
(integer) 2

127.0.0.1:6800> SMEMBERS class  #查看集合class成員
1) "monkey"
2) "bajie"

127.0.0.1:6800> srem class monkey  #刪除class的monkey
(integer) 1
127.0.0.1:6800> SMEMBERS class
1) "bajie"


127.0.0.1:6800> SISMEMBER class bajie  
(integer) 1
127.0.0.1:6800> SISMEMBER class monkey
(integer) 0
127.0.0.1:6800> 
#返回改是否是class的成員信息，不存在返回0，存在返回1

127.0.0.1:6800> sadd class monkey #再把monkey加入class
(integer)  1
 
127.0.0.1:6800> sadd class2 bajie shasha  #添加新集合zoo2
(integer) 2
127.0.0.1:6800> SMEMBERS class2
1) "shasha"
2) "bajie"

127.0.0.1:6800> sdiff class class2 #找出集合class中有的，而class2中沒有的元素
1) "monkey"

127.0.0.1:6800> sdiff class2 class   #找出集合class2中有的，而class中沒有的元素
1) "shasha"

127.0.0.1:6800> sinter class class2 #找出class和class2的交集，都有的元素
1) "bajie"

127.0.0.1:6800> SUNION class class2  #找出class和class2的並集，所有的不重覆的元素
1) "shasha"
2) "bajie"
3) "monkey"

sorted sets有序集合相關命令

都是以z開頭的命令

zset的每一個成員都有一個分數與之對應，並且分數是可以重覆的。有序集合的增刪改由於有啦排序，執行效率就是非常快速的，即便是訪問集合中間的數據也是非常高效的。

用來保存需要排序的數據，例如排行榜，成績，工資等。

利用有序集合的排序，排序學生的成績
127.0.0.1:6800> ZADD class_test 70 'bajie'
(integer) 1
127.0.0.1:6800> ZADD class_test 80 'monkey'
(integer) 1
127.0.0.1:6800> ZADD class_test 75 'shasha'
(integer) 1
127.0.0.1:6800> ZADD class_test  99 'tangseng'
(integer) 1

排行榜，zreverange 倒敘 zrange正序

127.0.0.1:6800> ZREVRANGE class_test 0 -1 withscores
1) "tangseng"
2) "99"
3) "monkey"
4) "80"
5) "shasha"
6) "75"
7) "bajie"
8) "70"

127.0.0.1:6800> ZRANGE class_test 0 -1 withscores
1) "bajie"
2) "70"
3) "shasha"
4) "75"
5) "monkey"
6) "80"
7) "tangseng"
8) "99"

移除有序集合class_test中的成員，bajie給移除掉

127.0.0.1:6800> ZREM class_test bajie
(integer) 1
127.0.0.1:6800> ZRANGE class_test 0 -1 withscores
1) "shasha"
2) "75"
3) "monkey"
4) "80"
5) "tangseng"
6) "99"

返回有序集合class_test的基數

127.0.0.1:6800> ZCARD class_test 
(integer) 3

返回成員的score值

127.0.0.1:6800> ZSCORE class_test monkey
"80"

redis發佈訂閱

Redis 通過 PUBLISH 、 SUBSCRIBE 等命令實現了訂閱與發佈模式。

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同時線上。

redis持久化RDB與AOF

RDB持久化

Redis是一種記憶體型資料庫，一旦伺服器進程退出，資料庫的數據就會丟失，為瞭解決這個問題，Redis提供了兩種持久化的方案，將記憶體中的數據保存到磁碟中，避免數據的丟失。

redis提供了RDB持久化的功能，這個功能可以將redis在記憶體中的的狀態保存到硬碟中，它可以手動執行。

也可以再redis.conf中配置，定期執行。

RDB持久化產生的RDB文件是一個經過壓縮的二進位文件，這個文件被保存在硬碟中，redis可以通過這個文件還原資料庫當時的狀態。

RDB(持久化)
    記憶體數據保存到磁碟
    在指定的時間間隔內生成數據集的時間點快照（point-in-time snapshot）
    優點：速度快，適合做備份，主從複製就是基於RDB持久化功能實現
    rdb通過再redis中使用save命令觸發 rdb


rdb配置參數：
    dir /data/6379/
    dbfilename  dbmp.rdb

    每過900秒 有1個操作就進行持久化

    save 900秒  1個修改類的操作
    save 300秒  10個操作
    save 60秒   10000個操作

    save  900  1
    save  300  10
    save  60   10000

#redis持久化之rdb機制，創建rdb的配置文件
    touch rdbredis.conf 

#寫入如下內容
    daemonize yes #後臺運行 
    port 6379   #指定埠 
    logfile /data/6379/redis.log    #指定日誌路徑
    dir /data/6379  #redis的數據文件，會存放在這裡
    dbfilename  dbmp.rdb        #開啟rdb持久化，且指定持久化文件的名字
    bind 0.0.0.0
    save 900 1    #定義觸發rdb持久化的時間機制 
    save 300 10
    save 60  10000  

#創建數據文件夾
    mkdir  -p /data/6379

# 創建數據
    set name bajie
    set name1 monkey

#手動保存
    save

#指定rdb文件啟動redis
    redis-server  rdbredis.conf  

#在開另一個視窗:
    cd /data/6379
    ls
    會存在.rdb文件

AOF持久化

AOF（append-only log file）
記錄伺服器執行的所有變更操作命令（例如set del等），併在伺服器啟動時，通過重新執行這些命令來還原數據集
AOF 文件中的命令全部以redis協議的格式保存，新命令追加到文件末尾。
優點：最大程式保證數據不丟
缺點：日誌記錄非常大

#redis持久化之rdb機制，創建rdb的配置文件
    touch rdbredis.conf 

#寫入如下內容
    daemonize yes #後臺運行 
    port 6379   #指定埠 
    logfile /data/6379/redis.log    #指定日誌路徑
    dir /data/6379  #redis的數據文件，會存放在這裡
    dbfilename  dbmp.rdb        #   開啟rdb持久化，且指定持久化文件的名字
    bind 0.0.0.0
    save 900 1    #定義觸發rdb持久化的時間機制 
    save 300 10
    save 60  10000  

#創建數據文件夾
    mkdir  -p /data/6379

# 創建數據
    set name bajie
    set name1 monkey

#保存
    save

#指定rdb文件啟動redis
    redis-server  rdbredis.conf  

#在開另一個視窗:
    cd /data/6379
    ls
    會存在.rdb文件

#redis持久化之aof方式，以日誌形式，把修改類的操作，記錄下來
    修改配置文件如下
    touch  aof.conf 
    寫入如下內容

    daemonize yes
    port 6379
    logfile /data/6379/redis.log
    dir /data/6379
    appendonly yes           #開啟aof的倆參數
    appendfsync everysec     #aof的持久化機制 

#指定aof文件啟動redis
redis-server aof.conf 

#在開另一個視窗:
    cd /data/6379
    ls
    會存在成.aof文件

tail -f appendonly.aof  #會夯住,監測狀態

不重啟，切換rdb持久化為aof持久化

1.準備一個rdb的redis資料庫
2.通過命令，直接切換aof
    127.0.0.1:6379> CONFIG set appendonly yes   #開啟AOF功能
    OK
    127.0.0.1:6379> CONFIG SET save ""  #關閉RDB功能
    OK

3.正確情況下，會生成aof日誌文件了，此時命令操作都是在aof裡面了

4.還得修改配置文件，以上命令只是臨時生效，改完以後，下次指定配置文件啟動，就一直是aof了
    port 6379
    logfile /data/6379/redis.log
    dir /data/6379
    dbfilename  dbmp.rdb
    save 900 1
    save 300 10
    save 60  10000
    daemonize yes
    appendonly yes  
    appendfsync everysec     

redis主從複製

redis集群中的資料庫複製是通過主從同步來實現的
主節點(master)把數據分發給從節點(slave)
主從同步的好處自安於高可用,redis節點有冗餘設計

原理：
1. 從伺服器向主伺服器發送 SYNC 命令。
2. 接到 SYNC 命令的主伺服器會調用BGSAVE 命令，創建一個 RDB 文件，並使用緩衝區記錄接下來執行的所有寫命令。
3. 當主伺服器執行完 BGSAVE 命令時，它會向從伺服器發送 RDB 文件，而從伺服器則會接收並載入這個文件。
4. 主伺服器將緩衝區儲存的所有寫命令發送給從伺服器執行。


1、在開啟主從複製的時候，使用的是RDB方式的，同步主從數據的
2、同步開始之後，通過主庫命令傳播的方式，主動的複製方式實現
3、2.8以後實現PSYNC的機制，實現斷線重連

示例

#redis的主從複製，做一個一主三從的實驗(手動切換主從)

mredis.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

準備一個從庫s1redis.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
    slaveof  127.0.0.1 6380  #也可以在配置文件中，直接定義，直接啟動，預設就是主從複製了


準備第二個從庫s2redis.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
    slaveof  127.0.0.1 6380  #也可以在配置文件中，直接定義，直接啟動，預設就是主從複製了

#創建三個資料庫的數據文件夾
    mkdir -p  /data/{6380,6381,6382}

#分別啟動三個資料庫實例
    [root@s24_linux myredis]# redis-server mredis.conf 
    [root@s24_linux myredis]# redis-server s1redis.conf 
    [root@s24_linux myredis]# redis-server s2redis.conf 
    [root@s24_linux myredis]# ps -ef|grep redis
    root      78545      1  0 10:54 ?        00:00:00 redis-server *:6380
    root      78550      1  0 10:54 ?        00:00:00 redis-server *:6381
    root      78555      1  0 10:54 ?        00:00:00 redis-server *:6382

#分別查看三個redis資料庫的庫信息
    [root@s24_linux myredis]# redis-cli -p 6380 info replication 
    [root@s24_linux myredis]# redis-cli -p 6381 info replication 
    [root@s24_linux myredis]# redis-cli -p 6382 info replication 


#通過命令，臨時給三個資料庫添加主從複製信息,如果在配置文件中設置成預設的主從關係,就不用寫下麵的內容
    redis-cli -p 6381  slaveof 127.0.0.1 6380    #6380設置為主庫,給6381指定為6380的從庫
    redis-cli -p 6381 info replication          #查看6381的複製信息
    redis-cli -p 6380 info replication          #查看6380的複製信息
    redis-cli -p 6382  slaveof 127.0.0.1 6380    #給6382設置為6380的從庫
    redis-cli -p 6380 info replication
        結果:
        [root@localhost linux_redis]# redis-cli -p 6380 info replication
        # Replication
        role:master 
        connected_slaves:2
        slave0:ip=127.0.0.1,port=6381,state=online,offset=84,lag=1 #從s1redis
        slave1:ip=127.0.0.1,port=6382,state=online,offset=84,lag=0 #從s2redis

#進行主從複製讀寫演示
    6380可讀可寫
    6381 6382只讀，不給寫

#殺死從庫，無所謂，再把從庫重新啟動，或者再創建一個新的就行 

#殺死主庫，必須得手動解決故障，吧從庫切換為新的主庫，繼續主從複製
    只需要剔除當前自己的從的身份即可，剔除6381的從的身份
    127.0.0.1:6381> slaveof no one
    OK

#再次啟動一個新的從庫，以6381為主庫即可

redis哨兵

Redis-Sentinel是redis官方推薦的高可用性解決方案，
當用redis作master-slave的高可用時，如果master本身宕機，redis本身或者客戶端都沒有實現主從切換的功能。

而redis-sentinel就是一個獨立運行的進程，用於監控多個master-slave集群，
自動發現master宕機，進行自動切換slave > master。

sentinel主要功能如下：

+ 不時的監控redis是否良好運行，如果節點不可達就會對節點進行下線標識
+ 如果被標識的是主節點，sentinel就會和其他的sentinel節點“協商”，如果其他節點也人為主節點不可達，就會選舉一個sentinel節點來完成自動故障轉義
+ 在master-slave進行切換後，master_redis.conf、slave_redis.conf和sentinel.conf的內容都會發生改變，即master_redis.conf中會多一行slaveof的配置，sentinel.conf的監控目標會隨之調換

Sentinel的工作方式：

每個Sentinel以每秒鐘一次的頻率向它所知的Master，Slave以及其他 Sentinel 實例發送一個 PING 命令
 

如果一個實例（instance）距離最後一次有效回覆 PING 命令的時間超過 down-after-milliseconds 選項所指定的值， 則這個實例會被 Sentinel 標記為主觀下線。

如果一個Master被標記為主觀下線，則正在監視這個Master的所有 Sentinel 要以每秒一次的頻率確認Master的確進入了主觀下線狀態。

當有足夠數量的 Sentinel（大於等於配置文件指定的值）在指定的時間範圍內確認Master的確進入了主觀下線狀態， 則Master會被標記為客觀下線

在一般情況下， 每個 Sentinel 會以每 10 秒一次的頻率向它已知的所有Master，Slave發送 INFO 命令

當Master被 Sentinel 標記為客觀下線時，Sentinel 向下線的 Master 的所有 Slave 發送 INFO 命令的頻率會從 10 秒一次改為每秒一次

若沒有足夠數量的 Sentinel 同意 Master 已經下線， Master 的客觀下線狀態就會被移除。

若 Master 重新向 Sentinel 的 PING 命令返回有效回覆， Master 的主觀下線狀態就會被移除。

主觀下線和客觀下線

主觀下線：Subjectively Down，簡稱 SDOWN，指的是當前 Sentinel 實例對某個redis伺服器做出的下線判斷。
客觀下線：Objectively Down， 簡稱 ODOWN，指的是多個 Sentinel 實例在對Master Server做出 SDOWN 判斷，並且通過 SENTINEL is-master-down-by-addr 命令互相交流之後，得出的Master Server下線判斷，然後開啟failover.

SDOWN適合於Master和Slave，只要一個 Sentinel 發現Master進入了ODOWN， 這個 Sentinel 就可能會被其他 Sentinel 推選出， 並對下線的主伺服器執行自動故障遷移操作。

ODOWN只適用於Master，對於Slave的 Redis 實例，Sentinel 在將它們判斷為下線前不需要進行協商， 所以Slave的 Sentinel 永遠不會達到ODOWN。

架構圖

#redis的哨兵配置，能夠自動的解決主從切換故障

1.準備三個redis資料庫實例，配置好，主從關係
    [root@localhost linux_redis]# cat mredis.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


    [root@localhost linux_redis]# cat s1redis.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
    slaveof 127.0.0.1 6380


    [root@localhost linux_redis]# cat s2redis.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
    slaveof  127.0.0.1 6380
    
    #分別啟動三個redis資料庫節點
        redis-sentinel shaobing.conf 
        redis-sentinel shaobing1.conf 
        redis-sentinel shaobing2.conf

2.準備三個哨兵sentinel(哨兵)的配置文件，三個哨兵配置文件，僅僅是埠的不同，預設是26379,26380,26381 
s24shaobing.conf 
    port 26379  
    dir /var/redis/data/
    logfile "26379.log"

    #當前Sentinel節點監控 192.168.119.10:6379 這個主節點
    #2代表判斷主節點失敗至少需要2個Sentinel節點節點同意
    #mymaster是主節點的別名
    sentinel monitor s24ms 127.0.0.1  6380  2

    #每個Sentinel節點都要定期PING命令來判斷Redis數據節點和其餘Sentinel節點是否可達，如果超過30000毫秒30s且沒有回覆，則判定不可達
    sentinel down-after-milliseconds s24ms 30000

    #當Sentinel節點集合對主節點故障判定達成一致時，Sentinel領導者節點會做故障轉移操作，選出新的主節點，
    #原來的從節點會向新的主節點發起複制操作，限制每次向新的主節點發起複制操作的從節點個數為1
    sentinel parallel-syncs s24ms 1

    #故障轉移超時時間為180000毫秒
    sentinel failover-timeout s24ms 180000
    #後臺運行哨兵 
    daemonize yes 

s24shaobing1.conf 
s24shaobing2.conf 
#快速生成2個配置文件
    [root@localhost linux_redis]# sed 's/26379/26380/g'   s24shaobing.conf  > s24shaobing1.conf
    [root@localhost linux_redis]# sed 's/26379/26381/g'   s24shaobing.conf  > s24shaobing2.conf
#創建數據文件夾
    mkdir -p /var/redis/data/



3.分別啟動三個哨兵並檢查進程是否啟動
    [root@localhost linux_redis]# redis-sentinel shaobing.conf 
    [root@localhost linux_redis]# redis-sentinel shaobing1.conf 
    [root@localhost linux_redis]# redis-sentinel shaobing2.conf 

    [root@localhost linux_redis]# ps -ef|grep redis
    root      78952      1  0 11:42 ?        00:00:00 redis-server *:6380
    root      78957      1  0 11:42 ?        00:00:00 redis-server *:6381
    root      78963      1  0 11:42 ?        00:00:00 redis-server *:6382
    root      79051      1  0 11:51 ?        00:00:00 redis-sentinel *:26379 [sentinel]
    root      79056      1  0 11:51 ?        00:00:00 redis-sentinel *:26380 [sentinel]
    root      79061      1  0 11:51 ?        00:00:00 redis-sentinel *:26381 [sentinel]


4.幹掉master主庫，哨兵會自動的選舉一個從庫為新的主庫
    kill -9 78952
5.將掛掉的主庫，重新啟動，查看複製信息
    [root@localhost linux_redis]# redis-cli -p 6382 info replication 
    # Replication
    role:master   #已經變為master
    connected_slaves:1
    slave0:ip=127.0.0.1,port=6381,state=online,offset=54714,lag=1
    master_replid:b7cdc9508bb529976720a385bafd804ffb35a2ab
    master_replid2:8c144e2f317052c195eefa4e56d67a3ab8848c9d
    master_repl_offset:54844
    second_repl_offset:48410
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:71
    repl_backlog_histlen:54774

#在過程中間只是更改了主的配置文件
查看主的配置文件
    port 26379
    dir "/var/redis/data"
    logfile "26379.log"
    sentinel myid 690257e82c765fe396a45bf9caee7e0a93b86db2
    sentinel deny-scripts-reconfig yes
    sentinel monitor s24ms 127.0.0.1 6382 2
    sentinel config-epoch s24ms 1
    daemonize yes
    # Generated by CONFIG REWRITE
    protected-mode no
    sentinel leader-epoch s24ms 1
    sentinel known-replica s24ms 127.0.0.1 6380
    sentinel known-replica s24ms 127.0.0.1 6381
    sentinel known-sentinel s24ms 127.0.0.1 26380 af8573b42730ed3bd6fc07a3af465c40ceddf340
    sentinel known-sentinel s24ms 127.0.0.1 26381 f8e9d772a588472f76778c0352d5e9405cc397f3
    sentinel current-epoch 1

redis-cluster集群的搭建

redis官方生成可以達到 10萬/每秒,每秒執行10萬條命令
假如業務需要每秒100萬的命令執行呢？

應該是考慮分散式，加機器，把數據分到不同的位置，分攤集中式的壓力，一堆機器做一件事

redis實例集群主要思想是將redis數據的key進行散列，通過hash函數特定的key會映射到指定的redis節點上

數據分佈理論

分散式資料庫首要解決把整個數據集按照分區規則映射到多個節點的問題，即把數據集劃分到多個節點上，每個節點負責整個數據的一個子集。

常見的分區規則有哈希分區和順序分區。Redis Cluster採用哈希分區規則，因此接下來會討論哈希分區規則。

    節點取餘分區
    一致性哈希分區
    虛擬槽分區(redis-cluster採用的方式)

安裝配置

大概步驟:

搭建集群分為幾部
    準備節點
    節點通信
    分配槽位給節點

1.準備6個資料庫節點，搭建三主三從的資料庫主從機群，6個節點，僅僅是埠的不同 
指定7000~7005 6個節點
touch redis-7000.conf 
vim redis-7000.conf  
    port 7000
    daemonize yes
    dir "/opt/redis/data"
    logfile "7000.log"
    dbfilename "dump-7000.rdb"
    cluster-enabled yes   #開啟集群模式
    cluster-config-file nodes-7000.conf　　#集群內部的配置文件

touch redis-7001.conf 
touch redis-7002.conf 
touch redis-7003.conf 
touch redis-7004.conf 
touch redis-7005.conf 

#每個節點寫入7000埠的編輯內容,註意埠不一樣
    sed 's/7000/7001/g'  redis-7000.conf > redis-7001.conf 
    sed 's/7000/7002/g'  redis-7000.conf > redis-7002.conf 
    sed 's/7000/7003/g'  redis-7000.conf > redis-7003.conf 
    sed 's/7000/7004/g'  redis-7000.conf > redis-7004.conf 
    sed 's/7000/7005/g'  redis-7000.conf > redis-7005.conf 

創建數據文件夾


分別啟動6個redis節點
    redis-server redis-7000.conf 
    redis-server redis-7001.conf 
    redis-server redis-7002.conf 
    redis-server redis-7003.conf 
    redis-server redis-7004.conf 
    redis-server redis-7005.conf
檢查狀態:
    [root@localhost clusterredis]# ps -ef|grep redis
    root       7138      1  0 01:01 ?        00:00:10 redis-server 0.0.0.0:6800
    root       7286      1  0 02:13 ?        00:00:06 redis-server *:6381
    root       7494      1  0 03:21 ?        00:00:03 redis-server *:6382
    root       7532      1  0 03:35 ?        00:00:04 redis-sentinel *:26379 [sentinel]
    root       7537      1  0 03:35 ?        00:00:04 redis-sentinel *:26380 [sentinel]
    root       7542      1  0 03:35 ?        00:00:04 redis-sentinel *:26381 [sentinel]
    root       7634      1  0 04:04 ?        00:00:00 redis-server *:7000 [cluster]
    root       7639      1  0 04:05 ?        00:00:00 redis-server *:7001 [cluster]
    root       7644      1  0 04:05 ?        00:00:00 redis-server *:7002 [cluster]
    root       7649      1  0 04:05 ?        00:00:00 redis-server *:7003 [cluster]
    root       7686      1  0 04:07 ?        00:00:00 redis-server *:7004 [cluster]
    root       7691      1  0 04:07 ?        00:00:00 redis-server *:7005 [cluster]

2.配置ruby環境，一鍵創建redis機群slot槽位分配
    yum直接安裝ruby解釋器
        yum install ruby -y  
    下載ruby操作redis的模塊
        wget http://rubygems.org/downloads/redis-3.3.0.gem      
        gem install -l redis-3.3.0.gem
    一鍵開啟redis集群槽位分配，先找一下這個ruby工具在哪
    find / -name  redis-trib.rb   
    
    #創建槽位:
    /linux_redis/redis-5.0.7/src/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-cli --cluster create 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 --cluster-replicas 1

    會創建六個槽位:三主三從:
        M: 181c47f790297d5f49058bcaa8886c06df43b172 127.0.0.1:7000 
        slots:[0-5460] (5461 slots) master
        M: c347896134bcc4fbc5061e82157c58a5835be3bd 127.0.0.1:7001
        slots:[5461-10922] (5462 slots) master
        M: 6dacb795eec38a3f0eb310ea43593d79a2884632 127.0.0.1:7002
        slots:[10923-16383] (5461 slots) master
        S: 326a871d0cb797b3f4f5c8660e027bf54605873e 127.0.0.1:7003
        replicates c347896134bcc4fbc5061e82157c58a5835be3bd
        S: 084b2cebed67291e98d54f61619aa3efbb93b3c7 127.0.0.1:7004
        replicates 6dacb795eec38a3f0eb310ea43593d79a2884632
        S: 1808e48c98f420164adc17ca476820778ba8f54f 127.0.0.1:7005
        replicates 181c47f790297d5f49058bcaa8886c06df43b172
        Can I set the above configuration? (type 'yes' to accept): yes


3.開啟redis集群功能，向集群中寫入數據，查看數據重定向
    以集群模式登陸redis-cluster ，寫入數據 
    
        [root@localhost clusterredis]# redis-cli -p 7000 -c   #登錄7000埠
        127.0.0.1:7000> set name cluster          #創建數據 
        -> Redirected to slot [5798] located at 127.0.0.1:7001  #重定向到7001埠
        OK

        退出當前埠,再次登錄
        127.0.0.1:7000> get name
        -> Redirected to slot [5798] located at 127.0.0.1:7001
        "cluster"  #可以查到內容