[Java知识库]【SpringCloud】Netflix - Eureka注册中心

【SpringCloud】Netflix - Eureka注册中心

一、简介

Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的

简单来说 ，Eureka 就是 Netflix 开源的一款提供服务注册和发现的产品，并且提供了 Java 客户端。当然在 Spring Cloud 大力优化后的 Eureka，已经不仅仅只是用于 AWS 云，而是可以应用在任何需要使用注册中心的场景。

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

1. Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。

2. Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就是一个内置的、使用轮询(round-robin)负载算法的负载均衡器。

在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。

下面是Eureka的使用场景

Eureka Server担任注册中心的角色，提供了服务的发现和注册功能
Service Provider 服务提供者,将自身的服务注册到Eureka Server,同时通过心跳检查服务的运行状态
Service Consumer 服务调用者,从Eureka Server 得到注册的服务列表,找到对应的服务地址在调用并使用

二、特点

以下内容来源：Eureka的功能特性及相关配置 - HappyCowboy - 博客园 (cnblogs.com)

2.1 注册中心

1. 服务同步（集群）

   当两个服务提供者注册到注册中心集群，它们的信息被注册中心集群维护（此时注册中心之间互相注册为服务）当服务提供者发送服务注册请求到一个注册中心时，他会将该请求转发给集群中相连的其他注册中心，从而实现注册中心的服务同步。通过服务同步，两个服务提供者的服务信息就可以通过这两台服务注册中心的任意一台获取到。

2. 服务剔除

   有时，服务实例并不一定是正常下线，可能由于内存溢出，网络故障等原因使得服务不能正常工作，而服务注册中心并未收到“服务下线”的请求。为了从服务列表中将这些无法提供服务的实例剔除，Eureka Server在启动时会创建一个定时任务，默认每隔一段时间（默认60s）将当前清单中超时（默认90s）没有续约的服务剔除

3. 自我保护

   服务注册到注册中心后，会维护一个心跳连接，告诉Eureka Server自己还活着。Eureka Server 在运行期间会统计心跳失败比例在15分钟内是是否低于85%，如果出现低于的情况（单机调试很容易满足，实际在生产环境中通常是由于网络不稳定导致的），会将当前的实例注册信息保护起来，让这些实例不过期，尽可能保护注册信息。而在这段保护期间内，实例若出现问题，那么客户端会拿到实际已经不存在的服务实例，会出现调用失败的情况，这时客户端就必须要有容错机制，比如请求重试，熔断器等

   注：在单机调试时，服务注册中心信息面板经常会出现如下提示：

   

   这就是由于触发了Eureka Server的自我保护机制

   可以使用eureka.server.enable-self-preservation=false参数来关闭保护机制

2.2 服务提供者

1. 服务注册

   服务提供者启动时，会通过rest请求的方式将自己注册到Eureka Server上，同时带上了自身服务的一些元数据信息。Eureka Server接收到请求后，将元数据信息存储在一个双层结构的Map中，其中与第一层的key是服务名，第二层的key是具体的服务实例名

    #是否向注册中心注册自己 默认 true
   eureka.client.register-with-eureka=false 
   # 是否去检索注册中心的服务 默认 true
   eureka.client.fetch-registry=false 
   

2. 服务续约

   在注册完服务后，服务提供者会维护一个心跳用来持续高速Eureka Server“我还活着”，以防止Eureka Server的“剔除任务”将该服务实例从服务列表中排除出去

   #定义服务续约任务的调用间隔时间 默认30s
   eureka.instance.lease-renewal-interval-in-seconds=30 
   #定义服务失效的时间 默认90s
   eureka.instance.lease-expiration-duration-in-seconds=90 
   

3. 服务下线

   当服务实例进行正常的关闭操作时，会触发一个服务下线的rest请求给Eureka Server ，告诉注册中心：”我要下线了“，服务端在接收请求后，将该服务置为下线（DOWN），并把下线时间传播出去（通知服务消费者）

2.3 服务消费者

1. 获取服务

   #是否检索注册中心的服务，获取服务则必须设置为true 默认为true
   eureka.client.fetch-registry=ture 
   eureka.client.registry.fetch.interval.seconds=30 
   

   当启动服务消费者时，会发送一个rest请求给注册中心，来获取上面注册的服务清单；为了性能考虑，Eureka Server会维护一份只读的服务清单来返回给客户端，同时缓存清单会每隔30秒更新一次

