Linux(Ubuntu16.04)下redis的安装，helloworld及读懂配置文件

迷南。 2022-05-29 13:49 42阅读 0赞

# Linux(Ubuntu16.04)下redis的安装，helloworld及读懂配置文件 #

--------------------

说明：redis3.0以后的版本增加了redis集群功能，在之后的博客会有集群功能的使用，所以建议安装redis3.0及以上的版本  
本次安装的redis安装包为redis-3.2.9.tar.gz  
想要使用redis需要服务器上有gcc，gcc是linux下的一个编译程序，是c程序的编译工具。GCC是GNU计划提供的编译器家族，支持C，C++，Objective-C，Java等多语音，同时能运行在x86，x86-64，IA-64，PowerPC等几乎所有硬件平台。（但腾讯云服务器自带gcc，可通过gcc –version命令查看gcc版本）

## 安装：把到官网下载好的redis压缩包放置到你想要的位置。并解压。 ##

本示例在/usr/local/jae位置放置redis压缩包，然后依次执行tar -zxvf redis-3.2.9.tar.gz 及 mv redis-3.2.9 redis  
命令，然后cd redis 在该文件下执行make命令（root@VM-98-105-ubuntu:/usr/local/jae/redis\# make）  
make命令为编译命令，接下来通过make install安装 可以通过PREFIX指定安装的路径（这条命令要在redis目录下执行）  
root@VM-98-105-ubuntu:/usr/local/jae/redis\# make install PREFIX=/usr/local/jae/redis/redisfirst  
执行后在redis目录下多出一个redisfirst文件夹，进入后还有bin文件夹，里面装着刚刚安装的东西  
![这里写图片描述][70]

--------------------

## 启动redis的两种方式（推荐使用后面一种） ##

