新 Spring Cloud (一) 之 Eureka 服务注册中心

最新推荐文章于 2022-11-11 12:43:23 发布

猫吻鱼

最新推荐文章于 2022-11-11 12:43:23 发布

阅读量512

点赞数 1

分类专栏： # Spring Cloud

本文链接：https://blog.csdn.net/qq_36882793/article/details/102676278

版权

Spring Cloud 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

一、前言
二、基本使用实例
三、Eureka高可用
以上：内容部分参考https://www.cnblogs.com/xishuai/p/spring-cloud-eureka-safe.html。如有侵扰，联系删除。内容仅用于自我记录学习使用。如有错误，欢迎指正

一、前言

0. 之前写过两篇Spring Cloud，但是感觉不够具体，所以重新写了一份。

新 SpringCloud (二) 之 Ribbon 负载均衡
 新 Spring Cloud (三) 之 Hystrix熔断保护
 新 Spring Cloud (四) 之 Fegin远程调用
 新 Spring Cloud (五) 之 Zuul 网关

1. SpringCloud

SpringCloud 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、负载均衡、微代理、事件总线、全局锁、决策竞选、分布式会话等等。它运行环境简单，可以在开发人员的电脑上运行。

2. 什么是Eureka

Eureka是Netflix开源的一个RESTful服务，主要用于服务的注册发现。Eureka由两个组件组成：Eureka服务器和Eureka客户端。Eureka服务器用作服务注册服务器。Eureka客户端是一个java客户端，用来简化与服务器的交互、作为轮询负载均衡器，并提供服务的故障切换支持。Netflix在其生产环境中使用的是另外的客户端，它提供基于流量、资源利用率以及出错状态的加权负载均衡。
Eureka的吸引力来源于以下几点：
开源：大家可以对实现一探究竟，甚至修改源码。
可靠：经过Netflix多年的生产环境考验，使用应该比较靠谱省心
功能齐全：不但提供了完整的注册发现服务，还有Ribbon等可以配合使用的服务。
基于Java：对于Java程序员来说，使用起来，心里比较有底。
spring cloud可以使用Spring Cloud, 与Eureka进行了很好的集成，使用起来非常方便。

3. 原理图

在这里插入图片描述

Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

二、基本使用实例

1. 场景介绍 : 滴滴打车服务。

在网约车未出现前，打车的情况是，乘客招手，司机停车载客。这种情况下，乘客和司机是相互暴露的，也就是互相见到面才能打车。
这个场景下，总共有三种角色，滴滴平台（服务注册中心），司机（服务提供方）和乘客（服务消费方）。司机和乘客需要注册滴滴平台，随后如果乘客给滴滴平台发起订单请求，滴滴平台再将订单请求分派给某个司机来完成这单任务。在实际项目中，服务注册中心即是Eureka。

2. 代码实践

首先创建一个项目 SpringCloudEurekaDemo 作为主项目，并删除其src文件夹，为了方便演示就直接创建的模块。下面的SpringCloud的创建，可以通过Spring脚手架搭建，也可以自己手动搭建，这里选择使用脚手架搭建（不为别的，只因为懒。。。）

(1). 创建三个模块框架

EurekaRegistryServer（服务注册中心：滴滴平台）、EurekaServerConsumer(服务消费者：乘客)、EurekaServerProvider（服务提供者：司机）
项目结构图如下：
在这里插入图片描述
通过Spring脚手架搭建一个项目时
EurekaRegistryServer 选择 Eureka Server 引入即可。
EurekaServerConsumer和EurekaServerProvider选择 Spring Web 和 Eureka Discovery Client 引入（不同版本idea可能名字会有所差异）

Eur
上面讲的不够清晰，所以下面贴出三个模块的pom文件

EurekaRegistryServer pom文件

<?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.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.kingfish</groupId>
    <artifactId>springcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springcloud</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.M3</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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </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>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

EurekaServerConsumer pom文件

<?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.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lkingfish</groupId>
    <artifactId>springcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springcloud</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.M3</spring-cloud.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </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>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

EurekaServerProvider pom文件

<?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.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lkingfish</groupId>
    <artifactId>springcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springcloud</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.M3</spring-cloud.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </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>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