2. 服务调用

   服务消费者获取服务清单后，通过服务名可以获取具体提供服务的实例名和该实例的元数据信息。有了这些元数据信息，客户端可以根据自己的需要决定具体调用哪个实例。对于访问实例的选择，Eureka中有Region和Zone两个概念，一个Region中可以包含多个Zone,每个服务客户端需要被注册到一个Zone钟，所以每个客户端对应一个Region和一个Zone。在进行服务调用时，优先访问同处一个Zone的服务提供方，若访问不到，再访问其他Zone的服务提供者。

三、Eureka服务搭建

3.1 Eureka注册中心

3.1.1 新建SpringBoot项目

依赖文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>SpringCloudEureka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringCloudEureka</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2021.0.1</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.1.2 配置Eureka

1. 配置类放开Eureka

   package com.example;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
   
   @EnableEurekaServer
   @SpringBootApplication
   public class SpringCloudEurekaApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(SpringCloudEurekaApplication.class, args);
       }
   
   }
   

2. 配置文件

   #erueka默认端口号：8761
   server.port=8761
   
   # 表示是否将自己注册到Eureka Server，默认为true。由于当前这个应用就是Eureka Server，故而设为false。
   eureka.client.registerWithEureka=false
   # 表示是否从Eureka Server获取注册信息，默认为true。因为这是一个单点的Eureka Server，不需要同步其他的Eureka Server节点的数据，故而设为false。
   eureka.client.fetchRegistry=false
   # 关闭Eureka Server的自我保护机制
   #eureka.server.enable-self-preservation=false
   

3.1.3 启动项目

访问：Eureka

页面分为5部分：

System Status 代表的系统状态
DS Replicas 该服务从哪里同步数据
Instances currently registered with Eureka 注册在Eureka的实例列表
General Info 系统运行环境 如cpu、内存等信息
Instance Info 本服务的基础信息 如ip地址 状态等

3.1.4 启动报错

启动Eureka服务端 时报的错，那可能的原因就是自已连了自己 导致的

问题原因：

在默认设置下，eureka服务注册中心会去注册中心获取其他服务的地址，也会将自己作为客户端来尝试注册它自己，所以我们需要禁用它的客户端注册行为:

解决办法是: 更改配置即可

# 表示是否将自己注册到Eureka Server，默认为true。由于当前这个应用就是Eureka Server，故而设为false。
eureka.client.registerWithEureka=false
# 表示是否从Eureka Server获取注册信息，默认为true。因为这是一个单点的Eureka Server，不需要同步其他的Eureka Server节点的数据，故而设为false。
eureka.client.fetchRegistry=false

3.1.5 访问页面报警提示

修改配置文件：

# 关闭Eureka Server的自我保护机制
eureka.server.enable-self-preservation=false

3.2 服务提供者

3.2.1 新建SpringBoot项目

web：提供访问地址

eureka discovery client：服务提供者

3.2.2 配置Erueka client

1. 配置文件

   # 当前服务应用名
   spring.application.name=spring-cloud-eureka-provider
   
   #当前服务端口号
   server.port=8081
   # 使用的是注册中心的地址，如果注册中心没有指定eureka.client.service-url.defaultZone的值，则默认使用EurekaClientConfigBean类中的常量DEFAULT_URL
   # 注意端口号，如果注册中心的端口号不是默认的8761，需要同步修改下面的端口号
   # 如果注册中心指定eureka.client.service-url.defaultZone的值，则使用注册中心指定的值
   eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
   

2. 配置启动类@EnableEurekaClient

   package com.example;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
   
   @SpringBootApplication
   //该注解可以不加
   @EnableEurekaClient
   public class SpringCloudEurekaProviderApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(SpringCloudEurekaProviderApplication.class, args);
       }
   
   }
   
   

3. 增加测试Controller

   package com.example.conreoller;
   
   import org.springframework.web.bind.annotation.PathVariable;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class ProductController {
   
       @RequestMapping("/product/{id}")
       public String findById(@PathVariable("id") Integer id){
           System.out.println(id);
           return "Success";
       }
   }
   

3.2.3 启动项目

客户端启动示意

注册中心示意

可视化页面：

测试Controller的访问

3.3 服务消费者

3.3.1 新建SpringBoot项目

3.3.2 配置Eureka Client

