考虑当前有两个微服务实例A和B，A服务需要调用B服务的某个REST接口。假如某一天B服务迁移到了另外一台服务器，IP和端口也发生了变化，这时候我们不得不去修改A服务中调用B服务REST接口的静态配置。随着公司业务的发展，微服务的数量也越来越多，服务间的关系可能变得非常复杂，传统的微服务维护变得愈加困难，也很容易出错。所谓服务治理就是用来实现各个微服务实例的自动化注册与发现，在这种模式下，服务间的调用不再通过指定具体的实例地址来实现，而是通过向服务注册中心获取服务名并发起请求调用实现。

Eureka是由Netflix开发的一款服务治理开源框架，Spring-cloud对其进行了集成。

Eureka既包含了服务端也包含了客户端，Eureka服务端是一个服务注册中心(Eureka Server)，提供服务的注册和发现，即当前有哪些服务注册进来可供使用；
Eureka客户端为服务提供者(Server Provider)，它将自己提供的服务注册到Eureka服务端，并周期性地发送心跳来更新它的服务租约，同时也能从服务端查询当前注册的服务信息并把它们缓存到本地并周期性地刷新服务状态。这样服务消费者(Server Consumer)便可以从服务注册中心获取服务名称，并消费服务。

三者关系如下图所示

image.png

搭建Eureka-Server服务注册中心

新建一个SpringBoot项目，引入依赖：

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

在启动类添加@EnableEurekaServer注解，Eureka服务端

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

在application.yml中添加配置

server:
  port: 9090
  
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

上面配置了服务的端口为9090，剩下几个为Eureka配置：

• eureka.instance.hostname 指定了Eureka服务端的IP；
• eureka.client.register-with-eureka 表示是否将服务注册到Eureka服务端，由于自身就是Eureka服务端，所以设置为false；
• eureka.client.fetch-registry 表示是否从Eureka服务端获取服务信息，因为这里只搭建了一个Eureka服务端，并不需要从别的Eureka服务端同步服务信息，所以这里设置为false；
• eureka.client.serviceUrl.defaultZone指定Eureka服务端的地址，默认值为http://localhost:8761/eureka

配置完成启动服务，访问：http://127.0.0.1:9090/

image.png

搭建Eureka-Client服务提供者

新建SpringBoot项目，引入依赖：

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

接着编写一个TestController，对外提供一些REST服务：

@RestController
public class TestController {

    @Autowired
    private DiscoveryClient client;

    @GetMapping("/info")
    public String info() {
        StringBuilder stringBuilder = new StringBuilder();
        for (String service : client.getServices()) {
            stringBuilder.append(service + " ");
        }
        return stringBuilder.toString();
    }

    @GetMapping("/hello")
    public String hello() {
        return "Hello World!";
    }
}

在启动类添加@EnableDiscoveryClient，Eureka客户端

@SpringBootApplication
@EnableDiscoveryClient
public class EurekaClientApplication {

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

}

添加application.yml 添加配置

server:
  port: 8082
  
spring:
  application:
    name: Server-Provider
    
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    serviceUrl:
      defaultZone: http://localhost:9090/eureka/

• server.port 指定了服务的端口为8082；
• spring.application.name 指定服务名称为Server-Provider，后续服务消费者要获取上面TestController中接口的时候会用到这个服务名；
• eureka.client.serviceUrl.defaultZone 指定Eureka服务端的地址，这里为上面定义的Eureka服务端地址；
• eureka.client.register-with-eureka和eureka.client.fetch-registry 上面已经解释了其意思，虽然这两个配置的默认值就是true，但这里还是显式配置下，使Eureka客户端的功能更为直观（即向服务端注册服务并定时从服务端获取服务缓存到本地）

配置好后，启动Eureka-Client，可以从控制台中看到注册成功的消息：

