Spring Cloud教程第一弹 Eureka服务注册中心

梦里梦外; 2022-12-18 09:58 137阅读 0赞

更多Spring与微服务相关的教程请点击这里 [Spring与微服务教程合集][Spring]

# 1、微服务架构概述 #

## 1.1、架构的发展历程 ##

单体 -> 分布式 -> SOA -> 微服务

**分布式：**

按照业务垂直切分，每个应用都是单体架构

**SOA：**

SOA中主要有两个角色：服务提供者和服务消费者，dubbo是soa的典型实现

**微服务：**

微服务是一种架构风格。对于一个大型复杂的业务系统，它的业务功能可以拆分为多个相互独立的微服务，各个微服务之间是松耦合的，通过各种远程协议进行同步/异步通信，各微服务均可以被独立部署、扩/缩容以及升/降级。

**微服务架构技术选型对比：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70][]

## 1.2、基于spring cloud的微服务解决方案 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 1][]

## 1.3、spring cloud项目模块 ##

spring cloud是一个开源项目集合，包括很多子项目,具体参考[https://github.com/spring-cloud][https_github.com_spring-cloud]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 2][]

## 1.4、springcloud+中间件+增强生态 ##

**中间件：**

*  服务治理中间件
 *  配置中心中间件
 *  网关中间件
 *  全链路监控中间件

**增强生态：**

*  分布式事务
 *  领域驱动
 *  gRPC
 *  springcloud与dubbo生态融合

# 2、走进Eureka世界 #

本教程基于spring cloud Hoxton.SR4版本、eureka 2.2.2.RELEASE版本

服务发现 = 注册中心 = 名字服务

eureka包括eureka server和eureka client（java编写的客户端）

## 2.1、eureka设计起源 ##

eureka最初是针对AWS（亚马逊云计算服务）不提供中间服务层的负载均衡的限制而设计开发的。AWS Elastic Load Balancer用来对客户端或终端设备请求进行负载均衡。而eureka则用来对中间层的服务做服务发现，配合其它组件提供负载均衡能力

netflix为什么要设计eureka，而不是直接利用AWS Elastic Load Balancer或者AWS Route 53呢？其官方文档简要说明如下：

*  理论上可以使用AWS Elastic Load Balancer对内部进行负载均衡，但是这样就会暴露到外网，存在安全性问题。
 *  另外AWS Elastic Load Balancer是传统的基于代理的负载均衡解决方案，无法直接基于服务元数据信息定制负载均衡算法。
 *  因此netflix设计了eureka，一方面给内部服务做服务发现，一方面结合ribbon组件提供个性化的负载均衡算法
 *  而AWS Route 53是一款命名服务，可以给中间层的服务提供服务发现功能，但它是基于DNS的服务，传统的基于DNS的负载均衡技术存在缓存更新延时问题，另外主要是无法对服务健康状态进行检查，因此netflix就自己设计了eureka

## 2.2、CAP理论 ##

Zookeeper为CP设计，Eureka为AP设计，作为服务发现产品，可用性优先级较高，一致性的特点并不重要，宁可返回错误的数据，也比不反回结果要好得多；

CAP理论提出就是针对分布式环境的，所以，P（分区容忍性）这个属性是必须具备的；

P就是在分布式环境中，由于网络的问题可能导致某个节点和其它节点失去联系，这时候就形成了P(partition 分区)，也就是由于网络问题，将系统的成员隔离成了2个区域，互相无法知道对方的状态，这在分布式环境下是非常常见的，因为P是必须的，那么我们需要选择的就是A和C；

大家知道，在分布式环境下，为了保证系统可用性，通常都采取了复制的方式，避免一个节点损坏，导致系统不可用。那么就出现了每个节点上的数据出现了很多个副本的情况，而数据从一个节点复制到另外的节点时需要时间和要求网络畅通的，所以，当P发生时，也就是无法向某个节点复制数据时，这时候你有两个选择：

*  选择可用性 A(Availability)，此时，那个失去联系的节点依然可以向系统提供服务，不过它的数据就不能保证是同步的了（失去了C属性）
 *  选择一致性C(Consistency)，为了保证数据库的一致性，我们必须等待失去联系的节点恢复过来，在这个过程中，那个节点是不允许对外提供服务的，这时候系统处于不可用状态(失去了A属性)

最常见的例子是读写分离，某个节点负责写入数据，然后将数据同步到其它节点，其它节点提供读取的服务，当两个节点出现通信问题时，你就面临着选择A（继续提供服务，但是数据不保证准确）或C（用户处于等待状态，一直等到数据同步完成）

## 2.3、服务实例如何注册到服务注册中心 ##

本质是调用eureka server的rest api的register方法

对于java应用则调用eureka client封装的api

对于springcloud应用则采用自动配置

## 2.4、peer to peer(同伴)架构 ##

分布式系统的数据在多个副本间的复制方式，可分为主从复制和对等复制

对等复制：任何副本都可以接收写操作，因此不存在写操作压力瓶颈，但各个副本之间的数据同步与冲突处理是一个比较棘手的问题

eureka server采用的就是peer to peer的复制模式

## 2.5、Zone(区)及Region(地区)的设计 ##

由于Netflix的大部分服务在亚马逊云上，因此Eureka的设计有一部分是基于亚马逊的Zone及Region的基础设施之上

eureka默认设置了4个Region：us-east-1、us-west-1、us-west-2、eu-west-1

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 3][]

