SpringCloud-服务注册与发现

服务注册与发现

前面我们没有服务注册中心,也可以服务间调用,为什么还要服务注册?

当服务很多时,单靠代码手动管理是很麻烦的,需要一个公共组件,统一管理多服务,包括服务是否正常运行,等

Eureka用于**服务注册,目前官网已经停止更新**

1、Eureka

服务治理

Spring Cloud封装了Netflix 公司开发的Eureka模块来实现服务治理

在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现

服务调用、负载均衡、容错等，实现服务发现与注册。

服务注册

Eureka采用了CS的设计架构，Eureka sever作为服务注册功能的服务器，它是服务注册中心。而系统中的其他做服务，使用 fureka的客户端连接到Eureka

Server并维持心跳连接。这样系统的维护人员就可以通过Eureka Server来监控系统中各个微服务是否正常运行。

在服务注册与发现中，有一个注册中心。当服务器启动的时候，会把当前自己服务器的信息，比如：服务地址通讯地址等以别名方式注册到注册中心上。另一方(消费者 | 服务提供者)，以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用

RPC远程调用框架核心设计思想：在于注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址)

Eureka的两个组件：

Eureka Server

Eureka Server 提供服务注册服务

各个微服务节点通过配置启动后，会在EurekaServer中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以

在界面中直观看到。

Eureka Client

Eureka Client 通过注册中心进行访问

是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向

Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点

移除（默认90秒)

单机版

EurekaServer端服务注册中心类似物业中心

EurekaClient端cloud-provider-payment8001将注册进EurekaServer 成为服务提供者provider

EurekaClient端cloud-consumer-order80将注册进EurekaServer 成为服务消费者consumer

1.创建cloud-eureka-server7001

2引入pom依赖

eureka最新的依赖变了

3.配置文件

server:
  port: 7001

# 单机版
eureka:
  instance:
    hostname: localhost  #eureka服务端的实例名字
  client:
    register-with-eureka: false    #表示不向注册中心注册自己
    fetch-registry: false   #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
    service-url:
      #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

4.主启动类

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

5.此时就可以启动当前项目了

浏览器输入：localhost:7001

6.其他服务注册到eureka

将payment模块加入eureka

1.在pom中添加依赖

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
dependency>

2.主启动类上，加注解。表示当前是eureka客户端

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

3.修改yml

eureka:
  client:
    # 表示是否将自己注册进EurekaServer 默认为true
    register-with-eureka: true
    # 是否从EurekaServer 抓取已有的注册信息。默认为true。单节点无所谓，集群必须设置为true才能配合ribbon 使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka

重启

成功注册

将order模块加入eureka

1.在pom中添加依赖

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
dependency>

2.主启动类上，加注解。表示当前是eureka客户端

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

3.修改yml

spring:
  application:
    name: cloud-order-service
eureka:
  client:
    # 表示是否将自己注册进EurekaServer 默认为true
    register-with-eureka: true
    # 是否从EurekaServer 抓取已有的注册信息。默认为true。单节点无所谓，集群必须设置为true才能配合ribbon 使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka

重启

集群

集群原理：

1,就是pay模块启动时,注册自己,并且自身信息也放入eureka
2.order模块,首先也注册自己,放入信息,当要调用pay时,先从eureka拿到pay的调用地址
3.通过HttpClient调用
并且还会缓存一份到本地,每30秒更新一次

微服务RPC远程服务调用最核心的是什么？

高可用：如果只有一个注册中心，出故障整个系统就瘫痪了。会导致整个微服务环境不可用。

解决办法：搭建Eureka注册中心集群，实现负载均衡+故障容错。

集群搭建原理：

互相注册

构建新erueka项目

cloud-eureka-server7002

1.pom文件

和7001一样即可

2.配置文件

在写配置文件之前，修改本机的hosts文件(C:\Windows\System32\drivers\etc)

# eureka
127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com
127.0.0.1 eureka7003.com

首先修改之前的7001的eureka项目,因为多个eureka需要互相注册

server:
  port: 7001
#集群版
eureka:
  instance:
    hostname: eureka7001.com    #eureka服务端的实例名字
  client:
    register-with-eureka: false    #表示不向注册中心注册自己
    fetch-registry: false   #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
    service-url:
      #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址
#      defaultZone: http://eureka7001.com:7001/eureka/
      defaultZone: http://eureka7002.com:7002/eureka/  #这个是集群版开启 互相注册

修改7002

server:
  port: 7002