(2). 搭建 EurekaRegistryServer

EurekaRegistryServer 作为服务注册中心，承担着如同滴滴平台一样的重任。他是作为一个单独的服务运行的。
搭建这样一个服务注册中心其实很简单

在启动类上加上注解 @EnableEurekaServer 标明当前服务作为一个Eureka服务注册中心。

@SpringBootApplication
@EnableEurekaServer
public class EurekaRegistryServerApplication{

    public static void main(String[] args) {
        SpringApplication.run(EurekaRegistryServerApplication.class, args);
    }

}

配置 yml 文件如下

server:
  port: 10086 # Eureka服务的端口
spring:
  application:
    name: eureka-registety-server # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://127.0.0.1:${server.port}/eureka
    register-with-eureka: true# 是否把自己注册到eureka服务列表,默认true，会将自己本身注册到Eureka中
    fetch-registry: false # 拉取eureka服务信息  指示此客户端是否应从eureka服务器获取eureka注册表信息，注意开启这个时候，在启动Eureka服务的时候会报错,但不影响使用。
  instance:   # 使用自定义ip ，否则在获取服务的时候ip地址会错误
    preferIpAddress: true
    instance-id: ${spring.application.name}:${server.port}

搭建完成，启动项目，访问localhost:10086。看到如下画面即说明成功

补充：
System Status : 系统状态信息
DS Replicas : Eureka集群信息
Instances currently registered with Eureka : 当前注册在Eureka的实例
General Info ： JVM信息
Instance Info ：实例信息

(3). 搭建 EurekaServerProvider

EurekaServerProvider 作为服务提供者，承担着滴滴平台司机的工作。所以这里我们要搭建一个司机服务。其实搭建过程也很简单，和上面的过程基本一致。
1. 启动类上加上注解 @EnableDiscoveryClient

@SpringBootApplication
@EnableDiscoveryClient      // 标志作为一个客户端被发现
public class EurekaServerProviderApplication{
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerProviderApplication.class, args);
    }
}

注：

@EnableDiscoveryClient ： t基于spring-cloud-commons，适用面较广，可以用于eureka，也可以用zookeeper、consul
@EnableEurekaClient ：基于spring-cloud-netflix，顾名思义，仅适用eureka

2. 配置yml文件如下:

server:
  port: 10000 # Eureka服务的端口
spring:
  application:
    name: eureka-server-provider # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://127.0.0.1:10086/eureka
    register-with-eureka: true  # 是否把自己注册到eureka服务列表,默认true，会将自己本身注册到Eureka中
    fetch-registry: true # 拉取eureka服务信息  指示此客户端是否应从eureka服务器获取eureka注册表信息，注意开启这个时候，在启动Eureka服务的时候会报错,但不影响使用。
  instance:   # 使用自定义ip ，否则在获取服务的时候ip地址会错误
    preferIpAddress: true
    instance-id: ${spring.application.name}:${server.port}

3. 上面的配置是将司机服务注册到了滴滴中心（EurekaServerProvder 注册到了 EurekaRegistryServer中）。相当于一个司机在滴滴上注册成为车主了，但是成为车主还不行，我们还要给他增加一个接单功能。创建一个DriverController 如下(port是端口号，别问干嘛用的，反正后面有用)

@RestController
@RequestMapping("driver")
public class DriverController {
    @Value("${server.port}")
    private int port;   // 端口号

    @RequestMapping("takeOrder")
    public String takeOrder(String msg){
        String result = "我是司机" + port + "，我接单了。乘客信息是：" + msg;
        System.out.println(result);
        return result;
    }
}

(4). 搭建 EurekaServerConsumer

和上面的司机服务差不多，我们首先需要在滴滴平台上注册，然后提供打车功能。
1. 启动类上加上注解 @EnableDiscoveryClient

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

2. 配置yml文件如下:

server:
  port: 10010 # Eureka服务的端口
