NacosSync

最新推荐文章于 2024-08-18 20:00:54 发布
转载 最新推荐文章于 2024-08-18 20:00:54 发布 · 2.1k 阅读 · 3

本文深入探讨了微服务环境下，Eureka、Zookeeper与Nacos之间的服务同步逻辑。详细介绍了Eureka与Zookeeper如何通过随机选择客户端、校验HTTP状态码、注册实例等步骤将服务信息同步至Nacos。同时，解析了PathChildrenCache与NamingService在zk同步过程中的作用，以及Guava EventBus在同步流程中的应用。

目录

一、Eureka同步逻辑

1. EurekaHttpClient从Client列表中随机选择

2. NamingService从Client列表中随机选择

3. EurekaHttpResponse中InstanceInfo同步

4. 校验HTTP状态码

5. registerInstance()同步服务注册

6. 同步任务订阅到SpecialSyncEventBus

二、zk同步逻辑

1. 根据serviceName的path和随机Client得到PathChildrenCache

2. NamingService从Client列表中随机选择

3. 获取当前数据List

4. 校验queryParam

5. registerInstance()同步服务注册

6. 添加监听器到listener

根据Guava的EventBus模式进行不同注册中心的服务同步（迁移）。

通过EventListener触发同步

public class EventListener {    
    @Subscribe
    public void listenerSyncTaskEvent(SyncTaskEvent syncTaskEvent) {

        try {
            long start = System.currentTimeMillis();
            syncManagerService.sync(syncTaskEvent.getTaskDO());
            skyWalkerCacheServices.addFinishedTask(syncTaskEvent.getTaskDO());
            metricsManager.record(MetricsStatisticsType.SYNC_TASK_RT, System.currentTimeMillis() - start);
        } catch (Exception e) {
            log.warn("listenerSyncTaskEvent process error", e);
        }

    }
}

public class SyncManagerService implements InitializingBean, ApplicationContextAware {
    public boolean sync(TaskDO taskDO) {

        return getSyncService(taskDO.getSourceClusterId(), taskDO.getDestClusterId()).sync(taskDO);

    }

    public SyncService getSyncService(String sourceClusterId, String destClusterId) {

        ClusterTypeEnum sourceClusterType = this.skyWalkerCacheServices.getClusterType(sourceClusterId);
        ClusterTypeEnum destClusterType = this.skyWalkerCacheServices.getClusterType(destClusterId);

        return syncServiceMap.get(generateSyncKey(sourceClusterType, destClusterType));
    }
}

SyncService的实现类sync()同步实现逻辑：

一、Eureka同步逻辑

  1. EurekaHttpClient
  2. NamingService
  3. EurekaHttpResponse
  4. HTTP状态码校验
  5. 同步
  6. 订阅到SpecialSyncEventBus
@NacosSyncService(sourceCluster = ClusterTypeEnum.EUREKA, destinationCluster = ClusterTypeEnum.NACOS)
public class EurekaSyncToNacosServiceImpl implements SyncService {
    @Override
    public boolean sync(TaskDO taskDO) {
        try {
            //random.nextInt(allClusterConnectKey.size())从client列表中随机选择一个client
            //1.EurekaHttpClient
            EurekaHttpClient eurekaHttpClient = eurekaServerHolder.get(taskDO.getSourceClusterId(), null);
            //2.NamingService
            NamingService destNamingService = nacosServerHolder.get(taskDO.getDestClusterId(), null);
            //3.EurekaHttpResponse
            EurekaHttpResponse<Application> eurekaHttpResponse =
                eurekaHttpClient.getApplication(taskDO.getServiceName());
            //Whether eurekaHttpResponse.getStatusCode() is in the HTTP series
            //4.HTTP状态码校验
            if (Objects.requireNonNull(HttpStatus.resolve(eurekaHttpResponse.getStatusCode())).is2xxSuccessful()) {
                Application application = eurekaHttpResponse.getEntity();
                for (InstanceInfo instanceInfo : application.getInstances()) {
                    //5.同步
                    if (needSync(instanceInfo.getMetadata())) {
                        if (InstanceInfo.InstanceStatus.UP.equals(instanceInfo.getStatus())) {
                            destNamingService.registerInstance(taskDO.getServiceName(),
                                buildSyncInstance(instanceInfo, taskDO));
                        } else {
                            destNamingService.deregisterInstance(instanceInfo.getAppName(), instanceInfo.getIPAddr(),
                                instanceInfo.getPort());
                        }
                    }

                }
            } else {
                metricsManager.recordError(MetricsStatisticsType.SYNC_ERROR);
                throw new RuntimeException("trying to connect to the server failed");
            }
            //6.订阅到SpecialSyncEventBus
            specialSyncEventBus.subscribe(taskDO, this::sync);
        } catch (Exception e) {
            log.error("sync task from eureka to nacos was failed, taskId:{}", taskDO.getTaskId(), e);
            metricsManager.recordError(MetricsStatisticsType.SYNC_ERROR);
            return false;
        }
        return true;
    }
}

