Spring Cloud | 服务 “注册与发现“ 框架 : Eureka框架

- Eureka 的 "工作机制" :
- - 一、Eureka 的 "工作原理" ( 两大组件 ) :
  - - 1.1 Eureka Server ( 服务注册中心 )
    - 1.2 Eureka Client ( 服务/服务实例，其存在 "两种角色" : ①服务提供者 ②服务消费者 ) :
    - - Eureka Client 的含义
      - 服务提供者
      - 服务消费者
      - Eureka Server 与服务提供者、服务消费者之间的关系
  - 二、第一个 Eureka应用 :
  - - 2.1 搭建 "Eureka Server"
    - - ① 创建 Eureka Server 项目
      - ② 全局配置文件( .yml文件 )中添加 "Eureka" ( 服务注册中心 ) 的相关配置信息
      - ③ 在项目启动类上添加 @EnableEurekaServer 注解
      - ④ 启动项目启动类的main( )方法
    - 2.2 搭建 "Eureka Client" 作为 "服务提供者"
    - - ⑤ 创建 Eureka Client 项目 ( 作为 "服务提供者" )
      - ⑥ 全局配置文件( .yml文件 )中添加 "Eureka" ( 服务提供者 )的相关配置信息
      - ⑦ 在项目启动类上添加 @EnableEurekaClient 注解
      - ⑧ 运行 "程序启动类"
    - 2.3 搭建 "Eureka Client" 作为 "服务消费者"
    - - ⑨ 创建 Eureka Client 项目 ( 作为 "服务消费者" )
      - ⑩ 全局配置文件( .yml文件 )中添加 "Eureka" ( 服务消费者 ) 的相关配置信息
      - ⑪ 在项目启动类上添加 @EnableEurekaClient 注解
      - ⑫ 运行 "程序启动类"
      - 小提示
  - 三、搭建 Eureka "高可用集群" :
  - - 1. 更改系统 " hosts文件" 配置
    - - ① 更改系统 " hosts文件" 配置
    - 2. 改造Eureka Server ( 服务注册中心 )
    - - ② 再建一个 Eureka Server项目
      - ③ 修改 eureka-server 项目 ( 第一个"服务注册中心" ) 中的"全局配置文件"
      - ④ 修改 eureka-server-another 项目 ( 第二个"服务注册中心" ) 中的"全局配置文件"
      - ⑤ 在项目启动类上添加 @EnableEurekaServer 注解
    - 3. 改造 "服务提供者"
    - - ⑥ 再创建一个 Eureka Client 项目 ( 作为 "服务提供者" )
      - ⑦ 全局配置文件( .yml文件 )中添加 "Eureka" ( 服务提供者 )的相关配置信息
      - ⑧ 在项目启动类上添加 @EnableEurekaClient 注解
    - 4. 改造 "服务消费者"
    - 5. 启用Eureka 高可用集群
  - 四、Eureka 的 "常用配置"
  - - 4.1 心跳机制
    - 4.2 "自我保护机制"
    - 4.3 其他配置 :
    - - "服务注册" 相关的 "配置信息"
      - "服务实例" 相关的 "配置信息"

在这里插入图片描述

作者简介 ：一只大皮卡丘，计算机专业学生，正在努力学习、努力敲代码中! 让我们一起继续努力学习！

该文章参考学习教材为：
《Spring Cloud微服务架构开发》 黑马程序员 / 编著
文章以课本知识点 + 代码为主线，结合自己看书学习过程中的理解和感悟，最终成就了该文章

文章用于本人学习使用 ，同时希望能帮助大家。
欢迎大家点赞👍 收藏⭐ 关注💖哦！！！

（侵权可联系我，进行删除，如果雷同，纯属巧合）

服务的注册 发现对于 微服务架构来说是一个非常重要的环节。在 单一架构应用中，业务逻辑层 ( Business Logic Layer，BLL )中的 接口之间的 互相调用，是通过一个固定的 Host 和 Port “发起” REST 或者 “RPC调用”。但是在微服务架构中，每个服务是 “动态变化” 的，难以通过 静态配置 的方式维护服务，以至于后来产生了大量的 服务发现框架来完成服务的自动化管理。

Eureka 的 “工作机制” :

一、Eureka 的 “工作原理” ( 两大组件 ) :

