What are the two ways for redis to persist?

1. Introduction to redis

REmote DIctionary Server (Redis) is a key-value storage system written by Salvatore Sanfilippo.

(Learning video sharing: redis video tutorial)

Redis is an open source software written in ANSI C language, complies with the BSD protocol, supports the network, and can be based on memory or memory. Persistent log type, Key-Value database, and provides APIs in multiple languages.

It is often called a data structure server because values ​​can be strings, hashes, lists, sets and sorted sets ) and other types.

It is similar to memcached, but data can be persisted and supports a wide range of data types. There are strings, linked lists, sets and sorted sets. It supports calculating the union, intersection and complement (difference) of sets on the server side, and also supports a variety of sorting functions. So Redis can also be regarded as a data structure server.

All data in Redis is stored in memory and then asynchronously saved to disk from time to time (this is called "semi-persistent mode"); every data change can also be written to into an append only file (aof) (this is called "full persistence mode").

Since Redis data is stored in memory, if persistence is not configured, all data will be lost after redis restarts. Therefore, you need to enable the persistence function of redis and save the data to the disk. When redis restarts, Afterwards, the data can be recovered from the disk. Redis provides two methods for persistence, one is RDB persistence (the principle is to periodically dump Reids' database records in memory to RDB persistence on disk), and the other is AOF (append only file) persistence ( The principle is to write Reids' operation log to the file in an appending manner). So what is the difference between these two persistence methods, and how to choose? Most of what I read on the Internet introduces how to configure and use these two methods, but there is no introduction to the difference between the two and what application scenarios they are used in.

2. The difference between the two

RDB persistence refers to writing the snapshot of the data set in the memory to the disk within a specified time interval. The actual operation process is to fork a child process, first Write the data set to a temporary file. After the writing is successful, replace the previous file and store it with binary compression.

3. Advantages and Disadvantages of the Two

What are the advantages of RDB?

1). Once this method is adopted, your entire Redis database will only contain one file, which is perfect for file backup. For example, you may plan to archive the last 24 hours of data every hour, and also archive the last 30 days of data every day. Through such a backup strategy, once a catastrophic failure occurs in the system, we can restore it very easily.

2). For disaster recovery, RDB is a very good choice. Because we can easily compress a single file and then transfer it to other storage media.

3). Maximize performance. For the Redis service process, when it starts persistence, the only thing it needs to do is to fork out the child process, and then the child process will complete the persistence work. This can greatly avoid the service process performing IO operations.

4). Compared with the AOF mechanism, if the data set is large, RDB startup efficiency will be higher.

What are the disadvantages of RDB?

1). If you want to ensure high availability of data, that is, avoid data loss to the greatest extent, then RDB will not be a good choice. Because once the system crashes before scheduled persistence, the data that has not had time to be written to the disk will be lost.

2). Since RDB assists in data persistence through fork child processes, if the data set is large, it may cause the entire server to stop serving for hundreds of milliseconds, or even 1 second. bell.

What are the advantages of AOF?

1). This mechanism can bring higher data security, that is, data persistence. Redis provides three synchronization strategies, namely synchronization every second, synchronization every modification and no synchronization. In fact, every second synchronization is also completed asynchronously, and its efficiency is also very high. The only difference is that once the system goes down, the data modified within this second will be lost. Every time a modification is synchronized, we can think of it as synchronous persistence, that is, every data change that occurs will be immediately recorded to the disk. It can be predicted that this method is the least efficient. As for no synchronization, no need to say more, I think everyone can understand it correctly.

2). Since this mechanism uses the append mode for writing log files, even if there is a downtime during the writing process, the existing content in the log file will not be destroyed. However, if we only write half of the data in this operation and a system crash occurs, don't worry. Before Redis starts next time, we can use the redis-check-aof tool to help us solve the data consistency problem.

3). If the log is too large, Redis can automatically enable the rewrite mechanism. That is, Redis continuously writes modified data to the old disk file in append mode. At the same time, Redis also creates a new file to record which modification commands were executed during this period. Therefore, data security can be better ensured when performing rewrite switching.

4). AOF contains a clearly formatted and easy-to-understand log file for recording all modification operations. In fact, we can also complete data reconstruction through this file.

What are the disadvantages of AOF?

1). For the same number of data sets, AOF files are usually larger than RDB files. RDB is faster than AOF when restoring large data sets.

2). Depending on the synchronization strategy, AOF is often slower than RDB in terms of operating efficiency. In short, the efficiency of the synchronization strategy per second is relatively high, and the efficiency of the synchronization disabling strategy is as efficient as RDB.

The criterion for choosing between the two is to see whether the system is willing to sacrifice some performance in exchange for higher cache consistency (aof), or whether it is willing to not enable backup in exchange for higher performance when write operations are frequent. When you run save manually, do the backup (rdb) again. RDB has a more eventually consistent meaning.

4. Commonly used configurations

RDB persistence configuration

Redis will dump the snapshot of the data set into the dump.rdb file. In addition, we can also modify the frequency of Redis server dump snapshots through the configuration file. After opening the 6379.conf file, we search for save and can see the following configuration information:

save 900 1       #At 900 seconds (15 minutes) later, if at least 1 key changes, dump the memory snapshot.

save 300 10 #After 300 seconds (5 minutes), if at least 10 keys have changed, dump the memory snapshot.

save 60 10000 #After 60 seconds (1 minute), if at least 10000 keys have changed, dump the memory snapshot.

AOF persistence configuration

There are three synchronization methods in the Redis configuration file, they are:

appendfsync always #Will be written every time a data modification occurs Import the AOF file.

appendfsync everysec #Synchronize once every second. This policy is the default policy of AOF.

appendfsync no       #Never synchronize. Efficient but data will not be persisted.

5. Reference materials

http://blog.csdn.net/jackpk/article/details/30073097
http://www.jb51.net/article/65264.htm

Related recommendations: redis database tutorial

The above is the detailed content of What are the two ways for redis to persist?. For more information, please follow other related articles on the PHP Chinese website!