1、前端启动模式  
./redis-server  
默认是前端启动模式，端口是6379  
![这里写图片描述][70 1]  
2、后端启动  
1）从redis的源码目录中复制redis.conf到redis的安装目录。（redis关键：能备份的先备份，conf文件可以多备份几个）  
(root@VM-98-105-ubuntu:/usr/local/jae/redis\# cp redis.conf /usr/local/jae/redis/redisfirst/bin)  
2）修改配置文件  
把此处的no改成yes  
意思是：默认情况下 redis 不是作为守护进程运行的，如果你想让它在后台运行，你就把它改成 yes。我们必须保证它不被杀死！！！  
![这里写图片描述][70 2]

通过./redis-server redis.conf命令后端启动，用ps aux|grep redis查看状态，使用./redis-cli进入redis，ping确认连接  
![这里写图片描述][70 3]

--------------------

## redis的常用命令及数据类型 ##

127.0.0.1:6379> set a 10  
OK  
127.0.0.1:6379> get a  
“10”  
数据类型：  
String  
Hash  
List  
Set  
SortedSet

--------------------

## 解析配置文件 ##

将整个redis配置文件罗列一下

# Redis configuration file example 
    
    //redis 配置文件示例 
    
    # 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 5gb 4m  
    
    # 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. 
    
    //单位是不区分大小写的，你写 1K 5GB 4M 也行

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# INCLUDES ######

\# Include one or more other config files here. This is useful if you  
\# have a standard template that goes to all Redis servers but also need  
//假如说你有一个可用于所有的 redis server 的标准配置模板，  
\# to customize a few per-server settings. Include files can include  
\# other files, so use this wisely.  
//但针对某些 server 又需要一些个性化的设置，可以使用 include 来包含一些其他的配置文件，这对你来说是非常有用的。  
\# Notice option “include” won’t be rewritten by command “CONFIG REWRITE”  
//但是要注意，include 是不能被 config rewrite 命令改写的  
\# from admin or Redis Sentinel. Since Redis always uses the last processed  
//由于 redis 总是以最后的加工前作为一个配置指令值，所以你最好是把 include 放在这个文件的最前面，以避免在运行时覆盖配置的改变，相反，你就把它放在后面  
\# 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.  
//如果您感兴趣的是使用包括重写配置选项，最好使用include作为最后一行。  
\# 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

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# GENERAL常用 ######

//默认情况下 redis 不是作为守护进程运行的，如果你想让它在后台运行，你就把它改成 yes。  
\# By default Redis does not run as a daemon. Use ‘yes’ if you need it.  
//当redis作为守护进程运行的时候，它会写一个 pid 到 /var/run/redis.pid 文件里面。  
\# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.  
daemonize no  
//当redis作为守护进程运行的时候，它会把 pid 默认写到 /var/run/redis.pid 文件里面，但是你可以在这里自己制定它的文件位置。  
\# 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 /var/run/redis.pid  
//监听端口号，默认为 6379，如果你设为 0 ，redis 将不在 socket 上监听任何客户端连接。  
\# Accept connections on the specified port, default is 6379.  
\# If port 0 is specified Redis will not listen on a TCP socket.  
port 6379  
//TCP 监听的最大容纳数量  
\# 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  
//Linux 内核会一声不响的把这个值缩小成 /proc/sys/net/core/somaxconn 对应的值，所以你要修改这两个值才能达到你的预期。  
\# make sure to raise both the value of somaxconn and tcp\_max\_syn\_backlog  
\# in order to get the desired effect.  
tcp-backlog 511  
//默认情况下，redis 在 server 上所有有效的网络接口上监听客户端连接。  
//你如果只想让它在一个网络接口上监听，那你就绑定一个IP或者多个IP。  
\# 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  
//示例，多个IP用空格隔开  
\# interfaces using the “bind” configuration directive, followed by one or  
\# more IP addresses.  
\#  
\# Examples:  
\#  
\# bind 192.168.1.100 10.0.0.1  
\# bind 127.0.0.1  
//指定 unix socket 的路径。  
\# 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.  
\#  
\# unixsocket /tmp/redis.sock  
\# unixsocketperm 700  
//指定在一个 client 空闲多少秒之后关闭连接（0 就是不管它）  
\# Close the connection after a client is idle for N seconds (0 to disable)  
timeout 0  
//tcp 心跳包。  
\# TCP keepalive.  
//如果设置为非零，则在与客户端缺乏通讯的时候使用 SO\_KEEPALIVE 发送 tcp acks 给客户端。  
\# If non-zero, use SO\_KEEPALIVE to send TCP ACKs to clients in absence  
//这个之所有有用，主要由两个原因：  
//1.防止死的 peers  
//2.从网络的角度看连接的活跃性中间设备。  
\# 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 (适用于开发或测试阶段)  
\# 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  
//指定日志文件的位置  
logfile “”  
//要想把日志记录到系统日志，就把它改成 yes，  
\# To enable logging to the system logger, just set ‘syslog-enabled’ to yes,  
//也可以可选择性的更新其他的syslog 参数以达到你的要求  
\# and optionally update the other syslog parameters to suit your needs.  
\# syslog-enabled no  
//设置 syslog 的 identity。  
\# Specify the syslog identity.  
\# syslog-ident redis  
//设置 syslog 的 facility，必须是 USER 或者是 LOCAL0-LOCAL7 之间的值。  
\# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.  
\# syslog-facility local0  
//设置数据库的数目。默认数据库是 DB 0，你可以在每个连接上使用 select 命令选择一个不同的数据库，  
\# 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 必须是一个介于 0 到 databasees - 1 之间的值  
\# dbid is a number between 0 and ‘databases’-1  
databases 16

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# SNAPSHOTTING快照 ######

//存 DB 到磁盘：  
\# Save the DB on disk:  
//格式：save <间隔时间（秒）> <写入次数>  
\# save  
//根据给定的时间间隔和写入次数将数据保存到磁盘  
\# Will save the DB if both the given number of seconds and the given  
\# number of write operations against the DB occurred.  
//下面的例子的意思是：  
/\*  
900 秒内如果至少有 1 个 key 的值变化，则保存  
300 秒内如果至少有 10 个 key 的值变化，则保存  
60 秒内如果至少有 10000 个 key 的值变化，则保存  
\*/  
\# 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  
//注意：你可以注释掉所有的 save 行来停用保存功能,也可以直接一个空字符串来实现停用.  
\# Note: you can disable saving completely by commenting out all “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  
/\*  
默认情况下，如果 redis 最后一次的后台保存失败，redis 将停止接受写操作，这样以一种强硬的方式让用户知道数据不能正确的持久化到磁盘，否则就会没人注意到灾难的发生。  
\*/  
\# 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.  
//如果后台保存进程重新启动工作了，redis 也将自动的允许写操作。  
\# If the background saving process will start working again Redis will  
\# automatically allow writes again.  
//然而你要是安装了靠谱的监控，你可能不希望 redis 这样做，那你就改成 no 好了。或者您可能希望禁用此功能，Redis会继续工作，即使磁盘有问题。  
\# 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.  
stop-writes-on-bgsave-error yes  
//是否在 dump .rdb 数据库的时候使用 LZF 压缩字符串  
\# Compress string objects using LZF when dump .rdb databases?  
//默认都设为 yes  
\# For default that’s set to ‘yes’ as it’s almost always a win.  
//如果你希望保存子进程节省点 cpu ，你就设置它为 no ，  
\# 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

\# 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.  
//是否校验rdb文件  
rdbchecksum yes  
//设置 dump 的文件位置  
\# The filename where to dump the DB  
dbfilename dump.rdb  
//工作目录  
\# The working directory.  
//例如上面的 dbfilename 只指定了文件名，  
\# 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.  
dir ./

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# REPLICATION主从复制 ######

//主从复制。使用 slaveof 来让一个 redis 实例成为另一个reids 实例的副本。  
//注意这个只需要在 slave 上配置。  
\# Master-Slave replication. Use slaveof to make a Redis instance a copy of  
\# another Redis server. A few things to understand ASAP about Redis replication.  
//对redis复制需要了解：  
//Redis复制是异步的，但你可以配置一个主停止接受写入，如果它似乎与至少一个给定数量的丛属没有连接。  
\# 1) Redis replication is asynchronous, but you can configure a master to  
\# stop accepting writes if it appears to be not connected with at least  
\# a given number of slaves.  
//Redis从属可以执行部分同步主redis，如果复制链路则丢失相对少量的时间。  
\# 2) Redis slaves are able to perform a partial resynchronization with the  
\# master if the replication link is lost for a relatively small amount of  
//你可以配置复制积压大小，并根据需要选择合理的值。  
\# time. You may want to configure the replication backlog size (see the next  
\# sections of this file) with a sensible value depending on your needs.  
//复制是自动的，不需要用户干预。在网络分区的从属会自动尝试重新连接到他们的主redis并同步。  
\# 3) Replication is automatic and does not need user intervention. After a  
\# network partition slaves automatically try to reconnect to masters  
\# and resynchronize with them.  
\#  
\# slaveof  
//如果master设置了requirepass，那么slave要连上master，需要有master的密码才行。masterauth就是用来配置master的密码，这样可以在连上master后进行认证。  
\# 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  
//当从库同主机失去连接或者复制正在进行，从机库有两种运行方式：1) 如果slave-serve-stale-data设置为yes(默认设置)，从库会继续响应客户端的请求。2) 如果slave-serve-stale-data设置为no，除去INFO和SLAVOF命令之外的任何请求都会返回一个错误”SYNC with master in progress”。  
\# 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.  
\#  
slave-serve-stale-data yes  
/\*你可以配置一个 slave 实体是否接受写入操作。  
通过写入操作来存储一些短暂的数据对于一个 slave 实例来说可能是有用的，  
因为相对从 master 重新同步数而言，据数据写入到 slave 会更容易被删除。  
但是如果客户端因为一个错误的配置写入，也可能会导致一些问题。  
\*/  
\# 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.  
//从 redis 2.6 版起，默认 slaves 都是只读的。  
\# 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.  
//作为从服务器，默认情况下是只读的（yes），可以修改成NO，用于写（不建议）。  
slave-read-only yes

\# Replication SYNC strategy: disk or socket.  
\#  
\# ——————————————————-  
\# WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY  
\# ——————————————————-  
/\*  
是否使用socket方式复制数据。目前redis复制提供两种方式，disk和socket。如果新的slave连上来或者重连的slave无法部分同步，就会执行全量同步，master会生成rdb文件。有2种方式：disk方式是master创建一个新的进程把rdb文件保存到磁盘，再把磁盘上的rdb文件传递给slave。socket是master创建一个新的进程，直接把rdb文件以socket的方式发给slave。disk方式的时候，当一个rdb保存的过程中，多个slave都能共享这个rdb文件。socket的方式就的一个个slave顺序复制。在磁盘速度缓慢，网速快的情况下推荐用socket方式。  
\*/  
\# New slaves and reconnecting slaves that are not able to continue the replication  
\# process just receiving differences, need to do what is called a “full  
\# synchronization”. An RDB file is transmitted from the master to the slaves.  
\# The transmission can happen in two different ways:  
\#  
\# 1) Disk-backed: The Redis master creates a new process that writes the RDB  
\# file on disk. Later the file is transferred by the parent  
\# process to the slaves incrementally.  
\# 2) Diskless: The Redis master creates a new process that directly writes the  
\# RDB file to slave sockets, without touching the disk at all.  
\#  
\# With disk-backed replication, while the RDB file is generated, more slaves  
\# can be queued and served with the RDB file as soon as the current child producing  
\# the RDB file finishes its work. With diskless replication instead once  
\# the transfer starts, new slaves arriving will be queued and a new transfer  
\# will start when the current one terminates.  
\#  
\# When diskless replication is used, the master waits a configurable amount of  
\# time (in seconds) before starting the transfer in the hope that multiple slaves  
\# will arrive and the transfer can be parallelized.  
\#  
\# With slow disks and fast (large bandwidth) networks, diskless replication  
\# works better.  
repl-diskless-sync no

\# When diskless replication is enabled, it is possible to configure the delay  
\# the server waits in order to spawn the child that transfers the RDB via socket  
\# to the slaves.  
\#  
\# This is important since once the transfer starts, it is not possible to serve  
\# new slaves arriving, that will be queued for the next RDB transfer, so the server  
\# waits a delay in order to let more slaves arrive.  
\#  
\# The delay is specified in seconds, and by default is 5 seconds. To disable  
\# it entirely just set it to 0 seconds and the transfer will start ASAP.  
//diskless复制的延迟时间，防止设置为0。一旦复制开始，节点不会再接收新slave的复制请求直到下一个rdb传输。所以最好等待一段时间，等更多的slave连上来。  
repl-diskless-sync-delay 5

\# 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.  
//slave根据指定的时间间隔向服务器发送ping请求。时间间隔可以通过 repl\_ping\_slave\_period 来设置，默认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.  
//复制连接超时时间。master和slave都有超时时间的设置。master检测到slave上次发送的时间超过repl-timeout，即认为slave离线，清除该slave信息。slave检测到上次和master交互的时间超过repl-timeout，则认为master离线。需要注意的是repl-timeout需要设置一个比repl-ping-slave-period更大的值，不然会经常检测到超时。  
\# 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.  
//是否禁止复制tcp链接的tcp nodelay参数，可传递yes或者no。默认是no，即使用tcp nodelay。如果master设置了yes来禁止tcp nodelay设置，在把数据复制给slave的时候，会减少包的数量和更小的网络带宽。但是这也可能带来数据的延迟。默认我们推荐更小的延迟，但是在数据量传输很大的场景下，建议选择yes。  
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 bigger 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离线的时候，不需要完全复制master的数据，如果可以执行部分同步，只需要把缓冲区的部分数据复制给slave，就能恢复正常复制状态。缓冲区的大小越大，slave离线的时间可以更长，复制缓冲区只有在有slave连接的时候才分配内存。没有slave的一段时间，内存会被释放出来，默认1m。  
\# 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.  
//master没有slave一段时间会释放复制缓冲区的内存，repl-backlog-ttl用来设置该时间长度。单位为秒。  
\# 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.  
//当master不可用，Sentinel会根据slave的优先级选举一个master。最低的优先级的slave，当选master。而配置成0，永远不会被选举。  
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 GUARANTEE 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:  
//redis提供了可以让master停止写入的方式，如果配置了min-slaves-to-write，健康的slave的个数小于N，mater就禁止写入。master最少得有多少个健康的slave存活才能执行写命令。这个配置虽然不能保证N个slave都一定能接收到master的写操作，但是能避免没有足够健康的slave的时候，master不能写入来避免数据丢失。设置为0是关闭该功能。  
\# min-slaves-to-write 3  
//延迟小于min-slaves-max-lag秒的slave才认为是健康的slave。  
\# 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  
//设置1或另一个设置为0禁用这个特性。  
\# min-slaves-max-lag is set to 10.

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# SECURITY安全 ######

//requirepass配置可以让用户使用AUTH命令来认证密码，才能使用其他命令。这让redis可以使用在不受信任的网络中。为了保持向后的兼容性，可以注释该命令，因为大部分用户也不需要认证。使用requirepass的时候需要注意，因为redis太快了，每秒可以认证15w次密码，简单的密码很容易被攻破，所以最好使用一个更复杂的密码。  
\# 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.  
\#  
\# 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.  
\#  
\# Example:  
//把危险的命令给修改成其他名称。比如CONFIG命令可以重命名为一个很难被猜到的命令，这样用户不能使用，而内部工具还能接着使用。  
\# 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个客户端连接。由于redis不区分连接是客户端连接还是内部打开文件或者和slave连接等，所以maxclients最小建议设置到32。如果超过了maxclients，redis会给新的连接发送’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策略进行处理。注意slave的输出缓冲区是不计算在maxmemory内的。所以为了防止主机内存使用完，建议设置的maxmemory需要更小一些。  
\# 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 according 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 no suitable keys for eviction.  
\#  
\# At the date of writing these 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:  
/\*  
内存容量超过maxmemory后的处理策略。  
\#volatile-lru：利用LRU算法移除设置过过期时间的key。  
\#volatile-random：随机移除设置过过期时间的key。  
\#volatile-ttl：移除即将过期的key，根据最近过期时间来删除（辅以TTL）  
\#allkeys-lru：利用LRU算法移除任何key。  
\#allkeys-random：随机移除任何key。  
\#noeviction：不移除任何key，只是返回一个写错误。  
\#上面的这些驱逐策略，如果redis没有合适的key驱逐，对于写命令，还是会返回错误。redis将不再接收写请求，只接收get请求。  
\*/  
\# maxmemory-policy noeviction

\# LRU and minimal TTL algorithms are not precise algorithms but approximated  
\# algorithms (in order to save memory), so you can tune it for speed or  
\# accuracy. For default Redis will check five keys and pick the one that was  
\# used less recently, you can change the sample size using the following  
\# configuration directive.  
\#  
\# The default of 5 produces good enough results. 10 Approximates very closely  
\# true LRU but costs a bit more CPU. 3 is very fast but not very accurate.  
//lru检测的样本数。使用lru或者ttl淘汰算法，从需要淘汰的列表中随机选择sample个key，选出闲置时间最长的key移除。  
\# maxmemory-samples 5

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# 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使用的是rdb方式持久化，这种方式在许多应用中已经足够用了。但是redis如果中途宕机，会导致可能有几分钟的数据丢失，根据save来策略进行持久化，Append Only File是另一种持久化方式，可以提供更好的持久化特性。Redis会把每次写入的数据在接收后都写入 appendonly.aof 文件，每次启动时Redis都会先把这个文件的数据读入内存里，先忽略RDB文件。  
\*/  
appendonly no  
//aof文件名  
\# 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 of waiting 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”.

\# appendfsync always  
/\*  
\#aof持久化策略的配置  
\#no表示不执行fsync，由操作系统保证数据同步到磁盘，速度最快。  
\#always表示每次写入都执行fsync，以保证数据同步到磁盘。  
\#everysec表示每秒执行一次fsync，可能会导致丢失这1s数据。  
\*/  
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.  
/\*  
在aof重写或者写入rdb文件的时候，会执行大量IO，此时对于everysec和always的aof模式来说，执行fsync会造成阻塞过长时间，no-appendfsync-on-rewrite字段设置为默认设置为no。如果对延迟要求很高的应用，这个字段可以设置为yes，否则还是设置为no，这样对持久化特性来说这是更安全的选择。设置为yes表示rewrite期间对新写操作不fsync,暂时存在内存中,等rewrite完成后再写入，默认为no，建议yes。Linux的默认fsync策略是30秒。可能丢失30秒数据  
\*/  
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文件大小超过上一次重写的aof文件大小的百分之多少进行重写，即当aof文件增长到一定大小的时候Redis能够调用bgrewriteaof对日志文件进行重写。当前AOF文件大小是上次日志重写得到AOF文件大小的二倍（设置为100）时，自动启动新的日志重写过程。  
\*/  
auto-aof-rewrite-percentage 100  
//设置允许重写的最小aof文件大小，避免了达到约定百分比但尺寸仍然很小的情况还要重写  
auto-aof-rewrite-min-size 64mb

\# An AOF file may be found to be truncated at the end during the Redis  
\# startup process, when the AOF data gets loaded back into memory.  
\# This may happen when the system where Redis is running  
\# crashes, especially when an ext4 filesystem is mounted without the  
\# data=ordered option (however this can’t happen when Redis itself  
\# crashes or aborts but the operating system still works correctly).  
\#  
\# Redis can either exit with an error when this happens, or load as much  
\# data as possible (the default now) and start if the AOF file is found  
\# to be truncated at the end. The following option controls this behavior.  
\#  
\# If aof-load-truncated is set to yes, a truncated AOF file is loaded and  
\# the Redis server starts emitting a log to inform the user of the event.  
\# Otherwise if the option is set to no, the server aborts with an error  
\# and refuses to start. When the option is set to no, the user requires  
\# to fix the AOF file using the “redis-check-aof” utility before to restart  
\# the server.  
\#  
\# Note that if the AOF file will be found to be corrupted in the middle  
\# the server will still exit with an error. This option only applies when  
\# Redis will try to read more data from the AOF file but not enough bytes  
\# will be found.  
/\*  
aof文件可能在尾部是不完整的，当redis启动的时候，aof文件的数据被载入内存。重启可能发生在redis所在的主机操作系统宕机后，尤其在ext4文件系统没有加上data=ordered选项（redis宕机或者异常终止不会造成尾部不完整现象。）出现这种现象，可以选择让redis退出，或者导入尽可能多的数据。如果选择的是yes，当截断的aof文件被导入的时候，会自动发布一个log给客户端然后load。如果是no，用户必须手动redis-check-aof修复AOF文件才可以。  
\*/  
aof-load-truncated yes

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# 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 exceeds 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 command was  
\# already issued by the script but the user doesn’t want to wait for the natural  
\# termination of the script.  
\#  
\# Set it to 0 or a negative value for unlimited execution without warnings.  
//如果达到最大时间限制（毫秒），redis会记个log，然后返回error。当一个脚本超过了最大时限。只有SCRIPT KILL和SHUTDOWN NOSAVE可以用。第一个可以杀没有调write命令的东西。要是已经调用了write，只能用第二个命令杀。  
lua-time-limit 5000

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# REDIS CLUSTER ######

\#  
\# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
\# WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however  
\# in order to mark it as “mature” we need to wait for a non trivial percentage  
\# of users to deploy it in production.  
\# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
\#  
\# Normal Redis instances can’t be part of a Redis Cluster; only nodes that are  
\# started as cluster nodes can. In order to start a Redis instance as a  
\# cluster node enable the cluster support uncommenting the following:  
//集群开关，默认是不开启集群模式。  
\# cluster-enabled yes

\# Every cluster node has a cluster configuration file. This file is not  
\# intended to be edited by hand. It is created and updated by Redis nodes.  
\# Every Redis Cluster node requires a different cluster configuration file.  
\# Make sure that instances running in the same system do not have  
\# overlapping cluster configuration file names.  
//集群配置文件的名称，每个节点都有一个集群相关的配置文件，持久化保存集群的信息。这个文件并不需要手动配置，这个配置文件有Redis生成并更新，每个Redis集群节点需要一个单独的配置文件，请确保与实例运行的系统中配置文件名称不冲突  
\# cluster-config-file nodes-6379.conf

\# Cluster node timeout is the amount of milliseconds a node must be unreachable  
\# for it to be considered in failure state.  
\# Most other internal time limits are multiple of the node timeout.  
//节点互连超时的阀值。集群节点超时毫秒数  
\# cluster-node-timeout 15000

\# A slave of a failing master will avoid to start a failover if its data  
\# looks too old.  
\#  
\# There is no simple way for a slave to actually have a exact measure of  
\# its “data age”, so the following two checks are performed:  
\#  
\# 1) If there are multiple slaves able to failover, they exchange messages  
\# in order to try to give an advantage to the slave with the best  
\# replication offset (more data from the master processed).  
\# Slaves will try to get their rank by offset, and apply to the start  
\# of the failover a delay proportional to their rank.  
\#  
\# 2) Every single slave computes the time of the last interaction with  
\# its master. This can be the last ping or command received (if the master  
\# is still in the “connected” state), or the time that elapsed since the  
\# disconnection with the master (if the replication link is currently down).  
\# If the last interaction is too old, the slave will not try to failover  
\# at all.  
\#  
\# The point “2” can be tuned by user. Specifically a slave will not perform  
\# the failover if, since the last interaction with the master, the time  
\# elapsed is greater than:  
\#  
\# (node-timeout \* slave-validity-factor) + repl-ping-slave-period  
\#  
\# So for example if node-timeout is 30 seconds, and the slave-validity-factor  
\# is 10, and assuming a default repl-ping-slave-period of 10 seconds, the  
\# slave will not try to failover if it was not able to talk with the master  
\# for longer than 310 seconds.  
\#  
\# A large slave-validity-factor may allow slaves with too old data to failover  
\# a master, while a too small value may prevent the cluster from being able to  
\# elect a slave at all.  
\#  
\# For maximum availability, it is possible to set the slave-validity-factor  
\# to a value of 0, which means, that slaves will always try to failover the  
\# master regardless of the last time they interacted with the master.  
\# (However they’ll always try to apply a delay proportional to their  
\# offset rank).  
\#  
\# Zero is the only value able to guarantee that when all the partitions heal  
\# the cluster will always be able to continue.  
/\*  
在进行故障转移的时候，全部slave都会请求申请为master，但是有些slave可能与master断开连接一段时间了，导致数据过于陈旧，这样的slave不应该被提升为master。该参数就是用来判断slave节点与master断线的时间是否过长。判断方法是：  
\#比较slave断开连接的时间和(node-timeout \* slave-validity-factor) + repl-ping-slave-period  
\#如果节点超时时间为三十秒, 并且slave-validity-factor为10,假设默认的repl-ping-slave-period是10秒，即如果超过310秒slave将不会尝试进行故障转移  
\*/  
\# cluster-slave-validity-factor 10

\# Cluster slaves are able to migrate to orphaned masters, that are masters  
\# that are left without working slaves. This improves the cluster ability  
\# to resist to failures as otherwise an orphaned master can’t be failed over  
\# in case of failure if it has no working slaves.  
\#  
\# Slaves migrate to orphaned masters only if there are still at least a  
\# given number of other working slaves for their old master. This number  
\# is the “migration barrier”. A migration barrier of 1 means that a slave  
\# will migrate only if there is at least 1 other working slave for its master  
\# and so forth. It usually reflects the number of slaves you want for every  
\# master in your cluster.  
\#  
\# Default is 1 (slaves migrate only if their masters remain with at least  
\# one slave). To disable migration just set it to a very large value.  
\# A value of 0 can be set but is useful only for debugging and dangerous  
\# in production.  
//master的slave数量大于该值，slave才能迁移到其他孤立master上，如这个参数若被设为2，那么只有当一个主节点拥有2 个可工作的从节点时，它的一个从节点会尝试迁移。  
\# cluster-migration-barrier 1

\# By default Redis Cluster nodes stop accepting queries if they detect there  
\# is at least an hash slot uncovered (no available node is serving it).  
\# This way if the cluster is partially down (for example a range of hash slots  
\# are no longer covered) all the cluster becomes, eventually, unavailable.  
\# It automatically returns available as soon as all the slots are covered again.  
\#  
\# However sometimes you want the subset of the cluster which is working,  
\# to continue to accept queries for the part of the key space that is still  
\# covered. In order to do so, just set the cluster-require-full-coverage  
\# option to no.  
//默认情况下，集群全部的slot有节点负责，集群状态才为ok，才能提供服务。设置为no，可以在slot没有全部分配的时候提供服务。不建议打开该配置，这样会造成分区的时候，小分区的master一直在接受写请求，而造成很长时间数据不一致。  
\# cluster-require-full-coverage yes

\# In order to setup your cluster make sure to read the documentation  
\# available at [http://redis.io][http_redis.io] web site.

###### \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\# 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.

\# 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.  
//slog log是用来记录redis运行中执行比较慢的命令耗时。当命令的执行超过了指定时间，就记录在slow log中，slog log保存在内存中，所以没有IO操作。  
//执行时间比slowlog-log-slower-than大的请求记录到slowlog里面，单位是微秒，所以1000000就是1秒。注意，负数时间会禁用慢查询日志，而0则会强制记录所有命令。  
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 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 enabled at runtime using the command  
\# “CONFIG SET latency-monitor-threshold ” if needed.  
//延迟监控功能是用来监控redis中执行比较缓慢的一些操作，用LATENCY打印redis实例在跑命令时的耗时图表。只记录大于等于下边设置的值的操作。0的话，就是关闭监视。默认延迟监控功能是关闭的，如果你需要打开，也可以通过CONFIG SET命令动态设置。  
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/notifications][http_redis.io_topics_notifications]  
\#  
\# 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, …  
\# String commands    
\#  l     List commands    
\#  s     Set commands    
\#  h     Hash commands    
\#  z     Sorted set commands    
\#  x     Expired events (events generated every time a key expires)    
\#  e     Evicted events (events generated when a key is evicted for maxmemory)    
\#  A     Alias for g String commands  \#  l     List commands  \#  s     Set commands  \#  h     Hash commands  \#  z     Sorted set commands  \#  x     Expired events (events generated every time a key expires)  \#  e     Evicted events (events generated when a key is evicted for maxmemory)  \#  A     Alias for g lshzxe, so that the “AKE” string means all the events.  
\#  
\# The “notify-keyspace-events” takes as argument a string that is composed  
\# of zero or multiple characters. The empty string means that notifications  
\# are disabled.  
\#  
\# 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 数据集的事件。因为开启键空间通知功能需要消耗一些 CPU ，所以在默认配置下，该功能处于关闭状态。  
\#notify-keyspace-events 的参数可以是以下字符的任意组合，它指定了服务器该发送哪些类型的通知：

