服务注册中心：Eureka

谁践踏了优雅 2022-10-25 00:57 278阅读 0赞

目录

  • 第一章 注册中心介绍
    • 1.1、什么是注册中心
    • 1.2、为啥用注册中心
    • 1.3、常见的注册中心
  • 第二章 Eureka介绍
    • 2.1、Eureka的介绍
    • 2.2、Eureka的三种角色
    • 2.3、Eureka的运行流程
  • 第三章 Eureka入门案例
    • 3.1、创建注册中心
    • 3.2、创建服务提供者
    • 3.3、创建服务消费者
  • 第四章 Eureka集群配置
    • 4.1、配置集群环境
    • 4.2、修改服务提供者
    • 4.3、修改服务消费者
  • 第五章 Eureka架构原理
  • 第六章 Eureka自我保护
    • 6.1、什么是自我保护
    • 6.2、为啥用自我保护
    • 6.3、如何关自我保护
  • 第七章 Eureka优雅停服
    • 7.1、什么是优雅停服
    • 7.2、如何配优雅停服
  • 第八章 Eureka安全认证
    • 8.1、什么是安全认证
    • 8.2、如何配安全认证
  • 第九章 Eureka配置详解
    • 9.1、server
      • 9.1.1、server与client之间关联配置
      • 9.1.2、server与remote之间关联配置
      • 9.1.3、server与other之间关联配置
      • 9.1.4、node与node之间关联配置
    • 9.2、client
    • 9.3、instance
    • 9.4、dashboard

配套资料，免费下载
链接：https://pan.baidu.com/s/1la\_3-HW-UvliDRJzfBcP\_w
提取码：lxfx
复制这段内容后打开百度网盘手机App，操作更方便哦

第一章 注册中心介绍

1.1、什么是注册中心

注册中心可以说是微服务架构中的“通讯录”，它记录了服务和服务地址的映射关系。在分布式系统中，服务会注册到这里，当服务需要调用其它服务时，就到这里找到服务的地址，进行调用。简单的来说：服务注册中心的作用就是服务的注册和服务的发现。

1.2、为啥用注册中心

了解了什么是注册中心，那么我们继续谈谈，为什么需要注册中心。在分布式系统中，我们不仅仅是需要在注册中心找到服务和服务地址的映射关系这么简单，我们还需要考虑更多更复杂的问题：

  • 服务注册后，如何及时发现
  • 服务宕机后，如何及时下线
  • 服务发现时，如何进行路由
  • 服务异常时，如何进行降级
  • 服务如何有效的水平扩展

这些问题的解决都依赖于注册中心。简单来看，注 册中心的功能有点类似于 DNS 服务器或者负载均衡器，而实际上，注册中心作为微服务的基础组件，可能要更加复杂，也需要更多的灵活性和时效性。所以，我们还需要学习更多 Spring Cloud 微服务组件协同完成应用开发。

1.3、常见的注册中心












































































特性 Eureka（会用） Nacos（重点） Consul（了解） Zookeeper（了解）
CAP AP CP + AP CP CP
健康检查 Client Beat TCP/HTTP/MYSQL/Client Beat TCP/HTTP/gRPC/Cmd Keep Alive
雪崩保护 有 有 无 无
自动注销实例 支持 支持 不支持 支持
访问协议 HTTP HTTP/DNS HTTP/DNS TCP
监听支持 支持 支持 支持 支持
多数据中心 支持 支持 支持 不支持
跨注册中心同步 不支持 支持 支持 不支持
SpringCloud集成 支持 支持 支持 支持

第二章 Eureka介绍

2.1、Eureka的介绍

Eureka 是 Netflix 开发的服务发现组件，本身是一个基于 REST 的服务。Spring Cloud 将它集成在其子项目 Spring Cloud Netflix 中，实现 Spring Cloud 的服务注册与发现，同时还提供了负载均衡、故障转移等能力。

2.2、Eureka的三种角色

4d7241e388b746a848b42aad4f884740.png

  • Eureka Server：通过 Register、Get、Renew 等接口提供服务的注册和发现。
  • Service Provider：服务提供方，把自身的服务实例注册到 Eureka Server 中。
  • Service Consumer：服务调用方，通过 Eureka Server 获取服务列表，消费服务。

2.3、Eureka的运行流程

c6611e956bf689962e14612ddf1dac53.png

第三章 Eureka入门案例

3.1、创建注册中心

（1）在spring-cloud-study下创建一个子模块，名称叫：eureka-server7001

（2）在eureka-server7001的pom.xml中，添加以下依赖信息

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.cloud</groupId>
  4.         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-web</artifactId>
  9.     </dependency>
  10.     <dependency>
  11.         <groupId>org.springframework.boot</groupId>
  12.         <artifactId>spring-boot-starter-actuator</artifactId>
  13.     </dependency>
  14.     <dependency>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-devtools</artifactId>
  17.         <scope>runtime</scope>
  18.         <optional>true</optional>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.projectlombok</groupId>
  22.         <artifactId>lombok</artifactId>
  23.         <version>1.18.16</version>
  24.     </dependency>    
  25. </dependencies>

（3）创建一个配置文件，名字叫application.yaml，然后把以下这段配置拷贝进去

  1. server:
  2.   port: 7001
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: eureka-server
  9. eureka:
  10.   instance:
  11.     #服务注册中心实例的主机名
  12.     hostname: localhost
  13.   client:
  14.     #是否将自己注册到注册中心，默认为 true，单实例模式下需要设置为 false
  15.     register-with-eureka: false
  16.     #是否从注册中心获取服务注册信息，默认为 true，单实例模式下需要设置为 false
  17.     fetch-registry: false
  18.     #注册中心对外暴露的注册地址
  19.     service-url:
  20.       defaultZone: http://${ eureka.instance.hostname}:${ server.port}/eureka/

