Nacos---服务心跳

已于 2024-05-08 19:03:54 修改
阅读量2.2k 收藏 2
点赞数 1
文章标签： 分布式
于 2023-02-05 21:16:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60786515/article/details/128893103
版权

上次服务发现说到注册时NacosNamingService 的registerInstance方法会先服务端发送请求

这个也会处理心跳

BeatReactor 维护一个线程池当调用BeatReact的.addBeatInfo(groupedServiceName, beatInfo)方法时，就会执行心跳

 心跳周期的默认值在com.alibaba.nacos.api.common.Constants类中 可以看到是5秒，默认5秒一次心跳。

调用线程池的schedule方法每5秒执行一次

public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
    NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo);
    String key = buildKey(serviceName, beatInfo.getIp(), beatInfo.getPort());
    BeatInfo existBeat = null;
    //fix #1733
    if ((existBeat = dom2Beat.remove(key)) != null) {
        existBeat.setStopped(true);
    }
    dom2Beat.put(key, beatInfo);
    // 利用线程池，定期执行心跳任务，周期为 beatInfo.getPeriod()
    executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
    MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
}

心跳的任务封装在BeatReactor这个类中，是一个Runnable，其run方法如下  发送请求，serverProxy.sendBeat这个地址就是：/v1/ns/instance/beat

@Override
public void run() {
    if (beatInfo.isStopped()) {
        return;
    }
    // 获取心跳周期
    long nextTime = beatInfo.getPeriod();
    try {
        // 发送心跳
        JsonNode result = serverProxy.sendBeat(beatInfo, BeatReactor.this.lightBeatEnabled);
        long interval = result.get("clientBeatInterval").asLong();
        boolean lightBeatEnabled = false;
        if (result.has(CommonParams.LIGHT_BEAT_ENABLED)) {
            lightBeatEnabled = result.get(CommonParams.LIGHT_BEAT_ENABLED).asBoolean();
        }
        BeatReactor.this.lightBeatEnabled = lightBeatEnabled;
        if (interval > 0) {
            nextTime = interval;
        }
        // 判断心跳结果
        int code = NamingResponseCode.OK;
        if (result.has(CommonParams.CODE)) {
            code = result.get(CommonParams.CODE).asInt();
        }
        if (code == NamingResponseCode.RESOURCE_NOT_FOUND) {
            // 如果失败，则需要 重新注册实例
            Instance instance = new Instance();
            instance.setPort(beatInfo.getPort());
            instance.setIp(beatInfo.getIp());
            instance.setWeight(beatInfo.getWeight());
            instance.setMetadata(beatInfo.getMetadata());
            instance.setClusterName(beatInfo.getCluster());
            instance.setServiceName(beatInfo.getServiceName());
            instance.setInstanceId(instance.getInstanceId());
            instance.setEphemeral(true);
            try {
                serverProxy.registerService(beatInfo.getServiceName(),
                                            NamingUtils.getGroupName(beatInfo.getServiceName()), instance);
            } catch (Exception ignore) {
            }
        }
    } catch (NacosException ex) {
        NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, code: {}, msg: {}",
                            JacksonUtils.toJson(beatInfo), ex.getErrCode(), ex.getErrMsg());

    } catch (Exception unknownEx) {
        NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, unknown exception msg: {}",
                            JacksonUtils.toJson(beatInfo), unknownEx.getMessage(), unknownEx);
    } finally {
        executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
    }
}

二.服务端：

InstanceController

服务注册时一样，在nacos-naming模块中的InstanceController类中，定义了一个方法用来处理心跳请求：根据namespaceId、serviceName、clusterName、ip、port从Nacos的注册表中 获取实例如果获取失败，说明心跳失败，实例尚未注册，重新调用注册接口这里重新注册一个实例，

