Redis4.0主从配置

版权说明：本文为博主原创，如果转载请注明来源。作为学习笔记，不能保证所有知识点是完全正确以及表达无误，用于生产环境配置时请斟酌。如有错误或建议请联系。侵删联系:linuxops@foxmail.com。感谢各位！

Redis主从复制

redis主从复制，就是主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，一般Master以写为主，Slave以读为主。主从复制用于读写分离、容灾备份。

一、主从复制的配置

一般而言，在配置主从复制时，配置从服务器即可，主服务器配置不需要配置。但是注意，在默认配置文件中，bind默认绑定的是127.0.0.1,默认配置无法让其他客户端访问本机，所以要在bind中绑定自己的网卡地址，或者绑定0.0.0.0监听所有的地址，否则主从无法通信。

################################# REPLICATION #################################
# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. A few things to understand ASAP about Redis replication.
#
# 1) Redis replication is asynchronous, but you can configure a master to
#    stop accepting writes if it appears to be not connected with at least
#    a given number of slaves.
# 2) Redis slaves are able to perform a partial resynchronization with the
#    master if the replication link is lost for a relatively small amount of
#    time. You may want to configure the replication backlog size (see the next
#    sections of this file) with a sensible value depending on your needs.
# 3) Replication is automatic and does not need user intervention. After a
#    network partition slaves automatically try to reconnect to masters
#    and resynchronize with them.

# slaveof <masterip> <masterport>
   slaveof 10.0.0.12 6379 --->当本机为从服务时，设置主服务的IP及端口，默认关闭

# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.

# masterauth <master-password>
   masterauth elain --->当本机为从服务时，设置主服务的连接密码

# When a slave loses its connection with the master, or when the replication
# is still in progress, the slave can act in two different ways:
#
# 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
#    still reply to client requests, possibly with out of date data, or the
#    data set may just be empty if this is the first synchronization.
#
# 2) if slave-serve-stale-data is set to 'no' the slave will reply with
#    an error "SYNC with master in progress" to all the kind of commands
#    but to INFO and SLAVEOF.
#
slave-serve-stale-data yes
在master服务器挂掉或者同步失败时，从服务器是否继续提供服务。
有以下两种情况：  
    1)  如果设置为 yes( 默认设置 ) ，从库会继续响应客户端的请求
    2)  如果设置为 no ，除了 INFO 和 SLAVOF 命令之外的任何请求都会返回一个错误 "SYNC with master in progress"

# You can configure a slave instance to accept writes or not. Writing against
# a slave instance may be useful to store some ephemeral data (because data
# written on a slave will be easily deleted after resync with the master) but
# may also cause problems if clients are writing to it because of a
# misconfiguration.
#
# Since Redis 2.6 by default slaves are read-only.
#
# Note: read only slaves are not designed to be exposed to untrusted clients
# on the internet. It's just a protection layer against misuse of the instance.
# Still a read only slave exports by default all the administrative commands
# such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
# security of read only slaves using 'rename-command' to shadow all the
# administrative / dangerous commands.

slave-read-only yes
配置 slave 实例是否接受写操作。
写 slave 对存储短暂数据（在同 master 数据同步后可以很容易地被删除）是有用的，但未配置的情况下，客户端写可能会发送问题。

# Replication SYNC strategy: disk or socket.
#
# -------------------------------------------------------
# WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY
# -------------------------------------------------------
#
# New slaves and reconnecting slaves that are not able to continue the replication
# process just receiving differences, need to do what is called a "full
# synchronization". An RDB file is transmitted from the master to the slaves.
# The transmission can happen in two different ways:
#
# 1) Disk-backed: The Redis master creates a new process that writes the RDB
#                 file on disk. Later the file is transferred by the parent
#                 process to the slaves incrementally.
# 2) Diskless: The Redis master creates a new process that directly writes the
#              RDB file to slave sockets, without touching the disk at all.
#
# With disk-backed replication, while the RDB file is generated, more slaves
# can be queued and served with the RDB file as soon as the current child producing
# the RDB file finishes its work. With diskless replication instead once
# the transfer starts, new slaves arriving will be queued and a new transfer
# will start when the current one terminates.
#
# When diskless replication is used, the master waits a configurable amount of
# time (in seconds) before starting the transfer in the hope that multiple slaves
# will arrive and the transfer can be parallelized.
#
# With slow disks and fast (large bandwidth) networks, diskless replication
# works better.

