SpringCloud五大基本组件详解之Eureka注册中心（一）

最新推荐文章于 2023-02-22 14:39:53 发布

只陪你

最新推荐文章于 2023-02-22 14:39:53 发布

阅读量408

点赞数 1

文章标签：分布式 eureka

本文链接：https://blog.csdn.net/weixin_46403305/article/details/107631333

版权

1.Eureka注册中心

1.简介

Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST服务，用于定位服务，以实现云端中间层服务发现和故障转移。服务注册与发现对于微服务架构来说是非常重要的，有了服务发现与注册，只需要用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了。功能类似于dubbo的注册中心，比如Zookeeper。

2.Eureka的基本架构

1-Eureka

Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址

2-提供者

提供者：启动后向Eureka注册自己信息（地址，提供什么服务）

3-消费者

消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新

4-心跳

心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

5.EurekaServer(注册中心)

EurekaServer作为一个独立的部署单元，以RESTAPI的形式为服务实例提供了注册、管理和查询等操作。同时，EurekaServer也为我们提供了可视化的监控页面，可以直观地看到各个EurekaServer当前的运行状态和所有已注册服务的情况。

6.EurekaClient(客户端)

●服务注册：

启动时，会调用服务注册方法，向 EurekaServer 注册自己的信息。

EurekaServer 会维护一个已注册服务的列表。当实例状态发生变化时（如自身检测认为Down的时候），也会向EurekaServer更新自己的服务状态，同时用 replicateToPeers() 向其它EurekaServer节点做状态同步。

●续约与剔除：

服务实例启动后，会周期性地向 EurekaServer 发送心跳以续约自己的信息，避免自己的注册信息被剔除。续约的方式与服务注册基本一致，首先更新自身状态，再同步到其它Peer。如果EurekaServer在一段时间内没有接收到某个微服务节点的心跳， EurekaServer 将会注销该微服务节点（自我保护模式除外）。

●服务消费：

ServiceConsumer 本质上也是一个 EurekaClient 。它启动后，会从 EurekaServer 上获取所有实例的注册信息，包括IP地址、端口等，并缓存到本地。这些信息默认每30秒更新一次。前文提到过，如果与 EurekaServer 通信中断， ServiceConsumer 仍然可以通过本地缓存与 ServiceProvider 通信。

3.Eureka项目的构建

1.导包

<!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>2.0.0.RELEASE</version>
        </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>

2.编写application.properties文件

server.port=7001
spring.application.name=eureka-server-7001
eureka.instance.hostname=eureka7001.com
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka

3.编写启动类

@SpringBootApplication
@EnableEurekaServer    //使能这个Eureka服务端
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class,args);
    }
}

4.将生产者注册到Eureka中

4.1导包

<!-- Eureka客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.0.0.RELEASE</version>
        </dependency>

4.2编写启动类使能

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

4.3 编写application.properties文件

# 应用名称
spring.application.name=springcloud-demo-service
# EurekaServer地址
eureka.client.service-url.defaultZone=http://127.0.0.1:7001/eureka
# 当调用getHostname获取实例的hostname时，返回ip而不是host名称
eureka.instance.prefer-ip-address=true
# 指定自己的ip信息，不指定的话会自己寻找
eureka.instance.ip-address=127.0.0.1

5.消费者从Eureka获取服务

5.1导包

<!-- Eureka客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

5.2编写启动类使能

@SpringBootApplication
@EnableDiscoveryClient // 开启EurekaClient功能
public class SpringcloudDemoConsumerApplication {
	public static void main(String[] args) {
		SpringApplication.run(SpringcloudDemoConsumerApplication.class, args);
	}
}

5.3编写application.properties文件

spring.application.name=springcloud-demo-consumer
# EurekaServer地址
eureka.client.service-url.defaultZone=http://127.0.0.1:7001/eureka
# 当调用getHostname获取实例的hostname时，返回ip而不是host名称
eureka.instance.prefer-ip-address=true
# 指定自己的ip信息，不指定的话会自己寻找
eureka.instance.ip-address=127.0.0.1

5.4编写controller

@RestController
@RequestMapping("consumer")
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient client;// Eureka客户端，可以获取到服务实例信息

    @RequestMapping("/test")
    public List<User> consumerTest(){
        List<String>list=client.getServices();
        System.out.println("*服务列表*"+list);
        List<ServiceInstance> srvList=client.getInstances("springcloud-demo-service");
        for(ServiceInstance element:srvList){
            System.out.println(element.getServiceId()+"\t"+element.getHost()+"\t"+element.getPort()+"\t" +element.getUri());
        }
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = srvList.get(0);

        // 获取ip和端口信息
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/all";
        System.out.println("访问地址:"+baseUrl);

        return this.restTemplate.getForObject(baseUrl,List.class);
    }
}