*  在每个Region下，还分了4个AvailabilityZone
 *  每个Region是相互独立及隔离的
 *  默认情况下资源只在单个Region下的AvailabilityZone之间复制，跨Region不会进行资源复制；由于资源在Region之间默认不会复制，因此eureka server的高可用主要就在于AvailabilityZone
 *  AvailabilityZone可以看做Region下面的一个个机房，各个机房相对独立，主要是为了Region的高可用设计
 *  一个AvailabilityZone可以设置多个Eureka sever节点，它们之间采用peer to peer复制

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 4][]

# 3、Eureka入门实战 #

## 3.1、搭建eureka server工程 ##

### 3.1.1、pom.xml ###

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/>
      </parent>
    
    <properties>
        <spring-cloud.version>Hoxton.SR4</spring-cloud.version>
      </properties>
    
    <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</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>

### 3.1.2、application.yml ###

server:
      port: 8080
    eureka:
      instance:
        hostname: localhost
      client:
        register-with-eureka: false
        fetch-registry: false
        service-url:
          defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka
    spring:
      application:
        name: eureka-server

### 3.1.3、启动并访问 ###

在工程启动类上，打上@EnableEurekaServer注解，启动项目，访问http://localhost:8080即可看到eureka的仪表盘界面

## 3.2、prefer-ip-address ##

*  eureka客户端向服务端注册时，有两种选择：一种是以主机名注册，另一种是以ip地址注册
 *  eureka.instance.prefer-ip-address默认为false,向eureka server注册时,会以hostname注册,如果java API不能自动获取hostname，也可以手动指定eureka.instance.hostname=localhost
 *  如果将eureka.instance.prefer-ip-address设为true，则向eureka server注册时会以ip地址注册(Java API自动获取IP地址)，如果指定了eureka.instance.ip-address,则以该值为准

**下面来测试一下：**

现在有三行配置，分别编号为1、2、3

1.   eureka.instance.prefer-ip-address: true
2.   eureka.instance. ip-address: 127.0.0.1
3.   eureka.instance. hostname: bobo

现有服务server-a，我将分别以端口号8010、8011、8012启动三个实例，分别使用配置1、配置1和2组合、配置3

**eureka仪表盘界面如下：**

![20201102161231808.png][]

**分别点击每个实例的链接，得到的URL如下：**