repl-diskless-sync no
复制集同步策略：磁盘或者socket
新slave连接或者老slave重新连接时候不能只接收不同，得做一个全同步。需要一个新的RDB文件dump出来，然后从master传到slave。可以有两种情况：
 1）基于硬盘（disk-backed）：master创建一个新进程dump RDB，完事儿之后由父进程（即主进程）增量传给slaves。
 2）基于socket（diskless）：master创建一个新进程直接dump RDB到slave的socket，不经过主进程，不经过硬盘。
 基于硬盘的话，RDB文件创建后，一旦创建完毕，可以同时服务更多的slave。基于socket的话， 新slave来了后，得排队（如果超出了repl-diskless-sync-delay还没来），完事儿一个再进行下一个。
 当用diskless的时候，master等待一个repl-diskless-sync-delay的秒数，如果没slave来的话，就直接传，后来的得排队等了。否则就可以一起传。
 disk较慢，并且网络较快的时候，可以用diskless。（默认用disk-based）

# When diskless replication is enabled, it is possible to configure the delay
# the server waits in order to spawn the child that transfers the RDB via socket
# to the slaves.
#
# This is important since once the transfer starts, it is not possible to serve
# new slaves arriving, that will be queued for the next RDB transfer, so the server
# waits a delay in order to let more slaves arrive.
#
# The delay is specified in seconds, and by default is 5 seconds. To disable
# it entirely just set it to 0 seconds and the transfer will start ASAP.

repl-diskless-sync-delay 5

# Slaves send PINGs to server in a predefined interval. It's possible to change
# this interval with the repl_ping_slave_period option. The default value is 10
# seconds.

# repl-ping-slave-period 10
从库会按照一个时间间隔向主库发送PINGs.默认是10秒  

# The following option sets the replication timeout for:
#
# 1) Bulk transfer I/O during SYNC, from the point of view of slave.
# 2) Master timeout from the point of view of slaves (data, pings).
# 3) Slave timeout from the point of view of masters (REPLCONF ACK pings).
#
# It is important to make sure that this value is greater than the value
# specified for repl-ping-slave-period otherwise a timeout will be detected
# every time there is low traffic between the master and the slave.
#

# repl-timeout 60
   设置主库批量数据传输时间或者ping回复时间间隔，默认值是60秒
   一定要确保repl-timeout大于repl-ping-slave-period

# Disable TCP_NODELAY on the slave socket after SYNC?
#
# If you select "yes" Redis will use a smaller number of TCP packets and
# less bandwidth to send data to slaves. But this can add a delay for
# the data to appear on the slave side, up to 40 milliseconds with
# Linux kernels using a default configuration.
#
# If you select "no" the delay for data to appear on the slave side will
# be reduced but more bandwidth will be used for replication.
#
# By default we optimize for low latency, but in very high traffic conditions
# or when the master and slaves are many hops away, turning this to "yes" may
# be a good idea.

repl-disable-tcp-nodelay no
是否关闭无延迟同步 默认no，即采用无延迟同步。
  1、如果选择 "yes" ,Redis 将使用一个较小的数字 TCP 数据包和更少的带宽将数据发送到 slave 
    但是这可能导致数据发送到 slave 端会有延迟 , 如果是 Linux kernel 的默认配置，会达到 40 毫秒 .
  2、如果选择 "no" ，则发送数据到 slave 端的延迟会降低，但将使用更多的带宽用于复制 .

