SpringCloud (二) --------- Eureka 注册中心

最新推荐文章于 2022-08-30 11:12:22 发布

在森林中麋了鹿

最新推荐文章于 2022-08-30 11:12:22 发布

阅读量947

点赞数

分类专栏： SpringCloud 文章标签： springcloud

本文链接：https://blog.csdn.net/m0_51111980/article/details/124415360

版权

SpringCloud 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、服务消费方直接调用服务提供方
- 1. 服务提供者
- 2. 服务消费者
二、服务注册与发现
三、搭建与配置 Eureka 服务注册中心
四、向 Eureka 服务注册中心注册服务
五、从 Eureka 服务注册中心发现与消费服务
六、Eureka 与 Zookeeper 的比较
七、Eureka 注册中心高可用集群说明
八、Eureka 注册中心高可用集群搭建
九、Eureka 注册中心高可用集群测试
十、Eureka 集群注册中心打包发布
十一、Eureka 服务注册中心自我保护机制

一、服务消费方直接调用服务提供方

1. 服务提供者

我们知道，SpringCloud 构建微服务是基于 SpringBoot 开发的。

1、创建一个 SpringBoot 工程，并且添加 SpringBoot 的相关依赖。

2、创建服务提供者的访问方法，也就是后续消费者如何访问提供者。

Spring Cloud 是基于 rest 的访问，所以我们添加一个 Controller，在该 Controller 中提供一个访问入口。

@RestController
public class GoodsController {
   @Autowired
   private GoodsService goodsService;
   
   //工程中, 常常使用 ResultObject 类或者 Msg 类作为通用返回类型
   @GetMapping("/service/goods")
   public ResultObject goods(Model model) {
       List<Goods> goodsList = goodsService.getAllGoods();
       return new ResultObject(Constant.ZERO, "查询成功", goodsList);
   }
}

3、启动运行该 SpringBoot 程序，访问该 controller

2. 服务消费者

服务消费者也是一个 SpringBoot 项目，服务消费者主要用来消费服务提供者提供的服务。

1、创建一个 SpringBoot 工程，并且添加 SpringBoot 的相关依赖。

2、开发一个消费者方法，去消费服务提供者提供的服务，这个消费者方法也是。

一个 Controller:

@RequestMapping("/cloud/goods")
@ResponseBody 
public Object goods(Model model) {

   ResponseEntity<ResultObject> responseEntity = restTemplate.getForEntity("http://localhost:8081/service/goods", ResultObject.class);
   int statusCodeValue = responseEntity.getStatusCodeValue();
   HttpStatus httpStatus = responseEntity.getStatusCode();
   HttpHeaders httpHeaders = responseEntity.getHeaders();
   ResultObject body = responseEntity.getBody();
   
   System.out.println(statusCodeValue);
   System.out.println(httpStatus);
   System.out.println(httpHeaders);
   System.out.println(body);
    
   model.addAttribute("goodsList", body.getData());
   return body;
}

3、启动该 SpringBoot 程序，测试服务消费者调用服务提供者。

补充：什么是 RestTemplate ?

RestTemplate 是从 Spring3.0 开始支持的一个 HTTP 请求工具，它提供了常见的REST请求方案的模版，例如 GET 请求、POST 请求、PUT 请求、DELETE 请求以及一些通用的请求执行方法 exchange 以及 execute。RestTemplate 继承自 InterceptingHttpAccessor 并且实现了 RestOperations 接口，其中 RestOperations 接口定义了基本的 RESTful 操作，这些操作在 RestTemplate 中都得到了实现。我们在 Spring Cloud 中利用这个对象来访问服务提供者。

二、服务注册与发现

前面的例子，是通过手动指定每个服务来实现调用的，这是相当低效的，当服务接口增多，这种手动指定接口地址的方式变得非常难以维护，Spring Cloud 提供了多种服务注册与发现的实现方式，例如：Eureka、Consul、Zookeeper。

Spring Cloud 支持得最好的是 Eureka，其次是 Consul，再次是 Zookeeper。

什么是服务注册？

服务注册：将服务所在主机、端口、版本号、通信协议等信息登记到注册中心上。

什么是服务发现？

服务发现：服务消费者向注册中心请求已经登记的服务列表，然后得到某个服务的主机、端口、版本号、通信协议等信息，从而实现对具体服务的调用。

Eureka 是什么？

Eureka 是 Netflix 的子模块之一，也是一个核心的模块，Eureka 采用了 C-S (客户端/服务端) 的设计架构，也就是 Eureka 由两个组件组成：Eureka 服务端和 Eureka 客户端。

