redis配置文件详解,以及怎么添加密码以及如何登陆

Dear 丶 2022-05-13 11:12 152阅读 0赞

Redis configuration file example

Note on units: when memory size is needed, it is possible to specify  
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.  
内存大小的配置，不区分大小写

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.

Notice option “include” won’t be rewritten by command “CONFIG REWRITE”  
from admin or Redis Sentinel. Since Redis always uses the last processed  
line as value of a configuration directive, you’d better put includes  
at the beginning of this file to avoid overwriting config change at runtime.

If instead you are interested in using includes to override configuration  
options, it is better to use include as the last line.

include /path/to/local.conf  
include /path/to/other.conf  
当配置多个redis时，可能大部分配置一样，而对于不同的redis，只有少部分配置需要定制  
就可以配置一个公共的模板配置。  
对于具体的reids，只需设置少量的配置，并用include把模板配置包含进来即可。

值得注意的是，对于同一个配置项，redis只对最后一行的有效  
所以为避免模板配置覆盖当前配置，应在配置文件第一行使用include  
当然，如果模板配置的优先级比较高，就在配置文件最后一行使用include

GENERAL

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.  
yes为使用守护进程，此时redis的进程ID会被写进 pidfile的配置中  
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.  
当redis以守护进程的方式启动时，redis的进程ID将会写在这个文件中  
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.  
redis 启动的端口。【应该知道redis是服务端吧】  
port 6379

TCP listen() backlog.

In high requests-per-second environments you need an high backlog in order  
to avoid slow clients connections issues. Note that the Linux kernel  
will silently truncate it to the value of /proc/sys/net/core/somaxconn so  
make sure to raise both the value of somaxconn and tcp\_max\_syn\_backlog  
in order to get the desired effect.  
最大链接缓冲池的大小，这里应该是指的未完成链接请求的数量  
（测试值为1时，仍可以有多个链接）  
但该值与listen函数中的backlog意义应该是相同的，源码中该值就是被用在了listen函数中  
该值同时受/proc/sys/net/core/somaxconn 和 tcp\_max\_syn\_backlog（/etc/sysctl.conf中配置）的限制  
tcp\_max\_syn\_backlog 指的是未完成链接的数量  
tcp-backlog 511

By default Redis listens for connections from all the network interfaces  
available on the server. It is possible to listen to just one or multiple  
interfaces using the “bind” configuration directive, followed by one or  
more IP addresses.  
绑定ip，指定ip可以连接到redis

Examples:

bind 192.168.1.100 10.0.0.1  
bind 127.0.0.1

Specify the path for the Unix socket that will be used to listen for  
incoming connections. There is no default, so Redis will not listen  
on a unix socket when not specified.

这个应该就是以文件形式创建的socket  
unixsocket /tmp/redis.sock  
unixsocketperm 755

Close the connection after a client is idle for N seconds (0 to disable)  
超时断链机制，如果一个链接在N秒内没有任何操作，则断开该链接  
N为0时，该机制失效  
timeout 0

TCP keepalive.

If non-zero, use SO\_KEEPALIVE to send TCP ACKs to clients in absence  
of communication. This is useful for two reasons:

1) Detect dead 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.  
就像心跳检测一样，检查链接是否保持正常，同时也可以保持正常链接的通信  
建议值为60

A reasonable value for this option is 60 seconds.  
tcp-keepalive 0

Specify the server verbosity level.  
This 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 notice

Specify the log file name. Also the empty string 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  
日志存放路径，默认是输出到标准输出，但当以守护进程方式启动时，默认输出到/dev/null(传说中的linux黑洞)  
logfile “”

To enable logging to the system logger, just set ‘syslog-enabled’ to yes,  
and optionally update the other syslog parameters to suit your needs.  
yes 表示将日志写到系统日志中  
syslog-enabled no

Specify the syslog identity.  
当syslog-enabled为yes时，指定系统日志的标示为 redis  
syslog-ident redis

Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.  
指定系统日志的设备  
syslog-facility local0

Set the number of databases. The default database is DB 0, you can select  
a different one on a per-connection basis using SELECT where  
dbid is a number between 0 and ‘databases’-1  
redis的数据库格式，默认16个(0~15)，默认使用第0个。  
databases 16

SNAPSHOTTING

