微服务注册中心Eureka原理到源码

1. Eureka简介

Eureka是Netflix开源的一款用于提供服务注册和发现的产品,它提供了完整的服务注册和发现功能,具有容错性,可伸缩性等特性。

Eureka包含两个组件:Eureka Server和Eureka Client。

• Eureka Server提供服务注册服务。各个微服务启动时,会通过Eureka Client向Eureka Server注册自己的信息(例如服务名称、IP地址、端口等)。
• Eureka Client会定时从Eureka Server获取服务注册信息,并会定时发送自己的服务注册信息,以保证信息的最新。
• 服务调用方(也是一个Eureka Client)可以从Eureka Server 获取到服务注册信息,并消费服务。

Eureka通过这种方式实现了服务的注册与发现,具有较强的可用性、扩展性。

2. Eureka Server

Eureka Server提供服务注册和发现功能,datastore用来保存注册信息,Server也会广播注册信息以实现高可用。

2.1 pom依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

2.2 配置文件

erver: 
  port: 8761

eureka:
  client:
    registerWithEureka: false #不向注册中心注册自己
    fetchRegistry: false #不从注册中心获取服务列表
  server:
    enable-self-preservation: false #关闭自我保护机制

2.3 启动类

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    } 
}

3. Eureka Client

Eureka Client是一个Java客户端,用于简化与Eureka Server的交互,客户端同时也具备一个内置的、使用轮询负载算法的负载均衡器。

3.1 pom依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

3.2 配置文件

spring:
  application:
    name: service-client #应用名称
    
eureka:
  client: 
    serviceUrl: 
      defaultZone: http://localhost:8761/eureka/ #Eureka Server地址
  instance:
    prefer-ip-address: true #注册中心实例IP 

3.3 启动类

@SpringBootApplication
@EnableEurekaClient
public class ClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(ClientApplication.class, args);
    }
} 

4. 操作步骤

1. 启动Eureka Server,访问http://localhost:8761
2. 启动Eureka Client,访问http://localhost:8761,会发现client注册到server
3. Eureka Client会30秒发送一次心跳到server,服务器轮询60秒送一次心跳
4. Eureka Client获取服务时会使用负载均衡对应的实例
5. Eureka通过自我保护机制避免脑裂,20分钟左右会自动恢复

5. Eureka自我保护机制

Eureka Server在运行中,会统计心跳失败次数在15分钟之内是否超过85%,如果达到该阈值,Eureka Server会进入自我保护模式。

在自我保护模式下,Eureka Server会保护服务注册信息,不再剔除服务实例信息。这个机制是避免在网络故障的情况下,由于客户端的心跳失败而导致注册信息被剔除,保证服务的可用性。

理论上,当网络故障恢复后,会有大量客户端重新注册到Eureka Server,这个时候由于Eureka Server关闭了自我保护机制,会对注册表进行大范围的清理,有一定概率会清理正确的注册信息,造成故障。

所以,在生产环境我们需要关闭Eureka Server的自我保护模式,应对上述问题,设置以下参数:

eureka:
  server: 
    enable-self-preservation: false   #关闭自我保护模式

关闭自我保护模式后,我们就需要考虑服务注册信息被错误清理的问题,这时候就需要一个更为全面和详尽的心跳检测机制来判断服务的可用性。例如:

• 对HTTP接口进行监控,如果接口仍然能够正常响应而心跳检测失败,则不应该清理该服务
• 增加服务间调用链监控,如果A服务可以调用B服务,则即使B服务的心跳失败,也不应该将其服务信息清理
• 增加服务器监控,如果服务所在主机依然正常,则即使心跳失败也不清理服务

以上方法需要配合Eureka的整体监控系统使用,才能很好地避免自我保护模式关闭后,服务注册信息被误清理的问题。

6. Eureka续约与剔除

Eureka Client会每隔30秒发送一次心跳来更新自己的服务租约。如果Eureka Server在90秒没有接收到服务的心跳,会将该服务从注册表中移除,认为该服务已下线。

• 服务续约:Eureka Client会每隔30秒发送一次心跳给Eureka Server来更新服务租约,以保证注册信息的最新。
• 服务剔除:如果某个微服务实例长时间未发送心跳(默认90秒), Eureka Server会将该服务实例信息从注册表中移除。