（4）创建一个包名字叫com.caochenlei，在这个包下创建一个主启动类EurekaServer7001Application

  1. @EnableEurekaServer
  2. @SpringBootApplication
  3. public class EurekaServer7001Application { 
  4.     public static void main(String[] args) { 
  5.         SpringApplication.run(EurekaServer7001Application.class);
  6.     }
  7. }

（5）启动当前注册中心应用服务，然后打开浏览器，在浏览器地址栏中输入：http://localhost:7001/

a9fb7f7c4d2f73b3100170363a0a0252.png

3.2、创建服务提供者

（1）在spring-cloud-study下创建一个子模块，名称叫：service-provider8001

（2）在service-provider8001的pom.xml中，添加以下依赖信息

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.cloud</groupId>
  4.         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-web</artifactId>
  9.     </dependency>
  10.     <dependency>
  11.         <groupId>org.springframework.boot</groupId>
  12.         <artifactId>spring-boot-starter-actuator</artifactId>
  13.     </dependency>
  14.     <dependency>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-devtools</artifactId>
  17.         <scope>runtime</scope>
  18.         <optional>true</optional>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.projectlombok</groupId>
  22.         <artifactId>lombok</artifactId>
  23.         <version>1.18.16</version>
  24.     </dependency>
  25. </dependencies>

（3）创建一个配置文件，名字叫application.yaml，然后把以下这段配置拷贝进去

  1. server:
  2.   port: 8001
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: service-provider
  9. eureka:
  10.   instance:
  11.     #是否使用 ip 地址注册
  12.     prefer-ip-address: true
  13.     #该实例注册到服务中心的唯一ID
  14.     instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
  15.   client:
  16.     #设置服务注册中心地址
  17.     service-url:
  18.       defaultZone: http://localhost:7001/eureka/

（4）创建一个包名字叫com.caochenlei，在这个包下创建一个主启动类ServiceProvider8001Application

  1. @EnableEurekaClient
  2. @SpringBootApplication
  3. public class ServiceProvider8001Application { 
  4.     public static void main(String[] args) { 
  5.         SpringApplication.run(ServiceProvider8001Application.class);
  6.     }
  7. }

（5）编写实体类代码（com.caochenlei.pojo.Product）

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class Product implements Serializable { 
  5.     private Integer pid;
  6.     private String name;
  7.     private Double price;
  8.     private Integer count;
  9. }

（6）编写服务层接口（com.caochenlei.service.ProductService）

  1. public interface ProductService { 
  2.     /** * 查找所有商品 * @return */
  3.     public List<Product> findAll();
  4. }

（7）编写服务层实现（com.caochenlei.service.impl.ProductServiceImpl）

  1. @Service
  2. public class ProductServiceImpl implements ProductService { 
  3.     @Override
  4.     public List<Product> findAll() { 
  5.         return Arrays.asList(
  6.                 new Product(1, "小米手机", 1000.0D, 100),
  7.                 new Product(2, "华为手机", 2000.0D, 200),
  8.                 new Product(3, "苹果手机", 3000.0D, 300)
  9.         );
  10.     }
  11. }

（8）编写控制层代码（com.caochenlei.controller.ProductController）

  1. @RestController
  2. public class ProductController { 
  3.     @Autowired
  4.     private ProductService productService;
  6.     @RequestMapping("/provider/product/findAll")
  7.     public List<Product> findAll() { 
  8.         return productService.findAll();
  9.     }
  10. }

（9）启动当前服务提供者，然后打开浏览器，在浏览器地址栏中输入：http://localhost:7001/

image-20210129215639316

（10）测试我们刚才写的业务代码，在浏览器地址栏中输入：http://localhost:8001/provider/product/findAll

d61a478626171b7d6de72b0490768d2d.png

3.3、创建服务消费者

（1）在spring-cloud-study下创建一个子模块，名称叫：service-consumer9001

（2）在service-consumer9001的pom.xml中，添加以下依赖信息

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.cloud</groupId>
  4.         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-web</artifactId>
  9.     </dependency>
  10.     <dependency>
  11.         <groupId>org.springframework.boot</groupId>
  12.         <artifactId>spring-boot-starter-actuator</artifactId>
  13.     </dependency>
  14.     <dependency>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-devtools</artifactId>
  17.         <scope>runtime</scope>
  18.         <optional>true</optional>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.projectlombok</groupId>
  22.         <artifactId>lombok</artifactId>
  23.         <version>1.18.16</version>
  24.     </dependency>
  25. </dependencies>

（3）创建一个配置文件，名字叫application.yaml，然后把以下这段配置拷贝进去

  1. server:
  2.   port: 9001
  4. spring:
  5.   application:
  6.     name: service-consumer9001
  8. eureka:
  9.   client:
  10.     #是否将自己注册到注册中心，默认为 true
  11.     register-with-eureka: false
  12.     #表示 Eureka Client 间隔多久去服务器拉取注册信息，默认为 30 秒
  13.     registry-fetch-interval-seconds: 10
  14.     #设置服务注册中心地址
  15.     service-url:
  16.       defaultZone: http://localhost:7001/eureka/

（4）创建一个包名字叫com.caochenlei，在这个包下创建一个主启动类ServiceConsumer9001Application

  1. @EnableEurekaClient
  2. @SpringBootApplication
  3. public class ServiceConsumer9001Application { 
  4.     public static void main(String[] args) { 
  5.         SpringApplication.run(ServiceConsumer9001Application.class);
  6.     }
  8.     @Bean
  9.     public RestTemplate restTemplate(){ 
  10.         return new RestTemplate();
  11.     }
  12. }