1. EurekaHttpClient从Client列表中随机选择

EurekaHttpClient eurekaHttpClient = eurekaServerHolder.get(taskDO.getSourceClusterId(), null);
public abstract class AbstractServerHolder<T> implements Holder {
    @Override
    public T get(String clusterId, String namespace) {
        //namespace=null,则finalNamespace=" ";否则为namespace
        final String finalNamespace = Optional.ofNullable(namespace).orElse("");
        //key=clusterId_finalNamespace
        String key = Joiner.on("_").join(clusterId,finalNamespace);
        log.info("starting create cluster server,clusterId={}", clusterId);
        //if key 不存在于serviceMap，则调用传入的function计算key的value，放入缓存map中
        serviceMap.computeIfAbsent(key, clusterKey -> {
            try {
                //随机从random.nextInt(allClusterConnectKey.size())中选择Cluster
                return createServer(clusterId,
                        () -> skyWalkerCacheServices.getClusterConnectKey(clusterId),
                        finalNamespace);
            } catch (Exception e) {
                log.error(String.format("clusterId=%s,start server failed", clusterId), e);
                return null;
            }
        });

        return serviceMap.get(key);
    }
}

2. NamingService从Client列表中随机选择

 NamingService destNamingService = nacosServerHolder.get(taskDO.getDestClusterId(), null);

3. EurekaHttpResponse中InstanceInfo同步

InstanceInfo存储服务信息。

EurekaHttpResponse<Application> eurekaHttpResponse =
                eurekaHttpClient.getApplication(taskDO.getServiceName());

4. 校验HTTP状态码

 if (InstanceInfo.InstanceStatus.UP.equals(instanceInfo.getStatus()))

5. registerInstance()同步服务注册

destNamingService.registerInstance(taskDO.getServiceName(),
                                buildSyncInstance(instanceInfo, taskDO));

6. 同步任务订阅到SpecialSyncEventBus

specialSyncEventBus.subscribe(taskDO, this::sync);

二、zk同步逻辑

  1. PathChildrenCache
  2. NamingService
  3. List<ChildData>
  4. queryParam校验
  5. 同步
  6. 添加监听器
