一、 Redis部署

1、 安装redis

wget http://redis.googlecode.com/files/redis-2.2.8.tar.gz

tar zxvf redis-2.2.8.tar.gz 

mv redis-2.2.8 /usr/local/redis 

cd /usr/local/redis 

make && make install

make命令执行完成后,会在src目录下生成5个可执行文件,分别是redis-server、redis-cli、redis-benchmark、redis-check-aof、redis-check-dump,它们的作用如下:
redis-server:Redis服务器的daemon启动程序
redis-cli:Redis命令行操作工具。当然,你也可以用telnet根据其纯文本协议来操作。
redis-benchmark:Redis性能测试工具,测试Redis在你的系统及你的配置下的读写性能。
redis-check-aof:更新日志检查

redis-check-dump:用于本地数据库检查

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

ps -ef|grep redis-server

5、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&gt; set name wwl

OK

设置一个key-value对

查询数据

127.0.0.1:6379&gt; get name "wwl"

取出key所对应的value

删除键值

127.0.0.1:6379&gt; del name

删除这个key及对应的value

验证键是否存在 127.0.0.1:6379&gt; exists name (integer) 0

其中0,代表此key不存在;1代表存在