存档

‘KV数据库’ 分类的存档

Linux下设置memcached访问IP

2016年12月11日 评论已被关闭

Linux下设置memcached访问IP

http://www.cnblogs.com/longshiyVip/p/5636233.html
在虚拟机上装了memcached,本地访问可以,但从其它机器连这台机器的memcached应用总是报连接失败。防火墙的端口都是打开的。Google了才知道原来需要修改memcached的配置文件,将默认的127.0.0.1地址改成外部可访问的地址。(与Mysql一样的道理)。
我在Ubuntu上apt-get install的配置文件被安装在了

/etc/memcached.conf
修改该文件中将

-l 127.0.0.1
改为本机的IP地址

-l 192.168.1.100
运行

/etc/init.d/memcached restart
重新启动后,从外部就可以访问了。

redis配置文件详解

2015年9月2日 评论已被关闭

redis配置文件详解
http://blog.chinaunix.net/uid-7374279-id-4618784.html
sed ‘s@^[# ].*$@@g’ /usr/local/redis/etc/redis.conf | awk ‘{if (length !=0) print $0}’
1. Redis默认不是以守护进程的方式运行,可以通过该配置项修改,使用yes启用守护进程
daemonize yes
2. 当Redis以守护进程方式运行时,Redis默认会把pid写入/var/run/redis.pid文件,可以通过pidfile指定
pidfile /usr/local/redis/var/redis.pid
3. 指定Redis监听端口,默认端口为6379,作者在自己的一篇博文中解释了为什么选用6379作为默认端口,因为6379在手机按键上MERZ对应的号码,而MERZ取自意大利歌女Alessia Merz的名字。
port 6379
4. 绑定的主机地址
# bind 127.0.0.1
5. 当客户端闲置多长时间后关闭连接,如果指定为0,表示关闭该功能
timeout 0
tcp-keepalive 0
6. 指定日志记录级别,Redis总共支持四个级别:debug、verbose、notice、warning,默认为notice
loglevel notice
7. 日志记录位置,默认为标准输出
logfile /usr/local/redis/var/redis.log
8. 设置数据库的数量,默认数据库为0,可以使用SELECT 命令在连接上指定数据库id
databases 16
9. 指定在多长时间内,有多少次更新操作,就将数据同步到数据文件,可以多个条件配合
save
分别表示900秒(15分钟)内有1个更改,300秒(5分钟)内有10个更改以及60秒内有10000个更改。
Redis默认配置文件中提供了三个条件:
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
10. 指定存储至本地数据库时是否压缩数据,默认为yes,Redis采用LZF压缩,如果为了节省CPU时间,可以关闭该选项,但会导致数据库文件变的巨大
rdbcompression yes
rdbchecksum yes
11. 指定本地数据库文件名,默认值为dump.rdb
dbfilename dump.rdb
12. 指定本地数据库存放目录
dir /usr/local/redis/var
13. 设置当本机为slave服务时,设置master服务的IP地址及端口,在Redis启动时,它会自动从master进行数据同步
# slaveof
14. 当master服务设置了密码保护时,slave服务连接master的密码
# masterauth
15. 设置Redis连接密码,如果配置了连接密码,客户端在连接Redis时需要通过AUTH 命令提供密码,默认关闭
# requirepass foobared
16. 设置同一时间最大客户端连接数,在 Redis2.4 中,最大连接数是被直接硬编码在代码里面的,而在2.6版本中这个值变成可配置的。maxclients 的默认值是 10000,你也可以在 redis.conf 中对这个值进行修改。
当然,这个值只是 Redis 一厢情愿的值,Redis 还会照顾到系统本身对进程使用的文件描述符数量的限制。在启动时 Redis 会检查系统的 soft limit,以查看打开文件描述符的个数上限。如果系统设置的数字,小于咱们希望的最大连接数加32,那么这个 maxclients 的设置将不起作用,Redis 会按系统要求的来设置这个值。(加32是因为 Redis 内部会使用最多32个文件描述符,所以连接能使用的相当于所有能用的描述符号减32)。
当上面说的这种情况发生时(maxclients 设置后不起作用的情况),Redis 的启动过程中将会有相应的日志记录。比如下面命令希望设置最大客户端数量为100000,所以 Redis 需要 100000+32 个文件描述符,而系统的最大文件描述符号设置为10144,所以 Redis 只能将 maxclients 设置为 10144 – 32 = 10112。
# maxclients 10000
17. 指定Redis最大内存限制,Redis在启动时会把数据加载到内存中,达到最大内存后,Redis会先尝试清除已到期或即将到期的Key,当此方法处理 后,仍然到达最大内存设置,将无法再进行写入操作,但仍然可以进行读取操作。Redis新的vm机制,会把Key存放内存,Value会存放在swap区
# maxmemory
slave-serve-stale-data yes
slave-read-only yes
repl-disable-tcp-nodelay no
slave-priority 100
18. 指定是否在每次更新操作后进行日志记录,Redis在默认情况下是异步的把数据写入磁盘,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为Redis本身同步数据文件是按上面slave条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认为no
appendonly no
19. 指定更新日志文件名,默认为appendonly.aof
# appendfilename appendonly.aof
20. 指定更新日志条件,共有3个可选值:
no:表示等操作系统进行数据缓存同步到磁盘(快)
always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢,安全)
everysec:表示每秒同步一次(折衷,默认值)
appendfsync everysec
21. 指定是否启用虚拟内存机制,默认值为no,简单的介绍一下,VM机制将数据分页存放,由Redis将访问量较少的页即冷数据swap到磁盘上,访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析Redis的VM机制)
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都存在于磁盘。
vm-max-memory 0
24. Redis swap文件分成了很多的page,一个对象可以保存在多个page上面,但一个page上不能被多个对象共享,vm-page-size是要根据存储的 数据大小来设定的,作者建议如果存储很多小对象,page大小最好设置为32或者64bytes;如果存储很大大对象,则可以使用更大的page,如果不 确定,就使用默认值
vm-page-size 32
25. 设置swap文件中的page数量,由于页表(一种表示页面空闲或使用的bitmap)是在放在内存中的,,在磁盘上每8个pages将消耗1byte的内存。
vm-pages 134217728
26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4
vm-max-threads 4
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
27. 指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法
hash-max-ziplist-entries 512
hash-max-ziplist-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
28. 指定是否激活重置哈希,默认为开启(后面在介绍Redis的哈希算法时具体介绍)
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
29. 指定包含其它的配置文件,可以在同一主机上多个Redis实例之间使用同一份配置文件,而同时各个实例又拥有自己的特定配置文件
# include /path/to/local.conf

