redis配置文件英译汉

  1. # By default Redis asynchronously dumps the dataset on disk. This mode is  
  2. # good enough in many applications, but an issue with the Redis process or  
  3. # a power outage may result into a few minutes of writes lost (depending on  
  4. # the configured save points).  
  5. #  
  6. # The Append Only File is an alternative persistence mode that provides  
  7. # much better durability. For instance using the default data fsync policy  
  8. # (see later in the config file) Redis can lose just one second of writes in a  
  9. # dramatic event like a server power outage, or a single write if something  
  10. # wrong with the Redis process itself happens, but the operating system is  
  11. # still running correctly.  
  12. #  
  13. # AOF and RDB persistence can be enabled at the same time without problems.  
  14. # If the AOF is enabled on startup Redis will load the AOF, that is the file  
  15. # with the better durability guarantees.  
  16. #  
  17. # Please check http://redis.io/topics/persistence for more information.  
  18.   
  19. appendonly no  
  20.   
  21. # The name of the append only file (default: "appendonly.aof")  
  22. # appendfilename appendonly.aof  
  23.   
  24. # The fsync() call tells the Operating System to actually write data on disk  
  25. # instead to wait for more data in the output buffer. Some OS will really flush   
  26. # data on disk, some other OS will just try to do it ASAP.  
  27. #  
  28. # Redis supports three different modes:  
  29. #  
  30. # no: don't fsync, just let the OS flush the data when it wants. Faster.  
  31. # always: fsync after every write to the append only log . Slow, Safest.  
  32. # everysec: fsync only one time every second. Compromise.  
  33. #  
  34. # The default is "everysec", as that's usually the right compromise between  
  35. # speed and data safety. It's up to you to understand if you can relax this to  
  36. # "no" that will let the operating system flush the output buffer when  
  37. # it wants, for better performances (but if you can live with the idea of  
  38. # some data loss consider the default persistence mode that's snapshotting),  
  39. # or on the contrary, use "always" that's very slow but a bit safer than  
  40. # everysec.  
  41. #  
  42. # More details please check the following article:  
  43. # http://antirez.com/post/redis-persistence-demystified.html  
  44. #  
  45. # If unsure, use "everysec".  
  46.   
  47. # appendfsync always  
  48. appendfsync always  
  49.   
  50. # appendfsync no  
  51.   
  52. # When the AOF fsync policy is set to always or everysec, and a background  
  53. # saving process (a background save or AOF log background rewriting) is  
  54. # performing a lot of I/O against the disk, in some Linux configurations  
  55. # Redis may block too long on the fsync() call. Note that there is no fix for  
  56. # this currently, as even performing fsync in a different thread will block  
  57. # our synchronous write(2) call.  
  58. #  
  59. # In order to mitigate this problem it's possible to use the following option  
  60. # that will prevent fsync() from being called in the main process while a  
  61. # BGSAVE or BGREWRITEAOF is in progress.  
  62. #  
  63. # This means that while another child is saving, the durability of Redis is  
  64. # the same as "appendfsync none". In practical terms, this means that it is  
  65. # possible to lose up to 30 seconds of log in the worst scenario (with the  
  66. # default Linux settings).  
  67. #   
  68. # If you have latency problems turn this to "yes". Otherwise leave it as  
  69. # "no" that is the safest pick from the point of view of durability.  
  70. no-appendfsync-on-rewrite no  
  71.   
  72.   
  73. # Automatic rewrite of the append only file.  
  74. # Redis is able to automatically rewrite the log file implicitly calling  
  75. # BGREWRITEAOF when the AOF log size grows by the specified percentage.  
  76. #   
  77. # This is how it works: Redis remembers the size of the AOF file after the  
  78. # latest rewrite (if no rewrite has happened since the restart, the size of  
  79. # the AOF at startup is used).  
  80. #  
  81. # This base size is compared to the current size. If the current size is  
  82. # bigger than the specified percentage, the rewrite is triggered. Also  
  83. # you need to specify a minimal size for the AOF file to be rewritten, this  
  84. # is useful to avoid rewriting the AOF file even if the percentage increase  
  85. # is reached but it is still pretty small.  
  86. #  
  87. # Specify a percentage of zero in order to disable the automatic AOF  
  88. # rewrite feature.  
  89.   
  90. auto-aof-rewrite-percentage 100  
  91. auto-aof-rewrite-min-size 64mb  