（5）编写实体类代码（com.caochenlei.pojo.Product）

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class Product implements Serializable { 
  5.     private Integer pid;
  6.     private String name;
  7.     private Double price;
  8.     private Integer count;
  9. }

（6）编写控制层代码（com.caochenlei.controller.ProductController）

  1. @RestController
  2. public class ProductController { 
  3.     public static final String BASE_URL = "http://localhost:8001";
  5.     @Autowired
  6.     private RestTemplate restTemplate;
  8.     @RequestMapping("/consumer/product/findAll")
  9.     public List<Product> findAll() { 
  10.         String findAllUrl = BASE_URL + "/provider/product/findAll";
  11.         Product[] products = restTemplate.getForObject(findAllUrl, Product[].class);
  12.         return Arrays.asList(products);
  13.     }
  14. }

（7）启动当前服务消费者，然后打开浏览器，在浏览器地址栏中输入：http://localhost:9001/consumer/product/findAll

f129e7906bdca0068206bea14f54eb6d.png

注意：我们现在虽然可以正常调用成功，但聪明的你一定要知道，我们现在只是学习了注册中心的搭建和服务的注册，并没有学习服务的远程调用，这个restTemplate本身就是spring提供的一种访问restful风格的模板类，他不是spring cloud的知识点，spring cloud下服务的调用我们会在后续章节或技术中进行介绍，这里特别说明，是怕大家混淆，我们这一章节重点学习注册中心。

第四章 Eureka集群配置

4.1、配置集群环境

（1）在刚才的父工程下再创建一个 eureka-server7002 注册中心的项目，如果是多机器部署不用修改端口，通过 IP 区分服务，如果在一台机器上演示需要修改端口区分服务。

（2）添加域名映射，eureka会把hostname相同的url移除掉，如果我们配置的都是localhost，所以虽然你启动了两个eureka，但是它们不会把自己当成集群

C:\Windows\System32\drivers\etc\hosts

  1. 127.0.0.1 eureka-server7001.com
  2. 127.0.0.1 eureka-server7002.com

（3）修改eureka-server7001的application.yaml

  1. server:
  2.   port: 7001
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: eureka-server
  9. eureka:
  10.   instance:
  11.     #服务注册中心实例的主机名
  12.     hostname: eureka-server7001.com
  13.     #是否使用 ip 地址注册
  14.     prefer-ip-address: true
  15.     #该实例注册到服务中心的唯一ID
  16.     instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
  17.   client:
  18.     #设置服务注册中心地址，指向另一个注册中心（除自己之外所有，多个使用逗号隔开）
  19.     service-url:
  20.       defaultZone: http://localhost:7002/eureka/

（4）修改eureka-server7002的application.yaml

  1. server:
  2.   port: 7002
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: eureka-server
  9. eureka:
  10.   instance:
  11.     #服务注册中心实例的主机名
  12.     hostname: eureka-server7002.com
  13.     #是否使用 ip 地址注册
  14.     prefer-ip-address: true
  15.     #该实例注册到服务中心的唯一ID
  16.     instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
  17.   client:
  18.     #设置服务注册中心地址，指向另一个注册中心（除自己之外所有，多个使用逗号隔开）
  19.     service-url:
  20.       defaultZone: http://localhost:7001/eureka/

（5）启动两个注册中心，他们会自动构成一个集群环境，我们先启动7001的，然后再启动7002的，先启动哪一个无所谓，但是会报错，这属于正常现象，因为你另一台还没有启动，没有办法注册，等两台都启动了，过一会清除一下控制台，就发现不报错了。

6c7fb77362c066d014366dbcfd2161f4.png

4.2、修改服务提供者

application.yaml

  1. server:
  2.   port: 8001
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: service-provider
  9. eureka:
  10.   instance:
  11.     #是否使用 ip 地址注册
  12.     prefer-ip-address: true
  13.     #该实例注册到服务中心的唯一ID
  14.     instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
  15.   client:
  16.     #设置服务注册中心地址
  17.     service-url:
  18.       defaultZone: http://eureka-server7001.com:7001/eureka/,http://eureka-server7002.com:7002/eureka/

http://localhost:7001/ ， http://localhost:7002/

b03df734cc4e2815e04074fd27079d9b.png

4.3、修改服务消费者

application.yaml

  1. server:
  2.   port: 9001
  4. spring:
  5.   application:
  6.     name: service-consumer9001
  8. eureka:
  9.   client:
  10.     #是否将自己注册到注册中心，默认为 true
  11.     register-with-eureka: false
  12.     #表示 Eureka Client 间隔多久去服务器拉取注册信息，默认为 30 秒
  13.     registry-fetch-interval-seconds: 10
  14.     #设置服务注册中心地址
  15.     service-url:
  16.       defaultZone: http://eureka-server7001.com:7001/eureka/,http://eureka-server7002.com:7002/eureka/

ProductController

  1. @RestController
  2. public class ProductController { 
  3.     @Autowired
  4.     private RestTemplate restTemplate;
  6.     @Autowired
  7.     private DiscoveryClient discoveryClient;
  9.     @RequestMapping("/consumer/product/findAll")
  10.     public List<Product> findAll() { 
  11.         //获取注册中心服务列表
  12.         List<ServiceInstance> instances = discoveryClient.getInstances("SERVICE-PROVIDER");
  13.         if (CollectionUtils.isEmpty(instances)) { 
  14.             return null;
  15.         }
  17.         //循环遍历打印服务实体
  18.         for (ServiceInstance instance : instances) { 
  19.             System.out.println(instance.getUri());
  20.             System.out.println(instance.getHost());
  21.             System.out.println(instance.getPort());
  22.             System.out.println("====================");
  23.         }
  25.         //我们拿出第一个服务实体
  26.         ServiceInstance si = instances.get(0);
  27.         String findAllUrl = si.getUri() + "/provider/product/findAll";
  28.         Product[] products = restTemplate.getForObject(findAllUrl, Product[].class);
  29.         return Arrays.asList(products);
  30.     }
  31. }