分类: KV数据库 标签:

用unix socket加速php-fpm、mysql、redis的连接

2015年9月2日 评论已被关闭

用unix socket加速php-fpm、mysql、redis的连接
http://jishu.zol.com.cn/2670.html
图虫的服务器长期是单机运行。估计除了mysql之外,php-fpm和redis还可以在单机上共存很长时间。(多说服务器早就达成了单机每日2000万+动态请求,所以我对单机搞定图虫的大流量非常乐观)
如果是单机服务,其实就不需要用IP哪怕是127.0.0.1这样的IP去连接mysql/redis/php了,因为即使是127.0.0.1也是要走TCP/IP层的。
unix提供的unix socket来实现单机的端口访问,很多文章提到用unix socket可以提升连接速度。
我简单测试了一下,200次redis请求的耗时38ms,如果改成unix socket方式,立刻降到27ms。这简直是立竿见影啊,10ms的差距足以让我们有动力把IP方式改成unix socket方式。
Mysql(PDO)启用unix socket的方法
1.在PDO的DSN里面:原来写host:xxx,改成unix_socket:/var/run/mysqld/mysqld.sock (当然你可以在my.cnf里面设置成别的)
2.给mysql的用户名@localhost,设置访问权限。由于unix_socket并不是主机,所以用unix socket方式连接mysql,mysql会强制认为用户是来自于localhost,所以一定要给username@localhost设置权限,而不是username@’%’
redis(phpredis)启用unix socket的方法
1.redis 默认没有开启unix socket,需要在/etc/redis/redis.conf中修改。注意unixsocketperm 777
unixsocket /var/run/redis/redis.sock
unixsocketperm 777
2.用phpredis连接:
$redis->connect(‘/var/run/redis/redis.sock’)
nginx + php-fpm启用unix socket的方法
1.php-fpm 的pool配置文件中:
listen = /var/run/php5-fpm.sock;
2.nginx sites的配置文件中:
fastcgi_pass unix:/var/run/php5-fpm.sock;
由于redis连接次数很多,因此redis使用unix socket的效果最明显,mysql其次,php基本上没有用不用sock都差不多

redis主从的配置和使用

2015年9月2日 评论已被关闭

redis主从的配置和使用
http://blog.chinaunix.net/uid-20498361-id-3202002.html
1, redis配置文件常用选项说明
daemonize no
说明:是否把redis-server启动在后台,默认是“否”。若改成yes,会生成一个pid文件。

pidfile /var/run/redis.pid
说明:redis-server的pid文件。
port 6379
说明:redis-server的端口号

dbfilename dump.rdb
说明:数据库文件的位置,最好添加绝对路径,若不添加时在启动用户的home目录下。
slaveof
说明:设置主从服务器的主服务器的地址和端口。例如:slaveof 192.168.1.1 6379

loglevel verbose
说明:日志级别,有四种,debug,verbose,notice,warning。

logfile stdout
说明:日志的输出文件,默认是标准输出。例如:logfile /tmp/redis.log

2, 主从的安装和配置
2.1 基本环境
假设我有两台机器:
master: 192.168.1.1
slave: 192.168.1.2
.下载
使用的版本是: redis-2.4.13
>cd redis-2.4.13
>make
>sudo make install

2.2 安装主服务器
vim redis.conf
根据自己的需要修改一些参数
.修改磁盘上保存数据库文件的位置:
dbfilename /redisdb/dump.rdb
.修改日志级别
#如果只要输出少量日志的话,可以用waring
loglevel warning
.修改日志文件的位置
logfile /tmp/redis.log

2.3 安装和配置从机
cp redis.conf /etc/redis_slave.conf
vim redis_slave.conf
修改其中的一行
配置master的ip地址和redis-server的端口。
slaveof

3, 启动和测试
主机: redis-server /etc/redis.conf
从机: redis-server /etc/redis_slave.conf
3.1 测试
在主机上启动redis客户端:
ssh 192.168.1.1
redis-cli
>set k1 v1
>get k1
“v1”
.登陆从机,并在从机上启动客户端:
ssh 192.168.1.2
redis-cli
>get k1
“v1”
可以看到redis已经把数据同步过来了。

分类: KV数据库 标签:

Redis学习及实践

2015年9月2日 评论已被关闭

Redis学习及实践
http://www.linuxidc.com/Linux/2014-03/97902.htm
安装+配置

因为最近项目会用到redis,之前在项目中会用到memcached,所以对redis进行了一番研究,这里做一个较详细的整理以供分享!

一、redis介绍

redis 是一个高性能的key-value数据库。 redis的出现,很大程度补偿了memcached这类keyvalue存储的不足,在部分场合可以对关系数据库起到很好的补充作用。它跟memcached类似,不过数据可以持久化,而且支持的数据类型很丰富。有字符串,链表,集合和有序集合。支持在服务器端计算集合的并,交和补集(difference)等,还支持多种排序功能。所以Redis也可以被看成是一个数据结构服务器。

Redis的所有数据都是保存在内存中,然后不定期的通过异步方式保存到磁盘上(这称为“半持久化模式”);也可以把每一次数据变化都写入到一个append only file(aof)里面(这称为“全持久化模式”)。它提供Python,Ruby,Erlang,PHP客户端,使用很方便。问题是这个项目还很新,可能还不足够稳定,而且没有在实际的一些大型系统应用的实例。此外,缺乏mc中批量get也是比较大的问题,始终批量获取跟多次获取的网络开销是不一样的。