@CanDistro
@PutMapping("/beat")
@Secured(parser = NamingResourceParser.class, action = ActionTypes.WRITE)
public ObjectNode beat(HttpServletRequest request) throws Exception {
	// 解析心跳的请求参数
    ObjectNode result = JacksonUtils.createEmptyJsonNode();
    result.put(SwitchEntry.CLIENT_BEAT_INTERVAL, switchDomain.getClientBeatInterval());

    String beat = WebUtils.optional(request, "beat", StringUtils.EMPTY);
    RsInfo clientBeat = null;
    if (StringUtils.isNotBlank(beat)) {
        clientBeat = JacksonUtils.toObj(beat, RsInfo.class);
    }
    String clusterName = WebUtils
        .optional(request, CommonParams.CLUSTER_NAME, UtilsAndCommons.DEFAULT_CLUSTER_NAME);
    String ip = WebUtils.optional(request, "ip", StringUtils.EMPTY);
    int port = Integer.parseInt(WebUtils.optional(request, "port", "0"));
    if (clientBeat != null) {
        if (StringUtils.isNotBlank(clientBeat.getCluster())) {
            clusterName = clientBeat.getCluster();
        } else {
            // fix #2533
            clientBeat.setCluster(clusterName);
        }
        ip = clientBeat.getIp();
        port = clientBeat.getPort();
    }
    String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);
    String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
    NamingUtils.checkServiceNameFormat(serviceName);
    Loggers.SRV_LOG.debug("[CLIENT-BEAT] full arguments: beat: {}, serviceName: {}", clientBeat, serviceName);
    // 尝试根据参数中的namespaceId、serviceName、clusterName、ip、port等信息
    // 从Nacos的注册表中 获取实例
    Instance instance = serviceManager.getInstance(namespaceId, serviceName, clusterName, ip, port);
	// 如果获取失败，说明心跳失败，实例尚未注册
    if (instance == null) {
        if (clientBeat == null) {
            result.put(CommonParams.CODE, NamingResponseCode.RESOURCE_NOT_FOUND);
            return result;
        }

        Loggers.SRV_LOG.warn("[CLIENT-BEAT] The instance has been removed for health mechanism, "
                             + "perform data compensation operations, beat: {}, serviceName: {}", clientBeat, serviceName);
		// 这里重新注册一个实例
        instance = new Instance();
        instance.setPort(clientBeat.getPort());
        instance.setIp(clientBeat.getIp());
        instance.setWeight(clientBeat.getWeight());
        instance.setMetadata(clientBeat.getMetadata());
        instance.setClusterName(clusterName);
        instance.setServiceName(serviceName);
        instance.setInstanceId(instance.getInstanceId());
        instance.setEphemeral(clientBeat.isEphemeral());

        serviceManager.registerInstance(namespaceId, serviceName, instance);
    }
	// 尝试基于namespaceId和serviceName从 注册表中获取Service服务
    Service service = serviceManager.getService(namespaceId, serviceName);
	// 如果不存在，说明服务不存在，返回404
    if (service == null) {
        throw new NacosException(NacosException.SERVER_ERROR,
                                 "service not found: " + serviceName + "@" + namespaceId);
    }
    if (clientBeat == null) {
        clientBeat = new RsInfo();
        clientBeat.setIp(ip);
        clientBeat.setPort(port);
        clientBeat.setCluster(clusterName);
    }
    // 如果心跳没问题，开始处理心跳结果
    service.processClientBeat(clientBeat);

    result.put(CommonParams.CODE, NamingResponseCode.OK);
    if (instance.containsMetadata(PreservedMetadataKeys.HEART_BEAT_INTERVAL)) {
        result.put(SwitchEntry.CLIENT_BEAT_INTERVAL, instance.getInstanceHeartBeatInterval());
    }
    result.put(SwitchEntry.LIGHT_BEAT_ENABLED, switchDomain.isLightBeatEnabled());
    return result;
}

如果心跳没问题，开始处理心跳结果，也是开启一个线程池执行任务ClientBeatProcessor

同样run方法 主要更新更新实例的最后一次心跳时间 lastBeat

