服务注册与发现
前面我们没有服务注册中心,也可以服务间调用,为什么还要服务注册?
当服务很多时,单靠代码手动管理是很麻烦的,需要一个公共组件,统一管理多服务,包括服务是否正常运行,等
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中添加依赖
<!--Eureka-client-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</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中添加依赖
<!--Eureka-client-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</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>
<!--springboot 整合 zookeeper 客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
</dependency>
<dependency>
<groupId>org.example</groupId>
<artifactId>cloud-api-commons</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</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>
<!--springboot 整合 zookeeper 客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
</dependency>
<dependency>
<groupId>org.example</groupId>
<artifactId>cloud-api-commons</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</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
简介
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>
<!--springboot 整合 consul 客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>
<!-- 引入自己定义的api通用包,可以使用Payment支付Entity -->
<dependency>
<groupId>org.example</groupId>
<artifactId>cloud-api-commons</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</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>
<!--springboot 整合 consul 客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>
<!-- 引入自己定义的api通用包,可以使用Payment支付Entity -->
<dependency>
<groupId>org.example</groupId>
<artifactId>cloud-api-commons</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</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 对立同一的矛盾关系。