centos 下安装redis

安装

[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"

安装完成

二、 配置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

ps -ef|grep redis-server

五、redis开机启动

Vi /etc/rc.d/rc.local

redis-server /usr/local/redis/redis.conf或

echo "redis-server /usr/local/redis/redis.conf" &gt;&gt; /etc/rc.d/rc.local

redis是单线程来处理全部client的请求的

 

实验

下面是个实验,首先清空当前数据库，而后
设置k1,k2.获取时k3对应返回nil
redis&gt; flushdb
OK
redis&gt; dbsize
(integer) 0
redis&gt; set k1 a
OK
redis&gt; set k2 b
OK
redis&gt; 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&gt; set k hello
OK
redis&gt; append k ,world
(integer) 11
redis&gt; get k
"hello,world"
substr key start end 返回截取过的key的字符串值,注意并不修改key的值。下标是从0开始的，接着上面例子
redis&gt; substr k 0 8
"hello,wor"
redis&gt; 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-----&gt;&gt;&gt;【Linux(master 192.168.3159:6379)】<&lt;&lt;--------------------slave----【Linux (slave 192.168.3.169:6381)】&lt;&lt;&lt;&lt;------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 &lt;-> 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&gt; set k_m master
OK
slave端操做:
redis 127.0.0.1:6379&gt; get k_m
“master”

什么是内存文件系统了？就是操做系统把系统内存划出一部分看成硬盘使用。你能够像操做磁盘那样的操做内存。但效率远远比硬盘来的快多了。通俗叫作内存文件系统，只要服务器不重起数据将一直都在。

redis-cli -p 6379 info 查看状态。

操做数据库

插入数据 telnet 127.0.0.1 6379 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这位博主的博客有