spring:
  application:
    name: eureka-server-consumer # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://127.0.0.1:10086/eureka
    register-with-eureka: true  # 是否把自己注册到eureka服务列表,默认true，会将自己本身注册到Eureka中
    fetch-registry: true # 拉取eureka服务信息  指示此客户端是否应从eureka服务器获取eureka注册表信息，注意开启这个时候，在启动Eureka服务的时候会报错,但不影响使用。
  instance:   # 使用自定义ip ，否则在获取服务的时候ip地址会错误
    preferIpAddress: true
    instance-id: ${spring.application.name}:${server.port}

3. 我们需要调用服务提供者的接口，所以需要注入RestTempalte

@SpringBootApplication
@EnableDiscoveryClient
public class EurekaServerConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerConsumerApplication.class, args);
    }
    // 注入 RestTempalate
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

4. 乘客增加呼叫出租车的接口，创建PassengerController 如下：

@RequestMapping("passenger")
@RestController
public class PassengerController {

    @RequestMapping("callTaxi")
    public String callTaxi(String msg){
        return null;
    }
}

(5) EurekaServerConsumer 调用 EurekaServerProvider 开始打车

启动三个服务，然后通过localhost:10086 可以看到“司机”和“乘客”都注册在“滴滴”了。
在这里插入图片描述
但是这时候我们怎么在 EurekaServerConsumer 中调用EurekaServerProvider的服务呢？
如下，即可，注释写的较为详细。

@RequestMapping("passenger")
@RestController
public class PassengerController {
    @Autowired
    private RestTemplate restTemplate;
    
    @Autowired
    private DiscoveryClient discoveryClient;	// 服务客户端，可以获取到eureka中服务的信息

    @RequestMapping("callTaxi")
    public String callTaxi(String msg) {
        // 从Eureka服务注册中心根据serviceId获取服务实例 - 这里获取司机服务，即 eureka-server-provider
        List<ServiceInstance> instances = discoveryClient.getInstances("eureka-server-provider");
        // 我们当前只有一个司机实例，所以获取第一个
        ServiceInstance serviceInstance = instances.get(0);
        // 拼接url
        String url = "http://" + serviceInstance.getHost() + ":"+ serviceInstance.getPort() + "/driver/takeOrder";
        MultiValueMap<String,String> multiValueMap =  new LinkedMultiValueMap<String,String>();
        multiValueMap.add("msg", msg);
        // 访问url
        String result = restTemplate.postForObject(url, multiValueMap, String.class);
        System.out.println(result);
        return result;
    }
}

我们访问 http://localhost:10010/passenger/callTaxi，可以看到如下结果，说明成功：
在这里插入图片描述

三、Eureka高可用

上面的例子中，我们有一个服务注册中心（EurekaRegistryServer）,一个乘客（EurekaServerConsumer），一个司机（EurekaServerProvider），这样就确保我们的服务正常工作了。
但是如果我们的服务注册中心挂掉了，那么整个系统就不可用了，所以我们认为如果我们这个服务注册中心挂掉之后，整个服务不可用。

注：服务注册中心挂掉了后，其实已注册的客户端还可以访问，但那是读取的客户端缓存，如果司机更换了手机号（服务名称、ip地址等各种信息）是无法更新到乘客端的，同样乘客也无法更新，并且不能有新的客户注册等局限性，所以我们仍认为整个系统不可用。这时候，我们就会想，如果Eureka服务注册中心可以作为一个集群，形成高可用的Eurake中心。
Eureka 支持服务同步，即多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。不就可以有效降低这种风险了吗。
那么，我们假设，现在有两个EurakeRegistryServer，即两个滴滴注册中心，一个端口10086，一个端口10087。
那么我们要做的第一步，首先要再创建一个EurakeRegistryServer:10087

服务名	端口
EurakeRegistryServer(服务注册中心)	10086
EurakeRegistryServer(服务注册中心)	10087
EurekaServerProvider(服务提供者)	10000
EurekaServerConsumer(服务服务消费者)	10010

1. EurakeRegistryServer (Eureka服务注册中心)

1. 搭建10087端口的EurakeRegistryServer

因为idea默认无法同时启动两个相同服务，所以需要我们操作一番。
在这里插入图片描述
添加一个Springboot启动项

设置名称和启动类

然后我们就添加成功了一个启动项。

2. 进行高可用配置