@NacosSyncService(sourceCluster = ClusterTypeEnum.ZK, destinationCluster = ClusterTypeEnum.NACOS)
public class ZookeeperSyncToNacosServiceImpl implements SyncService {
    @Override
    public boolean sync(TaskDO taskDO) {
        try {
            if (pathChildrenCacheMap.containsKey(taskDO.getTaskId())) {
                return true;
            }

            //使用PathChildrenCache监听zk集群当前目录+子节点。
            //1.PathChildrenCache
            PathChildrenCache pathChildrenCache = getPathCache(taskDO);
            //2.NamingService
            NamingService destNamingService = nacosServerHolder
                    .get(taskDO.getDestClusterId(), null);
            //3.List<ChildData>
            //获取当前数据：childData存储路径String path、信息Stat stat
            List<ChildData> currentData = pathChildrenCache.getCurrentData();
            for (ChildData childData : currentData) {
                String path = childData.getPath();
                Map<String, String> queryParam = parseQueryString(childData.getPath());
                //4.queryParam校验
                if (isMatch(taskDO, queryParam) && needSync(queryParam)) {
                    Map<String, String> ipAndPortParam = parseIpAndPortString(path);
                    Instance instance = buildSyncInstance(queryParam, ipAndPortParam, taskDO);
                    //5.同步
                    destNamingService.registerInstance(
                            getServiceNameFromCache(taskDO.getTaskId(), queryParam),
                            instance);
                }
            }
            //6.添加监听器
            Objects.requireNonNull(pathChildrenCache).getListenable()
                    .addListener((client, event) -> {
                        try {

                            String path = event.getData().getPath();
                            Map<String, String> queryParam = parseQueryString(path);

                            if (isMatch(taskDO, queryParam) && needSync(queryParam)) {
                                Map<String, String> ipAndPortParam = parseIpAndPortString(path);
                                Instance instance = buildSyncInstance(queryParam, ipAndPortParam,
                                        taskDO);
                                switch (event.getType()) {
                                    case CHILD_ADDED:
                                        destNamingService.registerInstance(
                                                getServiceNameFromCache(taskDO.getTaskId(),
                                                        queryParam), instance);
                                        break;
                                    case CHILD_UPDATED:

                                        destNamingService.registerInstance(
                                                getServiceNameFromCache(taskDO.getTaskId(),
                                                        queryParam), instance);
                                        break;
                                    case CHILD_REMOVED:

                                        destNamingService.deregisterInstance(
                                                getServiceNameFromCache(taskDO.getTaskId(),
                                                        queryParam),
                                                ipAndPortParam.get(INSTANCE_IP_KEY),
                                                Integer.parseInt(
                                                        ipAndPortParam.get(INSTANCE_PORT_KEY)));

                                        break;
                                    default:
                                        break;
                                }
                            }
                        } catch (Exception e) {
                            log.error("event process from zookeeper to nacos was failed, taskId:{}",
                                    taskDO.getTaskId(), e);
                            metricsManager.recordError(MetricsStatisticsType.SYNC_ERROR);
                        }

                    });
        } catch (Exception e) {
            log.error("sync task from zookeeper to nacos was failed, taskId:{}", taskDO.getTaskId(),
                    e);
            metricsManager.recordError(MetricsStatisticsType.SYNC_ERROR);
            return false;
        }
        return true;
    }
}

1. 根据serviceName的path和随机Client得到PathChildrenCache

PathChildrenCache监听zk集群中节点信息。

PathChildrenCache pathChildrenCache = getPathCache(taskDO);
   /**
     * fetch the Path cache when the task sync
     */
    protected PathChildrenCache getPathCache(TaskDO taskDO) {
        return pathChildrenCacheMap.computeIfAbsent(taskDO.getTaskId(), (key) -> {
            try {
                //集群中每个节点启动时，都注册到ZKServer上，然后每个节点都接收节点改变的监听，以便每个节点都实时更新集群信息（其他应用要使用）
                //监听使用PathChildrenCache,能监听当前目录+子节点。
                PathChildrenCache pathChildrenCache =
                        new PathChildrenCache(
                                //从client列表中随机得到一个client(CuratorFramework的client)
                                zookeeperServerHolder.get(taskDO.getSourceClusterId(), ""),
                                //路径：/dubbo/serviceName/providers
                                convertDubboProvidersPath(taskDO.getServiceName()), false);
                //BUILD_INITIAL_CACHE模式启动cache
                //  调用rebuild方法（此方法会阻塞执行）
                //      重新查询所有需要的数据
                //      不会触发任何事件
                //      安全创建path
                //      清空currentData缓存
                //      重新加载path下子节点，逐个结点重构缓存
                //          逐个读取节点数据和状态
                //          构建ChildData放入currentData
                //      通过rebuildTestExchanger发送要给信号对象
                pathChildrenCache.start(PathChildrenCache.StartMode.BUILD_INITIAL_CACHE);
                return pathChildrenCache;
            } catch (Exception e) {
                log.error("zookeeper path children cache start failed, taskId:{}",
                        taskDO.getTaskId(), e);
                return null;
            }
        });

    }

2. NamingService从Client列表中随机选择

 NamingService destNamingService = nacosServerHolder.get(taskDO.getDestClusterId(), null);