##K 键空间通知，所有通知以 keyspace@ 为前缀

##E 键事件通知，所有通知以 keyevent@ 为前缀

##g DEL 、 EXPIRE 、 RENAME 等类型无关的通用命令的通知

##$ 字符串命令的通知

##l 列表命令的通知

##s 集合命令的通知

##h 哈希命令的通知

##z 有序集合命令的通知

##x 过期事件：每当有过期键被删除时发送

##e 驱逐(evict)事件：每当有键因为 maxmemory 政策而被删除时发送

##A 参数 g$lshzxe 的别名

#输入的参数中至少要有一个 K 或者 E，否则的话，不管其余的参数是什么，都不会有任何 通知被分发。详细使用可以参考

[http://redis.io/topics/notifications][http_redis.io_topics_notifications]  
\*/  
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-max-ziplist-entries的用ziplist，大于hash-max-ziplist-entries用hash  
hash-max-ziplist-entries 512  
//value大小小于等于hash-max-ziplist-value的用ziplist，大于hash-max-ziplist-value用hash。  
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-max-ziplist-entries用ziplist，大于list-max-ziplist-entries用list。  
list-max-ziplist-entries 512  
//value大小小于等于list-max-ziplist-value的用ziplist，大于list-max-ziplist-value用list。  
list-max-ziplist-value 64

\# Sets have a special encoding in just one case: when a set is composed  
\# of just strings that happen 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.  
//数据量小于等于set-max-intset-entries用iniset，大于set-max-intset-entries用set。  
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:  
//数据量小于等于zset-max-ziplist-entries用ziplist，大于zset-max-ziplist-entries用zset。  
zset-max-ziplist-entries 128  
//value大小小于等于zset-max-ziplist-value用ziplist，大于zset-max-ziplist-value用zset。  
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.  
//value大小小于等于hll-sparse-max-bytes使用稀疏数据结构（sparse），大于hll-sparse-max-bytes使用稠密的数据结构（dense）。一个比16000大的value是几乎没用的，建议的value大概为3000。如果对CPU要求不高，对空间要求较高的，建议设置到10000左右。  
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  
\# actively rehash 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 from 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

\# 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:  
\#  
\# 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.  
//对客户端输出缓冲进行限制可以强迫那些不从服务器读取数据的客户端断开连接，用来强制关闭传输缓慢的客户端。  
//对于normal client，第一个0表示取消hard limit，第二个0和第三个0表示取消soft limit，normal client默认取消限制，因为如果没有寻问，他们是不会接收数据的。  
client-output-buffer-limit normal 0 0 0  
//对于slave client和MONITER client，如果client-output-buffer一旦超过256mb，又或者超过64mb持续60秒，那么服务器就会立即断开客户端连接。  
client-output-buffer-limit slave 256mb 64mb 60  
//对于pubsub client，如果client-output-buffer一旦超过32mb，又或者超过8mb持续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 according 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执行任务的频率为1s除以hz。  
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重写的时候，如果打开了aof-rewrite-incremental-fsync开关，系统会每32MB执行一次fsync。这对于把文件写入磁盘是有帮助的，可以避免过大的延迟峰值。  
aof-rewrite-incremental-fsync yes

--------------------

## 好吧，终于罗列完了，其实这个罗列大多方便自己复习的时候用而已。接下来，我们来看看我们需要重点关注的配置吧： ##

## 重点配置：（针对初学者，进阶的我们往后以方案形式来讲） ##

（1）.Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程  
daemonize no  
（2）.当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定  
pidfile /var/run/redis.pid  
（3）.指定Redis监听端口，默认端口为6379  
port 6379  
（4）.绑定的主机地址  
bind 127.0.0.1  
（5）.当 客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能  
timeout 300  
（6）指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose  
loglevel debug  
（7）设置数据库的数量，默认数据库为0，可以使用SELECT 命令在连接上指定数据库id  
databases 16  
（8） 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合  
save 900 1  
save 300 10  
save 60 10000  
（9）指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大  
rdbcompression yes  
（10）指定本地数据库文件名，默认值为dump.rdb  
dbfilename dump.rdb  
（11）指定本地数据库存放目录  
dir ./  
（12）设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步  
slaveof  
（13）当master服务设置了密码保护时，slav服务连接master的密码  
masterauth  
（14）设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH 命令提供密码，默认关闭  
requirepass foobared  
（15）设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息  
maxclients 128  
（16）指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no  
appendonly no  
（17）指定更新日志文件名，默认为appendonly.aof  
appendfilename appendonly.aof  
（18）指定更新日志条件，共有3个可选值：  
no：表示等操作系统进行数据缓存同步到磁盘（快）  
always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）  
everysec：表示每秒同步一次（折衷，默认值）  
appendfsync everysec

[70]: /images/20220529/3f489998f0c843a7a1a5f5441a3a1fed.png
[70 1]: /images/20220529/4bdbe836e84e47daa8279b4f14b60685.png
[70 2]: /images/20220529/9d58854217004cc9903bf5bdbc159b55.png
[70 3]: /images/20220529/0b0d7f73564e476ab3c87a91c79a3b0a.png
[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]: http://redis.io
[http_redis.io_topics_notifications]: http://redis.io/topics/notifications