随笔分类
配置文件详解
linux下开始出厂默认配置文件一定要进行备份!
Units单位
# 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 //可见,k和kb是不一样的
# 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. //单位对大小写不敏感,即都是一样的
- 配置大小单位,开头定义了一些基本的度量单位,只支持bytes,不支持bit
- 对大小写不敏感
INCLUDES包含
################################## 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
# to customize a few per-server settings. Include files can include
# other files, so use this wisely.
# //这里包含一个或多个其他配置文件.这是有用的如果你想要有一个标准的模板去引用到所有的配置文件,但是也想要有自定义一些服务器设置.包含文件可以包含其他文件,所以要明智地去使用它
# Note that 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.
# //注意选项“include”不会被命令“CONFIG REWRITING”重写从管理员或Redis哨兵那.因为Redis总是使用最后处理的行作为配置指令的值,你最好放include以避免在运行时覆盖配置更改
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
# //如果你对使用include来覆盖配置感兴趣的话,最好使用include作为最后一行
# include /path/to/local.conf
# include /path/to/other.conf
和Structs2配置文件类似,可以通过includes包含,redis.conf可以作为总闸,包含其他其他的配置文件
Networks
################################## NETWORK #####################################
# By default, if no "bind" configuration directive is specified, Redis listens
# for connections from all available network interfaces on the host machine.
# It is possible to listen to just one or multiple selected 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 ::1
#
# ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
# internet, binding to all the interfaces is dangerous and will expose the
# instance to everybody on the internet. So by default we uncomment the
# following bind directive, that will force Redis to listen only on the
# IPv4 loopback interface address (this means Redis will only be able to
# accept client connections from the same host that it is running on).
#
# IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES
# JUST COMMENT OUT THE FOLLOWING LINE.
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bind 127.0.0.1 //默认本地访问,即绑定的ip
# Protected mode is a layer of security protection, in order to avoid that
# Redis instances left open on the internet are accessed and exploited.
#
# When protected mode is on and if:
#
# 1) The server is not binding explicitly to a set of addresses using the
# "bind" directive.
# 2) No password is configured.
#
# The server only accepts connections from clients connecting from the
# IPv4 and IPv6 loopback addresses 127.0.0.1 and ::1, and from Unix domain
# sockets.
#
# By default protected mode is enabled. You should disable it only if
# you are sure you want clients from other hosts to connect to Redis
# even if no authentication is configured, nor a specific set of interfaces
# are explicitly listed using the "bind" directive.
protected-mode yes //保护模式 默认开启
# Accept connections on the specified port, default is 6379 (IANA #815344).
# If port 0 is specified Redis will not listen on a TCP socket.
port 6379 //默认端口 6379
# TCP listen() backlog.
#
# In high requests-per-second environments you need a high backlog in order
# to avoid slow clients connection 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.
//设置tcp的backlog,backlog其实是一个连接队列,backlog队列总和 = 未完成三次握手队列 + 已经完成三次握手队列.在高并发环境下你需要配置一个高backlog值来避免慢客户端连接问题.注意Linux内核会将这个值减少到/proc/sys/net/core/somaxconn的值,所以需要增大somaxconn和tcp_max_syn_backlog两个值来达成想要的效果
tcp-backlog 511 //tcp-backlog默认出厂配置值为 511
# 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
# Close the connection after a client is idle for N seconds (0 to disable)
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) Force network equipment in the middle to consider the connection to be
# alive.
#
# 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.
#
# A reasonable value for this option is 300 seconds, which is the new
# Redis default starting with Redis 3.2.1.
tcp-keepalive 300 //单位为秒,如果设置为0,则不会进行Keepalive监测,一个合理的设置值为300,定时去监测redis的连接情况
通用设置 General
################################# 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.
daemonize yes //daemonize用来指定redis是否要用守护线程的方式进行启动,采用yes时,表示该redis将一直运行,除非手动kill该进程
# If you run Redis from upstart or systemd, Redis can interact with your
# supervision tree. Options:
# supervised no - no supervision interaction
# supervised upstart - signal upstart by putting Redis into SIGSTOP mode
# requires "expect stop" in your upstart job config
# supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
# supervised auto - detect upstart or systemd method based on
# UPSTART_JOB or NOTIFY_SOCKET environment variables
# Note: these supervision methods only signal "process is ready."
# They do not enable continuous pings back to your supervisor.
supervised no
# If a pid file is specified, Redis writes it where specified at startup
# and removes it at exit.
#
# When the server runs non daemonized, no pid file is created if none is
# specified in the configuration. When the server is daemonized, the pid file
# is used even if not specified, defaulting to "/var/run/redis.pid".
# //当服务器运行非守护化时,如果没有守护化,则不会去创建pid文件在配置中指定.当服务器被守护化时,pid文件即使没有被指定也会使用,默认使用路径 /var/run/redis.pid
# Creating a pid file is best effort: if Redis is not able to create it
# nothing bad happens, the server will start and run normally.
pidfile /var/run/redis_6379.pid //如果以后台的方式运行,那么就需要指定一个 pid文件
# Specify the server verbosity level. //显示日志的输出级别
# This can be one of: //Redis的日志级别有以下四种:从上到下日志级别逐渐增高
# debug (a lot of information, useful for development/testing) //debug用于开发和测试阶段
# 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 "" //指定日志文件名,空字符串也可以用来强制Redis登录标准输出,请注意,如果你使用的是标准的输出logging但是daemonize,日志将被发送到/dev/null
# To enable logging to the system logger, just set 'syslog-enabled' to yes,
# and optionally update the other syslog parameters to suit your needs.
# syslog-enabled no //是否把日志输出到syslog,默认 no
# Specify the syslog identity.
# syslog-ident redis //指定redis为syslog的标识符
# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
# syslog-facility local0 //指定syslog设置,可以是USER或者LOCAL0 - LOCAL7,默认是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 <dbid> where
# dbid is a number between 0 and 'databases'-1
databases 16 //redis默认有16个db,默认使用0号的db
# By default Redis shows an ASCII art logo only when started to log to the
# standard output and if the standard output is a TTY. Basically this means
# that normally a logo is displayed only in interactive sessions.
#
# However it is possible to force the pre-4.0 behavior and always show a
# ASCII art logo in startup logs by setting the following option to yes.
always-show-logo yes //是否总是显示logo
SNAPSHOTTING快照
持久化,在规定的时间内,执行了多少次操作,则会持久化到文件 .rdb .aof
Redis是个内存数据库,如果不进行持久化的话,数据就会丢失 --内存是断电即失的
################################ SNAPSHOTTING ################################
#
# Save the DB on disk:
#
# save <seconds> <changes>
#
# Will save the DB if both the given number of seconds and the given
# number of write operations against the DB occurred.
#
# In the example below the behavior 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 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 //如果在900s内,至少有一个key进行了修改,redis便会进行持久化操作
save 300 10 //如果在300s内,至少有10个key进行了修改,redis便会进行持久化操作
save 60 10000 //如果在60s内,至少有10000个key进行了修改,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.
#
# 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.
stop-writes-on-bgsave-error yes //如果持久化出现了错误,主进程是否还要继续进行写入 是
# Compress string objects using LZF when dump .rdb databases?
# By default compression is enabled as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes //是否压缩 rdb文件,需要消耗一些cpu的资源
# 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.
rdbchecksum yes //保存rdb文件时,使用CRC64算法来进行数据的校验,但是这样会增加10%的性能消耗
# The filename where to dump the DB
dbfilename dump.rdb //持久化文件名
# Remove RDB files used by replication in instances without persistence
# enabled. By default this option is disabled, however there are environments
# where for regulations or other security concerns, RDB files persisted on
# disk by masters in order to feed replicas, or stored on disk by replicas
# in order to load them for the initial synchronization, should be deleted
# ASAP. Note that this option ONLY WORKS in instances that have both AOF
# and RDB persistence disabled, otherwise is completely ignored.
#
# An alternative (and sometimes better) way to obtain the same effect is
# to use diskless replication on both master and replicas instances. However
# in the case of replicas, diskless is not always an option.
rdb-del-sync-files no
# 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.
dir ./ //持久化文件生成目录 rdb 默认当前目录
REPLICATION复制
主从复制
SECURITY 安全
Redis默认没有密码
但是也可以来进行设置
################################## SECURITY ###################################
//redis主要是用来做缓存的,默认没有对密码进行默认设置,但是这并不意味着redis本身不支持密码设置,设置密码后,之后的每条命令之前都要进行密码验证 auth password
# Warning: since Redis is pretty fast, an outside user can try up to
# 1 million passwords per second against a modern box. This means that you
# should use very strong passwords, otherwise they will be very easy to break.
# Note that because the password is really a shared secret between the client
# and the server, and should not be memorized by any human, the password
# can be easily a long string from /dev/urandom or whatever, so by using a
# long and unguessable password no brute force attack will be possible.
简单来说,就是
127.0.0.1:6379> config get requirepass //获取密码
1) "requirepass"
2) ""
127.0.0.1:6379> config set requirepass "wu913428" //设置密码
OK
127.0.0.1:6379> ping //没有权限使用命令
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth wu913428 //验证权限
OK
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set name liangye
OK
127.0.0.1:6379> get name
"liangye"
127.0.0.1:6379>
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).
# //设置同一时间最大客户端连接数,默认为无限制,Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符,如果maxclients 0,表示不作限制.
# Once the limit is reached Redis will close all the new connections sending
# an error 'max number of clients reached'.
# //当客户端的连接数达到限制后,Redis会关闭新的连接并且向客户端返回 max number of clients reached初五信息
# IMPORTANT: When Redis Cluster is used, the max number of connections is also
# shared with the cluster bus: every node in the cluster will use two
# connections, one incoming and another outgoing. It is important to size the
# limit accordingly in case of very large clusters.
#
# maxclients 10000 //最大同时连接客户数量:10000
# Set a memory usage limit to the specified amount of bytes. //指定Redis最大内存限制
# When the memory limit is reached Redis will try to remove keys //达到最大内存时,Redis会去清除根据所选的最大内存策略选择出来的key
# 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 or LFU cache, or to
# set a hard memory limit for an instance (using the 'noeviction' policy).
#
# WARNING: If you have replicas attached to an instance with maxmemory on,
# the size of the output buffers needed to feed the replicas 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 replicas 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 replicas attached it is suggested that you set a lower
# limit for maxmemory so that there is some free RAM on the system for replica
# output buffers (but this is not needed if the policy is 'noeviction').
#
# maxmemory <bytes> //Redis来配置最大的内存容量
# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory //内存达到上限的处理策略
# is reached. You can select one from the following behaviors:
# //最大内存策略,即当达成最大内存/缓存时,从以下策略中选择一种 --说白了就是进行缓存清洁操作
# volatile-lru -> Evict using approximated LRU, only keys with an expire set.
//使用LRU算法移除Key,只对设置了过期时间的键
# allkeys-lru -> Evict any key using approximated LRU.
//对所有keys使用LRU算法进行移除
# volatile-lfu -> Evict using approximated LFU, only keys with an expire set.
//使用LFU算法移除Key,只对设置了过期时间的键
# allkeys-lfu -> Evict any key using approximated LFU.
//对所有keys使用LFU算法进行移除
# volatile-random -> Remove a random key having an expire set.
//在过期集合中移除随机的key,只对设置了过期时间的键
# allkeys-random -> Remove a random key, any key.
//移除随机的key
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
//移除哪些TTL最小的key,即那些最近要过期的key
# noeviction -> Don't evict anything, just return an error on write operations.
# //不进行移除. 针对写操作,只是返回错误信息
# LRU means Least Recently Used
# LFU means Least Frequently Used
#
# Both LRU, LFU and volatile-ttl are implemented using approximated
# randomized algorithms.
#
# 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-policy noeviction //可见redis默认选择的是永不过期的策略 --真实开发中不会去选择noeviction,不合理
# LRU, LFU 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. By default Redis will check five keys and pick the one that was
# used least 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 more CPU. 3 is faster but not very accurate.
# //设置样本的数量,LRU、LFU、最小TTL都并非是精确的算法,而是估算值,所以你可以来设置样本的大小
//redis默认会检查这么多个key,并选择其中LRU的那个
# maxmemory-samples 5 //默认样本数量为5,这是个较好的选择,选择10个的话好是好但是需要更多的CPU,选择3个的话虽然速度快但是不够精确
AOF
Append Only Mode aof 配置
############################## 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 for more information.
appendonly no //默认不开启AOF模式,默认使用rdb方式进行持久化,在大部分情况下,rdb完全够用
# 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
#
# If unsure, use "everysec".
//aof持久化的策略
# appendfsync always //每次修改都会进行sync,缓慢且安全
appendfsync everysec //每秒执行一次sync,可能会丢失这一秒的数据
# appendfsync no //不进行sync,让os自己来同步数据,速度更快
# 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.
no-appendfsync-on-rewrite no //是否开启重写机制,以来减小aof文件大小 --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.
auto-aof-rewrite-percentage 100 //aof自动重写配置,当前sof文件大小超过上一次重写的aof文件百分比多少时进行重写,这里是指当目前的aof文件大小时上一次日志重写时得到的aof文件大小的2倍是,自动开启新的日志重写
auto-aof-rewrite-min-size 64mb //设置允许重写的aof文件最小大小,这样可以避免达到了百分比但是文件小但仍然要去继续重写的情况
# 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-load-truncated yes
# When rewriting the AOF file, Redis is able to use an RDB preamble in the
# AOF file for faster rewrites and recoveries. When this option is turned
# on the rewritten AOF file is composed of two different stanzas:
#
# [RDB file][AOF tail]
#
# When loading, Redis recognizes that the AOF file starts with the "REDIS"
# string and loads the prefixed RDB file, then continues loading the AOF
# tail.
aof-use-rdb-preamble yes