性能测试结果:

SET操作每秒钟 110000 次,GET操作每秒钟 81000 次。

二、redis安装
2.1、linux安装
2.1.1、下载安装包
Wget http://redis.googlecode.com/files/redis-2.6.14.tar.gz

(笔者当前的最新版是2.6.14,可以去https://code.google.com/p/redis/downloads/list查看最新版)

1 [root@localhost 4setup]# wget http://redis.googlecode.com/files/redis-2.6.14.tar.gz

2.1.2,安装部署
123 [root@localhost 4setup]# tar xzf redis-2.6.14.tar.gz
[root@localhost 4setup]# cd redis-2.6.14
[root@localhost redis-2.6.14]# make

2.1.3、启动服务
在src目录下,运行redis-server。如果不指定conf文件的话,则按默认配置启动,如果指定conf文件的话则按conf文件的配置启动:
1 ./redis-server ../etc/redis.conf

Redis 服务端的默认连接端口是 6379。
2.1.4、客户端连接
在src目录下,运行redis-cli。比如,连接本机的redis,可用如下命令:
1 ./redis-cli -h 127.0.0.1 -p 6379

2.1.5、查看运行状态
如果在conf文件中设置了“daemonize no”的话,则运行状态信息会在终端直接打印;
如果设置了“daemonize yes”的话,则会以守护进程形式在后台运行,log输出位置则通过conf中的logfile设置,如:logfile /usr/local/redis/var/redis.log
2.1.6、停止redis实例
1 ./redis-cli shutdown

redis.conf文件的详细设置可参考: http://www.linuxidc.com/Linux/2014-03/97901.htm
另外也可参考笔者分享的另一篇文章《谈谈Memcached与Redis》
笔者的单独的简易设置为:
daemonize yes
pidfile /usr/local/redis/var/redis.pid
port 6379
timeout 300
loglevel debug
logfile /usr/local/redis/var/redis.log
databases 16
save 900 1
save 300 10
save 60 10000
rdbcompression yes
dbfilename dump.rdb
dir /usr/local/redis/var/
appendonly no
appendfsync always

2.2、Windows安装
Windows上的安装、配置和Linux类似,甚至更简单,笔者在这就不赘述了,也可以参考以下链接:
http://www.linuxidc.com/Linux/2011-06/37007.htm

三、与memcached的比较
memcache和redis都是内存型数据库,数据保存在内存中,通过tcp直接存取,memcached优势是速度快,并发高,缺点是数据类型有限,查询功能不强,一般用作缓存。在我们团队的项目中,一开始用的是memcached,后来用redis替代。
相比memcached:
1、redis具有持久化机制,可以定期将内存中的数据持久化到硬盘上。
2、redis具备binlog功能,可以将所有操作写入日志,当redis出现故障,可依照binlog进行数据恢复。
3、redis支持virtual memory,可以限定内存使用大小,当数据超过阈值,则通过类似LRU的算法把内存中的最不常用数据保存到硬盘的页面文件中。
4、redis原生支持的数据类型更多,使用的想象空间更大。
5、前面有位朋友所提及的一致性哈希,用在redis的sharding中,一般是在负载非常高需要水平扩展时使用。我们还没有用到这方面的功能,一般的项目,单机足够支撑并发了。redis 3.0将推出cluster,功能更加强大。
详细的对比,可参考笔者分享的另一篇文章《谈谈Memcached与Redis》 http://www.linuxidc.com/Linux/2014-03/97903.htm 。

分类: KV数据库 标签:

Redis配置文件参数说明

2015年9月2日 评论已被关闭

Redis配置文件参数说明

http://www.cnblogs.com/wenanry/archive/2012/02/26/2368398.html

配置文件参数说明:
1. Redis默认不是以守护进程的方式运行,可以通过该配置项修改,使用yes启用守护进程

daemonize no

2. 当Redis以守护进程方式运行时,Redis默认会把pid写入/var/run/redis.pid文件,可以通过pidfile指定

pidfile /var/run/redis.pid

3. 指定Redis监听端口,默认端口为6379,作者在自己的一篇博文中解释了为什么选用6379作为默认端口,因为6379在手机按键上MERZ对应的号码,而MERZ取自意大利歌女Alessia Merz的名字

port 6379

4. 绑定的主机地址

bind 127.0.0.1

5.当 客户端闲置多长时间后关闭连接,如果指定为0,表示关闭该功能

timeout 300

6. 指定日志记录级别,Redis总共支持四个级别:debug、verbose、notice、warning,默认为verbose

loglevel verbose

7. 日志记录方式,默认为标准输出,如果配置Redis为守护进程方式运行,而这里又配置为日志记录方式为标准输出,则日志将会发送给/dev/null

logfile stdout

8. 设置数据库的数量,默认数据库为0,可以使用SELECT <dbid>命令在连接上指定数据库id

databases 16

9. 指定在多长时间内,有多少次更新操作,就将数据同步到数据文件,可以多个条件配合

save <seconds> <changes>

Redis默认配置文件中提供了三个条件:

save 900 1

    save 300 10

    save 60 10000

分别表示900秒(15分钟)内有1个更改,300秒(5分钟)内有10个更改以及60秒内有10000个更改。

 

10. 指定存储至本地数据库时是否压缩数据,默认为yes,Redis采用LZF压缩,如果为了节省CPU时间,可以关闭该选项,但会导致数据库文件变的巨大

rdbcompression yes

11. 指定本地数据库文件名,默认值为dump.rdb

dbfilename dump.rdb

12. 指定本地数据库存放目录

dir ./

13. 设置当本机为slav服务时,设置master服务的IP地址及端口,在Redis启动时,它会自动从master进行数据同步

slaveof <masterip> <masterport>

14. 当master服务设置了密码保护时,slav服务连接master的密码

masterauth <master-password>

15. 设置Redis连接密码,如果配置了连接密码,客户端在连接Redis时需要通过AUTH <password>命令提供密码,默认关闭

requirepass foobared

16. 设置同一时间最大客户端连接数,默认无限制,Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数,如果设置 maxclients 0,表示不作限制。当客户端连接数到达限制时,Redis会关闭新的连接并向客户端返回max number of clients reached错误信息

maxclients 128

17. 指定Redis最大内存限制,Redis在启动时会把数据加载到内存中,达到最大内存后,Redis会先尝试清除已到期或即将到期的Key,当此方法处理 后,仍然到达最大内存设置,将无法再进行写入操作,但仍然可以进行读取操作。Redis新的vm机制,会把Key存放内存,Value会存放在swap区

maxmemory <bytes>

18. 指定是否在每次更新操作后进行日志记录,Redis在默认情况下是异步的把数据写入磁盘,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认为no

appendonly no

19. 指定更新日志文件名,默认为appendonly.aof

appendfilename appendonly.aof

20. 指定更新日志条件,共有3个可选值:
no:表示等操作系统进行数据缓存同步到磁盘(快)
always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢,安全)
everysec:表示每秒同步一次(折衷,默认值)