# Set the replication backlog size. The backlog is a buffer that accumulates
# slave data when slaves are disconnected for some time, so that when a slave
# wants to reconnect again, often a full resync is not needed, but a partial
# resync is enough, just passing the portion of data the slave missed while
# disconnected.
#
# The bigger the replication backlog, the longer the time the slave can be
# disconnected and later be able to perform a partial resynchronization.
#
# The backlog is only allocated once there is at least a slave connected.

# repl-backlog-size 1mb
设置复制的后台日志大小。
1、复制的后台日志越大， slave 断开连接及后来可能执行部分复制花的时间就越长。
2、后台日志在至少有一个 slave 连接时，仅仅分配一次。

# After a master has no longer connected slaves for some time, the backlog
# will be freed. The following option configures the amount of seconds that
# need to elapse, starting from the time the last slave disconnected, for
# the backlog buffer to be freed.
#
# A value of 0 means to never release the backlog.

# repl-backlog-ttl 3600
   在 master 不再连接 slave 后，后台日志将被释放。配置定义从最后一个 slave 断开连接后需要释放的时间（秒）。
   0 意味着从不释放后台日志

# The slave priority is an integer number published by Redis in the INFO output.
# It is used by Redis Sentinel in order to select a slave to promote into a
# master if the master is no longer working correctly.
#
# A slave with a low priority number is considered better for promotion, so
# for instance if there are three slaves with priority 10, 100, 25 Sentinel will
# pick the one with priority 10, that is the lowest.
#
# However a special priority of 0 marks the slave as not able to perform the
# role of master, so a slave with priority of 0 will never be selected by
# Redis Sentinel for promotion.
#
# By default the priority is 100.

slave-priority 100
1、如果 master 不能再正常工作，那么会在多个 slave 中，选择优先值最小的一个 slave 提升为 master 
2、优先值为 0 表示不能提升为 master 。
3、数值越小，优先级越高

# It is possible for a master to stop accepting writes if there are less than
# N slaves connected, having a lag less or equal than M seconds.
#
# The N slaves need to be in "online" state.
#
# The lag in seconds, that must be <= the specified value, is calculated from
# the last ping received from the slave, that is usually sent every second.
#
# This option does not GUARANTEE that N replicas will accept the write, but
# will limit the window of exposure for lost writes in case not enough slaves
# are available, to the specified number of seconds.
#
# For example to require at least 3 slaves with a lag <= 10 seconds use:

# min-slaves-to-write 3
# min-slaves-max-lag 10
  如果少于 N 个 slave 连接，且延迟时间 <=M 秒，则 master 可配置停止接受写操作。设置 0 为禁用
  以上配置例子表示：需要至少 3 个 slave 连接，且延迟 <=10 秒，否则Master停止接受写操作

# Setting one or the other to 0 disables the feature.
#
# By default min-slaves-to-write is set to 0 (feature disabled) and
# min-slaves-max-lag is set to 10.
# A Redis master is able to list the address and port of the attached
# slaves in different ways. For example the "INFO replication" section
# offers this information, which is used, among other tools, by
# Redis Sentinel in order to discover slave instances.
# Another place where this info is available is in the output of the
# "ROLE" command of a masteer.
#
# The listed IP and address normally reported by a slave is obtained
# in the following way:
#
#   IP: The address is auto detected by checking the peer address
#   of the socket used by the slave to connect with the master.
#
#   Port: The port is communicated by the slave during the replication
#   handshake, and is normally the port that the slave is using to
#   list for connections.
#
# However when port forwarding or Network Address Translation (NAT) is
# used, the slave may be actually reachable via different IP and port
# pairs. The following two options can be used by a slave in order to
# report to its master a specific set of IP and port, so that both INFO
# and ROLE will report those values.
#
# There is no need to use both the options if you need to override just
# the port or the IP address.
#
# slave-announce-ip 5.5.5.5
# slave-announce-port 1234

---

二、主从复制的几种场景

A、一主多从

MasterIP：172.16.16.211

Slaver01：172.16.16.212

Slaver02：172.16.16.213

Slaver01和Slaver02配置：

# slaveof <masterip> <masterport>
 slaveof 172.16.16.211 6379
 启用主从复制，指定Master为172.16.16.211 端口号为6379

