Nacos 1.4.x 临时实例心跳机制和服务健康检查

已于 2023-07-01 18:58:17 修改
阅读量458 收藏
点赞数
分类专栏： Nacos 文章标签： java Nacos
于 2023-07-01 17:17:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Confused_Tom_Cat/article/details/131464405
版权

参考链接：https://cloud.tencent.com/developer/article/2120188

关键属性

BeatReactor

  • Map<String, BeatInfo> dom2Beat：保存客户端心跳信息，key：serviceName + “#” + ip + “#” + port

ServiceManager

  • Map<String, Map<String, Service>> serviceMap：保存实例注册信息Map(namespace, Map(group::serviceName, Service))

Service

  • ClientBeatCheckTask clientBeatCheckTask：心跳检测任务
  • Map<String, Cluster> clusterMap：Cluster Map，Cluster中保存这个cluster下的所有Instance

Cluster

  • HealthCheckTask checkTask：给当前Cluster下的所有Instance异步发送心跳信息
  • Set persistentInstances：保存持久化Instance
  • Set ephemeralInstances：保存临时Instance，Instance注册实际是修改这个Set（将新添加的和需要保留的Instance放到新的Set中，然后用新Set替代旧的ephemeralInstances）

心跳流程

临时实例

  1. 客户端判断为临时实例时，会添加心跳任务，任务执行间隔固定时间，向服务端的/nacos/v1/ns/instance/beat接口发送心跳信息
  2. 服务端的心跳接口收到信息后，修改Instance为健康状态，并更新收到心跳的时间（lastBeat）为当前时间
  3. Service的ClientBeatCheckTask线程轮训检查临时实例的lastBeat的值，如果超过健康时间，修改实例为不健康，如果超过删除时间，调用内部删除的http接口删除实例

持久化实例

Cluster初始化时添加HealthCheckTask任务到线程池，HealthCheckTask会轮训Cluster中的持久化实例并向他们发送请求，通过请求的响应来标记健康状态

客户端

NacosNamingService.registerInstance

客户端建立心跳任务并向服务端发起注册请求

    public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
        NamingUtils.checkInstanceIsLegal(instance);
        String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
        if (instance.isEphemeral()) {
            BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
            beatReactor.addBeatInfo(groupedServiceName, beatInfo);
        }
        serverProxy.registerService(groupedServiceName, groupName, instance);
    }

BeatReactor.buildBeatInfo

建立新的心跳信息

	public BeatInfo buildBeatInfo(String groupedServiceName, Instance instance){
        BeatInfo beatInfo = new BeatInfo();
        beatInfo.setServiceName(groupedServiceName);
        beatInfo.setIp(instance.getIp());
        beatInfo.setPort(instance.getPort());
        beatInfo.setCluster(instance.getClusterName());
        beatInfo.setWeight(instance.getWeight());
        beatInfo.setMetadata(instance.getMetadata());
        beatInfo.setScheduled(false);
        beatInfo.setPeriod(instance.getInstanceHeartBeatInterval());
        return beatInfo;
    }

BeatReactor.addBeatInfo

添加心跳任务

	public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
	    NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo);
	    // 建立key：serviceName + "#" + ip + "#" + port
	    String key = buildKey(serviceName, beatInfo.getIp(), beatInfo.getPort());
	    BeatInfo existBeat = null;
	    // 如果存在相同的心跳任务，暂停之前的心跳任务
	    if ((existBeat = dom2Beat.put(key, beatInfo)) != null) {
	        existBeat.setStopped(true);
	    }
	    // 添加心跳任务
	    executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
	    MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
	}

BeatTask.run

心跳任务的执行，当前执行完成后，通过finally再此将任务加入到线程池中，来实现向服务端定时发送心跳信息
向服务端发送心跳信息后，如果服务端不存在此Instance，则再次调用注册方法

	public void run() {
		// 如果心跳任务暂停了，就不再继续执行
	    if (beatInfo.isStopped()) {
	        return;
	    }
	    long nextTime = beatInfo.getPeriod();
	    try {
	    	// 向服务端发送心跳信息，url为/nacos/v1/ns/instance/beat
	        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();
	        }
	        // 如果心跳对应的Instance在服务端不存在，调用注册接口重新向服务端发起注册
	        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.warn("[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.beat

提供给客户端的心跳接口，处理来自客户端的心跳请求
1.从请求中获取Instance的相关信息namespaceId，serviceName，clusterName，ip，port
2.如果Instance不存在且心跳信息也不存在，返回RESOURCE_NOT_FOUND异常，客户端收到这个异常后会重新向服务端发起注册请求
3.Instance不存在但心跳信息存在，调用注册方法注册Instance
4.判断Service是否存在，不存在抛出异常，存在则调用处理心跳信息的方法

	@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);
	    }
	    // 获取心跳请求中的namespaceId，serviceName，clusterName，ip，port
	    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);
	    // 获取对应的Instance信息
	    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;
	        }
	        // 服务端中不存在这个Instance，重新注册
	        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);
	    }
	    // 判断服务是否存在
	    Service service = serviceManager.getService(namespaceId, serviceName);
	    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;
	}