http://localhost:9001/consumer/product/findAll

414b9319cebe1f5af26d021721d47a00.png

注意：这里我们使用了discoveryClient获取了注册中心SERVICE-PROVIDER服务的服务列表，就是discoveryClient用来发现服务中心对应服务的地址，然后使用restTemplate进行远程调用，上一章节的服务地址是咱们自己写死的，这里就更进一步，往后还有更好用的调用方式。

第五章 Eureka架构原理

9f95800302cf07a9fbbc49a771ddeffe.png

  • Register(服务注册)：把自己的 IP 和端口注册给 Eureka。
  • Renew(服务续约)：发送心跳包，每 30 秒发送一次，告诉 Eureka 自己还活着。如果 90 秒还未发送心跳，宕机。
  • Cancel(服务下线)：当 Provider 关闭时会向 Eureka 发送消息，把自己从服务列表中删除，防止 Consumer 调用到不存在的服务。
  • Get Registry(获取服务注册列表)：获取其他服务列表。
  • Replicate(集群中数据同步)：Eureka 集群中的数据复制与同步。
  • Make Remote Call(远程调用)：完成服务的远程调用。

第六章 Eureka自我保护

6.1、什么是自我保护

一般情况下，服务在 Eureka 上注册后，会每 30 秒发送心跳包，Eureka 通过心跳来判断服务是否健康，同时会定期删除超过 90 秒没有发送心跳的服务。Eureka Server 在运行期间会去统计心跳失败比例在 15 分钟之内是否低于 85%，如果低于 85%，Eureka Server 会将这些实例保护起来，让这些实例不会过期，同时提示一个警告，这种算法叫做 Eureka Server 的自我保护模式，这种自我保护模式默认开启。

26c77f1ecfb92cf0aa7eb073bc57ad14.png

有两种情况会导致 Eureka Server 收不到微服务的心跳：

  • 微服务自身的原因
  • 微服务与 Eureka 之间的网络故障

6.2、为啥用自我保护

  • 因为同时保留”好数据”与”坏数据”总比丢掉任何数据要更好，当网络故障恢复后，这个 Eureka 节点会退出”自我保护模式”。
  • Eureka 还有客户端缓存功能（也就是微服务的缓存功能），即使 Eureka 集群中所有节点都宕机失效，微服务的 Provider 和 Consumer 都能正常通信。
  • 微服务的负载均衡策略会自动剔除死亡的微服务节点。

6.3、如何关自我保护

注册中心配置自我保护：

  1. eureka:
  2.   server:
  3.     #true：开启自我保护模式，false：关闭自我保护模式
  4.     enable-self-preservation: false
  5.     #清理间隔（单位：毫秒，默认是 60*1000）
  6.     eviction-interval-timer-in-ms: 60000

第七章 Eureka优雅停服

7.1、什么是优雅停服

在上一章节中，我们知道注册中心注册的服务默认会有自我保护模式，我们想要关闭这个模式也很简单，要是我不想关闭这个模式，让他正常默认启用，现在我想要下线某一个服务，让注册中心知道，这个服务是我们人为的下线的，这时候，注册中心应该正常踢出这个下线服务，而不是保护起来，这样就不会触发自我保护模式了，而其他的服务因为没有停止仍然有可能会触发自我保护模式，这个就是一种优雅的停止服务的方式。

7.2、如何配优雅停服

服务提供者配置优雅停服：

  1. #度量指标监控与健康检查
  2. management:
  3.   endpoints:
  4.     web:
  5.       exposure:
  6.         #开启 shutdown 端点访问
  7.         include: shutdown
  8.   endpoint:
  9.     #开启 shutdown 实现优雅停服
  10.     shutdown:
  11.       enabled: true

打开postman使用post方式关闭服务：http://localhost:8001/actuator/shutdown

image-20210130113259668

第八章 Eureka安全认证

8.1、什么是安全认证

现在我们已经学会搭建Eureka注册中心集群，但是，这个访问地址我们是可以直接访问的，既然我们可以直接访问，那要是部署到线上，别人是不是也可以通过地址直接来访问咱们的注册中心，这会存在安全隐患，我们能不能在访问注册中心的时候，需要账号和密码的验证，以此来保证访问当前注册中心的一定是咱们可信的人，那这个就是注册中心的安全认证。

8.2、如何配安全认证

（1）注册中心添加 security 依赖，两个都要加

  1. <!-- spring boot security 依赖 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-security</artifactId>
  5. </dependency>

（2）注册中心配置 security 认证，两个都要配

eureka-server7001的application.yaml

  1. server:
  2.   port: 7001
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: eureka-server
  8.   # 安全认证
  9.   security:
  10.     user:
  11.       name: root
  12.       password: 123456
  14. eureka:
  15.   instance:
  16.     #服务注册中心实例的主机名
  17.     hostname: eureka-server7001.com
  18.     #是否使用 ip 地址注册
  19.     prefer-ip-address: true
  20.     #该实例注册到服务中心的唯一ID
  21.     instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
  22.   client:
  23.     #设置服务注册中心地址，指向另一个注册中心（除自己之外所有，多个使用逗号隔开）
  24.     service-url:
  25.       defaultZone: http://root:123456@eureka-server7002.com:7002/eureka/