配置完成重启redis

在cli中，用INFO REPLICATION命令可以查看相关的主从复制的配置信息。当前配置信息如下：

Master信息：

172.16.16.211:6379> info replication
# Replication
role:master  #当前服务器的角色：Master
connected_slaves:2 #当前Master下挂Slaver的个数，当前为2个
slave0:ip=172.16.16.212,port=6379,state=online,offset=127,lag=1 #Slaver0的信息，Slaverip，端口，状态等
slave1:ip=172.16.16.213,port=6379,state=online,offset=127,lag=0 #Slaver1的信息，Slaverip，端口，状态等
master_repl_offset:127
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:126

Slaver信息(两台的重新信息是一样的)：

172.16.16.212:6379> info replication
# Replication
role:slave   #当前服务器的角色：Slaver
master_host:172.16.16.211 #当前Master的ip
master_port:6379 #当前Master的端口
master_link_status:up #当前Master的状态
master_last_io_seconds_ago:7
master_sync_in_progress:0
slave_repl_offset:127
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

测试：

172.16.16.211:6379> set k1 v1
OK
Master set一条记录

172.16.16.212:6379> get k1
"v1"
Slaver同步成功，并且可以读取

172.16.16.213:6379> get k1
"v1"
Slaver同步成功，并且可以读取

172.16.16.212:6379> set k2 v2
(error) READONLY You can't write against a read only slave.
Slaver试图set一条记录，报错。配置文件配置为Slaver只读模式

B、薪火相传

MasterIP：172.16.16.211 复制数据到Slaver01：172.16.16.212， Slaver01在复制到Slaver02：172.16.16.213....一直传下去

修改172.16.16.213的配置文件，将Master的地址需要为172.16.16.212，并且重启。

重启之后，用INFO REPLICATION命令查看信息

172.16.16.211：

172.16.16.211:6379> info replication
# Replication
role:master #本机的角色：Master
connected_slaves:1 #连接的Slaver个数：1
slave0:ip=172.16.16.212,port=6379,state=online,offset=1397,lag=0 #连接Slaver的信息
master_repl_offset:1397
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:1396
172.16.16.211:6379>

172.16.16.212：

172.16.16.212:6379> INFO REPLICATION
# Replication
role:slave #本机的角色：Slaver
master_host:172.16.16.211 #Master的IP
master_port:6379 #Master的端口
master_link_status:up #Master的状态
master_last_io_seconds_ago:10
master_sync_in_progress:0
slave_repl_offset:1495
slave_priority:100
slave_read_only:1
connected_slaves:1 #本机下挂的Slaver数：1
slave0:ip=172.16.16.213,port=6379,state=online,offset=183,lag=0 #下挂Slaver的信息，注意，是：172.16.16.213
master_repl_offset:183
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:182
172.16.16.212:6379>

172.16.16.213：

172.16.16.213:6379> info replication
# Replication
role:slave #本机角色：Slaver
master_host:172.16.16.212 #Master的ip，注意，是：172.16.16.212
master_port:6379 #Master的端口
master_link_status:up Master的状态
master_last_io_seconds_ago:6
master_sync_in_progress:0
slave_repl_offset:85
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

根据以上配置，一台redis服务器，只有一种角色要么Slaver要么Master，但是在Slaver下可以下挂Slaver，对于下挂的的Slaver来说，本机就是Master。

这种串联的主从复制中，如果中间节点发生了故障，那么下挂的服务器见不会被同步。

C、哨兵模式

在 一主多从 的模式中，如果Master发生故障了，那么下挂的Slaver不会更改自己的角色，依然是Slaver，直到Master重新上线后同步。在某种场合中 一主多从 的模式并不太适合实际的生产应用。

哨兵模式就是在一主多从的基础上增加了Master的选举机制，如果master故障，那么在存活的slaver选举一台为主机，其余存活的主机会自动连接选举出来的master同步，保证了可用性。

当选举新master之后，原来的master故障修复了，继续上线工作，原来的master将不会加入同步，需要在配置文件中或者cli中指定选举出来的master为master。