这两个机制 together 保证了注册表信息的时效性和可靠性。服务提供方通过心跳续约保证注册信息的最新,Eureka Server通过剔除机制清理失效的注册信息。

但是,如果网络出现故障,会有一定概率导致Eureka Server错误剔除服务实例,此时如果关闭了自我保护机制,就会造成注册信息的损失,影响到服务的可用性。

所以,Eureka在实现续约和剔除机制时,也需要参考自我保护机制一节所提到的解决方案,尽量避免因网络等故障而导致正确的服务实例信息被误清理的问题。

7. Eureka Server高可用配置

在生产环境下,我们需要对Eureka Server进行高可用配置,常见的方案有:

1. 运行多个Eureka Server实例,彼此之间相互注册为服务,且保证服务注册信息的同步。
2. 将Eureka Server的服务注册信息存储至数据库或其他中间件中,实现实例间的数据共享。
3. 增加Eureka Server的复制与同步机制,通过消息队列等中间件实现注册信息的同步传播。

这里我们主要讲解第一种方案:运行多个Eureka Server实例并互相注册。

7.1 配置文件

eureka:
  instance:
    hostname: eureka1 #eureka2
  client: 
    serviceUrl:
      defaultZone: http://eureka1:8761/eureka/,http://eureka2:8762/eureka/

其中hostname指的是Eureka Server节点的名称, serviceUrl配置了其它Eureka Server节点的地址信息,实现相互注册。

7.2 启动类

在各Eureka Server节点的启动类上增加@EnableEurekaServer注解:

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    } 
}  

7.3 验证

启动多个Eureka Server节点后,访问任一节点的管理界面,例如:http://eureka1:8761,可以看到其它节点也注册在此节点上,实现了高可用集群。

当某个节点故障时,通过Eureka Client即可消费其它节点上的服务注册信息,保证了Eureka Server的高可用。

而当节点恢复时,也可以从其它节点获取最新的注册信息并同步,继续为客户端提供服务发现的功能。

所以,运行多个Eureka Server实例并互相注册的方案较为简单高效,能很好地满足Eureka Server高可用的需求,适用于大多生产环境。

8. Eureka总结

通过上述内容,我们对Eureka进行了全面详细的介绍与分析,主要总结如下:

1. Eureka包含Server和Client两组件,Server提供服务注册和发现,Client用于服务注册与消费。
2. Eureka Server保存了所有服务的注册信息,有服务注册与发现的功能,高可用配置运行多个Server节点
3. Eureka Client会定期发送心跳更新自己的服务注册信息,若超过一定时间没有更新会被Server剔除。
4. Eureka Client在获取服务时会使用轮询负载均衡算法选择服务实例。
5. Eureka Server开启自我保护模式时会保护服务注册信息,生产环境建议关闭并增加相关监控。
6. Eureka适用于微服务架构下的服务治理,具有高可用,容错,可扩展等特性。
7. Eureka与其它微服务框架(Spring Cloud)整合良好,使用方便。

9. Eureka最佳实践

在生产环境中使用Eureka,我们还需要注意以下最佳实践:

1. 关闭Eureka Server的自我保护模式,增加复杂的心跳检测机制,避免因网络异常而误删服务实例。
2. Eureka Server节点数量设置为奇数,至少三个节点,保证高可用而又避免脑裂问题。
3. 增加Eureka Server的复制同步机制,将注册信息同步到其它节点以防数据丢失。
4. 给Eureka Server配置Sticky Session,使得同一个客户端连续访问同一Eureka Server节点。
5. 配置Eureka Server的身份验证,保证仅有授权客户端能够注册与获取服务。
6. 隔离Eureka Server与其它微服务,避免相互影响,Eureka Server须稳定可靠。
7. 监控Eureka Server节点状态、客户端状态、心跳状态及网络状况,快速发现和定位问题。
8. 提供Eureka Server和Client的Metrics指标与监控报警,保证稳定运行。
9. 采用自动扩缩容技术,根据Eureka Server节点负载情况动态调整其数量。
10. 客户端服务保证它所有的实例都使用相同的serviceId注册到Eureka,以实现负载均衡。
11. 避免客户端直接使用Eureka Server的服务实例列表,而是通过Eureka Client获取,以屏蔽Server列表的变动,提供稳定性。
12. 避免将Eureka Server的URL写死在客户端的配置中,可以通过服务发现的方式获取,提高系统的灵活性。