因为我们部署了两个服务注册中心，所以修改一下服务消费者（EurekaServerConsumer）和服务提供者（EurekaServerProvider）的yml文件，加上我们新加的服务注册中心地址，让我们的服务再10086端口和10087端口都注册一下。这样在10086端口服务挂掉后，可以通过10087端口的服务继续运行。
修改EurakeRegistryServer 服务10086端口yml配置文件如下，将10087端口地址配置到defaultZone中。随后启动10086端口的启动器

server:
  port: 10086 # Eureka服务的端口
spring:
  application:
    name: eureka-registety-server # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://127.0.0.1:10087/eureka
    register-with-eureka: true  # 是否把自己注册到eureka服务列表,默认true，会将自己本身注册到Eureka中
    fetch-registry: false # 拉取eureka服务信息  指示此客户端是否应从eureka服务器获取eureka注册表信息，注意开启这个时候，在启动Eureka服务的时候会报错,但不影响使用。
  instance:   # 使用自定义ip ，否则在获取服务的时候ip地址会错误
    preferIpAddress: true
    instance-id: ${spring.application.name}:${server.port}

修改EurakeRegistryServer 服务yml文件如下，随后启动10087端口启动器

server:
  port: 10087 # Eureka服务的端口
spring:
  application:
    name: eureka-registety-server # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://127.0.0.1:10086/eureka
    register-with-eureka: true  # 是否把自己注册到eureka服务列表,默认true，会将自己本身注册到Eureka中
    fetch-registry: false # 拉取eureka服务信息  指示此客户端是否应从eureka服务器获取eureka注册表信息，注意开启这个时候，在启动Eureka服务的时候会报错,但不影响使用。
  instance:   # 使用自定义ip ，否则在获取服务的时候ip地址会错误
    preferIpAddress: true
    instance-id: ${spring.application.name}:${server.port}

随后访问http://localhost:10087、http://localhost:10086 ，都可看到如下画面。启动的时候可能会报Cannot execute request on any known server 这是正常的，启动10086的时候，10087端口的服务还么启动（因为先启动的端口会找后启动端口的服务，但是后启动的服务还没启动）。
搭建完毕。可能大家还没有什么感觉。我们举个例子来演示一下。
1. 首先，将刚才所有的配置改回来。。。。
2. 启动服务注册中心，启动服务提供者，启动服务消费者。
3. 然后访问：http://localhost:10010/passenger/callTaxi。发现可以正常访问（这是当然的了，刚搭建的）
4. 我们关闭服务注册中心，重启服务提供者，服务消费者。（为什么要重启，因为Eurake客户端的列表被缓存在客户端的内存中，所以重启清除缓存）。然后再访问http://localhost:10010/passenger/callTaxi。哎！访问不了了（又是废话）
5. 这时候再把配置改成高可用的yml配置，同时启动10086端口，10087端口，服务消费者，服务提供者的服务。访问http://localhost:10010/passenger/callTaxi。没问题。
6. 关闭10086端口服务，重启服务提供者，服务消费者。访问http://localhost:10010/passenger/callTaxi。发现可以访问
7. 因为10086服务挂掉后，客户端会三次重试失败后会去找下一个地址，即10087端口的地址，而10087端口也有完整的服务注册信息，所以可以继续完成任务。

3. EurakeServerProvider（服务提供者）

服务提供者在启动时，会检测配置属性中的：eureka.client.register-with-eureka=true参数是否正确，事实上默认就是true。如果值确实为true，则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息，Eureka Server会把这些信息保存到一个双层Map结构中。eureka.client.register-with-eureka 指示着此实例是否应将其信息注册到eureka服务器以供他人发现在某些情况下。简单来说，就是标志着是否将自己注册到Eureka注册中心去。

第一层Map的Key就是服务id，一般是配置中的spring.application.name属性
第二层Map的key是服务的实例id。一般host+ serviceId + port，例如：locahost:service-provider:8081。值则是服务的实例对象，也就是说一个服务，可以同时启动多个不同实例，形成集群。

在注册服务完成以后，服务提供者会维持一个心跳（定时向EurekaServer发起Rest请求），告诉EurekaServer：“我还活着”。这个我们称为服务的续约（renew）；