2019-09-11 18:28:02.190  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Disable delta property : false
2019-09-11 18:28:02.190  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Single vip registry refresh property : null
2019-09-11 18:28:02.190  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Force full registry fetch : false
2019-09-11 18:28:02.190  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Application is null : false
2019-09-11 18:28:02.190  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Registered Applications size is zero : true
2019-09-11 18:28:02.190  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Application version is -1: true
2019-09-11 18:28:02.190  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Getting all instance registry info from the eureka server
2019-09-11 18:28:02.317  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : The response status is 200
2019-09-11 18:28:02.319  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Starting heartbeat executor: renew interval is: 30
2019-09-11 18:28:02.320  INFO 10400 --- [           main] c.n.discovery.InstanceInfoReplicator     : InstanceInfoReplicator onDemand update allowed rate per min is 4
2019-09-11 18:28:02.323  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Discovery Client initialized at timestamp 1568197682322 with initial instances count: 1
2019-09-11 18:28:02.324  INFO 10400 --- [           main] o.s.c.n.e.s.EurekaServiceRegistry        : Registering application SERVER-PROVIDER with eureka with status UP
2019-09-11 18:28:02.324  INFO 10400 --- [           main] com.netflix.discovery.DiscoveryClient    : Saw local status change event StatusChangeEvent [timestamp=1568197682324, current=UP, previous=STARTING]
2019-09-11 18:28:02.325  INFO 10400 --- [nfoReplicator-0] com.netflix.discovery.DiscoveryClient    : DiscoveryClient_SERVER-PROVIDER/DESKTOP-4DSQ1D6:Server-Provider:8082: registering service...
2019-09-11 18:28:02.353  INFO 10400 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8082 (http) with context path ''
2019-09-11 18:28:02.354  INFO 10400 --- [nfoReplicator-0] com.netflix.discovery.DiscoveryClient    : DiscoveryClient_SERVER-PROVIDER/DESKTOP-4DSQ1D6:Server-Provider:8082 - registration status: 204
2019-09-11 18:28:02.354  INFO 10400 --- [           main] .s.c.n.e.s.EurekaAutoServiceRegistration : Updating port to 8082
2019-09-11 18:28:02.356  INFO 10400 --- [           main] top.lconcise.EurekaClientApplication     : Started EurekaClientApplication in 3.062 seconds (JVM running for 3.657)

再次访问http://localhost:9090/，可看到服务列表里已经出现了名字为Server-providerde服务了：

image.png

Eureka-Server集群

Eureka服务端充当了重要的角色，所有Eureka客户端都将自己提供的服务注册到Eureka服务端，然后供所有服务消费者使用。如果单节点的Eureka服务端宕机了，那么所有服务都无法正常的访问，这必将是灾难性的。为了提高Eureka服务端的可用性，我们一般会对其集群部署，即同时部署多个Eureka服务端，并且可以相互间同步服务。

在搭建Eureka服务端的时候我们曾把下面两个配置给关闭了：

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

实际上在Eureka集群模式中，开启这两个参数可以让当前Eureka服务端将自己也作为服务注册到别的Eureka服务端，并且从别的Eureka服务端获取服务进行同步。所以这里我们将这两个参数置为true（默认就是true），下面开始搭建Eureka服务端集群，为了简单起见这里只搭建两个节点的Eureka服务端集群。

在Eureka-Server项目的src/main/resource目录下新建application-pro1.yml，配置如下：

server:
  port: 9090

spring:
  application:
    name: Eureka-Server

eureka:
  instance:
    hostname: pro1
  client:
    serviceUrl:
      defaultZone: http://pro2:7070/eureka/
  server:
    enable-self-preservation: false

• server.port=8080指定端口为9090
• spring.application.name=Eureka-Server指定了服务名称为Eureka-Server
• eureka.instance.hostname=peer1指定地址为pro1
• eureka.client.serviceUrl.defaultZone=http://pro2:7070/eureka/指定Eureka服务端的地址为另外一个Eureka服务端的地址pro2

下面我们创建另外一个Eureka服务端pro2的yml配置application-pro2.yml：

server:
  port: 7070

spring:
  application:
    name: Eureka-Server

eureka:
  instance:
    hostname: pro2
  client:
    serviceUrl:
      defaultZone: http://pro1:9090/eureka/
  server:
    enable-self-preservation: false

pro2中的serviceUrl我们指向Eureka服务端pro1。

为了让这种在一台机器上配置两个hostname的方式生效，我们需要修改下hosts文件（位置C:\Windows\System32\drivers\etc）：

127.0.0.1       pro1
127.0.0.1       pro2

我们将Eureka-Server项目打包成jar，然后分别运行以下两条命令来部署pro1和pro2：