appendfsync everysec

 

21. 指定是否启用虚拟内存机制,默认值为no,简单的介绍一下,VM机制将数据分页存放,由Redis将访问量较少的页即冷数据swap到磁盘上,访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析Redis的VM机制)

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. Redis swap文件分成了很多的page,一个对象可以保存在多个page上面,但一个page上不能被多个对象共享,vm-page-size是要根据存储的 数据大小来设定的,作者建议如果存储很多小对象,page大小最好设置为32或者64bytes;如果存储很大大对象,则可以使用更大的page,如果不 确定,就使用默认值

vm-page-size 32

25. 设置swap文件中的page数量,由于页表(一种表示页面空闲或使用的bitmap)是在放在内存中的,,在磁盘上每8个pages将消耗1byte的内存。

vm-pages 134217728

26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4

vm-max-threads 4

27. 设置在向客户端应答时,是否把较小的包合并为一个包发送,默认为开启

glueoutputbuf yes

28. 指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法

hash-max-zipmap-entries 64

    hash-max-zipmap-value 512

29. 指定是否激活重置哈希,默认为开启(后面在介绍Redis的哈希算法时具体介绍)

activerehashing yes

30. 指定包含其它的配置文件,可以在同一主机上多个Redis实例之间使用同一份配置文件,而同时各个实例又拥有自己的特定配置文件

include /path/to/local.conf

 

=============================================================
# Redis configuration file example

# Note on units: when memory size is needed, it is possible to specifiy
# it in the usual form of 1k 5GB 4M and so forth:
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.

# By default Redis does not run as a daemon. Use ‘yes’ if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
daemonize yes

# When running daemonized, Redis writes a pid file in /var/run/redis.pid by
# default. You can specify a custom pid file location here.
pidfile /usr/local/redis/run/redis.pid

# Accept connections on the specified port, default is 6379
port 6379

# If you want you can bind a single interface, if the bind option is not
# specified all the interfaces will listen for incoming connections.
#
#bind 192.168.20.12

# Close the connection after a client is idle for N seconds (0 to disable)
timeout 300

# Set server verbosity to ‘debug’
# it can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel verbose

# Specify the log file name. Also ‘stdout’ can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
#logfile stdout
logfile ./logs/redis.log

# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT <dbid> where
# dbid is a number between 0 and ‘databases’-1
databases 16

################################ SNAPSHOTTING  #################################
#
# Save the DB on disk:
#
#   save <seconds> <changes>
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving at all commenting all the “save” lines.

save 900 1
save 300 10
save 60 10000

# Compress string objects using LZF when dump .rdb databases?
# For default that’s set to ‘yes’ as it’s almost always a win.
# If you want to save some CPU in the saving child set it to ‘no’ but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes

# The filename where to dump the DB
dbfilename dump.rdb

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the ‘dbfilename’ configuration directive.
#
# Also the Append Only File will be created inside this directory.
#
# Note that you must specify a directory here, not a file name.
dir ./data/

################################# REPLICATION #################################

# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. Note that the configuration is local to the slave
# so for example it is possible to configure the slave to save the DB with a
# different interval, or to listen to another port, and so on.
#
# slaveof <masterip> <masterport>

# If the master is password protected (using the “requirepass” configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.
#
# masterauth <master-password>

################################## SECURITY ###################################

# 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

################################### LIMITS ####################################

# Set the max number of connected clients at the same time. By default there
# is no limit, and it’s up to the number of file descriptors the Redis process
# is able to open. The special value ‘0’ means no limits.
# Once the limit is reached Redis will close all the new connections sending
# an error ‘max number of clients reached’.
#
# maxclients 128

# Don’t use more memory than the specified amount of bytes.
# When the memory limit is reached Redis will try to remove keys with an
# EXPIRE set. It will try to start freeing keys that are going to expire
# in little time and preserve keys with a longer time to live.
# Redis will also try to remove objects from free lists if possible.
#
# If all this fails, Redis will start to reply with errors to commands
# that will use more memory, like SET, LPUSH, and so on, and will continue
# to reply to most read-only commands like GET.
#
# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
# ‘state’ server or cache, not as a real DB. When Redis is used as a real
# database the memory usage will grow over the weeks, it will be obvious if
# it is going to use too much memory in the long run, and you’ll have the time
# to upgrade. With maxmemory after the limit is reached you’ll start to get
# errors for write operations, and this may even lead to DB inconsistency.
#
# maxmemory <bytes>

############################## APPEND ONLY MODE ###############################

# By default Redis asynchronously dumps the dataset on disk. If you can live
# with the idea that the latest records will be lost if something like a crash
# happens this is the preferred way to run Redis. If instead you care a lot
# about your data and don’t want to that a single record can get lost you should
# enable the append only mode: when this mode is enabled Redis will append
# every write operation received in the file appendonly.aof. This file will
# be read on startup in order to rebuild the full dataset in memory.
#
# Note that you can have both the async dumps and the append only file if you
# like (you have to comment the “save” statements above to disable the dumps).
# Still if append only mode is enabled Redis will load the data from the
# log file at startup ignoring the dump.rdb file.
#
# IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
# log file in background when it gets too big.