eureka:
  instance:
    lease-expiration-duration-in-seconds: 90	// 服务失效时间，默认值90秒
    lease-renewal-interval-in-seconds: 30	    // 服务续约(renew 心跳)的间隔，默认为30秒

也就是说，默认情况下每个30秒服务会向注册中心发送一次心跳，证明自己还活着。如果超过90秒没有发送心跳，EurekaServer就会认为该服务宕机，会从服务列表中移除，这两个值在生产环境不要修改，默认即可。

4. EurakeServerConsumer（服务消费者）

当服务消费者启动时，会检测 eureka.client.fetch-registry=true 参数的值，如果为true，则会拉取Eureka Server服务的列表只读备份，然后缓存在本地。并且每隔30秒会重新获取并更新数据。我们可以通过下面的参数来修改：

eureka:
  client:
    registry-fetch-interval-seconds: 5		// 为了更加实时更新，可以改更小一点

5. 失效剔除和自我保护

1. 服务下线
当服务进行正常关闭操作时，它会触发一个服务下线的REST请求给Eureka Server，告诉服务注册中心：“我要下线了”。服务中心接受到请求之后，将该服务置为下线状态。

2. 失效剔除
有些时候，我们的服务提供方并不一定会正常下线，可能因为内存溢出、网络故障等原因导致服务无法正常工作。EurekaRegistryServer （服务注册中心） 需要将这样的服务剔除出服务列表。因此它会开启一个定时任务，每隔60秒对所有失效的服务（超过90秒未响应）进行剔除。
可以通过eureka.server.eviction-interval-timer-in-ms参数对其进行修改，单位是毫秒，生产环境不要修改。
这个会对我们开发带来极大的不变，你对服务重启，隔了60秒Eureka才反应过来。

3. 自我保护
我们关停一个服务，就会在Eureka面板看到如下一条警告：
在这里插入图片描述
这是触发了Eureka的自我保护机制。
Eureka在运行期间会统计心跳失败的比例，在15分钟内是否低于85%,如果出现了低于的情况，Eureka Server会将当前的实例注册信息保护起来，同时提示一个警告，一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据，也就是不会注销任何微服务。
在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。Eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下这很有效，保证了大多数服务依然可用。
可以通过下面的配置关闭或者开启自我保护。

eureka:
  server:
    enable-self-preservation: false # 关闭自我保护模式（缺省为打开）
    eviction-interval-timer-in-ms: 1000 # 扫描失效服务的间隔时间（缺省为60*1000ms）

注：对服务客户端来说，设置心跳时间，当超过这个时间后会被认定无效，等下一次注册中心扫描后，会将无效客户端剔除。

我们在单机测试的时候很容易满足心跳失败比例在 15 分钟之内低于 85%，这个时候就会触发 Eureka 的保护机制，一旦开启了保护机制，则服务注册中心维护的服务实例就不是那么准确了，此时我们可以使用eureka.server.enable-self-preservation=false来关闭保护机制，这样可以确保注册中心中不可用的实例被及时的剔除（不推荐）。

自我保护模式被激活的条件是：在 1 分钟后，Renews (last min) < Renews threshold。
在这里插入图片描述
这两个参数的意思：

Renews threshold：Eureka Server 期望每分钟收到客户端实例续约的总数。
Renews (last min)：Eureka Server 最后 1 分钟收到客户端实例续约的总数。

以上：内容部分参考https://www.cnblogs.com/xishuai/p/spring-cloud-eureka-safe.html。如有侵扰，联系删除。内容仅用于自我记录学习使用。如有错误，欢迎指正

猫吻鱼

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
新 Spring Cloud (一) 之 Eureka 服务注册中心

文章目录一、前言1. SpringCloud2. 服务提供者与消费关系3. 什么是Eureka4. 原理二、基本使用实例1. 场景介绍 : 滴滴打车服务。2. 代码实践(1). 首先需要搭建一个滴滴服务平台（Eurake 服务注册中心SpringCloudEurakeServer）(2). 搭建一个司机服务（服务提供方SpringCloudEurakeServerProvider）和一个乘客服务（...
复制链接

扫一扫