Save the DB on disk:

save

Will save the DB if both the given number of seconds and the given  
number of write operations against the DB occurred.  
快照，即将数据写到硬盘上，在秒内，至少有次写入数据库操作  
则会将数据写入硬盘一次。  
将save行注释掉则永远不会写入硬盘  
save “” 表示删除所有的快照点

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.

It is also possible to remove all the previously configured save  
points by adding a save directive with a single empty string argument  
like in the following example:

save “”

save 900 1  
save 300 10  
save 60 10000

By default Redis will stop accepting writes if RDB snapshots are enabled  
(at least one save point) and the latest background save failed.  
This will make the user aware (in a hard way) that data is not persisting  
on disk properly, otherwise chances are that no one will notice and some  
disaster will happen.

If the background saving process will start working again Redis will  
automatically allow writes again.

However if you have setup your proper monitoring of the Redis server  
and persistence, you may want to disable this feature so that Redis will  
continue to work as usual even if there are problems with disk,  
permissions, and so forth.  
当做快照失败的时候，redis会停止继续向其写入数据，保证第一时间发现redis快照出现问题  
当然，通过下面配置为 no，即使redis快照失败，也能继续向redis写入数据  
stop-writes-on-bgsave-error yes

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.  
快照的时候，是否用LZF压缩，使用压缩会占一定的cpu，但不使用压缩，快照会很大  
rdbcompression yes

Since version 5 of RDB a CRC64 checksum is placed at the end of the file.  
This makes the format more resistant to corruption but there is a performance  
hit to pay (around 10%) when saving and loading RDB files, so you can disable it  
for maximum performances.

RDB files created with checksum disabled have a checksum of zero that will  
tell the loading code to skip the check.  
数据校验，快照末尾会存放一个校验值，保证数据的准确性  
但数据校验会使性能下降约10%，默认开启校验  
rdbchecksum 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.

The Append Only File will also be created inside this directory.

Note that you must specify a directory here, not a file name.

快照存放的目录  
linux root下测试，会发现该进程会在当前目录下创建一个dump.rdb  
但快照却放在了根目录/下，重启的时候，是不会从快照中恢复数据的  
当把根目录下的dump.rdb文件拷贝到当前目录的时候，再次启动，就会从快照中恢复数据  
而且以后的快照也都在当前目录的dump.rdb中做操作

值得一提的是，快照是异步方式的，如果在还未达到快照的时候，修改了数据，而且redis发生问题crash了  
那么中间的修改数据是不会被保存到dump.rdb快照中的  
解决办法就是用Append Only Mode的同步模式(下面将会有该配置项)  
将会把每个操作写到Append Only File中，该文件也存放于当前配置的目录  
建议使用绝对路径！！！

dir ./

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.

主从复制，类似于双机备份。  
配置需指定主机的ip 和port  
slaveof

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.

如果主机redis需要密码，则指定密码  
密码配置在下面安全配置中  
masterauth

When a slave loses its connection with the master, or when the replication  
is still in progress, the slave can act in two different ways:

1) if slave-serve-stale-data is set to ‘yes’ (the default) the slave will  
still reply to client requests, possibly with out of date data, or the  
data set may just be empty if this is the first synchronization.

2) if slave-serve-stale-data is set to ‘no’ the slave will reply with  
an error “SYNC with master in progress” to all the kind of commands  
but to INFO and SLAVEOF.

当从机与主机断开时，即同步出现问题的时候，从机有两种处理方式  
yes, 继续响应客户端请求，但可能有脏数据（过期数据、空数据等）  
no，对客户端的请求统一回复为“SYNC with master in progress”，除了INFO和SLAVEOF命令  
slave-serve-stale-data yes

You can configure a slave instance to accept writes or not. Writing against  
a slave instance may be useful to store some ephemeral data (because data  
written on a slave will be easily deleted after resync with the master) but  
may also cause problems if clients are writing to it because of a  
misconfiguration.

Since Redis 2.6 by default slaves are read-only.

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.  
slave只读选项，设置从机只读（默认）。  
即使设置可写，当下一次从主机上同步数据，仍然会删除当前从机上写入的数据  
【待测试】：主机与从机互为slave会出现什么情况？  
【预期三种结果】：1. 提示报错 2. 主从服务器数据不可控 3. 一切正常  
slave-read-only yes

