为了保证服务的可用性，现代数据库都提供了复制功能，同时在多个进程中维护一致的数据状态。

Redis 支持一主多从的复制架构，该功能被简化成了一条 SLAVEOF 命令，下面通过条命令来解析 Redis 的主从复制机制。

通过 tcpdump 观察

在本机上通过 redis-server 启动两个服务，然后通过 tcpdump 观察主从间的交互情况：

redis-server --port 6379 --requirepass 123456 # 启动 master

redis-server --port 6380 --masterauth 123456  # 启动 slave

tcpdump -t -i lo0 host localhost and port 6379 | awk -F ']' '{print $1"]"$3}'

# 在 localhost:6380 上执行 SLAVEOF localhost 6379 建立同步连接，进入 Full-ReSync 阶段

localhost.59297 > localhost.6379: Flags [S]

localhost.6379 > localhost.59297: Flags [S.]

localhost.59297 > localhost.6379: Flags [P.] "PING"

localhost.6379 > localhost.59297: Flags [P.] "NOAUTH Authentication required."

localhost.59297 > localhost.6379: Flags [P.] "AUTH 123456"

localhost.6379 > localhost.59297: Flags [P.] "OK"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF listening-port 6380"

localhost.6379 > localhost.59297: Flags [P.] "OK":

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF capa eof"

localhost.6379 > localhost.59297: Flags [P.] "OK":

localhost.59297 > localhost.6379: Flags [P.] "PSYNC ? -1"

localhost.6379 > localhost.59297: Flags [P.] "FULLRESYNC 8efb6ca4edf1258c05a5ced43b0c73fe4deb1908 1"

