服务注册发现：Eureka 入门

侯乾 Lv4
  2019-12-08 20:32:21 2019-12-08 20:32:21 Created   2019-12-08 20:32:21 2019-12-08 20:32:21 Updated    

Eureka解决了什么问题

这个问题本质是问服务注册中心的价值。很多年前，那个时候微服务还没有兴起，大家用Nginx+Tomcat就搞定了，加机器加Tomcat时候，直接在线改Nginx配置就搞定，这叫手动服务注册。但是在现今的微服务架构中，服务可能动不动就几十个，上百个，算上冗余就几百个，而且微服务的发布很频繁，不断有新的服务加入进来；在应对大流量场景时，还需要扩容缩容。这如果还依靠Nginx那种原始的手工配置方式，是不可行的，成本太高了。所以，就出现了服务注册发现，即服务实例自己会在启动后注册到服务注册中心，这叫服务注册，然后每个服务实例又从服务注册中心拉取服务注册表，动态的感知到服务的上下线，这叫服务发现。所以，服务注册中心这种技术是在微服务架构中自然而然就过渡过来的，并不突兀。eureka作为Netflix全家桶中的服务注册中心实现，其意义也就不言自明了。

快速体验Eureka

1、构建一个Eureka Server

创建一个maven工程，加入如下配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
</parent>

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.cloud-version>Hoxton.RELEASE</spring.cloud-version>
</properties>

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

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

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</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>

创建一个application.yml文件，配置如下内容:

1
2
3
4
5
6
7
server:
  port: 8761

eureka:
  client:
    register-with-eureka: false #1
    fetch-registry: false       #2

#1 不要将此服务注册到eureka。因为当前服务已经是eureka server了

#2 不要拉取服务注册表。

创建一个启动类：

1
2
3
4
5
6
7
8
9
10
@Slf4j
@EnableEurekaServer
@SpringBootApplication
public class EurekaServer {

    public static void main(String[] args) {
        SpringApplication.run(EurekaServer.class, args);
        log.info("eureka server 启动成功");
    }
}

启动后，见到如下输出即为成功:

eureka server启动成功

2、开发一个服务提供者

1
2
3
4
5
6
7
8
@RestController
public class ServiceAController {

    @GetMapping("/sayHello/{name}")
    public String sayHello(@PathVariable("name") String name) {
        return "hello," + name;
    }
}
1
2
3
4
5
6
7
8
9
@Slf4j
@EnableEurekaClient
@SpringBootApplication
public class ServiceAApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceAApplication.class, args);
        log.info("ServiceA 启动成功");
    }
}

创建一个application.yml文件，配置如下内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
server:
  port: 8080

spring:
  application:
    name: serviceA

# eureka client config
eureka:
  instance:
    hostname: loacalhost
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

服务A启动成功

3、开发一个服务调用者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@RestController
@Configuration
public class ServiceBController {

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

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/greeting/{name}")
    public String greeting(@PathVariable("name") String name) {
        return restTemplate.getForObject("http://serviceA/sayHello/" + name, String.class);
    }
}
1
2
3
4
5
6
7
8
9
10
@Slf4j
@EnableEurekaClient
@SpringBootApplication
public class ServiceBApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceBApplication.class, args);
        log.info("ServiceB 启动成功");
    }
}

创建一个application.yml文件，配置如下内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
server:
  port: 9000

spring:
  application:
    name: serviceB

# eureka client config
eureka:
  instance:
    hostname: loacalhost
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

启动服务

serviceB启动成功

4、进行实验

浏览器访问localhost:8761打开Eureka注册服务控制台，可发现ServiceA和B都注册到Eureka Server上了

eureka控制台

在浏览器访问http://localhost:9000/greeting/jack,就可以看到结果了

结果

5、画图讲解Hello Word原理

  • 服务A和B的启动类上都有@EnableEurekaClient注解，此注解会将服务变为Eureka客户端应用，将自己注册到Eureka Server上
  • 服务B和服务A都会从Eureka Server拉取服务注册表
  • 服务B发起调用服务A的请求时，Ribbon根据拉取到本地的服务注册表，将服务名替换为hostname+port并发起服务调用

eureka helloword原理

Eureka集群实战

1、eureka注册中心集群

eureka如此重要的服务注册中心，肯定不可能是单点的。下面我们来构建一个eureka server集群。

分别使用如下配置各启动一个eureka server，组成一个集群。

1
2
3
4
5
6
7
8
9
10
11
server:
  port: 8762

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://peer2:8761/eureka
  instance:
    hostname: peer2
1
2
3
4
5
6
7
8
9
10
11
server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://peer2:8762/eureka
  instance:
    hostname: peer1

小技巧：可以同一个工程，分别启动一次即可。

如果是IDEA的话，可能不让你同时启动两个，按照如下配置一下即可，在Allow parallel run前打上勾即可

idea启动多个实例

随意访问一个eureka控制台，可发现两个节点已经组成集群。DS Replicas指的是当前eureka server的副本

eureka集群

小提示：假如访问peer2节点，会发现没有服务实例。不用着急，下面我们改造后就OK了。

2、将服务改造为注册到eureka server集群

分别将服务A和B的配置改为如下这样，变更部分为最后一行

1
2
3
4
5
6
eureka:
  instance:
    hostname: localhost
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka,http://localhost:8762/eureka