appendonly yes

# The name of the append only file (default: “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.
#
# 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 if one second passed since the last fsync. Compromise.
#
# The default is “everysec” 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 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.
#
# If unsure, use “everysec”.

# appendfsync always
appendfsync everysec
# appendfsync no

################################ VIRTUAL MEMORY ###############################

# Virtual Memory allows Redis to work with datasets bigger than the actual
# amount of RAM needed to hold the whole dataset in memory.
# In order to do so very used keys are taken in memory while the other keys
# are swapped into a swap file, similarly to what operating systems do
# with memory pages.
#
# To enable VM just set ‘vm-enabled’ to yes, and set the following three
# VM parameters accordingly to your needs.

vm-enabled no
# vm-enabled yes

# This is the path of the Redis swap file. As you can guess, swap files
# can’t be shared by different Redis instances, so make sure to use a swap
# file for every redis process you are running. Redis will complain if the
# swap file is already in use.
#
# The best kind of storage for the Redis swap file (that’s accessed at random)
# is a Solid State Disk (SSD).
#
# *** WARNING *** if you are using a shared hosting the default of putting
# the swap file under /tmp is not secure. Create a dir with access granted
# only to Redis user and configure Redis to create the swap file there.
vm-swap-file /tmp/redis.swap

# vm-max-memory configures the VM to use at max the specified amount of
# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
# is, if there is still enough contiguous space in the swap file.
#
# With vm-max-memory 0 the system will swap everything it can. Not a good
# default, just specify the max amount of RAM you can in bytes, but it’s
# better to leave some margin. For instance specify an amount of RAM
# that’s more or less between 60 and 80% of your free RAM.
vm-max-memory 0

# Redis swap files is split into pages. An object can be saved using multiple
# contiguous pages, but pages can’t be shared between different objects.
# So if your page is too big, small objects swapped out on disk will waste
# a lot of space. If you page is too small, there is less space in the swap
# file (assuming you configured the same number of total swap file pages).
#
# If you use a lot of small objects, use a page size of 64 or 32 bytes.
# If you use a lot of big objects, use a bigger page size.
# If unsure, use the default :)
vm-page-size 32

# Number of total memory pages in the swap file.
# Given that the page table (a bitmap of free/used pages) is taken in memory,
# every 8 pages on disk will consume 1 byte of RAM.
#
# The total swap size is vm-page-size * vm-pages
#
# With the default of 32-bytes memory pages and 134217728 pages Redis will
# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
#
# It’s better to use the smallest acceptable value for your application,
# but the default is large in order to work in most conditions.
vm-pages 134217728

# Max number of VM I/O threads running at the same time.
# This threads are used to read/write data from/to swap file, since they
# also encode and decode objects from disk to memory or the reverse, a bigger
# number of threads can help with big objects even if they can’t help with
# I/O itself as the physical device may not be able to couple with many
# reads/writes operations at the same time.
#
# The special value of 0 turn off threaded I/O and enables the blocking
# Virtual Memory implementation.
vm-max-threads 4

############################### ADVANCED CONFIG ###############################

# Glue small output buffers together in order to send small replies in a
# single TCP packet. Uses a bit more CPU but most of the times it is a win
# in terms of number of queries per second. Use ‘yes’ if unsure.
glueoutputbuf yes

# Hashes are encoded in a special way (much more memory efficient) when they
# have at max a given numer of elements, and the biggest element does not
# exceed a given threshold. You can configure this limits with the following
# configuration directives.
hash-max-zipmap-entries 64
hash-max-zipmap-value 512

# 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 an hash table
# that is rhashing, 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

################################## INCLUDES ###################################

# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all redis server but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# include /path/to/local.conf
# include /path/to/other.conf

复制代码
分类: KV数据库 标签:

redis配置文件详解

2015年9月2日 评论已被关闭

redis配置文件详解
http://running.iteye.com/blog/2065351

配置文件redis.conf
Xml代码 收藏代码
daemonize yes #—默认值no,该参数用于定制redis服务是否以守护模式运行。—
pidfile /var/run/redis.pid #默认值/var/run/redis.pid,指定redis服务的进程号文件路径,以守护模式运行时需要配置本参数;
port 6379 #默认值6379,指定redis服务的端口
# bind 127.0.0.1 #绑定ip,默认是本机所有网络设备;
timeout 0 #客户端空闲n秒后断开连接;默认是 0 表示不断开。
loglevel notice ###设置服务端的日志级别,有下列几种选择:
debug:记录详细信息,用于开发或调试;
verbose:提供很多有用的信息,但是又不像debug那么详尽,默认就是这一选项;
notice:适度提醒,多用于产品环境;
warning:仅显示重要的警告信息;
logfile “” ##指定日志的输出路径,默认值stdout,表示输出到屏幕,守护模式时则输出到/dev/null;
如果要输出日志到syslog中,可以启动syslog-enabled yes,默认该选项值为no。
# syslog-enabled no
databases 16 ###指定数据库的数量,默认为16个,默认使用的数据库是DB 0。
################################ SNAPSHOTTING ################################
—-以下为快照相关的设置:——
# save <seconds> <changes> ##指定多长时间刷新快照至磁盘,这个选项有两个属性值,只有当两个属性值均满足时才会触发;可以设置多种级别,例如默认的参数文件中就设置了:
save 900 1:每900秒(15分钟)至少一次键值变更时被触发;
save 300 10:每300秒(5分钟)至少10次键值变更时被触发;
save 60 10000:每60秒至少10000次键值变更时被触发;
save 900 1
save 300 10
save 60 10000
rdbcompression yes ##默认值yes,当dump数据库时使用LZF压缩字符串对象,如果CPU资源比较紧张,可以设置为no,选择不压缩;
rdbchecksum yes
# The filename where to dump the DB 数据库文件名
dbfilename dump.rdb ##默认值dump.rdb,dump到文件系统中的文件名
dir /usr/local/redis/db ##默认值./,即当前目录,dump出的数据文件的存储路径;