Eureka Server (一个独立的项目) 用于注册服务以及实现服务的负载平衡和故障转移，它是服务的注册中心，Eureka Client (我们的微服务) 它是用于与 Eureka Server 交互，获取其上注册的服务，使得交互变得非常简单，只需要通过服务标识符即可拿到服务。

Eureka 与spring-cloud的关系：

Eureka 是 Netflix 公司开发的 (一家做版权视频和云服务的公司) ，Spring Cloud 封装了Netflix 公司开发的 Eureka 模块来实现服务注册和发现，也就是说 Spring Cloud 对 Netflix Eureka 做了二次封装。

在这里插入图片描述

三、搭建与配置 Eureka 服务注册中心

Spring Cloud 要使用 Eureka 注册中心非常简单和方便，Spring Cloud 中的 Eureka 服务注册中心实际上也是一个 Spring Boot 工程，我们只需通过引入相关依赖和注解配置就能让Spring Boot 构建的微服务应用轻松地与 Eureka 进行整合。

具体步骤如下：

A、创建一个 SpringBoot 项目，并且添加 SpringBoot 的相关依赖

项目名为 springcloud-service-eureka

在这里插入图片描述

B、添加 eureka 的依赖

<!--Spring Cloud 的 eureka-server 起步依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

要想 eureka 被识别，必须添加 Maven 依赖管理器

<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>

C、在 Spring Boot 的入口类上添加一个 @EnableEurekaServer 注解

用于开启 Eureka 注册中心服务端

在这里插入图片描述

D、在 application.properties 文件中配置 Eureka 服务注册中心信息

#内嵌定时tomcat的端口
server.port=8761
#设置该服务注册中心的hostname
eureka.instance.hostname=localhost
#由于我们目前创建的应用是一个服务注册中心，而不是普通的应用，默认情况下，这个应用会向注册中心（也是它自己）注册它自己，设置为false表示禁止这种自己向自己注册的默认行为
eureka.client.register-with-eureka=false
#表示不去从服务端检索其他服务信息，因为自己就是服务端，服务注册中心本身的职责就是维护服务实例，它不需要去检索其他服务
eureka.client.fetch-registry=false
#指定服务注册中心的位置
eureka.client.service-url.defaultZone=http://localhost:8761/eureka

E、启动与测试 Eureka 服务注册中心

1、完成上面的项目搭建后，我们就可以启动 SpringBoot 程序，main 方法运行

2、启动成功之后，通过在浏览器地址栏访问我们的注册中心

在这里插入图片描述
注意地址栏输入的是： http://localhost:8761/

在这里插入图片描述

四、向 Eureka 服务注册中心注册服务

A、新建服务提供者项目

项目名为 springboot-server-eureka

在这里插入图片描述

B、在该服务提供者中添加 eureka 的依赖

因为服务提供者向注册中心注册服务，需要连接 eureka，所以需要 eureka 客户端的支持

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

<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>

C、激活 Eureka 中的 EnableEurekaClient 功能

在 Spring Boot 的入口函数处，通过添加 @EnableEurekaClient 注解来表明自己是一个 eureka 客户端，让我的服务提供者可以连接 eureka 注册中心。

在这里插入图片描述

D、配置服务名称和注册中心地址

#每间隔2s，向服务端发送一次心跳，证明自己依然"存活"
eureka.instance.lease-renewal-interval-in-seconds=2
#告诉服务端，如果我10s之内没有给你发心跳，就代表我故障了，将我踢出掉
eureka.instance.lease-expiration-duration-in-seconds=10
#告诉服务端，服务实例以IP作为链接，而不是取机器名
eureka.instance.prefer-ip-address=true
#告诉服务端，服务实例的名字(主机名)
eureka.instance.instance-id=springboot-server-eureka
#指定消费名称任意取值, 这个名称将在服务消费者时被调用
spring.application.name=provider
#eureka注册中心的连接地址
eureka.client.service-url.defaultZone=http://localhost:8761/eureka
#指定tomcat端口号防止与其他tomcat冲突
server.port=8081

上面我们主要用到的：
spring.application.name=provider
eureka.client.service-url.defaultZone=http://localhost:8761/eureka
server.port=8081
通常只需要配置这三个就行了

E、编写 Controller 类

package com.fancy.springbootservereureka.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @GetMapping("/test")
    public String test() {
        return "使用Eureka服务提供者-----";
    }
}