java -jar Eureka-Service-0.0.1-SNAPSHOT.jar --spring.profiles.active=pro1
java -jar Eureka-Service-0.0.1-SNAPSHOT.jar --spring.profiles.active=pro2

启动后，我们来访问peer1http://localhost:9090/：

image.png

因为Eureka服务端做了集群处理，所以Eureka客户端指定的服务端地址也要进行修改：

eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:9090/eureka/,http://peer2:7070/eureka/

我们将Eureka客户端（Server-Provider）打成jar包，然后分别用端口8082和8083启动两个服务：

java -jar Eureka-Client-0.0.1-SNAPSHOT.jar --server.port=8082
java -jar Eureka-Client-0.0.1-SNAPSHOT.jar --server.port=8083

然后访问http://peer2:9090/eureka/或者http://peer2:8081/eureka/：

image.png

搭建Server-Consumer服务消费者

在实际项目中，Eureka客户端即是服务提供者，也是服务消费者，即自身的接口可能被别的服务访问，同时也可能调用别的服务接口。这里为了更好的演示，我们把服务消费者单独的分开来演示。

新建一个Spring Boot项目，artifactId填Server-Consumer，其主要的任务就是将自身的服务注册到Eureka服务端，并且获取Eureka服务端提供的服务并进行消费。这里服务的消费我们用Ribbon来完成，Ribbon是一款实现服务负载均衡的开源软件，这里不做详细介绍。

引入依赖：

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

同样的，在入口类中加入@EnableDiscoveryClient注解用于发现服务和注册服务，并配置一个RestTemplate Bean，然后加上@LoadBalanced注解来开启负载均衡：

@SpringBootApplication
@EnableDiscoveryClient
public class ServerConsumerApplication {

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

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

}

接着编写一个TestController，用于消费服务：

@RestController
public class TestController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/info")
    public String getInfo() {
        return this.restTemplate.getForEntity("http://Server-Provider/info", String.class).getBody();
    }
}

上面代码注入了RestTemplate，getInfo中使用RestTemplate对象均衡的去获取服务并消费。可以看到我们使用服务名称（Server-Provider）去获取服务的，而不是使用传统的IP加端口的形式。这就体现了使用Eureka去获取服务的好处，我们只要保证这个服务名称不变即可，IP和端口不再是我们关心的点。

最后配置application.yml

server:
  port: 8989
  
spring:
  application:
    name: Server-Consumer
    
eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:9090/eureka/,http://peer2:7070/eureka/

端口为8989，服务名称为Server-Consumer并指定了Eureka服务端的地址。

启动该项目，访问http://localhost:9000/info：

成功获取到了信息，我们多次访问这个接口，然后观察8082和8083Eureka客户端的后台：

可以看到它们的后台都打印出了信息，说明我们从9000去获取服务是均衡的。

这时候我们关闭一个Eureka服务端，再次访问http://localhost:9000/info，还是可以成功获取到信息，这就是Eureka服务端集群的好处。

Eureka-Server添加认证

出于安全的考虑，我们可能会对Eureka服务端添加用户认证的功能。我们在Eureka-Server引入Spring-Security依赖：

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

然后在application.yml中配置用户名和密码：

security:
  user:
    name: mrbird
    password: 123456

添加配置问价配置：

@Configuration
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.httpBasic()                // HttpBasic
//        http.formLogin()              // 表单方式
                .and()
                .authorizeRequests()  // 授权配置
                .anyRequest()         // 所有请求
                .authenticated()      // 都需要认证
                .and().csrf().disable();
    }
}

Eureka服务端配置了密码之后，所有eureka.client.serviceUrl.defaultZone的配置也必须配置上用户名和密码，格式为：eureka.client.serviceUrl.defaultZone=http://{password}@{port}/eureka/，如：

eureka:
  client:
    serviceUrl:
      defaultZone: http://mrbird:123456@peer2:8081/eureka/

重新打包并部署后，访问http://localhost:8080/，页面将弹出验证窗口，输入用户名和密码后即可访问。

image.png

Eureka配置

源码：https://github.com/lbshold/springboot/tree/master/Spring-Cloud-Eureka

参考博文：https://mrbird.cc/Spring-Cloud-Eureka.html