3. 获取当前数据List<ChildData>

 List<ChildData> currentData = pathChildrenCache.getCurrentData();

 ChildData存储path、服务信息Stat。

public class ChildData implements Comparable<ChildData>
{
    private final String path;
    private final Stat stat;
    private final byte[] data;
}

4. 校验queryParam

Map<String, String> queryParam = parseQueryString(childData.getPath());
if (isMatch(taskDO, queryParam) && needSync(queryParam))

5. registerInstance()同步服务注册

destNamingService.registerInstance(
                            getServiceNameFromCache(taskDO.getTaskId(), queryParam),
                            instance);

6. 添加监听器到listener

Objects.requireNonNull(pathChildrenCache).getListenable()
                    .addListener((client, event))

 

参考：https://my.oschina.net/roccn/blog/918209

Nacos-Sync同步Eureka服务到指定命名空间
03-04 1056
Nacos-Sync同步Eureka服务到指定命名空间 默认情况下Nacos-Sync只能同步到public空间内, 但是某些时候我们需要同步到指定命名空间内, 此时只需做一些简单的修改即可满足. 首先下载源码https://github.com/nacos-group/nacos-sync.git之后切换到对应版本分支, 我用的是0.4.4的分支. 找到同步eureka的实现类EurekaSyncToNacosServiceImpl对应的方法sync(TaskDO taskDO) EurekaNaming
06. Nacos服务端-同步服务实例
u010369122的博客
12-03 792
喜闻乐见的是，果然为了提升性能，采用了异步处理方式，将任务添加到一个 tasks中，后续再处理，但是大家可能这时候会疑惑，我怎么知道在哪里会处理？告诉大家一个经验，一般来说这种异步处理逻辑，在哪个类里面添加的任务，该类中。上面方法的逻辑就是取出所有的任务key 进行遍历，然后获取 NacosTaskProcessor，调用。进行处理，如果处理失败或者发生异常，就将任务重新添加到Tasks，这里的关键逻辑肯定是。上面方法就是调用 task.run()，而 task 就是前面将任务进行转换过后的。
nacos-sync:服务同步组件
05-14
Nacos Sync 功能 控制台：提供用于管理的API和控制台 工作者：提供者服务注册同步。 建筑学 建筑拓扑 +-------------+ +----> |NacosClusterA| | +-------------+ +-------------+ | |NacosClusterB| Pull | +--+----------+ Info | +------------+ ^ | |ZooKeeper | | | +--+---
Nacos Committer 张龙：Nacos Sync 的设计原理和规划
weixin_34235135的博客
05-13 330
图：Nacos Meetup @杭州与你同行，抬头便是星空。本文整理自Nacos Committer 张龙的现场分享，阿里巴巴中间件受权发布。随着 Nacos 1.0.0 稳定版的发布，越来越多的企业开始在测试/预演/生产环境中逐步部署 Nacos。目前，除了部分企业已处于转型分布式架构的过程中，会考虑直接使用 Nacos 上生产，但仍有不少企业会考虑一些比较现实的问题：存量用户如何迁移注册中心到...
Nacos-Sync-未授权进后台（建议自查）
2301_80127209的博客
04-12 963
申明：本账号所分享内容仅用于网络安全技术讨论，切勿用于违法途径，所有渗透都需获取授权，违者后果自行承担，与本号及作者无关，请谨记守法。环境搭建、HTML，PHP，MySQL基础学习，信息收集，SQL注入,XSS，CSRF，暴力破解等等。对于鉴权类型的漏洞，主要的修复方式是全局增加鉴权。访问之后直接是进入后台的样子~免费领取安全学习资料包！帮助你在面试中脱颖而出。
gavinh2016#someArticles#Nacos16# NacosSync双向复制使用指南1
07-25
引言Nacos的注册发现和配置中心的源码基本录完了，还有一块是不同集群之间的同步。zk同步到Nacos集群，nacos集群之间做多活需要数据复制等。那本文就先看
nacosSync-server.jar
03-04
nacosSync同步eureka服务到指定命名空间内, 基于0.4.4修改.
k8s安装NacosSync
03-14
Kubernetes＊＊＊开源的容器编排平台，而NacosSync是一个用于同步Nacos配置中心数据到本地文件的工具。下面是安装NacosSync的步骤： 1. 首先，确保你已经安装了Kubernetes集群，并且集群正常运行。 2. 在...
linux 安装nacos nacosSync
11-03
根据提供的引用内容，可以得知安装nacos和nacosSync的步骤如下： 1. 解压jdk-8u191-linux-x64.tar.gz和nacosSync.0.4.7.tar.gz 2. 安装JDK1.8 3. 部署Nacos-Sync 4. 开启服务访问端口 5. 访问nacos-sync页面 6. ...
Nacos架构与原理 - Nacos-Sync
热门推荐
小工匠
07-01 1万+
NacosSync 是⼀个支持多种注册中心的同步组件,基于 Spring boot 开发框架,数据层采用Spring Data JPA ，遵循了标准的 JPA 访问规范，支持多种数据源存储,默认使用Hibernate实现,更加方便的支持表的自动创建更新。使用了高效的事件异步驱动模型, 支持多种自定义事件,使得同步任务处理的延时控制在 3s, 8C 16G 的单机能够支持 6K 的同步任务。
nacos-sync注册中心同步服务安装
qq_42834385的博客
04-13 1910
标题 文章目录标题概述Eureka注册中心同步至Nacos注册中心，搭建nacos-sync服务过程一、操作步骤1、解压jdk-8u191-linux-x64.tar.gz和nacosSync.0.4.7.tar.gz2、安装JDK1.83、部署Nacos-Sync4、开启服务访问端口5、访问nacos-sync页面二、操作步骤1、设置注册中心地址2、设置需要同步的服务 概述 Eureka注册中心同步至Nacos注册中心，搭建nacos-sync服务过程 一、操作步骤 1、解压jdk-8u191-linux
Nacos（十一）之NacosSync 介绍
茅坤宝骏氹的博客
02-01 1014
转载自NacosSync 介绍 介绍 NacosSync是一个支持多种注册中心的同步组件,基于Spring boot开发框架,数据层采用Spring Data JPA,遵循了标准的JPA访问规范,支持多种数据源存储,默认使用Hibernate实现,更加方便的支持表的自动创建更新 使用了高效的事件异步驱动模型, 支持多种自定义事件,使得同步任务处理的延时控制在3s,8C16G的单机能够支持6K的同步任务 NacosSync除了单机部署,也提供了高可用的集群部署模式,NacosSync是无状态设计,..
NacosSync 用户手册
深圳市多克创新科技有限公司
12-02 1732
NacosSync 用户手册
八、Nacos源码系列：Nacos集群数据同步
weixiaohuai的博客
02-07 2037
在Nacos以集群模式运行时，当Nacos服务器收到服务注册请求后，发生了ClientEvent.ClientChangedEvent事件，就会触发将注册的服务信息同步给集群中的其他Nacos-server节点。同步时，会涉及到一个负责节点和非负责节点。
Nacos的实时同步机制
chuixue24的博客
07-07 815
无
Nacos-Sync-未授权进后台
杳若的博客
08-16 1805
Nacos-Sync-未授权进后台
Nacos是如何实现数据同步的？
m0_73868307的博客
12-09 1590
Nacos是一个分布式系统，为了确保集群间数据一致，不仅仅依赖于数据发生改变时的实时同步，后台有定时任务做数据同步。此外，Nacos还提供了Nacos Sync功能，用于控制台管理和API，以及提供者服务注册同步。控制台提供了“同步配置”和“同步元数据”两个选项，可以选择需要同步的内容。简而言之，Nacos通过定时任务和Nacos Sync功能实现了集群间数据的同步，保证了数据的一致性和可靠性。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。
nacos-sync0.4.8+nginx安装部署
hlvy
03-16 577
nacos-sync0.4.8+nginx安装部署
【微服务】Nacos配置中心和客户端数据同步模式
最新发布
wosixiaokeai的博客
08-18 1169
Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它提供了一组简单易用的特性集，帮助用户快速实现动态服务发现、服务配置、服务元数据及流量管理。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值