*  http://10.71.34.72:8010/service-a/actuator/info
 *  http://127.0.0.1:8011/service-a/actuator/info
 *  http://bobo:8012/service-a/actuator/info

## 3.3、eureka server集成spring security安全认证 ##

### 3.3.1、pom.xml ###

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-security</artifactId>
            </dependency>

### 3.3.2、eureka server的application.yml ###

spring:
      application:
        name: eureka-server
      security:
        basic:
          enable: true
        user:
          name: admin
          password: ok
    server:
      servlet:
        context-path: /eureka-server
      port: 8000
    eureka:
      instance:
        hostname: localhost
      client:
        register-with-eureka: false
        fetch-registry: false
        service-url:
          defaultZone: http://${eureka.client.security.basic.user}:${eureka.client.security.basic.password}@${eureka.instance.hostname}:${server.port}/eureka-server/eureka
        security:
          basic:
            user: admin
            password: ok
      dashboard:
        path: /dashboard

### 3.3.3、eureka server配置SecurityConfig ###

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    
    
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Override
        protected void configure(HttpSecurity auth) throws Exception {
            super.configure(auth);
            auth.csrf().disable();
        }
    }

### 3.3.4、启动eureka server ###

根据上面的配置文件，eureka server的仪表盘界面URL为：[http://localhost:8000/eureka-server/dashboard][http_localhost_8000_eureka-server_dashboard]

第一次访问会跳转到登录表单页面

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 5][]

### 3.3.5、eureka client的application.yml ###

由于eureka server集成了spring security做安全认证，因此eureka client向server注册时，其配置也有一定的变化，如下所示：

eureka:
      client:
        service-url:
          defaultZone: http://${eureka.client.security.basic.user}:${eureka.client.security.basic.password}@localhost:8000/eureka-server/eureka/
        register-with-eureka: true
        fetch-registry: true
        security:
          basic:
            user: admin
            password: ok

## 3.4、eureka编程 ##

如下代码，展示了eureka的事件机制与EurekaClient的使用

import com.netflix.discovery.EurekaClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.netflix.eureka.server.event.*;
    import org.springframework.context.event.EventListener;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import java.util.Set;
    
    
    @RestController
    public class EurekaProgramming {
    
        @EventListener
        public void instanceRegistered(EurekaInstanceRegisteredEvent event){
            System.out.println("实例注册");
        }
        @EventListener
        public void instanceRenewed(EurekaInstanceRenewedEvent event){
            System.out.println("实例续租");
        }
        @EventListener
        public void registryAvailable(EurekaRegistryAvailableEvent event){
            System.out.println("注册中心启动");
        }
        @EventListener
        public void serverStarted(EurekaServerStartedEvent event){
            System.out.println("eureka server启动");
        }
        @EventListener
        public void instanceCanceled(EurekaInstanceCanceledEvent event){
            System.out.println("实例下线");
        }
    
        @Autowired
        private EurekaClient eurekaClient;
        //private DiscoveryClient discoveryClient;
    
        @GetMapping("/getAllKnownRegions")
        public Set<String> getAllKnownRegions(){
            Set<String> allKnownRegions = eurekaClient.getAllKnownRegions();
            return allKnownRegions;
        }
    
    
    }

## 3.5、多网卡选择 ##

问题场景：服务器上分别配置了eth0, eth1和eth2三块网卡，只有eth1的地址可供其它机器访问，eth0和eth2的 IP 无效。在这种情况下，服务注册时Eureka Client会自动选择eth0作为服务ip, 导致其它服务无法调用

Eureka Client并没有自己实现探测本机IP的逻辑，而是交给Spring的`InetUtils`工具类的`findFirstNonLoopbackAddress()`方法完成的

该工具类会获取所有网卡，依次进行遍历，取**ip地址合理、索引值最小且不在忽略列表**的网卡的ip地址作为结果。如果仍然没有找到合适的IP, 那么就将`InetAddress.getLocalHost()`做为最后的fallback方案

**解决方案1：**