@Override
public void run() {
    Service service = this.service;
    if (Loggers.EVT_LOG.isDebugEnabled()) {
        Loggers.EVT_LOG.debug("[CLIENT-BEAT] processing beat: {}", rsInfo.toString());
    }

    String ip = rsInfo.getIp();
    String clusterName = rsInfo.getCluster();
    int port = rsInfo.getPort();
    // 获取集群信息
    Cluster cluster = service.getClusterMap().get(clusterName);
    // 获取集群中的所有实例信息
    List<Instance> instances = cluster.allIPs(true);

    for (Instance instance : instances) {
        // 找到心跳的这个实例
        if (instance.getIp().equals(ip) && instance.getPort() == port) {
            if (Loggers.EVT_LOG.isDebugEnabled()) {
                Loggers.EVT_LOG.debug("[CLIENT-BEAT] refresh beat: {}", rsInfo.toString());
            }
            // 更新实例的最后一次心跳时间 lastBeat
            instance.setLastBeat(System.currentTimeMillis());
            if (!instance.isMarked()) {
                if (!instance.isHealthy()) {
                    instance.setHealthy(true);
                    Loggers.EVT_LOG
                        .info("service: {} {POS} {IP-ENABLED} valid: {}:{}@{}, region: {}, msg: client beat ok",
                              cluster.getService().getName(), ip, port, cluster.getName(),
                              UtilsAndCommons.LOCALHOST_SITE);
                    getPushService().serviceChanged(service);
                }
            }
        }
    }
}

 三心跳异常

上面是5秒发送心跳主要更新心跳时间

之前说过服务注册时，一定会创建一个Service对象，而Service中有一个init方法，会在注册时被调用 createEmptyService方法调用一个service.init(); 

开启一个线程池 调用scheduleWithFixedDelay方法每个5秒执行一次

public void init() {
    // 开启心跳检测的任务
    HealthCheckReactor.scheduleCheck(clientBeatCheckTask);
    for (Map.Entry<String, Cluster> entry : clusterMap.entrySet()) {
        entry.getValue().setService(this);
        entry.getValue().init();
    }
}

ClientBeatCheckTask 是任务 run方法 判断心跳间隔（当前时间 - 最后一次心跳时间）是否大于 实例被删除的最长超时时间，默认30秒，如果是超过了30秒，则删除实例。 心跳间隔超过15秒则标记被Nacos服务器为不健康

@Override
public void run() {
    try {
        // 找到所有临时实例的列表
        List<Instance> instances = service.allIPs(true);

        // first set health status of instances:
        for (Instance instance : instances) {
            // 判断 心跳间隔（当前时间 - 最后一次心跳时间） 是否大于 心跳超时时间，默认15秒
            if (System.currentTimeMillis() - instance.getLastBeat() > instance.getInstanceHeartBeatTimeOut()) {
                if (!instance.isMarked()) {
                    if (instance.isHealthy()) {
                        // 如果超时，标记实例为不健康 healthy = false
                        instance.setHealthy(false);
 
                        // 发布实例状态变更的事件
                        getPushService().serviceChanged(service);
                        ApplicationUtils.publishEvent(new InstanceHeartbeatTimeoutEvent(this, instance));
                    }
                }
            }
        }

        if (!getGlobalConfig().isExpireInstance()) {
            return;
        }

        // then remove obsolete instances:
        for (Instance instance : instances) {

            if (instance.isMarked()) {
                continue;
            }
           // 判断心跳间隔（当前时间 - 最后一次心跳时间）是否大于 实例被删除的最长超时时间，默认30秒
            if (System.currentTimeMillis() - instance.getLastBeat() > instance.getIpDeleteTimeout()) {
                // 如果是超过了30秒，则删除实例
                Loggers.SRV_LOG.info("[AUTO-DELETE-IP] service: {}, ip: {}", service.getName(),
                                     JacksonUtils.toJson(instance));
                deleteIp(instance);
            }
        }

    } catch (Exception e) {
        Loggers.SRV_LOG.warn("Exception while processing client beat time out.", e);
    }

}

以上就是临时实例心跳检测 和异常处理 

5秒检测一次

在超过15秒没收到客户端心跳时，就会把注册表中实例的健康状态改为false，而实例健康状态发生了变化后也同样会发布一个ServiceChangeEvent事件，

超时30秒没有收到客户端心跳时，就会从注册表表剔除该实例，会使用HTTP DELETE方式调用
/v1/ns/instance地址，

