[redis 源码走读] sentinel 哨兵 - 选举投票

最新推荐文章于 2024-06-01 08:01:43 发布
最新推荐文章于 2024-06-01 08:01:43 发布
阅读量912 收藏 3
点赞数 1
分类专栏： redis 文章标签： redis sentinel 哨兵 选举 投票
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenfh2020/article/details/110481392
版权

在 sentinel 故障转移的流程上，当 sentinel 确认 master 客观下线（《[redis 源码走读] sentinel 哨兵 - 主客观下线》）后，那么它要进入 选举投票 环节。

多个 sentinel 有可能在同一个时间段内一起发现某个 master 客观下线，如果多个 sentinel 同时执行故障转移，有可能会乱套，也可能出现“脑裂”现象（《[redis 源码走读] sentinel 哨兵 - 脑裂处理方案》），所以在一个集群里，多个 sentinel 需要通过投票选出一个代表，由代表去执行故障转移。

🔥 文章来源 《[redis 源码走读] sentinel 哨兵 - 选举投票程》

1. 原理

投票原理：“先到先得”，每个 sentinel 机会是对等的，都有投票权利。

每个 sentinel 当确认 master 客观下线，它需要向其它 sentinel 拉票，让它们投票给自己。当然 sentinel 除了拉票，它自己也能主动投，投别人，或者投自己。

多数服从少数，当集群里超过半数的 sentinel 选某个 sentinel 为代表，那么它就是 leader，这样选举结束。
选举投票

2. 拉票

2.1. 发送拉票命令

投票通过命令 SENTINEL IS-MASTER-DOWN-BY-ADDR：

# is-master-down-by-addr 命令格式。
SENTINEL is-master-down-by-addr <masterip> <masterport> <sentinel.current_epoch> <sentinel_runid>
  1. <masterip>， <masterport> 参数传输 master 的 ip 和 端口（注意：不是传 mastername，因为每个 sentinel 上配置的 name 有可能不一样）。
  2. <sentinel.current_epoch> 选举纪元，可以理解为选举计数器，每次 sentinel 之间选举，不一定成功，有可能会进行多次，所以每次选举计数器会加 1，表示第几轮选举。
  3. <sentinel_runid> 当前 sentinel 的 runid，因为选举投票原理是“先到先得”。当其它 sentinel 在一轮选举中，先接收到拉票信息的，会先投给它。

    例如 sentinel A，B，C 三个实例，当 A 向 B，C 进行拉票。B 先接收到 A 的拉票信息，那么 B 就选 A 为 leader，但是 C 在接收到 A 的拉票信息前，它已经接到 B 的拉票信息，它已经将票投给了 B，不能再投给 A 了，所以 B 会返回它选的 C 的信息。

void sentinelAskMasterStateToOtherSentinels(sentinelRedisInstance *master, int flags) {
    dictIterator *di;
    dictEntry *de;

    di = dictGetIterator(master->sentinels);
    while ((de = dictNext(di)) != NULL) {
        sentinelRedisInstance *ri = dictGetVal(de);
        ...
        /* Only ask if master is down to other sentinels if:
         *
         * 1) We believe it is down, or there is a failover in progress.
         * 2) Sentinel is connected.
         * 3) We did not receive the info within SENTINEL_ASK_PERIOD ms. */
        if ((master->flags & SRI_S_DOWN) == 0) continue;
        if (ri->link->disconnected) continue;
        if (!(flags & SENTINEL_ASK_FORCED) &&
            mstime() - ri->last_master_down_reply_time < SENTINEL_ASK_PERIOD)
            continue;

        /* 当 sentinel 检测到 master 主观下线，那么参数发送 "*"，等待确认客观下线，
         * 当确认客观下线后，再进入选举环节。sentinel 再向其它 sentinel 发送自己的 runid，去拉票。*/
        ll2string(port, sizeof(port), master->addr->port);
        retval = redisAsyncCommand(ri->link->cc,
                                   sentinelReceiveIsMasterDownReply, ri,
                                   "%s is-master-down-by-addr %s %s %llu %s",
                                   sentinelInstanceMapCommand(ri, "SENTINEL"),
                                   master->addr->ip, port,
                                   sentinel.current_epoch,
                                   (master->failover_state > SENTINEL_FAILOVER_STATE_NONE) ? sentinel.myid : "*");
        if (retval == C_OK) ri->link->pending_commands++;
    }
    dictReleaseIterator(di);
}