4.Eureka基础架构

Eureka架构中的三个核心角色：

服务注册中心
Eureka的服务端应用，提供服务注册和发现功能，就是刚刚我们建立的eureka-server-7001
服务提供者
提供服务的应用，可以是SpringBoot应用，也可以是其它任意技术实现，只要对外提供的是Rest风格服务即可。本例中就是我们实现的springcloud-demo
服务消费者
消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。本例中就是我们实现的springcloud-demo-consumer

5.高可用的Eureka Server

Eureka Server即服务的注册中心，在刚才的案例中，我们只有一个EurekaServer，事实EurekaServer也可以是一个集群，形成高可用的Eureka中心。

Eureka Server除了单点运行之外，还可以通过运行多个实例，并进行互相注册的方式来实现高可用的部署。所以我们只需要将Eureke Server配置其他可用的 serviceUrl 就能实现高可用部署。

服务同步

多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。

动手搭建高可用的EurekaServer

我们假设要搭建两条EurekaServer的集群，端口分别为：7001、7002、7003

1）我们修改原来的EurekaServer配置-7001：

server:
  port: 7001 # 端口
spring:
  application:
    name: eureka-server-7001 # 应用名称，会在Eureka中显示

eureka:
  instance:
    hostname: eureka7001.com
  client:
    register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
    fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka

所谓的高可用注册中心，其实就是把EurekaServer自己也作为一个服务进行注册，这样多个EurekaServer之间就能互相发现对方，从而形成集群。因此我们做了以下修改：

把service-url的值改成了另外一台EurekaServer的地址，而不是自己

2）我们修改原来的EurekaServer配置-7002：

server:
  port: 7002 # 端口
spring:
  application:
    name: eureka-server-7002 # 应用名称，会在Eureka中显示
eureka:
  instance:
    hostname: eureka7002.com
  client:
    register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
    fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7003.com:7003/eureka

3）我们修改原来的EurekaServer配置-7003：

server:
  port: 7003 # 端口
spring:
  application:
    name: eureka-server-7003 # 应用名称，会在Eureka中显示
eureka:
  instance:
    hostname: eureka7003.com
  client:
    register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
    fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

4）在自己的hosts中加入端口映射

127.0.0.1       eureka7001.com
127.0.0.1       eureka7002.com
127.0.0.1       eureka7003.com

c:\windows\system32\drivers\etc\hosts

5）启动测试

注意：idea中一个应用不能启动两次，我们需要重新配置一个启动器：

然后启动即可。

6）springcloud-demo集群版，客户端注册服务到集群

因为EurekaServer不止一个，因此注册服务的时候，service-url参数需要变化：

# EurekaServer地址
eureka.client.service-url.defaultZone= http:// eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka

7）测试服务是否注册

6.什么是Eureka保护机制

官方解释：自我保护模式正是一种针对网络异常波动的安全保护措施，使用自我保护模式能使Eureka集群更加的健壮、稳定的运行。

默认情况下，Eureka Client会定时的向 Eureka Server端发送心跳包，默认是30s发送一次，目的是告诉 Eureka Server当前客户端实例还处于存活状态，如果Eureka server在一定时间内没有收到实例的心跳，便会把该实例从注册表中删除（默认是90秒）,但是，如果短时间内丢失大量的实例心跳，便会触发Eureka server的自我保护机制的 ,默认自我保护机制处于开启状态，比如在开发测试时，需要频繁地重启微服务实例客户端，但是我们很少会把eureka server一起重启（因为在开发过程中不会修改eureka注册中心），当一分钟内收到的心跳数大量减少时，会触发该保护机制。可以在eureka管理界面看到Renews threshold和Renews(last min)，当Renews(last min)（最后一分钟收到的心跳数）小于Renews threshold（心跳阈值）的时候，如果某个服务实例宕机掉，触发保护机制，会出现红色的警告：

5.1.为什么要自我保护

因为同时保留"好数据"与"坏数据"总比丢掉任何数据要更好，当网络故障恢复后，这个 Eureka 节点会退出"自我保护模式"。

当一个服务未按时进行心跳续约时，在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。Eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下这很有效，保证了大多数服务依然可用。

为了防止在一定时间内，Eureka Client与Eureka Server在网络不同的情况下，Eureka Server误将Eureka Client服务剔除，这个机制是为了对服务进行保护；

5.2.如何关闭Eureka自我保护机制

