IT瘾君

二、consul ：SpringCloud Consul 使用详解

Consul 介绍

Consul 是 HashiCorp 公司推出的开源工具，用于实现分布式系统的服务发现与配置。与其它分布式服务注册与发现的方案，Consul 的方案更“一站式”，内置了服务注册与发现框架、分布一致性协议实现、健康检查、Key/Value 存储、多数据中心方案，不再需要依赖其它工具（比如 ZooKeeper 等）。使用起来也较为简单。Consul 使用 Go 语言编写，因此具有天然可移植性(支持Linux、windows和Mac OS X)；安装包仅包含一个可执行文件，方便部署，与 Docker 等轻量级容器可无缝配合。

Spring Cloud 支持的服务发现软件以及特性对比

Consul VS Eureka

Eureka 是一个服务发现工具。该体系结构主要是客户端/服务器，每个数据中心有一组 Eureka 服务器，通常每个可用区域一个。
1、通常 Eureka 的客户使用嵌入式 SDK 来注册和发现服务
2、对于非本地集成的客户，官方提供的 Eureka 一些 REST 操作 API
3、其它语言可以使用这些 API 来实现对 Eureka Server 的操作从而实现一个非 jvm 语言的 Eureka Client

Eureka 提供了一个弱一致的服务视图，尽可能的提供服务可用性。当客户端向服务器注册时，该服务器将尝试复制到其它服务器，但不提供保证复制完成。服务注册的生存时间（TTL）较短，要求客户端对服务器心跳检测。不健康的服务或节点停止心跳，导致它们超时并从注册表中删除。服务发现可以路由到注册的任何服务，由于心跳检测机制有时间间隔，可能会导致部分服务不可用。这个简化的模型允许简单的群集管理和高可扩展性。

Consul 提供了一些列特性，包括更丰富的健康检查，键值对存储以及多数据中心。Consul 需要每个数据中心都有一套服务，以及每个客户端的 agent，类似于使用像 Ribbon 这样的服务。Consul agent 允许大多数应用程序成为 Consul ，通过配置文件执行服务注册并通过 DNS 或负载平衡器 sidecars 发现。

Consul 提供强大的一致性保证，因为服务器使用 Raft 协议复制状态。Consul 支持丰富的健康检查，包括 TCP，HTTP，Nagios / Sensu 兼容脚本或基于 Eureka 的 TTL。客户端节点参与基于 Gossip 协议的健康检查，该检查分发健康检查工作，而不像集中式心跳检测那样成为可扩展性挑战。发现请求被路由到选举出来的 leader，这使他们默认情况下强一致性。允许客户端过时读取使任何服务器处理他们的请求，从而实现像 Eureka 这样的线性可伸缩性。

Consul 强烈的一致性意味着它可以作为领导选举和集群协调的锁定服务。Eureka 不提供类似的保证，并且通常需要为需要执行协调或具有更强一致性需求的服务运行 ZooKeeper。

Consul 提供了支持面向服务的体系结构所需的一系列功能。这包括服务发现，还包括丰富的运行状况检查，锁定，密钥/值，多数据中心联合，事件系统和 ACL。Consul 和 consul-template 和 envconsul 等工具生态系统都试图尽量减少集成所需的应用程序更改，以避免需要通过 SDK 进行本地集成。Eureka 是一个更大的 Netflix OSS 套件的一部分，该套件预计应用程序相对均匀且紧密集成。因此 Eureka 只解决了一小部分问题，可以和 ZooKeeper 等其它工具可以一起使用。

Consul 强一致性©带来的是：
服务注册相比 Eureka 会稍慢一些。因为 Consul 的 raft 协议要求必须过半数的节点都写入成功才认为注册成功 Leader 挂掉时，重新选举期间整个 Consul 不可用。保证了强一致性但牺牲了可用性。

Eureka 保证高可用(A)和最终一致性：
服务注册相对要快，因为不需要等注册信息 replicate 到其它节点，也不保证注册信息是否 replicate 成功当数据出现不一致时，虽然 A, B 上的注册信息不完全相同，但每个 Eureka 节点依然能够正常对外提供服务，这会出现查询服务信息时如果请求 A 查不到，但请求 B 就能查到。如此保证了可用性但牺牲了一致性。