#集群版
eureka:
  instance:
    hostname: eureka7002.com    #eureka服务端的实例名字
  client:
    register-with-eureka: false    #表示不向注册中心注册自己
    fetch-registry: false   #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
    service-url:
      #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址
#      defaultZone: http://eureka7002.com:7002/eureka/
      defaultZone: http://eureka7001.com:7001/eureka/  #这个是集群版开启 互相注册

3,主启动类:

复制7001的即可

4,然后启动7001,7002即可

将pay,order模块注册到eureka集群中:

1,只需要修改配置文件即可:

eureka:
  client:
    # 表示是否将自己注册进EurekaServer 默认为true
    register-with-eureka: true
    # 是否从EurekaServer 抓取已有的注册信息。默认为true。单节点无所谓，集群必须设置为true才能配合ribbon 使用负载均衡
    fetch-registry: true
    service-url:
      #      defaultZone: http://localhost:7001/eureka   # 单机版
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka    # 集群版

2,两个模块都修改上面的都一样即可

然后启动两个模块

要先启动7001,7002,然后是pay模块8001,然后是order(80)

将payment模块也配置为集群模式

1,创建新模块,8002

名称: cloud-provider-payment8002

2.pom文件

复制8001的

3,yml配置文件

复制8001的

端口修改成8002

服务名称不用改，用一样的

4.主启动类

复制8001的

修改为8002

5,mapper,service,controller都复制一份

为了区分，分别打印端口号：

@Slf4j
@RestController
@RequestMapping("/payment")
public class PaymentController {
    @Autowired
    private PaymentService paymentService;

    @Value("${server.port}")
    private String servicePort;

    @PostMapping("/create")
    public CommonResult<Payment> create(@RequestBody Payment payment){
        int result = paymentService.create(payment);
        log.info("****插入结果*****:"+result);
        if(result > 0){
            return new CommonResult(200,"插入数据库成功,serverPort: "+servicePort,result);
        }
        return new CommonResult(444,"插入数据库失败",result);
    }

    @GetMapping("/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        Payment payment = paymentService.getPaymentById(id);
        if(payment != null){
            return new CommonResult(200,"查询成功,serverPort: "+servicePort,payment);
        }
        return new CommonResult(444,"没有对应的记录，查询id"+id);
    }
}

然后就启动服务即可

此时访问order模块,发现并没有负载均衡到两个pay,模块中,而是只访问8001

虽然我们是使用RestTemplate访问的微服务,但是也可以负载均衡的

修改order80的访问地址

 //public static final String PAYMENT_URL = "http://localhost:8001";
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

注意这样还不行,需要让RestTemplate开启负载均衡注解,还可以指定负载均衡算法,默认轮询

修改RestTemplate的配置 添加@LoadBalanced

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

Ribben和Eureka 整合后Consumer可以直接调用服务而不用再关心地址和端口号，且改该服务还有负载能力了。

修改服务主机名和ip在eureka的web上显示

修改服务主机名

修改yml配置文件

添加instance.instance-id

eureka:
  client:
    # 表示是否将自己注册进EurekaServer 默认为true
    register-with-eureka: true
    # 是否从EurekaServer 抓取已有的注册信息。默认为true。单节点无所谓，集群必须设置为true才能配合ribbon 使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka   # 单机版
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka    # 集群版
  instance:
    instance-id: payment8001

同样的修改8002的

添加ip显示

修改yml配置文件

添加instance.prefer-ip-address

eureka:
  client:
    # 表示是否将自己注册进EurekaServer 默认为true
    register-with-eureka: true
    # 是否从EurekaServer 抓取已有的注册信息。默认为true。单节点无所谓，集群必须设置为true才能配合ribbon 使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka   # 单机版
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka    # 集群版
  instance:
    instance-id: payment8001
    prefer-ip-address: true       # 访问路径可以显示IP地址

同样的修改8002的

服务发现

对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息

以payment模块为例

1，引入DiscoveryClient

在controller里面

@Slf4j
@RestController
@RequestMapping("/payment")
public class PaymentController {
    @Autowired
    private PaymentService paymentService;

    @Value("${server.port}")
    private String servicePort;

    @Resource
    private DiscoveryClient discoveryClient;
    
        @GetMapping("/discovery")
    public Object discovery(){
        List<String> services = discoveryClient.getServices();
        for (String element : services) {
            log.info("*****element:  "+element);
        }

        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance instance : instances) {
            log.info("instance:"+instance.getInstanceId()+"\t"+instance.getHost()+"\t"+instance.getPort()+"\t"+instance.getUri());
        }
        return this.discoveryClient;
    }
}