不留痕迹的随风飘荡
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Nacos-服务端心跳机制
程序员劝退师的博客
01-04 5326
前言 上篇文章分析到Nacos客户端心跳机制，那么本文接上文Nacos-客户端心跳机制 ，继续分析Nacos服务端心跳机制。通过上文我们知道客户端发送心跳是通过下面这个接口完成的！Nacos服务端心跳机制我们可以分为两部分来分析，第一部分是心跳续约，第二部分是心跳检测 切入Nacos服务端代码！ Nacos服务端心跳续约 入口InstanceController.beat 这部分主要就是得到request中的数据，取出后为核心逻辑做准备！ 标注1的哪行代码是通过心跳发来的客户端数据，到Nacos服务
最新nacos-server-2.2.0下载
12-29
最新nacos-server-2.2.0版本，windows安装包
LeetCode 训练场：62，2024Java最新大厂面试真题总结
2401_83739660的博客
03-28 434
定义。
注册中心 Nacos 异常实例需要30s才能剔除 Nacos心跳时间设置（踩坑）
最新发布
2401_84046645的博客
04-22 1049
/ 设置心跳的周期，单位为秒，这里将心跳间隔设置为3秒：// 设置心跳超时时间，单位为秒，这里将心跳超时时间设为6秒，// 即服务端6秒收不到客户端心跳，会将该客户端注册的实例设为不健康：// 设置实例删除的超时时间，单位为秒，这里将实例删除超时时间设为9秒，// 即服务端9秒收不到客户端心跳，会将该客户端注册的实例删除：有相关配置如下spring:cloud:nacos:discovery:heart-beat-interval: 1 #心跳间隔。时间单位:秒。心跳间隔。
Nacos心跳时间配置及服务快速上下线
Mr_Huang_1的博客
08-03 1851
Nacos默认心跳时间为30秒。
Nacos心跳机制
qq_55112725的博客
09-22 650
Nacos接收到这个心跳包,首先检查当前服务在不在注册列表中,如果不在按新服务的业务进行注册,如果在,表示当前这个服务是健康状态。如果一个服务连续6次心跳(默认30秒)没有和Nacos进行信息的交互,Nacos会将这个服务从注册列表中剔除。默认情况下,服务启动开始每隔5秒会向Nacos发送一个"心跳包",这个心跳包中包含了当前服务的基本信息。如果一个服务连续3次心跳(默认15秒)没有和Nacos进行信息的交互,就会将当前服务标记为不健康的状态。注册到Nacos的微服务项目(模块)都是会遵循这个心跳机制。
Nacos服务心跳和健康检查源码介绍
spring_root的博客
09-11 921
接下来我们看标记不健康时候的代码，这部分代码在客户端注册的时候也出现相同的代码，只是我们略过了，这部分也是观察者模式的重要体现，从这里我们可以学习到的东西在于结合Spring的事件机制，轻松实现观察者模式，当然这个里面也有部分我感觉写的不太好，哈哈，大佬们看到勿喷。重点部分就是看BeatTask，BeatTask继承Runnable，run方法就是我们的重点，该方法调用了NamingProxy的sendBeat方法，服务端请求地址为/instance/beat的方法。
Nacos心跳检测
end1216的博客
11-08 405
nacos心跳检测 客户端服务端
探秘Nacos心跳机制：分布式系统中的关键之道
m0_72410588的博客
09-04 519
在分布式系统中，心跳是指定期发送的信号，用于检测和确认节点的存活状态。节点通过发送心跳信号来告知其他节点自己还活着，而其他节点则通过接收心跳信号来确认节点是否存活。心跳机制可以保持节点之间的连接，并及时发现节点的失效或故障。Nacos心跳机制在分布式系统中起着至关重要的作用，通过节点之间的心跳信号交互，实现了节点的健康状态监测、服务实例的自动摘除和自动感知等功能。合理配置和使用Nacos心跳机制，有助于提升系统的可靠性和可用性。希望本文对读者理解和使用Nacos心跳机制有所帮助。
Flink 心跳服务机制
METON的博客
10-08 3352
心跳机制是用于检测客户端或者服务端是否存活的一种机制，通过定期向对方发送请求方法，常见的心跳检测有两种： socket 套接字SO_KEEPALIVE本身带有的心跳机制，定期向对方发送心跳包，对方在收到心跳包后会自动回复； 应用自身实现心跳机制，同样也是使用定期发送请求的方式； Flink对各组件服务状态的监控统一使用心跳服务来管理，如同其上诉2实现机制一样，其主要也是调用方通过周期性定时发送心跳请求，接收方接收到心跳请求后作出对应的心跳响应；其内部实现是通过RPC相互调用的方式，并重置...
nacos(三) 心跳检测原理
qq_20831785的博客
03-06 2663
这篇文章主要针对nacos客户端的心跳检测。 在上一篇文章已提到注册服务的时候，碰到临时节点需要注册心跳检测 @Override public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException { if (instance.isEphemeral()) {//临时节点， 配置心跳检测 BeatInfo
spring心跳配置
04-24
spring心跳配置的，两种方式。 一种是以频率的方式 一种是以时间点的方式（）
nacos-server-1.2.0.zip
03-15
nacos-server-1.2.0.zip 包是从...节点Ip 节点状态 集群任期 Leader止时(ms) 心跳止时(ms) 192.168.1.2:8849 LEADER 1 16736 2500 192.168.1.2:8848 FOLLOWER 1 12510 2500 192.168.1.2:8850 FOLLOWER 1 16397 2500
第三章NacosDiscovery--服务治理
02-24
但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：一旦服务提供者地址变化，就需要手工修改代码一旦是多个服务提供者，无法实现负载均衡功能一旦服务变得越来越多，人工维护...
songhuan18#personal-notes#nacos笔记1
07-25
nacos获取配置比较重要的类定时更新元数据信息默认30秒nacos配置类心跳监测类如何自己修改源码后打包nacos。
nacos1.2.1.zip
05-09
作为一个新的coder，源码方面也是必不可少的一部分，最近在刚读完...个人很看好nacos，里边的一些源码精髓值得我们去学习，只做了服务注册，心跳日任务，健康检查的中午注释，后期会慢慢的更新饿的，这里是1.2.1版本的
nacos技术分享注册中心和配置中心)
04-06
nacos 是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台，下面将从注册中心和配置中心两个方面对 nacos 进行详细介绍。 注册中心是 nacos 的核心组件之一，负责管理服务实例的注册和发现。注册...
Nacos心跳机制实现快速上下线
欢迎来到我的博客
07-26 798
通过yml配置文件，配置元数据属性对Nacos心跳时间进行自定义配置。spring:cloud:nacos:discovery:metadata:preserved.heart.beat.interval: 1000 #心跳间隔。时间单位:毫秒。心跳间隔preserved.heart.beat.timeout: 3000 #心跳暂停。时间单位:毫秒。
Nacos注册中心原理解析
qq_45003354的博客
01-20 612
作为注册中心简介和服务注册简流程
nacos.client.heartbeat.interval在哪里配置
05-31
`nacos.client.heartbeat.interval`是Nacos客户端的一个配置属性，用于设置服务实例向Nacos注册中心发送心跳包的时间间隔。该属性可以在Nacos客户端的配置文件中进行配置。 具体来说，可以在`application.properties`或`application.yml`中添加如下配置： - `application.properties` ``` nacos.client.heartbeat.interval=10000 ``` - `application.yml` ``` nacos: client: heartbeat: interval: 10000 ``` 上述配置将Nacos客户端的心跳包时间间隔设置为10秒。可以根据实际情况进行修改。需要注意的是，该配置属性的单位是毫秒。 此外，该属性也可以在代码中进行配置，例如： ```java Properties properties = new Properties(); properties.setProperty("serverAddr", "localhost:8848"); properties.setProperty("namespace", "public"); properties.setProperty("nacos.client.heartbeat.interval", "10000"); NamingService namingService = NamingFactory.createNamingService(properties); ``` 上述代码将Nacos客户端的心跳包时间间隔设置为10秒，并创建一个连接到`localhost:8848`上的`NamingService`对象。需要注意的是，该方法的优先级高于配置文件中的配置。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值