4.Nacos一致性协议Raft心跳包发送

最新推荐文章于 2023-06-16 11:57:32 发布
最新推荐文章于 2023-06-16 11:57:32 发布
阅读量504 收藏 2
点赞数
分类专栏： Nacos 文章标签： raft算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingxinggua9620/article/details/113564706
版权

Nacos源码分析之发送心跳包源码分析

在RaftCore的init()方法中注册了一个每500ms执行一次的心跳任务

@PostConstruct
    public void init() throws Exception {
       	......
        //开启定时任务,每个500ms发起一次心跳    
        GlobalExecutor.registerHeartbeat(new HeartBeat());
        
        Loggers.RAFT.info("timer started: leader timeout ms: {}, heart-beat timeout ms: {}",
                GlobalExecutor.LEADER_TIMEOUT_MS, GlobalExecutor.HEARTBEAT_INTERVAL_MS);
    }

HeartBeat

这个方法中主要是看是否达到了发送心跳的时间，达到了就走发送心跳的逻辑sendBeat()；

//5000ms
public static final long HEARTBEAT_INTERVAL_MS = TimeUnit.SECONDS.toMillis(5L);
//0~5000ms
public volatile long heartbeatDueMs = RandomUtils.nextLong(0, GlobalExecutor.HEARTBEAT_INTERVAL_MS);
//500ms
public static final long TICK_PERIOD_MS = TimeUnit.MILLISECONDS.toMillis(500L);

public class HeartBeat implements Runnable {
    @Override
    public void run() {
        try {

            if (!peers.isReady()) {
                return;
            }
			//获取本机机器的节点信息
            RaftPeer local = peers.local();
            //设置心跳检测的间隔时间,每次发起心跳减去500ms,heartbeatDueMs初始化范围是:0~5000ms
            local.heartbeatDueMs -= GlobalExecutor.TICK_PERIOD_MS;
            if (local.heartbeatDueMs > 0) {
                return;
            }
			//重置心跳时间
            local.resetHeartbeatDue();
			//Leader节点向其他Follow节点小于等于0时发送心跳请求
            sendBeat();
        } catch (Exception e) {
            Loggers.RAFT.warn("[RAFT] error while sending beat {}", e);
        }
    }
}

sendBeat

1.判断如果是单机模式，或者自己不是leader就直接return，因为只有leader才有资格发送心跳包
2.将本机的信息和需要更新的数据的信息封装成一个byte数组，遍历除自己以外的机器发起心跳请求（/v1/ns/raft/beat接口）
3.接收到结果后刷新节点信息

