1061人阅读
# Redis示例配置文件
# 注意单位问题：当需要设置内存大小的时候，可以使用类似1k、5GB、4M这样的常见格式：
# 1k =& 1000 bytes
# 1kb =& 1024 bytes
# 1m =& 1000000 bytes
# 1gb =& 24 bytes
# 单位是大小写不敏感的，所以1GB 1Gb 1gB的写法都是完全一样的。
# Redis默认是不作为守护进程来运行的。你可以把这个设置为&yes&让它作为守护进程来运行。
# 注意，当作为守护进程的时候，Redis会把进程ID写到 /var/run/redis.pid
daemonize no
# 当以守护进程方式运行的时候，Redis会把进程ID默认写到 /var/run/redis.pid。你可以在这里修改路径。
pidfile /var/run/redis.pid
# 接受连接的特定端口，默认是6379。
# 如果端口设置为0，Redis就不会监听TCP套接字。
# 如果你想的话，你可以绑定单一接口；如果这里没单独设置，那么所有接口的连接都会被监听。
# bind 127.0.0.1
# 指定用来监听连接的unxi套接字的路径。这个没有默认值，所以如果你不指定的话，Redis就不会通过unix套接字来监听。
# unixsocket /tmp/redis.sock
# unixsocketperm 755
#一个客户端空闲多少秒后关闭连接。(0代表禁用，永不关闭)
# 设置服务器调试等级。
# 可能值：
# debug （很多信息，对开发/测试有用）
# verbose （很多精简的有用信息，但是不像debug等级那么多）
# notice （适量的信息，基本上是你生产环境中需要的程度）
# warning （只有很重要/严重的信息会记录下来）
loglevel verbose
# 指明日志文件名。也可以使用&stdout&来强制让Redis把日志信息写到标准输出上。
# 注意：如果Redis以守护进程方式运行，而你设置日志显示到标准输出的话，那么日志会发送到 /dev/null
logfile stdout
# 要使用系统日志记录器很简单，只要设置 &syslog-enabled& 为 &yes& 就可以了。
# 然后根据需要设置其他一些syslog参数就可以了。
# syslog-enabled no
# 指明syslog身份
# syslog-ident redis
# 指明syslog的设备。必须是一个用户或者是 LOCAL0 ~ LOCAL7 之一。
# syslog-facility local0
# 设置数据库个数。默认数据库是 DB 0，你可以通过SELECT &dbid& WHERE dbid（0～'databases' - 1）来为每个连接使用不同的数据库。
databases 16
################################ 快照 #################################
# 把数据库存到磁盘上:
save &seconds& &changes&
会在指定秒数和数据变化次数之后把数据库写到磁盘上。
下面的例子将会进行把数据写入磁盘的操作:
900秒（15分钟）之后，且至少1次变更
300秒（5分钟）之后，且至少10次变更
60秒之后，且至少10000次变更
注意：你要想不写磁盘的话就把所有 &save& 设置注释掉就行了。
save 900 1
save 300 10
save 60 10000
# 当导出到 .rdb 数据库时是否用LZF压缩字符串对象。
# 默认设置为 &yes&，所以几乎总是生效的。
# 如果你想节省CPU的话你可以把这个设置为 &no&，但是如果你有可压缩的key的话，那数据文件就会更大了。
rdbcompression yes
# 数据库的文件名
dbfilename dump.rdb
# 工作目录
# 数据库会写到这个目录下，文件名就是上面的 &dbfilename& 的值。
# 累加文件也放这里。
# 注意你这里指定的必须是目录，不是文件名。
################################# 同步 #################################
# 主从同步。通过 slaveof 配置来实现Redis实例的备份。
# 注意，这里是本地从远端复制数据。也就是说，本地可以有不同的数据库文件、绑定不同的IP、监听不同的端口。
# slaveof &masterip& &masterport&
# 如果master设置了密码（通过下面的 &requirepass& 选项来配置），那么slave在开始同步之前必须进行身份验证，否则它的同步请求会被拒绝。
# masterauth &master-password&
# 当一个slave失去和master的连接，或者同步正在进行中，slave的行为有两种可能：
# 1) 如果 slave-serve-stale-data 设置为 &yes& (默认值)，slave会继续响应客户端请求，可能是正常数据，也可能是还没获得值的空数据。
# 2) 如果 slave-serve-stale-data 设置为 &no&，slave会回复&正在从master同步（SYNC with master in progress）&来处理各种请求，除了 INFO 和 SLAVEOF 命令。
slave-serve-stale-data yes
# slave根据指定的时间间隔向服务器发送ping请求。
# 时间间隔可以通过 repl_ping_slave_period 来设置。
# 默认10秒。
# repl-ping-slave-period 10
# 下面的选项设置了大块数据I/O、向master请求数据和ping响应的过期时间。
# 默认值60秒。
# 一个很重要的事情是：确保这个值比 repl-ping-slave-period 大，否则master和slave之间的传输过期时间比预想的要短。
# repl-timeout 60
################################## 安全 ###################################
# 要求客户端在处理任何命令时都要验证身份和密码。
# 这在你信不过来访者时很有用。
# 为了向后兼容的话，这段应该注释掉。而且大多数人不需要身份验证（例如：它们运行在自己的服务器上。）
# 警告：因为Redis太快了，所以居心不良的人可以每秒尝试150k的密码来试图破解密码。
# 这意味着你需要一个高强度的密码，否则破解太容易了。
# requirepass foobared
# 命令重命名
# 在共享环境下，可以为危险命令改变名字。比如，你可以为 CONFIG 改个其他不太容易猜到的名字，这样你自己仍然可以使用，而别人却没法做坏事了。
# rename-command CONFIG b840fc02dcc15f59e41cb7be6c52
# 甚至也可以通过给命令赋值一个空字符串来完全禁用这条命令：
# rename-command CONFIG &&
################################### 限制 ####################################
# 设置最多同时连接客户端数量。
# 默认没有限制，这个关系到Redis进程能够打开的文件描述符数量。
# 特殊值&0&表示没有限制。
# 一旦达到这个限制，Redis会关闭所有新连接并发送错误&达到最大用户数上限（max number of clients reached）&
# maxclients 128
# 不要用比设置的上限更多的内存。一旦内存使用达到上限，Redis会根据选定的回收策略（参见：maxmemmory-policy）删除key。
# 如果因为删除策略问题Redis无法删除key，或者策略设置为 &noeviction&，Redis会回复需要更多内存的错误信息给命令。
# 例如，SET,LPUSH等等。但是会继续合理响应只读命令，比如：GET。
# 在使用Redis作为LRU缓存，或者为实例设置了硬性内存限制的时候（使用 &noeviction& 策略）的时候，这个选项还是满有用的。
# 警告：当一堆slave连上达到内存上限的实例的时候，响应slave需要的输出缓存所需内存不计算在使用内存当中。
# 这样当请求一个删除掉的key的时候就不会触发网络问题／重新同步的事件，然后slave就会收到一堆删除指令，直到数据库空了为止。
# 简而言之，如果你有slave连上一个master的话，那建议你把master内存限制设小点儿，确保有足够的系统内存用作输出缓存。
# （如果策略设置为&noeviction&的话就不无所谓了）
# maxmemory &bytes&
# 内存策略：如果达到内存限制了，Redis如何删除key。你可以在下面五个策略里面选：
# volatile-lru -& 根据LRU算法生成的过期时间来删除。
# allkeys-lru -& 根据LRU算法删除任何key。
# volatile-random -& 根据过期设置来随机删除key。
# allkeys-&random -& 无差别随机删。
# volatile-ttl -& 根据最近过期时间来删除（辅以TTL）
# noeviction -& 谁也不删，直接在写操作时返回错误。
# 注意：对所有策略来说，如果Redis找不到合适的可以删除的key都会在写操作时返回一个错误。
这里涉及的命令：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
# 默认值如下：
# maxmemory-policy volatile-lru
# LRU和最小TTL算法的实现都不是很精确，但是很接近（为了省内存），所以你可以用样例做测试。
# 例如：默认Redis会检查三个key然后取最旧的那个，你可以通过下面的配置项来设置样本的个数。
# maxmemory-samples 3
############################## 纯累加模式 ###############################
# 默认情况下，Redis是异步的把数据导出到磁盘上。这种情况下，当Redis挂掉的时候，最新的数据就丢了。
# 如果不希望丢掉任何一条数据的话就该用纯累加模式：一旦开启这个模式，Redis会把每次写入的数据在接收后都写入 appendonly.aof 文件。
# 每次启动时Redis都会把这个文件的数据读入内存里。
# 注意，异步导出的数据库文件和纯累加文件可以并存（你得把上面所有&save&设置都注释掉，关掉导出机制）。
# 如果纯累加模式开启了，那么Redis会在启动时载入日志文件而忽略导出的 dump.rdb 文件。
# 重要：查看 BGREWRITEAOF 来了解当累加日志文件太大了之后，怎么在后台重新处理这个日志文件。
appendonly no
# 纯累加文件名字（默认：&appendonly.aof&）
# appendfilename appendonly.aof
# fsync() 请求操作系统马上把数据写到磁盘上，不要再等了。
# 有些操作系统会真的把数据马上刷到磁盘上；有些则要磨蹭一下，但是会尽快去做。
# Redis支持三种不同的模式：
# no：不要立刻刷，只有在操作系统需要刷的时候再刷。比较快。
# always：每次写操作都立刻写入到aof文件。慢，但是最安全。
# everysec：每秒写一次。折衷方案。
# 默认的 &everysec& 通常来说能在速度和数据安全性之间取得比较好的平衡。
# 如果你真的理解了这个意味着什么，那么设置&no&可以获得更好的性能表现（如果丢数据的话，则只能拿到一个不是很新的快照）；
# 或者相反的，你选择 &always& 来牺牲速度确保数据安全、完整。
# 如果拿不准，就用 &everysec&
# appendfsync always
appendfsync everysec
# appendfsync no
# 如果AOF的同步策略设置成 &always& 或者 &everysec&，那么后台的存储进程（后台存储或写入AOF日志）会产生很多磁盘I/O开销。
# 某些Linux的配置下会使Redis因为 fsync() 而阻塞很久。
# 注意，目前对这个情况还没有完美修正，甚至不同线程的 fsync() 会阻塞我们的 write(2) 请求。
# 为了缓解这个问题，可以用下面这个选项。它可以在 BGSAVE 或 BGREWRITEAOF 处理时阻止 fsync()。
# 这就意味着如果有子进程在进行保存操作，那么Redis就处于&不可同步&的状态。
# 这实际上是说，在最差的情况下可能会丢掉30秒钟的日志数据。（默认Linux设定）
# 如果你有延迟的问题那就把这个设为 &yes&，否则就保持 &no&，这是保存持久数据的最安全的方式。
no-appendfsync-on-rewrite no
# 自动重写AOF文件
# 如果AOF日志文件大到指定百分比，Redis能够通过 BGREWRITEAOF 自动重写AOF日志文件。
# 工作原理：Redis记住上次重写时AOF日志的大小（或者重启后没有写操作的话，那就直接用此时的AOF文件），
基准尺寸和当前尺寸做比较。如果当前尺寸超过指定比例，就会触发重写操作。
# 你还需要指定被重写日志的最小尺寸，这样避免了达到约定百分比但尺寸仍然很小的情况还要重写。
# 指定百分比为0会禁用AOF自动重写特性。
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
################################## 慢查询日志 ###################################
# Redis慢查询日志可以记录超过指定时间的查询。运行时间不包括各种I/O时间。
# 例如：连接客户端，发送响应数据等。只计算命令运行的实际时间（这是唯一一种命令运行线程阻塞而无法同时为其他请求服务的场景）
# 你可以为慢查询日志配置两个参数：一个是超标时间，单位为微妙，记录超过个时间的命令。
# 另一个是慢查询日志长度。当一个新的命令被写进日志的时候，最老的那个记录会被删掉。
# 下面的时间单位是微秒，所以1000000就是1秒。注意，负数时间会禁用慢查询日志，而0则会强制记录所有命令。
slowlog-log-slower-than 10000
# 这个长度没有限制。只要有足够的内存就行。你可以通过 SLOWLOG RESET 来释放内存。（译者注：日志居然是在内存里的Orz）
slowlog-max-len 128
################################ 虚拟内存 ###############################
### 警告！虚拟内存在Redis 2.4是反对的。
### 非常不鼓励使用虚拟内存！！
# 虚拟内存可以使Redis在内存不够的情况下仍然可以将所有数据序列保存在内存里。
# 为了做到这一点，高频key会调到内存里，而低频key会转到交换文件里，就像操作系统使用内存页一样。
# 要使用虚拟内存，只要把 &vm-enabled& 设置为 &yes&，并根据需要设置下面三个虚拟内存参数就可以了。
vm-enabled no
# vm-enabled yes
# 这是交换文件的路径。估计你猜到了，交换文件不能在多个Redis实例之间共享，所以确保每个Redis实例使用一个独立交换文件。
# 最好的保存交换文件（被随机访问）的介质是固态硬盘（SSD）。
# *** 警告 *** 如果你使用共享主机，那么默认的交换文件放到 /tmp 下是不安全的。
# 创建一个Redis用户可写的目录，并配置Redis在这里创建交换文件。
vm-swap-file /tmp/redis.swap
# &vm-max-memory& 配置虚拟内存可用的最大内存容量。
# 如果交换文件还有空间的话，所有超标部分都会放到交换文件里。
# &vm-max-memory& 设置为0表示系统会用掉所有可用内存。
# 这默认值不咋地，只是把你能用的内存全用掉了，留点余量会更好。
# 例如，设置为剩余内存的60%-80%。
vm-max-memory 0
# Redis交换文件是分成多个数据页的。
# 一个可存储对象可以被保存在多个连续页里，但是一个数据页无法被多个对象共享。
# 所以，如果你的数据页太大，那么小对象就会浪费掉很多空间。
# 如果数据页太小，那用于存储的交换空间就会更少（假定你设置相同的数据页数量）
# 如果你使用很多小对象，建议分页尺寸为64或32个字节。
# 如果你使用很多大对象，那就用大一些的尺寸。
# 如果不确定，那就用默认值 :)
vm-page-size 32
# 交换文件里数据页总数。
# 根据内存中分页表（已用/未用的数据页分布情况），磁盘上每8个数据页会消耗内存里1个字节。
# 交换区容量 = vm-page-size * vm-pages
# 根据默认的32字节的数据页尺寸和的数据页数来算，Redis的数据页文件会占4GB，而内存里的分页表会消耗16MB内存。
# 为你的应验程序设置最小且够用的数字比较好，下面这个默认值在大多数情况下都是偏大的。
# 同时可运行的虚拟内存I/O线程数。
# 这些线程可以完成从交换文件进行数据读写的操作，也可以处理数据在内存与磁盘间的交互和编码/解码处理。
# 多一些线程可以一定程度上提高处理效率，虽然I/O操作本身依赖于物理设备的限制，不会因为更多的线程而提高单次读写操作的效率。
# 特殊值0会关闭线程级I/O，并会开启阻塞虚拟内存机制。
vm-max-threads 4
############################### 高级配置 ###############################
# 当有大量数据时，适合用哈希编码（需要更多的内存），元素数量上限不能超过给定限制。
# 你可以通过下面的选项来设定这些限制：
hash-max-zipmap-entries 512
hash-max-zipmap-value 64
# 与哈希相类似，数据元素较少的情况下，可以用另一种方式来编码从而节省大量空间。
# 这种方式只有在符合下面限制的时候才可以用：
list-max-ziplist-entries 512
list-max-ziplist-value 64
# 还有这样一种特殊编码的情况：数据全是64位无符号整型数字构成的字符串。
# 下面这个配置项就是用来限制这种情况下使用这种编码的最大上限的。
set-max-intset-entries 512
# 与第一、第二种情况相似，有序序列也可以用一种特别的编码方式来处理，可节省大量空间。
# 这种编码只适合长度和元素都符合下面限制的有序序列：
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
# 哈希刷新，每100个CPU毫秒会拿出1个毫秒来刷新Redis的主哈希表（顶级键值映射表）。
# redis所用的哈希表实现（见dict.c）采用延迟哈希刷新机制：你对一个哈希表操作越多，哈希刷新操作就越频繁；
# 反之，如果服务器非常不活跃那么也就是用点内存保存哈希表而已。
# 默认是每秒钟进行10次哈希表刷新，用来刷新字典，然后尽快释放内存。
# 如果你对延迟比较在意的话就用 &activerehashing no&，每个请求延迟2毫秒不太好嘛。
# 如果你不太在意延迟而希望尽快释放内存的话就设置 &activerehashing yes&。
activerehashing yes
################################## 包含 ###################################
# 包含一个或多个其他配置文件。
# 这在你有标准配置模板但是每个redis服务器又需要个性设置的时候很有用。
# 包含文件特性允许你引人其他配置文件，所以好好利用吧。
# include /path/to/local.conf
# include /path/to/other.conf
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：13383次
排名：千里之外7974人阅读
NoSQL（11）
运维（16）
Redis（10）
& & & & &Redis是个高性能的key-value数据库，它的key具有丰富的数据结构：string，hash，list set和sorted set。作为NOSQL，比起memcache之类，不仅仅key数据结构丰富，而且具有持久化的功能，并且能够支持主从复制，很方便构建集群。redis高性能很大程度上源于它是个内存型数据库，它的高性能表现在：set操作11w/s，get操作8.1w/s，与其他类型数据库性能差异，可以而参考：&
&。为了进一步加深对redis的理解总结，我打算写个redis系列的博客。这里主要谈谈redis安装部署及运维维护。
1、下载安装
[root@xsf003 tool]# wget -c /files/redis-2.4.17.tar.gz
[root@xsf003 tool]# tar -zxvf redis-2.4.17.tar.gz
[root@xsf003 tool]# cd redis-2.4.17
[root@xsf003 redis-2.4.17]# make
[root@xsf003 redis-2.4.17]# make install #安装 安装完毕，常用工具会自动拷贝到/user/loca/bin目录下。做为服务器，我们常常还需要把redis设置成开机自启动，源码包中有个很好用的脚本，执行脚步根据提示输入即可。
[root@xsf003 redis-2.4.17]# cd utils/
[root@xsf003 utils]# ./install_server.sh
Welcome to the redis service installer
This script will help you easily set up a running redis server
Please select the redis port for this instance: [6379]
Selecting default: 6379
Please select the redis config file name [/etc/redis/6379.conf]
Selected default - /etc/redis/6379.conf
Please select the redis log file name [/var/log/redis_6379.log]
Selected default - /var/log/redis_6379.log
Please select the data directory for this instance [/var/lib/redis/6379]
Selected default - /var/lib/redis/6379
Please select the redis executable path [/usr/local/bin/redis-server]
Copied /tmp/6379.conf =& /etc/init.d/redis_6379
Installing service...
Successfully added to chkconfig!
Successfully added to runlevels 345!
Starting Redis server...
Installation successful!
& & &注意执行install_server.sh，需要先进入utils目录，不然脚本会报错，提示找不到相应文件。安装完服务，redis自动启动，可以用ps命令查看到相关信息：
[root@xsf003 utils]# ps -ef | grep redis
00:00:02 /usr/local/bin/redis-server /etc/redis/6379.conf
0 10:59 pts/0
00:00:00 grep redis
2、手动启动关闭服务
[root@xsf003 utils]# /etc/init.d/redis_6379 stop
[root@xsf003 utils]# /etc/init.d/redis_6379 start
也可以用下面类似的命令直接启动关闭redis服务：
/usr/local/bin/redis-server /etc/redis/redis.conf
#指定配置文件 启动
/usr/local/bin/redis-cli -p 6379 shutdown
# 关闭，如果默认端口6379 可以直接 /usr/local/bin/redis-cli shutdown& &&
&& 3、通过客户端命令行工具连接redis服务查看redis相关信息
[root@xsf003 utils]# redis-cli
redis 127.0.0.1:6379&
b）其他指令
redis 127.0.0.1:6379& info
#查看server版本内存使用连接等信息
redis 127.0.0.1:6379& client list
#获取客户连接列表
redis 127.0.0.1:6379& client kill 127.0.0.1:33441 #终止某个客户端连接
redis 127.0.0.1:6379& dbsize #当前保存key的数量
redis 127.0.0.1:6379& save #立即保存数据到硬盘
redis 127.0.0.1:6379& bgsave #异步保存数据到硬盘
redis 127.0.0.1:6379& flushdb #当前库中移除所有key
redis 127.0.0.1:6379& flushall #移除所有key从所有库中
redis 127.0.0.1:6379& lastsave #获取上次成功保存到硬盘的unix时间戳
redis 127.0.0.1:6379& monitor #实时监测服务器接收到的请求
redis 127.0.0.1:6379& slowlog len #查询慢查询日志条数
(integer) 3
redis 127.0.0.1:6379& slowlog get #返回所有的慢查询日志，最大值取决于slowlog-max-len配置
redis 127.0.0.1:6379& slowlog get 2 #打印两条慢查询日志
redis 127.0.0.1:6379& slowlog reset #清空慢查询日志信息
通过以上操作，单台服务器基本跑起来了，不过后面的路还很长很长。。。。
参考文章：
http://redis.io/topics/introduction
http://timyang.net/data/mcdb-tt-redis/
http://redis.io/commands#server
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1240426次
积分：12628
积分：12628
排名：第734名
原创：248篇
转载：12篇
评论：125条
(2)(5)(2)(6)(1)(1)(3)(7)(3)(5)(5)(3)(2)(12)(4)(6)(18)(17)(14)(21)(14)(2)(3)(8)(2)(8)(12)(5)(28)(32)(7)(1)(1)# 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.#Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程（守护进程（daemon）是指在UNIX或其他多任务操作系统中在后台执行的电脑程序，并不会接受电脑用户的直接操控。）daemonize no
# When running daemonized, Redis writes a pid file in /var/run/redis.pid by# default. You can specify a custom pid file location here.#当 Redis 以守护进程的方式运行的时候,Redis 默认会把 pid 文件放在/var/run/redis.pid,你可以配置到其他地址。当运行多个 redis 服务时,需要指定不同的 pid 文件和端口pidfile /var/run/redis.pid # Accept connections on the specified port, default is 6379.# If port 0 is specified Redis will not listen on a TCP socket.#端口没什么好说的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.#指定Redis可接收请求的IP地址,不设置将处理所有请求,建议生产环境中设置# bind 127.0.0.1 # Close the connection after a client is idle for N seconds (0 to disable)#客户端连接的超时时间,单位为秒,超时后会关闭连接timeout 0 # 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#配置 log 文件地址,默认打印在命令行终端的窗口上logfile stdout # 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#设置数据库的个数,可以使用 SELECT &dbid&命令来切换数据库。默认使用的数据库是 0databases 16
## 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.#设置 Redis 进行数据库镜像的频率。#900秒之内有1个keys发生变化时#30秒之内有10个keys发生变化时#60秒之内有10000个keys发生变化时save 900 1save 300 10save 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.#数据库镜像备份的文件放置的路径。这里的路径跟文件名要分开配置是因为 Redis 在进行备份时,先会将当前数据库的状态写入到一个临时文件中,等备份完成时,再把该该临时文件替换为上面所指定的文件,#而这里的临时文件和上面所配置的备份文件都会放在这个指定的路径当中dir ./ # 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& # 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.#设置客户端连接后进行任何其他指定前需要使用的密码。警告:redis速度相当快,一个外部的用户可以在一秒钟进行150K次的密码尝试,你需要指定非常非常强大的密码来防止暴力破解。 # requirepass foobared
# 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'.#限制同时连接的客户数量。当连接数超过这个值时,redis 将不再接收其他连接请求,客户端尝试连接时将收到 error 信息# 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# accordingly to the eviction policy selected (see maxmemmory-policy).## If Redis can't remove keys according to the policy, or if the policy is# set to 'noeviction', Redis will start to reply with errors to commands# that would use more memory, like SET, LPUSH, and so on, and will continue# to reply to read-only commands like GET.## This option is usually useful when using Redis as an LRU cache, or to set# an 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').#设置redis能够使用的最大内存。当内存满了的时候,如果还接收到set命令,redis将先尝试剔除设置过expire信息的key,而不管该key的过期时间还没有到达。#在删除时,将按照过期时间进行删除,最早将要被过期的key将最先被删除。如果带有expire信息的key都删光了,那么将返回错误。#这样,redis将不再接收写请求,只接收get请求。maxmemory的设置比较适合于把redis当作于类似memcached 的缓存来使用# maxmemory &bytes& # 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.#默认情况下,redis 会在后台异步的把数据库镜像备份到磁盘,但是该备份是非常耗时的,而且备份也不能很频繁,如果发生诸如拉闸限电、拔插头等状况,那么将造成比较大范围的数据丢失。#所以redis提供了另外一种更加高效的数据库备份及灾难恢复方式。#开 启append only 模式之后,redis 会把所接收到的每一次写操作请求都追加到appendonly.aof 文件中,当redis重新启动时,会从该文件恢复出之前的状态。#但是这样会造成 appendonly.aof 文件过大,所以redis还支持了BGREWRITEAOF 指令,对appendonly.aof进行重新整理appendonly no # 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".#设置对 appendonly.aof 文件进行同步的频率。always 表示每次有写操作都进行同步,everysec 表示对写操作进行累积,每秒同步一次。# appendfsync alwaysappendfsync everysec# appendfsync no # 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.#是否开启虚拟内存支持。因为 redis 是一个内存数据库,而且当内存满的时候,无法接收新的写请求,所以在redis2.0中,提供了虚拟内存的支持。#但是需要注意的是,redis中,所有的key都会放在内存中,在内存不够时,只会把value 值放入交换区。#这样保证了虽然使用虚拟内存,但性能基本不受影响,同时,你需要注意的是你要把vm-max-memory设置到足够来放下你的所有的keyvm-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.#这里设置开启虚拟内存之后,redis将使用的最大物理内存的大小。默认为0,redis将把他所有的能放到交换文件的都放到交换文件中,以尽量少的使用物理内存。#在生产环境下,需要根据实际情况设置该值,最好不要使用默认的 0vm-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 #设置虚拟内存的页大小,如果你的 value 值比较大,比如说你要在 value 中放置博客、新闻之类的所有文章内容,就设大一点,如果要放置的都是很小的内容,那就设小一点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
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.#设置交换文件的总的 page 数量,需要注意的是,page table信息会放在物理内存中,每8个page 就会占据RAM中的 1 个 byte。#总的虚拟内存大小 = vm-page-size * vm-pagesvm-pages
# 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 IO 同时使用的线程数量。vm-max-threads 4 # 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.#redis 2.0 中引入了 hash 数据结构。 #hash 中包含超过指定元素个数并且最大的元素当没有超过临界时,hash 将以zipmap(又称为 small hash大大减少内存使用)来存储,这里可以设置这两个临界值hash-max-zipmap-entries 512hash-max-zipmap-value 64 # 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.#开启之后,redis 将在每 100 毫秒时使用 1 毫秒的 CPU 时间来对 redis 的 hash 表进行重新 hash,可以降低内存的使用。#当你的使用场景中,有非常严格的实时性需要,不能够接受 Redis 时不时的对请求有 2 毫秒的延迟的话,把这项配置为 no。#如果没有这么严格的实时性要求,可以设置为 yes,以便能够尽可能快的释放内存activerehashing yes
阅读(...) 评论()