Slaves send PINGs to server in a predefined interval. It’s possible to change  
this interval with the repl\_ping\_slave\_period option. The default value is 10  
seconds.

从服务器向主服务器发送心跳包，默认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大  
批量数据传输超时、ping超时  
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 有延迟，约40毫秒（linux kernel的默认配置），使用较少的数据包，较小的带宽  
no 无延迟（减少延迟），但需要更大的带宽  
repl-disable-tcp-nodelay no

Set the replication backlog size. The backlog is a buffer that accumulates  
slave data when slaves are disconnected for some time, so that when a slave  
wants to reconnect again, often a full resync is not needed, but a partial  
resync is enough, just passing the portion of data the slave missed while  
disconnected.

The biggest the replication backlog, the longer the time the slave can be  
disconnected and later be able to perform a partial resynchronization.

The backlog is only allocated once there is at least a slave connected.

默认情况下，当slave重连的时候，会进行全量数据同步  
但实际上slave只需要部分同步即可，这个选项设置部分同步的大小  
设置值越大，同步的时间就越长  
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.

A value of 0 means to never release the backlog.

主机的后台日志释放时间，即当没有slave连接时，过多久释放后台日志  
0表示不释放  
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.

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.

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.

By default the priority is 100.  
当主机crash的时候，在从机中选择一台作为主机，数字越小，优先级越高  
0 表示永远不作为主机，默认值是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.

The N slaves need to be in “online” state.

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.

For example to require at least 3 slaves with a lag <= 10 seconds use:

当slave数量小于min-slaves-to-write，且延迟小于等于min-slaves-max-lag时，  
主机停止写入操作  
0表示禁用  
默认min-slaves-to-write为0，即禁用。min-slaves-max-lag为10  
min-slaves-to-write 3  
min-slaves-max-lag 10

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.

SECURITY

Require clients to issue AUTH 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密码，默认不配置，即无密码  
这里注意，如果设置了密码，应该设置一个复杂度比较高的密码  
因为redis的速度很快，每秒可以尝试150k次的密码测试，很容易对其进行暴力破解（跑码）。  
疑问：这里为什么不设置一个针对主机的测试次数限制的，例如每10次，则禁止建立连接1个小时！  
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.

命令重命名，将命令重命名为另一个字符串标识  
如果命令为空串(“”)，则会彻底禁用该命令  
命令重命名，会对写AOF(Append of file)文件、slave从机造成一些问题  
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.

LIMITS

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).

Once the limit is reached Redis will close all the new connections sending  
an error ‘max number of clients reached’.

这只redis的最大连接数目，默认设置为10000个客户端  
当超过限制时，将段开新的连接，并响应“max number of clients reached”  
maxclients 10000

Don’t use more memory than the specified amount of bytes.  
When the memory limit is reached Redis will try to remove keys  
according to the eviction policy selected (see maxmemory-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  
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’).

redis的最大内存限制，如果达到最大内存，会按照下面的maxmemory-policy进行清除  
如果不能再清除或者maxmemory-policy为noeviction，则对于需要增加空间的操作，将会返回错误  
maxmemory

MAXMEMORY POLICY: how Redis will select what to remove when maxmemory  
is reached. You can select among five behaviors:

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

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:

内存删除策略，默认volatile-lru，利用LRU算法，删除过期的key  
maxmemory-policy volatile-lru

LRU and minimal TTL algorithms are not precise algorithms but approximated  
algorithms (in order to save memory), so you can select as well the sample  
size to check. For instance for default Redis will check three keys and  
pick the one that was used less recently, you can change the sample size  
using the following configuration directive.

LRU算法与最小TTL算法只是相对精确的算法，并不是绝对精确的算法  
为了更精确，可以设置样本个数  
比如设置3个样本，redis会选取三个key，并选择删除那个上次使用时间最远的  
maxmemory-samples 3

APPEND ONLY MODE

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).

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.

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.

Please check [http://redis.io/topics/persistence][http_redis.io_topics_persistence] for more information.  
将对redis所有的操作都保存到AOF文件中  
因为dump.rdb是异步的，在下次快照到达之前，如果出现crash等问题，会造成数据丢失  
而AOF文件时同步记录的，所以会完整的恢复数据

appendonly no

The name of the append only file (default: “appendonly.aof”)  
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 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][http_antirez.com_post_redis-persistence-demystified.html]