译文：

[python] view plain copy
 
    1. ############################## 仅追加方式 ###############################  
    2.   
    3. #默认情况下Redis会异步的将数据导出到磁盘上。这种模式对许多应用程序已经足够了，  
    4. #但是如果断电或者redis进程出问题就会导致一段时间内的更新数据丢失（取决与配置项）  
    5. #  
    6. #这种只增文件是可选的能够提供更好的体验的数据持久化策略。  
    7. #举个例子，如果使用默认的配置数据fsync策略，在服务器意外断电的情况下redis只会丢失一秒中内的更新数据，  
    8. #或者当redis进程出问题但操作系统运转正常时，redis只会丢失一个数据更新操作。  
    9. #  
    10. #AOF 和 RDB 持久化方式可以同时启动并且无冲突。  
    11. #如果AOF开启，启动redis时会加载aof文件，这些文件能够提供更好的保证。  
    12. #请在 http://redis.io/topics/persistence 获取更多数据持久化信息。  
    13.   
    14. appendonly no  
    15.   
    16. # 只增文件的文件名称。（默认是appendonly.aof）  
    17. # appendfilename appendonly.aof  
    18.   
    19. #调用fsync()函数会通知操作系统真正将数据写入磁盘，而不是等待缓冲区中有更多数据。  
    20. #有些操作系统会将数据输出到磁盘，有些操作系统只是ASAP。  
    21. #  
    22. #redis支持三种不同的方式：  
    23. #  
    24. #no:不调用，之等待操作系统来清空缓冲区当操作系统要输出数据时。很快。  
    25. # always: 每次更新数据都写入仅增日志文件。慢，但是最安全。  
    26. # everysec: 每秒调用一次。折中。  
    27. #  
    28. #默认是每秒中一次，因为它往往是在速度和数据安全两者之间的折中选择。  
    29. #如果你可以接受让操作系统去自动清空缓存，你可以将这项配置降低到'no'(如果你可以接受一段时间的数据丢失，默认的rdb就足够了)，  
    30. #这完全取决与你。如果你想要一个更好的体验或者从相反的角度，使用'always'，这样会很慢，但是比'everysec'安全些。  
    31. #  
    32. #请在下面的文章中获取更多细节知识：  
    33. #  http://antirez.com/post/redis-persistence-demystified.html  
    34. #  
    35. #如果你不是很清楚这三项之间的区别，或者不知道哪种适合你的机器，就是用默认吧。  
    36.   
    37. # appendfsync always  
    38. appendfsync always  
    39. # appendfsync no  
    40.   
    41. #当AOF策略设置为'always'或者'everysec'的时候，后台的保存进程会进行很多磁盘I／O操作，  
    42. #在某些linux结构中redis会在调用sync()方法时阻塞很长时间。记住，现在还没办法解决这个问题，即使在不同进程中进行调用也会block。  
    43. #  
    44. #使用如下配置可能会缓解这个问题，这样会在存储大数据或者BIGREWRITEAOF的时候不会在主进程中调用fsync()方法。  
    45. #  
    46. # 这表示，如果另外一个子进程在进行保存操作，redis的表现如同配置为‘appendfsync no’。  
    47. #在实际应用中，这表示在最坏的情景下（使用linux默认配置）可能会丢失30秒日志。  
    48. #   
    49. #如果你有特殊的情况可以配置为'yes'。但是配置为'no'是最为安全的选择。  
    50. no-appendfsync-on-rewrite no  
    51.   
    52.   
    53. #自动重写只增文件。  
    54. #redis可以自动盲从的调用‘BGREWRITEAOF’来重写日志文件，如果日志文件增长了指定的百分比。  
    55. #   
    56. #它是这样工作的：每次rewrite后redis会记录日志文件的大小。（如果重启后没有重写后的大小，就默认用日志文件大小）  
    57. #  
    58. # 这个基准日志大小和当前日志大小做比较。如果当前大小比指定的百分比，重写机制就会被触发。  
    59. #同时，你也要制定一个重写下线，用来避免增长百分比够了，但是日志文件还很小的情况。  
    60. #  
    61. #指定百分比为0可以注掉自动重写日志文件功能。  
    62.   
    63. auto-aof-rewrite-percentage 100  
    64. auto-aof-rewrite-min-size 64mb  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zlzxc/p/5864971.html