服务的 “注册与发现框架” : Eureka框架 ，该框架"包含" 两个组件，分别是 : (1) Eureka Server (2) Eureka Client。

1.1 Eureka Server ( 服务注册中心 )

Eureka Server : 服务注册服务器 / 服务注册中心。各个服务启动后，会在 Eureka Server (服务注册中心) 中进行注册，这样Eureka Server 的 服务注册表中将会存储 所有 可用服务节点 的信息。服务节点的信息可以在界面中直观地看到。
-----( 简而言之 : 各个服务启动后，会在"服务注册中心"中进行注册，注册的信息将存储在 "服务注册表"中，这些服务节点信息可在"界面"中直观地看到 )

1.2 Eureka Client ( 服务/服务实例，其存在 “两种角色” : ①服务提供者 ②服务消费者 ) :

Eureka Client 的含义

Eureka Client : 也称为服务 ( 服务实例 )，作为一个 Java客户端，用于 “简化” 与 Eureka Server 的交互。
Eureka Client内置一个使用轮询负载算法的 负载均衡器。服务启动后，Eureka Client ( 服务实例 ) 将 会向 Eureka Server 发送 心跳更新服务，如果 Eureka Server 在 多个心跳周期内( 默认90s内 )没有接收到某个服务的心跳，Eureka Server ( 服务注册中心 )就将会从 服务注册表中把这个服务节点移除。为了更好地讲解 Eureka 组件的工作原理，具体描述为下图所示 :

在上图中，Eureka Client ( 服务 / 服务实例) 注册在 Eureka Server ( 服务注册中心 )，Eureka Client 中的 服务是通过 REST 调用的。除此之外，Eureka Client还具有缓存功能，Eureka Client ( 服务 / 服务实例 ) 能够从 Eureka Server ( 服务注册中心 ) 查询当前注册 的 服务信息并 缓存到本地，这样即使Eureka Server宕机，Eureka Client 也依然可以 利用缓存 中的 信息调用服务。

EurekaClient ( 服务 / 服务实例 )存在 两种角色，分别是 ① 服务提供者 和 ② 服务消费者。

服务提供者

EurekaClient ( 服务 / 服务实例 ) 启动后，服务提供者会通过REST请求将自己注册在 Eureka Server ( 服务注册服务器 ) 中，并维护一个心跳 (默认30 秒发送一次心跳 ) 进行服务续约，告诉 EurekaServer “我还活着”，防止 Eureka Server 将 该服务 从服 务列表 中剔除。

服务消费者

用于获取 Eureka Server ( 服务注册中心 ) 注册的 “服务清单”，并且 该 “服务清单” 默认每隔 30 秒更新一次 。服务消费者 获取到服务清单后，能够根据自己的需求决定调用哪个服务，默认采用轮询方式调用，从而实现Eurekaclient的负载均衡。

Eureka Server 与服务提供者、服务消费者之间的关系

Eureka Server 与 服务提供者、服务消费者之间的关系如下图所示 :

在上图中，服务提供者和 服务消费者 都属于 Eureka Client，它们都会将自己的信息通过REST API 的形式 提交给EurekaServer。

服务消费者 “注册后”，还会获取一份 服务注册列表，该列表包含了所有向 Eureka Server ( 服务注册中心 ) 注册的 服务信息。获取到服务注册信息后，服务消费者就会根据服务提供者的 IP 地址，通过 HTTP 远程调用服务提供者的服务。

需要注意的是，服务提供者和服务消费者是可以相互转换的，因为一个服务既可能是服务消费者，同时又可能是服务提供者。例如在传统的企业应用三层架构中，服务层会调用数据访问层的接口进行数据操作，它本身也会提供服务给控制层使用。

二、第一个 Eureka应用 :

介绍了 Eureka的 工作机制 后，下面我们通过开发第一个Eureka应用加深对 服务注册与发现框架 : Eureka框架 的理解。
建议是 先建一个空工程，在这个工程中创建下面的项目。

2.1 搭建 “Eureka Server”

通过上面的学习，大家应该知道了 Eureka Server 是一个 服务注册与发现中心 / 服务注册中心。有了它我们才可以
注册Eureka Client ( 服务 / 服务实例 )。接下来我们 先搭建 Eureka Server，具体步骤如下 ：

① 创建 Eureka Server 项目

