Redis tutorial (10): Detailed explanation of persistence

1. What persistence mechanisms does Redis provide:

1). RDB persistence:
This mechanism refers to writing a snapshot of the data set in memory to disk within a specified time interval.
2). AOF persistence:
This mechanism will record every write operation processed by the server in the form of a log. At the beginning of the Redis server startup, the file will be read to rebuild the database to ensure that after startup The data in the database is complete.
3). No persistence:
We can disable the persistence function of the Redis server through configuration, so that we can treat Redis as an enhanced version of memcached.
4). Apply AOF and RDB at the same time.

2. Advantages and disadvantages of RDB mechanism:

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.

3. Advantages and disadvantages of the AOF mechanism:

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 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.
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.

4. Others:

1. Snapshotting:

By default, 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 #In 900 seconds (15 minutes ), 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 10,000 keys have changed, dump the memory snapshot.

2. Dump snapshot mechanism:

1). Redis forks the child process first.
2). The child process writes the snapshot data into the temporary RDB file.
3). When the child process completes the data writing operation, replace the old file with a temporary file.

3. AOF file:

As mentioned many times above, RDB's snapshot scheduled dump mechanism cannot guarantee good data durability. If our application is really concerned about this, we can consider using the AOF mechanism in Redis. For the Redis server, the default mechanism is RDB. If you need to use AOF, you need to modify the following entries in the configuration file:
Change appendonly no to appendonly yes
From now on, Redis will run every time After receiving the data modification command, it will be appended to the AOF file. The next time Redis is restarted, the information in the AOF file needs to be loaded to build the latest data into memory.

4. AOF configuration:

There are three synchronization methods in the Redis configuration file, they are:
appendfsync always #Will be written every time a data modification occurs 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. How to repair damaged AOF files:

1). Make an additional copy of the existing damaged AOF file.
2). Execute the "redis-check-aof --fix " command to repair the damaged AOF file.
3). Restart the Redis server with the repaired AOF file.

6. Redis data backup:

In Redis, we can back up running Redis data files online through copy. This is because the RDB file will not be modified once it is generated. Redis dumps the latest data into a temporary file every time, and then uses the rename function to atomically rename the temporary file to the original data file name. Therefore we can say that copying data files is safe and consistent at any time. In view of this, we can regularly back up the Redis data files by creating a cron job and copy the backup files to a safe disk medium.

The above is the content of Redis Tutorial (10): Detailed explanation of persistence. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!