其它方面，eureka 就是个 servlet 程序，跑在 servlet 容器中; Consul 则是 go 编写而成。

Consul 的优势：

1、使用 Raft 算法来保证一致性, 比复杂的 Paxos 算法更直接. 相比较而言, zookeeper 采用的是 Paxos, 而 etcd 使用的则是 Raft。
2、支持多数据中心，内外网的服务采用不同的端口进行监听。多数据中心集群可以避免单数据中心的单点故障,而其部署则需要3、考虑网络延迟, 分片等情况等。 zookeeper 和 etcd 均不提供多数据中心功能的支持。
4、支持健康检查。 etcd 不提供此功能。
5、支持 http 和 dns 协议接口。 zookeeper 的集成较为复杂, etcd 只支持 http 协议。
6、官方提供 web 管理界面, etcd 无此功能。
综合比较, Consul 作为服务注册和配置管理的新星, 比较值得关注和研究。

Consul 角色

client: 客户端, 无状态, 将 HTTP 和 DNS 接口请求转发给局域网内的服务端集群。
server: 服务端, 保存配置信息, 高可用集群, 在局域网内与本地客户端通讯, 通过广域网与其它数据中心通讯。每个数据中心的 server 数量推荐为 3 个或是 5 个。
Consul 客户端、服务端还支持跨中心的使用，更加提高了它的高可用性。

原理

1、Agent：Agent是在Consul集群的每个成员之上长期运行的一个守护进程。它通过运行consul agent启动。Agent可以运行在客户端或者服务器模式下。所有的节点都可以运行DNS和HTTP接口，以及负责运行健康检查和保持服务同步。

Agent职责（server/client）：拥有本地service信息（目录：data/services）、check信息（目录：data/checks）；执行check health（默认10s）；更新自己的agent状态；参与LAN Gossip。

Agent leave（ctrl-c 或 kill）：安全退出，通知集群中leader我已经离开了（一般几秒钟就能感知到），Catalog会将该agent的service和check移除。

Agent failed（kill -9）：非正常退出，该agent的serf健康状态为critical，service和check不会被移除，集群等待此agent恢复（默认72h）。

2、Client：Client是用来转发rpc请求到Server的Agent；超级轻量级，数量无限制。

Client职责：转发rpc请求到Server。

Client运维：其实不论client是leave还是failed，对用例来讲都没关系，因为如果服务本身是HA的，那么挂掉某一个服务的client，只是从服务的HA池中移除一个而已（交叉注册）！

3、Server：Server是具备一组扩展职责的agent，建议数量为3或5个。

Leader职责：将写请求（事务）复制到所有Server对等节点。

Server职责：选举leader（参与Raft法定人数）；维护集群状态；响应client的rpc请求；转发写请求到leader、转发读写请求到其它数据中心（TCP）、参与WAN Gossip。

Server运维：server最好是leave，而不是failed，因为leave对整个server的一致性（选举）是友好的，否则需要手动参与rejoin。

4、Catalog：服务发现的背后是一个service catalog（服务目录），catalog拥有整个consul cluster的高层视图。

Catalog职责：只是记录并返回一些信息（存储在BlotDB）；比如：哪些服务是可用的、哪些节点运行这些服务、服务健康信息等，通过dns或http接口暴露这些信息；

Catalog运维：只由Server节点维护，不能由Client维护，因为Catalog的同步是通过Raft log来做的，用来提供整个consul cluster的统一的一致性的视图。

5、Anti-Entropy：反熵，用来计数consul cluster的混乱趋势。

Anti-Entropy职责：保证Catalog与Agent的同步，同时也必须保证Catalog与Agent是完全分离的，不会相互影响；如果Catalog中的数据与Agent中的数据不一致，那么Agent的数据是权威的，会删除或更新Catalog中的数据。

Anti-Entropy运维：Catalog与Agent的同步规则：根据consul cluster size决定同步的间隔时间（size上升一个指数，interval增加1分钟），比如：size:1-128, interval:1min，size:129-256, interval: 2min。

6、Stale Reads：读取陈旧数据，默认情况下所有读写请求都由leader节点提供服务，但是从Consul的0.7版本开始，读请求由所有server节点负载提供服务（默认配置：allow-stale=true，max_stale=5s，这意味着从任意的Server中读取到的数据都与leader的数据存在5秒的偏差）。