F、启动服务提供者 SpringBoot 程序的 main 方法运行

G、启动运行之后，通过在浏览器地址栏访问我们之前搭建好的 eureka 注册中心

可以看到有一个服务已经注册成功了

在这里插入图片描述

五、从 Eureka 服务注册中心发现与消费服务

我们已经搭建一个服务注册中心，同时也向这个服务注册中心注册了服务，接下来我们就可以发现和消费服务了，这其中服务的发现由 eureka 客户端实现，而服务的消费由 Ribbon 实现，也就是说服务的调用需要 eureka 客户端和 Ribbon，两者配合起来才能实现。

Eureka 客户端是一个 Java 客户端，用来连接 Eureka 服务端，与服务端进行交互、负载均衡、服务的故障切换等。

Ribbon 是一个基于 HTTP 和 TCP 的客户端负载均衡器，当使用 Ribbon 对服务进行访问的时候，它会扩展 Eureka 客户端的服务发现功能，实现从Eureka 注册中心中获取服务端列表，并通过 Eureka 客户端来确定服务端是否己经启动。 Ribbon 在 Eureka 客户端服务发现的基础上，实现了对服务实例的选择策略，从而实现对服务的负载均衡消费。

接下来我们来让服务消费者去消费服务：

我们前面搭建了服务消费者项目，接下来我们就可以使用该服务消费者通过注册中心去调用服务提供者，步骤如下：

A、创建服务消费者项目

项目名 springboot-consumer-eureka

在这里插入图片描述

B、在该消费者项目中添加 eureka 的依赖

因为服务消费者从注册中心获取服务，需要连接 eureka，所以需要 eureka 客户端的支持。

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

<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>

C、激活 Eureka 中的 EnableEurekaClient 功能

在 Spring Boot 的入口函数处，通过添加 @EnableEurekaClient 注解来表明自己是一个eureka 客户端，让我的服务消费者可以使用 eureka 注册中心。

在这里插入图片描述
D、配置服务的名称和注册中心的地址

#每间隔2s，向服务端发送一次心跳，证明自己依然"存活"
eureka.instance.lease-renewal-interval-in-seconds=2
#告诉服务端，如果我10s之内没有给你发心跳，就代表我故障了，将我踢出掉
eureka.instance.lease-expiration-duration-in-seconds=10
#告诉服务端，服务实例以IP作为链接，而不是取机器名
eureka.instance.prefer-ip-address=true
#告诉服务端，服务实例的名字(主机名)
eureka.instance.instance-id=springboot-consumer-eureka
#指定消费名称任意取值, 这个名称将在服务消费者时被调用
spring.application.name=consumer
#eureka注册中心的连接地址
eureka.client.service-url.defaultZone=http://localhost:8761/eureka
#指定tomcat端口号防止与其他tomcat冲突
server.port=8082

上面我们主要用到的：
spring.application.name=consumer
eureka.client.service-url.defaultZone=http://localhost:8761/eureka
server.port=8082
通常只需要配置这三个就行了

E、Ribbon 调用服务

前面我介绍了服务的发现由 eureka 客户端实现，而服务的真正调用由 ribbon实现，所以我们需要在调用服务提供者时使用 ribbon 来调用。

package com.fancy.springbootconsumereureka.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @LoadBalanced 
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@LoadBalanced 注解用于标记当前的 RestTemplate 使用 Ribbon 的负载均衡访问服务提供者，当使用了 Eureka 注册中心后必须使用这个注解否则无法正常获取服务。默认情况 Ribbon 负载均衡策略是轮询的。

加入了 ribbon 的支持，那么在调用时，即可改为使用服务名称来访问：
restTemplate.getForEntity("http://provider/test", String.class).getBody();

E、完成 controller 类

package com.fancy.springbootconsumereureka.controller;

import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
public class TestController {

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/test")
    public String test() {

        ResponseEntity<String> result = restTemplate.getForEntity("http://provider/test", String.class);
        String body = result.getBody();
        return "使用了 Eureka 的服务消费者 ------- " + body;
    }
}

F、完成上面的步骤后，我们就可以启动消费者的 SpringBoot 程序，main 方法运行

在这里插入图片描述

G、启动成功之后，通过在浏览器地址栏访问我们的消费者，看是否可以正常调用远程服务提供者提供的服务

在这里插入图片描述

六、Eureka 与 Zookeeper 的比较

