目录

1 编写本文的初衷

2 具体实施

2.1 Redis持久化概念简介

2.2 获取指定RedisAOF持久化文件

2.3 把Redis的持久化AOF文件转换为RDB文件

 

 


因为目前实习工作需求,需要把服务器环境中所有Redis数据进行初步简单分析,即统计其中存储的每一个key所占内存的大小,以便作出清理不重要缓存数据的决策。

 

但是,由于从线上环境获得持久化文件为AOF文件,而不是RDB文件。RDB文件可以通过Rdbtools工具,来分析具体数据。但是AOF文件不能这样操作。

 

因此,就给我带来一个问题:如何通过AOF文件获取指定的RDB持久化文件呢?

 

于是,我通过查阅网上文章,获取的一个解决思路:单独在Redis中开启一个未使用过的端口服务,使用已得到的AOF文件替换该端口服务下自动生成的AOF文件;然后,重启该端口指定的Redis服务,即可把新的AOF文件中数据加载到Redis数据库中,最后在该端口服务客户端执行save或者bgsave命令,即可在指定路径下得到对应的RDB持久化文件。

 

 


Redis数据库进行持久化有两种方式:RDB持久化和AOF持久化。

 

那么,什么是RDB持久化呢?

RDB(Redis Database)持久化:可以将Redis在内存中的数据库状态保存到磁盘里面,避免数据意外丢失。RDB持久化既可以手动执行,也可以根据服务器配置选项定期执行,该功能可以将某个时间点上的数据库状态保存到一个RDB文件中。(PS:手动执行保存时,在客户端执行SAVE命令或者BGSAVE即可把当前所有数据保存到dump.rdb文件中,如果在线上执行,建议使用BGSAVE命令)

 

RDB文件具体功能:用于保存和还原Redis服务器所有数据库中的所有键值对数据。

 

那么,什么是AOF持久化呢?

AOF(Append Only File)持久化:与RDB持久化通过保存数据库中的键值对来记录数据库状态不同,AOF持久化是通过保存Redis服务器所执行的写命令来记录数据库状态的。AOF持久化功能的实现可以分为命令追加(append)、文件写入、文件同步(sync)三个步骤。

 

AOF文件具体功能:通过保存所有修改数据库的写命令请求来记录服务器的数据库状态。

 

 


一般情况,都是获取限制环境的AOF文件,那么如何在线上环境找到AOF文件呢?(PS:因为时间原因,可能忘记存储在哪里,所以以下提供一个搜索命令,方便操作)

  1. sudo find / -name '*.aof' # 此命令用于查找系统上所有以aof为后缀的文件 

通过该命令,查看具体文件的路径信息,即可确认自己需要获取的AOF文件。

确定后,通过一下命令把指定AOF文件拷贝到本地主机上:

  1. scp facelive@172.169.18.14:/home/facelive/prod_redis_data/redis/db-appendonly.aof . # 从服务器复制远程文件到本地当前所在根目录

 

 

 


关于redis.conf配置aof持久化文件读取修改配置简单介绍

(1)找到redis.conf文件,设置其中的字段属性:

  1. appendonly no ——> appendonly yes

此处也可以在redis客户端,使用指令来完成修改:

  1. redis 127.0.0.1:6379> config set appendonly yes
  2. OK
  3. redis 127.0.0.1:6379> BGREWRITEAOF # 用于重写生成aof文件
  4. Background append only file rewriting started

 

此选项为aof功能的开关,默认为“no”,可以通过“yes”来开启aof功能  

只有在“yes”下,aof重写/文件同步等特性才会生效  

(2)在redis.conf文件中,指定aof文件的名称

  1. appendfilename "appendonly.aof" # 这是文件中默认的配置名称,也可以自己修改指定的文件名称

 

(3)在redis.conf文件中,确认 aof操作中文件同步策略

配置默认结果:

  1. # appendfsync always
  2. appendfsync everysec
  3. # appendfsync no

 

即选用everysec,具体意思:

1. no:表示等操作系统进行数据缓存同步到磁盘.

2. always:表示每次更新操作后手动调用fsync() 将数据写到磁盘.

3. everysec:表示每秒同步一次.一般用everysec

(4)在redis.conf文件中,确认 aof-rewrite期间,appendfsync是否暂缓文件同步

配置默认结果:

  1. no-appendfsync-on-rewrite no

 

具体意思:

“no”表示“不暂缓”,“yes”表示“暂缓”,默认为“no”  

(5)在redis.conf文件中,确认 aof文件rewrite触发的最小文件尺寸(mb,gb),以及 相对于“上一次”rewrite,本次rewrite触发时aof文件应该增长的百分比

配置默认结果:

  1. auto-aof-rewrite-percentage 100
  2. auto-aof-rewrite-min-size 64mb

 

 

具体实施步骤:

(1) 创建一个新的redis.conf文件,该文件命名可采用redis_port.conf形式,例如:redis_6391.conf。该文件中内容起初完全何Redis默认的redis.conf文件中内容一致

 

(2) 修改redis_6391.conf指定的port值,在文件中搜索port把默认的6379修改为6391

 

(3) 修改redis_6391指定的dir值,在文件中搜索dir把默认的”.\”改为自己要存放文件的具体路径。该路径用于存放RDB文件和AOF文件

 

(4) 修改redis_6391指定的appendfilename值,在文件中搜索appendfilename把默认的”appendonly.aof”改为自己想要定义的文件名称,该文件即为AOF文件的最终名称

 

(5) 修改redis_6391指定的dbfilename值,在文件中搜索dbfilename把默认的”dump.rdb”改为自己想要定义的文件名称,该文件即为RDB文件的最终名称

 

(6) 此步骤最重要,修改redis_6391指定的appendonly值,在文件中搜索appendonly把默认的”no”改为”yes”。这句配置意思是Redis服务重启后,默认不加载AOF持久化文件恢复数据,而是去找RDB持久化文件恢复;如果修改为”yes”后,发现有AOF文件,会首先加载AOF文件恢复数据