综上,在生产环境使用Eureka,除了理解其实现原理外,配置与运维也是非常重要的。合理配置Eureka的参数,增加必要的监控与限流,避免可能出现的问题,这些最佳实践能够让Eureka在生产环境中发挥最大效能,保证系统的高可用。

10. Eureka替代方案

除了Eureka之外,还有其他服务注册发现组件,例如:

• Consul:HashiCorp公司开源的服务注册与发现中心,基于Raft协议,具有高可用性和一致性。
• Nacos:阿里巴巴开源的服务注册与发现中心,支持注册中心高可用部署,服务治理等功能。
• Zookeeper:开源的服务发现与配置管理中心,支持分布式协调服务,基于Paxos算法实现高可用。

这些替代方案与Eureka相比具有一定优缺点:

Consul:优点:基于Raft保证强一致性,健康检查丰富,支持ACL 缺点:学习成本较高,社区资源相对较少

Nacos:优点:阿里巴巴出品,一站式服务发现与管理 缺点:产品还比较新,功能不太丰富,生态圈还在发展

Zookeeper:优点:可靠性高,使用广泛,拥有大量用户与维护者 缺点:开发难度大,需要深入理解分布式协议,不专业做服务发现,功能局限

综上,这些服务注册与发现工具各有优势,我们可以根据实际需求进行选择:

• 如果对高可用与强一致性要求高,可选择Consul
• 如果需要简单易用的服务注册与发现,可选择Nacos
• 如果对Spring Cloud生态圈熟悉,Eureka仍是一个不错的选择

Eureka作为Netflix提出的服务发现组件,在微服务架构下发挥着重要作用,且与Spring Cloud深度集成,但是其替代方案也在蓬勃发展,各有优势。我们需要理解不同工具之间的差异,才能够在实践中灵活选型与迁移。

11. Eureka源码分析

Eureka作为一个成熟的服务注册与发现组件,其源码实现也值得我们去研究与理解。这里我们主要分析Eureka Server的源码:

11.1 服务注册

服务注册的核心逻辑在com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl#register()方法中:

@Override
public void register(InstanceInfo info, boolean isReplication) {
    // validate instance info
    validateInstance(info);
    
    // handle replication
    if (isReplication) {
        // 同步instancesMap复制实例
        replicateToPeers(Action.Register, info.getLeaseInfo(), info);
    }  
    
    // get applicationsMap, register instance to applicationsMap
    Application app = getApplication(info.getAppName());
    
    // register instance
    app.registerInstance(info);
    recentlyChangedQueue.add(info.getId());
    //添加到instancesMap中
    instancesMap.put(info.getId(), info);
} 

主要步骤:

1. 校验实例信息的合法性
2. 如果是复制的注册请求,则同步至Peer节点
3. 获取应用Application对象,若没有则创建
4. 将实例注册到Application中
5. 添加实例到instancesMap,维护实例与Application的映射关系
6. 添加实例ID到recentlyChangedQueue,用于 Instance Resource 变化事件通知

所以服务注册的核心就是将服务实例注册到应用Application中,并建立与Registry的映射关系,这是Eureka Server实现服务注册的基础。

11.2 服务续约

服务续约是通过定期发送心跳来实现的,其主要逻辑在com.netflix.eureka.lease.LeaseManager#renew()方法中:

public boolean renew(String appName, String id, boolean isReplication) {
    // get registry information
    InstanceInfo info = this.registry.getInstanceByAppAndId(appName, id);
    if (info != null) {
        // found the instance, renew lease
        info.setLeaseInfo(info.getLeaseInfo().renew());
        if (isReplication) {
            // replicate to peer nodes
            replicateToPeers(Action.Heartbeat, info.getLeaseInfo(), info, appName, id);
        }
        //更新instancesMap与Cache
        registry.store(info); 
        return true;
    } 
    // cannot find the instance
    return false; 
}

主要步骤:

1. 获取Registry中相应的服务实例信息
2. 如果找到,则续约该实例的租约,更新过期时间
3. 如果是复制的心跳,则同步至Peer节点
4. 更新instancesMap与Cache,维护最新实例数据
5. 找不到实例则续约失败

所以,服务续约的关键就是在收到心跳时更新实例的租约信息,并同步至Registry与Cache中,以保证注册表数据的最新。

11.3 服务剔除