使用 Spring Initializr方式创建一个名称为 eureka-server 的 Spring Boot项目，这里将Group命名为 com.myh，将 Artifact 命名为eureka-server，添加Eureka Server 依赖。

项目创建好后的 pom.xml文件代码 如下所示 :

pom.xml :

<?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>
		<!--	SpringBoot的版本为:2.1.7.RELEASE 	-->
		<version>2.1.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.myh</groupId>
	<artifactId>eureka-server</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>eureka-server</name>
	<description>eureka-server</description>
	<properties>
		<java.version>1.8</java.version>
		<!--	Springcloud的版本为:Greenwich.SR2 	-->
		<spring-cloud.version>Greenwich.SR2</spring-cloud.version>
	</properties>
	<dependencies>

		<!--	引入了 eureka-server的jar包	-->
		<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>

② 全局配置文件( .yml文件 )中添加 “Eureka” ( 服务注册中心 ) 的相关配置信息

在全局配置文件application.yml中添加Eureka的相关配置信息 ( 项目自动生成的配置文件为 application.properties，我们可直接将后缀名改掉就行，这两个文件格式都可以，只是内部的内容格式不同。)

application.yml :
server:
  port: 7000  #服务端口号为: 7000 / 指定 "服务注册中心"的"端口号"为:7000

spring:
  application:
    name: eureka-server #端口号名称配置 / 指定"服务注册中心"的名称

eureka:
  client:   
    register-with-eureka: false  #表示不将自己 "注册" 到"Eureka服务注册中心 / Eureka服务端" (默认值为true)
    fetch-registry: false  #表示 "不从" EurekaSever 中获取 "注册信息" (默认值为true)
    #(因为这里搭建的是Eureka Server，无须注册服务，也无须获取注册信息,所以 register-with-eureka 和 fetch-registry 的值都设置为false,其默认值为true )
    service-url:
      defaultZone: #设置"服务注册中心地址"
        http://${eureka.instance.hostname}:${server.port}/eureka/
  instance:
    hostname: localhost #主机名
在上面的配置信息中，server.port 指定了服务器端口号：7000。Spring.application.name 指定了当前服务名称是 eureka-server。 Eureka.client.register-with-eureka用于设置是否向 Eureka Server “注册”，默认值是 true。
Eureka.client.fetch-registry表示是否从Eureka Server “获取注册信息”，由于这里搭建的是Eureka Server，无须注册服务，也无须获取注册信息，因此，这里将fetch-registry 和 register-with-eureka的值 都设置为false。Eureka.client.service-url.defaultZone 用于设置 “服务注册中心地址”。

③ 在项目启动类上添加 @EnableEurekaServer 注解

在 项目启动类 上 添加 @EnableEurekaServer 注解 启动 Eureka Server功能：

在这里插入图片描述

EurekaServerApplication.java (项目启动类) :

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer // 启动Eureka Server
public class EurekaServerApplication {

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

}

④ 启动项目启动类的main( )方法

启动 项目启动类的 main( )方法。启动成功后，在浏览器中访问 http://localhost:7000/ 网址 来查看 Eureka Server 的 主界面 , 效果如下图 :

2.2 搭建 “Eureka Client” 作为 “服务提供者”

下面我们来搭建一个 EurekaClient 作为 服务提供者，并将其注册在上面搭建的 Eureka Server ( 服务注册中心 ) 中，具体步骤如下 ：

⑤ 创建 Eureka Client 项目 ( 作为 “服务提供者” )

使用 Spring Initializr方式创建一个名称为 eureka-provider ( 服务提供者 )的 Spring Boot项目。这里将 Group 命名为 com.myh , 将 Artifact命名为 eureka-provider , 添加 Web、 Eureka Client 依赖。

项目创建好后的 pom.xml文件 代码如下所示 :

pom.xml :

<?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>
        <!--    SpringBoot的版本为:2.1.7.RELEASE   -->
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.myh</groupId>
    <artifactId>eureka-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-provider</name>
    <description>eureka-provider</description>
    <properties>
        <java.version>1.8</java.version>
        <!--    Springcloud的版本为:Greenwich.SR2  -->
        <spring-cloud.version>GreenWich.SR2</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--    引入了 eureka-client 的jar包    -->
        <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>
        </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>

⑥ 全局配置文件( .yml文件 )中添加 “Eureka” ( 服务提供者 )的相关配置信息