eureka-server7002的application.yaml

  1. server:
  2.   port: 7002
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: eureka-server
  8.   # 安全认证
  9.   security:
  10.     user:
  11.       name: root
  12.       password: 123456
  14. eureka:
  15.   instance:
  16.     #服务注册中心实例的主机名
  17.     hostname: eureka-server7002.com
  18.     #是否使用 ip 地址注册
  19.     prefer-ip-address: true
  20.     #该实例注册到服务中心的唯一ID
  21.     instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
  22.   client:
  23.     #设置服务注册中心地址，指向另一个注册中心（除自己之外所有，多个使用逗号隔开）
  24.     service-url:
  25.       defaultZone: http://root:123456@eureka-server7001.com:7001/eureka/

（3）修改服务提供者的注册中心地址

  1. server:
  2.   port: 8001
  4. spring:
  5.   application:
  6.     #该名称在集群模式下应该保持一致
  7.     name: service-provider
  9. #度量指标监控与健康检查
  10. management:
  11.   endpoints:
  12.     web:
  13.       exposure:
  14.         #开启 shutdown 端点访问
  15.         include: shutdown
  16.   endpoint:
  17.     #开启 shutdown 实现优雅停服
  18.     shutdown:
  19.       enabled: true
  21. eureka:
  22.   instance:
  23.     #是否使用 ip 地址注册
  24.     prefer-ip-address: true
  25.     #该实例注册到服务中心的唯一ID
  26.     instance-id: ${ spring.cloud.client.ip-address}:${ server.port}
  27.   client:
  28.     #设置服务注册中心地址
  29.     service-url:
  30.       defaultZone: http://root:123456@eureka-server7001.com:7001/eureka/,http://root:123456@eureka-server7002.com:7002/eureka/

（4）修改服务消费者的注册中心地址

  1. server:
  2.   port: 9001
  4. spring:
  5.   application:
  6.     name: service-consumer9001
  8. eureka:
  9.   client:
  10.     #是否将自己注册到注册中心，默认为 true
  11.     register-with-eureka: false
  12.     #表示 Eureka Client 间隔多久去服务器拉取注册信息，默认为 30 秒
  13.     registry-fetch-interval-seconds: 10
  14.     #设置服务注册中心地址
  15.     service-url:
  16.       defaultZone: http://root:123456@eureka-server7001.com:7001/eureka/,http://root:123456@eureka-server7002.com:7002/eureka/

（5）配置注册中心的csrf