服务剔除是当实例租约已过期时,从注册表中剔除其信息,主要逻辑在com.netflix.eureka.registry.InstanceRegistry#expire()方法中:

public void expire(Action action) {
    if (!Action.Heartbeat.equals(action)) {
        logger.debug("Trying to expire instances with action: {}", action);
    }
    for (Iterator<Map.Entry<String, InstanceInfo>> iter = instancesMap.entrySet().iterator(); iter.hasNext(); ) {
        Map.Entry<String, InstanceInfo> entry = iter.next();
        InstanceInfo info = entry.getValue();
        // 如果实例已经过期,进行删除操作
        if (info.getLeaseInfo().isExpired(renewalThreshold)) { 
            if (Action.Delete == action) {
                // 删除操作,立即从集群剔除
                logger.info("DS: Registry: expire {}, {} - status: {}", info.getAppName(), info.getId(), info.getStatus());
                iter.remove(); //从Map中删除
                recentlyChangedQueue.add(info.getId()); //添加变更事件到消息队列
            } else if (Action.Sync == action) { 
                // 复制操作,同步至Peer节点
                logger.info("DS: Registry: sync expire {}, {} - status: {}", info.getAppName(), info.getId(), info.getStatus());
                replicateToPeers(Action.Cancel, info.getLeaseInfo(), info.getAppName(), info.getId());
            } else {
                // 默认是Heartbeat操作,设置Instance状态为EXPIRED
                logger.info("DS: Registry: expire {}, {} - status: {}", info.getAppName(), info.getId(), info.getStatus());
                info.setStatus(InstanceStatus.EXPIRED);  //设置状态为EXPIRED
                recentlyChangedQueue.add(info.getId()); //添加变更事件到消息队列
            }
        }
    }
}

主要步骤:

1. 遍历instancesMap获取所有的实例信息
2. 检查实例的租约是否已过期,若过期则进行删除或状态变更操作
3. 删除操作:从instancesMap中移除,添加Instance Resource变更事件
4. 复制操作:同步至Peer节点,执行INSTANCE_CANCEL操作
5. 默认(心跳)操作:设置实例状态为EXPIRED,添加Instance Resource变更事件
6. 未过期的实例不做任何操作

所以,服务剔除的关键是定期检查实例的租约状态,如果已过期需要从注册表中删除相应信息,同时通知感兴趣的服务进行相应处理,这是Eureka实现服务剔除的基石。

通过对Eureka服务注册、续约与剔除核心逻辑的分析,我们能够理解Eureka Server是如何维护注册表数据的:

1. 收到服务注册请求时将实例信息添加到注册表
2. 收到心跳时更新实例租约,刷新注册表
3. 定期检查租约,过期实例信息进行删除
4. 同步管理Peer节点之间的注册表数据

这些机制together保证了注册表信息的时效性与一致性,为Eureka Client提供可靠的服务发现与调用能力。

希望通过该分析,能够帮助大家深入理解Eureka的工作原理,在使用与运维Eureka Server时更加得心应手。

12. Eureka Server源码分析-高可用

在生产环境下,我们通常会部署多个Eureka Server实例来提供高可用的服务注册与发现能力。Eureka Server是如何实现多个节点之间的数据同步的呢?

这就涉及到Eureka的Peer节点复制机制。每个Eureka Server节点启动后,会在本地维护一个peerNodeUrls列表,包含其它Eureka Server节点的地址。

当本地收到服务注册、心跳、下线等请求时,会同步该信息给peerNodeUrls中的所有节点。同时本地节点也会周期性轮询peerNodeUrls中的节点获取其注册表信息。

所以,多个Eureka Server节点之间通过异步复制的方式来同步注册表数据,实现高可用部署,这就是Peer节点复制机制。

其核心逻辑在AbstractInstanceRegistry#replicateToPeers()方法中:

protected void replicateToPeers(Action action, Lease lease, InstanceInfo info, 
           String appName, String id) {
    EndpointRandomizer randomizer = EndpointRandomizer.getInstance();
    for (String peer : getPeerEurekaNodes()) {
        try {
            // choose a random peer to replicate to excluding self
            if (!peer.equals(peerEurekaNodeUrl)) {
                EurekaHttpClient httpClient = clientFactory.newClient(peer);
                // 执行复制请求
                httpClient.replicate(action, lease, info, appName, id); 
            }
        } catch (Throwable t) {
           logger.error("Cannot replicate information to peer: {}", peer, t); 
        }
    }
}