在全局配置文件application.yml中添加Eureka的相关配置信息 ( 项目自动生成的配置文件为 application.properties，我们可直接将后缀名改掉就行，这两个文件格式都可以，只是内部的内容格式不同。)

application.yml :
server:
  port: 7006 #指定 "服务提供者"的端口号: 7006

spring:
  application:
    name: eureka-provider #端口号名称配置 / 指定"服务提供者"的名称
eureka:
  client:
    service-url:
      register-with-eureka: true  #表示将自己 "注册" 到"Eureka服务注册中心 / Eureka服务端" (默认值为true,所以该属性可省略不配置)
      fetch-registry: true  #表示 "从" EurekaSever 中获取 "注册信息" (默认值为true,所以该属性可省略不配置)
      defaultZone:
        http://localhost:7000/eureka/  #指定EurekaServer(服务注册中心)的地址
  instance:
    hostname: localhost #主机名
上面的配置信息中，server.port 指定了服务提供者的端口号 , spring.application.name 指定了服务提供者 的名称，
eureka.client.service-url.defaultZone 指定了 Eureka Server ( 服务注册中心 ) 的地址。

⑦ 在项目启动类上添加 @EnableEurekaClient 注解

在 项目启动类 上 添加 @EnableEurekaClient 注解 启动 Eureka Client功能：

在这里插入图片描述

EurekaProviderApplication.java (项目启动类) :

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient //启动Eureka Client功能
public class EurekaProviderApplication {

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

}

⑧ 运行 “程序启动类”

保证EurekaServer ( 服务注册中心 )启动 的 状态下，运行EurekaProviderApplication 这个项目启动类，启动eureka-provider。启动成功后，控制台会 输出如下信息代码 :

上述日志信息说明 eureka-provider ( 服务提供者 ) 成功注册在 EurekaServer ( 服务注册中心 )上。在浏览器中访问 :
http://localhost:7000/，效果如下图所示 :

由上图可见，“Instances currently registered with Eureka” 这一项中注册了一个名称为 : “EUREKA-PROVIDER” 的服务，说明 服务提供者 已经 成功注册 到 EurekaServer ( 服务注册中心 ) 中。

2.3 搭建 “Eureka Client” 作为 “服务消费者”

搭建一个 EurekaClient 作为 服务消费者。其搭建方式与搭建服务提供者基本一样，具体步骤如下。

下面我们来搭建一个 EurekaClient 作为 服务消费者，并将其注册在上面搭建的 Eureka Server ( 服务注册中心 ) 中，具体步骤如下 ：

⑨ 创建 Eureka Client 项目 ( 作为 “服务消费者” )

使用 Spring Initializr 方式创建一个名称为 : eureka-consumer 的 Spring Boot 项目，这里将 Group 命名为 com.myh，将 Artifact 命名为 eureka-consumer , 添加 Eureka Client 依赖。

创建好后的 pom.xml 文件代码 如下所示 :

pom.xml ：

<?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>
        <!--	SpringBoot的版本为:2.1.7.RELEASE 	-->
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.myh</groupId>
    <artifactId>eureka-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-consumer</name>
    <description>eureka-consumer</description>
    <properties>
        <java.version>1.8</java.version>
        <!--	Springcloud的版本为:Greenwich.SR2 	-->
        <spring-cloud.version>GreenWich.SR2</spring-cloud.version>
    </properties>
    <dependencies>

        <!--  引入了 eureka-client 的jar包	-->
        <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>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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>

⑩ 全局配置文件( .yml文件 )中添加 “Eureka” ( 服务消费者 ) 的相关配置信息

在全局配置文件application.yml中添加Eureka的相关配置信息 ( 项目自动生成的配置文件为 application.properties，我们可直接将后缀名改掉就行，这两个文件格式都可以，只是内部的内容格式不同。)

application.yml ：
server:
  port: 7002 #指定 "服务消费者"的端口号: 7002

spring:
  application:
    name: eureka-consumer #端口号名称配置 / 指定"服务消费者"的名称
eureka:
  client:
    service-url:
      register-with-eureka: true  #表示将自己 "注册" 到"Eureka服务注册中心 / Eureka服务端" (默认值为true,所以该属性可省略不配置)
      fetch-registry: true  #表示 "从" EurekaSever 中获取 "注册信息" (默认值为true,所以该属性可省略不配置)
      defaultZone:
        http://localhost:7000/eureka/  #指定EurekaServer(服务注册中心)的地址
  instance:
    prefer-ip-address: true #显示主机的IP地址 ( 用于指定以"IP地址"注册到 Eureka Server上 )