Eureka自我保护机制默认是开启的，如果如果需要关闭自我保护机制，按照下述方式： enable-self-preservation: false 开关关闭掉，然后修改客户端和服务端相关参数，保证异常服务能及时剔除；

3.1.Eureka Server配置

注册中心关闭自我保护机制，修改检查失效服务的时间，以确保注册中心将不可用的实例及时正确剔除

yml:

#Eureka自我保护机制
server:
  #关闭eureka自我保护机制false（默认为true）
  enable-self-preservation: false
  # 配置Eureka Server清理无效节点的时间间隔（单位毫秒，默认60*1000毫秒,即60秒）
  eviction-interval-timer-in-ms: 2000

#关闭自我保护:true 为开启自我保护，false 为关闭自我保护
eureka.server.enableSelfPreservation=false
#清理间隔(单位:毫秒，默认是 60*1000)
eureka.server.eviction.interval-timer-in-ms=2000

然后启动server和服务，观察关闭服务前后的变化

3.2.Eureka Client配置

减短客户端服务发送服务心跳给服务端的时间，在开发测试时，将值设置设置小些，保证服务关闭后注册中心能及时踢出服务

eureka:
  instance:
    #eureka服务端在接受到实例的最后一次发出的心跳后，需要等待多久才可以将此删除，单位为秒（默认为90s），超过时间则剔除（客户端会按照此规则向Eureka服务端发送心跳检测包）
    lease-expiration-duration-in-seconds: 90
    #eureka客户端需要多长时间发送心跳给eureka服务端，单位为秒（默认为30s）,（客户端会按照此规则向Eureka服务端发送心跳检测包）
    lease-renewal-interval-in-seconds: 2

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

获取服务列表

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

eureka:
  client:
    #表示eureka client间隔多久去拉取服务器注册信息,默认为30秒
    registry-fetch-interval-seconds: 5

生产环境中，我们不需要修改这个值。

但是为了开发环境下，能够快速得到服务的最新状态，我们可以将其设置小一点。

5.3开启和关闭Eureka保护机制的场景

4.1.开发环境关闭

当我们在使用微服务框架做项目开发的时候，如果注册中心是Eureka，因为会频繁的重启本地开发环境，调试和修改代码，但是不会频繁的重启Eureka Server，所以建议在测试环境、本地开发环境时关闭Eureka的自我保护机制，，如果触发了保护机制，则旧的服务实例没有被删除，这时请求有可能跑到旧的实例中，而该实例已经关闭了，这就导致请求错误，影响开发测试效率；

4.2.生产环境开启

Linux—>Docker容器化部署—>K8S

在微服务各个节点部署到生产环境了之后，建议开启Eureka自我保护环境，这一点还是比较重要的，因为在生产环境，并不会频繁的重启，而且有时在短时间内可能会发生服务与服务之间网络故障、重启Eureka Client客户端服务实例等其他原因导致通讯中断，所以一定要把自我保护机制打开，否则网络一旦终端，就无法恢复，导致误删除服务节点，造成生产故障；

7.优雅的关闭自我保护

由于eureka的自我保护机制，直接对服务进行停止会使得eureka serve进入自我保护模式。服务并不会从列表中删除。

1.不需要再 Eureka Server 中配置关闭自我保护

首先将服务开启自我保护

然后让对应的服务具有优雅停服的功能，比如provider服务

2.需要再服务中添加 actuator.jar 包

需要添加actuator的jar包，只需要将pom文件改成

<!--监控依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

注意actuator的依赖在spring-cloud-starter-eureka-server中，所以我们要将Eureka的依赖修改为此

application.yml全局配置文件添加如下

management:
  endpoints:
    web:
      exposure:
        include: shutdown #暴漏shutdown端点服务
  endpoint:
    shutdown:
      enabled: true

3.启动服务

然后在postman里边用post请求方式，请求如下地址

http://ip:port/actuator/shutdown

4.发送一个关闭服务的 URL 请求

我们也可以通过HttpClient来发送一个停止服务的请求

<dependency>
   <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.8</version>
</dependency>

创建一个java类

/**
 * @program: springcloud-eureka-consumer
 * @description: httpClient工具类
 */
public class HttpClientUtil {
    public static String doGet(String url, Map<String, String> param) {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return resultString;
    }

    public static String doGet(String url) {
        return doGet(url, null);
    }

    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }

    public static String doPostJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static void main(String[] args) {
        String url = "http://127.0.0.1:8080/actuator/shutdown";
        //该url必须要使用dopost方式来发送
        HttpClientUtil.doPost(url);
    }
}

执行main方法，观察服务提供者及注册中心注册的服务

服务端的服务被停止了