主要逻辑:

1. 获取peerEurekaNodes,包含peerNodeUrls中所有节点地址
2. 随机选择一个非本地节点进行复制操作
3. 创建EurekaHttpClient,用于连接目标节点
4. 执行replicate操作,同步注册表信息至目标节点
5. 若复制失败,打印错误日志,不影响本地操作

所以,Eureka Server通过异步复制的方式与Peer节点同步注册表变更信息,而本地节点也定期从Peer节点拉取实例信息,这两个机制together实现了多个Eureka Server节点间高可用的部署方案。

但是,这种基于异步复制的高可用方案也存在一定限制:

1. 只能保证最终一致性,不能实时同步
2. 网络异常情况下可能出现短暂的数据不一致
3. 添加或下线实例请求只会同步至部分Peer节点
4. 无法做到跨数据中心级别的同步复制

所以,在对数据强一致性要求较高的场景下,可以考虑将注册表信息同步至关系型数据库或同步中间件,这可以在一定程度上弥补基于异步复制方案的不足,实现跨IDC级别的高可用部署。

总而言之,Peer节点复制机制为Eureka Server的高可用部署提供了简单可靠的方案,理解其实现原理有助于我们在生产环境中合理配置和运维Eureka Server。

13. Eureka常见问题与解决方案

在使用Eureka的过程中,我们可能会遇到一些常见问题,这里我们总结几个常见问题及解决方案:

13.1 Eureka Server节点无法同步注册表数据

这通常是由于网络异常或防火墙规则导致的,解决方案如下:

1. 检查Eureka Server节点间的网络连接,确保端口8761可被访问
2. 确认防火墙已开放8761端口用于Eureka Server通信
3. 确认Peer节点URL配置正确,节点可被正常访问
4. 缩短Eureka Server的registryFetchInterval值,加快拉取频率
5. 增加Eureka Server的日志级别,查看复制失败的详细日志排查原因
6. 作为最后手段,可将注册表信息同步到数据库或MQ实现高可用

所以,检查网络连接、防火墙规则以及相关参数配置是解决该问题的关键。而将注册表同步至数据库可以在一定程度上避免该问题的影响。

13.2 Eureka Server开启自我保护模式

这通常是由于网络故障导致大量客户端无法续约,Eureka默认开启自我保护模式以保护注册表数据,解决方案:

1. 关闭Eureka Server的自我保护模式:

eureka.server.enableSelfPreservation=false

2. 增加心跳与续约判断的敏感度,加快检测实例失效的速度:

eureka.instance.leaseExpirationDurationInSeconds=30 
eureka.server.renewalThresholdUpdateIntervalMs=15000

3. 提高Eureka Server的续约超时比例阈值,触发自我保护模式的条件更为宽松:

eureka.server.renewalPercentThreshold=0.9

4. 增加客户端心跳前提醒机制,避免续约失败比例过高
5. 增加Eureka Server相关指标监控,一旦进入自我保护模式快速Received通知
6. 查看客户端监控,检查是否有大量客户端续约失败的情况,定位网络异常原因

所以,关闭自我保护模式,调整相关参数及增加监控是解决该问题的有效手段。而避免大量客户端无法续约的情况也是根本之策。

13.3 Eureka Client无法获取服务实例

这通常是由于Eureka Client无法连接Eureka Server或注册表信息不正确导致的,解决方案:

1. 检查Eureka Client的参数配置,确认eureka.client.serviceUrl.defaultZone正确
2. 确认Eureka Server端口8761可被Eureka Client访问,防火墙已经开通
3. 检查Eureka Client的服务注册信息在Eureka Server的注册表中是否正确
4. 确认Eureka Client的元数据数据中的instanceId与Eureka Server注册表中的一致
5. 增加Eureka Client的日志级别,排查无法从Eureka Server获取实例的详细原因
6. 确认其他正常的Eureka Client可以从Eureka Server获取实例信息,排除注册表问题
7. 重新启动Eureka Client应用,重新注册服务到Eureka Server,刷新注册表缓存
8. 配置Eureka Client的cacheRefreshExecutorThreadPoolSize参数,加快注册表信息的刷新速度
9. 作为最后手段,直接在Eureka Client中配置服务实例的静态列表,临时绕过Eureka Server