7、Gossip Protocol：consul通过Serf使用Gossip协议（基于SWIM），提供成员管理、故障检测和事件广播（UDP）。

8、Consensus Protocol：consul通过该协议（基于Raft）提供一致性。

Consul 工作原理：

1、当 Producer 启动的时候，会向 Consul 发送一个 post 请求，告诉 Consul 自己的 IP 和 Port
2、Consul 接收到 Producer 的注册后，每隔10s（默认）会向 Producer 发送一个健康检查的请求，检验Producer是否健康
3、当 Consumer 发送 GET 方式请求 /api/address 到 Producer 时，会先从 Consul 中拿到一个存储服务 IP 和 Port 的临时表，从表中拿到 Producer 的 IP 和 Port 后再发送 GET 方式请求 /api/address
4、该临时表每隔10s会更新，只包含有通过了健康检查的 Producer
Spring Cloud Consul 项目是针对 Consul 的服务治理实现。Consul 是一个分布式高可用的系统，它包含多个组件，但是作为一个整体，在微服务架构中为我们的基础设施提供服务发现和服务配置的工具。

Consul 安装

linux安装

安装步骤

本地安装

Consul 官网](https://www.consul.io/downloads.html)下载 Consul 的最新版本,解压是一个 consul.exe 的执行文件

cd 到对应的目录下，使用 cmd 启动 Consul

cd D:\Program Files\consul_1.6.0_windows_amd64
#cmd启动：
consul agent -dev        # -dev表示开发模式运行，另外还有-server表示服务模式运行

可以在同级目录下创建一个 run.bat 脚本来启动，脚本内容如下：

consul agent -dev
pause

启动结果如下：

访问：http://localhost:8500，可以看到 Consul 的管理界面

应用

spring-cloud-consul：

1、service-provider：注册服务（立即）；检查Catalog服务列表（30s）；检查连接的consul client状态（30s）；

2、service-consumer：检查Catalog服务列表（30s）；找到服务后，检查服务健康状态（30s）；

Consul 服务端

创建一个 consul-producer 项目，依赖包如下：


  4.0.0
  com.adou.consul.consumer
  consul-consumer
  0.0.1-SNAPSHOT

	
		org.springframework.boot
		spring-boot-starter-parent
		2.0.3.RELEASE
		 
	

	
		Finchley.RELEASE
	

	
		
			
				org.springframework.cloud
				spring-cloud-dependencies
				${spring-cloud.version}
				pom
				import
			
		
	


	
		
			org.springframework.boot
			spring-boot-starter-actuator
		
		
			org.springframework.cloud
			spring-cloud-starter-consul-discovery
		
		
			org.springframework.boot
			spring-boot-starter-web
		
		
			org.springframework.boot
			spring-boot-starter-test
			test

spring-boot-starter-actuator 健康检查依赖于此包。
spring-cloud-starter-consul-discovery Spring Cloud Consul 的支持。
Spring Boot 版本使用的是 2.0.3.RELEASE，Spring Cloud 最新版本是 Finchley.RELEASE 依赖于 Spring Boot 2.x.

配置文件application.properties

spring.application.name=consul-producer
server.port=8501
spring.cloud.consul.host=localhost
spring.cloud.consul.port=8500
spring.cloud.consul.discovery.serviceName=service-producer

启动类

@SpringBootApplication
@EnableDiscoveryClient
public class ConsulProducerApplication {
 
	public static void main(String[] args) {
		SpringApplication.run(ConsulProducerApplication.class, args);
	}
}

提供服务

@RestController
public class HelloController {
 
    @RequestMapping("/hello")
    public String hello() {
        return "helle consul";
    }
}

模拟注册均衡负载复制一份上面的项目重命名为consul-producer-2 ,修改对应的端口为 8502，修改 hello 方法的返回值为：”helle consul2”，修改完成后依次启动两个项目。

再次在浏览器访问地址：http://localhost:8500，发现页面多了 service-producer 服务，点击进去后页面显示有两个服务提供者。显示如下：

Consul 消费端

创建一个 consul-consumer 项目，pom 文件和上面示例保持一致

配置文件

spring.application.name=consul-consumer
server.port=8503
spring.cloud.consul.host=locahost
spring.cloud.consul.port=8500
spring.cloud.consul.discovery.register=false

启动类

进行测试
创建一个 ServiceController ,试试如果去获取 Consul 中的服务

@RestController
public class ServiceController {
 
    @Autowired
    private LoadBalancerClient loadBalancer;
    @Autowired
    private DiscoveryClient discoveryClient;
 
   /**
     * 获取所有服务
     */
    @RequestMapping("/services")
    public Object services() {
        return discoveryClient.getInstances("service-producer");
    }
 
    /**
     * 从所有服务中选择一个服务（轮询）
     */
    @RequestMapping("/discover")
    public Object discover() {
        return loadBalancer.choose("service-producer").getUri().toString();
    }
}

添加完 ServiceController 之后我们启动项目，访问地址：http://localhost:8503/services，返回：

[{
	"serviceId": "service-producer",
	"host": "localhost",
	"port": 8501,
	"secure": false,
	"metadata": {
		"secure": "false"
	},
	"uri": "localhost:8501",
	"scheme": null
}, {
	"serviceId": "service-producer",
	"host": "localhost",
	"port": 8502,
	"secure": false,
	"metadata": {
		"secure": "false"
	},
	"uri": "localhost8502",
	"scheme": null
}]

发现我们刚才创建的端口为 8501 和 8502 的两个服务端都存在。

多次访问地址：http://localhost:8503/discover，页面会交替返回下面信息：

http://windows10.microdone.cn:8501
http://windows10.microdone.cn:8502
...

创建 CallHelloController ：
@RestController
public class CallHelloController {

@Autowired
private LoadBalancerClient loadBalancer;

@RequestMapping("/call")
public String call() {
    ServiceInstance serviceInstance = loadBalancer.choose("service-producer");
    System.out.println("服务地址：" + serviceInstance.getUri());
    System.out.println("服务名称：" + serviceInstance.getServiceId());

    String callServiceResult = new RestTemplate().getForObject(serviceInstance.getUri().toString() + "/hello", String.class);
    System.out.println(callServiceResult);
    return callServiceResult;
}

}
使用 RestTemplate 进行远程调用。添加完之后重启 consul-consumer 项目。在浏览器中访问地址：http://localhost:8503/call，依次返回结果如下：

helle consul
helle consul2
...

这里提供RestTemplate 远程调用工具类

mport java.util.Map;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

/**
 * RestTemplate 远程调用工具类
 * 
 * @author zhoudoujun01
 * @createDate 2019-09-12
 *
 */
public class RestTemplateUtils {

    private static final RestTemplate restTemplate = new RestTemplate();

    // ----------------------------------GET-------------------------------------------------------

    /**
     * GET请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity get(String url, Class responseType) {
        return restTemplate.getForEntity(url, responseType);
    }

    /**
     * GET请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity get(String url, Class responseType, Object... uriVariables) {
        return restTemplate.getForEntity(url, responseType, uriVariables);
    }

    /**
     * GET请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity get(String url, Class responseType, Map uriVariables) {
        return restTemplate.getForEntity(url, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity get(String url, Map headers, Class responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return get(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity get(String url, HttpHeaders headers, Class responseType, Object... uriVariables) {
        HttpEntity requestEntity = new HttpEntity(headers);
        return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity get(String url, Map headers, Class responseType, Map uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return get(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity get(String url, HttpHeaders headers, Class responseType, Map uriVariables) {
        HttpEntity requestEntity = new HttpEntity(headers);
        return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
    }

    // ----------------------------------POST-------------------------------------------------------

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @return
     */
    public static  ResponseEntity post(String url, Class responseType) {
        return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
    }

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity post(String url, Object requestBody, Class responseType) {
        return restTemplate.postForEntity(url, requestBody, responseType);
    }

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity post(String url, Object requestBody, Class responseType, Object... uriVariables) {
        return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
    }

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity post(String url, Object requestBody, Class responseType, Map uriVariables) {
        return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity post(String url, Map headers, Object requestBody, Class responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return post(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static  ResponseEntity post(String url, HttpHeaders headers, Object requestBody, Class responseType, Object... uriVariables) {
        HttpEntity