################################# REPLICATION #################################
—-以下为复制相关的设置,复制默认是不启用的,因此在默认的参数文件下列表参数均被注释—-
# slaveof <masterip> <masterport> ##指定主端ip和端口,用于创建一个镜像服务
# masterauth <master-password> ##如果master配置了密码的话,此处也需做设置;
slave-serve-stale-data yes ##默认值yes。当slave丢失与master端的连接,或者复制仍在处理,那么slave会有下列两种表现:
当本参数值为yes时,slave为继续响应客户端请求,尽管数据已不同步甚至没有数据(出现在初次同步的情况下);
当本参数值为no时,slave会返回”SYNC with master in progreee”的错误信息;
slave-read-only yes ##默认从Redis是只读模式
# repl-ping-slave-period 10 ###默认值10,指定slave定期ping master的周期;
# repl-timeout 60 ##默认值60,指定超时时间。注意本参数包括批量传输数据和ping响应的时间。

################################## SECURITY ###################################
——以下为安全相关的设置——
# requirepass foobared ###指定一个密码,客户端连接时也需要通过密码才能成功连接;
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52 ###重定义命令,例如将CONFIG命令更名为一个很复杂的名字:
# rename-command CONFIG “” 取消这个命令;

################################### LIMITS ####################################
—–以下为资源限制方面的设置——
# maxclients 10000 ##指定客户端的最大并发连接数,默认是没有限制,直到redis无法创建新的进程为止,设置该参数值为0也表示不限制,如果该参数指定了值,当并发连接达到指定值时,redis会关闭所有新连接,并返回’max number of clients reached’的错误信息;
# maxmemory <bytes> ###设置redis最大可使用内存。当达到最大内存后,redis会尝试按照设置的回收策略删除键值。如果无法删除键值,或者保留策略设置为不清除,那么redis就会向发出内存的请求返回错误信息。当把redis做为一级LRU的缓存时本参数较为有用。
# maxmemory-policy volatile-lru ###默认值volatile-lru,指定清除策略,有下列几种方法:
volatile-lru -> remove the key with an expire set using an LRU algorithm
allkeys-lru -> remove any key accordingly to the LRU algorithm
volatile-random -> remove a random key with an expire set
allkeys->random -> remove a random key, any key
volatile-ttl -> remove the key with the nearest expire time (minor TTL)
noeviction -> don’t expire at all, just return an error on write operations
# maxmemory-samples 3 ###默认值3,LRU和最小TTL策略并非严谨的策略,而是大约估算的方式,因此可以选择取样值以便检查。

############################## APPEND ONLY MODE ###############################
—–以下为APPEND的配置—-
ONLY模式的设置,默认情况下redis采用异步方式dump数据到磁盘上,极端情况下这可能会导致丢失部分数据(比如服务器突然宕机),如果数据比较重要,不希望丢失,可以启用直写的模式,这种模式下redis会将所有接收到的写操作同步到appendonly.aof文件中,该文件会在redis服务启动时在内存中重建所有数据。注意这种模式对性能影响非常之大。
appendonly no ##默认值no,指定是否启用直写模式;
# appendfilename appendonly.aof ###直写模式的默认文件名appendonly.aof
appendfsync:调用fsync()方式让操作系统写数据到磁盘上,数据同步方式,有下列几种模式:
always:每次都调用,比如安全,但速度最慢;
everysec:每秒同步,这也是默认方式;
no:不调用fsync,由操作系统决定何时同步,比如快的模式;
no-appendfsync-on-rewrite:默认值no。当AOF fsync策略设置为always或everysec,后台保存进程会执行大量的I/O操作。某些linux配置下redis可能会阻塞过多的fsync()调用。
auto-aof-rewrite-percentage:默认值100
auto-aof-rewrite-min-size:默认值64mb
# appendfsync always
appendfsync everysec
# appendfsync no

############################### ADVANCED CONFIG ###############################
—–以下为高级配置相关的设置—-
hash-max-zipmap-entries:默认值512,当某个map的元素个数达到最大值,但是其中最大元素的长度没有达到设定阀值时,其HASH的编码采用一种特殊的方式(更有效利用内存)。本参数与下面的参数组合使用来设置这两项阀值。设置元素个数;
hash-max-zipmap-value:默认值64,设置map中元素的值的最大长度;这两个
list-max-ziplist-entries:默认值512,与hash类似,满足条件的list数组也会采用特殊的方式以节省空间。
list-max-ziplist-value:默认值64
set-max-intset-entries:默认值512,当set类型中的数据都是数值类型,并且set中整型元素的数量不超过指定值时,使用特殊的编码方式。
zset-max-ziplist-entries:默认值128,与hash和list类似。
zset-max-ziplist-value:默认值64
activerehashing:默认值yes,用来控制是否自动重建hash。Active rehashing每100微秒使用1微秒cpu时间排序,以重组Redis的hash表。重建是通过一种lazy方式,写入hash表的操作越多,需要执行rehashing的步骤也越多,如果服务器当前空闲,那么rehashing操作会一直执行。如果对实时性要求较高,难以接受redis时不时出现的2微秒的延迟,则可以设置activerehashing为no,否则建议设置为yes,以节省内存空间。

建议修改的地方
假设redis实例名name
Java代码 收藏代码
1.pidfile /var/run/${name}.pid
2.port 6379 #不能重复
3.logfile /opt/logs/redis/${name}/stdout.log
4.dir /opt/workspace/redis/${name}

分类: KV数据库 标签:

Redis用户添加、分页、登录、注册、加关注案例

2015年3月7日 评论已被关闭

Redis用户添加、分页、登录、注册、加关注案例

http://www.cnblogs.com/jiqing9006/p/3657480.html
连接redis代码redis.php
复制代码
<?php
//实例化
$redis = new Redis();
//连接服务器
$redis->connect(“localhost”);
//授权
$redis->auth(“lamplijie”);

复制代码

说明:这是入口文件,使用redis数据库必须先引入它。这样才能用php操作redis数据库。