2.2. 接收拉票

其它 sentinel 节点，接收到拉票信息，进行投票 sentinelVoteLeader。

void sentinelCommand(client *c) {
    ...
    else if (!strcasecmp(c->argv[1]->ptr, "is-master-down-by-addr")) {
        ...
        /* 其它 sentinel 接收到询问命令，根据 ip 和 端口查找对应的 master。 */
        ri = getSentinelRedisInstanceByAddrAndRunID(
            sentinel.masters, c->argv[2]->ptr, port, NULL);

        /* 当前 sentinel 如果没有处于异常保护状态，而且也检测到询问的 master 已经主观下线了。 */
        if (!sentinel.tilt && ri && (ri->flags & SRI_S_DOWN) && (ri->flags & SRI_MASTER))
            isdown = 1;

        /* 询问 master 主观下线命令参数是 *，选举投票参数是请求的 sentinel 的 runid。*/
        if (ri && ri->flags & SRI_MASTER && strcasecmp(c->argv[5]->ptr, "*")) {
            /* 投票 */
            leader = sentinelVoteLeader(ri, (uint64_t)req_epoch, c->argv[5]->ptr, &leader_epoch);
        }

        /* 投票选举业务确定回复的内容参数。 */
        addReplyArrayLen(c, 3);
        addReply(c, isdown ? shared.cone : shared.czero);
        addReplyBulkCString(c, leader ? leader : "*");
        addReplyLongLong(c, (long long)leader_epoch);
        if (leader) sdsfree(leader);
    }
    ...
}

2.3. 拉票回复

根据回复结果，更新对应 sentinel 选举的 leader 结果。

/* Receive the SENTINEL is-master-down-by-addr reply, see the
 * sentinelAskMasterStateToOtherSentinels() function for more information. */
void sentinelReceiveIsMasterDownReply(redisAsyncContext *c, void *reply, void *privdata) {
    ...
    if (r->type == REDIS_REPLY_ARRAY && r->elements == 3 &&
        r->element[0]->type == REDIS_REPLY_INTEGER &&
        r->element[1]->type == REDIS_REPLY_STRING &&
        r->element[2]->type == REDIS_REPLY_INTEGER) {
        ri->last_master_down_reply_time = mstime();
        if (r->element[0]->integer == 1) {
            /* ri sentinel 回复：它也检测到该 master 节点已经主观下线。 */
            ri->flags |= SRI_MASTER_DOWN;
        } else {
            ri->flags &= ~SRI_MASTER_DOWN;
        }
        if (strcmp(r->element[1]->str, "*")) {
            /* 当前 sentinel 向 ri 拉选票，ri 回复：它所投票的 sentinel（runid）。*/
            sdsfree(ri->leader);
            if ((long long)ri->leader_epoch != r->element[2]->integer)
                serverLog(LL_WARNING,
                          "%s voted for %s %llu", ri->name,
                          r->element[1]->str,
                          (unsigned long long)r->element[2]->integer);
            ri->leader = sdsnew(r->element[1]->str);
            ri->leader_epoch = r->element[2]->integer;
        }
    }
}

3. 投票

  • 投票方式

sentinel 的投票有两种方式：

  1. 被动：接收到别人的投票请求（上述的别人拉票 SENTINEL IS-MASTER-DOWN-BY-ADDR）。
  2. 主动：“我”主动投票（sentinelVoteLeader）给别人/自己。

投票是“先到先得”，可以投给别人也可以投给自己，如果实在没人拉票，就投给自己。“先到先得” 是通过 epoch 去标识，它是一个计数器，表示第几轮投票。所有 sentinel 节点第一轮投票从 epoch == 1 开始，区别是有些 sentinel 投得快，有的投得慢，因为每个 sentinel 时钟定时执行的频率有可能不一样。