哨兵模式配置：

启动一个哨兵来监控redis服务器（包括master和slaver），可以用一下命令：

[root@Redis01 ~]# redis-sentinel /usr/redis/sentinel.conf

在redis源码包中提供了一份哨兵的配置文件示例sentinel.conf，将文件复制到配置文件目录中，打开配置文件：

# Example sentinel.conf
# *** IMPORTANT ***
#
# By default Sentinel will not be reachable from interfaces different than
# localhost, either use the 'bind' directive to bind to a list of network
# interfaces, or disable protected mode with "protected-mode no" by
# adding it to this configuration file.
#
# Before doing that MAKE SURE the instance is protected from the outside
# world via firewalling or other means.
#
# For example you may use one of the following:

# bind 127.0.0.1 192.168.1.1
绑定网卡ip，使多个哨兵能通通讯。
#
# protected-mode no
# port <sentinel-port>
# The port that this sentinel instance will run on
port 26379
哨兵运行的端口

# sentinel announce-ip <ip>
# sentinel announce-port <port>
#
# The above two configuration directives are useful in environments where,
# because of NAT, Sentinel is reachable from outside via a non-local address.
#
# When announce-ip is provided, the Sentinel will claim the specified IP address
# in HELLO messages used to gossip its presence, instead of auto-detecting the
# local address as it usually does.
#
# Similarly when announce-port is provided and is valid and non-zero, Sentinel
# will announce the specified TCP port.
#
# The two options don't need to be used together, if only announce-ip is
# provided, the Sentinel will announce the specified IP and the server port
# as specified by the "port" option. If only announce-port is provided, the
# Sentinel will announce the auto-detected local IP and the specified port.
#
# Example:
#
# sentinel announce-ip 1.2.3.4
# dir <working-directory>
# Every long running process should have a well-defined working directory.
# For Redis Sentinel to chdir to /tmp at startup is the simplest thing
# for the process to don't interfere with administrative tasks such as
# unmounting filesystems.
dir /tmp
哨兵的工作目录

# sentinel monitor <master-name> <ip> <redis-port> <quorum>
#
# Tells Sentinel to monitor this master, and to consider it in O_DOWN
# (Objectively Down) state only if at least <quorum> sentinels agree.
#
# Note that whatever is the ODOWN quorum, a Sentinel will require to
# be elected by the majority of the known Sentinels in order to
# start a failover, so no failover can be performed in minority.
#
# Slaves are auto-discovered, so you don't need to specify slaves in
# any way. Sentinel itself will rewrite this configuration file adding
# the slaves using additional configuration options.
# Also note that the configuration file is rewritten when a
# slave is promoted to master.
#
# Note: master name should not include special characters or spaces.
# The valid charset is A-z 0-9 and the three characters ".-_".
sentinel monitor mymaster 127.0.0.1 6379 2
监控一个redis服务器，各项表示的意思如下：
sentinel monitor mymaster        127.0.0.1        6379              2
                被监控服务器名字    被监控服务器的ip   被监控服务器的端口   同意数量

以上配置指示 Sentinel 去监视一个名为 mymaster 的主服务器，这个主服务器的IP地址为127.0.0.1，端口号为 6379，而将这个主服务器判断为失效至少需要 2 个 Sentinel 同意 （只要同意 Sentinel 的数量不达标，自动故障迁移就不会执行）