1. 配置文件

   # 当前服务应用名
   spring.application.name=spring-cloud-eureka-user
   
   #当前服务端口号
   server.port=8082
   # 使用的是注册中心的地址
   eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
   # 不将当前服务注册到eureka
   #eureka.client.registerWithEureka=false
   

2. 启动类

   package com.example;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.cloud.client.loadbalancer.LoadBalanced;
   import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
   import org.springframework.context.annotation.Bean;
   import org.springframework.web.client.RestTemplate;
   
   @SpringBootApplication
   @EnableEurekaClient
   public class SpringCloudEruekaUserApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(SpringCloudEruekaUserApplication.class, args);
       }
   
       /**
        * 提供RestTemplate模板，便于调用接口
        * @return
        */
       @Bean
       @LoadBalanced
       public RestTemplate restTemplate(){
           return new RestTemplate();
       }
   
   }
   

3.3.3 创建测试Controller

package com.example.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class UseController {

    @Autowired
    private RestTemplate template;
    
    @GetMapping("/query/{id}")
    public String queryProductInfo(@PathVariable("id")Integer id){
        //不需要使用http:localhost:8081，使用applicationName就可以实现
        String msg = template.getForObject("http://spring-cloud-eureka-provider:8081/product/"+id,String.class);
        System.out.println(msg);
        return msg;
    }
}

访问：localhost:8082/query/1

四、Eureka集群搭建

4.1 配置文件修改

1. 注册中心1

   #项目名
   spring.application.name=spring-cloud-eureka-service
   #erueka默认端口号：8761
   server.port=8761
   
   # 使用的是第二个注册中心的地址
   eureka.client.service-url.defaultZone=http://localhost:8762/eureka/,http://localhost:8761/eureka/
   
   #显示 可视化页面的 DS Replicas
   eureka.instance.prefer-ip-address=true
   

2. 注册中心2

   #项目名
   spring.application.name=spring-cloud-eureka-service2
   #erueka默认端口号：8761
   server.port=8762
   
   # 使用的是注册中心的地址
   eureka.client.service-url.defaultZone=http://localhost:8762/eureka/,http://localhost:8761/eureka/
   
   #显示 可视化页面的 DS Replicas
   eureka.instance.prefer-ip-address=true
   

3. 注意点

   1. 两个注册中心的端口号需要不一致
   2. 注册中心的地址，需要加上注册的位置的地址，需要通过逗号隔开
   3. 注意可视化页面的DS Replicas为空问题

4.2 启动项目

如需要点击访问，需要注意端口号和上述配置文件一致

注册中心1地址：Eureka

注册中心2地址：Eureka

五、Eureka自我保护机制

Eureka Server在运行期间会去统计心跳失败的比例在15分钟之内是否低于85% , 如果低于85%，Eureka Server会认为当前实例的客户端与自己的心跳连接出现了网络故障，那么Eureka Server会把这些实例保护起来，让这些实例不会因为过期而剔除。

这样做的目的是为了减少网络不稳定或者网络分区的情况下，Eureka Server将健康服务剔除下线的问题。 使用自我保护机制可以使得Eureka 集群更加健壮和稳定的运行。

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

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

1. Eureka Server 进入自我保护机制，会出现以下几种情况：
2. Eureka 仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上(即保证当前节点依然可用)
3. 当网络稳定时，当前实例新的注册信息会被同步到其它节点中

Eureka 自我保护机制是为了防止误杀服务而提供的一个机制。当个别客户端出现心跳失联时，则认为是客户端的问题，剔除掉客户端；当 Eureka 捕获到大量的心跳失败时，则认为可能是网络问题，进入自我保护机制；当客户端心跳恢复时，Eureka 会自动退出自我保护机制。

六、常见配置

6.1 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

6.2 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

6.3 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

参考文章：

1. Eureka服务中心的搭建(1)_技术无止境-CSDN博客
2. Eureka 与 zookeeper 的区别、原理及各自优缺点_一个小小bug的博客-CSDN博客_eureka和zookeeper的区别
3. Eureka的功能特性及相关配置 - HappyCowboy - 博客园 (cnblogs.com)
4. Eureka 缓存机制详细配置_技术无止境-CSDN博客_eureka 缓存
5. Eureka工作原理_技术无止境-CSDN博客_eureka

附件：

内含两个注册中心，一个服务提供者，一个服务消费者

SpringCloudEurekaDemo-Java文档类资源-CSDN文库