上面的配置信息中，server.port 指定了服务消费者的端口号 , spring.application.name 指定了服务消费者 的名称，
eureka.client.service-url.defaultZone 指定了 Eureka Server ( 服务注册中心 ) 的地址，
eureka.instance.prefer-ip-address 用于指定 以IP地址 "注册"到Eureka Server ( 服务注册中心 )上。

⑪ 在项目启动类上添加 @EnableEurekaClient 注解

在 项目启动类 上 添加 @EnableEurekaClient 注解 启动 Eureka Client功能：

在这里插入图片描述

EurekaConsumerApplication.java (项目启动类) :

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient //启动Eureka Client功能
public class EurekaConsumerApplication {

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

}

⑫ 运行 “程序启动类”

保证EurekaServer ( 服务注册中心 )启动 的 状态下，运行EurekaConsumerApplication这个项目启动类，启动eureka-consumer。启动成功后，在浏览器中访问 : http://localhost:7000/，效果如下图所示 :

由上图可见，“Instances currently registered with Eureka” 这一项中注册了一个名称为 : “EUREKA-CONSUMER” 的
服务，说明 服务消费者 已经 成功注册 到 EurekaServer ( 服务注册中心 ) 中。

小提示

调试 Eureka 时，有时 Eureka Server 主页面会提示下图所示的 警告信息 ：

之所以出现这样的 警告信息，是因为本地调试时 触发了 Eureka Server 的保护机制。此时，可以在 Eureka Server 的全局配置文件中配置 “eureka.server.enable-self-preservation=false 参数，关闭保护机制 即可。

三、搭建 Eureka “高可用集群” :

通过开发第一个Eureka应用，我们认识并体验了 Eureka组件的简单用法。但是上面这个例子并 没有体现出 Eureka的高可用特性。下面我们对上面这个 Eureka应用进行改造，搭建 如下图所示 的 Eureka 高可用集群。

搭建Eureka高可用集群的具体步骤如下 ：

1. 更改系统 " hosts文件" 配置

① 更改系统 " hosts文件" 配置

由于 当前的开发环境只有一台PC，操作系统为 Windows，因此，如果要构建集群、就需要修改 hosts 文件，为其添加主机名的映射。 ① 找到 C:Windows\System32\drivers\etc\hosts 文件 ，把该hosts文件拉到桌面上，在文件中添加以下代码内容后，最后将hosts文件拉回到 “原文件夹中”。
127.0.0.1 server1
127.0.0.1 server2

2. 改造Eureka Server ( 服务注册中心 )

Eureka Server的高可用 实际上就是 将自己作为服务向其他服务注册中心 “注册自己”，这样就可以形成一组互相注册的服务注册中心，以 实现服务清单 的 互相同步，达到高可用的效果。
我们 在之前项目 eureka-server 的 基础上进行扩展，构建一个 双节点 的 服务注册中心集群。具体操作步骤如下所示。

② 再建一个 Eureka Server项目

按照上面 创建 Eumeka Server 项目 的方式，再搭建 一个名 eureka-server-another 的 Eumeka Server 项目 :

使用 Spring Initializr方式创建一个名称为 eureka-server-another 的 Spring Boot项目，这里将Group命名为 com.myh，将 Artifact 命名为eumeka-server-another，添加Eureka Server 依赖。

在这里插入图片描述

项目创建好后的 pom.xml文件代码 如下所示 :

pom.xml :

<?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>
        <!--    SpringBoot的版本为:2.1.7.RELEASE   -->
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.myh</groupId>
    <artifactId>eureka-server-another</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-server-another</name>
    <description>eureka-server-another</description>
    <properties>
        <java.version>1.8</java.version>
        <!--    Springcloud的版本为:Greenwich.SR2  -->
        <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
    </properties>
    <dependencies>

        <!--    引入了 eureka-server的jar包 -->
        <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>

③ 修改 eureka-server 项目 ( 第一个"服务注册中心" ) 中的"全局配置文件"

修改项目 : eureka-server 的 全局配置文件 : application.yml。修改后的配置文件代码 如下所示 :

application.yml :

