There are several ways to persist redis

Redis is an advanced key-value database. 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"); also Each data change can be written to 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 appended manner).

So what is the difference between these two persistence methods, and how to choose?

RDB persistence refers to writing a 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, and write After the import is successful, the previous file is replaced and stored using binary compression.

AOF persistence records every write and delete operation processed by the server in the form of a log. Query operations are not recorded, but are recorded in text. You can open the file to see detailed operation records.

The advantages and disadvantages of both

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. Predictably, this approach 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 log file with a clear and easy-to-understand format 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 when write operations are frequent in exchange for higher cache consistency. Performance, wait until you run save manually before backing up (rdb). RDB has a more eventually consistent meaning.

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