以下给出我本机修改后的redis_6391.conf文件中具体配置代码:

  1. 1 # Redis configuration file example
  2. 2
  3. 3 # Note on units: when memory size is needed, it is possible to specify
  4. 4 # it in the usual form of 1k 5GB 4M and so forth:
  5. 5 #
  6. 6 # 1k => 1000 bytes
  7. 7 # 1kb => 1024 bytes
  8. 8 # 1m => 1000000 bytes
  9. 9 # 1mb => 1024*1024 bytes
  10. 10 # 1g => 1000000000 bytes
  11. 11 # 1gb => 1024*1024*1024 bytes
  12. 12 #
  13. 13 # units are case insensitive so 1GB 1Gb 1gB are all the same.
  14. 14
  15. 15 ################################## INCLUDES ###################################
  16. 16
  17. 17 # Include one or more other config files here. This is useful if you
  18. 18 # have a standard template that goes to all Redis server but also need
  19. 19 # to customize a few per-server settings. Include files can include
  20. 20 # other files, so use this wisely.
  21. 21 #
  22. 22 # Notice option "include" won't be rewritten by command "CONFIG REWRITE"
  23. 23 # from admin or Redis Sentinel. Since Redis always uses the last processed
  24. 24 # line as value of a configuration directive, you'd better put includes
  25. 25 # at the beginning of this file to avoid overwriting config change at runtime.
  26. 26 #
  27. 27 # If instead you are interested in using includes to override configuration
  28. 28 # options, it is better to use include as the last line.
  29. 29 #
  30. 30 # include /path/to/local.conf
  31. 31 # include /path/to/other.conf
  32. 32
  33. 33 ################################ GENERAL #####################################
  34. 34
  35. 35 # By default Redis does not run as a daemon. Use 'yes' if you need it.
  36. 36 # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
  37. 37 daemonize no
  38. 38
  39. 39 # When running daemonized, Redis writes a pid file in /var/run/redis.pid by
  40. 40 # default. You can specify a custom pid file location here.
  41. 41 pidfile /var/run/redis.pid
  42. 42
  43. 43 # Accept connections on the specified port, default is 6391.
  44. 44 # If port 0 is specified Redis will not listen on a TCP socket.
  45. 45 port 6391
  46. 46
  47. 47 # TCP listen() backlog.
  48. 48 #
  49. 49 # In high requests-per-second environments you need an high backlog in order
  50. 50 # to avoid slow clients connections issues. Note that the Linux kernel
  51. 51 # will silently truncate it to the value of /proc/sys/net/core/somaxconn so
  52. 52 # make sure to raise both the value of somaxconn and tcp_max_syn_backlog
  53. 53 # in order to get the desired effect.
  54. 54 tcp-backlog 511
  55. 55
  56. 56 # By default Redis listens for connections from all the network interfaces
  57. 57 # available on the server. It is possible to listen to just one or multiple
  58. 58 # interfaces using the "bind" configuration directive, followed by one or
  59. 59 # more IP addresses.
  60. 60 #
  61. 61 # Examples:
  62. 62 #
  63. 63 # bind 192.168.1.100 10.0.0.1
  64. 64 # bind 127.0.0.1
  65. 65
  66. 66 # Specify the path for the Unix socket that will be used to listen for
  67. 67 # incoming connections. There is no default, so Redis will not listen
  68. 68 # on a unix socket when not specified.
  69. 69 #
  70. 70 # unixsocket /tmp/redis.sock
  71. 71 # unixsocketperm 700
  72. 72
  73. 73 # Close the connection after a client is idle for N seconds (0 to disable)
  74. 74 timeout 0
  75. 75
  76. 76 # TCP keepalive.
  77. 77 #
  78. 78 # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
  79. 79 # of communication. This is useful for two reasons:
  80. 80 #
  81. 81 # 1) Detect dead peers.
  82. 82 # 2) Take the connection alive from the point of view of network
  83. 83 # equipment in the middle.
  84. 84 #
  85. 85 # On Linux, the specified value (in seconds) is the period used to send ACKs.
  86. 86 # Note that to close the connection the double of the time is needed.
  87. 87 # On other kernels the period depends on the kernel configuration.
  88. 88 #
  89. 89 # A reasonable value for this option is 60 seconds.
  90. 90 tcp-keepalive 0
  91. 91
  92. 92 # Specify the server verbosity level.
  93. 93 # This can be one of:
  94. 94 # debug (a lot of information, useful for development/testing)
  95. 95 # verbose (many rarely useful info, but not a mess like the debug level)
  96. 96 # notice (moderately verbose, what you want in production probably)
  97. 97 # warning (only very important / critical messages are logged)
  98. 98 loglevel notice
  99. 99
  100. 100 # Specify the log file name. Also the empty string can be used to force
  101. 101 # Redis to log on the standard output. Note that if you use standard
  102. 102 # output for logging but daemonize, logs will be sent to /dev/null
  103. 103 logfile ""
  104. 104
  105. 105 # To enable logging to the system logger, just set 'syslog-enabled' to yes,
  106. 106 # and optionally update the other syslog parameters to suit your needs.
  107. 107 # syslog-enabled no
  108. 108
  109. 109 # Specify the syslog identity.
  110. 110 # syslog-ident redis
  111. 111
  112. 112 # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
  113. 113 # syslog-facility local0
  114. 114
  115. 115 # Set the number of databases. The default database is DB 0, you can select
  116. 116 # a different one on a per-connection basis using SELECT <dbid> where
  117. 117 # dbid is a number between 0 and 'databases'-1
  118. 118 databases 16
  119. 119
  120. 120 ################################ SNAPSHOTTING ################################
  121. 121 #
  122. 122 # Save the DB on disk:
  123. 123 #
  124. 124 # save <seconds> <changes>
  125. 125 #
  126. 126 # Will save the DB if both the given number of seconds and the given
  127. 127 # number of write operations against the DB occurred.
  128. 128 #
  129. 129 # In the example below the behaviour will be to save:
  130. 130 # after 900 sec (15 min) if at least 1 key changed
  131. 131 # after 300 sec (5 min) if at least 10 keys changed
  132. 132 # after 60 sec if at least 10000 keys changed
  133. 133 #
  134. 134 # Note: you can disable saving at all commenting all the "save" lines.
  135. 135 #
  136. 136 # It is also possible to remove all the previously configured save
  137. 137 # points by adding a save directive with a single empty string argument
  138. 138 # like in the following example:
  139. 139 #
  140. 140 # save ""
  141. 141
  142. 142 save 900 1
  143. 143 save 300 10
  144. 144 save 60 10000
  145. 145
  146. 146 # By default Redis will stop accepting writes if RDB snapshots are enabled
  147. 147 # (at least one save point) and the latest background save failed.
  148. 148 # This will make the user aware (in a hard way) that data is not persisting
  149. 149 # on disk properly, otherwise chances are that no one will notice and some
  150. 150 # disaster will happen.
  151. 151 #
  152. 152 # If the background saving process will start working again Redis will
  153. 153 # automatically allow writes again.
  154. 154 #
  155. 155 # However if you have setup your proper monitoring of the Redis server
  156. 156 # and persistence, you may want to disable this feature so that Redis will
  157. 157 # continue to work as usual even if there are problems with disk,
  158. 158 # permissions, and so forth.
  159. 159 stop-writes-on-bgsave-error yes
  160. 160
  161. 161 # Compress string objects using LZF when dump .rdb databases?
  162. 162 # For default that's set to 'yes' as it's almost always a win.
  163. 163 # If you want to save some CPU in the saving child set it to 'no' but
  164. 164 # the dataset will likely be bigger if you have compressible values or keys.
  165. 165 rdbcompression yes
  166. 166
  167. 167 # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  168. 168 # This makes the format more resistant to corruption but there is a performance
  169. 169 # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
  170. 170 # for maximum performances.
  171. 171 #
  172. 172 # RDB files created with checksum disabled have a checksum of zero that will
  173. 173 # tell the loading code to skip the check.
  174. 174 rdbchecksum yes
  175. 175
  176. 176 # The filename where to dump the DB
  177. 177 dbfilename dump_6391.rdb
  178. 178
  179. 179 # The working directory.
  180. 180 #
  181. 181 # The DB will be written inside this directory, with the filename specified
  182. 182 # above using the 'dbfilename' configuration directive.
  183. 183 #
  184. 184 # The Append Only File will also be created inside this directory.
  185. 185 #
  186. 186 # Note that you must specify a directory here, not a file name.
  187. 187 dir /home/liuzhen/data
  188. 188
  189. 189 ################################# REPLICATION #################################
  190. 190
  191. 191 # Master-Slave replication. Use slaveof to make a Redis instance a copy of
  192. 192 # another Redis server. A few things to understand ASAP about Redis replication.
  193. 193 #
  194. 194 # 1) Redis replication is asynchronous, but you can configure a master to
  195. 195 # stop accepting writes if it appears to be not connected with at least
  196. 196 # a given number of slaves.
  197. 197 # 2) Redis slaves are able to perform a partial resynchronization with the
  198. 198 # master if the replication link is lost for a relatively small amount of
  199. 199 # time. You may want to configure the replication backlog size (see the next
  200. 200 # sections of this file) with a sensible value depending on your needs.
  201. 201 # 3) Replication is automatic and does not need user intervention. After a
  202. 202 # network partition slaves automatically try to reconnect to masters
  203. 203 # and resynchronize with them.
  204. 204 #
  205. 205 # slaveof <masterip> <masterport>
  206. 206
  207. 207 # If the master is password protected (using the "requirepass" configuration
  208. 208 # directive below) it is possible to tell the slave to authenticate before
  209. 209 # starting the replication synchronization process, otherwise the master will
  210. 210 # refuse the slave request.
  211. 211 #
  212. 212 # masterauth <master-password>
  213. 213
  214. 214 # When a slave loses its connection with the master, or when the replication
  215. 215 # is still in progress, the slave can act in two different ways:
  216. 216 #
  217. 217 # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
  218. 218 # still reply to client requests, possibly with out of date data, or the
  219. 219 # data set may just be empty if this is the first synchronization.
  220. 220 #
  221. 221 # 2) if slave-serve-stale-data is set to 'no' the slave will reply with
  222. 222 # an error "SYNC with master in progress" to all the kind of commands
  223. 223 # but to INFO and SLAVEOF.
  224. 224 #
  225. 225 slave-serve-stale-data yes
  226. 226
  227. 227 # You can configure a slave instance to accept writes or not. Writing against
  228. 228 # a slave instance may be useful to store some ephemeral data (because data
  229. 229 # written on a slave will be easily deleted after resync with the master) but
  230. 230 # may also cause problems if clients are writing to it because of a
  231. 231 # misconfiguration.
  232. 232 #
  233. 233 # Since Redis 2.6 by default slaves are read-only.
  234. 234 #
  235. 235 # Note: read only slaves are not designed to be exposed to untrusted clients
  236. 236 # on the internet. It's just a protection layer against misuse of the instance.
  237. 237 # Still a read only slave exports by default all the administrative commands
  238. 238 # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
  239. 239 # security of read only slaves using 'rename-command' to shadow all the
  240. 240 # administrative / dangerous commands.
  241. 241 slave-read-only yes
  242. 242
  243. 243 # Slaves send PINGs to server in a predefined interval. It's possible to change
  244. 244 # this interval with the repl_ping_slave_period option. The default value is 10
  245. 245 # seconds.
  246. 246 #
  247. 247 # repl-ping-slave-period 10
  248. 248
  249. 249 # The following option sets the replication timeout for:
  250. 250 #
  251. 251 # 1) Bulk transfer I/O during SYNC, from the point of view of slave.
  252. 252 # 2) Master timeout from the point of view of slaves (data, pings).
  253. 253 # 3) Slave timeout from the point of view of masters (REPLCONF ACK pings).
  254. 254 #
  255. 255 # It is important to make sure that this value is greater than the value
  256. 256 # specified for repl-ping-slave-period otherwise a timeout will be detected
  257. 257 # every time there is low traffic between the master and the slave.
  258. 258 #
  259. 259 # repl-timeout 60
  260. 260
  261. 261 # Disable TCP_NODELAY on the slave socket after SYNC?
  262. 262 #
  263. 263 # If you select "yes" Redis will use a smaller number of TCP packets and
  264. 264 # less bandwidth to send data to slaves. But this can add a delay for
  265. 265 # the data to appear on the slave side, up to 40 milliseconds with
  266. 266 # Linux kernels using a default configuration.
  267. 267 #
  268. 268 # If you select "no" the delay for data to appear on the slave side will
  269. 269 # be reduced but more bandwidth will be used for replication.
  270. 270 #
  271. 271 # By default we optimize for low latency, but in very high traffic conditions
  272. 272 # or when the master and slaves are many hops away, turning this to "yes" may
  273. 273 # be a good idea.
  274. 274 repl-disable-tcp-nodelay no
  275. 275
  276. 276 # Set the replication backlog size. The backlog is a buffer that accumulates
  277. 277 # slave data when slaves are disconnected for some time, so that when a slave
  278. 278 # wants to reconnect again, often a full resync is not needed, but a partial
  279. 279 # resync is enough, just passing the portion of data the slave missed while
  280. 280 # disconnected.
  281. 281 #
  282. 282 # The biggest the replication backlog, the longer the time the slave can be
  283. 283 # disconnected and later be able to perform a partial resynchronization.
  284. 284 #
  285. 285 # The backlog is only allocated once there is at least a slave connected.
  286. 286 #
  287. 287 # repl-backlog-size 1mb
  288. 288
  289. 289 # After a master has no longer connected slaves for some time, the backlog
  290. 290 # will be freed. The following option configures the amount of seconds that
  291. 291 # need to elapse, starting from the time the last slave disconnected, for
  292. 292 # the backlog buffer to be freed.
  293. 293 #
  294. 294 # A value of 0 means to never release the backlog.
  295. 295 #
  296. 296 # repl-backlog-ttl 3600
  297. 297
  298. 298 # The slave priority is an integer number published by Redis in the INFO output.
  299. 299 # It is used by Redis Sentinel in order to select a slave to promote into a
  300. 300 # master if the master is no longer working correctly.
  301. 301 #
  302. 302 # A slave with a low priority number is considered better for promotion, so
  303. 303 # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
  304. 304 # pick the one with priority 10, that is the lowest.
  305. 305 #
  306. 306 # However a special priority of 0 marks the slave as not able to perform the
  307. 307 # role of master, so a slave with priority of 0 will never be selected by
  308. 308 # Redis Sentinel for promotion.
  309. 309 #
  310. 310 # By default the priority is 100.
  311. 311 slave-priority 100
  312. 312
  313. 313 # It is possible for a master to stop accepting writes if there are less than
  314. 314 # N slaves connected, having a lag less or equal than M seconds.
  315. 315 #
  316. 316 # The N slaves need to be in "online" state.
  317. 317 #
  318. 318 # The lag in seconds, that must be <= the specified value, is calculated from
  319. 319 # the last ping received from the slave, that is usually sent every second.
  320. 320 #
  321. 321 # This option does not GUARANTEES that N replicas will accept the write, but
  322. 322 # will limit the window of exposure for lost writes in case not enough slaves
  323. 323 # are available, to the specified number of seconds.
  324. 324 #
  325. 325 # For example to require at least 3 slaves with a lag <= 10 seconds use:
  326. 326 #
  327. 327 # min-slaves-to-write 3
  328. 328 # min-slaves-max-lag 10
  329. 329 #
  330. 330 # Setting one or the other to 0 disables the feature.
  331. 331 #
  332. 332 # By default min-slaves-to-write is set to 0 (feature disabled) and
  333. 333 # min-slaves-max-lag is set to 10.
  334. 334
  335. 335 ################################## SECURITY ###################################
  336. 336
  337. 337 # Require clients to issue AUTH <PASSWORD> before processing any other
  338. 338 # commands. This might be useful in environments in which you do not trust
  339. 339 # others with access to the host running redis-server.
  340. 340 #
  341. 341 # This should stay commented out for backward compatibility and because most
  342. 342 # people do not need auth (e.g. they run their own servers).
  343. 343 #
  344. 344 # Warning: since Redis is pretty fast an outside user can try up to
  345. 345 # 150k passwords per second against a good box. This means that you should
  346. 346 # use a very strong password otherwise it will be very easy to break.
  347. 347 #
  348. 348 # requirepass foobared
  349. 349
  350. 350 # Command renaming.
  351. 351 #
  352. 352 # It is possible to change the name of dangerous commands in a shared
  353. 353 # environment. For instance the CONFIG command may be renamed into something
  354. 354 # hard to guess so that it will still be available for internal-use tools
  355. 355 # but not available for general clients.
  356. 356 #
  357. 357 # Example:
  358. 358 #
  359. 359 # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  360. 360 #
  361. 361 # It is also possible to completely kill a command by renaming it into
  362. 362 # an empty string:
  363. 363 #
  364. 364 # rename-command CONFIG ""
  365. 365 #
  366. 366 # Please note that changing the name of commands that are logged into the
  367. 367 # AOF file or transmitted to slaves may cause problems.
  368. 368
  369. 369 ################################### LIMITS ####################################
  370. 370
  371. 371 # Set the max number of connected clients at the same time. By default
  372. 372 # this limit is set to 10000 clients, however if the Redis server is not
  373. 373 # able to configure the process file limit to allow for the specified limit
  374. 374 # the max number of allowed clients is set to the current file limit
  375. 375 # minus 32 (as Redis reserves a few file descriptors for internal uses).
  376. 376 #
  377. 377 # Once the limit is reached Redis will close all the new connections sending
  378. 378 # an error 'max number of clients reached'.
  379. 379 #
  380. 380 # maxclients 10000
  381. 381
  382. 382 # Don't use more memory than the specified amount of bytes.
  383. 383 # When the memory limit is reached Redis will try to remove keys
  384. 384 # according to the eviction policy selected (see maxmemory-policy).
  385. 385 #
  386. 386 # If Redis can't remove keys according to the policy, or if the policy is
  387. 387 # set to 'noeviction', Redis will start to reply with errors to commands
  388. 388 # that would use more memory, like SET, LPUSH, and so on, and will continue
  389. 389 # to reply to read-only commands like GET.
  390. 390 #
  391. 391 # This option is usually useful when using Redis as an LRU cache, or to set
  392. 392 # a hard memory limit for an instance (using the 'noeviction' policy).
  393. 393 #
  394. 394 # WARNING: If you have slaves attached to an instance with maxmemory on,
  395. 395 # the size of the output buffers needed to feed the slaves are subtracted
  396. 396 # from the used memory count, so that network problems / resyncs will
  397. 397 # not trigger a loop where keys are evicted, and in turn the output
  398. 398 # buffer of slaves is full with DELs of keys evicted triggering the deletion
  399. 399 # of more keys, and so forth until the database is completely emptied.
  400. 400 #
  401. 401 # In short... if you have slaves attached it is suggested that you set a lower
  402. 402 # limit for maxmemory so that there is some free RAM on the system for slave
  403. 403 # output buffers (but this is not needed if the policy is 'noeviction').
  404. 404 #
  405. 405 # maxmemory <bytes>
  406. 406
  407. 407 # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
  408. 408 # is reached. You can select among five behaviors:
  409. 409 #
  410. 410 # volatile-lru -> remove the key with an expire set using an LRU algorithm
  411. 411 # allkeys-lru -> remove any key accordingly to the LRU algorithm
  412. 412 # volatile-random -> remove a random key with an expire set
  413. 413 # allkeys-random -> remove a random key, any key
  414. 414 # volatile-ttl -> remove the key with the nearest expire time (minor TTL)
  415. 415 # noeviction -> don't expire at all, just return an error on write operations
  416. 416 #
  417. 417 # Note: with any of the above policies, Redis will return an error on write
  418. 418 # operations, when there are not suitable keys for eviction.
  419. 419 #
  420. 420 # At the date of writing this commands are: set setnx setex append
  421. 421 # incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
  422. 422 # sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
  423. 423 # zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
  424. 424 # getset mset msetnx exec sort
  425. 425 #
  426. 426 # The default is:
  427. 427 #
  428. 428 # maxmemory-policy volatile-lru
  429. 429
  430. 430 # LRU and minimal TTL algorithms are not precise algorithms but approximated
  431. 431 # algorithms (in order to save memory), so you can select as well the sample
  432. 432 # size to check. For instance for default Redis will check three keys and
  433. 433 # pick the one that was used less recently, you can change the sample size
  434. 434 # using the following configuration directive.
  435. 435 #
  436. 436 # maxmemory-samples 3
  437. 437
  438. 438 ############################## APPEND ONLY MODE ###############################
  439. 439
  440. 440 # By default Redis asynchronously dumps the dataset on disk. This mode is
  441. 441 # good enough in many applications, but an issue with the Redis process or
  442. 442 # a power outage may result into a few minutes of writes lost (depending on
  443. 443 # the configured save points).
  444. 444 #
  445. 445 # The Append Only File is an alternative persistence mode that provides
  446. 446 # much better durability. For instance using the default data fsync policy
  447. 447 # (see later in the config file) Redis can lose just one second of writes in a
  448. 448 # dramatic event like a server power outage, or a single write if something
  449. 449 # wrong with the Redis process itself happens, but the operating system is
  450. 450 # still running correctly.
  451. 451 #
  452. 452 # AOF and RDB persistence can be enabled at the same time without problems.
  453. 453 # If the AOF is enabled on startup Redis will load the AOF, that is the file
  454. 454 # with the better durability guarantees.
  455. 455 #
  456. 456 # Please check http://redis.io/topics/persistence for more information.
  457. 457
  458. 458 appendonly yes
  459. 459
  460. 460 # The name of the append only file (default: "appendonly.aof")
  461. 461
  462. 462 appendfilename "appendonly_6391.aof"
  463. 463
  464. 464 # The fsync() call tells the Operating System to actually write data on disk
  465. 465 # instead to wait for more data in the output buffer. Some OS will really flush
  466. 466 # data on disk, some other OS will just try to do it ASAP.
  467. 467 #
  468. 468 # Redis supports three different modes:
  469. 469 #
  470. 470 # no: don't fsync, just let the OS flush the data when it wants. Faster.
  471. 471 # always: fsync after every write to the append only log . Slow, Safest.
  472. 472 # everysec: fsync only one time every second. Compromise.
  473. 473 #
  474. 474 # The default is "everysec", as that's usually the right compromise between
  475. 475 # speed and data safety. It's up to you to understand if you can relax this to
  476. 476 # "no" that will let the operating system flush the output buffer when
  477. 477 # it wants, for better performances (but if you can live with the idea of
  478. 478 # some data loss consider the default persistence mode that's snapshotting),
  479. 479 # or on the contrary, use "always" that's very slow but a bit safer than
  480. 480 # everysec.
  481. 481 #
  482. 482 # More details please check the following article:
  483. 483 # http://antirez.com/post/redis-persistence-demystified.html
  484. 484 #
  485. 485 # If unsure, use "everysec".
  486. 486
  487. 487 # appendfsync always
  488. 488 appendfsync everysec
  489. 489 # appendfsync no
  490. 490
  491. 491 # When the AOF fsync policy is set to always or everysec, and a background
  492. 492 # saving process (a background save or AOF log background rewriting) is
  493. 493 # performing a lot of I/O against the disk, in some Linux configurations
  494. 494 # Redis may block too long on the fsync() call. Note that there is no fix for
  495. 495 # this currently, as even performing fsync in a different thread will block
  496. 496 # our synchronous write(2) call.
  497. 497 #
  498. 498 # In order to mitigate this problem it's possible to use the following option
  499. 499 # that will prevent fsync() from being called in the main process while a
  500. 500 # BGSAVE or BGREWRITEAOF is in progress.
  501. 501 #
  502. 502 # This means that while another child is saving, the durability of Redis is
  503. 503 # the same as "appendfsync none". In practical terms, this means that it is
  504. 504 # possible to lose up to 30 seconds of log in the worst scenario (with the
  505. 505 # default Linux settings).
  506. 506 #
  507. 507 # If you have latency problems turn this to "yes". Otherwise leave it as
  508. 508 # "no" that is the safest pick from the point of view of durability.
  509. 509
  510. 510 no-appendfsync-on-rewrite no
  511. 511
  512. 512 # Automatic rewrite of the append only file.
  513. 513 # Redis is able to automatically rewrite the log file implicitly calling
  514. 514 # BGREWRITEAOF when the AOF log size grows by the specified percentage.
  515. 515 #
  516. 516 # This is how it works: Redis remembers the size of the AOF file after the
  517. 517 # latest rewrite (if no rewrite has happened since the restart, the size of
  518. 518 # the AOF at startup is used).
  519. 519 #
  520. 520 # This base size is compared to the current size. If the current size is
  521. 521 # bigger than the specified percentage, the rewrite is triggered. Also
  522. 522 # you need to specify a minimal size for the AOF file to be rewritten, this
  523. 523 # is useful to avoid rewriting the AOF file even if the percentage increase
  524. 524 # is reached but it is still pretty small.
  525. 525 #
  526. 526 # Specify a percentage of zero in order to disable the automatic AOF
  527. 527 # rewrite feature.
  528. 528
  529. 529 auto-aof-rewrite-percentage 100
  530. 530 auto-aof-rewrite-min-size 64mb
  531. 531
  532. 532 # An AOF file may be found to be truncated at the end during the Redis
  533. 533 # startup process, when the AOF data gets loaded back into memory.
  534. 534 # This may happen when the system where Redis is running
  535. 535 # crashes, especially when an ext4 filesystem is mounted without the
  536. 536 # data=ordered option (however this can't happen when Redis itself
  537. 537 # crashes or aborts but the operating system still works correctly).
  538. 538 #
  539. 539 # Redis can either exit with an error when this happens, or load as much
  540. 540 # data as possible (the default now) and start if the AOF file is found
  541. 541 # to be truncated at the end. The following option controls this behavior.
  542. 542 #
  543. 543 # If aof-load-truncated is set to yes, a truncated AOF file is loaded and
  544. 544 # the Redis server starts emitting a log to inform the user of the event.
  545. 545 # Otherwise if the option is set to no, the server aborts with an error
  546. 546 # and refuses to start. When the option is set to no, the user requires
  547. 547 # to fix the AOF file using the "redis-check-aof" utility before to restart
  548. 548 # the server.
  549. 549 #
  550. 550 # Note that if the AOF file will be found to be corrupted in the middle
  551. 551 # the server will still exit with an error. This option only applies when
  552. 552 # Redis will try to read more data from the AOF file but not enough bytes
  553. 553 # will be found.
  554. 554 aof-load-truncated yes
  555. 555
  556. 556 ################################ LUA SCRIPTING ###############################
  557. 557
  558. 558 # Max execution time of a Lua script in milliseconds.
  559. 559 #
  560. 560 # If the maximum execution time is reached Redis will log that a script is
  561. 561 # still in execution after the maximum allowed time and will start to
  562. 562 # reply to queries with an error.
  563. 563 #
  564. 564 # When a long running script exceed the maximum execution time only the
  565. 565 # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
  566. 566 # used to stop a script that did not yet called write commands. The second
  567. 567 # is the only way to shut down the server in the case a write commands was
  568. 568 # already issue by the script but the user don't want to wait for the natural
  569. 569 # termination of the script.
  570. 570 #
  571. 571 # Set it to 0 or a negative value for unlimited execution without warnings.
  572. 572 lua-time-limit 5000
  573. 573
  574. 574 ################################## SLOW LOG ###################################
  575. 575
  576. 576 # The Redis Slow Log is a system to log queries that exceeded a specified
  577. 577 # execution time. The execution time does not include the I/O operations
  578. 578 # like talking with the client, sending the reply and so forth,
  579. 579 # but just the time needed to actually execute the command (this is the only
  580. 580 # stage of command execution where the thread is blocked and can not serve
  581. 581 # other requests in the meantime).
  582. 582 #
  583. 583 # You can configure the slow log with two parameters: one tells Redis
  584. 584 # what is the execution time, in microseconds, to exceed in order for the
  585. 585 # command to get logged, and the other parameter is the length of the
  586. 586 # slow log. When a new command is logged the oldest one is removed from the
  587. 587 # queue of logged commands.
  588. 588
  589. 589 # The following time is expressed in microseconds, so 1000000 is equivalent
  590. 590 # to one second. Note that a negative number disables the slow log, while
  591. 591 # a value of zero forces the logging of every command.
  592. 592 slowlog-log-slower-than 10000
  593. 593
  594. 594 # There is no limit to this length. Just be aware that it will consume memory.
  595. 595 # You can reclaim memory used by the slow log with SLOWLOG RESET.
  596. 596 slowlog-max-len 128
  597. 597
  598. 598 ################################ LATENCY MONITOR ##############################
  599. 599
  600. 600 # The Redis latency monitoring subsystem samples different operations
  601. 601 # at runtime in order to collect data related to possible sources of
  602. 602 # latency of a Redis instance.
  603. 603 #
  604. 604 # Via the LATENCY command this information is available to the user that can
  605. 605 # print graphs and obtain reports.
  606. 606 #
  607. 607 # The system only logs operations that were performed in a time equal or
  608. 608 # greater than the amount of milliseconds specified via the
  609. 609 # latency-monitor-threshold configuration directive. When its value is set
  610. 610 # to zero, the latency monitor is turned off.
  611. 611 #
  612. 612 # By default latency monitoring is disabled since it is mostly not needed
  613. 613 # if you don't have latency issues, and collecting data has a performance
  614. 614 # impact, that while very small, can be measured under big load. Latency
  615. 615 # monitoring can easily be enalbed at runtime using the command
  616. 616 # "CONFIG SET latency-monitor-threshold <milliseconds>" if needed.
  617. 617 latency-monitor-threshold 0
  618. 618
  619. 619 ############################# Event notification ##############################
  620. 620
  621. 621 # Redis can notify Pub/Sub clients about events happening in the key space.
  622. 622 # This feature is documented at http://redis.io/topics/notifications
  623. 623 #
  624. 624 # For instance if keyspace events notification is enabled, and a client
  625. 625 # performs a DEL operation on key "foo" stored in the Database 0, two
  626. 626 # messages will be published via Pub/Sub:
  627. 627 #
  628. 628 # PUBLISH __keyspace@0__:foo del
  629. 629 # PUBLISH __keyevent@0__:del foo
  630. 630 #
  631. 631 # It is possible to select the events that Redis will notify among a set
  632. 632 # of classes. Every class is identified by a single character:
  633. 633 #
  634. 634 # K Keyspace events, published with __keyspace@<db>__ prefix.
  635. 635 # E Keyevent events, published with __keyevent@<db>__ prefix.
  636. 636 # g Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
  637. 637 # $ String commands
  638. 638 # l List commands
  639. 639 # s Set commands
  640. 640 # h Hash commands
  641. 641 # z Sorted set commands
  642. 642 # x Expired events (events generated every time a key expires)
  643. 643 # e Evicted events (events generated when a key is evicted for maxmemory)
  644. 644 # A Alias for g$lshzxe, so that the "AKE" string means all the events.
  645. 645 #
  646. 646 # The "notify-keyspace-events" takes as argument a string that is composed
  647. 647 # by zero or multiple characters. The empty string means that notifications
  648. 648 # are disabled at all.
  649. 649 #
  650. 650 # Example: to enable list and generic events, from the point of view of the
  651. 651 # event name, use:
  652. 652 #
  653. 653 # notify-keyspace-events Elg
  654. 654 #
  655. 655 # Example 2: to get the stream of the expired keys subscribing to channel
  656. 656 # name __keyevent@0__:expired use:
  657. 657 #
  658. 658 # notify-keyspace-events Ex
  659. 659 #
  660. 660 # By default all notifications are disabled because most users don't need
  661. 661 # this feature and the feature has some overhead. Note that if you don't
  662. 662 # specify at least one of K or E, no events will be delivered.
  663. 663 notify-keyspace-events ""
  664. 664
  665. 665 ############################### ADVANCED CONFIG ###############################
  666. 666
  667. 667 # Hashes are encoded using a memory efficient data structure when they have a
  668. 668 # small number of entries, and the biggest entry does not exceed a given
  669. 669 # threshold. These thresholds can be configured using the following directives.
  670. 670 hash-max-ziplist-entries 512
  671. 671 hash-max-ziplist-value 64
  672. 672
  673. 673 # Similarly to hashes, small lists are also encoded in a special way in order
  674. 674 # to save a lot of space. The special representation is only used when
  675. 675 # you are under the following limits:
  676. 676 list-max-ziplist-entries 512
  677. 677 list-max-ziplist-value 64
  678. 678
  679. 679 # Sets have a special encoding in just one case: when a set is composed
  680. 680 # of just strings that happens to be integers in radix 10 in the range
  681. 681 # of 64 bit signed integers.
  682. 682 # The following configuration setting sets the limit in the size of the
  683. 683 # set in order to use this special memory saving encoding.
  684. 684 set-max-intset-entries 512
  685. 685
  686. 686 # Similarly to hashes and lists, sorted sets are also specially encoded in
  687. 687 # order to save a lot of space. This encoding is only used when the length and
  688. 688 # elements of a sorted set are below the following limits:
  689. 689 zset-max-ziplist-entries 128
  690. 690 zset-max-ziplist-value 64
  691. 691
  692. 692 # HyperLogLog sparse representation bytes limit. The limit includes the
  693. 693 # 16 bytes header. When an HyperLogLog using the sparse representation crosses
  694. 694 # this limit, it is converted into the dense representation.
  695. 695 #
  696. 696 # A value greater than 16000 is totally useless, since at that point the
  697. 697 # dense representation is more memory efficient.
  698. 698 #
  699. 699 # The suggested value is ~ 3000 in order to have the benefits of
  700. 700 # the space efficient encoding without slowing down too much PFADD,
  701. 701 # which is O(N) with the sparse encoding. The value can be raised to
  702. 702 # ~ 10000 when CPU is not a concern, but space is, and the data set is
  703. 703 # composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
  704. 704 hll-sparse-max-bytes 3000
  705. 705
  706. 706 # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
  707. 707 # order to help rehashing the main Redis hash table (the one mapping top-level
  708. 708 # keys to values). The hash table implementation Redis uses (see dict.c)
  709. 709 # performs a lazy rehashing: the more operation you run into a hash table
  710. 710 # that is rehashing, the more rehashing "steps" are performed, so if the
  711. 711 # server is idle the rehashing is never complete and some more memory is used
  712. 712 # by the hash table.
  713. 713 #
  714. 714 # The default is to use this millisecond 10 times every second in order to
  715. 715 # active rehashing the main dictionaries, freeing memory when possible.
  716. 716 #
  717. 717 # If unsure:
  718. 718 # use "activerehashing no" if you have hard latency requirements and it is
  719. 719 # not a good thing in your environment that Redis can reply form time to time
  720. 720 # to queries with 2 milliseconds delay.
  721. 721 #
  722. 722 # use "activerehashing yes" if you don't have such hard requirements but
  723. 723 # want to free memory asap when possible.
  724. 724 activerehashing yes
  725. 725
  726. 726 # The client output buffer limits can be used to force disconnection of clients
  727. 727 # that are not reading data from the server fast enough for some reason (a
  728. 728 # common reason is that a Pub/Sub client can't consume messages as fast as the
  729. 729 # publisher can produce them).
  730. 730 #
  731. 731 # The limit can be set differently for the three different classes of clients:
  732. 732 #
  733. 733 # normal -> normal clients including MONITOR clients
  734. 734 # slave -> slave clients
  735. 735 # pubsub -> clients subscribed to at least one pubsub channel or pattern
  736. 736 #
  737. 737 # The syntax of every client-output-buffer-limit directive is the following:
  738. 738 #
  739. 739 # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
  740. 740 #
  741. 741 # A client is immediately disconnected once the hard limit is reached, or if
  742. 742 # the soft limit is reached and remains reached for the specified number of
  743. 743 # seconds (continuously).
  744. 744 # So for instance if the hard limit is 32 megabytes and the soft limit is
  745. 745 # 16 megabytes / 10 seconds, the client will get disconnected immediately
  746. 746 # if the size of the output buffers reach 32 megabytes, but will also get
  747. 747 # disconnected if the client reaches 16 megabytes and continuously overcomes
  748. 748 # the limit for 10 seconds.
  749. 749 #
  750. 750 # By default normal clients are not limited because they don't receive data
  751. 751 # without asking (in a push way), but just after a request, so only
  752. 752 # asynchronous clients may create a scenario where data is requested faster
  753. 753 # than it can read.
  754. 754 #
  755. 755 # Instead there is a default limit for pubsub and slave clients, since
  756. 756 # subscribers and slaves receive data in a push fashion.
  757. 757 #
  758. 758 # Both the hard or the soft limit can be disabled by setting them to zero.
  759. 759 client-output-buffer-limit normal 0 0 0
  760. 760 client-output-buffer-limit slave 256mb 64mb 60
  761. 761 client-output-buffer-limit pubsub 32mb 8mb 60
  762. 762
  763. 763 # Redis calls an internal function to perform many background tasks, like
  764. 764 # closing connections of clients in timeout, purging expired keys that are
  765. 765 # never requested, and so forth.
  766. 766 #
  767. 767 # Not all tasks are performed with the same frequency, but Redis checks for
  768. 768 # tasks to perform accordingly to the specified "hz" value.
  769. 769 #
  770. 770 # By default "hz" is set to 10. Raising the value will use more CPU when
  771. 771 # Redis is idle, but at the same time will make Redis more responsive when
  772. 772 # there are many keys expiring at the same time, and timeouts may be
  773. 773 # handled with more precision.
  774. 774 #
  775. 775 # The range is between 1 and 500, however a value over 100 is usually not
  776. 776 # a good idea. Most users should use the default of 10 and raise this up to
  777. 777 # 100 only in environments where very low latency is required.
  778. 778 hz 10
  779. 779
  780. 780 # When a child rewrites the AOF file, if the following option is enabled
  781. 781 # the file will be fsync-ed every 32 MB of data generated. This is useful
  782. 782 # in order to commit the file to the disk more incrementally and avoid
  783. 783 # big latency spikes.
  784. 784 aof-rewrite-incremental-fsync yes

