通过自动配置和绑定到Spring环境，为Spring应用程序提供Netflix OSS集成。通过一些简单的注解，你可以快速启用和配置应用程序中的通用模式。Netflix 提供的模式包括服务发现（Eureka）、断路器（Hystrix）、智能路由（zul）和客户端负载平衡（Ribbon）。
引入Eureka Client的依赖（非Eureka Server需引入）
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency>
引入Eureka Server的依赖（搭建服务注册中心需引入）
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> </dependency>
一、Eureka是什么
Eureka 是 Netflix 公司开源的产品，它是一种基于 REST（Representational State Transfer）的服务，主要用于 AWS 云。Eureka 提供了完整的 Service Registry 和 Service Discovery 实现，也是 Spring Cloud 体系中最重要最核心的组件之一。
简单来说 ，Eureka 就是 Netflix 开源的一款提供服务注册和发现的产品，并且提供了 Java 客户端。当然在 Spring Cloud 大力优化后的 Eureka，已经不仅仅只是用于 AWS 云，而是可以应用在任何需要使用注册中心的场景。
Eureka 由两个组件组成：Eureka 服务端和 Eureka 客户端。Eureka 服务端就是注册中心。Eureka 客户端是一个 java 客户端，用来简化与服务端的交互、作为轮询负载均衡器，并提供服务的故障切换支持。
Eureka服务中心示意图：
从上面看Eureka Server担任注册中心的角色，提供了服务的发现和注册功能。
Service Provider 服务提供者,将自身的服务注册到Eureka Server,同时通过心跳检查服务的运行状态。
Service Consumer 服务调用者,从Eureka Server 得到注册的服务列表,找到对应的服务地址在调用并使用。
二、单点模式
创建Eureka Server项目，在pom文件中引入如下依赖：
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> </dependency>
在启动类上添加注解：
@EnableEurekaServer
在application.yml中配置：
spring:
application:
name: eureka
server:
port: 8761
eureka:
instance:
hostname: localhost
client:
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
register-with-eureka: false
fetch-registry: false
测试：
在浏览器中输入localhost:8761即可访问注册中心。注册中心页面被分为五部分
- System Status 代表系统状态
- DS Replicas 该服务从哪里同步数据
- Instances currently registered with Eureka 注册在Eureka的实例列表
- General Info 系统运行环境 如cpu、内存等信息
- Instance Info 本服务的基础信息 如ip地址 状态等
三、（HA）集群模式
理论上来讲，服务消费者本地缓存了服务提供者的地址。即使 Eureka Server 宕机，也不会影响服务之间的调用，但是一旦涉及到服务的上下线，本地的缓存信息将会出现偏差，从而影响到了整个微服务架构的稳定性，因此搭建 Eureka Server 集群来提高整个架构的高可用性，是非常有必要的。这样就可以使注册中心高可用。
开启 Eureka 集群配置后，服务启动时 Eureka Server 会将注册信息向其它 Eureka Server 进行同步，因此搭建高可用架构只需要将 Eureke Server 配置指向其它可用的 serviceUrl 即可（即Eureka Server之间需要相互注册）。
我们在Eureka 单个示例的基础上，复制出三份来分别命名为：eureka-a、eureka-b、eureka-c 三个示例项目，使用这三个示例项目搭建 Eureka Server 的集群。
接下来需要分别修改 eureka-a、eureka-b、eureka-c 的配置信息。
eureka-a的配置如下：
@SpringBootApplication @EnableEurekaServer public class EurekaAApplication { public static void main(String[] args) { SpringApplication.run(EurekaAApplication.class, args); } }
spring:
application:
name: eureka server
server:
port: 8001
eureka:
instance:
hostname: eurekaA
client:
serviceUrl.defaultZone: http://eurekaB:8002/eureka/,http://eurekaC:8003/eureka/
register-with-eureka: true
fetch-registry: true
eureka-b的配置如下：
@SpringBootApplication @EnableEurekaServer public class EurekaBApplication { public static void main(String[] args) { SpringApplication.run(EurekaBApplication.class, args); } }
spring:
application:
name: eureka server
server:
port: 8002
eureka:
instance:
hostname: eurekaB
client:
serviceUrl.defaultZone: http://eurekaA:8001/eureka/,http://eurekaC:8003/eureka/
register-with-eureka: true
fetch-registry: true
eureka-c的配置如下：
@SpringBootApplication @EnableEurekaServer public class EurekaCApplication { public static void main(String[] args) { SpringApplication.run(EurekaCApplication.class, args); } }
spring:
application:
name: eureka server
server:
port: 8003
eureka:
instance:
hostname: eurekaC
client:
serviceUrl.defaultZone: http://eurekaA:8001/eureka/,http://eurekaB:8002/eureka/
register-with-eureka: true
fetch-registry: true
eureka.client.register-with-eureka 和 eureka.client.fetch-registry配置为 true ，表示将自己注册到注册中心，并且从注册中心获取注册信息
eureka.client.serviceUrl.defaultZone，指向其它两个注册中心。
依次启动 eureka-a、eureka-b、eureka-c 项目，等待全部启动完成之后，在eureka的后台页面的DS Replicas，可以看到同步的其他Eureka Server。
四、eureka服务与注册
搭建好服务中心后，就可以开始实现服务注册和服务发现了。
在没有微服务之前有已经有跨服务调用了，比如ServiceB去调用ServiceA中的服务 , 传统模式可以直接在ServiceB中写ServiceA中的服务但是这样是写死了的，不够灵活。
传统的调用：
微服务下的跨系统调用：
此时服务的调用应该是分两个步骤的：
- ServiceB 去服务中心拿到ServiceA的地址，如果ServiceA是单机部署，那么这个地址就只有一个，如果ServiceA是集群是集群环境部署，那么发现的地址就是多个。
- 拿到了ServiceA的地址后，ServiceB再去调用ServiceA的相关服务了。
这样做其实是有很多好处的，首先互相调用的地址可以不用写死，需要的时候直接去服务中心获取，并且服务之间也可以很方便的部署、集群等。
在服务提供者或消费者都引入依赖
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency>
服务提供者的application.yml：
# 别名
spring:
application:
name: provider
#端口
server:
port: 4001
# provider config
eureka:
client:
service-url:
defaultZone: http://localhost:1111/eureka
spring.application.name 是服务的名称，你可以理解成是别名，其他的服务调用的时候需要使用这个name来调用。
eureka.client.service-url.defaultZone 是这个服务需要注册到服务中心地址，这里需要注意的是，如果服务中心是一个集群，这里也可以只写服务中心的一个节点，eureka会自动集群对服务进行同步。
添加注解
在启动类上添加注解@EnableDiscoveryClient 或@EnableEurekaClient。
从Spring Cloud Edgware开始，@EnableDiscoveryClient 或@EnableEurekaClient 可省略。只需加上相关依赖，并进行相应配置，即可将微服务注册到服务发现组件上。
@EnableDiscoveryClient和@EnableEurekaClient共同点就是：都是能够让注册中心能够发现，扫描到改服务。不同点就是：@EnableEurekaClient只适用于Eureka作为注册中心，@EnableDiscoveryClient 可以是其他注册中心。
DiscoveryClient类
org.springframework.cloud.client.discovery.DiscoveryClient可以直接注入到用得到的地方，它可以从Eureka或者从Consul上根据服务名查询一个服务的详细信息。
discoveryClient.getInstances 就是调用服务的名称，返回的是一个List<ServiceInstance>，因为服务提供者可能是集群部署，所以provider的实例就有多个。
ServiceInstance保存了很多信息，如主机地址、端口号、实例id等。ServiceInstance是一个接口，有很多实现类，EurekaServiceInstance就是其中的一个。
DiscoveryClient其实只是一个接口，具体的实现类就是CompositeDiscovery，当我们的微服务启动的时候，就会在CompositeDiscoveryClientAutoConfiguration类中配置一个CompositeDiscovery的实例，其实真正调用的是CompositeDiscoveryClient类中的discoveryClients 属性提供的 DiscoveryClient，而discoveryClients 属性默认集合中只有一条数据，就是EurekaDiscoveryClient，最终在EurekaDiscoveryClient类中，通过EurekaClient来获取一个微服务的实例信息了
五、添加用户验证
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
注意：一旦spring-boot-starter-security存在与类路径上就会开启用户验证，不管是否设置用户名和密码（会提供默认的）。
修改Server的配置文件
spring: application: name: eureka-server security: user: name: admin password: 123
server配置defaultZone改为：
defaultZone: http://${security.user.name}:${security.user.password}@${eureka.instance.hostname}:${server.port}/eureka/
修改Client的配置文件
defaultZone: http:admin:123@//localhost:8761/eureka/
增加WebSecurityConfig配置类
eureka服务添加security验证之后，client注册失败：cannot execute any request on any know server。是因为新版本的security默认开启csrf了，关掉就好了，新建一个配置类。
import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; @EnableWebSecurity @Configuration public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable(); http.authorizeRequests().anyRequest().authenticated().and().httpBasic(); //开启认证 } }
六、eureka工作原理
Eureka 作为 Spring Cloud 体系中最核心、默认的注册中心组件，研究它的运行机制，有助于我们在工作中更好地使用它。
Eureka服务中心示意图中的服务提供者和服务的消费者，本质上也是 Eureka Client 角色。整体上可以分为两个主体：Eureka Server 和 Eureka Client。
Eureka Server：注册中心服务端
注册中心服务端主要对外提供了三个功能：
（1）服务注册：服务提供者启动时，会通过 Eureka Client 向 Eureka Server 注册信息，Eureka Server 会存储该服务的信息，Eureka Server 内部有二层缓存机制来维护整个注册表。
（2）提供注册表：服务消费者在调用服务时，如果 Eureka Client 没有缓存注册表的话，会从 Eureka Server 获取最新的注册表。
（3）同步状态：Eureka Client 通过注册、心跳机制和 Eureka Server 同步当前客户端的状态。
Eureka Client：注册中心客户端
Eureka Client 是一个 Java 客户端，用于简化与 Eureka Server 的交互。Eureka Client 会拉取、更新和缓存 Eureka Server 中的信息。因此当所有的 Eureka Server 节点都宕掉，服务消费者依然可以使用缓存中的信息找到服务提供者，但是当服务有更改的时候会出现信息不一致。
（1）服务注册
服务的提供者，将自身注册到注册中心，服务提供者也是一个 Eureka Client。当 Eureka Client 向 Eureka Server 注册时，它提供自身的元数据，比如 IP 地址、端口，运行状况指示符 URL，主页等。
（2）服务续约
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
（3）服务剔除
当 Eureka Client 和 Eureka Server 不再有心跳时，Eureka Server 会将该服务实例从服务注册列表中删除，即服务剔除。
（4）服务下线
Eureka Client 在程序关闭时向 Eureka Server 发送取消请求。 发送请求后，该客户端实例信息将从 Eureka Server 的实例注册表中删除。该下线请求不会自动完成，它需要调用以下内容：
DiscoveryManager.getInstance().shutdownComponent()；
（5）获取注册列表信息
Eureka Client 从服务器获取注册表信息，并将其缓存在本地。客户端会使用该信息查找其他服务，从而进行远程调用。该注册列表信息定期（每30秒钟）更新一次。每次返回注册列表信息可能与 Eureka Client 的缓存信息不同，Eureka Client 自动处理。
如果由于某种原因导致注册列表信息不能及时匹配，Eureka Client 则会重新获取整个注册表信息。 Eureka Server 缓存注册列表信息，整个注册表以及每个应用程序的信息进行了压缩，压缩内容和没有压缩的内容完全相同。Eureka Client 和 Eureka Server 可以使用 JSON/XML 格式进行通讯。在默认情况下 Eureka Client 使用压缩 JSON 格式来获取注册列表的信息。
获取服务是服务消费者的基础，所以必有两个重要参数需要注意：
# 启用服务消费者从注册中心拉取服务列表的功能 eureka.client.fetch-registry=true # 设置服务消费者从注册中心拉取服务列表的间隔 eureka.client.registry-fetch-interval-seconds=30
（6）远程调用
当 Eureka Client 从注册中心获取到服务提供者信息后，就可以通过 Http 请求调用对应的服务；服务提供者有多个时，Eureka Client 客户端会通过 Ribbon 自动进行负载均衡。
自我保护机制
默认情况下，如果 Eureka Server 在一定的 90s 内没有接收到某个微服务实例的心跳，会注销该实例。但是在微服务架构下服务之间通常都是跨进程调用，网络通信往往会面临着各种问题，比如微服务状态正常，网络分区故障，导致此实例被注销。
固定时间内大量实例被注销，可能会严重威胁整个微服务架构的可用性。为了解决这个问题，Eureka 开发了自我保护机制，那么什么是自我保护机制呢？
Eureka Server 在运行期间会去统计心跳失败比例在 15 分钟之内是否低于 85%，如果低于 85%，Eureka Server 即会进入自我保护机制。
Eureka Server 触发自我保护机制后，页面会出现提示：
Eureka Server 进入自我保护机制，会出现以下几种情况：
- Eureka 不再从注册列表中移除因为长时间没收到心跳而应该过期的服务。
- Eureka 仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上(即保证当前节点依然可用)。
- 当网络稳定时，当前实例新的注册信息会被同步到其它节点中。
Eureka 自我保护机制是为了防止误杀服务而提供的一个机制。当个别客户端出现心跳失联时，则认为是客户端的问题，剔除掉客户端；当 Eureka 捕获到大量的心跳失败时，则认为可能是网络问题，进入自我保护机制；当客户端心跳恢复时，Eureka 会自动退出自我保护机制。
如果在保护期内刚好这个服务提供者非正常下线了，此时服务消费者就会拿到一个无效的服务实例，即会调用失败。对于这个问题需要服务消费者端要有一些容错机制，如重试，断路器等。
通过在 Eureka Server 配置如下参数，开启或者关闭保护机制，生产环境建议打开：
eureka.server.enable-self-preservation=true
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 集群之间的状态是采用异步方式同步的，所以不保证节点间的状态一定是一致的，不过基本能保证最终状态是一致的。
（1）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 中获取信息。
（2）Eurka 保证 AP
Eureka Server 各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而 Eureka Client 在向某个 Eureka 注册时，如果发现连接失败，则会自动切换至其它节点。只要有一台 Eureka Server 还在，就能保证注册服务可用(保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。
Eureka工作流程
- Eureka Server 启动成功，等待服务端注册。在启动过程中如果配置了集群，集群之间定时通过 Replicate 同步注册表，每个 Eureka Server 都存在独立完整的服务注册表信息。
- Eureka Client 启动时根据配置的 Eureka Server 地址去注册中心注册服务。
- Eureka Client 会每 30s 向 Eureka Server 发送一次心跳请求，证明客户端服务正常。
- 当 Eureka Server 90s 内没有收到 Eureka Client 的心跳，注册中心则认为该节点失效，会注销该实例。
- 单位时间内 Eureka Server 统计到有大量的 Eureka Client 没有上送心跳，则认为可能为网络异常，进入自我保护机制，不再剔除没有上送心跳的客户端。
- 当 Eureka Client 心跳请求恢复正常之后，Eureka Server 自动退出自我保护模式。
- Eureka Client 定时全量或者增量从注册中心获取服务注册表，并且将获取到的信息缓存到本地。
- 服务调用时，Eureka Client 会先从本地缓存找寻调取的服务。如果获取不到，先从注册中心刷新注册表，再同步到本地缓存。
- Eureka Client 获取到目标服务器信息，发起服务调用。
- Eureka Client 程序关闭时向 Eureka Server 发送取消请求，Eureka Server 将实例从注册表中删除。
七、eureka缓存机制
Eureka数据存储
我们知道 Eureka Server 在运行期间就是一个普通的 Java 项目，并没有使用数据库之类的存储软件，那么在运行期间是如何存储数据的呢？
Eureka Server 的数据存储分了两层：数据存储层和缓存层。数据存储层记录注册到 Eureka Server 上的服务信息，缓存层是经过包装后的数据，可以直接在 Eureka Client 调用时返回。我们先来看看数据存储层的数据结构。
Eureka Server 的数据存储层是双层的 ConcurrentHashMap，我们知道 ConcurrentHashMap 是线程安全高效的 Map 集合。
private final ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>> registry= new ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>>();
第一层的 ConcurrentHashMap 的 key=spring.application.name 也就是客户端实例注册的应用名；value 为嵌套的 ConcurrentHashMap。
第二层嵌套的 ConcurrentHashMap 的 key=instanceId 也就是服务的唯一实例 ID，value 为 Lease 对象，Lease 对象存储着这个实例的所有注册信息，包括 ip 、端口、属性等。
根据这个存储结构我们可以发现，Eureka Server 第一层都是存储着所有的服务名，以及服务名对应的实例信息，也就是说第一层都是按照服务应用名这个维度来切分存储：
应用名1：应用1实例 Map 应该名2：应用2实例 Map ...
第二层是根据实例的唯一 ID 来存储的，那么按照这个结构最终的存储数据格式为：
： 应用1实例A：实例A的注册信息
应用名1：应用1实例： 应用1实例B：实例B的注册信息
： 应用1实例C：实例C的注册信息
： ....
-----------------
： 应用2实例F：实例F的注册信息
应该名2：应用2实例： 应用2实例G：实例G的注册信息
： ...
...
数据存储层数据结构如下图所示：
当如服务的状态发生变更时，会同步 Eureka Server 中的 registry 数据信息，比如服务注册、剔除服务时。
Eureka缓存机制
Eureka Server 为了提供响应效率，提供了两层的缓存结构，将 Eureka Client 所需要的注册信息，直接存储在缓存结构中。
第一层缓存：readOnlyCacheMap，本质上是 ConcurrentHashMap，依赖定时从 readWriteCacheMap 同步数据，默认时间为 30 秒。
readOnlyCacheMap ： 是一个 CurrentHashMap 只读缓存，这个主要是为了供客户端获取注册信息时使用，其缓存更新，依赖于定时器的更新，通过和 readWriteCacheMap 的值做对比，如果数据不一致，则以 readWriteCacheMap 的数据为准。
第二层缓存：readWriteCacheMap，本质上是 Guava 缓存。
readWriteCacheMap：readWriteCacheMap 的数据主要同步于存储层。当获取缓存时判断缓存中是否没有数据，如果不存在此数据，则通过 CacheLoader 的 load 方法去加载，加载成功之后将数据放入缓存，同时返回数据。
readWriteCacheMap 缓存过期时间，默认为 180 秒，当服务下线、过期、注册、状态变更，都会来清除此缓存中的数据。
Eureka Client 获取全量或者增量的数据时，会先从一级缓存中获取；如果一级缓存中不存在，再从二级缓存中获取；如果二级缓存也不存在，这时候先将存储层的数据同步到缓存中，再从缓存中获取。
通过 Eureka Server 的二层缓存机制，可以非常有效地提升 Eureka Server 的响应时间，通过数据存储层和缓存层的数据切割，根据使用场景来提供不同的数据支持。
其它缓存设计
除过 Eureka Server 端存在缓存外，Eureka Client 也同样存在着缓存机制，Eureka Client 启动时会全量拉取服务列表，启动后每隔 30 秒从 Eureka Server 量获取服务列表信息，并保持在本地缓存中。
Eureka Client 增量拉取失败，或者增量拉取之后对比 hashcode 发现不一致，就会执行全量拉取，这样避免了网络某时段分片带来的问题，同样会更新到本地缓存。
同时对于服务调用，如果涉及到 ribbon 负载均衡，那么 ribbon 对于这个实例列表也有自己的缓存，这个缓存定时(默认30秒)从 Eureka Client 的缓存更新。
这么多的缓存机制可能就会造成一些问题，一个服务启动后可能最长需要 90s 才能被其它服务感知到：
- 首先，Eureka Server 维护每 30s 更新的响应缓存。
- Eureka Client 对已经获取到的注册信息也做了 30s 缓存。
- 负载均衡组件 Ribbon 也有 30s 缓存。
这三个缓存加起来，就有可能导致服务注册最长延迟 90s ，这个需要我们在特殊业务场景中注意其产生的影响。
八、eureka常用配置
在 Spring Cloud 官网查看 Spring Cloud Netflix 的介绍时，会出现以下几个名字
- Eureka Server，Eureka 作为注册中心的角色，称之为 Eureka Server。
- Eureka Client，注册到 Eureka 的客户端。
- Eureka Instance，可以称之为 Eureka 实例，注册到服务中心的每一个单独的示例，比如 ip 为 192.168.0.1 、端口为 8080 的一个实例。
- Eureka service，Eureka service 其实是 Eureka Instance 的一个抽象，比如是订单服务，有可能订单服务是由多个订单实例（Eureka Instance）组成，具体表现为配置应用名相同的一组实例。
Eureka Server配置
#服务端开启自我保护模式，前面章节有介绍 eureka.server.enable-self-preservation=true #扫描失效服务的间隔时间（单位毫秒，默认是60*1000）即60秒 eureka.server.eviction-interval-timer-in-ms= 60000 #间隔多长时间，清除过期的 delta 数据 eureka.server.delta-retention-timer-interval-in-ms=0 #请求频率限制器 eureka.server.rate-limiter-burst-size=10 #是否开启请求频率限制器 eureka.server.rate-limiter-enabled=false #请求频率的平均值 eureka.server.rate-limiter-full-fetch-average-rate=100 #是否对标准的client进行频率请求限制。如果是false，则只对非标准client进行限制 eureka.server.rate-limiter-throttle-standard-clients=false #注册服务、拉去服务列表数据的请求频率的平均值 eureka.server.rate-limiter-registry-fetch-average-rate=500 #设置信任的client list eureka.server.rate-limiter-privileged-clients= #在设置的时间范围类，期望与client续约的百分比。 eureka.server.renewal-percent-threshold=0.85 #多长时间更新续约的阈值 eureka.server.renewal-threshold-update-interval-ms=0 #对于缓存的注册数据，多长时间过期 eureka.server.response-cache-auto-expiration-in-seconds=180 #多长时间更新一次缓存中的服务注册数据 eureka.server.response-cache-update-interval-ms=0 #缓存增量数据的时间，以便在检索的时候不丢失信息 eureka.server.retention-time-in-m-s-in-delta-queue=0 #当时间戳不一致的时候，是否进行同步 eureka.server.sync-when-timestamp-differs=true #是否采用只读缓存策略，只读策略对于缓存的数据不会过期。 eureka.server.use-read-only-response-cache=true ################server node 与 node 之间关联的配置#####################33 #发送复制数据是否在request中，总是压缩 eureka.server.enable-replicated-request-compression=false #指示群集节点之间的复制是否应批处理以提高网络效率。 eureka.server.batch-replication=false #允许备份到备份池的最大复制事件数量。而这个备份池负责除状态更新的其他事件。可以根据内存大小，超时和复制流量，来设置此值得大小 eureka.server.max-elements-in-peer-replication-pool=10000 #允许备份到状态备份池的最大复制事件数量 eureka.server.max-elements-in-status-replication-pool=10000 #多个服务中心相互同步信息线程的最大空闲时间 eureka.server.max-idle-thread-age-in-minutes-for-peer-replication=15 #状态同步线程的最大空闲时间 eureka.server.max-idle-thread-in-minutes-age-for-status-replication=15 #服务注册中心各个instance相互复制数据的最大线程数量 eureka.server.max-threads-for-peer-replication=20 #服务注册中心各个instance相互复制状态数据的最大线程数量 eureka.server.max-threads-for-status-replication=1 #instance之间复制数据的通信时长 eureka.server.max-time-for-replication=30000 #正常的对等服务instance最小数量。-1表示服务中心为单节点。 eureka.server.min-available-instances-for-peer-replication=-1 #instance之间相互复制开启的最小线程数量 eureka.server.min-threads-for-peer-replication=5 #instance之间用于状态复制，开启的最小线程数量 eureka.server.min-threads-for-status-replication=1 #instance之间复制数据时可以重试的次数 eureka.server.number-of-replication-retries=5 #eureka节点间间隔多长时间更新一次数据。默认10分钟。 eureka.server.peer-eureka-nodes-update-interval-ms=600000 #eureka服务状态的相互更新的时间间隔。 eureka.server.peer-eureka-status-refresh-time-interval-ms=0 #eureka对等节点间连接超时时间 eureka.server.peer-node-connect-timeout-ms=200 #eureka对等节点连接后的空闲时间 eureka.server.peer-node-connection-idle-timeout-seconds=30 #节点间的读数据连接超时时间 eureka.server.peer-node-read-timeout-ms=200 #eureka server 节点间连接的总共最大数量 eureka.server.peer-node-total-connections=1000 #eureka server 节点间连接的单机最大数量 eureka.server.peer-node-total-connections-per-host=10 #在服务节点启动时，eureka尝试获取注册信息的次数 eureka.server.registry-sync-retries= #在服务节点启动时，eureka多次尝试获取注册信息的间隔时间 eureka.server.registry-sync-retry-wait-ms= #当eureka server启动的时候，不能从对等节点获取instance注册信息的情况，应等待多长时间。 eureka.server.wait-time-in-ms-when-sync-empty=0
Eureka Client配置
#该客户端是否可用
eureka.client.enabled=true
#实例是否在eureka服务器上注册自己的信息以供其他服务发现，默认为true
eureka.client.register-with-eureka=false
#此客户端是否获取eureka服务器注册表上的注册信息，默认为true
eureka.client.fetch-registry=false
#是否过滤掉，非UP的实例。默认为true
eureka.client.filter-only-up-instances=true
#与Eureka注册服务中心的通信zone和url地址
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/
#client连接Eureka服务端后的空闲等待时间，默认为30 秒
eureka.client.eureka-connection-idle-timeout-seconds=30
#client连接eureka服务端的连接超时时间，默认为5秒
eureka.client.eureka-server-connect-timeout-seconds=5
#client对服务端的读超时时长
eureka.client.eureka-server-read-timeout-seconds=8
#client连接all eureka服务端的总连接数，默认200
eureka.client.eureka-server-total-connections=200
#client连接eureka服务端的单机连接数量，默认50
eureka.client.eureka-server-total-connections-per-host=50
#执行程序指数回退刷新的相关属性，是重试延迟的最大倍数值，默认为10
eureka.client.cache-refresh-executor-exponential-back-off-bound=10
#执行程序缓存刷新线程池的大小，默认为5
eureka.client.cache-refresh-executor-thread-pool-size=2
#心跳执行程序回退相关的属性，是重试延迟的最大倍数值，默认为10
eureka.client.heartbeat-executor-exponential-back-off-bound=10
#心跳执行程序线程池的大小,默认为5
eureka.client.heartbeat-executor-thread-pool-size=5
# 询问Eureka服务url信息变化的频率（s），默认为300秒
eureka.client.eureka-service-url-poll-interval-seconds=300
#最初复制实例信息到eureka服务器所需的时间（s），默认为40秒
eureka.client.initial-instance-info-replication-interval-seconds=40
#间隔多长时间再次复制实例信息到eureka服务器，默认为30秒
eureka.client.instance-info-replication-interval-seconds=30
#从eureka服务器注册表中获取注册信息的时间间隔（s），默认为30秒
eureka.client.registry-fetch-interval-seconds=30
# 获取实例所在的地区。默认为us-east-1
eureka.client.region=us-east-1
#实例是否使用同一zone里的eureka服务器，默认为true，理想状态下，eureka客户端与服务端是在同一zone下
eureka.client.prefer-same-zone-eureka=true
# 获取实例所在的地区下可用性的区域列表，用逗号隔开。（AWS）
eureka.client.availability-zones.china=defaultZone,defaultZone1,defaultZone2
#eureka服务注册表信息里的以逗号隔开的地区名单，如果不这样返回这些地区名单，则客户端启动将会出错。默认为null
eureka.client.fetch-remote-regions-registry=
#服务器是否能够重定向客户端请求到备份服务器。 如果设置为false，服务器将直接处理请求，如果设置为true，它可能发送HTTP重定向到客户端。默认为false
eureka.client.allow-redirects=false
#客户端数据接收
eureka.client.client-data-accept=
#增量信息是否可以提供给客户端看，默认为false
eureka.client.disable-delta=false
#eureka服务器序列化/反序列化的信息中获取“_”符号的的替换字符串。默认为“__“
eureka.client.escape-char-replacement=__
#eureka服务器序列化/反序列化的信息中获取“$”符号的替换字符串。默认为“_-”
eureka.client.dollar-replacement="_-"
#当服务端支持压缩的情况下，是否支持从服务端获取的信息进行压缩。默认为true
eureka.client.g-zip-content=true
#是否记录eureka服务器和客户端之间在注册表的信息方面的差异，默认为false
eureka.client.log-delta-diff=false
# 如果设置为true,客户端的状态更新将会点播更新到远程服务器上，默认为true
eureka.client.on-demand-update-status-change=true
#此客户端只对一个单一的VIP注册表的信息感兴趣。默认为null
eureka.client.registry-refresh-single-vip-address=
#client是否在初始化阶段强行注册到服务中心，默认为false
eureka.client.should-enforce-registration-at-init=false
#client在shutdown的时候是否显示的注销服务从服务中心，默认为true
eureka.client.should-unregister-on-shutdown=true
Eureka Instance 常用配置
#服务注册中心实例的主机名 eureka.instance.hostname=localhost #注册在Eureka服务中的应用组名 eureka.instance.app-group-name= #注册在的Eureka服务中的应用名称 eureka.instance.appname= #该实例注册到服务中心的唯一ID eureka.instance.instance-id= #该实例的IP地址 eureka.instance.ip-address= #该实例，相较于hostname是否优先使用IP eureka.instance.prefer-ip-address=false