安裝
[root@localhost ~]# mkdir -p /usr/local/services/download
新建下載目錄
[root@localhost ~]# cd /usr/local/services/download
[root@localhost download]# wget http://redis.googlecode.com/files/redis-2.4.2.tar.gz
下載地址：
--2011-11-15 19:30:48-- http://redis.googlecode.com/files/redis-2.4.2.tar.gz
Resolving redis.googlecode.com... 64.233.183.82
Connecting to redis.googlecode.com|64.233.183.82|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 627947 (613K) [application/octet-stream]
Saving to: `redis-2.4.2.tar.gz'
100%[=============================================================================================================================>] 627,947 930K/s in 0.7s
2011-11-15 19:30:48 (930 KB/s) - `redis-2.4.2.tar.gz' saved [627947/627947]
安裝命令如下
[root@localhost download]# tar zxvf redis-2.4.2.tar.gz
[root@localhost download]# mv redis-2.4.2 ../
[root@localhost services]# cd redis-2.4.2/
[root@localhost redis-2.4.2]# make
直接make就行
make命令執行完成後,會再src目錄下生成本個可執行文件，分別是redis-server、redis-cli、redis-benchmark、redis-stat，它們的作用如下：
- redis-server：Redis服務器的daemon啓動程序
- redis-cli：Redis命令行操作工具。當然，你也可以用telnet根據其純文本協議來操作
- redis-benchmark：Redis性能測試工具，測試Redis在你的系統及你的配置下的讀寫性能
- redis-stat：Redis狀態檢測工具，可以檢測Redis當前狀態參數及延遲狀況
[root@localhost redis-2.4.2]# vim redis.conf
當前目錄redis.conf是redis的配置文件
daemonize no 將no改爲redis後臺運行
daemonize yes
保存退出
[root@localhost redis-2.4.2]# cd src/
啓動腳本redis-server就在src目下
[root@localhost src]# ./redis-server ../redis.conf
腳本後面跟上.conf的路徑
[root@localhost src]# ps aux | grep redis
root 4833 0.0 0.0 39672 1400 ? Ssl 19:39 0:00 ./redis-server ../redis.conf
root 4838 0.0 0.0 61148 776 pts/0 R+ 19:39 0:00 grep redis
./redis-cli是測試客戶端腳本（執行這個腳本就可以和redis交互了）
[root@localhost src]# ./redis-cli
redis 127.0.0.1:6379> set a b
OK
redis 127.0.0.1:6379> get a
"b"
安裝完成
2、 配置redis
vi /usr/local/redis/redis.conf
daemonize yes
pidfile /usr/local/redis/redis.pid
port 6379
timeout 300
loglevel verbose
logfile /usr/local/redis/redis.log
databases 16
save 900 1
save 300 10
save 60 10000
rdbcompression yes
dbfilename dump.rdb
dir /usr/local/redis
slave-serve-stale-data yes
maxmemory 67108864 #64M*1024*8
appendonly no
appendfsync everysec
no-appendfsync-on-rewrite no
vm-enabled no
vm-swap-file /tmp/redis.swap
vm-max-memory 0
vm-page-size 32
vm-pages 134217728
vm-max-threads 8
hash-max-zipmap-entries 512
hash-max-zipmap-value 64
list-max-ziplist-entries 512
list-max-ziplist-value 64
set-max-intset-entries 512
activerehashing yes
1,是否以後臺進程運行，默認爲no
daemonize no
2,如以後臺進程運行，則需指定一個pid，默認爲/var/run/redis.pid
pidfile /var/run/redis.pid
3,監聽端口，默認爲6379
port 6379
4,綁定主機IP，默認值爲127.0.0.1（註釋）
#bind 127.0.0.1
5,超時時間，默認爲300（秒）
timeout 300
6,日誌記錄等級，有4個可選值，debug，verbose（默認值），notice，warning
loglevel verbose
7,日誌記錄方式，默認值爲stdout
logfile stdout
8,可用數據庫數，默認值爲16，默認數據庫爲0
databases 16
9,指出在多長時間內，有多少次更新操作，就將數據同步到數據文件。這個可以多個條件配合，比如默認配置文件中的設置，就設置了三個條件。
900秒（15分鐘）內至少有1個key被改變
save 900 1
300秒（5分鐘）內至少有10個key被改變
save 300 10
10,存儲至本地數據庫時是否壓縮數據，默認爲yes
rdbcompression yes
11,本地數據庫文件名，默認值爲dump.rdb
dbfilename /root/redis_db/dump.rdb
12,本地數據庫存放路徑，默認值爲 ./
dir /root/redis_db/
13,當本機爲從服務時，設置主服務的IP及端口（註釋）(重要)
slaveof <masterip> <masterport>
14,當本機爲從服務時，設置主服務的連接密碼（註釋）
masterauth <master-password>
15,連接密碼（註釋）
requirepass foobared
16,最大客戶端連接數，默認不限制（註釋）0爲不限制
maxclients 0
17,設置最大內存，達到最大內存設置後，Redis會先嚐試清除已到期或即將到期的Key，當此方法處理後，任到達最大內存設置，將無法再進行寫入操作。（註釋）
maxmemory 67108864 (64M)
18,是否在每次更新操作後進行日誌記錄，如果不開啓，可能會在斷電時導致一段時間內的數據丟失。因爲redis本身同步數據文件是按上面save條件來同步的，所以有的數據會在一段時間內只存在於內存中。默認值爲no
appendonly no
19,更新日誌文件名，默認值爲appendonly.aof（註釋）
appendfilename /root/redis_db/appendonly.aof
20,更新日誌條件，共有3個可選值。no表示等操作系統進行數據緩存同步到磁盤，always表示每次更新操作後手動調用fsync()將數據寫到磁盤，everysec表示每秒同步一次（默認值）。
appendfsync everysec
21,是否使用虛擬內存，默認值爲no
vm-enabled no
22,虛擬內存文件路徑，默認值爲/tmp/redis.swap，不可多個Redis實例共享
vm-swap-file /tmp/redis.swap
23,將所有大於vm-max-memory的數據存入虛擬內存,無論vm-max-memory設置多小,所有索引數據都是內存存儲的 (Redis的索引數據就是keys),也就是說,當vm-max-memory設置爲0的時候,其實是所有value都存在於磁盤。默認值爲0。
vm-max-memory 0
24,虛擬內存文件以塊存儲，每塊32bytes
vm-page-size 32
25,虛擬內在文件的最大數
vm-pages 134217728
26,可以設置訪問swap文件的線程數,設置最好不要超過機器的核數,如果設置爲0,那麼所有對swap文件的操作都是串行的.可能會造成比較長時間的延遲,但是對數據完整性有很好的保證.
vm-max-threads 4
27,把小的輸出緩存放在一起，以便能夠在一個TCP packet中爲客戶端發送多個響應，具體原理和真實效果我不是很清楚。所以根據註釋，你不是很確定的時候就設置成yes
glueoutputbuf yes
28,在redis 2.0中引入了hash數據結構。當hash中包含超過指定元素個數並且最大的元素沒有超過臨界時，hash將以一種特殊的編碼方式（大大減少內存使用）來存儲，這裏可以設置這兩個臨界值
hash-max-zipmap-entries 64
29,hash中一個元素的最大值
hash-max-zipmap-value 512
30,開啓之後，redis將在每100毫秒時使用1毫秒的CPU時間來對redis的hash表進行重新hash，可以降低內存的使用。當你的使用場景中，有非常嚴格的實時性需要，不能夠接受Redis時不時的對請求有2毫秒的延遲的話，把這項配置爲no。如果沒有這麼嚴格的實時性要求，可以設置 爲yes，以便能夠儘可能快的釋放內存
activerehashing yes
Redis支持很多的參數，但都有默認值。
??daemonize:
默認情況下，redis不是在後臺運行的，如果需要在後臺運行，把該項的值更改爲yes
??pidfile
當Redis在後臺運行的時候，Redis默認會把pid文件放在/var/run/redis.pid，你可以配置到其他地址。當運行多個redis服務時，需要指定不同的pid文件和端口
??bind
指定Redis只接收來自於該IP地址的請求，如果不進行設置，那麼將處理所有請求，在生產環境中最好設置該項
??port
監聽端口，默認爲6379
??timeout
設置客戶端連接時的超時時間，單位爲秒。當客戶端在這段時間內沒有發出任何指令，那麼關閉該連接
??loglevel
log等級分爲4級，debug, verbose, notice, 和warning。生產環境下一般開啓notice
??logfile
配置log文件地址，默認使用標準輸出，即打印在命令行終端的窗口上
??databases
設置數據庫的個數，可以使用SELECT <dbid>命令來切換數據庫。默認使用的數據庫是0
??save
設置Redis進行數據庫鏡像的頻率。 if(在60秒之內有10000個keys發生變化時){ 進行鏡像備份 }else if(在300秒之內有10個keys發生了變化){ 進行鏡像備份 }else if(在900秒之內有1個keys發生了變化){ 進行鏡像備份 }
??rdbcompression
在進行鏡像備份時，是否進行壓縮
??dbfilename
鏡像備份文件的文件名
??dir
數據庫鏡像備份的文件放置的路徑。這裏的路徑跟文件名要分開配置是因爲Redis在進行備份時，先會將當前數據庫的狀態寫入到一個臨時文件中，等備份完成時，再把該該臨時文件替換爲上面所指定的文件，而這裏的臨時文件和上面所配置的備份文件都會放在這個指定的路徑當中
??slaveof
設置該數據庫爲其他數據庫的從數據庫
??masterauth
當主數據庫連接需要密碼驗證時，在這裏指定
??requirepass
設置客戶端連接後進行任何其他指定前需要使用的密碼。警告：因爲redis速度相當快，所以在一臺比較好的服務器下，一個外部的用戶可以在一秒鐘進行150K次的密碼嘗試，這意味着你需要指定非常非常強大的密碼來防止暴力破解。
??maxclients
限制同時連接的客戶數量。當連接數超過這個值時，redis將不再接收其他連接請求，客戶端嘗試連接時將收到error信息。
??maxmemory
設置redis能夠使用的最大內存。當內存滿了的時候，如果還接收到set命令，redis將先嚐試剔除設置過expire信息的key，而不管該key的過期時間還沒有到達。在刪除時，將按照過期時間進行刪除，最早將要被過期的key將最先被刪除。如果帶有expire信息的key都刪光了，那麼將返回錯誤。這樣，redis將不再接收寫請求，只接收get請求。maxmemory的設置比較適合於把redis當作於類似memcached的緩存來使用。
??appendonly
默認情況下，redis會在後臺異步的把數據庫鏡像備份到磁盤，但是該備份是非常耗時的，而且備份也不能很頻繁，如果發生諸如拉閘限電、拔插頭等狀況，那麼將造成比較大範圍的數據丟失。所以redis提供了另外一種更加高效的數據庫備份及災難恢復方式。開啓append only模式之後，redis會把所接收到的每一次寫操作請求都追加到appendonly.aof文件中，當redis重新啓動時，會從該文件恢復出之前的狀態。但是這樣會造成appendonly.aof文件過大，所以redis還支持了BGREWRITEAOF指令，對appendonly.aof進行重新整理。所以我認爲推薦生產環境下的做法爲關閉鏡像，開啓appendonly.aof，同時可以選擇在訪問較少的時間每天對appendonly.aof進行重寫一次。
??appendfsync
設置對appendonly.aof文件進行同步的頻率。always表示每次有寫操作都進行同步，everysec表示對寫操作進行累積，每秒同步一次。這個需要根據實際業務場景進行配置
??vm-enabled
是否開啓虛擬內存支持。因爲redis是一個內存數據庫，而且當內存滿的時候，無法接收新的寫請求，所以在redis 2.0中，提供了虛擬內存的支持。但是需要注意的是，redis中，所有的key都會放在內存中，在內存不夠時，只會把value值放入交換區。這樣保證了雖然使用虛擬內存，但性能基本不受影響，同時，你需要注意的是你要把vm-max-memory設置到足夠來放下你的所有的key
??vm-swap-file
設置虛擬內存的交換文件路徑
??vm-max-memory
這裏設置開啓虛擬內存之後，redis將使用的最大物理內存的大小。默認爲0，redis將把他所有的能放到交換文件的都放到交換文件中，以儘量少的使用物理內存。在生產環境下，需要根據實際情況設置該值，最好不要使用默認的0
??vm-page-size
設置虛擬內存的頁大小，如果你的value值比較大，比如說你要在value中放置博客、新聞之類的所有文章內容，就設大一點，如果要放置的都是很小的內容，那就設小一點。
??vm-pages
設置交換文件的總的page數量，需要注意的是，page table信息會放在物理內存中，每8個page就會佔據RAM中的1個byte。總的虛擬內存大小＝ vm-page-size * vm-pages
??vm-max-threads
設置VM IO同時使用的線程數量。因爲在進行內存交換時，對數據有編碼和解碼的過
程，所以儘管IO設備在硬件上本上不能支持很多的併發讀寫，但是還是如果你所保存的vlaue值比較大，將該值設大一些，還是能夠提升性能的
??glueoutputbuf
把小的輸出緩存放在一起，以便能夠在一個TCP packet中爲客戶端發送多個響應，具體原理和真實效果我不是很清楚。所以根據註釋，你不是很確定的時候就設置成yes
??hash-max-zipmap-entries
在redis 2.0中引入了hash數據結構。當hash中包含超過指定元素個數並且最大的元素沒有超過臨界時，hash將以一種特殊的編碼方式（大大減少內存使用）來存儲，這裏可以設置這兩個臨界值
??activerehashing
開啓之後，redis將在每100毫秒時使用1毫秒的CPU時間來對redis的hash表進行重新hash，可以降低內存的使用。當你的使用場景中，有非常嚴格的實時性需要，不能夠接受Redis時不時的對請求有2毫秒的延遲的話，把這項配置爲no。如果沒有這麼嚴格的實時性要求，可以設置爲yes，以便能夠儘可能快的釋放內存
3、啓動，使用redis
redis-server /usr/local/redis/redis.conf //啓動redis
//以下redis-cli來設置key-value值，並且取得數據
root@ubuntu:/usr/local/redis# redis-cli set test "我要測試一下"
OK
root@ubuntu:/usr/local/redis# redis-cli get test
"\xe6\x88\x91\xe8\xa6\x81\xe6\xb5\x8b\xe8\xaf\x95\xe4\xb8\x80\xe4\xb8\x8b" //以下是telnet的方式來設置key-value值
root@ubuntu:/usr/local/redis# telnet 127.0.0.1 6379
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
set test mytest
+OK
get test
$6
mytest
quit
+OK
Connection closed by foreign host.
4、關閉redis
redis-cli shutdown
# killall -9 redis-server //關閉所有
檢測Redis是否啓動：
netstat -an –t
5、redis開機啓動
Vi /etc/rc.d/rc.local
redis-server /usr/local/redis/redis.conf或
echo "redis-server /usr/local/redis/redis.conf" >> /etc/rc.d/rc.local
redis是單線程來處理所有client的請求的
實驗
下面是個實驗,首先清空當前數據庫，然後
設置k1,k2.獲取時k3對應返回nil
redis> flushdb
OK
redis> dbsize
(integer) 0
redis> set k1 a
OK
redis> set k2 b
OK
redis> mget k1 k2 k3
1. "a"
2. "b"
3. (nil)
mset key1 value1 ... keyN valueN 一次設置多個key的值，成功返回1表示所有的值都設置了，失敗返回0表示沒有任何值被設置
msetnx key1 value1 ... keyN valueN 同上，但是不會覆蓋已經存在的key
incr key 對key的值做加加操作,並返回新的值。注意incr一個不是int的value會返回錯誤，incr一個不存在的key，則設置key爲1
decr key 同上，但是做的是減減操作，decr一個不存在key，則設置key爲-1
incrby key integer 同incr，加指定值 ，key不存在時候會設置key，並認爲原來的value是 0
decrby key integer 同decr，減指定值。decrby完全是爲了可讀性，我們完全可以通過incrby一個負值來實現同樣效果，反之一樣。
append key value 給指定key的字符串值追加value,返回新字符串值的長度。下面給個例子
redis> set k hello
OK
redis> append k ,world
(integer) 11
redis> get k
"hello,world"
substr key start end 返回截取過的key的字符串值,注意並不修改key的值。下標是從0開始的，接着上面例子
redis> substr k 0 8
"hello,wor"
redis> get k
"hello,world"
主從複製
redis主從複製配置和使用都非常簡單。通過主從複製可以允許多個slave server擁有和master server相同的數據庫副本。下面是關於redis主從複製的一些特點
1.master可以有多個slave
2.除了多個slave連到相同的master外，slave也可以連接其他slave形成圖狀結構
3.主從複製不會阻塞master。也就是說當一個或多個slave與master進行初次同步數據時，master可以繼續處理client發來的請求。相反slave在初次同步數據時則會阻塞不能處理client的請求。
4.主從複製可以用來提高系統的可伸縮性,我們可以用多個slave 專門用於client的讀請求，比如sort操作可以使用slave來處理。也可以用來做簡單的數據冗餘
5.可以在master禁用數據持久化，只需要註釋掉master 配置文件中的所有save配置，然後只在slave上配置數據持久化。
下面介紹下主從複製的過程
當設置好slave服務器後，slave會建立和master的連接，然後發送sync命令。無論是第一次同步建立的連接還是連接斷開後的重新連接，master都會啓動一個後臺進程，將數據庫快照保存到文件中，同時master主進程會開始收集新的寫命令並緩存起來。後臺進程完成寫文件後，master就發送文件給slave，slave將文件保存到磁盤上，然後加載到內存恢復數據庫快照到slave上。接着master就會把緩存的命 令轉發給slave。而且後續master收到的寫命令都會通過開始建立的連接發送給slave。從master到slave的同步數據的命令和從 client發送的命令使用相同的協議格式。當master和slave的連接斷開時slave可以自動重新建立連接。如果master同時收到多個 slave發來的同步連接命令，只會使用啓動一個進程來寫數據庫鏡像，然後發送給所有slave。
redis主從複製特點:
1.master（主）可以擁有多個slave（從）
2.多個slave可以連接同一個master外，還可以連接到其他slave
3.主從複製不會阻塞master，在同步數據時，master可以繼續處理client請求
4.提高系統的伸縮性
5.可以在master禁用數據持久化，註釋掉master配置文件中的所有save配置，只需在slave上配置數據持久化
#當有一條Keys數據被改變是，900秒刷新到disk一次
#save 900 1
#當有10條Keys數據被改變時，300秒刷新到disk一次
#save 300 10
#當有1w條keys數據被改變時，60秒刷新到disk一次
#save 60 10000
redis主從複製過程:
當配置好slave後，slave與master建立連接，然後發送sync命令。無論是第一次連接還是重新連接，master都會啓動一個後臺進程，將數據庫快照保存到文件中，同時master主進程會開始收集新的寫命令並緩存。後臺進程完成寫文件後，master就發送文件給slave，slave將文件保存到硬盤上，再加載到內存中，接着master就會把緩存的命令轉發給slave，後續master將收到的寫命令發送給slave。如果 master同時收到多個slave發來的同步連接命令，master只會啓動一個進程來寫數據庫鏡像，然後發送給所有的slave。
配置
Redis的主從複製功能非常強大，一個master可以擁有多個slave，而一個slave又可以擁有多個slave，如此下去，形成了強大的多級 服務器集羣架構。下面我演示下怎樣在多臺服務器上進行Redis數據主從複製。這裏我假設有兩臺服務器，一臺是Linux操作系統（局域網 IP：192.168.3.159），一臺是Linux操作系統（局域網IP：192.168.3.169）此時我們要到用到linux ，這裏我們採用centOs5.4 ，redis採用redis-2.0.4。
這裏我使用1個master以及1個slave（master在一個Linux下，一個slave在一個Linux下，基本流程是
client -----whrite----->>>【Linux(master 192.168.3159:6379)】<<<--------------------slave----【Linux (slave 192.168.3.169:6381)】<<<<------read---------client
1.在master上修改redis.conf
#bind 192.168.3.159(可不設置)
2.在slave上修改redis.conf
port 6381（slave上端口）
bind 192.168.3.169
slaveof 192.168.3.159 6379 （設置master的Host以及Port）
3.啓動服務
首先啓動master
redis-server redis.conf
然後啓動slave
redis-server redis.conf
查看日誌出現
tail -f redis.log
* Connecting to MASTER...
[5374] 23 Aug 03:33:20 * Receiving 5479067bytes data dump from MASTER
[5374]23 Aug 03:33:21 * MASTER <-> SLAVE sync succeeded
完整配置實例（關閉主從服務器防火牆）
redis主從配置:
【master】
daemonize yes
pidfile /var/run/redis.pid
port 6379
timeout 300
loglevel verbose
logfile /usr/local/redis-2.2.12/var/log/redis.log
databases 16
save 900 1
save 300 10
save 60 10000
maxmemory
rdbcompression yes
dbfilename dump.rdb
dir /usr/local/redis-2.2.12/var/data
requirepass redis
appendonly no
appendfsync everysec
no-appendfsync-on-rewrite no
slowlog-log-slower-than 10000
slowlog-max-len 1024
vm-enabled no
vm-swap-file /tmp/redis.swap
vm-max-memory 0
vm-page-size 32
vm-pages 134217728
vm-max-threads 4
hash-max-zipmap-entries 512
hash-max-zipmap-value 64
list-max-ziplist-entries 512
list-max-ziplist-value 64
set-max-intset-entries 512
activerehashing yes
【slave】
daemonize yes
pidfile /var/run/redis.pid
port 6379
timeout 300
loglevel verbose
logfile /usr/local/redis-2.2.12/var/log/redis.log
databases 16
save 900 1
save 300 10
save 60 10000
rdbcompression yes
dbfilename dump.rdb
dir /usr/local/redis-2.2.12/var/data
appendonly no
appendfsync everysec
no-appendfsync-on-rewrite no
slowlog-log-slower-than 10000
slowlog-max-len 1024
vm-enabled no
vm-swap-file /tmp/redis.swap
vm-max-memory 0
vm-page-size 32
vm-pages 134217728
vm-max-threads 4
hash-max-zipmap-entries 512
hash-max-zipmap-value 64
list-max-ziplist-entries 512
list-max-ziplist-value 64
set-max-intset-entries 512
activerehashing yes
slaveof 192.168.1.159 6379 #主
redis複製測試
tail -f redis.log
查看master端日誌:
[8930] 31 Jul 19:16:09 – Accepted 192.168.1.136:54774
[8930] 31 Jul 19:16:09 * Slave ask for synchronization
[8930] 31 Jul 19:16:09 * Starting BGSAVE for SYNC
[8930] 31 Jul 19:16:09 * Background saving started by pid 10782
[10782] 31 Jul 19:16:09 * DB saved on disk
[8930] 31 Jul 19:16:09 * Background saving terminated with success
[8930] 31 Jul 19:16:09 * Synchronization with slave succeeded
[8930] 31 Jul 19:16:14 – DB 0: 1 keys (0 volatile) in 4 slots HT.
[8930] 31 Jul 19:16:14 – 1 clients connected (1 slaves), 807320 bytes in use
查看slave端日誌:
[24398] 01 Aug 10:16:10 * Connecting to MASTER…
[24398] 01 Aug 10:16:10 * MASTER <-> SLAVE sync started: SYNC sent
[24398] 01 Aug 10:16:10 * MASTER <-> SLAVE sync: receiving 25 bytes from master
[24398] 01 Aug 10:16:10 * MASTER <-> SLAVE sync: Loading DB in memory
[24398] 01 Aug 10:16:10 * MASTER <-> SLAVE sync: Finished with success
[24398] 01 Aug 10:16:15 – DB 0: 1 keys (0 volatile) in 4 slots HT.
[24398] 01 Aug 10:16:15 – 1 clients connected (0 slaves), 798960 bytes in use
master端操作:
redis 127.0.0.1:6379> set k_m master
OK
slave端操作:
redis 127.0.0.1:6379> get k_m
“master”
什麼是內存文件系統了？就是操作系統把系統內存劃出一部分當作硬盤使用。你可以像操作磁盤那樣的操作內存。但效率遠遠比硬盤來的快多了。通俗叫做內存文件系統，只要服務器不重起數據將一直都在。
redis-cli -p 6379 info 查看狀態。
操作數據庫
|
插入數據 127.0.0.1:6379> set name wwl OK 設置一個key-value對 查詢數據 127.0.0.1:6379> get name "wwl" 取出key所對應的value 刪除鍵值 127.0.0.1:6379> del name 刪除這個key及對應的value |
|
驗證鍵是否存在 127.0.0.1:6379> exists name (integer) 0 |
其中0，代表此key不存在；1代表存在
詳細的redis解釋在http://hanjie.blog.51cto.com/2684172/488374這位博主的博客有