server:
  port: 7000  #服务端口号为: 7000 / 指定 "服务注册中心"的"端口号"为:7000

spring:
  application:
    name: eureka-server #端口号名称配置 / 指定"服务注册中心"的名称

eureka:
  client:
    register-with-eureka: false  #表示不将自己 "注册" 到"Eureka服务注册中心 / Eureka服务端" (默认值为true)
    fetch-registry: false  #表示 "不从" EurekaSever 中获取 "注册信息" (默认值为true)
    #(因为这里搭建的是Eureka Server，无须注册服务，也无须获取注册信息,所以 register-with-eureka 和 fetch-registry 的值都设置为false,其默认值为true )
    service-url:
      defaultZone:  #设置"服务注册中心地址" ( 指向第二个创建的 "服务注册中心" )
        http://server2:7009/eureka/
  instance:
    hostname: server1  #主机名

④ 修改 eureka-server-another 项目 ( 第二个"服务注册中心" ) 中的"全局配置文件"

修改项目 : eureka-server-another 的 全局配置文件 : application.yml。修改后的配置文件代码 如下所示 :

application.yml :

server:
  port: 7009  #服务端口号为: 7009 / 指定 "该服务注册中心"的"端口号"为:7009
spring:
  application:
    name: eureka-server2  #端口号名称配置 / 指定该"服务注册中心"的名称
  eureka:
    client:
      register-with-eureka: true  #表示将自己 "注册" 到"Eureka服务注册中心 / Eureka服务端" (默认值为true,所以该属性可省略不配置)
      fetch-registry: true  #表示 "从" EurekaSever 中获取 "注册信息" (默认值为true,所以该属性可省略不配置
      service-url:
        defaultZone: #设置"服务注册中心地址" ( 指向第一个创建的 "服务注册中心" , 该注册操作为 : Eureka的"高可用" : 将"自己作为服务"向其他服务注册中心 "注册自己" )
          http://server1:7000/eureka/
  instance:
    hostname: server2 #主机名

⑤ 在项目启动类上添加 @EnableEurekaServer 注解

在 项目启动类 上 添加 @EnableEurekaServer 注解 启动 Eureka Server功能：

3. 改造 “服务提供者”

⑥ 再创建一个 Eureka Client 项目 ( 作为 “服务提供者” )

由于上图 : Eureka的 Eureka 高可用集群有"两个" 服务提供者，因此我们 还需要搭建一个服务提供者。
使用 Spring Initializr方式创建一个名称为 eureka-provider-another ( 服务提供者 )的Spring Boot项目。这里将 Group 命名为 com.myh , 将 Artifact命名为 eureka-provider-another , 添加 Web、Eureka Client 依赖。

项目创建好后的 pom.xml文件 代码如下所示 :

pom.xml :

<?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>
        <!--	SpringBoot的版本为:2.1.7.RELEASE 	-->
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.myh</groupId>
    <artifactId>eureka-provider-another</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-provider-another</name>
    <description>eureka-provider-another</description>
    <properties>
        <java.version>1.8</java.version>
        <!--	Springcloud的版本为:Greenwich.SR2 	-->
        <spring-cloud.version>GreenWich.SR2</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--  引入了 eureka-client 的jar包	-->
        <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>
        </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>

⑦ 全局配置文件( .yml文件 )中添加 “Eureka” ( 服务提供者 )的相关配置信息

在全局配置文件application.yml中添加Eureka的相关配置信息 ( 项目自动生成的配置文件为 application.properties，我们可直接将后缀名改掉就行，这两个文件格式都可以，只是内部的内容格式不同。)

application.yml :
server:
  port: 7007 #指定 该"服务提供者"的端口号: 7007

spring:
  application:
    name: eureka-provider #端口号名称配置 / 指定该"服务提供者"的名称
eureka:
  client:
    service-url:
      register-with-eureka: true  #表示将自己 "注册" 到"Eureka服务注册中心 / Eureka服务端" (默认值为true,所以该属性可省略不配置)
      fetch-registry: true  #表示 "从" EurekaSever 中获取 "注册信息" (默认值为true,所以该属性可省略不配置)
      defaultZone:
        http://localhost:7000/eureka/  #指定EurekaServer(服务注册中心)的地址
  instance:
    hostname: localhost #主机名