列表页list.php
复制代码
<a href=”add.php”>注册</a>
<?php
require(“redis.php”);
if(!empty($_COOKIE[‘auth’])){
$id = $redis->get(“auth:”.$_COOKIE[‘auth’]);
$name = $redis->hget(“user:”.$id,”username”);
?>
欢迎您,<?php echo $name?>,<a href=”logout.php”>退出</a>

<?php
}else{
?>

<a href=”login.php”>登陆</a>
<?php
}
//用户总数
$count = $redis->lsize(“uid”);

//页大小
$page_size = 3;

//当前页码
$page_num = (!empty($_GET[‘page’]))?$_GET[‘page’]:1;

//页总数
$page_count = ceil($count/$page_size);

$ids = $redis->lrange(“uid”,($page_num-1)*$page_size,(($page_num-1)*$page_size+$page_size-1));

//var_dump($ids);

/*for($i=1;$i<=($redis->get(“userid”));$i++){
$data[] = $redis->hgetall(“user:”.$i);
}*/
foreach($ids as $v){
$data[] = $redis->hgetall(“user:”.$v);
}
//var_dump($data);
//$data = array_filter($data);
?>
<table border=1>
<tr>
<th>uid</th>
<th>username</th>
<th>age</th>
<th>操作</th>
<tr>
<?php foreach($data as $v){?>
<tr>
<td><?php echo $v[‘uid’]?></td>
<td><?php echo $v[‘username’]?></td>
<td><?php echo $v[‘age’]?></td>
<td><a href=”del.php?id=<?php echo $v[‘uid’]?>”>删除</a> <a href=”mod.php?id=<?php echo $v[‘uid’]?>”>编辑</a>

<?php if(!empty($_COOKIE[‘auth’])&&$id!=$v[‘uid’]){?>
<a href=”addfans.php?id=<?php echo $v[‘uid’]?>&uid=<?php echo $id?>”>加关注</a></td>
<?php }?>
</tr>
<?php }?>
<tr>
<td colspan=”4″>
<a href=”?page=<?php echo (($page_num-1)<=1)?1:($page_num-1) ?>”>上一页</a>
<a href=”?page=<?php echo (($page_num+1)>=$page_count)?$page_count:($page_num+1) ?>”>下一页</a>
<a href=”?page=1″>首页</a>
<a href=”?page=<?php echo $page_count?>”>尾页</a>
当前<?php echo $page_num?>页
总共<?php echo $page_count?>页
总共<?php echo $count?>个用户
</td>
</tr>
</table>

<table border=1>
<caption>我关注了谁</caption>
<?php
$data = $redis->smembers(“user:”.$id.”:following”);
foreach($data as $v){
$row = $redis->hgetall(“user:”.$v);
?>
<tr>
<td><?php echo $row[‘uid’]?></td>
<td><?php echo $row[‘username’]?></td>
<td><?php echo $row[‘age’]?></td>
</tr>
<?php
}
?>
</table>

<table border=1>
<caption>我的粉丝</caption>
<?php
$data = $redis->smembers(“user:”.$id.”:followers”);
foreach($data as $v){
$row = $redis->hgetall(“user:”.$v);
?>
<tr>
<td><?php echo $row[‘uid’]?></td>
<td><?php echo $row[‘username’]?></td>
<td><?php echo $row[‘age’]?></td>
</tr>
<?php
}
?>
</table>

复制代码

说明:相关功能和连接都在这里体现出来

添加静态页add.php
复制代码
<form action=”reg.php” method=”post”>
用户名:<input type=”text” name=”username” /><br />
密码:<input type=”password” name=”password” /><br />
年龄:<input type=”text” name=”age” /><br />
<input type=”submit” value=”注册” />
<input type=”reset” value=”重新填写” />
</form>

复制代码

说明:注册页面,很简洁,提供用户名,密码等让用户注册。完了到reg页面中保存处理。

处理添加页reg.php
复制代码
<?php
require(“redis.php”);
$username = $_POST[‘username’];
$password = md5($_POST[‘password’]);
$age = $_POST[‘age’];
$uid = $redis->incr(“userid”);
$redis->hmset(“user:”.$uid,array(“uid”=>$uid,”username”=>$username,”password”=>$password,”age”=>$age));
$redis->rpush(“uid”,$uid);
$redis->set(“username:”.$username,$uid);
header(“location:list.php”);

复制代码

说明:注册成功后,也就是添加成功后跳转到list页面,这是一般的流程,在这里有所体现。这里是选择用hash来保存用户信息,类似于sql中的表。同时将id保存到队列中,方便分页的时候统计个数。

修改静态页mod.php
复制代码
<?php
require(“redis.php”);
$uid = $_GET[‘id’];
$data = $redis->hgetall(“user:”.$uid);
?>
<form action=”doedit.php” method=”post”>
<input type=”hidden” value=”<?php echo $data[‘uid’]?>” name=”uid” />
用户名:<input type=”text” name=”username” value=”<?php echo $data[‘username’]?>” /><br />
年龄:<input type=”text” name=”age” value=”<?php echo $data[‘age’]?>” /><br />
<input type=”submit” value=”修改” />
<input type=”reset” value=”重新填写” />
</form>

复制代码

说明:修改页面,首先获取id,用了hgetall方法,获取用户信息并展示出来。

处理添加信息页doedit.php
复制代码
<?php
require(“redis.php”);
$uid = $_POST[‘uid’];
$username = $_POST[‘username’];
$age = $_POST[‘age’];
$a = $redis->hmset(“user:”.$uid,array(“username”=>$username,”age”=>$age));
if($a){
header(“location:list.php”);
}else{
header(“location:mod.php?id=”.$uid);
}

复制代码

说明:通过post获取信息,并且修改之hmset,修改成功进行跳转。

删除页del.php

<?php
require(“redis.php”);
$uid = $_GET[‘id’];
$redis->del(“user:”.$uid);
$redis->lrem(“uid”,$uid);
header(“location:list.php”);

说明:删除hash表中的数据,和队列中的数据。