private void sendBeat() throws IOException, InterruptedException {
    //获取本地机器的节点信息
    RaftPeer local = peers.local();
    //判断如果是单机模式，或者自己不是leader就直接return
    if (ApplicationUtils.getStandaloneMode() || local.state != RaftPeer.State.LEADER) {
        return;
    }
    if (Loggers.RAFT.isDebugEnabled()) {
        Loggers.RAFT.debug("[RAFT] send beat with {} keys.", datums.size());
    }
	//重置leader选举时间
    local.resetLeaderDue();

    // build data
    //构建一个空的数据包
    ObjectNode packet = JacksonUtils.createEmptyJsonNode();
    //替换为本地机器的的节点信息
    packet.replace("peer", JacksonUtils.transferToJsonNode(local));

    ArrayNode array = JacksonUtils.createEmptyArrayNode();

    if (switchDomain.isSendBeatOnly()) {
        Loggers.RAFT.info("[SEND-BEAT-ONLY] {}", String.valueOf(switchDomain.isSendBeatOnly()));
    }
	//将信息封装成一个gzip，并且转换为byte数组后发起心跳请求
    if (!switchDomain.isSendBeatOnly()) {
        for (Datum datum : datums.values()) {

            ObjectNode element = JacksonUtils.createEmptyJsonNode();

            if (KeyBuilder.matchServiceMetaKey(datum.key)) {
                element.put("key", KeyBuilder.briefServiceMetaKey(datum.key));
            } else if (KeyBuilder.matchInstanceListKey(datum.key)) {
                element.put("key", KeyBuilder.briefInstanceListkey(datum.key));
            }
            element.put("timestamp", datum.timestamp.get());

            array.add(element);
        }
    }

    packet.replace("datums", array);
    // broadcast
    Map<String, String> params = new HashMap<String, String>(1);
    params.put("beat", JacksonUtils.toJson(packet));

    String content = JacksonUtils.toJson(params);

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    GZIPOutputStream gzip = new GZIPOutputStream(out);
    gzip.write(content.getBytes(StandardCharsets.UTF_8));
    gzip.close();

    byte[] compressedBytes = out.toByteArray();
    String compressedContent = new String(compressedBytes, StandardCharsets.UTF_8);

    if (Loggers.RAFT.isDebugEnabled()) {
        Loggers.RAFT.debug("raw beat data size: {}, size of compressed data: {}", content.length(),
                           compressedContent.length());
    }
	//遍历除自身以外的节点，发送心跳请求
    for (final String server : peers.allServersWithoutMySelf()) {
        try {
            //API_BEAT: /raft/beat
            final String url = buildUrl(server, API_BEAT);
            if (Loggers.RAFT.isDebugEnabled()) {
                Loggers.RAFT.debug("send beat to server " + server);
            }
            HttpClient.asyncHttpPostLarge(url, null, compressedBytes, new AsyncCompletionHandler<Integer>() {
                @Override
                public Integer onCompleted(Response response) throws Exception {
                    if (response.getStatusCode() != HttpURLConnection.HTTP_OK) {
                        Loggers.RAFT.error("NACOS-RAFT beat failed: {}, peer: {}", response.getResponseBody(),
                                           server);
                        MetricsMonitor.getLeaderSendBeatFailedException().increment();
                        return 1;
                    }
					//接收到结果后刷新节点信息
                    peers.update(JacksonUtils.toObj(response.getResponseBody(), RaftPeer.class));
                    if (Loggers.RAFT.isDebugEnabled()) {
                        Loggers.RAFT.debug("receive beat response from: {}", url);
                    }
                    return 0;
                }

                @Override
                public void onThrowable(Throwable t) {
                    Loggers.RAFT.error("NACOS-RAFT error while sending heart-beat to peer: {} {}", server, t);
                    //出现异常时监视器发送心跳失败的次数+1
                    MetricsMonitor.getLeaderSendBeatFailedException().increment();
                }
            });
        } catch (Exception e) {
            Loggers.RAFT.error("error while sending heart-beat to peer: {} {}", server, e);
            MetricsMonitor.getLeaderSendBeatFailedException().increment();
        }
    }

}

RaftController.beat

@PostMapping("/beat")
public JsonNode beat(HttpServletRequest request, HttpServletResponse response) throws Exception {

    String entity = new String(IoUtils.tryDecompress(request.getInputStream()), StandardCharsets.UTF_8);
    String value = URLDecoder.decode(entity, "UTF-8");
    value = URLDecoder.decode(value, "UTF-8");

    JsonNode json = JacksonUtils.toObj(value);

    RaftPeer peer = raftCore.receivedBeat(JacksonUtils.toObj(json.get("beat").asText()));

    return JacksonUtils.transferToJsonNode(peer);
}

RaftCore.receivedBeat

这个方法很长，因为这个方法中不仅有要处理心跳的逻辑，同时还处理了由心跳请求带过来的数据处理的逻辑，所以我们分两段来看，心跳逻辑的处理部分主要做了一下几件事情:
1.进行一系列的判断，看是否出现了异常逻辑（比如发送心跳的不是leader，发送心跳的机器的term比自己的小等等），如果出现了那么抛出异常。

2.排除了异常情况下，走正常逻辑，首先把自己的状态修改为follower，并且把选票改为发送心跳的机器

3.重置leader选举时间和发送心跳的时间

4.更新leader以及peers信息（peers.makeLeader）

这个方法中主要做了以下几件事：
①.设置本地内存的leader为发送心跳的机器
②.判断是否还存在其他状态为leader的节点，如果有，那么发送一个get的异步请求获取该节点的信息（接口为/v1/ns/raft/peer）
③.根据结果对本地的节点信息进行更新

