nacos集群raft选举算法

骑猪看日落 2024-04-18 09:11 26阅读 0赞

选举算法  
Nacos集群采用raft算法来实现，它是相对zookeeper的选举算法较为简单的一种。  
选举算法的核心在RaftCore 中，包括数据的处理和数据同步  
raft算法演示地址：http://thesecretlivesofdata.com/raft/  
在Raft中，节点有三种角色：

Leader：负责接收客户端的请求  
Candidate：用于选举Leader的一种角色  
Follower：负责响应来自Leader或者Candidate的请求  
选举分为两个阶段：  
服务启动的时候  
leader挂了的时候  
所有节点启动的时候，都是follower状态。 如果在一段时间内如果没有收到leader的心跳（可能是没有leader，也可能是leader挂了），那么follower会变成Candidate。然后发起选举，选举之前，会增加term，这个term和zookeeper中的epoch的道理是一样的。  
follower会投自己一票，并且给其他节点发送票据vote，等到其他节点回复  
在这个过程中，可能出现几种情况  
收到过半的票数通过，则成为leader  
被告知其他节点已经成为leader，则自己切换为follower  
一段时间内没有收到过半的投票，则重新发起选举  
约束条件在任一term中，单个节点最多只能投一票  
选举的几种情况  
第一种情况，赢得选举之后，leader会给所有节点发送消息，避免其他节点触发新的选举  
第二种情况，比如有三个节点A B C。A B同时发起选举，而A的选举消息先到达C，C给A投了一票，当B的消息到达C时，已经不能满足上面提到的第一个约束，即C不会给B投票，而A和B显然都不会给对方投票。A胜出之后，会给B,C发心跳消息，节点B发现节点A的term不低于自己的term，知道有已经有Leader了，于是转换成follower  
第三种情况， 没有任何节点获得majority投票，可能是平票的情况。加入总共有四个节点（A/B/C/D），Node C、Node D同时成为了candidate，但Node A投了NodeD一票，NodeB投了Node C一票，这就出现了平票 split vote的情况。这个时候大家都在等啊等，直到超时后重新发起选举。如果出现平票的情况，那么就延长了系统不可用的时间,因此raft引入了randomized election timeouts来尽量避免平票情况  
数据的处理  
对于事务操作，请求会转发给leader  
非事务操作上，可以任意一个节点来处理  
下面这段代码摘自 RaftCore ， 在发布内容的时候，做了两个事情

如果当前的节点不是leader，则转发给leader节点处理  
如果是，则向所有节点发送onPublish  
public void signalPublish(String key, Record value) throws Exception \{

if (!isLeader()) {
            JSONObject params = new JSONObject();
            params.put("key", key);
            params.put("value", value);
            Map<String, String> parameters = new HashMap<>(1);
            parameters.put("key", key);
    
            raftProxy.proxyPostLarge(getLeader().ip, API_PUB, params.toJSONString(), parameters);
            return;
        }
    
        try {
            OPERATE_LOCK.lock();
            long start = System.currentTimeMillis();
            final Datum datum = new Datum();
            datum.key = key;
            datum.value = value;
            if (getDatum(key) == null) {
                datum.timestamp.set(1L);
            } else {
                datum.timestamp.set(getDatum(key).timestamp.incrementAndGet());
            }
    
            JSONObject json = new JSONObject();
            json.put("datum", datum);
            json.put("source", peers.local());
    
            onPublish(datum, peers.local());
    
            final String content = JSON.toJSONString(json);
    
            final CountDownLatch latch = new CountDownLatch(peers.majorityCount());
            for (final String server : peers.allServersIncludeMyself()) {
                if (isLeader(server)) {
                    latch.countDown();
                    continue;
                }
                final String url = buildURL(server, API_ON_PUB);
                HttpClient.asyncHttpPostLarge(url, Arrays.asList("key=" + key), content, new AsyncCompletionHandler<Integer>() {
                    @Override
                    public Integer onCompleted(Response response) throws Exception {
                        if (response.getStatusCode() != HttpURLConnection.HTTP_OK) {
                            Loggers.RAFT.warn("[RAFT] failed to publish data to peer, datumId={}, peer={}, http code={}",
                                datum.key, server, response.getStatusCode());
                            return 1;
                        }
                        latch.countDown();
                        return 0;
                    }
    
                    @Override
                    public STATE onContentWriteCompleted() {
                        return STATE.CONTINUE;
                    }
                });
    
            }
    
            if (!latch.await(UtilsAndCommons.RAFT_PUBLISH_TIMEOUT, TimeUnit.MILLISECONDS)) {
                // only majority servers return success can we consider this update success
                Loggers.RAFT.error("data publish failed, caused failed to notify majority, key={}", key);
                throw new IllegalStateException("data publish failed, caused failed to notify majority, key=" + key);
            }
    
            long end = System.currentTimeMillis();
            Loggers.RAFT.info("signalPublish cost {} ms, key: {}", (end - start), key);
        } finally {
            OPERATE_LOCK.unlock();
        }
    }

————————————————  
版权声明：本文为CSDN博主「雨下的泡馍」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/smlCSDN/article/details/100099207