Eureka 会自动化配置 CSRF 防御机制，Spring Security 认为 POST, PUT, and DELETE http methods 都是有风险的，如果这些 method 发送过程中没有带上 CSRF token 的话，会被直接拦截并返回 403 forbidden。我们应该使 CSRF 忽略 /eureka/** 的所有请求。

在每一个注册中心的com.caochenlei包下创建一个配置类，名字叫WebSecurityConfig

  1. @Configuration
  2. @EnableWebSecurity
  3. public class WebSecurityConfig extends WebSecurityConfigurerAdapter { 
  4.     @Override
  5.     protected void configure(HttpSecurity http) throws Exception { 
  6.         super.configure(http); // 加这句是为了访问 eureka 控制台和 /actuator 时能做安全控制
  7.         http.csrf().ignoringAntMatchers("/eureka/**"); // 忽略 /eureka/** 的所有请求
  8.     }
  9. }

（6）重新启动所有的项目，启动的顺序以此是

  1. eureka-server7001
  2. eureka-server7002
  3. service-provider8001
  4. service-consumer9001

（7）打开浏览器输入Eureka的控制台地址，分别访问

http://localhost:7001/

http://localhost:7002/

85bae2add24d6b48e218d39da07bdfdc.png

image-20210130123236854

第九章 Eureka配置详解

9.1、server

9.1.1、server与client之间关联配置

  1. #服务端开启自我保护模式。无论什么情况，服务端都会保持一定数量的服务。避免client与server的网络问题，而出现大量的服务被清除。
  2. eureka.server.enable-self-preservation=true
  3. #开启清除无效服务的定时任务，时间间隔。默认1分钟
  4. eureka.server.eviction-interval-timer-in-ms= 60000
  5. #间隔多长时间，清除过期的delta数据
  6. eureka.server.delta-retention-timer-interval-in-ms=0
  7. #过期数据，是否也提供给client
  8. eureka.server.disable-delta=false
  9. #eureka服务端是否记录client的身份header
  10. eureka.server.log-identity-headers=true
  11. #请求频率限制器
  12. eureka.server.rate-limiter-burst-size=10
  13. #是否开启请求频率限制器
  14. eureka.server.rate-limiter-enabled=false
  15. #请求频率的平均值
  16. eureka.server.rate-limiter-full-fetch-average-rate=100
  17. #是否对标准的client进行频率请求限制。如果是false，则只对非标准client进行限制
  18. eureka.server.rate-limiter-throttle-standard-clients=false
  19. #注册服务、拉去服务列表数据的请求频率的平均值
  20. eureka.server.rate-limiter-registry-fetch-average-rate=500
  21. #设置信任的client list
  22. eureka.server.rate-limiter-privileged-clients=
  23. #在设置的时间范围类，期望与client续约的百分比。
  24. eureka.server.renewal-percent-threshold=0.85
  25. #多长时间更新续约的阈值
  26. eureka.server.renewal-threshold-update-interval-ms=0
  27. #对于缓存的注册数据，多长时间过期
  28. eureka.server.response-cache-auto-expiration-in-seconds=180
  29. #多长时间更新一次缓存中的服务注册数据
  30. eureka.server.response-cache-update-interval-ms=0
  31. #缓存增量数据的时间，以便在检索的时候不丢失信息
  32. eureka.server.retention-time-in-m-s-in-delta-queue=0
  33. #当时间戳不一致的时候，是否进行同步
  34. eureka.server.sync-when-timestamp-differs=true
  35. #是否采用只读缓存策略，只读策略对于缓存的数据不会过期。
  36. eureka.server.use-read-only-response-cache=true

9.1.2、server与remote之间关联配置

  1. #过期数据，是否也提供给远程region
  2. eureka.server.disable-delta-for-remote-regions=false
  3. #回退到远程区域中的应用程序的旧行为 (如果已配置) 如果本地区域中没有该应用程序的实例, 则将被禁用。
  4. eureka.server.disable-transparent-fallback-to-other-region=false
  5. #指示在服务器支持的情况下, 是否必须为远程区域压缩从尤里卡服务器获取的内容。
  6. eureka.server.g-zip-content-from-remote-region=true
  7. #连接eureka remote note的连接超时时间
  8. eureka.server.remote-region-connect-timeout-ms=1000
  9. #remote region 应用白名单
  10. eureka.server.remote-region-app-whitelist.
  11. #连接eureka remote note的连接空闲时间
  12. eureka.server.remote-region-connection-idle-timeout-seconds=30
  13. #执行remote region 获取注册信息的请求线程池大小
  14. eureka.server.remote-region-fetch-thread-pool-size=20
  15. #remote region 从对等eureka加点读取数据的超时时间
  16. eureka.server.remote-region-read-timeout-ms=1000
  17. #从remote region 获取注册信息的时间间隔
  18. eureka.server.remote-region-registry-fetch-interval=30
  19. #remote region 连接eureka节点的总连接数量
  20. eureka.server.remote-region-total-connections=1000
  21. #remote region 连接eureka节点的单机连接数量
  22. eureka.server.remote-region-total-connections-per-host=50
  23. #remote region抓取注册信息的存储文件，而这个可靠的存储文件需要全限定名来指定
  24. eureka.server.remote-region-trust-store=
  25. #remote region 储存的文件的密码
  26. eureka.server.remote-region-trust-store-password=
  27. #remote region url.多个逗号隔开
  28. eureka.server.remote-region-urls=
  29. #remote region url.多个逗号隔开
  30. eureka.server.remote-region-urls-with-name=

9.1.3、server与other之间关联配置

  1. #缓存ASG信息的过期时间。
  2. eureka.server.a-s-g-cache-expiry-timeout-ms=0
  3. #查询ASG信息的超时时间
  4. eureka.server.a-s-g-query-timeout-ms=300
  5. #服务更新ASG信息的频率
  6. eureka.server.a-s-g-update-interval-ms=0
  7. #AWS访问ID
  8. eureka.server.a-w-s-access-id=
  9. #AWS安全密钥
  10. eureka.server.a-w-s-secret-key=
  11. #AWS绑定策略
  12. eureka.server.binding-strategy=eip
  13. #用于从第三方AWS 帐户描述自动扩展分组的角色的名称。
  14. eureka.server.list-auto-scaling-groups-role-name=
  15. #是否应该建立连接引导
  16. eureka.server.prime-aws-replica-connections=true
  17. #服务端尝试绑定候选EIP的次数
  18. eureka.server.e-i-p-bind-rebind-retries=3
  19. #服务端绑定EIP的时间间隔.如果绑定就检查;如果绑定失效就重新绑定。当且仅当已经绑定的情况
  20. eureka.server.e-i-p-binding-retry-interval-ms=10
  21. #服务端绑定EIP的时间间隔.当且仅当服务为绑定的情况
  22. eureka.server.e-i-p-binding-retry-interval-ms-when-unbound=
  23. #服务端尝试绑定route53的次数
  24. eureka.server.route53-bind-rebind-retries=3
  25. #服务端间隔多长时间尝试绑定route53
  26. eureka.server.route53-binding-retry-interval-ms=30
  27. #用于建立route53域的ttl，默认为30
  28. eureka.server.route53-domain-t-t-l=10

9.1.4、node与node之间关联配置

  1. #发送复制数据是否在request中，总是压缩
  2. eureka.server.enable-replicated-request-compression=false
  3. #指示群集节点之间的复制是否应批处理以提高网络效率。
  4. eureka.server.batch-replication=false
  5. #允许备份到备份池的最大复制事件数量。而这个备份池负责除状态更新的其他事件。可以根据内存大小，超时和复制流量，来设置此值得大小
  6. eureka.server.max-elements-in-peer-replication-pool=10000
  7. #允许备份到状态备份池的最大复制事件数量
  8. eureka.server.max-elements-in-status-replication-pool=10000
  9. #多个服务中心相互同步信息线程的最大空闲时间
  10. eureka.server.max-idle-thread-age-in-minutes-for-peer-replication=15
  11. #状态同步线程的最大空闲时间
  12. eureka.server.max-idle-thread-in-minutes-age-for-status-replication=15
  13. #服务注册中心各个instance相互复制数据的最大线程数量
  14. eureka.server.max-threads-for-peer-replication=20
  15. #服务注册中心各个instance相互复制状态数据的最大线程数量
  16. eureka.server.max-threads-for-status-replication=1
  17. #instance之间复制数据的通信时长
  18. eureka.server.max-time-for-replication=30000
  19. #正常的对等服务instance最小数量。-1表示服务中心为单节点。
  20. eureka.server.min-available-instances-for-peer-replication=-1
  21. #instance之间相互复制开启的最小线程数量
  22. eureka.server.min-threads-for-peer-replication=5
  23. #instance之间用于状态复制，开启的最小线程数量
  24. eureka.server.min-threads-for-status-replication=1
  25. #instance之间复制数据时可以重试的次数
  26. eureka.server.number-of-replication-retries=5
  27. #eureka节点间间隔多长时间更新一次数据。默认10分钟。
  28. eureka.server.peer-eureka-nodes-update-interval-ms=600000
  29. #eureka服务状态的相互更新的时间间隔。
  30. eureka.server.peer-eureka-status-refresh-time-interval-ms=0
  31. #eureka对等节点间连接超时时间
  32. eureka.server.peer-node-connect-timeout-ms=200
  33. #eureka对等节点连接后的空闲时间
  34. eureka.server.peer-node-connection-idle-timeout-seconds=30
  35. #节点间的读数据连接超时时间
  36. eureka.server.peer-node-read-timeout-ms=200
  37. #eureka server 节点间连接的总共最大数量
  38. eureka.server.peer-node-total-connections=1000
  39. #eureka server 节点间连接的单机最大数量
  40. eureka.server.peer-node-total-connections-per-host=10
  41. #在服务节点启动时，eureka尝试获取注册信息的次数
  42. eureka.server.registry-sync-retries=
  43. #在服务节点启动时，eureka多次尝试获取注册信息的间隔时间
  44. eureka.server.registry-sync-retry-wait-ms=
  45. #当eureka server启动的时候，不能从对等节点获取instance注册信息的情况，应等待多长时间。
  46. eureka.server.wait-time-in-ms-when-sync-empty=0

9.2、client

  1. #该客户端是否可用
  2. eureka.client.enabled=true
  3. #实例是否在eureka服务器上注册自己的信息以供其他服务发现，默认为true
  4. eureka.client.register-with-eureka=false
  5. #此客户端是否获取eureka服务器注册表上的注册信息，默认为true
  6. eureka.client.fetch-registry=false
  7. #是否过滤掉，非UP的实例。默认为true
  8. eureka.client.filter-only-up-instances=true
  9. #与Eureka注册服务中心的通信zone和url地址
  10. eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/
  11. #client连接Eureka服务端后的空闲等待时间，默认为30 秒
  12. eureka.client.eureka-connection-idle-timeout-seconds=30
  13. #client连接eureka服务端的连接超时时间，默认为5秒
  14. eureka.client.eureka-server-connect-timeout-seconds=5
  15. #client对服务端的读超时时长
  16. eureka.client.eureka-server-read-timeout-seconds=8
  17. #client连接all eureka服务端的总连接数，默认200
  18. eureka.client.eureka-server-total-connections=200
  19. #client连接eureka服务端的单机连接数量，默认50
  20. eureka.client.eureka-server-total-connections-per-host=50
  21. #执行程序指数回退刷新的相关属性，是重试延迟的最大倍数值，默认为10
  22. eureka.client.cache-refresh-executor-exponential-back-off-bound=10
  23. #执行程序缓存刷新线程池的大小，默认为5
  24. eureka.client.cache-refresh-executor-thread-pool-size=2
  25. #心跳执行程序回退相关的属性，是重试延迟的最大倍数值，默认为10
  26. eureka.client.heartbeat-executor-exponential-back-off-bound=10
  27. #心跳执行程序线程池的大小,默认为5
  28. eureka.client.heartbeat-executor-thread-pool-size=5
  29. # 询问Eureka服务url信息变化的频率（s），默认为300秒
  30. eureka.client.eureka-service-url-poll-interval-seconds=300
  31. #最初复制实例信息到eureka服务器所需的时间（s），默认为40秒
  32. eureka.client.initial-instance-info-replication-interval-seconds=40
  33. #间隔多长时间再次复制实例信息到eureka服务器，默认为30秒
  34. eureka.client.instance-info-replication-interval-seconds=30
  35. #从eureka服务器注册表中获取注册信息的时间间隔（s），默认为30秒
  36. eureka.client.registry-fetch-interval-seconds=30
  37. # 获取实例所在的地区。默认为us-east-1
  38. eureka.client.region=us-east-1
  39. #实例是否使用同一zone里的eureka服务器，默认为true，理想状态下，eureka客户端与服务端是在同一zone下
  40. eureka.client.prefer-same-zone-eureka=true
  41. # 获取实例所在的地区下可用性的区域列表，用逗号隔开。（AWS）
  42. eureka.client.availability-zones.china=defaultZone,defaultZone1,defaultZone2
  43. #eureka服务注册表信息里的以逗号隔开的地区名单，如果不这样返回这些地区名单，则客户端启动将会出错。默认为null
  44. eureka.client.fetch-remote-regions-registry=
  45. #服务器是否能够重定向客户端请求到备份服务器。 如果设置为false，服务器将直接处理请求，如果设置为true，它可能发送HTTP重定向到客户端。默认为false
  46. eureka.client.allow-redirects=false
  47. #客户端数据接收
  48. eureka.client.client-data-accept=
  49. #增量信息是否可以提供给客户端看，默认为false
  50. eureka.client.disable-delta=false
  51. #eureka服务器序列化/反序列化的信息中获取“_”符号的的替换字符串。默认为“__“
  52. eureka.client.escape-char-replacement=__
  53. #eureka服务器序列化/反序列化的信息中获取“$”符号的替换字符串。默认为“_-”
  54. eureka.client.dollar-replacement="_-"
  55. #当服务端支持压缩的情况下，是否支持从服务端获取的信息进行压缩。默认为true
  56. eureka.client.g-zip-content=true
  57. #是否记录eureka服务器和客户端之间在注册表的信息方面的差异，默认为false
  58. eureka.client.log-delta-diff=false
  59. # 如果设置为true,客户端的状态更新将会点播更新到远程服务器上，默认为true
  60. eureka.client.on-demand-update-status-change=true
  61. #此客户端只对一个单一的VIP注册表的信息感兴趣。默认为null
  62. eureka.client.registry-refresh-single-vip-address=
  63. #client是否在初始化阶段强行注册到服务中心，默认为false
  64. eureka.client.should-enforce-registration-at-init=false
  65. #client在shutdown的时候是否显示的注销服务从服务中心，默认为true
  66. eureka.client.should-unregister-on-shutdown=true
  67. # 获取eureka服务的代理主机，默认为null
  68. eureka.client.proxy-host=
  69. #获取eureka服务的代理密码，默认为null
  70. eureka.client.proxy-password=
  71. # 获取eureka服务的代理端口, 默认为null
  72. eureka.client.proxy-port=
  73. # 获取eureka服务的代理用户名，默认为null
  74. eureka.client.proxy-user-name=
  75. #属性解释器
  76. eureka.client.property-resolver=
  77. #获取实现了eureka客户端在第一次启动时读取注册表的信息作为回退选项的实现名称
  78. eureka.client.backup-registry-impl=
  79. #这是一个短暂的×××的配置，如果最新的×××是稳定的，则可以去除，默认为null
  80. eureka.client.decoder-name=
  81. #这是一个短暂的编码器的配置，如果最新的编码器是稳定的，则可以去除，默认为null
  82. eureka.client.encoder-name=
  83. #是否使用DNS机制去获取服务列表，然后进行通信。默认为false
  84. eureka.client.use-dns-for-fetching-service-urls=false
  85. #获取要查询的DNS名称来获得eureka服务器，此配置只有在eureka服务器ip地址列表是在DNS中才会用到。默认为null
  86. eureka.client.eureka-server-d-n-s-name=
  87. #获取eureka服务器的端口，此配置只有在eureka服务器ip地址列表是在DNS中才会用到。默认为null
  88. eureka.client.eureka-server-port=
  89. #表示eureka注册中心的路径，如果配置为eureka，则为http://x.x.x.x:x/eureka/，在eureka的配置文件中加入此配置表示eureka作为客户端向注册中心注册，从而构成eureka集群。此配置只有在eureka服务器ip地址列表是在DNS中才会用到，默认为null
  90. eureka.client.eureka-server-u-r-l-context=

9.3、instance

  1. #服务注册中心实例的主机名
  2. eureka.instance.hostname=localhost
  3. #注册在Eureka服务中的应用组名
  4. eureka.instance.app-group-name=
  5. #注册在的Eureka服务中的应用名称
  6. eureka.instance.appname=
  7. #该实例注册到服务中心的唯一ID
  8. eureka.instance.instance-id=
  9. #该实例的IP地址
  10. eureka.instance.ip-address=
  11. #该实例，相较于hostname是否优先使用IP
  12. eureka.instance.prefer-ip-address=false
  13. #用于AWS平台自动扩展的与此实例关联的组名，
  14. eureka.instance.a-s-g-name=
  15. #部署此实例的数据中心
  16. eureka.instance.data-center-info=
  17. #默认的地址解析顺序
  18. eureka.instance.default-address-resolution-order=
  19. #该实例的环境配置
  20. eureka.instance.environment=
  21. #初始化该实例，注册到服务中心的初始状态
  22. eureka.instance.initial-status=up
  23. #表明是否只要此实例注册到服务中心，立马就进行通信
  24. eureka.instance.instance-enabled-onit=false
  25. #该服务实例的命名空间,用于查找属性
  26. eureka.instance.namespace=eureka
  27. #该服务实例的子定义元数据，可以被服务中心接受到
  28. eureka.instance.metadata-map.test = test
  29. #服务中心删除此服务实例的等待时间(秒为单位),时间间隔为最后一次服务中心接受到的心跳时间
  30. eureka.instance.lease-expiration-duration-in-seconds=90
  31. #该实例给服务中心发送心跳的间隔时间，用于表明该服务实例可用
  32. eureka.instance.lease-renewal-interval-in-seconds=30
  33. #该实例，注册服务中心，默认打开的通信数量
  34. eureka.instance.registry.default-open-for-traffic-count=1
  35. #每分钟续约次数
  36. eureka.instance.registry.expected-number-of-renews-per-min=1
  37. #该实例健康检查url,绝对路径
  38. eureka.instance.health-check-url=
  39. #该实例健康检查url,相对路径
  40. eureka.instance.health-check-url-path=/health
  41. #该实例的主页url,绝对路径
  42. eureka.instance.home-page-url=
  43. #该实例的主页url,相对路径
  44. eureka.instance.home-page-url-path=/
  45. #该实例的安全健康检查url,绝对路径
  46. eureka.instance.secure-health-check-url=
  47. #https通信端口
  48. eureka.instance.secure-port=443
  49. #https通信端口是否启用
  50. eureka.instance.secure-port-enabled=false
  51. #http通信端口
  52. eureka.instance.non-secure-port=80
  53. #http通信端口是否启用
  54. eureka.instance.non-secure-port-enabled=true
  55. #该实例的安全虚拟主机名称(https)
  56. eureka.instance.secure-virtual-host-name=unknown
  57. #该实例的虚拟主机名称(http)
  58. eureka.instance.virtual-host-name=unknown
  59. #该实例的状态呈现url,绝对路径
  60. eureka.instance.status-page-url=
  61. #该实例的状态呈现url,相对路径
  62. eureka.instance.status-page-url-path=/status

9.4、dashboard

  1. #是否启用Eureka的仪表板。默认为true.
  2. eureka.dashboard.enabled=true
  3. #到Eureka仪表板的服务路径（相对于servlet路径）。默认为“/”
  4. eureka.dashboard.path=/

发表评论

表情：
评论列表 （有 0 条评论，278人围观）

还没有评论，来说两句吧...

相关阅读