spring:
      cloud:
        inetutils:
          # 配置忽略的网卡名称，支持正则
          ignored-interfaces:
            - ens33
          #配置偏好的IP地址，支持正则
          preferred-networks:

**解决方案2：**

**直接指定IP地址**

eureka:
      instance:
        ip-address=
        prefer-ip-address=true

#    4、Eureka集群 #

## 4.1、注意点 ##

*  register-with-eureka 需要设置为true，或者不设置，默认为true
 *  hostname和defaultZone的域名不要设置为localhost，应设置为别名，并在操作系统的host文件中添加映射

127.0.0.1        peer1
    127.0.0.1        peer2
    127.0.0.1        peer3

否则后台会出现registered-replicas为空的情况

enable-self-preservation 设置为false 关闭自我保护模式，否则一个节点挂掉之后，不会在unavailable-replicas中出现

## 4.2、重点配置 ##

### 4.2.1、服务端 ###

**节点1**：

eureka.instance.hostname=peer1
    
    eureka.client.register-with-eureka=true
    
    eureka.client.service-url.defaultZone=http://peer2:8001/eureka/,http://peer3:8002/eureka/

**节点2：**

eureka.instance.hostname=peer2
    
    eureka.client.register-with-eureka=true
    
    eureka.client.service-url.defaultZone=http://peer1:8000/eureka/,http://peer3:8002/eureka/

**节点3：**

eureka.instance.hostname=peer3
    
    eureka.client.register-with-eureka=true
    
    eureka.client.service-url.defaultZone=http://peer1:8000/eureka/,http://peer2:8001/eureka/

### 4.2.2、客户端 ###

eureka.client.service-url.defaultZone=http://peer1:8000/eureka/,http://peer2:8001/eureka/,http://peer3:8002/eureka/

# 5、Eureka的高可用机制 #

## 5.1、服务的核心操作 ##

*  Register：实例注册
 *  Cancel：实例下线
 *  Renew：实例续租
 *  evic：是server端的一个方法，用于剔除租约过期的实例

对于evic操作，eureka server有一个类EvictionTask，继承了TimerTask，默认每1分钟进行一次evic操作，将已下线的实例给剔除掉。可以修改默认配置：eureka.server.eviction-interval-timer-in-ms: 6000

## 5.2、什么是自我保护机制 ##

eureka Server 在运行期间会去统计心跳失败比例在 15 分钟之内是否低于 85%，如果低于 85%，Eureka Server 会将这些实例保护起来，让这些实例不会过期，继续显示在eureka的实例列表里，因为这些服务有可能仍然可用，直到心跳恢复正常之后，它自动退出自我保护模式

但是在保护期内如果这些服务真的坏掉了，此时服务消费者就会拿到一个无效的服务实例，此时会调用失败，对于这个问题需要服务消费者端要有一些容错机制，如重试，断路器等

## 5.3、Eureka自我保护机制的激活条件 ##

**首先观察一下eureka界面**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 6][]

自我保护机制开启的条件是：Renews(last min) < Renews threshold,即eureka server实际收到的心跳小于期望收到的心跳

期望收到的心跳计算公式：int Renews threshold = (int)(实例数量\*2\*0.85) 为什么要乘以2，因为实例每分钟发送2次心跳

且默认每五分钟统计一次上一分钟实际收到的心跳

eureka界面如果出现了上图中的那一行红色警告字体，就代表开启了自我保护机制。当eureka退出自我保护机制，那一行红字也会消失

**针对上述机制，eureka server端有如下配置：**

eureka:
      server:
        # int Renews threshold = (int)(实例数量*2*0.85) 为什么要乘以2，因为实例每分钟发送2次心跳
        # 自我保护机制的激活条件 = 上一分钟，Renews < Renews threshold
        renewal-percent-threshold: 0.85 #配置百分比
        enable-self-preservation: true #是否开启自我保护机制
        wait-time-in-ms-when-sync-empty: 10000 #默认是300000ms，即5分钟。每五分钟统计一次Renews
      
      instance:
        #多长时间没有收到客户端的心跳，才认定客户端下线，默认90秒，但实际有bug,为180秒
        lease-expiration-duration-in-seconds: 90