著名的 CAP 理论指出，一个分布式系统不可能同时满足 C(一致性)、A(可用性) 和 P(分区容错性)。由于分区容错性在是分布式系统中必须要保证的，因此我们只能在 A 和 C 之间进行权衡，在此 Zookeeper 保证的是 CP, 而 Eureka 则是 AP。

P 全称：Partition Tolerance （分区容忍）

主要是指网络问题，比如：A 、B、C 三台机器之间相互 ping 不通、网络不通，这种情况在分布式系统里面是允许的，也是很有可能发生的，我们要容忍这种情况的出现，在这种情况出现的时候，我们是选择 “一致性的C” 还是选择 “可用性的A”，就看应用场景。

Zookeeper 保证 CP

在 ZooKeeper 中，当 master 节点因为网络故障与其他节点失去联系时，剩余节点会重新进行 leader 选举，但是问题在于，选举 leader 需要一定时间, 且选举期间整个 ZooKeeper 集群都是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因网络问题使得 ZooKeeper 集群失去 master 节点是大概率事件，虽然服务最终能够恢复，但是在选举时间内导致服务注册长期不可用是难以容忍的。

Eureka 保证 AP

Eureka 优先保证可用性，Eureka 各个节点是平等的，某几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而 Eureka 的客户端在向某个 Eureka 注册或时如果发现连接失败，则会自动切换至其它节点，只要有一台 Eureka 还在，就能保证注册服务可用 (保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。所以 Eureka 在网络故障导致部分节点失去联系的情况下，只要有一个节点可用，那么注册和查询服务就可以正常使用，而不会像 zookeeper 那样使整个注册服务瘫痪，Eureka 优先保证了可用性。

七、Eureka 注册中心高可用集群说明

在微服务架构的这种分布式系统中，我们要充分考虑各个微服务组件的高可用性问题，不能有单点故障，由于注册中心 eureka 本身也是一个服务，如果它只有一个节点，那么它有可能发生故障，这样我们就不能注册与查询服务了，所以我们需要一个高可用的服务注册中心，这就需要通过注册中心集群来解决。

Eureka 服务注册中心它本身也是一个服务，它也可以看做是一个提供者，又可以看做是一个消费者，我们之前通过配置：eureka.client.register-with-eureka=false 让注册中心不注册自己，但是我们可以向其他注册中心注册自己。

Eureka Server 的高可用实际上就是将自己作为服务向其他服务注册中心注册自己，这样就会形成一组互相注册的服务注册中心，进而实现服务清单的互相同步，往注册中心 A 上注册的服务，可以被复制同步到注册中心 B 上，所以从任何一台注册中心上都能查询到已经注册的服务，从而达到高可用的效果。

在这里插入图片描述

八、Eureka 注册中心高可用集群搭建

我们知道，Eureka 注册中心高可用集群就是各个注册中心相互注册，所以：在 8761 的配置文件中，让它的 service-url 指向 8762 和 8763，在 8762 的配置文件中让它的 service-url 指向 8761和 8763，在 8763 的配置文件中让它的 service-url 指向 8761和8762。

由于两两互相指向对方，实际上我们构建了一个三节点的服务注册中心集群。

eureka.client.service-url.defaultZone=http://eureka8762:8762/eureka/,http://eureka8763:8763/eureka/

eureka.client.service-url.defaultZone=http://eureka8761:8761/eureka/,http://eureka8763:8763/eureka/

eureka.client.service-url.defaultZone=http://eureka8761:8761/eureka/,http://eureka8762:8762/eureka/

然后在本地 hosts 文件配置：C:\Windows\System32\drivers\etc\hosts

127.0.0.1 eureka8761 
127.0.0.1 eureka8762
127.0.0.1 eureka8763

运行时，在运行配置项目 Program Arguments 中配置：

--spring.profiles.active=eureka8761 
--spring.profiles.active=eureka8762
--spring.profiles.active=eureka8763

分别启动三个注册中心，访问三个注册中心页面，观察注册中心页面是否正常

九、Eureka 注册中心高可用集群测试

在要进行注册的服务中配置：

#eureka注册中心的连接地址

eureka.client.service-url.defaultZone=http://eureka8761:8761/eureka,http://eureka8762:8762/eureka,http://eureka8763:8763/eureka

启动服务提供者服务，然后观察注册中心页面，可以看到服务会在三个注册中心上都注册成功。

十、Eureka 集群注册中心打包发布

Spring Cloud Eureka集群注册中心打包发布

在实际项目中，需要将Eureka发布到具体服务器上进行部署，打包部署其实和SpringBoot里面的一样，我们可以把其达成jar包，启动时对于properties文件，不同的环境激活不同的配置文件；

运行：

java -jar springcloud-service-eureka.jar --spring.profiles.active=eureka8761
java -jar springcloud-service-eureka.jar --spring.profiles.active=eureka8762
java -jar springcloud-service-eureka.jar --spring.profiles.active=eureka8763

可以写个shell脚本实现三个注册中心的启动

#!/bin/sh
nohup java -jar 34-springcloud-service-eureka-1.0.0.jar --spring.profiles.active=eureka8761 > ./logs/eureka8761.log &
nohup java -jar 34-springcloud-service-eureka-1.0.0.jar --spring.profiles.active=eureka8762 > ./logs/eureka8762.log &
nohup java -jar 34-springcloud-service-eureka-1.0.0.jar --spring.profiles.active=eureka8763 > ./logs/eureka8763.log &

修改 linux 的 hosts 文件

vim /etc/hosts
192.168.10.128 eureka8761
192.168.10.128 eureka8762
192.168.10.128 eureka8763

十一、Eureka 服务注册中心自我保护机制

自我保护机制是 Eureka 注册中心的重要特性，当 Eureka 注册中心进入自我保护模式时，在 Eureka Server 首页会输出如下警告信息：

EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. ENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.

小写是：

emergency ! eureka may be incorrectly claiming instances are up when they’re not. renewals are lesser than threshold and hence the instances are not being expired just to be safe.

在没有 Eureka 自我保护的情况下，如果 Eureka Server 在一定时间内没有接收到某个微服务实例的心跳，Eureka Server 将会注销该实例，但是当发生网络分区故障时，那么微服务与 Eureka Server 之间将无法正常通信，以上行为可能变得非常危险了，因为微服务本身其实是正常的，此时不应该注销这个微服务，如果没有自我保护机制，那么 Eureka Server 就会将此服务注销掉。

Eureka 通过 “自我保护模式” 来解决这个问题 —— 当 Eureka Server 节点在短时间内丢失过多客户端时 (可能发生了网络分区故障) ，那么就会把这个微服务节点进行保护。一旦进入自我保护模式，Eureka Server 就会保护服务注册表中的信息，不删除服务注册表中的数据(也就是不会注销任何微服务)。当网络故障恢复后，该 Eureka Server 节点会再自动退出自我保护模式。

所以，自我保护模式是一种应对网络异常的安全保护措施，它的架构哲学是宁可同时保留所有微服务(健康的微服务和不健康的微服务都会保留) ，也不盲目注销任何健康的微服务，使用自我保护模式，可以让 Eureka 集群更加的健壮、稳定。当然也可以使用配置项： eureka.server.enable-self-preservation = false 禁用自我保护模式。

关闭自我保护模式后会出现红色：

THE SELF PRESERVATION MODE IS TURNED OFF. THIS MAY NOT PROTECT INSTANCE EXPIRY IN CASE OF NETWORK/OTHER PROBLEMS.

但是 Eureka Server 自我保护模式也会给我们带来一些困扰，如果在保护期内某个服务提供者刚好非正常下线了，此时服务消费者就会拿到一个无效的服务实例，此时会调用失败，对于这个问题需要服务消费者端具有一些容错机制，如重试，断路器等。

Eureka 的自我保护模式是有意义的，该模式被激活后，它不会从注册列表中剔除因长时间没收到心跳导致注册过期的服务，而是等待修复，直到心跳恢复正常之后，它自动退出自我保护模式。这种模式旨在避免因网络分区故障导致服务不可用的问题。

例如，两个微服务客户端实例 A 和 B 之间有调用的关系，A 是消费者，B 是提供者，但是由于网络故障，B 未能及时向 Eureka 发送心跳续约，这时候 Eureka 不能简单的将 B 从注册表中剔除，因为如果剔除了，A 就无法从 Eureka 服务器中获取 B 注册的服务，但是这时候 B 服务是可用的。所以，Eureka 的自我保护模式最好还是开启它。

关于自我保护常用几个配置如下：

服务器端配置：

#测试时关闭自我保护机制，保证不可用服务及时踢出 
eureka.server.enable-self-preservation=false

客户配置：

#每间隔 2s，向服务端发送一次心跳，证明自己依然"存活" 
eureka.instance.lease-renewal-interval-in-seconds=2

#告诉服务端，如果我 10s 之内没有给你发心跳，就代表我故障了，将我踢出掉 
eureka.instance.lease-expiration-duration-in-seconds=10