If unsure, use “everysec”.  
redis的数据同步方式，三种  
no，redis本身不做同步，由OS来做。redis的速度会很快  
always，在每次写操作之后，redis都进行同步，即写入AOF文件。redis会变慢，但是数据更安全  
everysec，折衷考虑，每秒同步一次数据。【默认】

appendfsync always  
appendfsync everysec  
appendfsync no

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.  
redis的同步方式中，always和everysec，快照和写AOF可能会执行大量的硬盘I/O操作，  
而在一些Linux的配置中，redis会阻塞很久，而redis本身并没有很好的解决这一问题。  
为了缓和这一问题，redis提供no-appendfsync-on-rewrite选项，  
即当有另外一个进程在执行保存操作的时候，redis采用no的同步方式。  
最坏情况下会有延迟30秒的同步延迟。  
如果你觉得这样做会有潜在危险，则请将该选项改为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文件  
当AOF日志文件大小增长到指定百分比时，redis会自动隐式调用BGREWRITEAOF来重写AOF文件  
redis会记录上次重写AOF文件之后的大小，  
如果当前文件大小增加了auto-aof-rewrite-percentage，则会触发重写AOF日志功能  
当然如果文件过小，比如小于auto-aof-rewrite-min-size这个大小，是不会触发重写AOF日志功能的  
auto-aof-rewrite-percentage为0时，禁用重写功能

auto-aof-rewrite-percentage 100  
auto-aof-rewrite-min-size 64mb

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脚本的最大执行时间（单位是毫秒），默认5000毫秒，即5秒  
如果LUA脚本执行超过这个限制，可以调用SCRIPT KILL和SHUTDOWN NOSAVE命令。  
SCRIPT KILL可以终止脚本执行  
SHUTDOWN NOSAVE关闭服务，防止LUA脚本的写操作发生  
该值为0或者负数，表示没有限制时间  
lua-time-limit 5000

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.  
记录执行比较慢的命令  
执行比较慢仅仅是指命令的执行时间，不包括客户端的链接与响应等时间  
slowlog-log-slower-than 设定这个慢的时间，单位是微妙，即1000000表示1秒，0表示所有命令都记录，负数表示不记录  
slowlog-max-len表示记录的慢命令的个数，超过限制，则最早记录的命令会被移除  
命令的长度没有限制，但是会消耗内存，用SLOWLOG RESET来收回这些消耗的内存

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

LATENCY MONITOR

The Redis latency monitoring subsystem samples different operations  
at runtime in order to collect data related to possible sources of  
latency of a Redis instance.

Via the LATENCY command this information is available to the user that can  
print graphs and obtain reports.

The system only logs operations that were performed in a time equal or  
greater than the amount of milliseconds specified via the  
latency-monitor-threshold configuration directive. When its value is set  
to zero, the latency monitor is turned off.

By default latency monitoring is disabled since it is mostly not needed  
if you don’t have latency issues, and collecting data has a performance  
impact, that while very small, can be measured under big load. Latency  
monitoring can easily be enalbed at runtime using the command  
“CONFIG SET latency-monitor-threshold ” if needed.  
延迟监控器  
redis延迟监控子系统在运行时，会抽样检测可能导致延迟的不同操作  
通过LATENCY命令可以打印相关信息和报告, 命令如下（摘自源文件注释）：  
LATENCY SAMPLES: return time-latency samples for the specified event.  
LATENCY LATEST: return the latest latency for all the events classes.  
LATENCY DOCTOR: returns an human readable analysis of instance latency.  
LATENCY GRAPH: provide an ASCII graph of the latency of the specified event.

系统只记录超过设定值的操作，单位是毫秒，0表示禁用该功能  
可以通过命令“CONFIG SET latency-monitor-threshold ” 直接设置而不需要重启redis