char *sentinelVoteLeader(sentinelRedisInstance *master, uint64_t req_epoch, char *req_runid, uint64_t *leader_epoch) {
    /* 同步 epoch，保证多个 sentinel 数据一致性。 */
    if (req_epoch > sentinel.current_epoch) {
        sentinel.current_epoch = req_epoch;
        sentinelFlushConfig();
        sentinelEvent(LL_WARNING, "+new-epoch", master, "%llu",
                      (unsigned long long)sentinel.current_epoch);
    }

    /* 有可能出现多次选举，投票给最大一轮选举的 sentinel。*/
    if (master->leader_epoch < req_epoch && sentinel.current_epoch <= req_epoch) {
        sdsfree(master->leader);
        master->leader = sdsnew(req_runid);
        master->leader_epoch = sentinel.current_epoch;
        sentinelFlushConfig();
        sentinelEvent(LL_WARNING, "+vote-for-leader", master, "%s %llu",
                      master->leader, (unsigned long long)master->leader_epoch);
        /* 如果别人是 leader，那么先设置故障转移开始时间，使得在一个时间段内，
         * 别人在故障转移的时候，自己不能开启故障转移。 */
        if (strcasecmp(master->leader, sentinel.myid))
            master->failover_start_time = mstime() + rand() % SENTINEL_MAX_DESYNC;
    }

    *leader_epoch = master->leader_epoch;
    return master->leader ? sdsnew(master->leader) : NULL;
}
  • 主动投票。

故障转移有很多环节，sentinel 要选举中赢得选举，成为 leader，才能完成故障转移所有环节。

当 sentinel 检测到 master 客观下线，它进入了“选举”环节，已经开启了故障转移，并统计投票选举结果。在统计票数过程中，它会根据统计结果进行主动投票：如果没人来拉票，我也没有投过票，那么可以投自己，否则自己投票数多的人。

void sentinelFailoverWaitStart(sentinelRedisInstance *ri) {
    ...
    /* 统计选举结果。 */
    leader = sentinelGetLeader(ri, ri->failover_epoch);
    ...
}

/* 统计选票结果。*/
char *sentinelGetLeader(sentinelRedisInstance *master, uint64_t epoch) {
    ...
    /* 如果没人来拉票，我也没有投过票，那么可以投自己，否则自己投票数多的人。 */
    if (winner)
        myvote = sentinelVoteLeader(master, epoch, winner, &leader_epoch);
    else
        myvote = sentinelVoteLeader(master, epoch, sentinel.myid, &leader_epoch);
    ...
    return winner;
}

4. 统计票数

定时检查已经连接的 sentinel，统计选举情况，选出票数最多的 sentinel 为 leader。

char *sentinelGetLeader(sentinelRedisInstance *master, uint64_t epoch) {
    ...
    counters = dictCreate(&leaderVotesDictType, NULL);
    voters = dictSize(master->sentinels) + 1; /* All the other sentinels and me.*/

    /* 统计别人的 sentinel 投票结果。 */
    di = dictGetIterator(master->sentinels);
    while ((de = dictNext(di)) != NULL) {
        sentinelRedisInstance *ri = dictGetVal(de);
        if (ri->leader != NULL && ri->leader_epoch == sentinel.current_epoch)
            sentinelLeaderIncr(counters, ri->leader);
    }
    dictReleaseIterator(di);

    /* Check what's the winner. For the winner to win, it needs two conditions:
     * 1) Absolute majority between voters (50% + 1).
     * 2) And anyway at least master->quorum votes. */
    di = dictGetIterator(counters);
    while ((de = dictNext(di)) != NULL) {
        uint64_t votes = dictGetUnsignedIntegerVal(de);
        if (votes > max_votes) {
            max_votes = votes;
            winner = dictGetKey(de);
        }
    }
    dictReleaseIterator(di);

    /* 前面是统计其它人的投票，现在轮到我投票，如果其它人已经投票了，那么就将自己的票投给 winner，
     * 否则自己的票就投给自己。 */
    if (winner)
        myvote = sentinelVoteLeader(master, epoch, winner, &leader_epoch);
    else
        myvote = sentinelVoteLeader(master, epoch, sentinel.myid, &leader_epoch);

    /* 统计自己的投票结果。 */
    if (myvote && leader_epoch == epoch) {
        uint64_t votes = sentinelLeaderIncr(counters, myvote);
        if (votes > max_votes) {
            max_votes = votes;
            winner = myvote;
        }
    }

    /* 选出的 winner 最少要 >= 已知 sentinel 个数的 (50% + 1)，
     * 而且 winner 票数也不能少于法定投票数量。 */
    voters_quorum = voters / 2 + 1;
    if (winner && (max_votes < voters_quorum || max_votes < master->quorum))
        winner = NULL;

    winner = winner ? sdsnew(winner) : NULL;
    sdsfree(myvote);
    dictRelease(counters);
    return winner;
}

5. 差异化

5.1. 随机时间