上面的配置信息中，server.port 指定了服务提供者的端口号 , spring.application.name 指定了服务提供者 的名称，
eureka.client.service-url.defaultZone 指定了 Eureka Server ( 服务注册中心 ) 的地址。

⑧ 在项目启动类上添加 @EnableEurekaClient 注解

在 项目启动类 上 添加 @EnableEurekaClient 注解 启动 Eureka Client功能。

4. 改造 “服务消费者”

这里搭建的 Eureka高可用集群 只有一个服务消费者。修改项目 : eureka-consumer 中的全局配置文件： application.yml。修改后的代码内容如下所示 :

application.yml :

server:
  port: 7002 #指定 "服务消费者"的端口号: 7002

spring:
  application:
    name: demo-consumer #端口号名称配置 / 指定"服务消费者"的名称
eureka:
  client:
    service-url:
      register-with-eureka: true  #表示将自己 "注册" 到"Eureka服务注册中心 / Eureka服务端" (默认值为true,所以该属性可省略不配置)
      fetch-registry: true  #表示 "从" EurekaSever 中获取 "注册信息" (默认值为true,所以该属性可省略不配置)
      defaultZone:
        http://server1:7000/eureka/,http://server2:7009/eureka/  #在两个"服务注册中心"中都进行"注册"
  instance:
    hostname: localhost #主机地址
    lease-renewal-interval-in-seconds: 5  #修改周期性心跳的默认时间为5s (默认为每30s发送一次)
    lease-expiration-duration-in-seconds: 10 #修改剔除服务的默认时间修改为10s (默认剔除时间为90s),每隔10s刷新服务列表，将无效服务剔除

5. 启用Eureka 高可用集群

依次启动 “两个” Eureka Server( 服务注册中心 )、"两个" 服务提供者、"一个"服务消费者。启动成功后，无论访问哪个 Eureka Server，Eureka Server 的 注册实例 都是一样的。

分别访问 ：http://server1:7000/ 和 http://server2:7009/ ，具体效果如下图所示 :

四、Eureka 的 “常用配置”

4.1 心跳机制

Eureka是通过心跳的方式实现对各个 "服务实例"的 健康检测。在Eureka的服务续约与 剔除机制下，
客户端的 健康状态 从注册到 注册中心开始都会处于 UP状态，除非心跳中止一段时间后，服务注册中心将其剔除。心跳机制可以有效检查客户端进程 “是否正常运作”。下面将对 Eureka 心跳机制常用配置 进行讲述。
服务启动后，Eureka Client ( 服务实例 )将会向 Eureka Server ( 服务注册中心 ) 发送 周期性的心跳，默认是每 30 秒发送一次，可通过修改Eureka Client 实例 的 全局配置文件中的 eureka.instance.leaseRenwalIntervalInSeconds( lease-renewal-interval-in-seconds )属性 来改变发送周期性心跳的默认时间。具体代码如下所示 :
eureka:
  instance:
    lease-renewal-interval-in-seconds: 5  #修改周期性心跳的默认时间为5s (默认为每30s发送一次)
Eureka Server 如果在一定期限内没有接收到Eureka Client 实例的心跳，就会 将该实例从注册中心 “剔除掉”，其他客户端将 无法访问这个实例。这个期限默认值为 : 90秒，可通过 eureka.instance.leaseExpriationDurationInSeconds ( lease-expiration-duration-in-seconds ) 属性 来 改变这个值。具体代码如下所示 :
eureka:
  instance:
    lease-expiration-duration-in-seconds: 10 #修改剔除服务的默认时间修改为10s (默认剔除时间为90s),每隔10s刷新服务列表，将无效服务剔除

4.2 “自我保护机制”

Eureka 的 自我保护机制 是为了 防止出现 “误杀” 服务 的情况。Eureka 注册中心 和 服务中心 都有 发生故障的可能。
如果 Eureka Server 服务注册中心 发生故障，Eureka Client 服务 就有 可能不能正常续约，而这个时候 , 服务是 正常的 , 但是 注册中心 会 将超过 90秒未续约 的 服务剔除 造成 “误杀”服务 的情况。

Eureka Server 通过 判断 “是否” 存在大量 “续约失败” 的服务，从而 确定 "是否开启"自我保护。默认情况下，Eureka Server配置的自我保护阀值是 0.85。如果Eureka Server 运行期间根据 心跳比例 接收到的服务续约低于阀值，Eureka Server 就 开启自我保护，“不再剔除” 注册列表 的信息。