latency-monitor-threshold 0

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][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@** prefix.  
E Keyevent events, published with **keyevent@** prefix.  
g Generic commands (non-type specific) like DEL, EXPIRE, RENAME, …  
StringcommandslListcommandssSetcommandshHashcommandszSortedsetcommandsxExpiredevents(eventsgeneratedeverytimeakeyexpires)eEvictedevents(eventsgeneratedwhenakeyisevictedformaxmemory)AAliasforg  S t r i n g c o m m a n d s l L i s t c o m m a n d s s S e t c o m m a n d s h H a s h c o m m a n d s z S o r t e d s e t c o m m a n d s x E x p i r e d e v e n t s ( e v e n t s g e n e r a t e d e v e r y t i m e a k e y e x p i r e s ) e E v i c t e d e v e n t s ( e v e n t s g e n e r a t e d w h e n a k e y i s e v i c t e d f o r m a x m e m o r y ) A A l i a s f o r 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.  
事件通知，当事件发生时，redis可以通知Pub/Sub客户端  
空串表示禁用事件通知  
注意：K和E至少要指定一个，否则不会有事件通知  
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数目比较少，并且最大元素没有超过给定值时，Hash使用比较有效的内存数据结构来存储。  
即ziplist的结构（压缩的双向链表），参考：[http://blog.csdn.net/benbendy1984/article/details/7796956][http_blog.csdn.net_benbendy1984_article_details_7796956]  
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配置同Hash  
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.  
Sets的元素如果全部是整数（10进制），且为64位有符号整数，则采用特殊的编码方式。  
其元素个数限制配置如下：  
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:  
sorted set 同Hash和List  
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.  
关于HyperLogLog的介绍：[http://www.redis.io/topics/data-types-introhyperloglogs][http_www.redis.io_topics_data-types-introhyperloglogs]  
HyperLogLog稀疏表示限制设置，如果其值大于16000，则仍然采用稠密表示，因为这时稠密表示更能有效使用内存  
建议值为3000  
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.  
每100毫秒，redis将用1毫秒的时间对Hash表进行重新Hash。  
采用懒惰Hash方式：操作Hash越多，则重新Hash的可能越多，若根本就不操作Hash，则不会重新Hash  
默认每秒10次重新hash主字典，释放可能释放的内存  
重新hash会造成延迟，如果对延迟要求较高，则设为no，禁止重新hash。但可能会浪费很多内存  
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 including MONITOR clients  
slave -> slave clients  
pubsub -> clients subscribed to at least one pubsub channel or pattern

The syntax of every client-output-buffer-limit directive is the following:

客户端输出缓冲区限制，当客户端从服务端的读取速度不够快时，则强制断开  
三种不同的客户端类型：normal、salve、pubsub，语法如下：  
client-output-buffer-limit

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.  
当达到硬限制，或者达到软限制且持续了算限制秒数，则立即与客户端断开  
限制设为0表示禁止该功能  
普通用户默认不限制  
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.  
redis调用内部函数执行的后台任务的频率  
后台任务比如：清除过期数据、客户端超时链接等  
默认为10，取值范围1~500,  
对延迟要求很低的可以设置超过100以上  
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文件时，该设置为yes，则每生成32MB的数据，就进行同步  
aof-rewrite-incremental-fsync yes

**对redis加入密码:**  
在这里是通过命令进行密码的添加  
首先进入到src目录下,执行./redis-server启动服务端,然后执行./redis-cli进入到客户端,此时在客户端执行以下命令:

config get requirepass

查看是否有密码:  
![这里写图片描述][70]  
然后开始设置密码:

config set requirepass 123456

设置成功之后进入重新进入客户端,执行命令时会出现以下错误:  
![这里写图片描述][70 1]  
只需要输入以下命令就可以了:

auth 123456

然后就可以继续操作了.至此密码设置成功

[http_redis.io_topics_persistence]: http://redis.io/topics/persistence
[http_antirez.com_post_redis-persistence-demystified.html]: http://antirez.com/post/redis-persistence-demystified.html
[http_redis.io_topics_keyspace-events]: http://redis.io/topics/keyspace-events
[http_blog.csdn.net_benbendy1984_article_details_7796956]: http://blog.csdn.net/benbendy1984/article/details/7796956
[http_www.redis.io_topics_data-types-introhyperloglogs]: http://www.redis.io/topics/data-types-introhyperloglogs
[70]: /images/20220513/4f200489f2134c768d4f54b94f96c31b.png
[70 1]: /images/20220513/f607e1ecbb514c769a6521938cfded9c.png