Service.processClientBeat

// 添加心跳信息处理的任务到线程池

    public void processClientBeat(final RsInfo rsInfo) {
        ClientBeatProcessor clientBeatProcessor = new ClientBeatProcessor();
        clientBeatProcessor.setService(this);
        clientBeatProcessor.setRsInfo(rsInfo);
        HealthCheckReactor.scheduleNow(clientBeatProcessor);
    }
ClientBeatProcessor.run

心跳信息处理，修改Cluster中对应的Instance.lastBeat的值为当前系统时间，如果之前Instance.healthy为false且Instance.marked为false，修改Instance.healthy为true且发布Instance改变的事件

	public void run() {
        Service service = this.service;
        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) {
                instance.setLastBeat(System.currentTimeMillis());
                // 修改Instance健康状态并发布事件
                if (!instance.isMarked() && !instance.isHealthy()) {
                    instance.setHealthy(true);
                    getPushService().serviceChanged(service);
                }
            }
        }
    }

ServiceManager.putServiceAndInit

将Service保存到serviceMap中，并将Service初始化，初始化时会新建心跳的定时任务

	private void putServiceAndInit(Service service) throws NacosException {
	    putService(service);
	    service = getService(service.getNamespaceId(), service.getName());
	    service.init();
	    consistencyService
	            .listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), true), service);
	    consistencyService
	            .listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), false), service);
	    Loggers.SRV_LOG.info("[NEW-SERVICE] {}", service.toJson());
	}
	// 启动服务的心跳检测
	public void init() {
	   HealthCheckReactor.scheduleCheck(clientBeatCheckTask);
	   for (Map.Entry<String, Cluster> entry : clusterMap.entrySet()) {
	       entry.getValue().setService(this);
	       entry.getValue().init();
	   }
	}

Service.init()

添加当前Service对应的心跳检测任务到线程池，5S一次，同时调用Cluster的init方法

    public void init() {
        HealthCheckReactor.scheduleCheck(clientBeatCheckTask);
        for (Map.Entry<String, Cluster> entry : clusterMap.entrySet()) {
            entry.getValue().setService(this);
            entry.getValue().init();
        }
    }
ClientBeatCheckTask.run
	public void run() {
	    try {
	    	// 判断Service是否由当前服务端进行检测
	        if (!getDistroMapper().responsible(service.getName())) {
	            return;
	        }
	        
	        if (!getSwitchDomain().isHealthCheckEnabled()) {
	            return;
	        }
	        // 获取当前Service下所有的临时的Instance
	        List<Instance> instances = service.allIPs(true);
	        
	        // first set health status of instances:
	        for (Instance instance : instances) {
	        	// 如果上次收到心跳的时间到现在超过了预定的时间，设置Instance的状态为false，并发送ServiceChangeEvent和InstanceHeartbeatTimeoutEvent事件
	            if (System.currentTimeMillis() - instance.getLastBeat() > instance.getInstanceHeartBeatTimeOut()) {
	                if (!instance.isMarked()) {
	                    if (instance.isHealthy()) {
	                        instance.setHealthy(false);
	                        getPushService().serviceChanged(service);
	                        ApplicationUtils.publishEvent(new InstanceHeartbeatTimeoutEvent(this, instance));
	                    }
	                }
	            }
	        }
	        // getGlobalConfig().isExpireInstance()的值默认为true
	        if (!getGlobalConfig().isExpireInstance()) {
	            return;
	        }
	        for (Instance instance : instances) {
	            if (instance.isMarked()) {
	                continue;
	            }
	            // 心跳超时，使用http异步请求/v1/ns/instance?来删除Instance
	            if (System.currentTimeMillis() - instance.getLastBeat() > instance.getIpDeleteTimeout()) {
	                deleteIp(instance);
	            }
	        }
	        
	    } catch (Exception e) {
	        Loggers.SRV_LOG.warn("Exception while processing client beat time out.", e);
	    }
	    
	}

Cluster.init

初始化Cluster，通过volatile修饰的属性inited保证只初始化一次，添加健康检测任务到线程池中

    public synchronized void init() {
        if (inited) {
            return;
        }
        checkTask = new HealthCheckTask(this);
        
        HealthCheckReactor.scheduleCheck(checkTask);
        inited = true;
    }