所以,排查网络、参数配置与注册表信息的问题是解决该问题的关键,优化Eureka Client的参数配置或增加刷新频率也可以在一定程度上缓解这个问题。而绕过Eureka Server配置静态实例列表应作为最后手段使用。

14. Eureka最佳实践

在使用Eureka的过程中,我们总结了一些最佳实践,希望能够帮助大家更高效可靠的使用Eureka。

14.1 Eureka Server高可用部署

• 使用负载均衡指向多个Eureka Server节点
• 部署Peer节点到不同可用区或机房
• 配置更短的registryFetchInterval与registerWithEurekaInterval来加快注册表同步速度
• 加大Eureka Server的缓存过期时间,减少注册表变更导致的不可用情况
• 关闭Eureka Server的自我保护模式,增强故障转移能力
• 将注册表信息同步到数据库或MQ,提高数据持久性

高可用部署是Eureka Server最重要的实践,需要考虑参数调整、缓存配置与持久化方案等多个方面。

14.2 Eureka Client专有参数配置

• 配置eureka.instance.preferIpAddress为true,使用IP地址作为实例ID
• 避免使用hostName作为实例ID,可能导致重启后实例ID变化
• 配置eureka.client.healthcheck.enabled为true,使用Eureka的健康检查机制
• 配置eureka.client.cacheRefreshExecutorThreadPoolSize来加快注册表变更的应用速度
• 配置eureka.client.serviceUrl.defaultZone及eureka.client.backupRegistryImpl来定义Eureka Server列表
• 配置eureka.client.enable-delta为false关闭增量注册表信息拉取

针对Eureka Client有很多专有的参数可以进行定制化配置,这需要我们结合实际使用情况进行设置。

14.3 监控与告警

• 收集Eureka Server的自我保护模式、续约成功率等关键指标进行监控
• 监控Eureka Client的注册与续约成功情况,定位潜在故障
• 对Eureka Server节点和Eureka Client实例加强健康检查,一旦出现问题快速告警
• 收集Eureka Server的GC、内存、连接池等JVM指标进行统一监控
• 检查Eureka Server的实例数及租约信息,周期性收集注册表快照以便问题分析
• 监控网络连接情况,在出现网络异常时快速检查Eureka Server节点间的数据同步

充分的监控与告警机制是保障Eureka稳定可靠运行的基础,这需要我们在运维层面投入较多精力。

15. 总结

里做一个总结,帮助大家进一步系统地理解Eureka。

Eureka包含三大组件:Eureka Server、Eureka Client与Application。其中:

• Eureka Server提供服务注册与发现功能,包含多个节点实现高可用
• Eureka Client将自己提供的服务注册到Eureka Server,并从Eureka Server获取其他服务实例
• Application代表需要注册与发现的具体微服务应用

Eureka Server内部包含:

• PeerAwareInstanceRegistry:管理服务实例注册表信息,实现Peer节点数据同步
• InstanceRegistry:负责服务实例的注册、续约、剔除等操作
• EurekaServerContext:Eureka Server的上下文环境
• EurekaServerBootstrap:Eureka Server的启动引导类
• EurekaController:REST接口,接收Eureka Client的请求并调用InstanceRegistry执行

Eureka Client内部包含:

• EurekaClient:实现与Eureka Server的交互,包括注册、续约与获取服务等
• EurekaClientConfig:Eureka Client的配置项
• ApplicationInfoManager:管理服务实例的应用信息
• EurekaInstanceConfig:服务实例的元数据配置
• EurekaException:Eureka Client抛出的自定义异常

服务注册与发现的流程:

1. Eureka Client向Eureka Server注册服务,将实例信息添加到注册表中,获取转发的心跳周期
2. Eureka Client定期发送心跳续约请求到Eureka Server,维持租约及获取注册表变更
3. Eureka Client从Eureka Server获取服务实例列表,并缓存在本地,定期刷新
4. Eureka Server通过异步复制方式将注册表信息同步到Peer节点
5. Eureka Client和Eureka Server通过心跳续约定期上报自身状态

除此之外,我们还学习了Eureka的高可用架构、常见问题解决思路、源码解析和最佳实践等内容。系统地学习并理解Eureka的架构设计与工作流程,可以让我们在实际项目中更加便捷高效地使用它,并能够应对运维过程中出现的各类问题。