# sentinel auth-pass <master-name> <password>
#
# Set the password to use to authenticate with the master and slaves.
# Useful if there is a password set in the Redis instances to monitor.
#
# Note that the master password is also used for slaves, so it is not
# possible to set a different password in masters and slaves instances
# if you want to be able to monitor these instances with Sentinel.
#
# However you can have Redis instances without the authentication enabled
# mixed with Redis instances requiring the authentication (as long as the
# password set is the same for all the instances requiring the password) as
# the AUTH command will have no effect in Redis instances with authentication
# switched off.
#
# Example:
#
# sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
# sentinel down-after-milliseconds <master-name> <milliseconds>
#
# Number of milliseconds the master (or any attached slave or sentinel) should
# be unreachable (as in, not acceptable reply to PING, continuously, for the
# specified period) in order to consider it in S_DOWN state (Subjectively
# Down).
#
# Default is 30 seconds.
sentinel down-after-milliseconds mymaster 30000
# sentinel parallel-syncs <master-name> <numslaves>
#
# How many slaves we can reconfigure to point to the new slave simultaneously
# during the failover. Use a low number if you use the slaves to serve query
# to avoid that all the slaves will be unreachable at about the same
# time while performing the synchronization with the master.
sentinel parallel-syncs mymaster 1
# sentinel failover-timeout <master-name> <milliseconds>
#
# Specifies the failover timeout in milliseconds. It is used in many ways:
#
# - The time needed to re-start a failover after a previous failover was
#   already tried against the same master by a given Sentinel, is two
#   times the failover timeout.
#
# - The time needed for a slave replicating to a wrong master according
#   to a Sentinel current configuration, to be forced to replicate
#   with the right master, is exactly the failover timeout (counting since
#   the moment a Sentinel detected the misconfiguration).
#
# - The time needed to cancel a failover that is already in progress but
#   did not produced any configuration change (SLAVEOF NO ONE yet not
#   acknowledged by the promoted slave).
#
# - The maximum time a failover in progress waits for all the slaves to be
#   reconfigured as slaves of the new master. However even after this time
#   the slaves will be reconfigured by the Sentinels anyway, but not with
#   the exact parallel-syncs progression as specified.
#
# Default is 3 minutes.
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
#
# sentinel notification-script and sentinel reconfig-script are used in order
# to configure scripts that are called to notify the system administrator
# or to reconfigure clients after a failover. The scripts are executed
# with the following rules for error handling:
#
# If script exits with "1" the execution is retried later (up to a maximum
# number of times currently set to 10).
#
# If script exits with "2" (or an higher value) the script execution is
# not retried.
#
# If script terminates because it receives a signal the behavior is the same
# as exit code 1.
#
# A script has a maximum running time of 60 seconds. After this limit is
# reached the script is terminated with a SIGKILL and the execution retried.
# NOTIFICATION SCRIPT
#
# sentinel notification-script <master-name> <script-path>
# 
# Call the specified notification script for any sentinel event that is
# generated in the WARNING level (for instance -sdown, -odown, and so forth).
# This script should notify the system administrator via email, SMS, or any
# other messaging system, that there is something wrong with the monitored
# Redis systems.
#
# The script is called with just two arguments: the first is the event type
# and the second the event description.
#
# The script must exist and be executable in order for sentinel to start if
# this option is provided.
#
# Example:
#
# sentinel notification-script mymaster /var/redis/notify.sh
# CLIENTS RECONFIGURATION SCRIPT
#
# sentinel client-reconfig-script <master-name> <script-path>
#
# When the master changed because of a failover a script can be called in
# order to perform application-specific tasks to notify the clients that the
# configuration has changed and the master is at a different address.
# 
# The following arguments are passed to the script:
#
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
#
# <state> is currently always "failover"
# <role> is either "leader" or "observer"
# 
# The arguments from-ip, from-port, to-ip, to-port are used to communicate
# the old address of the master and the new address of the elected slave
# (now a master).
#
# This script should be resistant to multiple invocations.
#
# Example:
#
# sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

启用哨兵监控redis，当master在指定的规则中被判断为故障，哨兵就会启动故障转移。保证高可用。

D、复制的原理

slave启动连接master成功以后会发送sync命令。

master接到命令以后启动后台的存盘进程，同时收集所有收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slaver，一完成同步。（注意配置文件中“repl-diskless-sync no”的配置，基于磁盘和基于socket的区别）。

全量复制（首次连接）：slaver在接收到master数据库文件后，将其存盘并加载到内存中。

增量复制（上次同步成功之后）：首次同步成功后，master会继续将新的所有收集到的修改命令依次传给slaver，完成同步。