2,在主启动类上添加一个注解

@EnableDiscoveryClient

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

然后重启8001。访问/payment/discovery

Eureka的自我保护机制

自我保护机制原理

保护模式主要用于一组客户端和Eureka Server之间存在网络分区场景下的保护。
一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据，也就是不会注销任何微服务。

如果在Eureka Server的首页看到以下这段提示，则说明Eureka进入了保护模式:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XZLJT1Qc-1658487143734)(SpringCloud/image-20220717174142427.png)]

即：某时刻某一个微服务不可用了。Eureka不会立刻清理，依旧会对该微服务的信息进行保存。（属于CAP里面的AP分支）

• 为什么会产生Eureka自我保护机制？

为了防lEurekaClient可以正常运行，但是与EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除

• 什么是自我保护机制？

默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒)。但是当网络分区故障发生(延时、卡

顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。

Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时(可能发生了网络分区故障)，那么这个节点就会进入自我保护模

式。

总结：

在自我保护模式中，Eureka Server会保护服务注册表中的信息，不再注销任何服务实例。

它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话讲解：好死不如赖活着

综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留）)也不盲目注销

任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮、稳定。

禁止自我保护

以7001和8001为例

修改7001的yml：

eureka:
  instance:
    hostname: eureka7001.com    #eureka服务端的实例名字
  client:
    register-with-eureka: false    #表示不向注册中心注册自己
    fetch-registry: false   #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
    service-url:
      #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7001/eureka/
#      defaultZone: http://eureka7002.com:7002/eureka/  #这个是集群版开启 互相注册 集群就是指向其他的eureka
  server:
#    关闭自我保护机制，保证不可用服务被及时踢除
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 2000

修改8001的yml

eureka:
  client:
    # 表示是否将自己注册进EurekaServer 默认为true
    register-with-eureka: true
    # 是否从EurekaServer 抓取已有的注册信息。默认为true。单节点无所谓，集群必须设置为true才能配合ribbon 使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka   # 单机版
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka    # 集群版
  instance:
    instance-id: payment8001
    prefer-ip-address: true       # 访问路径可以显示IP地址
    # Eureka 客户端向服务端发送心跳的时间间隔，单位为秒（默认为30秒）
    lease-renewal-interval-in-seconds: 1
    # Eureka 客户端在收到最后一次心跳后等待的时间上限，单位为秒（默认为90秒），超时将剔除服务
    lease-expiration-duration-in-seconds: 2

先关闭8001

此时启动erueka和pay.此时如果直接关闭了pay,那么erueka会直接删除其注册信息

2、Zookeeper

zookeeper是一个分布式协调工具，可以实现注册中心功能

关闭Linux服务器防火墙后启动zookeeper服务器

Zookeeper服务器取代Eureka服务器，zk作为服务注册中心

1.安装zookeeper并启动

2.创建新的pay模块

单独用于注册到zk中

名字：cloud-provider-zookeeper-payment8004

1.pom依赖

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-zookeeper-discoveryartifactId>
        dependency>

        <dependency>
            <groupId>org.examplegroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>${project.version}version>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
        dependency>
    dependencies>

2.yml配置文件

# 8004 表示注册到zookeeper服务器的支付服务提供者端口号
server:
  port: 8004

# 服务别名----注册到zookeeper 到注册中心的名称
spring:
  application:
    name: cloud-provider-payment
  cloud:
    zookeeper:
      connect-string: 192.168.160.128:2181

3,主启动类

@SpringBootApplication
// 该注解用于向使用consul或者zookeeper 作为注册中心时的注册服务
@EnableDiscoveryClient
public class PaymentMain8004 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8004.class,args);
    }
}

4,controller

@Slf4j
@RestController
@RequestMapping("/payment")
public class PaymentController {
    @Value("${server.port}")
    private String serverPort;

    @RequestMapping("/zk")
    public String paymentZk(){
        return "Springcloud with zookeeper:  "+serverPort +"\t"+ UUID.randomUUID();
    }

}

5,启动

此时启动,会报错,因为jar包与我们的zk版本不匹配

修改pom文件，改成与我们zk相匹配的jar包

eg：

再次重启：

此时8004就已经注册到zk中了。

6.测试

• 验证测试：浏览器 - http://localhost:8004/payment/zk

• 验证测试2 ：接着用zookeeper客户端操作
  