实际使用中，redis 集群基本都部署在局域网，当一个 master 下线，各个 sentinel 会很快感知 master 客观下线。因为 sentinel 都是通过时钟定时工作，为了让 sentinel 差异化，时钟的频率会引入随机数，这样使得各个 sentinel 差异化更接近现实。

int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    ...
    /* Run the Sentinel timer if we are in sentinel mode. */
    if (server.sentinel_mode) sentinelTimer();
    ...
}

void sentinelTimer(void) {
    ...
    /* 定时器刷新频率添加随机数，添加投票的差异化。 */
    server.hz = CONFIG_DEFAULT_HZ + rand() % CONFIG_DEFAULT_HZ;
}

/* 故障转移开始时间也会添加一个随机时间因子。*/
master->failover_start_time = mstime() + rand() % SENTINEL_MAX_DESYNC;

5.2. 先到先得

投票的原理是“先到先得”，如何操作才能保证 “先到先得”？如何保证在同一个时间段内，只有一个 sentinel 在进行故障转移？我们看看这个变量的巧妙利用 master->failover_start_time。

  • 主动。
/* 是否满足故障转移条件，开启故障转移。 */
int sentinelStartFailoverIfNeeded(sentinelRedisInstance *master) {
    /* master 客观下线。 */
    if (!(master->flags & SRI_O_DOWN)) return 0;

    /* 当前 master 没有处在故障转移过程中。 */
    if (master->flags & SRI_FAILOVER_IN_PROGRESS) return 0;

    /* 两次故障转移，需要有一定的时间间隔。如果别人已经开始了，
     * 那么你也需要等待一段时间，让别人在这个时间段内先跑完流程。否则自己可以开启故障转移流程。 */
    if (mstime() - master->failover_start_time < master->failover_timeout * 2) {
        ...
        return 0;
    }

    /* 满足故障转移条件，开启故障转移。 */
    sentinelStartFailover(master);
    return 1;
}

void sentinelStartFailover(sentinelRedisInstance *master) {
    ...
    /* 开启故障转移，设置故障转移时间。 */
    master->failover_start_time = mstime() + rand() % SENTINEL_MAX_DESYNC;
    ...
}
  • 被动。当别人向你拉票的时候，说明故障转移已经开始，结合上面分析，那么当你要开启故障转移的时候，你必须等待一段时间。
char *sentinelVoteLeader(sentinelRedisInstance *master, uint64_t req_epoch, char *req_runid, uint64_t *leader_epoch) {
    ...
    /* 有可能出现多次选举，投票给最大一轮选举的 sentinel。*/
    if (master->leader_epoch < req_epoch && sentinel.current_epoch <= req_epoch) {
        ...
        /* 如果投票的人不是自己，那么开启故障转移。 */
        if (strcasecmp(master->leader, sentinel.myid))
            master->failover_start_time = mstime() + rand() % SENTINEL_MAX_DESYNC;
    }
    ...
}

6. 参考

如果文章不错，给个点赞呗 ~ 谢谢。👍