localhost.6379 > localhost.59297: Flags [P.] [|RESP:

localhost.6379 > localhost.59297: Flags [P.] "REDIS0007M-z^Iredis-ver^F3.2.11M-z" [|RESP

# 完成 Full-ReSync 后进入 Propagation 阶段

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "1"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "1"

localhost.6379 > localhost.59297: Flags [P.] "PING"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "15"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "15"

localhost.6379 > localhost.59297: Flags [P.] "SELECT" "0" "SET" "KEY" "VALUE"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "85"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "85"

localhost.6379 > localhost.59297: Flags [P.] "SET" "KEY2" "VALUE2"

localhost.6379 > localhost.59297: Flags [P.] "MSET" "KEY3" "VALUE3" "KEY4" "VALUE4" "KEY5" "VALUE5"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "256"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "256"

localhost.6379 > localhost.59297: Flags [P.] "PING"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "270"

localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "270"

# 在 localhost:6380 上执行 DEBUG SLEEP 60 模拟网络中断的情况

localhost.6379 > localhost.59297: Flags [P.] "PING"

localhost.6379 > localhost.59297: Flags [P.] "SET" "KEY6" "VALUE6"

localhost.6379 > localhost.59297: Flags [P.] "SET" "KEY7" "VALUE7"

localhost.6379 > localhost.59297: Flags [P.] "PING"

localhost.6379 > localhost.59297: Flags [P.] "MSET" "KEY8" "VALUE8" "KEY9" "VALUE9"

localhost.6379 > localhost.59297: Flags [P.] "PING"

localhost.6379 > localhost.59297: Flags [P.] "PING"

localhost.59297 > localhost.6379: Flags [.]

localhost.59297 > localhost.6379: Flags [R.]

# 旧的同步连接断开后重新建立同步连接，进入 Partical-ReSync 阶段

localhost.59313 > localhost.6379: Flags [S]

localhost.6379 > localhost.59313: Flags [S.]

localhost.59313 > localhost.6379: Flags [P.] "PING"

localhost.6379 > localhost.59313: Flags [P.] "NOAUTH Authentication required."

localhost.59313 > localhost.6379: Flags [P.] "AUTH 123456"

localhost.6379 > localhost.59313: Flags [P.] "OK"

localhost.59313 > localhost.6379: Flags [P.] "REPLCONF listening-port 6380"

localhost.6379 > localhost.59313: Flags [P.] "OK"

localhost.59313 > localhost.6379: Flags [P.] "REPLCONF capa eof"

localhost.6379 > localhost.59313: Flags [P.] "OK"

localhost.59313 > localhost.6379: Flags [P.] "PSYNC 8efb6ca4edf1258c05a5ced43b0c73fe4deb1908 271"

localhost.6379 > localhost.59313: Flags [P.] "CONTINUE"

localhost.6379 > localhost.59313: Flags [P.] "PING" "PING" "SET" "KEY6" "VALUE6" "PING" "SET" "KEY7" "VALUE7" "PING" "MSET" "KEY8" "VALUE8" "KEY9" "VALUE9" "PING" "PING"

localhost.59313 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "519"

localhost.59313 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "519"

localhost.6379 > localhost.59313: Flags [P.] "PING"

localhost.59313 > localhost.6379: Flags [P.]: "REPLCONF" "ACK" "533"

localhost.59313 > localhost.6379: Flags [P.]: "REPLCONF" "ACK" "533"

整个过程可以分为 Full-ReSync, Command-Propagate, Partical-ReSync 总共 3 阶段：

             +----------------------+                +---------------------+

             | redisServer (master) |                | redisServer (slave) |

             |    localhost:6379    |                |    localhost:6380   |

             +----------------------+                +---------------------+

             |        slaves        |                |        master       |

             +----------------------+                +---------------------+

                        |                                       |

                 +----------------+                      +-------------+

                 | redisClient[?] |                      | redisClient |

                 +----------------+                      +-------------+

                                                                |

       ^                <<<<<<<<<<<<<<<<<< PING <<<<<<<<<<<<<<<<<

       |                |                                               Step 1 : 检查套接字与 master 状态

       |                >>>>>>>>>>>>> PONG / NOAUTH >>>>>>>>>>>>>

       |                                                        |

       |                <<<<<<<<<<<<<<<<<< AUTH <<<<<<<<<<<<<<<<<

       |                |                                               Step 2 : 身份验证

       |                >>>>>>>>>>>>>>>>>>> OK >>>>>>>>>>>>>>>>>>

       |                                                        |

       |                <<<< REPLCONF listening-port [port] <<<<<

       |                |                                               Step 3 : 发送 slave 端口

   Full-ReSync          >>>>>>>>>>>>>>>>>>> OK >>>>>>>>>>>>>>>>>>

       |                                                        |

       |                <<<<<< REPLCONF capa [eof|psync2] <<<<<<<

       |                |                                               Step 4 : 检查命令兼容性

       |                >>>>>>>>>>>>>>>>>>> OK >>>>>>>>>>>>>>>>>>

       |                                                        |

       |                <<<<<<<<<<<<<< PSYNC ? -1 <<<<<<<<<<<<<<<

       |                |

       |                >>>>>> FULLRESYNC [replid] [offset] >>>>>       Step 6 : 执行全量同步

       |                V

       |              BGSAVE

       |                V

       v                >>>>>>>>>>>>> RDB Snapshot >>>>>>>>>>>>>>                

       ^                <<<<<<<<< REPLCONF ACK [offset] <<<<<<<<<

       |                >>>>>>>>>>>>>>> COMMAND 1 >>>>>>>>>>>>>>>

       |                >>>>>>>>>>>>>>> COMMAND 2 >>>>>>>>>>>>>>>

       |                <<<<<<<< REPLCONF ACK [offset+?] <<<<<<<<       心跳检测 & 命令传播

Command-Propagate       >>>>>>>>>>>>>>>>>> PING >>>>>>>>>>>>>>>>>

       |                >>>>>>>>>>>>>>> COMMAND 3 >>>>>>>>>>>>>>>

       |                <<<<<<<< REPLCONF ACK [offset+?] <<<<<<<<

       |                <<<<<<<< REPLCONF ACK [offset+?] <<<<<<<<

       v                >>>>>>>>>>>>>>>>>> PING >>>>>>>>>>>>>>>>>                

       ^                =========================================

       |                ====== The Same With Full-ReSync ========

       |                =========================================

       |                                                        |

  Partical-ReSync       <<<<<<<< PSYNC [replid] [offset] <<<<<<<<       重连后执行部分同步

       |                |

       |                >>>>>>>>>>>>>>> CONTINUE >>>>>>>>>>>>>>>>

       |                >>>>>>>>>>>>>>> COMMAND N >>>>>>>>>>>>>>>

       v                >>>>>>>>>>>>>>> COMMAND ... >>>>>>>>>>>>>

PSYNC 命令

最初 Redis 用于同步的命令是SYNC，每次重连执行该命令时都会生成、传输、加载整个完整的 RDB 快照，严重占用机器资源与网络带宽。为了解决这一问题，后续版本的 Redis 追加了PSYNC命令，该命令支持以下两种同步模式：

全量重新同步Full-ReSync
- slave 首次连接 master
- master 与 slave 之间的状态差异过大
部分重新同步Partical-ReSync
- 网络抖动导致同步连接断开重连
- sentinel 机制导致 master 节点发生变更

数据结构

下面看看 redisServer 中与PSYNC相关的数据结构：

struct redisServer {

    /*

     *  节点ID 与 复制偏移量

     *

     *     若当前节点是 master

     *     server.replid 就是 server.runid

     *

     *     若当前节点原本是 master，转化为 slave 节点后

     *     server.replid 与 server.master_repl_offset 会被新 master 的同步信息覆盖

     *

     *     若当前节点原本是 slave，被提升为 master 节点后

     *     rserver.eplid2 与 server.second_replid_offset 会记录当前节点作为 slave 时的同步信息

     */

    char runid[CONFIG_RUN_ID_SIZE+1];   /* 当前节点的运行时ID（每次重启都会发生变化） */

    char replid[CONFIG_RUN_ID_SIZE+1];  /* 当前 master 节点的 runid */

    char replid2[CONFIG_RUN_ID_SIZE+1]; /* 当前 master 节点作为 slave 节点时连接的 master 的 runid */

    long long master_repl_offset;   /* 当前 master 节点的复制偏移量 */

    long long second_replid_offset; /* 当前 master 节点作为 slave 节点时的同步偏移量 */

    /*

     * 复制积压缓冲

     *

     *     master 只维护一个全局的 server.repl_backlog，由所有 slave 节点共享

     *     为了减少内存占用，server.repl_backlog 仅在 slave 节点存在时按需创建

     */

    char *repl_backlog;             /* 复制积压缓冲（环形缓冲）*/

    long long repl_backlog_size;    /* 积压缓冲大小 */

    long long repl_backlog_histlen; /* 积压数据长度 */

    long long repl_backlog_idx;     /* 积压缓冲尾部（可写位置）*/

    long long repl_backlog_off;     /* 积压缓冲首字节对应的同步偏移量（master offset）*/

}

运行ID

　无论主从，每个 Redis 服务器会在启动时生成一个长度为 40 的十六进制字符串作为运行IDrunid：

当 slave 首次请求同步时，会将 master 返回的server.runid保存至server.replid
当 slave 重新请求同步时，会将之前保存的server.replid发送给 master：
- 如果该 ID 与当前 master 的server.runid不一致，则必须执行一次全量重新同步
- 如果该 ID 与当前 master 的server.runid一致，则可以尝试执行部分同步操作

复制偏移量

　主从双方都会维护一个单位为字节的复制偏移量offset，通过该偏移量可以判断主从间的状态是否一致：

master 向 slave 传播 N 字节数据后，会将自己的复制偏移量增加 N
slave 接收到 master 传来的 N 个字节数据时，会将自己的复制偏移量增加 N

　当 master 接收到 REPLCONF ACK 中的偏移量时，可以据此判断发送给 slave 的数据是否发生了丢失，并重发丢失的数据。

积压缓冲

　master 端维护了一个定长的积压缓冲队列backlog。

　master 向 slave 传播命令时会同时将命令放入该队列，因此缓冲区里会保留一部分最新的命令。

　slave 发出同步请求时，如果 slave 的偏移量之后 (offset+1) 的数据存在于积压缓冲，master 才会执行部分同步。

同步流程

SLAVE 视角

slave 接收到SLAVEOF命令后，会调用replicaofCommand开始执行主从同步：

void replicaofCommand(client *c) {

    // ...

    if (!strcasecmp(c->argv[1]->ptr,"no") &&

        !strcasecmp(c->argv[2]->ptr,"one")) {

        if (server.masterhost) { // 如果接收到的命令是 SLAVE NO ONE 则断开主从同步

            // ...

        }

    } else {

        if (c->flags & CLIENT_SLAVE) {

            return; // 如果已经是客户端是一个 slave 节点，则拒绝该命令

        }

        if (server.masterhost && !strcasecmp(server.masterhost,c->argv[1]->ptr) && server.masterport == port) {

            return; // 如果已经连接上 SLAVEOF 中指定的 master 节点，则直接返回

        }

        // 如果尚未连接任意 master 节点，则根据 masterhost 与 masterport 建立 TCP 连接

        // 并注册监听函数 syncWithMaster

    }

}

void syncWithMaster(connection *conn) {

    // 向 master 节点发送 PING 命令

    if (server.repl_state == REPL_STATE_CONNECTING) {

        server.repl_state = REPL_STATE_RECEIVE_PONG;

        err = sendSynchronousCommand(SYNC_CMD_WRITE,conn,"PING",NULL); // 发送 PING 命令

        // ...

    }

    // 监听到 master 对 PING 命令的响应

    if (server.repl_state == REPL_STATE_RECEIVE_PONG) {

        if (err[0] != '+' &&

            strncmp(err,"-NOAUTH",7) != 0 &&

            strncmp(err,"-NOPERM",7) != 0 &&

            strncmp(err,"-ERR operation not permitted",28) != 0)

        {

            goto error;

        }

        server.repl_state = REPL_STATE_SEND_AUTH; // 只处理 master 响应值为 PONG、NOAUTH、NOPERM 的情况

    }

    // 根据 master 对 PING 的响应值，判断是否需要授权

    if (server.repl_state == REPL_STATE_SEND_AUTH) {

        if (server.masteruser && server.masterauth) {

            err = sendSynchronousCommand(SYNC_CMD_WRITE,conn,"AUTH",

                                         server.masteruser,server.masterauth,NULL); // 发送 AUTH 命令

            // ...

            server.repl_state = REPL_STATE_RECEIVE_AUTH;

        } else {

            // 如果没有设置 server.masteruser 与 server.masterauth 授权信息，则跳过 AUTH

            server.repl_state = REPL_STATE_SEND_PORT;

        }

    }

    // 此处略过以下步骤：

    // 使用 REPLCONF listening-port 命令将 slave 的端口告知 master

    // 使用 REPLCONF ip-address 命令将 slave 的 IP 告知 master

    // 使用 REPLCONF capa eof / capa psync2 命令将 slave 兼容性（支持的特性）告知 master

     // 开始发送 PSYNC 命令

    if (server.repl_state == REPL_STATE_SEND_PSYNC) {

        if (slaveTryPartialResynchronization(conn,0) == PSYNC_WRITE_ERROR) {

            goto write_error;

        }

        server.repl_state = REPL_STATE_RECEIVE_PSYNC;

        return;

    }

    // 读取 PSYNC 命令的响应

    psync_result = slaveTryPartialResynchronization(conn,1);

    // 如果监听到 CONTINUE 响应，跳过全量同步

    if (psync_result == PSYNC_CONTINUE) return;

    // 如果返回值为 PSYNC_FULLRESYNC 或 PSYNC_NOT_SUPPORTED

    // 开始执行执行全量同步，注册 readSyncBulkPayload 监听 RDB 文件下载

    if (connSetReadHandler(conn, readSyncBulkPayload) == C_ERR) {

        // ...

        goto error;

    }

    server.repl_state = REPL_STATE_TRANSFER;

    // ...

}

int slaveTryPartialResynchronization(connection *conn, int read_reply) {

    if (!read_reply) {

        if (server.cached_master) { // server.cached_master 中存在记录，尝试执行部分同步

            psync_replid = server.cached_master->replid;

        } else {

            psync_replid = "?"; // server.cached_master 中不存在记录，只能执行全量同步

        }

        // 发起 PSYNC 命令

        reply = sendSynchronousCommand(SYNC_CMD_WRITE,conn,"PSYNC",psync_replid,psync_offset,NULL);

        // ...

        return PSYNC_WAIT_REPLY;

    }

    reply = sendSynchronousCommand(SYNC_CMD_READ,conn,NULL); // 读取 PSYNC 响应

    // 如果 master 响应 FULLRESYNC 则直接进行全量同步

    if (!strncmp(reply,"+FULLRESYNC",11)) {

        // ...

        return PSYNC_FULLRESYNC;

    }

    // 如果 master 响应 CONTINUE 则尝试执行部分同步

    if (!strncmp(reply,"+CONTINUE",9)) {

        // ...

        return PSYNC_CONTINUE;

    }

    // master 暂时无法处理 PSYNC 命令 —> PSYNC_TRY_LATER

    // master 不支持 PSYNC 命令 -> PSYNC_NOT_SUPPORTED

}

MASTER 视角

master 接收到PSYNC命令后，会调用syncCommand开启同步流程：

void syncCommand(client *c) {

    // 接收到 slave 发送的 PSYNC 命令

    if (!strcasecmp(c->argv[0]->ptr,"psync")) {

        if (masterTryPartialResynchronization(c) == C_OK) {

            return; // 无需全量同步，直接返回

        }

    }

    // 若代码运行至此处，意味着部分同步失败，需要执行全量同步

    // master 会执行 BGSAVE 命令生成快照并传输给 slave

    // 同步 RDB 快照的方式有两种：

    //     基于磁盘(Disk-backed)：在磁盘生成 RDB 快照文件，然后再传输给 slave

    //     无盘(Diskless)：直接将 RDB 快照数据写入 slave socket

}

int masterTryPartialResynchronization(client *c) {

    long long psync_offset; // 该 slave 最新的同步偏移量

    char *master_replid;    // slave 同步偏移量对应的 master 的 runid

    /*

     *  以下情况可以避免全量同步：

     *  1. slave 最近一次同步的 master 是当前实例（网络抖动）

     *  2. slave 与当前节点原本是同个 master 的从节点，且当前节点的同步偏移量 second_replid_offset 较大（维护重启、故障切换）*/

    if (strcasecmp(master_replid, server.replid) &&

       (strcasecmp(master_replid, server.replid2) ||psync_offset > server.second_replid_offset))

    {

        goto need_full_resync; // 不满足 PSYNC 条件，需要执行全量同步

    }

    /*

     *  以下情况只能执行全量同步：

     *  1. master 没有初始化积压缓冲

     *  2. slave 的同步偏移量落后于积压缓冲 */

    if (!server.repl_backlog ||

        psync_offset < server.repl_backlog_off ||

        psync_offset > (server.repl_backlog_off + server.repl_backlog_histlen))

    {

        goto need_full_resync; // 进行全量同步

    }

    // 若代码运行至此处，意味着可以执行部分同步

    listAddNodeTail(server.slaves,c);

    // 根据客户端是否兼容 PSYNC2，返回不同的 CONTINUE 响应

    if (c->slave_capa & SLAVE_CAPA_PSYNC2) {

        buflen = snprintf(buf,sizeof(buf),"+CONTINUE %s\r\n", server.replid);

    } else {

        buflen = snprintf(buf,sizeof(buf),"+CONTINUE\r\n");

    }

    // CONTINUE 命令后面，紧接着就是 server.repl_backlog 的内容

    psync_len = addReplyReplicationBacklog(c,psync_offset);

    // ...

}

心跳 & 命令传播

Redis 每秒会执行一次定时任务replicationCron，其中就包含主从同步间的心跳，可以发现主从双方的心跳频率是不一致的：

void replicationCron(void) {

    // slave 定时向 master 发送 REPLCONF ACK 命令

    if (server.masterhost && server.master &&

        !(server.master->flags & CLIENT_PRE_PSYNC)) {

        addReplyArrayLen(c,3);

        addReplyBulkCString(c,"REPLCONF");

        addReplyBulkCString(c,"ACK");

        addReplyBulkLongLong(c,c->reploff);

    }

    // master 定时向 slave 发送 PING 命令

    if ((replication_cron_loops % server.repl_ping_slave_period) == 0 &&

        listLength(server.slaves))

    {

        robj *ping_argv[1];

        ping_argv[0] = createStringObject("PING",4);

        replicationFeedSlaves(server.slaves, server.slaveseldb, ping_argv, 1);

        decrRefCount(ping_argv[0]);

    }

}

master 在调用call函数执行客户端传过来的命令时，会将命令传播给 slave 并同时写入积压缓冲：

void call(client *c, int flags) {

    // ...

    if (flags & CMD_CALL_PROPAGATE && (c->flags & CLIENT_PREVENT_PROP) != CLIENT_PREVENT_PROP)

    {

        // 当前命令是否需要传播

        if (propagate_flags != PROPAGATE_NONE && !(c->cmd->flags & CMD_MODULE))

            propagate(c->cmd,c->db->id,c->argv,c->argc,propagate_flags);

    }

}

void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,

               int flags)

{

    // ...

    if (flags & PROPAGATE_REPL)

        replicationFeedSlaves(server.slaves,dbid,argv,argc);

}

void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {

    // 如果当前节点没有 slave 节点或复制积压缓冲，立即返回

    if (server.repl_backlog == NULL && listLength(slaves) == 0) return;

    // 向 repl_backlog 中批量写入命令

    if (server.repl_backlog) {

        char aux[LONG_STR_SIZE+3]; // 命令缓冲，用于序列化 redis 命令

        /* 写入当前批次的命令数量 */

        aux[0] = '*';

        len = ll2string(aux+1,sizeof(aux)-1,argc);

        aux[len+1] = '\r';

        aux[len+2] = '\n';

        feedReplicationBacklog(aux,len+3);

        /* 逐个遍历命令，将其序列化后写入 repl_backlog */

        for (j = 0; j < argc; j++) {

            long objlen = stringObjectLen(argv[j]);

            aux[0] = '$';

            len = ll2string(aux+1,sizeof(aux)-1,objlen);

            aux[len+1] = '\r';

            aux[len+2] = '\n';

            feedReplicationBacklog(aux,len+3);

            feedReplicationBacklogWithObject(argv[j]);

            feedReplicationBacklog(aux+len+1,2);

        }

    }

    // 将命令批量传播给所有 slaves 对应的 client

    listRewind(slaves,&li);

    while((ln = listNext(&li))) {

        client *slave = ln->value;

        /* 写入当前批次的命令数量 */

        addReplyArrayLen(slave,argc);

        /* 逐个遍历命令，将传播给 slave 节点 */

        for (j = 0; j < argc; j++)

            addReplyBulk(slave,argv[j]);

    }

}

Redis 主从复制（Replication）

通过 tcpdump 观察

PSYNC 命令

数据结构

运行ID

复制偏移量

积压缓冲

同步流程

SLAVE 视角

MASTER 视角

心跳 & 命令传播

相关参数

slave-serve-stale-data

repl-diskless-sync

repl-ping-slave-period

repl-backlog-size

min-slaves-to-write & min-slaves-max-lag

Redis 主从复制（Replication）的更多相关文章

随机推荐

热门专题