public RaftPeer receivedBeat(JsonNode beat) throws Exception {
    final RaftPeer local = peers.local();
    final RaftPeer remote = new RaftPeer();
    JsonNode peer = beat.get("peer");
    remote.ip = peer.get("ip").asText();
    remote.state = RaftPeer.State.valueOf(peer.get("state").asText());
    remote.term.set(peer.get("term").asLong());
    remote.heartbeatDueMs = peer.get("heartbeatDueMs").asLong();
    remote.leaderDueMs = peer.get("leaderDueMs").asLong();
    remote.voteFor = peer.get("voteFor").asText();
	//如果不是leader发出心跳包 抛出异常
    if (remote.state != RaftPeer.State.LEADER) {
        Loggers.RAFT.info("[RAFT] invalid state from master, state: {}, remote peer: {}", remote.state,
                          JacksonUtils.toJson(remote));
        throw new IllegalArgumentException("invalid state from master, state: " + remote.state);
    }
	//本地任期大于远程任期 抛出异常
    if (local.term.get() > remote.term.get()) {
        Loggers.RAFT
            .info("[RAFT] out of date beat, beat-from-term: {}, beat-to-term: {}, remote peer: {}, and leaderDueMs: {}",
                  remote.term.get(), local.term.get(), JacksonUtils.toJson(remote), local.leaderDueMs);
        throw new IllegalArgumentException(
            "out of date beat, beat-from-term: " + remote.term.get() + ", beat-to-term: " + local.term.get());
    }
	//本地服务状态不是follower 则设置为follower，选票设置为leader的ip
    if (local.state != RaftPeer.State.FOLLOWER) {

        Loggers.RAFT.info("[RAFT] make remote as leader, remote peer: {}", JacksonUtils.toJson(remote));
        // mk follower
        local.state = RaftPeer.State.FOLLOWER;
        local.voteFor = remote.ip;
    }

    final JsonNode beatDatums = beat.get("datums");
    //重置心跳时间和leader选举时间
    local.resetLeaderDue();
    local.resetHeartbeatDue();
	//更新leader以及peers信息
    peers.makeLeader(remote);
	//如果不仅仅只是发送心跳  （可能在心跳的时候也会携带需要更新的数据过来）
    if (!switchDomain.isSendBeatOnly()) {

        Map<String, Integer> receivedKeysMap = new HashMap<>(datums.size());

        for (Map.Entry<String, Datum> entry : datums.entrySet()) {
            receivedKeysMap.put(entry.getKey(), 0);
        }

        // now check datums
        List<String> batch = new ArrayList<>();

        int processedCount = 0;
        if (Loggers.RAFT.isDebugEnabled()) {
            Loggers.RAFT
                .debug("[RAFT] received beat with {} keys, RaftCore.datums' size is {}, remote server: {}, term: {}, local term: {}",
                       beatDatums.size(), datums.size(), remote.ip, remote.term, local.term);
        }
        for (Object object : beatDatums) {
            processedCount = processedCount + 1;

            JsonNode entry = (JsonNode) object;
            String key = entry.get("key").asText();
            final String datumKey;
			//判断是元数据信息还是服务实例数据
            if (KeyBuilder.matchServiceMetaKey(key)) {
                datumKey = KeyBuilder.detailServiceMetaKey(key);
            } else if (KeyBuilder.matchInstanceListKey(key)) {
                datumKey = KeyBuilder.detailInstanceListkey(key);
            } else {
                // ignore corrupted key:
                continue;
            }

            long timestamp = entry.get("timestamp").asLong();

            receivedKeysMap.put(datumKey, 1);

            try {
                //如果本地存在一样的键的数据，时间戳本地的大于远程更新的 那说明数据是过期的，直接忽略
                if (datums.containsKey(datumKey) && datums.get(datumKey).timestamp.get() >= timestamp
                    && processedCount < beatDatums.size()) {
                    continue;
                }
				//如果是本地没有的键的数据或者时间戳大于本地的数据的时间戳的数据，直接添加到list中，等待批量更新
                if (!(datums.containsKey(datumKey) && datums.get(datumKey).timestamp.get() >= timestamp)) {
                    batch.add(datumKey);
                }
				//尽量攒够50一起更新
                if (batch.size() < 50 && processedCount < beatDatums.size()) {
                    continue;
                }

                String keys = StringUtils.join(batch, ",");

                if (batch.size() <= 0) {
                    continue;
                }

                Loggers.RAFT.info("get datums from leader: {}, batch size is {}, processedCount is {}"
                                  + ", datums' size is {}, RaftCore.datums' size is {}", getLeader().ip, batch.size(),
                                  processedCount, beatDatums.size(), datums.size());

                // update datum entry
                //构建http请求根据数据的key获取leader中的数据来更新数据
                //API_GET: /raft/datum
                String url = buildUrl(remote.ip, API_GET) + "?keys=" + URLEncoder.encode(keys, "UTF-8");
                HttpClient.asyncHttpGet(url, null, null, new AsyncCompletionHandler<Integer>() {
                    @Override
                    public Integer onCompleted(Response response) throws Exception {
                        if (response.getStatusCode() != HttpURLConnection.HTTP_OK) {
                            return 1;
                        }

                        List<JsonNode> datumList = JacksonUtils
                            .toObj(response.getResponseBody(), new TypeReference<List<JsonNode>>() {
                            });

                        for (JsonNode datumJson : datumList) {
                            Datum newDatum = null;
                            OPERATE_LOCK.lock();
                            try {

                                Datum oldDatum = getDatum(datumJson.get("key").asText());
								 //旧数据不为空，而且远程的时间戳小于等于本地的时间戳，直接忽略
                                if (oldDatum != null && datumJson.get("timestamp").asLong() <= oldDatum.timestamp
                                    .get()) {
                                    Loggers.RAFT
                                        .info("[NACOS-RAFT] timestamp is smaller than that of mine, key: {}, remote: {}, local: {}",
                                              datumJson.get("key").asText(),
                                              datumJson.get("timestamp").asLong(), oldDatum.timestamp);
                                    continue;
                                }
								//根据不同的数据类型进行处理
                                if (KeyBuilder.matchServiceMetaKey(datumJson.get("key").asText())) {
                                    Datum<Service> serviceDatum = new Datum<>();
                                    serviceDatum.key = datumJson.get("key").asText();
                                    serviceDatum.timestamp.set(datumJson.get("timestamp").asLong());
                                    serviceDatum.value = JacksonUtils
                                        .toObj(datumJson.get("value").toString(), Service.class);
                                    newDatum = serviceDatum;
                                }

                                if (KeyBuilder.matchInstanceListKey(datumJson.get("key").asText())) {
                                    Datum<Instances> instancesDatum = new Datum<>();
                                    instancesDatum.key = datumJson.get("key").asText();
                                    instancesDatum.timestamp.set(datumJson.get("timestamp").asLong());
                                    instancesDatum.value = JacksonUtils
                                        .toObj(datumJson.get("value").toString(), Instances.class);
                                    newDatum = instancesDatum;
                                }

                                if (newDatum == null || newDatum.value == null) {
                                    Loggers.RAFT.error("receive null datum: {}", datumJson);
                                    continue;
                                }
								//本地磁盘写入新数据
                                raftStore.write(newDatum);
								//新数据放入本地内存中
                                datums.put(newDatum.key, newDatum);
                                //添加数据修改的事件
                                notifier.addTask(newDatum.key, ApplyAction.CHANGE);

                                local.resetLeaderDue();
								//更新本地leader和本机的term，数据每次变动，term+100
                                if (local.term.get() + 100 > remote.term.get()) {
                                    getLeader().term.set(remote.term.get());
                                    local.term.set(getLeader().term.get());
                                } else {
                                    local.term.addAndGet(100);
                                }
								 //更新磁盘的term
                                raftStore.updateTerm(local.term.get());

                                Loggers.RAFT.info("data updated, key: {}, timestamp: {}, from {}, local term: {}",
                                                  newDatum.key, newDatum.timestamp, JacksonUtils.toJson(remote), local.term);

                            } catch (Throwable e) {
                                Loggers.RAFT
                                    .error("[RAFT-BEAT] failed to sync datum from leader, datum: {}", newDatum,
                                           e);
                            } finally {
                                OPERATE_LOCK.unlock();
                            }
                        }
                        TimeUnit.MILLISECONDS.sleep(200);
                        return 0;
                    }
                });

                batch.clear();

            } catch (Exception e) {
                Loggers.RAFT.error("[NACOS-RAFT] failed to handle beat entry, key: {}", datumKey);
            }

        }
		//如果是远程没有的key 那么证明本地的key是脏数据 需要删除
        List<String> deadKeys = new ArrayList<>();
        for (Map.Entry<String, Integer> entry : receivedKeysMap.entrySet()) {
            if (entry.getValue() == 0) {
                deadKeys.add(entry.getKey());
            }
        }

        for (String deadKey : deadKeys) {
            try {
                deleteDatum(deadKey);
            } catch (Exception e) {
                Loggers.RAFT.error("[NACOS-RAFT] failed to remove entry, key={} {}", deadKey, e);
            }
        }

    }

    return local;
}