HealthCheckTask.run
	public void run() {
        try {
        	// 检查Cluster是否能执行心跳任务
            if (distroMapper.responsible(cluster.getService().getName()) && switchDomain
                    .isHealthCheckEnabled(cluster.getService().getName())) {
                // 持久性实例心跳检测，会通过向Instance的端口发送请求，通过响应来修改Instance的health的值
                // List<Instance> ips = task.getCluster().allIPs(false);
                healthCheckProcessor.process(this);
            }
        } catch (Throwable e) {
            // 这里省略了日志输出的代码
        } finally {
        	// 重新将当前任务加入线程池中来达到循环执行的目的
            if (!cancelled) {
                HealthCheckReactor.scheduleCheck(this);
                // 这里省略了日志输出的代码
            }
        }
    }
最近减肥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Nacos心跳机制实现快速上下线
欢迎来到我的博客
07-26 890
通过yml配置文件，配置元数据属性对Nacos心跳时间进行自定义配置。spring:cloud:nacos:discovery:metadata:preserved.heart.beat.interval: 1000 #心跳间隔。时间单位:毫秒。心跳间隔preserved.heart.beat.timeout: 3000 #心跳暂停。时间单位:毫秒。
nacos-1.4.rar
11-07
Nacos提供了内置的健康检查机制，可以定期检测服务实例的健康状态。如果发现服务实例异常，会自动从服务列表中剔除，防止故障扩散。1.4版本优化了健康检查算法，提升了检查效率，减少了误判率。 4. **灰度发布** ...
Nacos心跳时间配置及服务快速上下线
Mr_Huang_1的博客
08-03 1990
Nacos默认心跳时间为30秒。
Nacos如何进行服务健康检查？
最新发布
wddblog的博客
05-13 535
如果服务端在一段时间内（例如连续几个心跳周期）没有收到某个临时实例的心跳，那么就会认为该服务实例已经宕机，将其从服务列表中移除。客户端在注册服务时，会向Nacos服务端发送一个心跳请求，并在之后定期发送心跳请求以保持与服务端的连接。Nacos还支持负载均衡和容错处理功能。在服务调用过程中，Nacos可以根据服务实例的健康状态、负载情况等因素进行智能路由，确保请求能够分发到健康且负载较低的服务实例上。服务端负载压力：对于持久实例的健康检查，服务端需要定时发起探测请求并等待响应，这可能会增加服务端的负载压力。
nacos源码分析-心跳检测(服务端)
墨家巨子@俏如来
01-16 2067
前面我们讲了《nacos源码分析-服务注册(客户端)》 和 《nacos源码分析-服务注册(服务端)》，主要是讲的服务注册流程，本章节我们来讲服务心跳检测机制。
Spring Cloud 2.2.2 源码之五十七nacos服务端处理实例心跳一
王伟王胖胖的博客
04-29 1549
Spring Cloud 2.2.2 源码之五十七nacos服务端处理实例心跳回顾客户端实例心跳服务端处理心跳InstanceController的beatService的processClientBeat处理一次心跳 回顾客户端实例心跳 在服务实例注册之前，如果是临时的服务实例，会先开启心跳任务，不过心跳任务5秒后会运行，第一次心跳的时候会带上心跳内容，也就是服务实例的信息，避免实例不存在又要重...
微服务(总): eureka与nacos的区别及心跳配置修改
pingzhuyan的博客
06-25 1481
文章中会介绍到nacos与eureka的本质区别, 并且如何重新配置心跳, 自我保护机制,服务剔除规则, 以及二者如何保证CAP/AP的 微服务注册中心文章末尾是微服务的常用功能服务目录及传送门client 每30秒发送心跳 到 server, 90秒没有收到心跳 删除服务client:register-with-eureka:true #false表示不向注册中心注册fetch-registry:false #false维护服务实例，不区域检索服务#集群指向其他的eureka。
Nacos心跳机制解读（含简单源码分析）
一个菜鸡的博客
12-05 1568
心跳机制是一种用于监测和管理微服务可用性的机制，它用来维护注册中心和服务提供者之间的连接状态，并及时更新服务实例的状态信息。心跳机制包括两个主要组件：心跳发送方（客户端）和心跳接收方（服务端）。每隔几分钟发送一个固定信息给服务端，服务端收到后回复一个固定信息如果服务端几分钟内没有收到客户端信息则视客户端断开。发包方可以是客户也可以是服务端心跳发送方（Heartbeat Sender）：每个微服务都会定期发送称为心跳消息的请求到一个中央位置（例如注册中心或负载均衡器）。
SpringCloudAlibaba - Nacos (1) 服务治理
qq_38074398的博客
07-03 345
最终的效果是将不同用户绑定到不同角色，不同角色可以操作不同命名空间，并对命名空间进行不同的操作（r / w / rw）。下面我们接入一下 Nacos，将我们自己的服务：goods-service、order-service 注册到 Nacos 中，并可用通过管控台进行查看。里面描述着服务的各种信息字段，注意右下角的下线按钮，触发后会修改服务注册表中该服务节点的状态，意味着其他服务无法在访问该节点。会发现新增了一条数据，服务节点的端口为 9201，正是我们新启动的订单服务。版本的 Nacos 进行学习。
nacos1.x升级mysql8.x完整教程.txt
03-15
这是因为，默认情况下，Nacos开启的是Embedded内嵌数据库，持久化开启后，从官网上下载的Nacos默认支持mysql5.X，对于高版本的mysql8.x由于驱动版本太低，是不支持。本文的目标就是让Nacos1.x支持mysql8.x
nacos-1.4.2.7z
07-16
此外，Nacos 还具有健康检查机制，可以实时监控服务实例的状态，确保服务的高可用性。 配置管理是Nacos 的另一大核心功能。它允许开发者集中地管理应用的配置，提供动态配置更新的能力，无需重启应用即可生效。这...
Nacos1.4版本下载
12-02
Nacos 提供实时健康检查，阻止服务向不健康的主机或服务实例发送请求。Nacos 支持传输层(PING 或 TCP)和应用层(如 HTTP、Redis、MySQL、用户自定义）的健康检查。 对于复杂的云环境和网络拓扑环境中（如 VPC、边缘...
nacos2.0.2.zip nacos2.0.2 windows和linux都有从外网GitHub上下载原版
08-24
Nacos是阿里巴巴开源的一款分布式服务治理和配置中心的框架，主要应用于微服务的管理，包括服务注册与发现、配置管理、健康检查等功能。版本2.0.2是Nacos的一个稳定版本，提供了对Windows和Linux操作系统的支持，...
Nacos的服务心跳
qq_40708942的博客
12-08 1602
nacos的实例分为临时实例和永久实例两种,相应的不同的实例会用有不同的心跳机制.临时实例基于心跳方式做健康检测,永久实例是有Nacos主动探测实例状态.可以通过在yaml文件配置.NacosNamingService这个接口实现了服务心跳的功能从上面的代码可以看到BeatInfo就是包含心跳需要的各种信息,这个类中维护了一个线程池;
Nacos---服务心跳
weixin_60786515的博客
02-05 2567
Nacos---服务心跳
Nacos健康检查
Jak的博客
11-14 8796
一、健康检查流程图 二、客户端 nacos是如何定时通过心跳机制判断实例是否存活的呢，这就是健康检查机制。 NamingService.registerInstance()方法中，会做两件事情 组装心跳包BeatInfo，并且发送心跳 注册nacos实例，通过http调用的方式，将请求发送到InstanceController.register()方法中 三、服务端 客户端请求，发送到服务端InstanceController.register()方法中 该方法中调用了serv
Nacos（1.4.2）服务注册、服务心跳源码分析
VivianStark的博客
05-25 503
在服务注册执行putServiceAndInit方法时，调用Service#init方法，一个服务Service对应一个任务，开启健康检查定时任务ClientBeatCheckTask，默认延迟5s后执行，若某个实例超过15s没有收到心跳，则认为实例不健康；若某个实例超过30s没有收到心跳，则删除该实例。执行Cluster的updateIps方法，更新具体的实例信息，此处更新利用了写时复制技术，从老的集合中复制一份数据用来更新数据，而查询时继续从原来的实例中获取。
Nacos 1.4.1注册中心源码深度解析-健康检查
MaoTongBin的专栏
03-11 245
这样就对服务器的节点进行了过滤，只有一台才能执行健康检查。搞了一个定时任务，延时5s执行，然后每隔5s一次。我们来看下这个定时任务com.alibaba.nacos.naming.healthcheck.ClientBeatCheckTask#run。服务注册时会调用到com.alibaba.nacos.naming.core.Service#init。我们在回头看下com.alibaba.nacos.naming.healthcheck.ClientBeatCheckTask#run。
nacos2.X源码分析
05-31
5. `nacos-discovery`: Nacos 的服务发现模块，包括服务注册和发现的 API、服务实例的管理和心跳检测等功能； 6. `nacos-naming`: Nacos 的命名服务模块，包括服务的命名、分组和标签等功能； 7. `nacos-server`: ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值