精华内容
下载资源
问答
  • Eureka Eureka is a REST (Representational State Transfer) based service that is primarily used in the AWS cloud for locating services for the purpose of load balancing and failover of middle-tier ...
  • 服务注册和发现随着用户对软件性能的要求越来越高,软件系统从单机到集群到分布式和微服务逐步升级,软件架构越来越复杂。想象一下,如果写代码时在调用rest API,你需要知道对方服务器的IP和端口号,如果对方网络...

    服务注册和发现

    随着用户对软件性能的要求越来越高,软件系统从单机到集群到分布式和微服务逐步升级,软件架构越来越复杂。

    想象一下,如果写代码时在调用rest API,你需要知道对方服务器的IP和端口号,如果对方网络地址是静态的,那么我们可以在配置文件配置或者直接代码里写死,但现在基于云的微服务应用中,服务实例的网络地址是动态分配的。而且,由于自动扩展,失败和更新,服务实例的配置也经常变化。这样一来,客户端代码需要一套更精细的服务发现机制。

    为了解决现状,服务注册中心逐渐被研究以及慢慢进入开发者的视野。

    注册中心对比

    目前主流的注册中心有Zookeeper,Eureka,Nacos,Consul,CoreDNS等产品,下图介绍了当前几种注册中心的差异。

    (上图的consul实际上满足的是cp)

    Eureka 核心概念

    Eureka是Netflix开发的服务发现框架,本身是一个基于REST的服务,主要用于定位运行在AWS域中的中间层服务,以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中,以实现SpringCloud的服务发现功能。

    Eureka Server:注册中心服务端

    注册中心服务端主要对外提供了三个功能:

    服务注册

    服务提供者启动时,会通过 Eureka Client 向 Eureka Server 注册信息,Eureka Server 会存储该服务的信息,Eureka Server 内部有二层缓存机制来维护整个注册表

    提供注册表

    服务消费者在调用服务时,如果 Eureka Client 没有缓存注册表的话,会从 Eureka Server 获取最新的注册表

    同步状态

    Eureka Client 通过注册、心跳机制和 Eureka Server 同步当前客户端的状态。

    Eureka Client:注册中心客户端

    Eureka Client 是一个 Java 客户端,用于简化与 Eureka Server 的交互。Eureka Client 会拉取、更新和缓存 Eureka Server 中的信息。因此当所有的 Eureka Server 节点都宕掉,服务消费者依然可以使用缓存中的信息找到服务提供者,但是当服务有更改的时候会出现信息不一致。

    Register: 服务注册

    服务的提供者,将自身注册到注册中心,服务提供者也是一个 Eureka Client。当 Eureka Client 向 Eureka Server 注册时,它提供自身的元数据,比如 IP 地址、端口,运行状况指示符 URL,主页等。

    Renew: 服务续约

    Eureka Client 会每隔 30 秒发送一次心跳来续约。 通过续约来告知 Eureka Server 该 Eureka Client 运行正常,没有出现问题。 默认情况下,如果 Eureka Server 在 90 秒内没有收到 Eureka Client 的续约,Server 端会将实例从其注册表中删除,此时间可配置,一般情况不建议更改。

    服务续约的两个重要属性

    服务续约任务的调用间隔时间,默认为30秒

    eureka.instance.lease-renewal-interval-in-seconds=30服务失效的时间,默认为90秒。

    eureka.instance.lease-expiration-duration-in-seconds=90

    Eviction 服务剔除

    当 Eureka Client 和 Eureka Server 不再有心跳时,Eureka Server 会将该服务实例从服务注册列表中删除,即服务剔除。

    Cancel: 服务下线

    Eureka Client 在程序关闭时向 Eureka Server 发送取消请求。 发送请求后,该客户端实例信息将从 Eureka Server 的实例注册表中删除。该下线请求不会自动完成,它需要调用以下内容:

    DiscoveryManager.getInstance().shutdownComponent();

    GetRegisty: 获取注册列表信息

    Eureka Client 从服务器获取注册表信息,并将其缓存在本地。客户端会使用该信息查找其他服务,从而进行远程调用。该注册列表信息定期(每30秒钟)更新一次。每次返回注册列表信息可能与 Eureka Client 的缓存信息不同,Eureka Client 自动处理。

    获取服务是服务消费者的基础,所以必有两个重要参数需要注意:

    # 启用服务消费者从注册中心拉取服务列表的功能

    eureka.client.fetch-registry=true# 设置服务消费者从注册中心拉取服务列表的间隔

    eureka.client.registry-fetch-interval-seconds=30

    Remote Call: 远程调用

    当 Eureka Client 从注册中心获取到服务提供者信息后,就可以通过 Http 请求调用对应的服务;服务提供者有多个时,Eureka Client 客户端会通过 Ribbon 自动进行负载均衡。

    自我保护机制

    默认情况下,如果 Eureka Server 在一定的 90s 内没有接收到某个微服务实例的心跳,会注销该实例。但是在微服务架构下服务之间通常都是跨进程调用,网络通信往往会面临着各种问题,比如微服务状态正常,网络分区故障,导致此实例被注销。

    固定时间内大量实例被注销,可能会严重威胁整个微服务架构的可用性。为了解决这个问题,Eureka 开发了自我保护机制,那么什么是自我保护机制呢?

    Eureka Server 接收到的服务续约低于为该值配置的百分比(默认15分钟内低于85%),则服务开启自我保护机制,也就是不再剔除注册列表的信息。

    Eureka Server 触发自我保护机制后,页面会出现提示:

    Eureka Server 进入自我保护机制,会出现以下几种情况:

    (1 Eureka 不再从注册列表中移除因为长时间没收到心跳而应该过期的服务

    (2 Eureka 仍然能够接受新服务的注册和查询请求,但是不会被同步到其它节点上(即保证当前节点依然可用)

    (3 当网络稳定时,当前实例新的注册信息会被同步到其它节点中

    Eureka 自我保护机制是为了防止误杀服务而提供的一个机制。

    当个别客户端出现心跳失联时,则认为是客户端的问题,剔除掉客户端;当 Eureka 捕获到大量的心跳失败时,则认为可能是网络问题,进入自我保护机制;

    当客户端心跳恢复时,Eureka 会自动退出自我保护机制。

    如果在保护期内刚好这个服务提供者非正常下线了,此时服务消费者就会拿到一个无效的服务实例,即会调用失败。对于这个问题需要服务消费者端要有一些容错机制,如重试,断路器等。

    通过在 Eureka Server 配置如下参数,开启或者关闭保护机制,生产环境建议打开:

    eureka.server.enable-self-preservation=true

    Eureka 集群原理

    再来看看 Eureka 集群的工作原理。我们假设有三台 Eureka Server 组成的集群,第一台 Eureka Server 在北京机房,另外两台 Eureka Server 在深圳和西安机房。这样三台 Eureka Server 就组建成了一个跨区域的高可用集群,只要三个地方的任意一个机房不出现问题,都不会影响整个架构的稳定性。

    从图中可以看出 Eureka Server 集群相互之间通过 Replicate(复制) 来同步数据,相互之间不区分主节点和从节点,所有的节点都是平等的。在这种架构中,节点通过彼此互相注册来提高可用性,每个节点需要添加一个或多个有效的 serviceUrl 指向其他节点。

    如果某台 Eureka Server 宕机,Eureka Client 的请求会自动切换到新的 Eureka Server 节点。当宕机的服务器重新恢复后,Eureka 会再次将其纳入到服务器集群管理之中。当节点开始接受客户端请求时,所有的操作都会进行节点间复制,将请求复制到其它 Eureka Server 当前所知的所有节点中。

    另外 Eureka Server 的同步遵循着一个非常简单的原则:只要有一条边将节点连接,就可以进行信息传播与同步。所以,如果存在多个节点,只需要将节点之间两两连接起来形成通路,那么其它注册中心都可以共享信息。每个 Eureka Server 同时也是 Eureka Client,多个 Eureka Server 之间通过 P2P 的方式完成服务注册表的同步。

    Eureka Server 集群之间的状态是采用异步方式同步的,所以不保证节点间的状态一定是一致的,不过基本能保证最终状态是一致的。

    Eureka 分区

    Eureka 提供了 Region 和 Zone 两个概念来进行分区,这两个概念均来自于亚马逊的 AWS:

    region:可以理解为地理上的不同区域,比如亚洲地区,中国区或者深圳等等。没有具体大小的限制。根据项目具体的情况,可以自行合理划分 region。

    zone:可以简单理解为 region 内的具体机房,比如说 region 划分为深圳,然后深圳有两个机房,就可以在此 region 之下划分出 zone1、zone2 两个 zone。

    上图中的 us-east-1c、us-east-1d、us-east-1e 就代表了不同的 Zone。Zone 内的 Eureka Client 优先和 Zone 内的 Eureka Server 进行心跳同步,同样调用端优先在 Zone 内的 Eureka Server 获取服务列表,当 Zone 内的 Eureka Server 挂掉之后,才会从别的 Zone 中获取信息。

    Eurka 保证 AP

    Eureka Server 各个节点都是平等的,几个节点挂掉不会影响正常节点的工作,剩余的节点依然可以提供注册和查询服务。而 Eureka Client 在向某个 Eureka 注册时,如果发现连接失败,则会自动切换至其它节点。只要有一台 Eureka Server 还在,就能保证注册服务可用(保证可用性),只不过查到的信息可能不是最新的(不保证强一致性)。

    Eureka 工作流程

    了解完 Eureka 核心概念,自我保护机制,以及集群内的工作原理后,我们来整体梳理一下 Eureka 的工作流程:

    1、Eureka Server 启动成功,等待服务端注册。在启动过程中如果配置了集群,集群之间定时通过 Replicate 同步注册表,每个 Eureka Server 都存在独立完整的服务注册表信息

    2、Eureka Client 启动时根据配置的 Eureka Server 地址去注册中心注册服务

    3、Eureka Client 会每 30s 向 Eureka Server 发送一次心跳请求,证明客户端服务正常

    4、当 Eureka Server 90s 内没有收到 Eureka Client 的心跳,注册中心则认为该节点失效,会注销该实例

    5、单位时间内 Eureka Server 统计到有大量的 Eureka Client 没有上送心跳,则认为可能为网络异常,进入自我保护机制,不再剔除没有上送心跳的客户端

    6、当 Eureka Client 心跳请求恢复正常之后,Eureka Server 自动退出自我保护模式

    7、Eureka Client 定时全量或者增量从注册中心获取服务注册表,并且将获取到的信息缓存到本地

    8、服务调用时,Eureka Client 会先从本地缓存找寻调取的服务。如果获取不到,先从注册中心刷新注册表,再同步到本地缓存

    9、Eureka Client 获取到目标服务器信息,发起服务调用

    10、Eureka Client 程序关闭时向 Eureka Server 发送取消请求,Eureka Server 将实例从注册表中删除

    Eureka控制台参数说明

    1、HOME

    进入Eureka控制台首页,首先看HOME页的头部

    System Status

    Environment: 环境,默认为test,该参数在实际使用过程中,可以不用更改

    Data center: 数据中心,使用的是默认的是 “MyOwn”

    Current time:当前的系统时间

    Uptime:已经运行了多少时间

    Lease expiration enabled:是否启用租约过期 ,自我保护机制关闭时,该值默认是true, 自我保护机制开启之后为false。

    Renews threshold: 每分钟最少续约数,Eureka Server 期望每分钟收到客户端实例续约的总数。

    Renews (last min): 最后一分钟的续约数量(不含当前,1分钟更新一次),Eureka Server 最后 1 分钟收到客户端实例续约的总数。

    2、DS Replicas

    这个下面的信息是这个Eureka Server相邻节点,互为一个集群。

    再往下面,就是注册到这个服务上的实例信息。

    4、General Info

    total-avail-memory : 总共可用的内存

    environment : 环境名称,默认test

    num-of-cpus : CPU的个数

    current-memory-usage : 当前已经使用内存的百分比

    server-uptime : 服务启动时间

    registered-replicas : 相邻集群复制节点

    unavailable-replicas :不可用的集群复制节点,如何确定不可用? 主要是server1 向 server2和server3发送接口查询自身的注册信息,

    如果查询不到,则默认为不可用,也就是说如果Eureka Server自身不作为客户端注册到上面去,则相邻节点都会显示为不可用。

    available-replicas :可用的相邻集群复制节点

    5、Instance Info

    ipAddr:eureka服务端IP

    status:eureka服务端状态

    Last 1000 cancelled leases:最后1000个取消的租约

    Last 1000 newly registered leases:最后1000个新注册的租约

    Eureka工作原理:https://blog.csdn.net/qwe86314/article/details/94552801

    展开全文
  • Eureka是Netflix开源的一款提供服务注册和发现的产品,github地址为 https://github.com/Netflix/eureka。注册中心是分布式开发的核心组件之一,而eureka是spring cloud推荐的注册中心实现,因此对于Java开发同学来...

    Eureka是Netflix开源的一款提供服务注册和发现的产品,github地址为 https://github.com/Netflix/eureka。注册中心是分布式开发的核心组件之一,而eureka是spring cloud推荐的注册中心实现,因此对于Java开发同学来说,还是有必要学习eureka的,特别是其架构及设计思想。

    官方文档定义是:Eureka is a REST (Representational State Transfer) based service that is primarily used in the AWS cloud for locating services for the purpose of load balancing and failover of middle-tier servers. We call this service, the Eureka Server. Eureka also comes with a Java-based client component,the Eureka Client, which makes interactions with the service much easier. The client also has a built-in load balancer that does basic round-robin load balancing.

    Eureka是一个REST (Representational State Transfer)服务,它主要用于AWS云,用于定位服务,以实现中间层服务器的负载平衡和故障转移,我们称此服务为Eureka服务器。Eureka也有一个基于java的客户端组件,Eureka客户端,这使得与服务的交互更加容易,同时客户端也有一个内置的负载平衡器,它执行基本的循环负载均衡。

    Eureka提供了完整的Service Registry和Service Discovery实现,并且也经受住了Netflix自己的生产环境考验,相对使用起来会比较省心(同时Spring Cloud还有一套非常完善的开源代码来整合Eureka,所以使用起来非常方便)

    本文主要内容有:eureka基础概念及架构、服务发现原理、eureka server/client流程分析及优缺点分析,最后做个小结。由于本文侧重于原理分析,因此eureka(结合spring cloud)的使用就不再赘述了,感兴趣的小伙伴可以看下 程序猿DD 关于spring cloud的相关教程。

    eureka基础

    eureka架构图

    c486fd059d22412e02363dff0a663140.png
    • Eureka Server:提供服务注册和发现,多个Eureka Server之间会同步数据,做到状态一致(最终一致性)
    • Service Provider:服务提供方,将自身服务注册到Eureka,从而使服务消费方能够找到
    • Service Consumer:服务消费方,从Eureka获取注册服务列表,从而能够消费服务

    注意,上图中的3个角色都是逻辑角色,在实际运行中,这几个角色甚至可以是同一个项目(JVM进程)中。

    自我保护机制

    自我保护机制主要在Eureka Client和Eureka Server之间存在网络分区的情况下发挥保护作用,在服务器端和客户端都有对应实现。假设在某种特定的情况下(如网络故障), Eureka Client和Eureka Server无法进行通信,此时Eureka Client无法向Eureka Server发起注册和续约请求,Eureka Server中就可能因注册表中的服务实例租约出现大量过期而面临被剔除的危险,然而此时的Eureka Client可能是处于健康状态的(可接受服务访问),如果直接将注册表中大量过期的服务实例租约剔除显然是不合理的,自我保护机制提高了eureka的服务可用性。

    当自我保护机制触发时,Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务,仍能查询服务信息并且接受新服务注册请求,也就是其他功能是正常的。这里思考下,如果eureka节点A触发自我保护机制过程中,有新服务注册了然后网络回复后,其他peer节点能收到A节点的新服务信息,数据同步到peer过程中是有网络异常重试的,也就是说,是能保证最终一致性的。

    服务发现原理

    eureka server可以集群部署,多个节点之间会进行(异步方式)数据同步,保证数据最终一致性,Eureka Server作为一个开箱即用的服务注册中心,提供的功能包括:服务注册、接收服务心跳、服务剔除、服务下线等。需要注意的是,Eureka Server同时也是一个Eureka Client,在不禁止Eureka Server的客户端行为时,它会向它配置文件中的其他Eureka Server进行拉取注册表、服务注册和发送心跳等操作。

    eureka server端通过appName和instanceInfoId来唯一区分一个服务实例,服务实例信息是保存在哪里呢?其实就是一个Map中:

    // 第一层的key是appName,第二层的key是instanceInfoIdprivate final ConcurrentHashMap>> registry  = new ConcurrentHashMap>>();

    服务注册

    Service Provider启动时会将服务信息(InstanceInfo)发送给eureka server,eureka server接收到之后会写入registry中,服务注册默认过期时间DEFAULT_DURATION_IN_SECS = 90秒。InstanceInfo写入到本地registry之后,然后同步给其他peer节点,对应方法com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl#replicateToPeers。

    写入本地registry

    服务信息(InstanceInfo)保存在Lease中,写入本地registry对应方法com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl#register,Lease统一保存在内存的ConcurrentHashMap中,在服务注册过程中,首先加个读锁,然后从registry中判断该Lease是否已存在,如果已存在则比较lastDirtyTimestamp时间戳,取二者最大的服务信息,避免发生数据覆盖。使用InstanceInfo创建一个新的InstanceInfo:

    if (existingLastDirtyTimestamp > registrationLastDirtyTimestamp) { // 已存在Lease则比较时间戳,取二者最大值 registrant = existingLease.getHolder();}Lease lease = new Lease(registrant, leaseDuration);if (existingLease != null) { // 已存在Lease则取上次up时间戳 lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());}​public Lease(T r, int durationInSecs) { holder = r; registrationTimestamp = System.currentTimeMillis(); // 当前时间 lastUpdateTimestamp = registrationTimestamp; duration = (durationInSecs * 1000);}

    不知道小伙伴看了上述方法的代码有没有这样的疑问?

    通过读锁并且 registry 的读取和写入不是原子的,那么在并发时其实是有可能发生数据覆盖的,如果发生数据覆盖岂不是有问题了!猛一看会以为脏数据不就是有问题么?换个角度想,脏数据就一定有问题么?

    其实针对这个问题,eureka的处理方式是没有问题的,该方法并发时,针对InstanceInfo Lease的构造,二者的信息是基本一致的,因为registrationTimestamp取的就是当前时间,所以并并发的数据不会产生问题。

    同步给其他peer

    InstanceInfo写入到本地registry之后,然后同步给其他peer节点,对应方法com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl#replicateToPeers。如果当前节点接收到的InstanceInfo本身就是另一个节点同步来的,则不会继续同步给其他节点,避免形成“广播效应”;InstanceInfo同步时会排除当前节点。

    InstanceInfo的状态有依以下几种:Heartbeat, Register, Cancel, StatusUpdate, DeleteStatusOverride,默认情况下同步操作时批量异步执行的,同步请求首先缓存到Map中,key为requestType+appName+id,然后由发送线程将请求发送到peer节点。

    Peer之间的状态是采用异步的方式同步的,所以不保证节点间的状态一定是一致的,不过基本能保证最终状态是一致的。结合服务发现的场景,实际上也并不需要节点间的状态强一致。在一段时间内(比如30秒),节点A比节点B多一个服务实例或少一个服务实例,在业务上也是完全可以接受的(Service Consumer侧一般也会实现错误重试和负载均衡机制)。所以按照CAP理论,Eureka的选择就是放弃C,选择AP。

    如果同步过程中,出现了异常怎么办呢,这时会根据异常信息做对应的处理,如果是读取超时或者网络连接异常,则稍后重试;如果其他异常则打印错误日志不再后续处理。

    服务续约

    Renew(服务续约)操作由Service Provider定期调用,类似于heartbeat。主要是用来告诉Eureka Server Service Provider还活着,避免服务被剔除掉。renew接口实现方式和register基本一致:首先更新自身状态,再同步到其它Peer,服务续约也就是把过期时间设置为当前时间加上duration的值。

    注意:服务注册如果InstanceInfo不存在则加入,存在则更新;而服务预约只是进行更新,如果InstanceInfo不存在直接返回false。

    服务下线

    Cancel(服务下线)一般在Service Provider shutdown的时候调用,用来把自身的服务从Eureka Server中删除,以防客户端调用不存在的服务,eureka从本地”删除“(设置为删除状态)之后会同步给其他peer,对应方法com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl#cancel。

    服务失效剔除

    Eureka Server中有一个EvictionTask,用于检查服务是否失效。Eviction(失效服务剔除)用来定期(默认为每60秒)在Eureka Server检测失效的服务,检测标准就是超过一定时间没有Renew的服务。默认失效时间为90秒,也就是如果有服务超过90秒没有向Eureka Server发起Renew请求的话,就会被当做失效服务剔除掉。失效时间可以通过eureka.instance.leaseExpirationDurationInSeconds进行配置,定期扫描时间可以通过eureka.server.evictionIntervalTimerInMs进行配置。

    服务剔除#evict方法中有很多限制,都是为了保证Eureka Server的可用性:比如自我保护时期不能进行服务剔除操作、过期操作是分批进行、服务剔除是随机逐个剔除,剔除均匀分布在所有应用中,防止在同一时间内同一服务集群中的服务全部过期被剔除,以致大量剔除发生时,在未进行自我保护前促使了程序的崩溃。

    eureka server/client流程

    服务信息拉取

    Eureka consumer服务信息的拉取分为全量式拉取和增量式拉取,eureka consumer启动时进行全量拉取,运行过程中由定时任务进行增量式拉取,如果网络出现异常,可能导致先拉取的数据被旧数据覆盖(比如上一次拉取线程获取结果较慢,数据已更新情况下使用返回结果再次更新,导致数据版本落后),产生脏数据。对此,eureka通过类型AtomicLong的fetchRegistryGeneration对数据版本进行跟踪,版本不一致则表示此次拉取到的数据已过期。

    fetchRegistryGeneration过程是在拉取数据之前,执行fetchRegistryGeneration.get获取当前版本号,获取到数据之后,通过fetchRegistryGeneration.compareAndSet来判断当前版本号是否已更新。

    注意:如果增量式更新出现意外,会再次进行一次全量拉取更新。

    Eureka server的伸缩容

    Eureka Server是怎么知道有多少Peer的呢?Eureka Server在启动后会调用EurekaClientConfig.getEurekaServerServiceUrls来获取所有的Peer节点,并且会定期更新。定期更新频率可以通过eureka.server.peerEurekaNodesUpdateIntervalMs配置。

    这个方法的默认实现是从配置文件读取,所以如果Eureka Server节点相对固定的话,可以通过在配置文件中配置来实现。如果希望能更灵活的控制Eureka Server节点,比如动态扩容/缩容,那么可以override getEurekaServerServiceUrls方法,提供自己的实现,比如我们的项目中会通过数据库读取Eureka Server列表。

    eureka server启动时把自己当做是Service Consumer从其它Peer Eureka获取所有服务的注册信息。然后对每个服务信息,在自己这里执行Register,isReplication=true,从而完成初始化。

    Service Provider

    Service Provider启动时首先时注册到Eureka Service上,这样其他消费者才能进行服务调用,除了在启动时之外,只要实例状态信息有变化,也会注册到Eureka Service。需要注意的是,需要确保配置eureka.client.registerWithEureka=true。register逻辑在方法AbstractJerseyEurekaHttpClient.register中,Service Provider会依次注册到配置的Eureka Server Url上,如果注册出现异常,则会继续注册其他的url。

    Renew操作会在Service Provider端定期发起,用来通知Eureka Server自己还活着。 这里instance.leaseRenewalIntervalInSeconds属性表示Renew频率。默认是30秒,也就是每30秒会向Eureka Server发起Renew操作。这部分逻辑在HeartbeatThread类中。在Service Provider服务shutdown的时候,需要及时通知Eureka Server把自己剔除,从而避免客户端调用已经下线的服务,逻辑本身比较简单,通过对方法标记@PreDestroy,从而在服务shutdown的时候会被触发。

    Service Consumer

    Service Consumer这块的实现相对就简单一些,因为它只涉及到从Eureka Server获取服务列表和更新服务列表。Service Consumer在启动时会从Eureka Server获取所有服务列表,并在本地缓存。需要注意的是,需要确保配置eureka.client.shouldFetchRegistry=true。由于在本地有一份Service Registries缓存,所以需要定期更新,定期更新频率可以通过eureka.client.registryFetchIntervalSeconds配置。

    小结

    为什么要用eureka呢,因为分布式开发架构中,任何单点的服务都不能保证不会中断,因此需要服务发现机制,某个节点中断后,服务消费者能及时感知到保证服务高可用。从eureka的设计与实现上来说还是容易理解的,SpringCloud将它集成在自己的子项目spring-cloud-netflix中,实现SpringCloud的服务发现功能。

    注册中心除了用eureka之外,还有zookeeper、consul、nacos等解决方案,他们实现原理不同,各自适用于不同的场景,可按需使用。

    Eureka比ZooKeeper相比优势是什么

    Zookeeper保证CP 当向注册中心查询服务列表时,我们可以容忍注册中心返回的是几分钟以前的注册信息,但不能接受服务直接down掉不可用。也就是说,服务注册功能对可用性的要求要高于一致性。但是zk会出现这样一种情况,当master节点因为网络故障与其他节点失去联系时,剩余节点会重新进行leader选举。问题在于,选举leader的时间太长,30 ~ 120s, 且选举期间整个zk集群都是不可用的,这就导致在选举期间注册服务瘫痪。在云部署的环境下,因网络问题使得zk集群失去master节点是较大概率会发生的事,虽然服务能够最终恢复,但是漫长的选举时间导致的注册长期不可用是不能容忍的。

    Eureka保证AP Eureka看明白了这一点,因此在设计时就优先保证可用性。Eureka各个节点都是平等的,几个节点挂掉不会影响正常节点的工作,剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册或时如果发现连接失败,则会自动切换至其它节点,只要有一台Eureka还在,就能保证注册服务可用(保证可用性),只不过查到的信息可能不是最新的(不保证强一致性)。除此之外,Eureka还有一种自我保护机制,如果在15分钟内超过85%的节点都没有正常的心跳,那么Eureka就认为客户端与注册中心出现了网络故障。

    eureka有哪些不足: eureka consumer本身有缓存,服务状态更新滞后,最常见的状况就是,服务下线了但是服务消费者还未及时感知,此时调用到已下线服务会导致请求失败,只能依靠consumer端的容错机制来保证。

    展开全文
  • 本篇将来先解析下Eureka Client 的工作原理。Netflix 和 SpringCloudspring-cloud-commons 模块是 spring 在分布式领域上(服务发现,服务注册,断路器,负载均衡)的规范定义。spring-cloud-netflix...

    前面一些 demo 中已经介绍了如何使用 SOFABoot 来集成 Spring Cloud Netflix Eureka 组件。本篇将来先解析下 Eureka Client 的工作原理。

    Netflix 和 SpringCloud

    spring-cloud-commons 模块是 spring 在分布式领域上(服务发现,服务注册,断路器,负载均衡)的规范定义。spring-cloud-netflix 是基于此规范的具体实现,Netflix OSS 里的各种组件也都实现了这个 commons 规范。关系如下:

    Spring Cloud Netflix Eureka 服务发现实现原理

    基于上图,这里以 Eureka 中的服务发现为例,来具体讲下是如何实现的。Spring Cloud common 中提供了用于服务发现的两个关键类:DiscoveryClient 接口 和 EnableDiscoveryClient 注解。

    DiscoveryClient 接口

    下面这张图描述的是在服务发现这个功能上,SpringCloud 是如何与 Netflix 整合的。 在 spring-cloud-netflix-eureka-client 中对 Spring Cloud Common 中的 DiscoveryClient 接口进行了实现,实现类是 EurekaDiscoveryClient 。

    DiscoveryClient 的接口定义与方法:

    /**

    * DiscoveryClient表示服务发现常用的读取操作,例如Netflix Eureka或consul.io

    * @author Spencer Gibb

    */

    public interface DiscoveryClient {

    /**

    * 实现描述

    * @return the description

    */

    String description();

    /**

    * 获取与特定serviceId关联的所有ServiceInstances

    * @param serviceId the serviceId to query

    * @return a List of ServiceInstance

    */

    List getInstances(String serviceId);

    /**

    * 返回所有已知的服务ID

    */

    List getServices();

    }

    复制代码

    EurekaDiscoveryClient 中实现了这几个方法,但是 EurekaDiscoveryClient 自身没有实现如何与服务端交互的逻辑,而是通过 com.netflix.DiscoveryClient 类来完成。所以 spring-cloud-netflix-eureka-client 干的事情就是实现了 Spring Cloud Common 规范,然后在实现上包装了 netflix 。

    @EnableDiscoveryClient 注解

    ```java @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @Import(EnableDiscoveryClientImportSelector.class) public @interface EnableDiscoveryClient { //是否自动注册,默认是true。 boolean autoRegister() default true; } ```

    EnableDiscoveryClientImportSelector 将会从 META-INF/spring.factories 里找出 key 为org.springframework.cloud.client.discovery.EnableDiscoveryClient 的类。

    对于 autoRegister :

    如果自动注册属性为true,会在找出的这些类里再加上一个类:AutoServiceRegistrationConfiguration, AutoServiceRegistrationConfiguration 内部会使用@EnableConfigurationProperties(AutoServiceRegistrationProperties.class) 触发构造AutoServiceRegistrationProperties 这个 bean。像eureka,nacos,它们的自动化配置类里都使用了@ConditionalOnBean(AutoServiceRegistrationProperties.class) 来确保存在AutoServiceRegistrationProperties 这个 bean 存在的时候才会构造 AutoServiceRegistration 进行注册。

    如果自动注册属性为 false,在Environment 里加一个 PropertySource,内部的配置项是spring.cloud.service-registry.auto-registration.enabled,值是false(代表不构造AutoServiceRegistrationProperties.class)。这样 eureka 就不会注册。

    对应上面这段逻辑的代码如下:

    spring-cloud-netflix-eureka-client 自己也提供了一个注解 EnableEurekaClient,其作用于这个注解一样

    Eureka 架构图

    consumer  : 服务消费方,eureka client 角色,可以从 eureka server 上拉取到其他已注册服务的信息,从而根据这些信息找到自己所需的服务,然后发起远程调用。

    provider : 服务提供方,eureka client 角色,可以向 eureka server 上注册和更新自己的信息,当然作为 eureka client ,它也可以从server 上获取到其他服务的信息。

    Eureka server : 服务注册中心,提供服务注册和服务发现功能;

    同步复制 : eureka server 之间进行注册服务信息的同步,这样可以保证集群中每个server 都能提供完整的服务信息。

    关于 AWS 上 Regin 和 Availability Zone 的概念,请自行查阅相关资料

    源码解析

    配置信息读取

    Eureka Client的自动配置类是 org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration ,这里面主要就负责了一些配置信息的服务诸如 DiscoveryClient 、EurekaServiceRegistry等主要bean的初始化工作。

    另外还有一个 EurekaDiscoveryClientConfiguration 类,负责配置自动注册和应用的健康检查器初始化。

    读取 eureka.client.*

    @Bean

    @ConditionalOnMissingBean(value = EurekaClientConfig.class, search = SearchStrategy.CURRENT)

    public EurekaClientConfigBean eurekaClientConfigBean(ConfigurableEnvironment env) {

    EurekaClientConfigBean client = new EurekaClientConfigBean();

    if ("bootstrap".equals(this.env.getProperty("spring.config.name"))) {

    // 默认情况下,我们不会在引导过程中注册,但是以后会有另一个机会。

    client.setRegisterWithEureka(false);

    }

    return client;

    }

    复制代码

    EurekaClientConfigBean 封装的是 eureka client 和 eureka server 交互所需要的配置信息,比如前面demo工程中的 eureka.client.service-url.defaultZone 的配置。

    读取 eureka.instance.*

    @Bean

    @ConditionalOnMissingBean(value = EurekaInstanceConfig.class, search = SearchStrategy.CURRENT)

    public EurekaInstanceConfigBean eurekaInstanceConfigBean(InetUtils inetUtils,

    ManagementMetadataProvider managementMetadataProvider) {

    // 代码较长,此处省略

    }

    复制代码

    EurekaInstanceConfigBean 封装的是 eureka client 自身实例的配置信息,提供服务注册的基本元数据信息。

    核心组件 bean 初始化

    这里也实例化了一些核心的组件bean。

    ApplicationInfoManager

    EurekaClientConfiguration#eurekaApplicationInfoManager

    @Bean

    @ConditionalOnMissingBean(value = ApplicationInfoManager.class, search = SearchStrategy.CURRENT)

    public ApplicationInfoManager eurekaApplicationInfoManager(

    EurekaInstanceConfig config) {

    InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);

    return new ApplicationInfoManager(config, instanceInfo);

    }

    复制代码

    RefreshableEurekaClientConfiguration#eurekaApplicationInfoManager

    @Bean

    @ConditionalOnMissingBean(value = ApplicationInfoManager.class, search = SearchStrategy.CURRENT)

    @org.springframework.cloud.context.config.annotation.RefreshScope

    @Lazy

    public ApplicationInfoManager eurekaApplicationInfoManager(EurekaInstanceConfig config) {

    InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);

    return new ApplicationInfoManager(config, instanceInfo);

    }

    复制代码

    RefreshScope ,被此注解标注的情况下,将会被动态刷新。包括属性信息等,注意,对于动态刷新,被RefreshScope标记的类不能是final的。

    ApplicationInfoManager 是应用信息管理器,用于管理服务实例的信息类 InstanceInfo 和服务实例的配置信息类 EurekaInstanceConfig 。

    DiscoveryClient

    @Bean

    public DiscoveryClient discoveryClient(EurekaInstanceConfig config, EurekaClient client) {

    return new EurekaDiscoveryClient(config, client);

    }

    复制代码

    DiscoveryClient ,前面说到,这个类是Spring Cloud 中用于服务发现使用的客户端接口。注意这里是SpringCloud提供的接口,不是netflix中的类。

    EurekaServiceRegistry

    @Bean

    public EurekaServiceRegistry eurekaServiceRegistry() {

    return new EurekaServiceRegistry();

    }

    复制代码

    EurekaServiceRegistry 是 ServiceRegistry 的实现类。ServiceRegistry 是 SpringCloud 提供了注册和注销等方法,这些方法允许用户提供自定义注册服务。

    EurekaRegistration

    @Bean

    @ConditionalOnBean(AutoServiceRegistrationProperties.class)

    @ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)

    public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient, CloudEurekaInstanceConfig instanceConfig, ApplicationInfoManager applicationInfoManager, ObjectProvider healthCheckHandler) {

    return EurekaRegistration.builder(instanceConfig)

    .with(applicationInfoManager)

    .with(eurekaClient)

    .with(healthCheckHandler)

    .build();

    }

    复制代码

    每个 ServiceRegistry 实现都有自己的 Registry 实现。

    ZookeeperRegistration -> ZookeeperServiceRegistry

    ZookeeperRegistration -> EurekaServiceRegistry

    ConsulRegistration       -> ConsulServiceRegistry

    如果你需要自定义实现 ServiceRegistry ,则也不要提供一个 Registration  的实现。

    服务发现

    服务发现的基本情况在上面已经提到了,但是由于 SpingCloud 中并没有提供具体的交互操作而是由 com.netflix.discovery.DiscoveryClient 来完成具体工作。所以关于服务服务发现这里就直接围绕这个类来展开。

    LookopService

    public interface LookupService {

    // 根据服务实例注册的appName 来获取 Application

    Application getApplication(String appName);

    // 返回当前注册表中所有的服务实例信息

    Applications getApplications();

    // 根据服务实例Id获取服务实例信息

    List getInstancesById(String id);

    /**

    * 获取下一个可能的服务器,以处理来自从eureka接收到的注册表信息的请求。

    * @virtualHostname 与 服务器 关联的虚拟主机名。

    * @secure 指示是HTTP还是HTTPS请求

    *

    */

    InstanceInfo getNextServerFromEureka(String virtualHostname, boolean secure);

    }

    复制代码

    LookupService 接口的作用就是用于查找活动服务实例;总共提供了四个方法,很好理解。每个方法的作用见注释。

    EurekaClient

    EurekaClient 也是一个接口,集成并且扩展了 LookupService。

    This interface does NOT try to clean up the current client interface for eureka 1.x. Rather it tries to provide an easier transition path from eureka 1.x to eureka 2.x. 从这来看,EurekaClient 的存在是为了给 Eureka1.x 向 Eureka 2.x 升级提供容错能力。

    EurekaClient 在 LookupService 基础上扩展了很多方法,如下:

    public interface EurekaClient extends LookupService {

    // 省去@Deprecated方法和获取服务实例信息的接口方法

    // 注册健康检查处理器

    public void registerHealthCheck(HealthCheckHandler healthCheckHandler);

    // 监听client服务信息的更新

    public void registerEventListener(EurekaEventListener eventListener);

    // 取消监听

    public boolean unregisterEventListener(EurekaEventListener eventListener);

    // 获取当前健康检查处理器

    public HealthCheckHandler getHealthCheckHandler();

    // 关闭 eureka 客户端。还向eureka服务器发送撤销注册请求。

    public void shutdown();

    // EurekaClientConfig

    public EurekaClientConfig getEurekaClientConfig();

    // ApplicationInfoManager

    public ApplicationInfoManager getApplicationInfoManager();

    }

    复制代码

    HealthCheckHandler 这个是用于检查当前客户端状态的,这个在后面心跳机制里面会说道。

    DiscoveryClient

    com.netflix.discovery.DiscoveryClient,这个类会在构造函数中完成一系列重要的操作,如:拉取注册表信息,服务注册,初始化心跳机制,缓存刷新,按需注册定时任务等等。

    DiscoveryClient(ApplicationInfoManager applicationInfoManager,

    EurekaClientConfig config,

    AbstractDiscoveryClientOptionalArgs args,

    Provider backupRegistryProvider) {

    // ...

    }

    复制代码

    几个参数的释义如下:

    applicationInfoManager :应用信息管理器

    config :client 与 server 交互的配置信息

    args :客户端提供的过滤器类型(支持jersey1和jersey2),后面用来构建 EurekaTransport

    backupRegistryProvider : 备份注册中心

    服务发现

    下面代码片段也是在 DiscoveryClient 的构造函数里面的,这里就是拉取注册服务信息的逻辑:

    if (clientConfig.shouldFetchRegistry() && !fetchRegistry(false)) {

    fetchRegistryFromBackup();

    }

    复制代码

    clientConfig.shouldFetchRegistry() 这个方法拿到的就是配置文件中 eureka.client.fetch-registry 的值,默认为true,表示从 eureka server 拉取注册表信息。

    fetchRegistry(boolean)是从 eureka server 拉取注册信息的方法,参数用于表示是否是强制拉取全量的注册信息;此方法除非在协调eureka服务器和客户端注册表信息方面存在问题,否则此方法只尝试在第一次进行全量获取,后面均是增量获取。

    fetchRegistryFromBackup() 如果 eureka server 服务不可用,则采用的备用方案。

    底层通信实现 EurekaTransport

    EurekaTransport 是 DiscoveryClient 的内部类,EurekaTransport 封装了具体的基于 jersey 的底层通信实现。

    FetchRegistry

    上图为拉取注册信息的整个过程。对于黄色贴条上的条件,如果满足其中一个,则都会进行全量拉取;否则进行增量拉取。计算 hash 值是为了后面可以与server端应用信息的进行对比,用于感知是否需要重新进行拉取操作。

    服务注册

    服务注册逻辑也是在 DiscoveryClient 的构造函数中完成,代码片段如下:

    if (clientConfig.shouldRegisterWithEureka() && clientConfig.shouldEnforceRegistrationAtInit()) {

    try {

    if (!register() ) {

    throw new IllegalStateException("Registration error at startup. Invalid server response.");

    }

    } catch (Throwable th) {

    logger.error("Registration error at startup: {}", th.getMessage());

    throw new IllegalStateException(th);

    }

    }

    复制代码

    向server端注册需要满足的两个条件是:1、允许向server端注册  2、是否在客户端初始化期间强制注册

    boolean register() throws Throwable {

    logger.info(PREFIX + "{}: registering service...", appPathIdentifier);

    EurekaHttpResponse httpResponse;

    try {

    httpResponse = eurekaTransport.registrationClient.register(instanceInfo);

    } catch (Exception e) {

    logger.warn(PREFIX + "{} - registration failed {}", appPathIdentifier, e.getMessage(), e);

    throw e;

    }

    if (logger.isInfoEnabled()) {

    logger.info(PREFIX + "{} - registration status: {}", appPathIdentifier, httpResponse.getStatusCode());

    }

    return httpResponse.getStatusCode() == 204;

    }

    复制代码

    通过 eurekaTransport 对象,基于 REST 调用向 eureka server 进行服务注册。

    心跳机制

    心跳机制的初始化工作也是在 DiscoveryClient 构造函数中完成。在DiscoveryClient构造函数的最后,有一个初始化调度任务的方法,在这个方法里就包括心跳的初始化。

    heartbeatExecutor 心跳线程池:

    heartbeatExecutor = new ThreadPoolExecutor(

    1, clientConfig.getHeartbeatExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,

    new SynchronousQueue(),

    new ThreadFactoryBuilder()

    .setNameFormat("DiscoveryClient-HeartbeatExecutor-%d")

    .setDaemon(true)

    .build()

    复制代码

    scheduler 提交周期执行:

    // Heartbeat timer

    scheduler.schedule(

    new TimedSupervisorTask(

    "heartbeat",

    scheduler,

    heartbeatExecutor,

    renewalIntervalInSecs,

    TimeUnit.SECONDS,

    expBackOffBound,

    new HeartbeatThread()

    ),

    renewalIntervalInSecs, TimeUnit.SECONDS);

    复制代码

    TimedSupervisorTask 是 eureka 中自动调节间隔的周期性任务类。HeartbeatThread 是具体执行任何的线程,run方法中执行的就是 renew() 续期。

    boolean renew() {

    EurekaHttpResponse httpResponse;

    try {

    // 通过 eurekaTransport 来与 server 通信续期

    httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);

    logger.debug(PREFIX + "{} - Heartbeat status: {}", appPathIdentifier, httpResponse.getStatusCode());

    // 404 标识当前服务实例不存在

    if (httpResponse.getStatusCode() == 404) {

    // 记录心跳次数

    REREGISTER_COUNTER.increment();

    logger.info(PREFIX + "{} - Re-registering apps/{}", appPathIdentifier, instanceInfo.getAppName());

    long timestamp = instanceInfo.setIsDirtyWithTime();

    // 重新注册

    boolean success = register();

    if (success) {

    instanceInfo.unsetIsDirty(timestamp);

    }

    return success;

    }

    // 200 状态正常

    return httpResponse.getStatusCode() == 200;

    } catch (Throwable e) {

    logger.error(PREFIX + "{} - was unable to send heartbeat!", appPathIdentifier, e);

    return false;

    }

    }

    复制代码

    服务下线

    关闭 eureka client,还向 eureka server 发送撤销注册请求。该方法在DiscoveryClient#shutdown 方法中。

    @PreDestroy

    @Override

    public synchronized void shutdown() {

    // 保证原子操作

    if (isShutdown.compareAndSet(false, true)) {

    logger.info("Shutting down DiscoveryClient ...");

    if (statusChangeListener != null && applicationInfoManager != null) {

    // 应用管理器取消状态监听

    applicationInfoManager.unregisterStatusChangeListener(statusChangeListener.getId());

    }

    // 清理任务调度执行

    cancelScheduledTasks();

    // If APPINFO was registered

    if (applicationInfoManager != null

    && clientConfig.shouldRegisterWithEureka()

    && clientConfig.shouldUnregisterOnShutdown()) {

    //设置服务实例状态为 DOWN

    applicationInfoManager.setInstanceStatus(InstanceStatus.DOWN);

    //注销注册

    unregister();

    }

    // 关闭 jersey 客户端

    if (eurekaTransport != null) {

    eurekaTransport.shutdown();

    }

    heartbeatStalenessMonitor.shutdown();

    registryStalenessMonitor.shutdown();

    logger.info("Completed shut down of DiscoveryClient");

    }

    }

    复制代码

    展开全文
  • Eureka基本原理

    千次阅读 2019-06-01 22:12:56
    (1)就是首先有一个eureka server,服务的注册与发现的中心 (2)你如果写好了一个服务,就可以将其注册到...2、Eureka基本原理 (1)服务都会注册到eureka的注册表 (2)eureka有心跳机制,自动检测服务,故障...

    1、什么是注册中心

    (1)就是首先有一个eureka server,服务的注册与发现的中心
    (2)你如果写好了一个服务,就可以将其注册到eureka server上去
    (3)然后别人的服务如果要调用你的服务,就可以从eureka server上查找你的服务所在的地址,然后调用

    2、Eureka基本原理

    (1)服务都会注册到eureka的注册表
    (2)eureka有心跳机制,自动检测服务,故障时自动从注册表中摘除
    (3)每个服务也会缓存euraka的注册表,即使eureka server挂掉,每个服务也可以基于本地注册表缓存,与其他服务进行通信
    (4)只不过是如果eureka server挂掉了,那么无法发布新的服务了

    展开全文
  • Eureka工作原理

    2021-03-27 16:31:01
    SpringCloudEureka服务注册中心主要职责是对于微服务的治理,提供服务注册,服务发现,服务同步,服务续约等功能 大体分为两部分eureka-server和eureka-cline eureka-server用于服务端 eureka-cline用于客户端 其...
  • Eureka简单原理

    2020-11-19 13:44:26
    2.Eureka集群原理 相互注册,互相守望。在Eureka的高可用状态下,这些注册中心是对等的。他们会互相将注册到自己的实例同步给其他的注册中心。注册中心收到注册信息后会判断是否是其他注册中心同步的信
  • Eureka是Netflix开源的一款提供服务注册和发现的产品,github地址为 https://github.com/Netflix/eureka。注册中心是分布式开发的核心组件之一,而eureka是spring cloud推荐的注册中心实现,因此对于Java开发同学来...
  • Eureka是Netflix开源的一款提供服务注册和发现的产品github地址为 https://github.com/Netflix/eureka注册中心是分布式开发的核心组件之一而eureka是spring cloud推荐的注册中心实现Eureka是一个REST ...
  • Eureka 实现原理

    千次阅读 2019-06-13 13:53:00
    Eureka 是 Netflix 出品的用于实现服务注册和发现的工具。 Spring Cloud 集成了 Eureka,并提供了开箱即用的支持。其中, Eureka 又可细分为 Eureka Server 和 Eureka Client。 上图是来自eureka的官方架构图,这...
  • eureka同步原理_Eureka

    2020-12-30 22:53:57
    一、什么是服务注册中心:服务注册中心是... 服务注册中心的作用 :1,服务的注册 2,服务的发现常见的注册中心有哪些 :1.Dubbo 的注册中心 Zookeeper 2,Sringcloud 的注册中心 Eureka服务注册中心解决了什么问题 ...
  • 1、Eureka 简介Eureka 是 Netflix 出品的用于实现服务注册和发现的工具。...2、基本原理上图来自eureka的官方架构图,这是基于集群配置的eureka;- 处于不同节点的eureka通过Replicate进行数据同...
  • spring-cloud-eureka 发现服务实现原理 ... 本质是@EnableEurekaServer中导入了一个EurekaServerConfiguration的配置。...定时更新 ...发现原理 客户端定时从发现服务器中更新其他在线的客户端列表 ...
  • eureka基本原理

    2020-09-02 21:53:54
    1、没有Eureka 1.1、简单的订单服务 调用 库存服务 ... ...1.2、如果此时,库存服务增加了一台机器呢?...订单服务代码又得修改,就问你恶心不,你还手写不,手写...此时订单服务会自动拉取库存服务,发现有两台,会平...
  • 我的博客,原文出处... #Eureka Server会定时(间隔值是eureka.server.eviction-interval-timer-in-ms,默认60s)进行检查,如果发现实例在在一定时间 #(此值由客户端设置的eureka.instance.lease-expiration-dur
  • 在前面的文章介绍了,如何使用服务注册发现组件:Eureka,并给出使用示例。本文在此基础上,将会讲解 Eureka 客户端实现的内幕,结合源码深入实现的细节,知其所以然。客户端需要重点关注以下几点:从Eureka Server...
  • Eureka服务发现原理 eureka:多个eureka server组成一个高可用的eureka集群,集群内的eureka节点之间通过同步复制的方式更新注册信息,保持服务注册信息的一致性。 Application Service: 是一个服务的提供者,为...
  • Eureka是Netflix开源的一款提供服务注册和发现的产品 github地址为https://github.com/Netflix/eureka。 注册中心是分布式开发的核心组件之一,而eureka是spring cloud推荐的注册中心实现,因此对于Java开发同学来...
  • Eureka原理

    2020-03-23 11:02:56
    Eureka 是 Netflix 出品的用于实现服务注册和发现的工具。 Spring Cloud 集成了 Eureka,并提供了开箱即用的支持。其中, Eureka 又可细分为 Eureka Server 和 Eureka Client。 1.基本原理 上图是来自eureka的官方...
  • 前言之前写了几篇Spring Cloud的小白教程,相信看过的朋友对Spring Cloud中的一些应用有了简单的了解,写...Eureka简介Eureka是Netflix开发的服务发现框架,本身就是一个基于REST的服务。Spring Cloud将它集成在其子...
  • 服务发现原理 原理:如下图 1.1、发现原理 1.1.1、服务部署情况 注册中心:部署在上海机房,北京机房,深圳机房 服务提供者:部署在上海机房,深圳机房 消费者:部署在上海机房,北京机房 1.1.2、服务注册情况 ...
  • Spring Cloud 体系中最核心、默认的注册中心组件,研究它的运行机制,有助于我们在工作中更好地使用它 ---(虽然eureka 已经不再更新了,但是对于曾经springcloud家族的注册和发现中心,还是需要懂一下她的实现原理的...
  • 从第一章《什么是SpringCloud》中我们可以知道,一个微服务框架覆盖的东西是很多的,而如何去管理这些服务或者说API接口,就显得异常重要了。所以本章节,主要介绍下SpringCloud中使用Eureka实现服务的注册与发现
  • Spring Cloud-Eureka Client 原理解析Netflix 和 SpringCloudSpring Cloud Netflix Eureka 服务发现实现原理DiscoveryClient 接口@EnableDiscoveryClient 注解Eureka 架构图源码解析配置信息读取读取 eureka.client....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 728
精华内容 291
关键字:

eureka发现原理