但是，如果在 Eureka Server 保护期间 发生了 服务下线 的情况，这时 Eureka Server 维护的 服务清单就 不那么准确了。此时可以关闭保护机制，确保服务中心不可用的服务实例被及时剔除。
默认情况下，Eureka Server 自我保护是 开启的，如果需要关闭，就可以在 全局配置文件 中添加下列代码 :
eureka:
  server:
    enable-self-preservation: false #关系Eureka Server "自我保护机制"

4.3 其他配置 :

多数情况下，Eureka Server 作为 现成产品，不需要 “修改其配置信息” 。而 Eureka Client 作为 微服务架构中的应用，不仅需要向 Eureka Server 注册，还会作为服务实例 “互相调用”。下面将针对 Eureka Clent 以下两方面的配置进行讲解，具体如下 :

“服务注册” 相关的 “配置信息”

关于 服务注册的 相关配置信息 都是以 eureka.client 作为前缀。Eureka Client 与 服务注册相关的配置信息 如下表所示 ：

参数名称参数说明
enable 启动 Eureka客户端，默认值 为 tue。
registryFetchIntervalSeconds 从 Eureka 服务端 “获取” 注册信息的 间隔时间，单位为秒，默认值 为 30s。
fetchRegistry 是否从 Eureka 服务端 / Eureka服务注册中心 中获取注册信息，默认值为false。
eurekaServerReadTimeoutSeconds 读取 Eureka Server信息的 超时时间，单位为秒，默认值为8s。
InitiallnstanceInfoReolicationInstervalSeconds 初始化实例信息到 Eureka 服务端 的 间隔时间，单位为秒，默认值 为 40s。
instanceInfoReolicationInstervalSeconds 更新 实例信息 的变化到 Eureka 服务端的 间隔时间，单位为秒，默认值 为 30s。

参数名称	参数说明
enable	启动 Eureka客户端，默认值为 tue。
registryFetchIntervalSeconds	从 Eureka 服务端 “获取” 注册信息的间隔时间，单位为秒，默认值为 30s。
fetchRegistry	是否从 Eureka 服务端 / Eureka服务注册中心中获取注册信息，默认值为false。
eurekaServerReadTimeoutSeconds	读取 Eureka Server信息的超时时间，单位为秒，默认值为8s。
InitiallnstanceInfoReolicationInstervalSeconds	初始化实例信息到 Eureka 服务端的间隔时间，单位为秒，默认值为 40s。
instanceInfoReolicationInstervalSeconds	更新实例信息的变化到 Eureka 服务端的间隔时间，单位为秒，默认值为 30s。

“服务实例” 相关的 “配置信息”

关于 服务实例的 相关配置信息都以 eureka.instance 为前缀。Eureka Client 与 服务实例相关的配置信息 如下表所示 ：

参数名称参数说明
preferlpAddress 是否优先使用IP 地址作为主机名的标识，默认值为false。
leaseRenewalIntervalInSeconds Eureka 客户端 向 服务端 发送心跳的 时间间隔，单位为秒、默认值 为 30s。
leaseExpirationDurationInSeconds Eureka 服务端在收到最后一次心跳之后等待的 时间上限 ( 等待多少秒后剔除服务 )，单位为秒，默认值为90s。如果超出时间后，服务端就会将该服务实例从服务清单中剔除，从而禁止服务调用请求 “被发送” 到该实例上。
аpрname 服务名，默认取 spring.application.name 的 配置值，如果没有就为 unknown。
hostname 主机名，不配置时 将根据 操作系统 的 主机名来获取。

参数名称	参数说明
preferlpAddress	是否优先使用IP 地址作为主机名的标识，默认值为false。
leaseRenewalIntervalInSeconds	Eureka 客户端向服务端发送心跳的时间间隔，单位为秒、默认值为 30s。
leaseExpirationDurationInSeconds	Eureka 服务端在收到最后一次心跳之后等待的时间上限 ( 等待多少秒后剔除服务 )，单位为秒，默认值为90s。如果超出时间后，服务端就会将该服务实例从服务清单中剔除，从而禁止服务调用请求 “被发送” 到该实例上。
аpрname	服务名，默认取 spring.application.name 的配置值，如果没有就为 unknown。
hostname	主机名，不配置时将根据操作系统的主机名来获取。