登录页login.php
复制代码
<?php
require(“redis.php”);
$username = $_POST[‘username’];
$pass = $_POST[‘password’];
$id = $redis->get(“username:”.$username);
if(!empty($id)){
$password = $redis->hget(“user:”.$id,”password”);
if(md5($pass) == $password){
$auth = md5(time().$username.rand());
$redis->set(“auth:”.$auth,$id);
setcookie(“auth”,$auth,time()+86400);
header(“location:list.php”);
}
}
?>
<form action=”” method=”post”>
用户名:<input type=”text” name=”username” /><br />
密码:<input type=”password” name=”password” /><br />
<input type=”submit” value=”登陆” />
</form>

复制代码

说明:获取数据并判断用户名是否存在,以及密码是否正确,如果正确,保存到cookie中。

登出页logout.php

<?php
setcookie(“auth”,””,time()-1);
header(“location:list.php”);

说明:清除cookie中的数据。

添加粉丝页addfans.php
复制代码
<?php
$id = $_GET[‘id’];
$uid = $_GET[‘uid’];
require(“redis.php”);
$redis->sadd(“user:”.$uid.”:following”,$id);
$redis->sadd(“user:”.$id.”:followers”,$uid);
header(“location:list.php”);

复制代码

说明:一切都跟uid关联起来,这里的关注与粉丝用集合来存储。非常的合理。

小结:redis的使用,需要转变思维。它与传统的数据库还是有区别的,要能够巧妙的使用它的存储数据的几种类型。string、hash、list、set等等。来实现相关的功能。

分类: KV数据库 标签:

高性能Nosql数据库Tokyo Cabinet的兄弟Kyoto Cabinet介绍

2015年1月28日 评论已被关闭

高性能Nosql数据库Tokyo Cabinet的兄弟Kyoto Cabinet介绍

 http://www.cnblogs.com/sunli/archive/2010/04/24/1719531.html

      话说高性能的Tokyo Cabinet的兄弟,那性能肯定是不错。官方网站:http://1978th.net/kyotocabinet/

Kyoto Cabinet是一个key-value数据库管理程序的library ,key和value都可以使二进制或者字符串格式。数据存储存分hash和b+ tree模式。

Kyoto Cabinet非常快,在hash模式下,插入100万数据只要0.9秒,在b+ tree模式下只要1.1秒。查询200万条数据也只需要1秒。并且Kyoto Cabinet的数据文件占用的空间也非常小。Kyoto Cabinet的可伸缩性也是非常好的,数据库文件可以达到8EB。(1EB=1024PB,1PB=1024TB)。这比bdb的可管理256tb的数据要大得多了吧。

Kyoto Cabinet提供C++, C, and Ruby的API,可惜没有php和java和C#的。

Kyoto Cabinet跟Tokyo Cabinet比:

1.文件占用的空间更小

2.在多线程下,性能更好。作者说,单线程下Tokyo Cabinet的性能更好。

3.支持windows系统

作者很强悍,很可能还会提供Kyoto  Tyrant的网络接口。

 

新浪微博:http://t.sina.com.cn/sunli1223
分类: KV数据库 标签:

请注意Tokyo Tyrant (ttserver)在大数据量下的不稳定

2015年1月28日 评论已被关闭

请注意Tokyo Tyrant (ttserver)在大数据量下的不稳定

http://www.cnblogs.com/sunli/archive/2010/06/20/1761412.html

[文章作者:孙立 链接:http://www.cnblogs.com/sunli/ 更新时间:2010-06-20]

ttserver不稳定案例

1. CMS a系统的文章采用了ttserver存储。在数据达到30多G的时候,经常出现写入失败,还出现了几次意外崩溃,无法重启成功,只得从slave恢复数据。

2.CMS b系统的图片使用ttserver存储,在数据导到65G的时候出现无法写入的情况,重启后问题依旧,只得从slave重新恢复数据重启。

3.BBS系统采用ttserver做缓存,设计上采用如果没有更新,那么缓存永久存在的策略。在数据达到65GB,数据条数在700多万条的时候,出现大量写入失败的情况,系统负载开始上升,日志出现大量do_mc_set: operation failed。当然这里作为缓存比较好处理,删掉,重新建个新的就OK。(注:启动参数data.tch#bnum=10000000#xmsiz=434217728#rcnum=20000)

测试中ttserver写入表现不稳定

1.#bum=10000000

插入940多万数据(一条7.2k)时出现崩溃(测了两次都一样,看起来好像内部出现了死锁,连上后,无法进行任何响应,没有任何操作时,也占了大量CPU)。越到后面插入的qps(每秒响应数)越小。而且波动比较大。

#bum=100000000

可以顺利插入上千万的数据,但是越到后面qps越小。越到后面插入的qps(每秒响应数)越小。而且波动比较大。

2.跟其他的nosql(mongodb,bdb je,cassandra)对比测试,在写入上,ttserver是表现最不稳定的,其他的nosql都非常好。

总结和注意

1.经过对Tokyo Cabinet 的测试,同样跟ttserver一样,所以应该是Tokyo Cabinet 导致的不稳定。在选择btree方式存储时,随着数据量的增加一样不稳定。在优化参数上也做了各种尝试。

2.ttserver在性能的表现上非常不俗,特别是内存占用和cpu占用都很低,能同时响应上万的并发。但是你应该注意,他一般在数据导到20G以上就会出现不稳定情况。

所以用ttserver来存储单条比较小的数据非常好,存储大文本或者大的二进制文件,由于空间占用上升很快,很快就会变得不稳定。

3.注意备份,使用master-slave是个非常好的主意,在ttserver崩溃导致文件损坏或者其他什么原因无法启动时,你可以从slave 拷贝数据文件来进行恢复。

4.如果你一定要使用ttserver,建议对数据进行分片(sharding)存储,或者你自己使用一个网络接口,底层使用Tokyo Cabinet 来进行分片存储。

5.以上只是个人在使用中遇到的情况,本人正在尝试在存储大文本的ttserver进行替换掉。

新浪微博:http://t.sina.com.cn/sunli1223
分类: KV数据库 标签: