[Redis] The core principle of master-slave replication

Redis master-slave architecture
A single-machine redis can carry anywhere from tens of thousands to tens of thousands of QPS.For cache, it is generally used to support read high concurrency.Therefore, the architecture is made into a master-slave architecture, with one master and multiple slaves, the master is responsible for writing, and the data is copied to other slave nodes, and the slave nodes are responsible for reading.All read requests go to slave nodes.In this way, horizontal expansion can also be easily achieved, supports high read concurrency.

redis replication -> master-slave architecture-> Read and write separation -> Horizontal expansion supports high read concurrency

Core mechanism of redis replication

• redis replicates data to the slave node asynchronously, but starting with redis 2.8, the slave node will periodically confirm the amount of data it replicates each time;
• A master node can be configured with multiple slave nodes;
• slave node can also connect to other slave nodes;
• When the slave node is replicating, it will not block the normal work of the master node;
• When the slave node is doing replication, it will not block its own query operations. It will use the old data set to provide services; but when the replication is completed, it needs to delete the old data set and load the new data set. ThisThe external service will be suspended at that time;
  *slave node is mainly used for horizontal expansion and separation of read and write. The expanded slave node can improve the read throughput.

Note:

• If the master-slave architecture is adopted, it is recommended that the persistence of the master node must be enabled. It is not recommended to use the slave node as the data hot backup of the master node, because in that case, if you turn off the persistence of the master, the master may be down.When the machine restarts, the data is empty, and after replication, the data of the slave node may also be lost.
• In addition, various backup schemes of the master also need to be done.In case all local files are lost, select an rdb from the backup to restore the master, so as to ensure that there is data at startup, even if the high availability mechanism explained later is adopted, the slave node can automatically take over the master node,But it is also possible that the master node restarts automatically before sentinel detects the master failure, or it may cause all the slave node data above to be cleared.

The core principle of redis master-slave replication

• When starting a slave node, it sends a PSYNC command to the master node.
• If this is the first time the slave node connects to the master node, a full resynchronization full replication will be triggered.At this point, the master will start a background thread and start generating an RDB snapshot file,
• At the same time, all write commands newly received from the client client are also cached in memory.After the RDB file is generated, the master will send the RDB to the slave, and the slave will first write it to the local disk, and then load it into memory from the local disk,
• The master will then send the write command cached in memory to the slave, and the slave will also synchronize the data.
• If the slave node has a network failure with the master node and is disconnected, it will automatically reconnect. After the connection, the master node will only copy the missing data to the slave part.
  

Process principle

1. When the MS relationship is established between the slave database and the master database, the SYNC command will be sent to the master database
2. After the main library receives the SYNC command, it will start saving snapshots in the background (RDB persistence process), and cache the write commands received during the period
3. When the snapshot is completed, the master Redis will send the snapshot file and all cached write commands to the slave Redis
4. After receiving from Redis, the snapshot file will be loaded and the received cached command will be executed
5. After that, the master Redis will send the command from Redis whenever it receives a write command, thereby ensuring data consistency

Disadvantages

• The replication and synchronization of all slave node data are handled by the master node, which will cause too much pressure on the master node and use the master-slave-slave structure to solve