改完重启后访问eureka控制台页面即可看到都有服务实例了。

服务健康自检机制

默认情况下，你的所有服务，比如服务A和服务B，都会自动给eureka注册中心同步心跳，续约。如果eureka server一段时间内没有感知到某个服务的心跳，就会把那个服务下线。

1、基于spring-boot-actuator的服务健康检查

服务加入如下依赖

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

重启后访问http://localhost:port/actuator/health可以看到返回的服务状态，默认是UP

2、spring-cloud-eureka整合spring-boot-actuator实现自定义服务健康检查

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * 自定义健康检查器
 */
@Component
public class ServiceAHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        // 此处可以加上一些失败条件判断，符合这些条件就返回Status.DOWN即可
        // 主要是自己依赖的一些基础设施，看他们是否挂了或者自己连不上他们了，来决定自己是否健康
        return new Health.Builder(Status.UP).build();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * eureka整合actuator实现自定义健康检查器
 */
@Component
public class ServiceAHealthCheckHandler implements HealthCheckHandler {

    @Autowired
    private ServiceAHealthIndicator indicator;

    @Override
    public InstanceInfo.InstanceStatus getStatus(InstanceInfo.InstanceStatus currentStatus) {
        Status status = indicator.health().getStatus();
        // 可以根据status来决定返回什么实例状态
        return InstanceInfo.InstanceStatus.UP;
    }
}

eureka client会定时调用getStatus方法来判断服务实例的状态，如果状态变化了，就会通知eureka server。当服务实例挂掉了，那么eureka server就会感知到，然后下线这个服务实例。

3、生产经验分享

一般情况下很少使用这第二种方式自定义健康状态检查器，原因如下：

  • 对于eureka
    eureka默认是client通过心跳与eureka server保持心跳通信，如果心跳不及时或者没有心跳了，那么就说明那个服务挂了，然后eureka server就会摘除这个服务实例，这个机制足够用了
  • 对于服务
    在大规模部署中，每个服务都很复杂，不可能去一个个搞一堆健康检查的。大部分情况下，我们就是会对外暴露一个/health接口，然后专门外部定时调用各个服务的/health接口来判断当前这个服务状态就足够了。

Eureka常见配置

心跳检测

eureka客户端，默认每隔30秒发送一次心跳到eureka server（以后简称注册中心）。

1
2
3
4
5
6
eureka:
  instance:
    # 配置eureka client与注册中心心跳间隔时间，默认是30秒。在eureka中，心跳被称为续约（renew）
    lease-renewal-interval-in-seconds: 
    # 配置如果多少秒内没有收到一个服务实例的心跳，就摘除（expiration 失效）这个服务，默认是90秒。
    lease-expiration-duration-in-seconds:

一般情况下，这俩参数建议不要修改

注册表抓取

默认情况下，客户端每隔30秒去注册中心抓取最新的注册表，然后缓存到本地。通过下面参数可修改时间间隔

1
2
3
4
eureka:
  client:
    # 客户端每隔多少秒去注册中心抓取最新注册表，默认30秒
    registry-fetch-interval-seconds:

自定义元数据

通过下面的metadata-map定义服务的元数据，反正就是你自己需要的一些东西，不过一般挺少使用的

1
2
3
eureka:
  instance:
    metadata-map:

自我保护模式

如果在eureka控制台看到下面这样的东西：

eureka自我保护机制

这就是eureka进入了自我保护模式。如果客户端的心跳失败超过了一定的比例，或者说在一定时间内（默认15分钟）接收到的服务续约低于85%，那么就会认为是自己网络故障了，这个时候会导致人家client无法发送心跳，如果不加以控制，eureka服务实例摘除机制会将实例一个个的下掉。为了避免这种情况的发生，eureka这个时候会一种保护模式，保护服务注册表，不会立即把失效的服务实例摘除。在测试的时候一般会关闭这个自我保护模式：

1
2
3
eureka:
  server:
    enable-self-preservation: false

总结

本篇博客，我们已经初步体会如何使用eureka，剖析了eureka的常见配置，后续我们马上进入源码剖析环节。

  • Title: 服务注册发现：Eureka 入门
  • Author: 侯乾
  • Created at : 2019-12-08 20:32:21
  • Updated at : 2019-12-08 20:32:21
  • Link: http://houqian.github.io/2019/12/08/服务注册发现：Eureka-入门/
  • License: This work is licensed under CC BY-NC-SA 4.0.
Comments
On this page
服务注册发现：Eureka 入门
  1. Eureka解决了什么问题
  2. 快速体验Eureka
    1. 1、构建一个Eureka Server
    2. 2、开发一个服务提供者
    3. 3、开发一个服务调用者
    4. 4、进行实验
    5. 5、画图讲解Hello Word原理
  3. Eureka集群实战
    1. 1、eureka注册中心集群
    2. 2、将服务改造为注册到eureka server集群
  4. 服务健康自检机制
    1. 1、基于spring-boot-actuator的服务健康检查
    2. 2、spring-cloud-eureka整合spring-boot-actuator实现自定义服务健康检查
    3. 3、生产经验分享
  5. Eureka常见配置
    1. 心跳检测
    2. 注册表抓取
    3. 自定义元数据
    4. 自我保护模式
  6. 总结