**针对上述机制，eureka client端有如下配置：**

eureka:
      instance:
        lease-renewal-interval-in-seconds: 1 #默认每30秒发生一次心跳
      client:
        #默认每30秒客户端从eureka server服务注册表上拉取一次注册信息
        registry-fetch-interval-seconds: 30

## 5.4、Eureka的Response Cache ##

### 5.4.1、rest api ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 7][]

### 5.4.2、缓存分级 ###

*  readOnlyCacheMap
 *  readWriteCacheMap
 *  registry

Eureka Server的缓存机制依赖于谷歌的gauva cache , 在Eureka中通过com.netflix.eureka.registry.ResponseCacheImpl 这个操作类来实现缓存的机制

private final ConcurrentMap<Key, ResponseCacheImpl.Value> readOnlyCacheMap = new ConcurrentHashMap();
    private final LoadingCache<Key, ResponseCacheImpl.Value> readWriteCacheMap;
    private final AbstractInstanceRegistry registry;

因此，Eureka Server的缓存是通过一个只读，一个读写缓存来实现的。

**readWriteCacheMap **

*  此处存放的是最终的缓存， 当服务下线，过期，注册，状态变更，都会来清除这个缓存里面的数据， 然后通过CacheLoader进行缓存加载，并且读写缓存有一个过期时间
 *  在进行readWriteCacheMap.get(key)的时候，首先看这个缓存里面有没有该数据，如果没有则通过CacheLoader的load方法去加载，加载成功之后将数据放入缓存，同时返回数据

**readOnlyCacheMap**

*  这是一个JVM的CurrentHashMap只读缓存，这个主要是为了供客户端获取注册信息时使用，其缓存更新，依赖于定时器的更新，通过和readWriteCacheMap 的值做对比，如果数据不一致，则以readWriteCacheMap 的数据为准

**针对只读缓存和读写缓存，有如下配置：**

eureka:
      server:
        use-read-only-response-cache: false #是否使用只读缓存
        response-cache-auto-expiration-in-seconds: 180 #读写缓存过期时间,默认180秒
        response-cache-update-interval-ms: 30000 # 只读缓存定时刷新周期，默认为30秒

**总结：**

eureka的读写缓存和只读缓存，是为了保证高可用的。但是缓存太多，导致CAP理论中的一致性弱过头了，并且读写缓存已经是CurrentHashMap，纯内存操作，性能已经很高了，没必要再套一层只读缓存，因此建议关掉只读缓存

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 8][]

[Spring]: https://blog.csdn.net/xl_1803/article/details/109462842
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70]: /images/20221122/22dbd2e47e2845f4a48c951ba9dcdc72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 1]: /images/20221122/17f7b6e9c1534d9aaef1a19ab9e0ed5a.png
[https_github.com_spring-cloud]: https://github.com/spring-cloud
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 2]: /images/20221122/bf538987efb6431e829c414b9b1f3945.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 3]: /images/20221122/ce2f32f1ea4849e59c873b3f8e567cdc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 4]: /images/20221122/4ae709576c594d6695135d98e330ebb4.png
[20201102161231808.png]: /images/20221122/f941ca2a6d52462894bd5be6e8b0546b.png
[http_localhost_8000_eureka-server_dashboard]: http://localhost:8000/eureka-server/dashboard
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 5]: /images/20221122/d18ea74f2c01414a817ba3899e49791d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 6]: /images/20221122/bc205b79a9284897bf8ae16d00fa19ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 7]: /images/20221122/45998100d88d48fc82cd715a2145767e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hsXzE4MDM_size_16_color_FFFFFF_t_70 8]: /images/20221122/570637e8b2fd4daaa074d495e8d252ad.png