wenfh2020
关注
专栏目录
深入学习 Redis Sentinel - 基于 DockerCompose 编排哨兵分布式架构，理解工作原理
CYK_byte的博客
09-13 1053
Redis Sentinel 是⼀个分布式架构，其中包含若干个 Sentinel 节点（哨兵）和 Redis 数据节点，这两种结点之间的哨兵机制，是通过独立的进程来体现的，和 redis-server 是不同进程！redis-sentinel 不负责存储数据，只是对其他的 redis-server 进程起到监控的效果.
Redis：哨兵（sentinel）
m0_46669446的博客
01-23 1634
redis：持久化 redis：主从复制 redis：哨兵 redis：集群 1 概述 1.1 作用 从宏观角度回顾一下Redis实现高可用相关的技术。它们包括：持久化、复制、哨兵和集群，其主要作用和解决的问题是： 持久化：持久化是最简单的高可用方法(有时甚至不被归为高可用的手段)，主要作用是数据备份，即将数据存储在硬盘，保证数据不会因进程退出而丢失。 复制：复制是高可用Redis的基础，哨兵和集群都是在复制基础上实现高可用的。复制主要实现了数据的多机备份，以及对于读操作的负载均衡和简单的故障恢复。缺陷
Sentinel-哨兵机制
ghw15221836342的博客
06-03 672
Redis:Sentinel-哨兵机制哨兵机制的基本流程主观下线和客观下线选举领头sentinel选举新主库参考文献 Redis中采用了主从库模式，如果从库挂了，客户端可以继续向主库或其他从库发送请求，进行相关的操作，但是如果主库发生故障了，那就直接会影响到从库的同步，因为从库没有相应的主库可以进行数据复制操作了。如果Redis在半夜出现故障，还需要运维手动切换，人工运维的成本太高。所以我们必须有一个高可用方案来抵抗节点故障，当故障发生时可以自动进行从主切换，程序可以不用重启，运维可以继续睡大觉，仿佛什么
Raft协议实战之Redis Sentinel的选举Leader源码解析
weixin_30814319的博客
11-09 717
这可能是我看过的写的最详细的关于redis 选举的文章了， 原文链接 Raft协议是用来解决分布式系统一致性问题的协议，在很长一段时间，Paxos被认为是解决分布式系统一致性的代名词。但是Paxos难于理解，更难以实现，诸如Google大牛们开发的分布式锁系统Chubby都遭遇了很多坑。Raft协议设计的初衷就是容易实现，保证对于普遍的人群都可以十分舒适容易的去理解。另外，它必须能够让...
哨兵机制源码
子冉冰清的博客
02-08 1213
哨兵机制源码 我们知道，Redis 主从复制是保证 Redis 可用性的一个重要手段。而一旦 Redis 主节点发生故障，哨兵机制就会执行故障切换。这个故障切换过程实现起来其实比较复杂，涉及了哨兵 Leader 选举、新主节点选举和故障切换等关键操作。但同时，这个故障切换过程又是我们在实现高可用系统时经常要面对的开发需求。 所以从这篇文章开始，逐一介绍下，Redis 哨兵机制及其实现故障切换的关键技术设计与实现。通过这部分内容的学习，既可以了解在故障切换过程中，起到重要作用的 Raft 协议是如何实现的，而
【有料】Raft协议实战之Redis Sentinel的选举Leader源码解析
daobuxinzi的博客
05-10 662
Raft协议是用来解决分布式系统一致性问题的协议，在很长一段时间，Paxos被认为是解决分布式系统一致性的代名词。但是Paxos难于理解，更难以实现，诸如Google大牛们开发的分布式锁系统Chubby都遭遇了很多坑。Raft协议设计的初衷就是容易实现，保证对于普遍的人群都可以十分舒适容易的去理解。另外，它必须能够让人形成直观的认识，这样系统的构建者才能够在现实中进行必然的扩展。本文从Redis Sentinel集群选择Leader的具体流程和源码分析，描述Raft协议中的选举Leader算法。
基于phpredis封装的redis-sentinel客户端redis-sentinel.zip
07-19
redis-sentinel 就像他的名字一样，他是一个哨兵，监控 master 状态，如果超过规定时间没有响应，则自动进行主从切换，期间会有一段时间（决定于具体的配置参数）redis集群无法提供服务 。原理类似 mysql 的 MHA。...
bitnami-docker-redis-sentinel-exporter
03-19
$ docker run --name redis-sentinel-exporter bitnami/redis-sentinel-exporter:latest 为什么要使用Bitnami Images？ Bitnami密切跟踪上游源代码变化，并使用我们的自动化系统及时发布该图像的新版本。 对于...
redis集群：redis-sentinel(哨兵机制)集群
05-09
3. **故障转移**：当主节点故障时，Sentinel会组织投票选举新的主节点，并将从节点升级为主节点，同时更新所有客户端的连接信息。 4. **配置更新**：在完成故障转移后，Sentinel会协调并更新所有客户端关于新主节点...
[redis 源码走读] - sentinel 哨兵 - 选举投票
最新发布
smart_an的专栏
06-01 968
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！投票原理：”先到先得”，每个 sentinel 机会是对等的，都有投票权利。当前 sentienl 节点，确认某个 master 客观下线后，它会主动开启故障转移的选举环节，进行拉票（选自己）和投票（选别人）。
【Redis学习】Sentinel集群选举机制
kezade的blog
03-21 1767
【Redis学习】Sentinel集群选举机制概要一、三个定时任务1.每隔10秒2.每隔2秒3.每隔1秒二、主观下线三、客观下线四、Sentinel领导者选举五、故障转移 概要 当redis集群的主节点故障时，Sentinel集群将从剩余的从节点中选举一个新的主节点，有以下步骤： 故障节点主观下线 故障节点客观下线 Sentinel集群选举领导者 Sentinel领导者决定新主节点 一、三个定时任务 1.每隔10秒 每隔10秒，每个Sentinel节点会向主节点和从节点发送info命令，用以获取最新的拓
Redis Sentinel 源码分析 - Sentinel 选举机制和主备倒换
middleware2018的博客
09-25 448
作者：Wen Hui 转载：中间件小哥 Sentinel 的选举机制 在上面的文章我们提到过，Sentinel在主备倒换的过程中会使用is-master-down-by-addr命令来与其他Sentinel进行通信以取得其他Sentinel的投票。每个Sentinel实例都有被选举成领头Sentinel的机会，领头Sentinel会主导整个主节点下线进行主备倒换的过程。 如上面代码所示，当Sentinel在主备倒换开始的时候会使用is-master-down-by-addr命令附上自己的运行Id
Redis 哨兵模式的源码（转载）
pythonluo的专栏
11-20 507
建议阅读： 1、Sentinel的理论部分见：Redis之Sentinel I、上帝视角 1、Sentinel也是Redis服务器，只是与普通服务器职责不同，其负责监视Redis服务器，以提高服务器集群的可靠性。Sentinel与普通服务器共用一套框架（网络框架，底层数据结构，订阅与发布机制），但又有其独立的运行代码。 为维护Sentinel系统的正常运行，我们先来看Redis为Sentin...
Sentinel实现原理
qq_43422296的博客
05-10 710
启动并且初始化Sentinel Sentinel本质上只是一个运行在特殊模式下的Redis服务器，当一个Sentinel启动时，它需要执行以下步骤： 1）初始化服务器。 2）将普通Redis服务器使用的代码替换成Sentinel专用代码。 3）初始化Sentinel状态。 4）根据给定的配置文件，初始化Sentinel的监视主服务器列表。 5）创建连向主服务器的网络连接。 对于每个被Sentinel监视的主服务器来说，Sentinel会创建两个连向主服务器的异步网络连接： ❑一个是命令连接，这个连接专门用于
redis集群节点宕机 fail状态 redis的投票机制实测
~冷空气~
02-15 3633
redis集群节点宕机 fail状态 redis的投票机制实测
redis Sentinel机制、原理及代码分析
zheng6652的专栏
08-31 647
* 需求背景     有多个或一个sentinel实例组成的sentinel系统可以监视任意多个主服务器，以及这些主服务器属下的所有从服务器，并且在被监视的主服务器进入下线状态时，自动将下线主服务器属下的某个从服务器升级为新的主服务器，然后由新的主服务器代替已下线的主服务器继续处理命令请求。   * sentinel监控分布式系统的功能和需求     @服务器状态-主服务器上线下线监控...
从哨兵Leader选举学习Raft协议实现（上）
子冉冰清的博客
02-08 2246
从哨兵Leader选举学习Raft协议实现（上） 在上篇文章当中，我们了解了哨兵实例的初始化过程。哨兵实例一旦运行后，会周期性地检查它所监测的主节点的运行状态。当发现主节点出现客观下线时，哨兵实例就要开始执行故障切换流程了。 不过，我们在部署哨兵实例时，通常会部署多个哨兵来进行共同决策，这样就避免了单个哨兵对主节点状态的误判。但是这同时也给我们带来了一个问题，即当有多个哨兵判断出主节点故障后，究竟由谁来执行故障切换？ 实际上，这就和哨兵 Leader 选举有关了。而哨兵 Leader 选举，又涉及到分布式系
高可用：哨兵机制（Redis Sentinel）
qq_25447799的博客
03-30 2482
Redis中实现高可用的哨兵机制
redis 哨兵选举
08-03
Redis哨兵选举机制是通过Raft选举算法实现的。当选举的票数大于等于哨兵节点数的一半时，该节点将成为领导者。如果没有超过一半的票数，选举将继续进行。要成为领导者的哨兵节点需要满足两个条件：首先，获得超过一半的赞成票；其次，获得的票数还需要大于等于哨兵配置文件中的quorum值。[1] 哨兵选举的过程包括故障切换、哨兵集群的组建、哨兵监控Redis主库下线的判定、新主库的选出以及故障的转移。哨兵机制可以实现故障切换，但不能完成主从切换。在选举哨兵领导者时，一个哨兵必须获得超过一半的选票，但如果只有两个哨兵活着，无论怎么投票，一个哨兵最多只能获得两票，无法达到超过一半选票的结果。因此，无法选出新的主库。[2][3]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值