makeLeader

public RaftPeer makeLeader(RaftPeer candidate) {
    //将发送心跳的机器设为leader
    if (!Objects.equals(leader, candidate)) {
        leader = candidate;
        ApplicationUtils.publishEvent(new MakeLeaderEvent(this, leader, local()));
        Loggers.RAFT
            .info("{} has become the LEADER, local: {}, leader: {}", leader.ip, JacksonUtils.toJson(local()),
                  JacksonUtils.toJson(leader));
    }

    for (final RaftPeer peer : peers.values()) {
        Map<String, String> params = new HashMap<>(1);
        //如果本地的内存中还保存着之前的leader
        if (!Objects.equals(peer, candidate) && peer.state == RaftPeer.State.LEADER) {
            try {
                //发送请求获取该机器的信息，更新信息
                String url = RaftCore.buildUrl(peer.ip, RaftCore.API_GET_PEER);
                HttpClient.asyncHttpGet(url, null, params, new AsyncCompletionHandler<Integer>() {
                    @Override
                    public Integer onCompleted(Response response) throws Exception {
                        if (response.getStatusCode() != HttpURLConnection.HTTP_OK) {
                            Loggers.RAFT
                                .error("[NACOS-RAFT] get peer failed: {}, peer: {}", response.getResponseBody(),
                                       peer.ip);
                            peer.state = RaftPeer.State.FOLLOWER;
                            return 1;
                        }

                        update(JacksonUtils.toObj(response.getResponseBody(), RaftPeer.class));

                        return 0;
                    }
                });
            } catch (Exception e) {
                peer.state = RaftPeer.State.FOLLOWER;
                Loggers.RAFT.error("[NACOS-RAFT] error while getting peer from peer: {}", peer.ip);
            }
        }
    }

    return update(candidate);
}
瓜瓜醒
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对标Eureka的AP一致性，Nacos如何实现Raft算法
01-07
Raft 适用于一个管理日志一致性的协议，相比于 Paxos 协议 Raft 更易于理解和去实现它。 为了提高理解性，Raft 将一致性算法分为了几个部分，包括领导选取（leader selection）、日志复制（log replication）、安全...
Nacos源码分析二十四、Raft选举过程（2）
vinylon的博客
01-12 446
MasterElection 投票 前面我们看到了MasterElection用于选举的任务，我们再看一下run方法： @Override public void run() { try { // ready状态 if (!peers.isReady()) { return; } //获取本地结点 RaftPeer local = peers.local(); // 任期-500
Raft算法理解
qq_56449176的博客
06-05 48
客户端发送一个请求到主节点(set 5) 即主节点现在是未提交的(set 5) 再又主节点下个心跳发送给所有follower节点 给所有节点同步(set 5) 然后大多数节点回复给主节点接收到(set 5)未提交 主节点提交(set 5) 响应给客户端 再又主节点下个心跳发送给所有follower节点 给所有节点同步(set 5)已提交。网络分区也可以保存一致性 分区上3下2 当下节点要改变数据由于只有两个节点不占多少 即不会成功 当合并 遵循轮数多的leader节点为新的leader节点。
动手实现 Raft 算法（附详细实现过程及源码）
最新发布
NPC的博客
06-16 1509
一致性问题是分布式领域最基础、最重要的问题，也是半个世纪以来的研究热点。随着业务场景越来越复杂，计算规模越来越庞大，单点系统往往难以满足高可扩展（Scalability）和高容错（Fault-tolerance）两方面的需求。此时就需要多台服务器通过组成集群，构建更加强大和稳定的“虚拟超级服务器”。任务量越大，处理集群的规模越大，设计和管理的挑战也就越高。谷歌公司的全球搜索集群系统，包括数十万台服务器，每天响应百亿次的互联网搜索请求。集群系统要实现一致性不是一件容易的事。
Nacos源码分析之Raft协议(二)----心跳包发送
qq47653423的博客
10-12 707
上篇文章
微服务-Nacos数据一致性
wangzhipeng47的博客
06-05 1400
Nacos数据一致性 目录 一、Raft算法 二、Nacos中Raft部分源码 init() 1. 获取Raft集群节点 NamingProxy.getServers()获取集群节点 NamingProxy.refreshSrvIfNeed()得到节点信息 NamingProxy.refreshServerListFromDisk()获取集群节点信息 2. Raft集群数据恢复 RaftStore.load() 3. Raft选举 GlobalExecutor.registe...
配置nacos集群报错request: /nacos/v1/ns/instance/list failed, servers: [localhost:81/nacos], code: 500, msg
qq_60361946的博客
11-08 6476
request: /nacos/v1/ns/instance/list failed, servers: [localhost:81/nacos], code: 500, msg: Whitelabel Error PageThis application has no explicit mapping for /error, so you are seeing this as a fallback. Tue Nov
Nacos 常见问题及解决方法
xt1233的博客
11-05 1万+
Nacos 开源至今已有一年，在这一年里，得到了很多用户的支持和反馈。在与社区的交流中，我们发现有一些问题出现的频率比较高，为了能够让用户更快的解决问题，我们总结了这篇常见问题及解决方法，这篇文章后续也会合并到 Nacos 官网的 FAQ 里。 如何依赖最新的 Nacos 客户端？ 很多用户都是通过 Spring Cloud Alibaba 或者 Dubbo 依赖的 Nacos 客户端，那么 Sp...
本地nacos报错：nacos启动时两种常见错误解决方法 java.lang.IllegalStateException 和 com.alibaba.nacos.api.exception
枫陵的博客
03-28 9678
报错详情 1： java.lang.IllegalStateException: failed to req API:/nacos/v1/ns/instance after all servers([127.0.0.1:8848]) tried: failed to req API:http://127.0.0.1:8848/nacos/v1/ns/instance. code:500 msg: java.net.ConnectException: Connection refused: connect
Nacos学习笔记（四）：心跳机制
仔哥学编程
12-16 2430
Nacos源码学习：心跳
在.NET Core中用最原生的方式读取Nacos的配置方法(推荐)
12-20
背景 之前老黄写过一篇《ASP.NET Core结合Nacos来完成配置管理和服务发现》简单介绍了如何让.NET Core程序接入Nacos，之前的SDK里面更多的是对Nacos的Open API进行了封装以及对服务注册和发现的封装。 配置这一块当时并没有过多的处理，用起来有时感觉不会特别顺手，所以将它和.NET Core的配置结合起来了，让它用起来更简便。 怎么个简便法呢？ 可以说，除了多添加一下provider，其他的操作都是和最原始的一模一样，你想用IConfiguration就用IConfiguration，想用IOptions系列就用IOptions系列。 更容易做到无缝迁移！ 当然
8.nacos+gateway 动态路由
01-01
"Nacos+Gateway 动态路由实现" Nacos+Gateway 动态路由是 SpringCloud Gateway 中的一种实现方法，主要基于 Nacos 的配置中心和 Gateway 的路由机制，实现了动态路由的配置和更新。 1. Nacos 配置中心 Nacos 是一...
nacos-consistency-2.0.4.RELEASE-API文档-中文版.zip
05-07
标签：pig4cloud、consistency、nacos、jar包、java、中文文档； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准...
nacos-naming-2.0.4.RELEASE-API文档-中文版.zip
05-07
标签：pig4cloud、naming、nacos、jar包、java、中文文档； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请...
nacos-auth-2.0.4.RELEASE-API文档-中文版.zip
05-07
标签：pig4cloud、auth、nacos、jar包、java、中文文档； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请...
Nacos源码解析(二) - 心跳机制与健康检查
qq_40344505的博客
10-19 2070
Nacos心跳机制与健康检查
解决集群环境nacos频繁报错：找不到节点 send request fail,client not connected。
热门推荐
小小张自由—>张有博
03-14 1万+
解决集群环境nacos频繁报错：找不到节点。send request fail,client not connected。
共识算法—Raft协议
08-11
课程目标：理解非拜占庭故障下达成共识的强一致协议Raft；适用人群：大数据/Java基础人群课程收益：理解非拜占庭故障下达成共识的强一致协议Raft；课程配套学习资料，建议学员学习过程中跟着视频教程实操，可理解更加深入。技术问题可在下方留言，每晚8点我会准时答疑。感谢观看，祝您学习愉快！
4.nacos源码分析之-leader发送心跳给所有的follower
colossus——bigdata的专栏
12-19 1083
心跳线程启动 在启动选举线程后，开始启动发送心跳的线程： //每隔500ms发送一次心跳心跳线程 ScheduledExecutorService去调度 GlobalExecutor.registerHeartbeat(new HeartBeat()); public static void registerHeartbeat(Runnable runnable) { ...
Caused by: com.alibaba.nacos.core.distributed.raft.exception.JRaftException: java.io.IOException: Failed to bind
05-24
这个错误是由于Nacos无法在指定端口上绑定，可能是端口已经被占用或者权限不足。您可以尝试更换端口或者以管理员身份运行Nacos。您还可以检查是否有其他应用程序正在使用相同的端口，如果有，请关闭它们以释放端口。如果问题仍然存在，您可以尝试在Nacos配置文件中进行一些更改，例如更改绑定的IP地址或更改Nacos实例的名称。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值