[zk: localhost:2181(CONNECTED) 5] ls /services/cloud-provider-payment
[9e03f796-9672-4136-ae32-84f0de4ccacc]
[zk: localhost:2181(CONNECTED) 6] ls /services/cloud-provider-payment/9e03f796-9672-4136-ae32-84f0de4ccacc
[]
[zk: localhost:2181(CONNECTED) 7] get /services/cloud-provider-payment/9e03f796-9672-4136-ae32-84f0de4ccacc
{"name":"cloud-provider-payment","id":"9e03f796-9672-4136-ae32-84f0de4ccacc","address":"DESKTOP-3058MDQ.lan","port":8004,"sslPort":null,"payload":{"@class":"org.springframework.cloud.zookeeper.discovery.ZookeeperInstance","id":"application-1","name":"cloud-provider-payment","metadata":{}},"registrationTimeUTC":1658057554392,"serviceType":"DYNAMIC","uriSpec":{"parts":[{"value":"scheme","variable":true},{"value":"://","variable":false},{"value":"address","variable":true},{"value":":","variable":false},{"value":"port","variable":true}]}}

json格式化get /services/cloud-provider-payment/a4567f50-6ad9-47a3-9fbb-7391f41a9f3d的结果：

{
    "name": "cloud-provider-payment",
    "id": "9e03f796-9672-4136-ae32-84f0de4ccacc",
    "address": "DESKTOP-3058MDQ.lan",
    "port": 8004,
    "sslPort": null,
    "payload": {
        "@class": "org.springframework.cloud.zookeeper.discovery.ZookeeperInstance",
        "id": "application-1",
        "name": "cloud-provider-payment",
        "metadata": {}
    },
    "registrationTimeUTC": 1658057554392,
    "serviceType": "DYNAMIC",
    "uriSpec": {
        "parts": [
            {
                "value": "scheme",
                "variable": true
            },
            {
                "value": "://",
                "variable": false
            },
            {
                "value": "address",
                "variable": true
            },
            {
                "value": ":",
                "variable": false
            },
            {
                "value": "port",
                "variable": true
            }
        ]
    }
}

ZooKeeper的服务节点是临时节点，没有Eureka那含情脉脉。

3.创建order消费模块注册到zk

1,创建项目

名字: cloud-consum-zookeeper-order80

2,pom

 <dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-zookeeper-discoveryartifactId>
        dependency>

        <dependency>
            <groupId>org.examplegroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>${project.version}version>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
        dependency>
    dependencies>

3,配置文件

server:
  port: 80

# 服务别名----注册到zookeeper 到注册中心的名称
spring:
  application:
    name: cloud-consumer-order
  cloud:
    zookeeper:
      connect-string: 127.0.0.1:2181  # 192.168.160.128:2181

4,主启动类

@SpringBootApplication
// 该注解用于向使用consul或者zookeeper 作为注册中心时的注册服务
@EnableDiscoveryClient
public class OrderZKMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderZKMain80.class,args);
    }
}

5,配置类

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

6,业务类

@Slf4j
@RestController
@RequestMapping("/payment")
public class OrderZKController {
    public static final String INVOKE_URL = "http://cloud-provider-payment";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping(value = "/consumer/payment/zk")
    public String paymentInfo()
    {
        String result = restTemplate.getForObject(INVOKE_URL+"/payment/zk",String.class);
        return result;
    }
}

7,启动

可以发现已经注册

8、集群版的zk注册

只需修改配置文件

这个connect-string指定多个zk地址即可

connect-string: 1.2.3.4,2.3.4.5

3、consul

简介

Consul官网

Consul下载地址

What is Consul?

Consul is a service mesh solution providing a full featured control plane with service discovery, configuration, and segmentation functionality. Each of these features can be used individually as needed, or they can be used together to build a full service mesh. Consul requires a data plane and supports both a proxy and native integration model. Consul ships with a simple built-in proxy so that everything works out of the box, but also supports 3rd party proxy integrations such as Envoy. link

Consul是一个服务网格解决方案，它提供了一个功能齐全的控制平面，具有服务发现、配置和分段功能。这些特性中的每一个都可以根据需要单独使用，也可以一起用于构建全服务网格。Consul需要一个数据平面，并支持代理和本机集成模型。Consul船与一个简单的内置代理，使一切工作的开箱即用，但也支持第三方代理集成，如Envoy。

基本概念

Consul是一套开源的分布式服务发现和配置管理系统，由HashiCorp公司用Go语言开发。