redis_6391.conf源码

 

 

(7) 重启指定端口的服务,例如此处在Redis按照src目录下,运行./redis-server redis_6391.conf即可启动服务,待服务完成启动成功后,即可把指定的AOF文件数据加载进去(PS:此步骤需要先确认指定目录下的AOF文件已被替换成目标AOF文件,期间可以多次重启实现具体AOF文件加载)

以下给出我本机使用Redis加载启动大小为1.7G的aof文件,由于文件比较大,所以加载的时间有点长,此处是加载了60秒。

liuzhen@liuzhen-ubuntu:~/redis-2.8.17/src$ ./redis-server redis_6391.conf

[68180] 19 Jul 15:02:07.997 * Increased maximum number of open files to 10032 (it was originally set to 1024).

                _._                                                  

           _.-``__ ''-._                                             

      _.-``    `.  `_.  ''-._           Redis 2.8.17 (00000000/0) 64 bit

  .-`` .-```.  ```\/    _.,_ ''-._                                   

 (    '      ,       .-`  | `,    )     Running in stand alone mode

 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6391

 |    `-._   `._    /     _.-'    |     PID: 68180

  `-._    `-._  `-./  _.-'    _.-'                                   

 |`-._`-._    `-.__.-'    _.-'_.-'|                                  

 |    `-._`-._        _.-'_.-'    |           http://redis.io        

  `-._    `-._`-.__.-'_.-'    _.-'                                   

 |`-._`-._    `-.__.-'    _.-'_.-'|                                  

 |    `-._`-._        _.-'_.-'    |                                  

  `-._    `-._`-.__.-'_.-'    _.-'                                   

      `-._    `-.__.-'    _.-'                                       

          `-._        _.-'                                           

              `-.__.-'                                               

 

[68180] 19 Jul 15:02:08.011 # Server started, Redis version 2.8.17

[68180] 19 Jul 15:05:12.843 * DB loaded from append only file: 184.831 seconds

[68180] 19 Jul 15:05:12.843 * The server is now ready to accept connections on port 6391

[68180] 19 Jul 15:05:13.008 * 10000 changes in 60 seconds. Saving...

[68180] 19 Jul 15:05:13.084 * Background saving started by pid 68228

[68228] 19 Jul 15:05:47.548 * DB saved on disk

[68228] 19 Jul 15:05:47.613 * RDB: 23 MB of memory used by copy-on-write

[68180] 19 Jul 15:05:47.717 * Background saving terminated with success

[68180] 19 Jul 15:07:54.064 * DB saved on disk

[68180] 19 Jul 15:08:58.096 * Asynchronous AOF fsync is taking too long (disk is busy?). Writing the AOF buffer without waiting for fsync to complete, this may slow down Redis.

[68180] 19 Jul 16:49:14.515 * Background saving started by pid 90980

[90980] 19 Jul 16:56:56.883 * DB saved on disk

[90980] 19 Jul 16:56:56.966 * RDB: 4 MB of memory used by copy-on-write

[68180] 19 Jul 16:56:57.418 * Background saving terminated with success

 

 

(8)打开Redis客户端,运行./redis-cli -p 6391,客户端启动成功后,运行命令save,等待命令运行成功后,即可得到本步骤最终目标的RDB持久化文件(PS:此处如果是在线上环境尝试,建议采用bgsave命令)

此处给出,使用AOF文件还原数据后,查看具体数据信息的结果:

liuzhen@liuzhen-ubuntu:~/redis-2.8.17/src$ ./redis-cli -p 6391

127.0.0.1:6391> info

# Server

redis_version:2.8.17

redis_git_sha1:00000000

redis_git_dirty:0

redis_build_id:4ba260b6ab802599

redis_mode:standalone

os:Linux 4.13.0-39-generic x86_64

arch_bits:64

multiplexing_api:epoll

gcc_version:5.4.0

process_id:68180

run_id:97cddc494e3924885bacb03776dfe09e8fa055f9

tcp_port:6391

uptime_in_seconds:9400

uptime_in_days:0

hz:10

lru_clock:5266472

config_file:/home/liuzhen/redis-2.8.17/src/redis_6391.conf

 

# Clients

connected_clients:1

client_longest_output_list:0

client_biggest_input_buf:0

blocked_clients:0

 

# Memory

used_memory:2239514040

used_memory_human:2.09G

used_memory_rss:330895360

used_memory_peak:2272377648

used_memory_peak_human:2.12G

used_memory_lua:38912

mem_fragmentation_ratio:0.15

mem_allocator:jemalloc-3.6.0

 

# Persistence

loading:0

rdb_changes_since_last_save:0

rdb_bgsave_in_progress:0

rdb_last_save_time:1531990617

rdb_last_bgsave_status:ok

rdb_last_bgsave_time_sec:463

rdb_current_bgsave_time_sec:-1

aof_enabled:1

aof_rewrite_in_progress:0

aof_rewrite_scheduled:0

aof_last_rewrite_time_sec:-1

aof_current_rewrite_time_sec:-1

aof_last_bgrewrite_status:ok

aof_last_write_status:ok

aof_current_size:1700508277

aof_base_size:1699947297

aof_pending_rewrite:0

aof_buffer_length:0

aof_rewrite_buffer_length:0

aof_pending_bio_fsync:0

aof_delayed_fsync:1

 

# Stats

total_connections_received:2

total_commands_processed:281

instantaneous_ops_per_sec:0

rejected_connections:0

sync_full:0

sync_partial_ok:0

sync_partial_err:0

expired_keys:9290

evicted_keys:0

keyspace_hits:1065050

keyspace_misses:0

pubsub_channels:0

pubsub_patterns:0

latest_fork_usec:101807

 

# Replication

role:master

connected_slaves:0

master_repl_offset:0

repl_backlog_active:0

repl_backlog_size:1048576

repl_backlog_first_byte_offset:0

repl_backlog_histlen:0

 

# CPU

used_cpu_sys:46.01

used_cpu_user:189.71

used_cpu_sys_children:134.11

used_cpu_user_children:79.12

 

# Keyspace

db1:keys=1146336,expires=51965,avg_ttl=276142509

127.0.0.1:6391>

 

 

备注:在Redis指定端口服务加载给定的AOF文件时,如果AOF文件过大,系统可能会报如下错误:

 Can’t save in background: fork: Cannot allocate memory

解决办法:

修改系统/etc/sysctl.conf文件,并添加以下内容:

vm.overcommit_memory=1

 

在 FreeBSD上:

sudo /etc/rc.d/sysctl reload

 

在 Linux上:

sudo sysctl -p /etc/sysctl.conf

 

 

参考资料:

 

版权声明:本文为liuzhen1995原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/liuzhen1995/p/9338082.html