redis應用之安裝配置介紹
1、redis介紹：php
一、redis定義：html
Redis是一個開源的使用ANSI C語言編寫、支持網絡、可基於內存亦可持久化的日誌型、Key-Value數據庫，並提供多種語言的API。從2010年3月15日起，Redis的開發工做由VMware主持。redis是一個key-value存儲系統。和Memcached相似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數據類型都支持push/pop、add/remove及取交集並集和差集及更豐富的操做，並且這些操做都是原子性的。在此基礎上，redis支持各類不一樣方式的排序。與memcached同樣，爲了保證效率，數據都是緩存在內存中。區別是redis會週期性的把更新的數據寫入磁盤或者把修改操做寫入追加的記錄文件，而且在此基礎上實現了master-slave(主從)同步。Redis 是一個高性能的key-value數據庫。redis的出現，很大程度補償了memcached這類key/value存儲的不足，在部分場合能夠對關係數據庫起到很好的補充做用，它提供了Python，Ruby，Erlang，PHP客戶端，使用很方便。node
二、redis存儲介紹c++
redis使用了兩種文件格式：全量數據和增量請求。全量數據格式是把內存中的數據寫入磁盤，便於下次讀取文件進行加載；增量請求文件則是把內存中的數據序列化爲操做請求，用於讀取文件進行replay獲得數據，序列化的操做包括SET、RPUSH、SADD、ZADD。git
三、redis性能:github
下面是官方的bench-mark數據：web
測試完成了50個併發執行100000個請求。redis
設置和獲取的值是一個256字節字符串。算法
Linux box是運行Linux 2.6,這是X3320 Xeon 2.5 ghz。數據庫
文本執行使用loopback接口(127.0.0.1)。
結果:寫的速度是110000次/s,讀的速度是81000次/s 。
2、redis單臺服務的安裝配置
環境：centos 6.6 x86_64
注：有2種安裝方式，第一種是直接yum安裝；第二種是編譯安裝
一、使用yum安裝（版本偏低2.4.10）
配置epel源 #rpm -ivh http://dl.Fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm #yum install redis -y 啓動redis #service redis start #chkconfig --add redis #chkconfig redis on 查看進程 #ps aux | grep redis redis 4393 0.0 0.3 39936 7092 ? Ssl 15:01 0:00 /usr/sbin/redis-server /etc/redis.conf 查看版本等信息： #/usr/bin/redis-cli info redis_version:2.4.10 redis_git_sha1:00000000 redis_git_dirty:0 arch_bits:64 multiplexing_api:epoll gcc_version:4.4.6 …………………… 查看安裝了哪些文件： #rpm -ql redis /etc/logrotate.d/redis /etc/rc.d/init.d/redis /etc/redis.conf /usr/bin/redis-benchmark /usr/bin/redis-check-aof /usr/bin/redis-check-dump /usr/bin/redis-cli /usr/sbin/redis-server /usr/share/doc/redis-2.4.10 /usr/share/doc/redis-2.4.10/00-RELEASENOTES /usr/share/doc/redis-2.4.10/BUGS /usr/share/doc/redis-2.4.10/CONTRIBUTING /usr/share/doc/redis-2.4.10/COPYING /usr/share/doc/redis-2.4.10/README /usr/share/doc/redis-2.4.10/TODO /var/lib/redis /var/log/redis /var/run/redis 查看默認配置文件 #cat /etc/redis.conf | egrep -v "^#|^$" daemonize yes pidfile /var/run/redis/redis.pid port 6379 bind 127.0.0.1 timeout 0 loglevel notice logfile /var/log/redis/redis.log databases 16 save 900 1 save 300 10 save 60 10000 rdbcompression yes dbfilename dump.rdb dir /var/lib/redis/ slave-serve-stale-data yes appendonly yes appendfsync everysec no-appendfsync-on-rewrite no auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb 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 zset-max-ziplist-entries 128 zset-max-ziplist-value 64 activerehashing yes
二、使用編譯方式安裝redis
注：編譯安裝能夠安裝比較穩定的高版本，截止到20161010，最新版本是3.2.4 官網http://redis.io/
安裝依賴包
#yum install gcc gcc-c++ tcl -y
PS:遇到的問題
a、若是不安裝tcl，後面make test的時候回報錯，以下：
cd src && make test make[1]: Entering directory `/root/redis-3.0.3/src' You need tcl 8.5 or newer in order to run the Redis test make[1]: *** [test] Error 1 make[1]: Leaving directory `/root/redis-3.0.3/src' make: *** [test] Error 2
b、make的時候報錯（版本3.0.3）
#make cd src && make all make[1]: Entering directory `/root/redis-3.0.3/src' CC adlist.o In file included from adlist.c:34: zmalloc.h:50:31: error: jemalloc/jemalloc.h: No such file or directory zmalloc.h:55:2: error: #error "Newer version of jemalloc required" make[1]: *** [adlist.o] Error 1 make[1]: Leaving directory `/root/redis-3.0.3/src' make: *** [all] Error 2 在README 有這個一段話。 Allocator --------- Selecting a non-default memory allocator when building Redis is done by setting the `MALLOC` environment variable. Redis is compiled and linked against libc malloc by default, with the exception of jemalloc being the default on Linux systems. This default was picked because jemalloc has proven to have fewer fragmentation problems than libc malloc. To force compiling against libc malloc, use: % make MALLOC=libc To compile against jemalloc on Mac OS X systems, use: % make MALLOC=jemalloc 大概意思是說關於分配器allocator， 若是有MALLOC 這個 環境變量， 會有用這個環境變量的 去創建Redis。 並且libc 並非默認的 分配器， 默認的是 jemalloc, 由於 jemalloc 被證實有更少的fragmentation problems 比libc。 可是若是你又沒有jemalloc 而只有 libc 固然 make 出錯，因此加這麼一個參數。 解決辦法： #make MALLOC=libc #添加一個參數 ……………… Hint: It's a good idea to run 'make test' ;) make[1]: Leaving directory `/root/redis-3.0.3/src'
開始編譯安裝redis-3.0.7
#tar xf redis-3.0.7.tar.gz #cd redis-3.0.7 #make ………… Hint: It's a good idea to run 'make test' ;) make[1]: Leaving directory `/root/redis-3.0.7/src' #make test ……………… \o/ All tests passed without errors! Cleanup: may take some time... OK make[1]: Leaving directory `/root/redis-3.0.7/src'
到這裏已經編譯安裝OK了！
我這裏自定義路徑，把redis安裝到/usr/local/redis/目錄下，操做以下：
#mkdir -pv /usr/local/redis/bin #cd /root/redis-3.0.7/src #cp redis-benchmark /usr/local/redis/bin #cp redis-check-aof /usr/local/redis/bin #cp redis-check-dump /usr/local/redis/bin #cp redis-cli /usr/local/redis/bin #cp redis-server /usr/local/redis/bin #cp redis-sentinel /usr/local/redis/bin/ #cp redis-trib.rb /usr/local/redis/bin/ 設置環境變量： #vim /etc/profile PATH=$PATH:/usr/local/redis/bin #source /etc/profile 建立conf目錄： #mkdir /usr/local/redis/conf 建立log目錄 #mkdir -pv /usr/local/redis/log/ 建立配置文件： #cp /root/redis-3.0.7/redis.conf /usr/local/redis/conf #cp /root/redis-3.0.7/sentinel.conf /usr/local/redis/conf
配置文件根據需求修改成以下：
logfile "/usr/local/redis/log/redis.log" daemonize no --改成yes,讓redis在後臺運行 pidfile /var/run/redis.pid port 6379 --端口能夠自定義，默認是6379 bind 10.0.18.145 127.0.0.1 --綁定地址，本機IP dbfilename dump.rdb --rdb名稱 dir /usr/local/redis/ --數據存放路徑 appendonly yes --開啓aof日誌 databases 16 --數據庫數目
其餘參數根據須要修改!
注：appendonly選項就是負責是否開啓AOF日誌的開關.AOF日誌,你能夠簡單理解爲MySQL binlog同樣的東西,做用就是記錄每次的寫操做,在遇到斷電等問題時能夠用它來恢復數據庫狀態。可是他不是bin的,而是text的.一行一行,寫得很規範.若是你是一臺redis,那你也能經過它恢復數據.
系統參數設置：
設置打開文件的最大數
#vim /etc/security/limits.conf * soft nofile 65535 * hard nofile 65535 * soft nproc 10240 * hard nproc 10240
啓動redis
#nohup /usr/local/redis/bin/redis-server /usr/local/redis/conf/redis.conf & #在後臺運行 啓動以後，查看是否運行正常 #netstat -tunlp Active Internet connections (only servers) Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 4628/sshd tcp 0 0 127.0.0.1:25 0.0.0.0:* LISTEN 1101/master tcp 0 0 127.0.0.1:6379 0.0.0.0:* LISTEN 9514/redis-server 1 tcp 0 0 10.0.18.145:6379 0.0.0.0:* LISTEN 9514/redis-server 1 tcp 0 0 :::22 :::* LISTEN 4628/sshd tcp 0 0 ::1:25 :::* LISTEN 1101/master 注：啓動redis以後看到的日誌： vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect. 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled. WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128. 從上述信息能夠看出，應該是須要優化一些系統參數 #vi /etc/sysctl.conf #添加或者修改參數 vm.overcommit_memory = 1 net.core.somaxconn = 511 vm.swappiness = 0 net.ipv4.neigh.default.gc_stale_time=120 net.ipv4.conf.all.rp_filter=0 net.ipv4.conf.default.rp_filter=0 net.ipv4.conf.default.arp_announce = 2 net.ipv4.conf.all.arp_announce=2 net.ipv4.tcp_max_tw_buckets = 5000 net.ipv4.tcp_syncookies = 1 net.ipv4.tcp_max_syn_backlog = 1024 #默認值 net.ipv4.tcp_synack_retries = 2 net.ipv4.conf.lo.arp_announce=2 注：net.ipv4.tcp_max_syn_backlog 參數決定了SYN_RECV狀態隊列的數量，通常默認值爲512或者1024，即超過這個數量，系統將再也不接受新的TCP鏈接請求， 必定程度上能夠防止系統資源耗盡。可根據狀況增長該值以接受更多的鏈接請求。centos系統默認是1024 查看修改以前 #cat /sys/kernel/mm/transparent_hugepage/enabled [always] madvise never #echo never > /sys/kernel/mm/transparent_hugepage/enabled #修改成never #cat /sys/kernel/mm/transparent_hugepage/enabled always madvise [never] 而後重啓redis，就不會提示以前的WARNING了！
對redis進行一個簡單的壓力測試，以下：
#redis-benchmark -t set -c 20 -n 1000000 -r 100000000 ====== SET ====== 1000000 requests completed in 17.69 seconds 20 parallel clients 3 bytes payload keep alive: 1 99.99% <= 1 milliseconds 100.00% <= 1 milliseconds 56516.33 requests per second
3、redis配置文件參數和經常使用命令介紹
一、配置文件參數，以下：
#cat redis.conf # 當你須要爲某個配置項指定內存大小的時候，必需要帶上單位，一般的格式就是 1k 5gb 4m 等這樣 # 1k => 1000 bytes # 1kb => 1024 bytes # 1m => 1000000 bytes # 1mb => 1024*1024 bytes # 1g => 1000000000 bytes # 1gb => 1024*1024*1024 bytes # 單位是不區分大小寫的，你寫 1K 5GB 4M 也行 # 假如說你有一個可用於全部的 redis server 的標準配置模板， # 但針對某些 server 又須要一些個性化的設置， # 你可使用 include 來包含一些其餘的配置文件，這對你來講是很是有用的。 # 可是要注意，include 是不能被 config rewrite 命令改寫的 # 因爲 redis 老是以最後的加工線做爲一個配置指令值，因此你最好是把 include 放在這個文件的最前面， # 以免在運行時覆蓋配置的改變，相反，你就把它放在後面。 # include /path/to/local.conf # include /path/to/other.conf ################################ 經常使用 ##################################### # 默認狀況下 redis 不是做爲守護進程運行的，若是你想讓它在後臺運行，你就把它改爲 yes。 daemonize no # 當redis做爲守護進程運行的時候，它會把 pid 默認寫到 /var/run/redis.pid 文件裏面， # 可是你能夠在這裏自定義它的文件位置。 pidfile /var/run/redis.pid # 監聽端口號，默認爲 6379，若是你設爲0,redis 將不在 socket 上監放任何客戶端鏈接，也能夠自定義端口 port 6379 # TCP 監聽的最大容納數量 # 在高併發的環境下，你須要把這個值調高以免客戶端鏈接緩慢的問題。 # Linux 內核會一言不發的把這個值縮小成 /proc/sys/net/core/somaxconn 對應的值， # 因此你要修改somaxconn和tcp_max_syn_backlog這兩個值才能達到你的預期。 tcp-backlog 511 # 默認狀況下，redis 在 server 上全部有效的網絡接口上監聽客戶端鏈接。 # 你若是隻想讓它在一個網絡接口上監聽，那你就綁定一個IP或者多個IP。 # 示例，多個IP用空格隔開: # bind 192.168.1.100 10.0.0.1 # bind 127.0.0.1 # 指定 unix socket 的路徑。 # unixsocket /tmp/redis.sock # unixsocketperm 755 # 指定在一個 client 空閒多少秒以後關閉鏈接（0 就是無論它） timeout 0 # tcp 心跳包。 # 若是設置爲非零，則在與客戶端缺少通信的時候使用SO_KEEPALIVE發送tcp acks給客戶端。 # 這個之全部有用，主要由兩個緣由： # 1) 防止死的 peers # 2) Take the connection alive from the point of view of network # equipment in the middle. # On Linux, the specified value (in seconds) is the period used to send ACKs. # Note that to close the connection the double of the time is needed. # On other kernels the period depends on the kernel configuration. # # A reasonable value for this option is 60 seconds. # 推薦一個合理的值就是60秒 tcp-keepalive 0 # 定義日誌級別。 # 能夠是下面的這些值： # debug (適用於開發或測試階段) # verbose (many rarely useful info, but not a mess like the debug level) # notice (適用於生產環境) # warning (僅僅一些重要的消息被記錄) loglevel notice # 指定日誌文件的位置 logfile "/var/log/redis.log" # 要想把日誌記錄到系統日誌，就把它改爲 yes， # 也能夠可選擇性的更新其餘的syslog 參數以達到你的要求 # syslog-enabled no # 設置 syslog 的 identity。 # syslog-ident redis # 設置 syslog 的 facility，必須是 USER 或者是 LOCAL0-LOCAL7 之間的值。 # syslog-facility local0 # 設置數據庫的數目。 # 默認數據庫是 DB 0，你能夠在每一個鏈接上使用 select <dbid> 命令選擇一個不一樣的數據庫， # 可是 db id 必須是一個介於 0 到 databasees - 1 之間的值 databases 16 ################################ 快照 ################################ # # 存 DB 到磁盤： # # 格式：save <間隔時間（秒）> <寫入次數> # # 根據給定的時間間隔和寫入次數將數據保存到磁盤 # # 下面的例子的意思是： # 900 秒內若是至少有 1 個 key 的值變化，則保存 # 300 秒內若是至少有 10 個 key 的值變化，則保存 # 60 秒內若是至少有 10000 個 key 的值變化，則保存 # # 注意：你能夠註釋掉全部的 save 行來停用保存功能。 # 也能夠直接一個空字符串來實現停用： # save "" save 900 1 save 300 10 save 60 10000 # 默認狀況下，若是 redis 最後一次的後臺保存失敗，redis 將中止接受寫操做， # 這樣以一種強硬的方式讓用戶知道數據不能正確的持久化到磁盤，不然就會沒人注意到災難的發生。 # 若是後臺保存進程從新啓動工做了，redis也將自動的容許寫操做。 補充： redis的存儲分爲內存存儲、磁盤存儲和log文件三部分，配置文件中有三個參數對其進行配置。 由於redis自己同步數據文件是按上面的save條件來同步的，因此有的數據會在一段時間內只存在於內存中。開啓的話每次寫操做會記一條log，這會提升數據抗風險能力，但影響效率。 #然而若是你已經設置了對redis服務器的正確監視和持久性，你可能要禁用此功能，以便redis將繼續正常工做 即便有磁盤、權限等問題，說白點就是有任何問題致使的bgsave失敗都中止redis的對外服務。默認yes，能夠設置爲no stop-writes-on-bgsave-error yes # 是否在dump .rdb 數據庫的時候使用 LZF 壓縮字符串，默認都設爲 yes # 若是你但願保存子進程節省點 cpu ，你就設置它爲 no，不過這個數據集可能就會比較大 rdbcompression yes # 是否校驗rdb文件 rdbchecksum yes # 設置dump的文件名 dbfilename dump.rdb # 工做目錄 # 例如上面的 dbfilename 只指定了文件名， # 可是它會寫入到這個目錄下。這個配置項必定是個目錄，而不能是文件名。 dir ./ #能夠自定義，好比dir /usr/local/redis/ ################################# 主從複製 ################################# # 主從複製。使用slaveof來讓一個redis實例成爲另外一個reids實例的副本。 關於Redis複製的幾個事情 # 1)redis複製是異步的，可是若是它看起來沒有與至少給定數量的slave鏈接，你能夠將master配置爲中止接受寫入 # 2)若是複製連接丟失相對較少的時間，Redis從服務器可以與主設備執行部分從新同步。 # 你可能須要根據你的須要使用合理的值配置複製積壓大小（請參閱此文件的下一部分） # 3)複製是自動的，不須要用戶干預。網絡分區後，從服務器自動嘗試從新鏈接到主服務器並與其同步。 # # 設置當本機爲slave服務時，設置master服務的IP地址及端口，在Redis啓動時，它會自動從master進行數據同步 # slaveof <masterip> <masterport> # 若是 master 須要密碼認證，就在這裏設置 # masterauth <master-password> # 當一個 slave 與 master 失去聯繫，或者複製正在進行的時候， # slave 可能會有兩種表現： # 1) 若是slave-serve-stale-data設置爲 yes ，slave仍然會應答客戶端請求，但返回的數據多是過期， # 或者數據多是空的在第一次同步的時候 # # 2) 若是slave-serve-stale-data設置爲 no ，在你執行除了info 和slaveof 以外的其餘命令時， # slave 都將返回一個 "SYNC with master in progress" 的錯誤， slave-serve-stale-data yes # 你能夠配置一個slave實體是否接受寫入操做。 # 經過寫入操做來存儲一些短暫的數據對於一個 slave 實例來講多是有用的， # 由於相對從 master 從新同步數而言，據數據寫入到 slave 會更容易被刪除。 # 可是若是客戶端由於一個錯誤的配置寫入，也可能會致使一些問題。 # # 從 redis 2.6 版起，默認 slaves 都是隻讀的。 # Note: read only slaves are not designed to be exposed to untrusted clients # on the internet. It's just a protection layer against misuse of the instance. # Still a read only slave exports by default all the administrative commands # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve # security of read only slaves using 'rename-command' to shadow all the # administrative / dangerous commands. # 注意：只讀的 slaves 沒有被設計成在 internet 上暴露給不受信任的客戶端。 # 它僅僅是一個針對誤用實例的一個保護層。 # 從服務器只讀設置，默認是yes slave-read-only yes # 複製SYNC策略：磁盤或套接字。 # 使用慢磁盤和快速（大帶寬）網絡，無盤複製的效果更好 repl-diskless-sync no #當啓用無磁盤複製時，能夠配置服務器等待的延遲，以便生成將RDP經過套接字傳輸到從屬設備的子節點。 # #延遲時間以秒爲單位，默認值爲5秒。 要徹底禁用它只是設置爲0秒，傳輸將盡快啓動。 repl-diskless-sync-delay 5 # # Slaves 在一個預約義的時間間隔內發送 ping 命令到 server 。 # 你能夠改變這個時間間隔。默認爲 10 秒。 # repl-ping-slave-period 10 # The following option sets the replication timeout for: # 設置主從複製過時時間 # 1) Bulk transfer I/O during SYNC, from the point of view of slave. # 2) Master timeout from the point of view of slaves (data, pings). # 3) Slave timeout from the point of view of masters (REPLCONF ACK pings). # # It is important to make sure that this value is greater than the value # specified for repl-ping-slave-period otherwise a timeout will be detected # every time there is low traffic between the master and the slave. # 這個值必定要比 repl-ping-slave-period 大 # # repl-timeout 60 # Disable TCP_NODELAY on the slave socket after SYNC? # # If you select "yes" Redis will use a smaller number of TCP packets and # less bandwidth to send data to slaves. But this can add a delay for # the data to appear on the slave side, up to 40 milliseconds with # Linux kernels using a default configuration. # # If you select "no" the delay for data to appear on the slave side will # be reduced but more bandwidth will be used for replication. # # By default we optimize for low latency, but in very high traffic conditions # or when the master and slaves are many hops away, turning this to "yes" may # be a good idea. 默認狀況下，咱們針對低延遲進行優化，但在很是高的流量條件下或當主設備和從設備有許多跳時， 將其轉換爲「yes」多是一個好主意。因此默認是no repl-disable-tcp-nodelay no # 設置主從複製容量大小。這個 backlog 是一個用來在 slaves 被斷開鏈接時 # 存放 slave 數據的 buffer，因此當一個 slave 想要從新鏈接，一般不但願所有從新同步， # 只是部分同步就夠了，僅僅傳遞 slave 在斷開鏈接時丟失的這部分數據。 # # The biggest the replication backlog, the longer the time the slave can be # disconnected and later be able to perform a partial resynchronization. # 這個值越大，salve 能夠斷開鏈接的時間就越長。 # # The backlog is only allocated once there is at least a slave connected. # # repl-backlog-size 1mb # After a master has no longer connected slaves for some time, the backlog # will be freed. The following option configures the amount of seconds that # need to elapse, starting from the time the last slave disconnected, for # the backlog buffer to be freed. # 在某些時候，master 再也不鏈接 slaves，backlog 將被釋放。 # # A value of 0 means to never release the backlog. # 若是設置爲 0 ，意味着毫不釋放 backlog 。 # # repl-backlog-ttl 3600 # The slave priority is an integer number published by Redis in the INFO output. # It is used by Redis Sentinel in order to select a slave to promote into a # master if the master is no longer working correctly. # 從屬優先級是Redis在INFO輸出中發佈的整數。若是主服務器再也不正確工做，則Redis Sentinel # 使用它來選擇從服務器升級爲主服務器。 # A slave with a low priority number is considered better for promotion, so # for instance if there are three slaves with priority 10, 100, 25 Sentinel will # pick the one with priority 10, that is the lowest. # 具備低優先級號的從服務器被認爲更好地用於推廣，因此例如，若是存在具備優先級10,100,25的三個從服務器 # 則哨兵將選擇具備優先級10的那臺，即最低的那個。 # However a special priority of 0 marks the slave as not able to perform the # role of master, so a slave with priority of 0 will never be selected by # Redis Sentinel for promotion. # 當master不能正常工做的時候，Redis Sentinel 會從 slaves 中選出一個新的 master， # 這個值越小，就越會被優先選中，可是若是是 0 ，那是意味着這個 slave 不可能被選中。 # 默認優先級爲 100。 slave-priority 100 # It is possible for a master to stop accepting writes if there are less than # N slaves connected, having a lag less or equal than M seconds. # 若是鏈接少於N個slave服務器，具備小於或等於M秒的滯後，則master能夠中止接受寫入 # The N slaves need to be in "online" state. # 這N個slave服務器必須是處於online狀態 # The lag in seconds, that must be <= the specified value, is calculated from # the last ping received from the slave, that is usually sent every second. # # This option does not GUARANTEES that N replicas will accept the write, but # will limit the window of exposure for lost writes in case not enough slaves # are available, to the specified number of seconds. # # 此選項不保證N個副本將接受寫入，但將在沒有足夠的slave可用的狀況下將丟失寫入的曝光窗口限制爲指定的秒數。 # For example to require at least 3 slaves with a lag <= 10 seconds use: # # min-slaves-to-write 3 # min-slaves-max-lag 10 # 也就是說若是啓用以上2個選項，master只有當有N個slaves處於鏈接狀態的狀況下才接受寫操做 # Setting one or the other to 0 disables the feature. # # By default min-slaves-to-write is set to 0 (feature disabled) and # min-slaves-max-lag is set to 10. # 默認狀況下，min-slave-to-write設置爲0（禁用功能），min-slaves-max-lag設置爲10。 ################################## 安全 ################################### # Require clients to issue AUTH <PASSWORD> before processing any other # commands. This might be useful in environments in which you do not trust # others with access to the host running redis-server. # # This should stay commented out for backward compatibility and because most # people do not need auth (e.g. they run their own servers). # # Warning: since Redis is pretty fast an outside user can try up to # 150k passwords per second against a good box. This means that you should # use a very strong password otherwise it will be very easy to break. # # 設置認證密碼，這裏的密碼是加密後的加密串！ # requirepass foobared # Command renaming. # # It is possible to change the name of dangerous commands in a shared # environment. For instance the CONFIG command may be renamed into something # hard to guess so that it will still be available for internal-use tools # but not available for general clients. #能夠在共享環境中更改危險命令的名稱。 例如，CONFIG命令能夠重命名爲難以猜想的東西， #以便它仍然可用於內部使用工具，但不能用於通常客戶端。 # Example: 好比 # # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52 # # It is also possible to completely kill a command by renaming it into # an empty string: 也能夠經過將命令重命名爲空字符串來徹底殺死命令： # rename-command CONFIG "" # # Please note that changing the name of commands that are logged into the # AOF file or transmitted to slaves may cause problems. ################################### 限制 #################################### # Set the max number of connected clients at the same time. By default # this limit is set to 10000 clients, however if the Redis server is not # able to configure the process file limit to allow for the specified limit # the max number of allowed clients is set to the current file limit # minus 32 (as Redis reserves a few file descriptors for internal uses). # # 一旦達到最大限制，redis 將關閉全部的新鏈接，併發送一個‘max number of clients reached’的錯誤。 # maxclients 10000 # 不要使用比指定的字節數更多的內存。 # 若是你設置了這個值，當緩存的數據容量達到這個值， redis 將根據你選擇的 # eviction 策略來移除一些 keys。 # # 若是 redis 不能根據策略移除 keys ，或者是策略被設置爲 ‘noeviction’， # redis 將開始響應錯誤給命令，如 set，lpush 等等， # 並繼續響應只讀的命令，如 get # # This option is usually useful when using Redis as an LRU cache, or to set # a hard memory limit for an instance (using the 'noeviction' policy). # # WARNING: If you have slaves attached to an instance with maxmemory on, # the size of the output buffers needed to feed the slaves are subtracted # from the used memory count, so that network problems / resyncs will # not trigger a loop where keys are evicted, and in turn the output # buffer of slaves is full with DELs of keys evicted triggering the deletion # of more keys, and so forth until the database is completely emptied. # # In short... if you have slaves attached it is suggested that you set a lower # limit for maxmemory so that there is some free RAM on the system for slave # output buffers (but this is not needed if the policy is 'noeviction'). # # 最大使用內存 # maxmemory <bytes> # maxmemory 3GB # 最大內存策略，你有 5 個選擇。 # # volatile-lru -> remove the key with an expire set using an LRU algorithm # 使用 LRU 算法移除包含過時設置的 key，通常生產環境使用這個策略 # allkeys-lru -> remove any key accordingly to the LRU algorithm # 根據 LRU 算法移除全部的 key 。 # volatile-random -> remove a random key with an expire set # 刪除帶有過時集的隨機密鑰 # allkeys-random -> remove a random key, any key # 移除一個隨機key，任意key # volatile-ttl -> remove the key with the nearest expire time (minor TTL) # 刪除具備最近過時時間的密鑰（次TTL） # noeviction -> don't expire at all, just return an error on write operations # 不讓任何 key 過時，只是在寫入操做時返回一個錯誤 # # Note: with any of the above policies, Redis will return an error on write # operations, when there are not suitable keys for eviction. # # At the date of writing this commands are: set setnx setex append # incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd # sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby # zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby # getset mset msetnx exec sort # # The default is: # 默認設置是 noeviction # maxmemory-policy noeviction 能夠根據狀況自定義策略，好比 maxmemory-policy volatile-lru # LRU and minimal TTL algorithms are not precise algorithms but approximated # algorithms (in order to save memory), so you can tune it for speed or # accuracy. For default Redis will check five keys and pick the one that was # used less recently, you can change the sample size using the following # configuration directive. # # The default of 5 produces good enough results. 10 Approximates very closely # true LRU but costs a bit more CPU. 3 is very fast but not very accurate. # 默認值爲5產生足夠好的結果。 10近似很是接近真實的LRU，但成本更多的CPU。 3是很是快，但不是很準確。 # maxmemory-samples 5 #因此通常都是默認 ############################## APPEND ONLY 模式 ############################### # By default Redis asynchronously dumps the dataset on disk. This mode is # good enough in many applications, but an issue with the Redis process or # a power outage may result into a few minutes of writes lost (depending on # the configured save points). #默認狀況下，Redis異步地轉儲磁盤上的數據集。 這種模式在許多應用程序中是足夠好的， 可是Redis進程或斷電的問題可能致使幾分鐘的寫入丟失（取決於配置的保存點）。 # The Append Only File is an alternative persistence mode that provides # much better durability. For instance using the default data fsync policy # (see later in the config file) Redis can lose just one second of writes in a # dramatic event like a server power outage, or a single write if something # wrong with the Redis process itself happens, but the operating system is # still running correctly. # 僅附加文件是可提供更好耐久性的替代持久性模式。 例如，使用默認數據fsync策略（見後面的配置文件） # Redis在一個戲劇性的事件，如服務器斷電，丟失只有一秒的寫入，或一個單一的寫若是Redis進程自己發生錯誤， # 可是操做系統仍然正常運行。 # AOF and RDB persistence can be enabled at the same time without problems. # If the AOF is enabled on startup Redis will load the AOF, that is the file # with the better durability guarantees. # AOF和RDB持久性能夠同時啓用而沒有問題。 若是在啓動時啓用AOF，Redis將加載AOF，這是具備更好的持久性保證的文件。 # Please check http://redis.io/topics/persistence for more information. appendonly no ##aof日誌的類型默認是no，若是要保持更好的數據持久性，設置爲yes 補充：appendonly yes/no appendonly配置，指出是否在每次更新操做後進行日誌記錄，若是不開啓，可能會在斷電時致使一段時間內的數據丟失。 # The name of the append only file (default: "appendonly.aof") 僅追加文件的名稱（默認值：「appendonly.aof」） appendfilename "appendonly.aof" # The fsync() call tells the Operating System to actually write data on disk # instead to wait for more data in the output buffer. Some OS will really flush # data on disk, some other OS will just try to do it ASAP.（as soon as possible） # # Redis supports three different modes: # # no: don't fsync, just let the OS flush the data when it wants. Faster. # always: fsync after every write to the append only log . Slow, Safest. # everysec: fsync only one time every second. Compromise. # # The default is "everysec", as that's usually the right compromise between # speed and data safety. It's up to you to understand if you can relax this to # "no" that will let the operating system flush the output buffer when # it wants, for better performances (but if you can live with the idea of # some data loss consider the default persistence mode that's snapshotting), # or on the contrary, use "always" that's very slow but a bit safer than # everysec. # # More details please check the following article: # http://antirez.com/post/redis-persistence-demystified.html # # If unsure, use "everysec". # appendfsync always appendfsync everysec #默認everysec便可 # appendfsync no 注：appendfsync no/always/everysec ，appendfsync是Redis將OS數據緩衝區中數據刷新到磁盤的策略 no表示操做系統進行數據緩存同步到磁盤，always表示每次更新操做後手動調用fsync()將數據寫到磁盤，everysec表示每秒同步一次，默認是everysec。 # When the AOF fsync policy is set to always or everysec, and a background # saving process (a background save or AOF log background rewriting) is # performing a lot of I/O against the disk, in some Linux configurations # Redis may block too long on the fsync() call. Note that there is no fix for # this currently, as even performing fsync in a different thread will block # our synchronous write(2) call. # In order to mitigate this problem it's possible to use the following option # that will prevent fsync() from being called in the main process while a # BGSAVE or BGREWRITEAOF is in progress. # This means that while another child is saving, the durability of Redis is # the same as "appendfsync none". In practical terms, this means that it is # possible to lose up to 30 seconds of log in the worst scenario (with the # default Linux settings). # # If you have latency problems turn this to "yes". Otherwise leave it as # "no" that is the safest pick from the point of view of durability. 若是有延遲問題，請將其設置爲「yes」。 不然，從耐久性的角度看，它是「no」，這是最安全的選擇。 no-appendfsync-on-rewrite no # Automatic rewrite of the append only file. # Redis is able to automatically rewrite the log file implicitly calling # BGREWRITEAOF when the AOF log size grows by the specified percentage. # # This is how it works: Redis remembers the size of the AOF file after the # latest rewrite (if no rewrite has happened since the restart, the size of # the AOF at startup is used). # # This base size is compared to the current size. If the current size is # bigger than the specified percentage, the rewrite is triggered. Also # you need to specify a minimal size for the AOF file to be rewritten, this # is useful to avoid rewriting the AOF file even if the percentage increase # is reached but it is still pretty small. # # Specify a percentage of zero in order to disable the automatic AOF # rewrite feature. 指定一個百分比爲零，以禁用自動AOF重寫功能。 auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb # An AOF file may be found to be truncated at the end during the Redis # startup process, when the AOF data gets loaded back into memory. # This may happen when the system where Redis is running # crashes, especially when an ext4 filesystem is mounted without the # data=ordered option (however this can't happen when Redis itself # crashes or aborts but the operating system still works correctly). # # Redis can either exit with an error when this happens, or load as much # data as possible (the default now) and start if the AOF file is found # to be truncated at the end. The following option controls this behavior. # # If aof-load-truncated is set to yes, a truncated AOF file is loaded and # the Redis server starts emitting a log to inform the user of the event. # Otherwise if the option is set to no, the server aborts with an error # and refuses to start. When the option is set to no, the user requires # to fix the AOF file using the "redis-check-aof" utility before to restart # the server. # # Note that if the AOF file will be found to be corrupted in the middle # the server will still exit with an error. This option only applies when # Redis will try to read more data from the AOF file but not enough bytes # will be found. 請注意，若是AOF文件將被髮如今中間被損壞，服務器仍將退出並出現錯誤。此選項僅在Redis嘗試從AOF文件讀取更多數據但找不到足夠的字節時適用。 aof-load-truncated yes ################################ LUA SCRIPTING ############################### # Max execution time of a Lua script in milliseconds. # # If the maximum execution time is reached Redis will log that a script is # still in execution after the maximum allowed time and will start to # reply to queries with an error. # # When a long running script exceed the maximum execution time only the # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be # used to stop a script that did not yet called write commands. The second # is the only way to shut down the server in the case a write commands was # already issue by the script but the user don't want to wait for the natural # termination of the script. # # Set it to 0 or a negative value for unlimited execution without warnings. lua-time-limit 5000 ################################ REDIS 集羣 ############################### # # 啓用或停用集羣 # cluster-enabled yes # Every cluster node has a cluster configuration file. This file is not # intended to be edited by hand. It is created and updated by Redis nodes. # Every Redis Cluster node requires a different cluster configuration file. # Make sure that instances running in the same system does not have # overlapping cluster configuration file names. # 集羣配置文件 # cluster-config-file nodes-6379.conf # Cluster node timeout is the amount of milliseconds a node must be unreachable # for it to be considered in failure state. # Most other internal time limits are multiple of the node timeout. # 集羣節點超時時間 # cluster-node-timeout 15000 # A slave of a failing master will avoid to start a failover if its data # looks too old. # There is no simple way for a slave to actually have a exact measure of # its "data age", so the following two checks are performed: # # 1) If there are multiple slaves able to failover, they exchange messages # in order to try to give an advantage to the slave with the best # replication offset (more data from the master processed). # Slaves will try to get their rank by offset, and apply to the start # of the failover a delay proportional to their rank. # # 2) Every single slave computes the time of the last interaction with # its master. This can be the last ping or command received (if the master # is still in the "connected" state), or the time that elapsed since the # disconnection with the master (if the replication link is currently down). # If the last interaction is too old, the slave will not try to failover # at all. # # The point "2" can be tuned by user. Specifically a slave will not perform # the failover if, since the last interaction with the master, the time # elapsed is greater than: # # (node-timeout * slave-validity-factor) + repl-ping-slave-period # # So for example if node-timeout is 30 seconds, and the slave-validity-factor # is 10, and assuming a default repl-ping-slave-period of 10 seconds, the # slave will not try to failover if it was not able to talk with the master # for longer than 310 seconds. # # A large slave-validity-factor may allow slaves with too old data to failover # a master, while a too small value may prevent the cluster from being able to # elect a slave at all. # # For maximum availability, it is possible to set the slave-validity-factor # to a value of 0, which means, that slaves will always try to failover the # master regardless of the last time they interacted with the master. # (However they'll always try to apply a delay proportional to their # offset rank). # # Zero is the only value able to guarantee that when all the partitions heal # the cluster will always be able to continue. # # cluster-slave-validity-factor 10 # Cluster slaves are able to migrate to orphaned masters, that are masters # that are left without working slaves. This improves the cluster ability # to resist to failures as otherwise an orphaned master can't be failed over # in case of failure if it has no working slaves. # # Slaves migrate to orphaned masters only if there are still at least a # given number of other working slaves for their old master. This number # is the "migration barrier". A migration barrier of 1 means that a slave # will migrate only if there is at least 1 other working slave for its master # and so forth. It usually reflects the number of slaves you want for every # master in your cluster. # # Default is 1 (slaves migrate only if their masters remain with at least # one slave). To disable migration just set it to a very large value. # A value of 0 can be set but is useful only for debugging and dangerous # in production. # # cluster-migration-barrier 1 # In order to setup your cluster make sure to read the documentation # available at http://redis.io web site. ################################## SLOW LOG ################################### # The Redis Slow Log is a system to log queries that exceeded a specified # execution time. The execution time does not include the I/O operations # like talking with the client, sending the reply and so forth, # but just the time needed to actually execute the command (this is the only # stage of command execution where the thread is blocked and can not serve # other requests in the meantime). # You can configure the slow log with two parameters: one tells Redis # what is the execution time, in microseconds, to exceed in order for the # command to get logged, and the other parameter is the length of the # slow log. When a new command is logged the oldest one is removed from the # queue of logged commands. # The following time is expressed in microseconds, so 1000000 is equivalent # to one second. Note that a negative number disables the slow log, while # a value of zero forces the logging of every command. slowlog-log-slower-than 10000 # There is no limit to this length. Just be aware that it will consume memory. # You can reclaim memory used by the slow log with SLOWLOG RESET. slowlog-max-len 128 ############################# Event notification ############################## # Redis can notify Pub/Sub clients about events happening in the key space. # This feature is documented at http://redis.io/topics/keyspace-events # # For instance if keyspace events notification is enabled, and a client # performs a DEL operation on key "foo" stored in the Database 0, two # messages will be published via Pub/Sub: # # PUBLISH __keyspace@0__:foo del # PUBLISH __keyevent@0__:del foo # # It is possible to select the events that Redis will notify among a set # of classes. Every class is identified by a single character: # # K Keyspace events, published with __keyspace@<db>__ prefix. # E Keyevent events, published with __keyevent@<db>__ prefix. # g Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ... # $ String commands # l List commands # s Set commands # h Hash commands # z Sorted set commands # x Expired events (events generated every time a key expires) # e Evicted events (events generated when a key is evicted for maxmemory) # A Alias for g$lshzxe, so that the "AKE" string means all the events. # # The "notify-keyspace-events" takes as argument a string that is composed # by zero or multiple characters. The empty string means that notifications # are disabled at all. # # Example: to enable list and generic events, from the point of view of the # event name, use: # # notify-keyspace-events Elg # # Example 2: to get the stream of the expired keys subscribing to channel # name __keyevent@0__:expired use: # # notify-keyspace-events Ex # # By default all notifications are disabled because most users don't need # this feature and the feature has some overhead. Note that if you don't # specify at least one of K or E, no events will be delivered. notify-keyspace-events "" ############################### ADVANCED CONFIG ############################### # Hashes are encoded using a memory efficient data structure when they have a # small number of entries, and the biggest entry does not exceed a given # threshold. These thresholds can be configured using the following directives. hash-max-ziplist-entries 512 hash-max-ziplist-value 64 # Similarly to hashes, small lists are also encoded in a special way in order # to save a lot of space. The special representation is only used when # you are under the following limits: list-max-ziplist-entries 512 list-max-ziplist-value 64 # Sets have a special encoding in just one case: when a set is composed # of just strings that happens to be integers in radix 10 in the range # of 64 bit signed integers. # The following configuration setting sets the limit in the size of the # set in order to use this special memory saving encoding. set-max-intset-entries 512 # Similarly to hashes and lists, sorted sets are also specially encoded in # order to save a lot of space. This encoding is only used when the length and # elements of a sorted set are below the following limits: zset-max-ziplist-entries 128 zset-max-ziplist-value 64 # HyperLogLog sparse representation bytes limit. The limit includes the # 16 bytes header. When an HyperLogLog using the sparse representation crosses # this limit, it is converted into the dense representation. # # A value greater than 16000 is totally useless, since at that point the # dense representation is more memory efficient. # # The suggested value is ~ 3000 in order to have the benefits of # the space efficient encoding without slowing down too much PFADD, # which is O(N) with the sparse encoding. The value can be raised to # ~ 10000 when CPU is not a concern, but space is, and the data set is # composed of many HyperLogLogs with cardinality in the 0 - 15000 range. hll-sparse-max-bytes 3000 # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in # order to help rehashing the main Redis hash table (the one mapping top-level # keys to values). The hash table implementation Redis uses (see dict.c) # performs a lazy rehashing: the more operation you run into a hash table # that is rehashing, the more rehashing "steps" are performed, so if the # server is idle the rehashing is never complete and some more memory is used # by the hash table. # # The default is to use this millisecond 10 times every second in order to # active rehashing the main dictionaries, freeing memory when possible. # # If unsure: # use "activerehashing no" if you have hard latency requirements and it is # not a good thing in your environment that Redis can reply form time to time # to queries with 2 milliseconds delay. # # use "activerehashing yes" if you don't have such hard requirements but # want to free memory asap when possible. activerehashing yes # The client output buffer limits can be used to force disconnection of clients # that are not reading data from the server fast enough for some reason (a # common reason is that a Pub/Sub client can't consume messages as fast as the # publisher can produce them). # The limit can be set differently for the three different classes of clients: # normal -> normal clients # slave -> slave clients and MONITOR clients # pubsub -> clients subscribed to at least one pubsub channel or pattern # # The syntax of every client-output-buffer-limit directive is the following: # # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds> # # A client is immediately disconnected once the hard limit is reached, or if # the soft limit is reached and remains reached for the specified number of # seconds (continuously). # So for instance if the hard limit is 32 megabytes and the soft limit is # 16 megabytes / 10 seconds, the client will get disconnected immediately # if the size of the output buffers reach 32 megabytes, but will also get # disconnected if the client reaches 16 megabytes and continuously overcomes # the limit for 10 seconds. # # By default normal clients are not limited because they don't receive data # without asking (in a push way), but just after a request, so only # asynchronous clients may create a scenario where data is requested faster # than it can read. # # Instead there is a default limit for pubsub and slave clients, since # subscribers and slaves receive data in a push fashion. # # Both the hard or the soft limit can be disabled by setting them to zero. client-output-buffer-limit normal 0 0 0 client-output-buffer-limit slave 256mb 64mb 60 client-output-buffer-limit pubsub 32mb 8mb 60 # Redis calls an internal function to perform many background tasks, like # closing connections of clients in timeout, purging expired keys that are # never requested, and so forth. # # Not all tasks are performed with the same frequency, but Redis checks for # tasks to perform accordingly to the specified "hz" value. # # By default "hz" is set to 10. Raising the value will use more CPU when # Redis is idle, but at the same time will make Redis more responsive when # there are many keys expiring at the same time, and timeouts may be # handled with more precision. # # The range is between 1 and 500, however a value over 100 is usually not # a good idea. Most users should use the default of 10 and raise this up to # 100 only in environments where very low latency is required. hz 10 # When a child rewrites the AOF file, if the following option is enabled # the file will be fsync-ed every 32 MB of data generated. This is useful # in order to commit the file to the disk more incrementally and avoid # big latency spikes. aof-rewrite-incremental-fsync yes
二、redis經常使用命令
進入redis進行操做：
#redis-cli -h 10.0.18.145 -p 6379 10.0.18.145:6379> 也能夠這樣，其實和上面是同樣的 #redis-cli -p 6379 127.0.0.1:6379> 127.0.0.1:6379> exit #退出 127.0.0.1:6379> info #能夠查看全部redis相關的信息 127.0.0.1:6379> help #查看幫助信息 redis-cli 3.0.7 Type: "help @<group>" to get a list of commands in <group> "help <command>" for help on <command> "help <tab>" to get a list of possible help topics "quit" to exit 10.0.18.145:6379> set name curry #設置一個key的值爲curry OK 10.0.18.145:6379> get name #查看一個key的值 "curry" 10.0.18.145:6379> exists name #key存在返回非0 (integer) 1 10.0.18.145:6379> del name #刪除key (integer) 1 10.0.18.145:6379> exists name #key不存在返回0 (integer) 0 10.0.18.145:6379> mset name curry num 30 team golden #同時設置多個key OK 10.0.18.145:6379> get num "30" 10.0.18.145:6379> keys * #查看全部的key，*表示全部，匹配全部字符 1) "name" 2) "num" 3) "team" 10.0.18.145:6379>keys n* #列出以n開頭的全部key 1) "name" 2) "num" 10.0.18.145:6379> keys ??m? #?是匹配一個或者多個單個字符 1) "name" 10.0.18.145:6379> keys t[e]* #[]符號，匹配一個或者多個字符 1) "team" 10.0.18.145:6379> keys t[ebc]* 1) "team" 10.0.18.145:6379> flushdb #慎用此命令，會清除全部的key OK 10.0.18.145:6379> keys * (empty list or set) 10.0.18.145:6379> randomkey #從當前數據庫中隨機返回(不刪除)一個key。 "name" 10.0.18.145:6379> randomkey "name" 10.0.18.145:6379> randomkey "num" 10.0.18.145:6379> randomkey "team" 返回給定key的剩餘生存時間(time to live)(以秒爲單位)，以下： 10.0.18.145:6379> set name james #設置key-name的值爲james OK 10.0.18.145:6379> expire name 30 #過時值30秒 (integer) 1 10.0.18.145:6379> get name #查看key的值 "james" 10.0.18.145:6379> ttl name #查看ttl值，這裏還剩下22秒過時 (integer) 22 10.0.18.145:6379> get name #過了30秒，過時了，值消失了 (nil) 不帶TTL的key 10.0.18.145:6379> set site www.redis.cn OK 10.0.18.145:6379> ttl site (integer) -1 10.0.18.145:6379> ttl www.redis.cn (integer) -2 將當前數據庫(默認爲0)的key移動到給定的數據庫db當中。 10.0.18.145:6379> select 0 #redis默認使用數據庫0，爲了清洗起見，這裏在顯示指定一次 OK 10.0.18.145:6379> set song "secret base - Zone" #設置一個key OK 10.0.18.145:6379> move song 1 #將song 這個key移動到數據庫1 (integer) 1 10.0.18.145:6379> exists song #查看song，返回0，表示已經被移走 (integer) 0 10.0.18.145:6379> select 1 #使用數據庫1 OK 10.0.18.145:6379[1]> exists song #證明song被移到了數據庫1(注意命令提示符變成了"ip:6379[1]"，代表正在使用數據庫1) (integer) 1 10.0.18.145:6379[1]> get song #查看key的值 "secret base - Zone" 重命名key 10.0.18.145:6379[1]> rename song songtest #用法 OK 10.0.18.145:6379[1]> get song (nil) 10.0.18.145:6379[1]> get songtest "secret base - Zone" 注：若是是批量刪除key能夠這樣 redis-cli -p 7000 -h 192.168.10.20 -c del soa:position:*
4、redis數據持久化相關介紹
redis與memcached等緩存系統有一個最大的區別就是能夠按期將內存中的數據保存到硬盤中，以實現數據持久化。
redis實現數據持久化有兩種方式：第一種是RDB快照方式；另一種是AOF方式！
一、RDB持久化
RDB持久化是根據必定的保存規則按期對redis在內存中的數據作一個快照，把快照數據同步到硬盤上，每次的快照文件就是一個保存着redis數據的二進制文件。它也是redis默認的持久化方法。 RDB持久化保存快照文件的過程： a、redis快照啓動後，建立一個當前進程(父進程)的副本(子進程)。 b、父進程繼續接受來自客戶端的命令，子進程將內存中的數據開始同步到硬盤中，保存到一個臨時文件中。 c、子進程完成快照後，快照的臨時文件替換舊的快照文件，並斷開與父進程的鏈接。 RDB持久化配置，在redis.conf中，默認以下： save 900 1 save 300 10 save 60 10000 這是一個保存規則，前面的redis配置文件詳解中有介紹！ 注意：若是不想啓用RDB持久化，將save參數刪除掉或者註釋掉便可！ RDB持久化其餘配置 dir ./ #持久化文件保存目錄，能夠自定義 dbfilename dump.rdb #RDB持久化保存的文件名，也能夠自定義 stop-writes-on-bgsave-error yes #當保存時遇到錯誤（磁盤或者其餘硬件錯誤）是否中止寫入，默認爲yes rdbcompression yes #保存文件時是否啓動壓縮 rdbchecksum yes #是否啓用RDB數據檢驗
二、AOF持久化
AOF持久化是將用戶操做的命令(主要對修改數據的命令，就是除了查詢之外的命令，包括增刪改的命令)保存到一個文本文件中。 AOF持久化配置，在redis.conf中： appendonly yes #默認是no，啓動aof，就修改成yes appendfilename "appendonly.aof" #保存aof持久化的文件名 appendfsync everysec #aof文件同步頻率 注：啓用AOF持久化，並非立刻將內存數據寫到文件中，它是將它寫到硬盤緩存中，而後根據必定頻率同步到文件中 共有三個值可選擇：always表示只要有更新就同步；everysec是每秒種同步一次;no表示不一樣步！ no-appendfsync-on-rewrite no #在不啓用硬盤緩存同步到硬盤文件這個選項時，是否重寫文件，默認爲no， 若是發生redis服務阻塞，將此參數改成yes！ #重寫文件的頻率# auto-aof-rewrite-percentage 100 #第一種表示當文件超過舊文件100%時進行重寫 auto-aof-rewrite-min-size 64mb #第二種表示當文件超過64mb時進行重寫 aof-load-truncated yes #當redis遇到退出時，從新載入時是否加載異常出現時的殘餘數據，默認yes
三、RDB和AOF的比較以及優缺點
RDB優勢： a、RDB是一個很是緊湊(compact)的文件，保存了redis在某個時間點上的數據集，這種文件很是適合用於進行備份 能夠根據本身的需求自定義備份，好比每小時備份一次RDB文件，或者每月的每一天，也備份一個RDB文件。 b、RDB很是適用於災難恢復（disaster recovery）,它只有一個文件，而且內容都很是緊湊，能夠（在加密後）將它傳送到別的服務器。 c、RDB能夠最大化Redis的性能：父進程在保存RDB文件時惟一要作的就是fork出一個子進程，而後這個子進程就會處理接下來的全部保存工做，父進程無須執行任何磁盤 I/O 操做 d、RDB 在恢復大數據集時的速度比 AOF 的恢復速度要快。 RDB缺點： a、若是你沒法接受偶爾的數據丟失，rdb方式不適合你，雖然這種方式能夠自定義不一樣的save point來控制保存rdb文件的頻率 可是，由於RDB文件須要保存整個數據集的狀態，因此它並非一個輕鬆的操做。所以你可能會至少5分鐘才保存一次RDB文件。 在這種狀況下，一旦發生故障停機，你就可能會丟失好幾分鐘的數據。 b、每次保存RDB的時候，Redis都要fork()出一個子進程，並由子進程來進行實際的持久化工做。在數據集比較龐大時，fork()會很是耗時和耗費內存資源 並且形成服務器在某某毫秒內中止處理客戶端；若是數據集很是巨大，而且CPU時間很是緊張的話，那麼這種中止時間甚至可能會更長！ ##### AOF優勢 a、使用AOF持久化會讓Redis變得很是耐久(much more durable)，AOF的默認策略爲每秒鐘fsync一次，在這種配置下Redis仍然能夠保持良好的性能，而且就算髮生故障停機，也最多隻會丟失一秒鐘的數據！ b、AOF文件是一個只進行追加操做的日誌文件(append only log)所以對AOF文件的寫入不須要進行seek,即便日誌由於某些緣由而包含了未寫入完整的命令(好比寫入時磁盤已滿，寫入中途停機，等等),redis-check-aof工具也能夠輕易地修復這種問題. c、Redis能夠在AOF文件體積變得過大時，自動地在後臺對AOF進行重寫：重寫後的新AOF文件包含了恢復當前數據集所需的最小命令集合 d、AOF重寫也須要進行fork()，但不管AOF重寫的執行間隔有多長，數據的耐久性都不會有任何損失。 AOF缺點 a、對於相同的數據集來講，AOF文件的體積一般要大於RDB文件的體積 b、在通常狀況下，每秒fsync的性能依然很是高，而關閉fsync可讓AOF的速度和RDB同樣快，即便在高負荷之下也是如此。 不過在處理巨大的寫入載入時，RDB能夠提供更有保證的最大延遲時間（latency）
四、在生產環境中如何選擇redis的持久化方式
通常來講,若是想達到足以媲美PostgreSQL的數據安全性，你應該同時使用兩種持久化功能。若是你很是關心你的數據,但仍然能夠承受數分鐘之內的數據丟失，那麼你能夠只使用RDB持久化。有不少用戶都只使用AOF持久化，但並不推薦這種方式：由於定時生成RDB快照（snapshot）很是便於進行數據庫備份，而且RDB恢復數據集的速度也要比AOF恢復的速度要快！
五、redis備份相關
注：我在生產環境就是取消配置文件中的save，只保留appendonly！
RDB+AOF的備份方式，以下：
在redis.conf中取消rdb的自動save配置，啓動aof的配置： #save 900 1 #註釋或者刪除 #save 300 10 #save 60 10000 appendonly yes #啓用aof持久化 appendfilename "appendonly.aof" 而後在服務器上定時對RDB數據進行備份（也能夠不備份RDB） #redis-cli save 或者 #能夠每週或者天天執行一次 #redis-cli -h 10.0.9.25 -p 6379 save（指定端口來備份） 若是設置了密碼，能夠添加-a 參數，以下： ./bin/redis-cli -h 10.0.9.25 -a abcd123 -p 6379 save #天天執行一次下面的bgrewriteaof### /usr/local/redis/bin/redis-cli -h host -p 6379 BGREWRITEAOF > /root/backup/log/`date`.log #這個必須執行
補充：
BGREWRITEAOF：執行一個AOF文件重寫操做。重寫會建立一個當前AOF文件的體積優化版本。即便BGREWRITEAOF執行失敗，也不會有任何數據丟失，由於舊的AOF文件在BGREWRITEAOF成功以前不會被修改。重寫操做只會在沒有其餘持久化工做在後臺執行時被觸發，也就是說：若是Redis的子進程正在執行快照的保存工做，那麼AOF重寫的操做會被預約(scheduled)，等到保存工做完成以後再執行AOF重寫。在這種狀況下，BGREWRITEAOF的返回值仍然是OK ，但還會加上一條額外的信息，說明BGREWRITEAOF要等到保存操做完成以後才能執行。在Redis 2.6或以上的版本可使用INFO命令查看BGREWRITEAOF是否被預約。若是已經有別的AOF文件重寫在執行，那麼BGREWRITEAOF返回一個錯誤，而且這個新的BGREWRITEAOF 請求也不會被預約到下次執行。
5、redis簡單優化
一、若是都是內網的服務器，儘可能不要給redis外網ip地址，這樣不安全，容易被掃到
二、修改redis默認6379的端口，這一個端口也是***掃描的對象
三、redis配置文件參數優化：
maxmemory 3GB maxmemory-policy volatile-lru #內存策略 ##配置rename-command避免誤操做## rename-command FLUSHALL "XSFLUSHALL" rename-command FLUSHDB "XSFLUSHDB" rename-command SHUTDOWN "XSSHUTDOWN" rename-command DEBUG "XSDEBUG" rename-command CONFIG "XSCONFIG" rename-command SLAVEOF "XSSLAVEOF"
redis進行中文轉換
192.168.1.43:7000>keys agentServer:houseInfo:agentId_* --列出匹配到的key 192.168.1.43:7000>SMEMBERS "agentServer:houseInfo:agentId_3071" --轉換keys 192.168.1.19:7000> "\xe8\x8b\x8f\xe5\xa0\xa4\xe6\x98\xa5\xe6\x99\x93\xe5\x90\x8d\xe8\x8b\x91 21\xe5\x8f\xb7 1503\xe5\xae\xa4" --查看中文內容 (error) ERR unknown command '蘇堤春曉名苑 21號 1503室' 亂碼問題： 在redis中查看到的key的值是亂碼，形如： 192.168.10.62:7000>hget bdm:cache:3:cityName 3020 "\xe6\x98\x8c\xe5\x90\x89\xe8\x87\xaa\xe6\xb2\xbb\xe5\xb7\x9e" 想把這些亂碼轉換成中文，須要添加--raw 參數進入redis，以下 ./redis-cli --raw -h 192.168.10.62 -p 7000 再次查看：就是中文了 192.168.10.62:7000> hget bdm:cache:3:cityName 3020 昌吉自治州
redis修改key的值：
192.168.10.62:7000> hget bdm:cache:3:longitude 3020 --查看 87.28944100 192.168.10.62:7000> hset bdm:cache:3:longitude 3020 89.69238300 --修改成89.69238300 0 192.168.10.62:7000> hget bdm:cache:3:longitude 3020 --再次查看 89.69238300
四、redis模塊
有時候使用LNAMP環境，須要redis模塊，加入已經配置好了LANMP環境，可是沒有redis模塊，能夠動態添加，以下：
php的redis擴展模塊安裝配置 php-redis客戶端下載地址：https://codeload.github.com/nicolasff/phpredis/zip/master 1.安裝配置 #unzip phpredis-master.zip #cd phpredis-master #/usr/local/php/bin/phpize #./configure --with-php-config=/usr/local/php/bin/php-config #make #make install 2.執行完make install後會生成 #Installing shared extensions: /usr/local/php//lib/php/extensions/no-debug-non-zts-20060613/ 3.修改php.ini vi /usr/local/php/etc/php.ini 查找extension_dir,修改成 extension_dir = "/usr/local/php/lib/php/extensions/no-debug-non-zts-20060613/" #在php配置文件最後一行添加redis.so extension = redis.so 4.重啓apache #service httpd restart 5.檢查redis模塊是否加載。 #php -m |grep redis
6、redis命令行界面修改參數
redis除了能夠在redis.conf中修改參數以外，還能夠在命令行需改
192.168.1.112:7000> config get * 1) "dbfilename" 2) "dump.rdb" 3) "requirepass" 4) "" 5) "masterauth" 6) "" 7) "unixsocket" 8) "" 9) "logfile" 10) "/usr/local/redis/7000/redis.log" 11) "pidfile" 12) "/usr/local/redis/7000/redis.pid" 13) "maxmemory" 14) "943718400" 15) "maxmemory-samples" 16) "5" 17) "timeout" 18) "0" 19) "tcp-keepalive" 20) "0" 21) "auto-aof-rewrite-percentage" 22) "100" 23) "auto-aof-rewrite-min-size" 24) "67108864" 25) "hash-max-ziplist-entries" 26) "512" 27) "hash-max-ziplist-value" 28) "64" 29) "list-max-ziplist-entries" 30) "512" 31) "list-max-ziplist-value" 32) "64" 33) "set-max-intset-entries" 34) "512" 35) "zset-max-ziplist-entries" 36) "128" 37) "zset-max-ziplist-value" 38) "64" 39) "hll-sparse-max-bytes" 40) "3000" 41) "lua-time-limit" 42) "5000" 43) "slowlog-log-slower-than" 44) "10000" 45) "latency-monitor-threshold" 46) "0" 47) "slowlog-max-len" 48) "128" 49) "port" 50) "7000" 51) "tcp-backlog" 52) "511" 53) "databases" 54) "1" 55) "repl-ping-slave-period" 56) "10" 57) "repl-timeout" 58) "60" 59) "repl-backlog-size" 60) "1048576" 61) "repl-backlog-ttl" 62) "3600" 63) "maxclients" 64) "10000" 65) "watchdog-period" 66) "0" 67) "slave-priority" 68) "100" 69) "min-slaves-to-write" 70) "0" 71) "min-slaves-max-lag" 72) "10" 73) "hz" 74) "10" 75) "cluster-node-timeout" 76) "10000" 77) "cluster-migration-barrier" 78) "1" 79) "cluster-slave-validity-factor" 80) "10" 81) "repl-diskless-sync-delay" 82) "5" 83) "cluster-require-full-coverage" 84) "yes" 85) "no-appendfsync-on-rewrite" 86) "no" 87) "slave-serve-stale-data" 88) "yes" 89) "slave-read-only" 90) "yes" 91) "stop-writes-on-bgsave-error" 92) "no" 93) "daemonize" 94) "yes" 95) "rdbcompression" 96) "yes" 97) "rdbchecksum" 98) "yes" 99) "activerehashing" 100) "yes" 101) "repl-disable-tcp-nodelay" 102) "no" 103) "repl-diskless-sync" 104) "no" 105) "aof-rewrite-incremental-fsync" 106) "yes" 107) "aof-load-truncated" 108) "yes" 109) "appendonly" 110) "yes" 111) "dir" 112) "/usr/local/redis/7000" 113) "maxmemory-policy" 114) "volatile-lru" 115) "appendfsync" 116) "everysec" 117) "save" 118) "" 119) "loglevel" 120) "notice" 121) "client-output-buffer-limit" 122) "normal 0 0 0 slave 268435456 67108864 60 pubsub 33554432 8388608 60" 123) "unixsocketperm" 124) "0" 125) "slaveof" 126) "" 127) "notify-keyspace-events" 128) "" 129) "bind" 130) "0.0.0.0" 修改日誌級別： 192.168.1.112:7000> config set loglevel "notice" OK #顯示ok表示set 成功 192.168.1.112:7000> config set maxmemory "943718400" OK #顯示ok表示set 成功
不足之處，請多多指出！
相關文章
- 1. 【redis】1.redis-windows安裝+配置介紹
- 2. 【redis】redis-windows安裝+配置介紹
- 3. 【轉】Redis 的安裝配置介紹
- 4. Redis介紹和安裝配置
- 5. redis 安裝及配置介紹
- 6. redis簡介+安裝+配置
- 7. haproxy安裝配置介紹
- 8. Grafana安裝配置介紹
- 9. Nginx 安裝配置介紹
- 10. Nginx介紹,安裝,配置
- 更多相關文章...
- • Git 安裝配置 - Git 教程
- • Docker 安裝 Redis - Docker教程
- • Composer 安裝與使用
- • Java Agent入門實戰（一）-Instrumentation介紹與使用
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章