提供了微服务系统中的服务治理、配置中心、控制总线等功能。这些功能中的每一个都可以根据需要单独使用，也可以一起使用以构建全方位的服务网格，总之

Consul提供了一种完整的服务网格解决方案。

它具有很多优点。包括:基于raft协议，比较简洁;支持健康检查,同时支持HTTP和DNS协议支持跨数据中心的WAN集群提供图形界面跨平台，支持Linux、Mac、Windows

功能

• 服务发现
  • 提供http和dns两种发现方式
• 健康检测
  • 支持多种方式，http、tcp、docker、shell脚本定制化
• kv存储
  • key、value的存储方式
• 多数据中心
  • consul支持多数据中心
• 可视化web界面

怎么玩

安装并运行consul

官网安装说明

windows版解压缩后，得consul.exe，打开cmd

查看版本 consul -v :

D:\studytools\springcloud\consul>consul -v
Consul v1.12.3
Revision 2308c75e
Protocol 2 spoken by default, understands 2 to 3 (agent will automatically use protocol >2 when speaking to compatible agents)

开发模式启动consul agent -dev：

浏览器输入 - http://localhost:8500/ - 打开Consul控制页。

服务提供者注册进consul

1.新建Module支付服务provider8006

名字cloud-provider-consul-payment8006

2.pom依赖

<dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-consul-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>org.examplegroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>${project.version}version>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
        dependency>
    dependencies>

3.yml配置

# consul 服务端口号
server:
  port: 8006

spring:
  application:
    name: cloud-provider-payment
  cloud:
    # consul注册中心地址
    consul:
      host: localhost
      port: 8500
      discovery:
        #hostname 127.0.0.1
        service-name: ${spring.application.name}

4.主启动类

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

5.业务类controller

@Slf4j
@RestController
@RequestMapping("/payment")
public class PaymentController {

    @Value("${server.port}")
    private String serverPort;

    @RequestMapping("/consul")
    public String paymentZk(){
        return "SpringCloud with consul:  "+serverPort +"\t"+ UUID.randomUUID();
    }
}

6.验证测试

服务消费者注册进consul

1.新建Module消费服务order80

名字cloud-consumer-consul-order80

2.pom依赖

<dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-consul-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>org.examplegroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>${project.version}version>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
        dependency>
    dependencies>

3.yml配置

# consul 服务端口号
server:
  port: 80

spring:
  application:
    name: cloud-consul-order
  cloud:
    # consul注册中心地址
    consul:
      host: localhost
      port: 8500
      discovery:
        #hostname 127.0.0.1
        service-name: ${spring.application.name}

4.主启动类

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

5配置类

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

6.业务类controller

@Slf4j
@RestController
@RequestMapping("/consumer")
public class OrderConsulController {
    public static final String INVOKE_URL = "http://cloud-provider-payment";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping(value = "/payment/consul")
    public String paymentInfo()
    {
       return restTemplate.getForObject(INVOKE_URL+"/payment/consul",String.class);
    }

}

7.验证测试

运行consul，cloud-provider-consul-payment8006，cloud-consumer-consul-order80

http://localhost:8500/ 主页会显示出consul，cloud-providerconsul-payment8006，cloud-consumerconsul-order80三服务。

三个注册中心异同点

组件名	语言	CAP	服务健康检查	对外暴露接口	Spring Cloud集成
Eureka	Java	AP	可配支持	HTTP	已集成
Consul	Go	CP	支持	HTTP/DNS	已集成
Zookeeper	Java	CP	支持	客户端	已集成

CAP：

• C：Consistency (强一致性)
• A：Availability (可用性)
• P：Partition tolerance （分区容错性)

CAP理论关注粒度是数据，而不是整体系统设计的策略

最多只能同时较好的满足两个。

CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求。

因此，根据CAP原理将NoSQL数据库分成了满足CA原则、满足CP原则和满足AP原则三大类:

• CA - 单点集群，满足—致性，可用性的系统，通常在可扩展性上不太强大。
• CP - 满足一致性，分区容忍必的系统，通常性能不是特别高。
• AP - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。

AP架构（Eureka）

当网络分区出现后，为了保证可用性，系统B可以返回旧值，保证系统的可用性。

结论：违背了一致性C的要求，只满足可用性和分区容错，即AP

CP架构（ZooKeeper/Consul）

当网络分区出现后，为了保证一致性，就必须拒接请求，否则无法保证一致性。

结论：违背了可用性A的要求，只满足一致性和分区容错，即CP。

CP 与 AP 对立同一的矛盾关系。