微服务框架
2019年11月13日
14:51
1.纵向拆分的独立系统的集群问题
1.1没有引入管理的功能
系统的管理权,授权,监听,熔断等逻辑都没有引入
1.2在静态配置的负载均衡的强耦合
在庞大的纵向拆分的集群中,nginx的静态文件维护的负载均衡逻辑,很容易出现强耦合,如集群中某些节点出现宕机/迁移,可以引入微服务的概念,从架构的角度去解决问题
2.微服务框架
2.1微服务
从一个单体项目,从一个功能比较集中的项目中纵向拆分出来独立运行的每个功能,每一个功能的系统就是微服务
微------纵向拆分
服务------功能被调用
2.2定义
一个框架计数能够管理大量的拆分的独立系统,监控,熔断等功能,这种框架计数就是微服务框架
2.3 springcloud
轻量级的微服务框架,可以给予springboot的自动配置(减少了自定义的大量代码编写,实现了多个微服务框架组件的功能
eureka : 服务治理
ribbon : 客户端负载均衡调用
zuul : 网关,微服务唯一对外提供的接口
feign: ribbon是同一种客户端,封住哪个了ribbon
hystrix :熔断器
config : 微服务中配置文件的管理者
Springcloud的组件
2019年11月13日
15:30
1.Eureka服务治理组件
Springcloud中的核心组件,可以实现对整个微服务集群中所有节点进行服务的发现,服务的抓取,服务的监听
1.1服务治理的概念中三个角色
- 服务注册中心 : 所有的服务的集中管理角色
- 服务的提供者 : 服务提供者会将自己的信息打包(ip,port,服务名称等等),注册在注册中心,并且被注册中心管理和维护(注册)
- 服务的调用者 : 可以通过对注册中心的访问,获取服务的提供者的信息,从而进行负载均衡的调用(抓取发现)
1.2入门案例-----注册中心
准备一个springboot+springcloud开发环境的工程
- 导入所有的springcloud的相关依赖
- 引入eureka注册中心的依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>
- application.properties
#服务启动端口
server.port=8888
#eureka相关配置
#关闭当前配置中心的服务抓取和注册
#如果自己到自己注册,需要提供服务名称
spring.application.name=eurekaserver
eureka.client.registerWithEureka=true
eureka.client.fetchRegistry=false
#注册中心的地址,但是凡事服务注册这都需要配这个地址,
#注册者会访问这个地址的接口,携带自己节点的信息注册
eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureka
- 启动类
添加一个eureka的注解,就能实现启动加载eureka的自动配置逻辑,实现一个web应用包含一个eurekaserver的进程
@springBootApplication
@EnableEurekaServer
//eureka注册中心进程启动需要springboot加载扫描的注解
public class StarterEurekaServer{
public static void main(String[] args){
SpringApplication.run(StarterEurekaServer.class,args);
}
}
- web页面
访问http://localhost:8888/
上图显示是当前注册中心维护的所有服务信息,展示的服务名称,服务实例名称(内存中维护的服务的详细信息)
- 注册中心的作用
- 管理注册者的服务信息
内部接收注册者的请求,注册者携带本机/节点的详细参数(ip,port,服务名称)发送给注册中心,eureka接收请求,在内存中存储一个双层map对象,保存所有的内容
- 服务的监听超时
多个注册者同时注册一个服务,相当于一个具体的服务被一个集群管理者接收请求,每60秒判断是否有服务提供者的续约超时达到90秒,一旦满足条件,将会从内存中间超时的实例剔除
1.3入门案例 -----服务提供者
创建了一个工程springboot+springcloud可以被调用一个资源访问/hello,作为一个服务提供者,必须生成一个服务名称service-hi ,注册在注册中心
- 搭建一个springboot+springcloud环境
pom文件导入springboot相关依赖
- 引入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
客户端依赖
starter-eureka-server包含了这个依赖
- application.properties
#服务启动端口
server.port=9001
#服务名称
spring.application.name=service-hi
#注册/发现开启(默认开启)
#eureka.client.registerWithEureka=true
#服务抓取
#eureka.client.fetchRegistry=true
#注册中心的地址,但凡是服务注册者都需要配置这个地址,
#注册者会访问这个地址的接口,携带自己节点的信息注册
eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureka
- 启动类
@SpringBootApplication
@EnableEurekaClient //客户端注解
public class StarterEurekaClient1{
public static void main (String[] args){
SpringApplication.run(StarterEurekaClient1.class,args);
}
}
- 调用功能
/hello?name=wang 返回字符串
@RestController
public class HelloController{
@RequestMapping("hello")
public String sayHi(String name){
return "hello"+name+",I am from 9001";
}
}
- 高可用的集群注册同一个服务
client-client1 eureka-client2
复制client1位client2,并且更改:
server.port=9002
controller返回值 I am from 9002
启动类StarterEuerkaClient2
注册者实现逻辑:
注册: 启动后,当前eureka client,一旦赋予注册能力,registerWithEureka=true,将会访问注册中心接口8888/eureka携带详细信息,注册在注册中心,注册中心以服务名称为key值记录一个当前服务的所有节点信息的map对象
续约 : eureka client 一旦在注册中心提供注册的信息,将会每30秒发送一次心跳(heartbeat)请求,告知注册中心,当前实例是存活的
服务剔除:
30: 客户端发起心跳
60: 注册中心,每隔60秒检测一次心跳的最后时间
90: 注册中心,检测发现超过90秒没有发起心跳检测将会把该实例剔除
注册中心的保护机制
EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.
庞大的集群中,如果按照正常的逻辑,管理一个微服务集群(100个服务,每个20个节点2000个注册者),超时续约的个数如果在15%以内,eureka注册中心,判断是正常超时,将会按照剔除逻辑对实例进行内存数据的清除,如果超过15%,认为是不正常超时,会开启保护机制,一旦开启,所有服务信息(map对象)不会做任何的剔除,形成对微服务的保护.
如果需要观察剔除的现象可以将保护机制关闭,在注册中心将保护机制关闭:
#关闭保护机制
eureka.server.enable-self-preservation=false
eureka.instance.prefer-ip-address=true
2.ribbon组件
配合服务治理组件eureka的客户端的发现功能,从注册中心抓取最新的服务注册信息,从而可以在代码内部发起向该服务的访问,使用注册信息中实例的详细信息访问不同节点实现负载均衡.这就是ribbon组件: 可以调用服务,支持负载均衡访问springcloud客户端组件
ribbon只能实现管理抓取的拦截逻辑,对restTemplate发送的请求做拦截处理
2.1入门案例ribbon负载均衡调用9001/9002
- 创建一个具备开发springboot+springcloud功能的maven工程
- pom文件添加依赖
- springboot相关依赖
- eureka-client(抓取服务)
- ribbon的组件相关依赖
- application.properties
- server.port=9004
- 服务名称 service-ribbon
spring.application.name=service-ribbon
- 注册抓取 /true
- 注册url地址
eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureka
- 启动类
ereuka client相关注解,创建一个springboot框架管理的内存对象
@Bean
@loadBalanced
RestTemplate
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
@SpringBootApplication
@EnableEurekaClient
public class StarterRibbon {
public static void main(String[] args) {
SpringApplication.run(StarterRibbon.class, args);
}
@Bean //表明方法的返回值需要Spring管理
@LoadBalanced //添加负载均衡功能
public RestTemplate initRestTemplate(){
return new RestTemplate();
}}
2.2实现一个负载均衡的调用后段服务service-hi
编写一个ribbon的对外访问的url接口 localhost:9004/hi?name=wang
通过ribbon直接实现负载均衡访问9001/9002
HelloController
@RestController
public class HelloController {
@Autowired
private HelloService helloService;
//客户端调用hi接口
@RequestMapping("hi")
public String sayHi(String name){
return "RIBBON:"+helloService.sayHi(name);
}
}
HelloService
@Autowired
private RestTemplate client;//会因为使用而创建过程
//@Bean+@LoadBalanced注解，ribbon会对restTemplate发送
//任何请求做拦截工作，将域名寻找抓取的服务名称做实力节点
//节点的ip:port的替换
public String sayHi(String name) {
//http://service-hi/hello?name=wang
String sayHi=client.getForObject(
"http://service-hi/hello?name="+name,
String.class);
return sayHi;
}
2.3实现动态扩充服务提供者
单独访问ribbon工程可以实现SpringCloud的ribbon组件做服务调用服务的功能测试,对于被调用的服务service-hi,只要启动9003作为扩容的节点,添加到eureka注册中心,注册中心维护的注册信息将会发生变动
ribbon工程整合了eureka client可以实现服务的抓起,每30秒重新更新抓取一次服务注册信息的map数据
2.4负载均衡的方式
| 微服务框架 2019年11月13日 14:51 1.纵向拆分的独立系统的集群问题 1.1没有引入管理的功能 系统的管理权,授权,监听,熔断等逻辑都没有引入 1.2在静态配置的负载均衡的强耦合 在庞大的纵向拆分的集群中,nginx的静态文件维护的负载均衡逻辑,很容易出现强耦合,如集群中某些节点出现宕机/迁移,可以引入微服务的概念,从架构的角度去解决问题 2.微服务框架 2.1微服务 从一个单体项目,从一个功能比较集中的项目中纵向拆分出来独立运行的每个功能,每一个功能的系统就是微服务 微------纵向拆分 服务------功能被调用 2.2定义 一个框架计数能够管理大量的拆分的独立系统,监控,熔断等功能,这种框架计数就是微服务框架 2.3 springcloud 轻量级的微服务框架,可以给予springboot的自动配置(减少了自定义的大量代码编写,实现了多个微服务框架组件的功能
eureka : 服务治理 ribbon : 客户端负载均衡调用 zuul : 网关,微服务唯一对外提供的接口 feign: ribbon是同一种客户端,封住哪个了ribbon hystrix :熔断器 config : 微服务中配置文件的管理者
Springcloud的eureka组件+ribbon组件 2019年11月13日 15:30 1.Eureka服务治理组件 Springcloud中的核心组件,可以实现对整个微服务集群中所有节点进行服务的发现,服务的抓取,服务的监听 1.1服务治理的概念中三个角色
1.2入门案例-----注册中心 准备一个springboot+springcloud开发环境的工程
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-eureka-server</artifactId> </dependency>
#服务启动端口 server.port=8888 #eureka相关配置 #关闭当前配置中心的服务抓取和注册 #如果自己到自己注册,需要提供服务名称 spring.application.name=eurekaserver eureka.client.registerWithEureka=true eureka.client.fetchRegistry=false #注册中心的地址,但是凡事服务注册这都需要配这个地址, #注册者会访问这个地址的接口,携带自己节点的信息注册 eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureka
添加一个eureka的注解,就能实现启动加载eureka的自动配置逻辑,实现一个web应用包含一个eurekaserver的进程 @springBootApplication @EnableEurekaServer //eureka注册中心进程启动需要springboot加载扫描的注解 public class StarterEurekaServer{ public static void main(String[] args){ SpringApplication.run(StarterEurekaServer.class,args); } }
访问http://localhost:8888/
上图显示是当前注册中心维护的所有服务信息,展示的服务名称,服务实例名称(内存中维护的服务的详细信息)
内部接收注册者的请求,注册者携带本机/节点的详细参数(ip,port,服务名称)发送给注册中心,eureka接收请求,在内存中存储一个双层map对象,保存所有的内容
多个注册者同时注册一个服务,相当于一个具体的服务被一个集群管理者接收请求,每60秒判断是否有服务提供者的续约超时达到90秒,一旦满足条件,将会从内存中间超时的实例剔除 1.3入门案例 -----服务提供者 创建了一个工程springboot+springcloud可以被调用一个资源访问/hello,作为一个服务提供者,必须生成一个服务名称service-hi ,注册在注册中心
pom文件导入springboot相关依赖
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-eureka</artifactId> </dependency> 客户端依赖 starter-eureka-server包含了这个依赖
#服务启动端口 server.port=9001 #服务名称 spring.application.name=service-hi #注册/发现开启(默认开启) #eureka.client.registerWithEureka=true #服务抓取 #eureka.client.fetchRegistry=true #注册中心的地址,但凡是服务注册者都需要配置这个地址, #注册者会访问这个地址的接口,携带自己节点的信息注册 eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureka
@SpringBootApplication @EnableEurekaClient //客户端注解 public class StarterEurekaClient1{ public static void main (String[] args){ SpringApplication.run(StarterEurekaClient1.class,args); } }
/hello?name=wang 返回字符串 @RestController public class HelloController{ @RequestMapping("hello") public String sayHi(String name){ return "hello"+name+",I am from 9001"; } }
client-client1 eureka-client2 复制client1位client2,并且更改: server.port=9002 controller返回值 I am from 9002 启动类StarterEuerkaClient2
注册者实现逻辑: 注册: 启动后,当前eureka client,一旦赋予注册能力,registerWithEureka=true,将会访问注册中心接口8888/eureka携带详细信息,注册在注册中心,注册中心以服务名称为key值记录一个当前服务的所有节点信息的map对象 续约 : eureka client 一旦在注册中心提供注册的信息,将会每30秒发送一次心跳(heartbeat)请求,告知注册中心,当前实例是存活的
服务剔除: 30: 客户端发起心跳 60: 注册中心,每隔60秒检测一次心跳的最后时间 90: 注册中心,检测发现超过90秒没有发起心跳检测将会把该实例剔除 注册中心的保护机制 EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE. 庞大的集群中,如果按照正常的逻辑,管理一个微服务集群(100个服务,每个20个节点2000个注册者),超时续约的个数如果在15%以内,eureka注册中心,判断是正常超时,将会按照剔除逻辑对实例进行内存数据的清除,如果超过15%,认为是不正常超时,会开启保护机制,一旦开启,所有服务信息(map对象)不会做任何的剔除,形成对微服务的保护.
如果需要观察剔除的现象可以将保护机制关闭,在注册中心将保护机制关闭: #关闭保护机制 eureka.server.enable-self-preservation=false eureka.instance.prefer-ip-address=true 2.ribbon组件 配合服务治理组件eureka的客户端的发现功能,从注册中心抓取最新的服务注册信息,从而可以在代码内部发起向该服务的访问,使用注册信息中实例的详细信息访问不同节点实现负载均衡.这就是ribbon组件: 可以调用服务,支持负载均衡访问springcloud客户端组件 ribbon只能实现管理抓取的拦截逻辑,对restTemplate发送的请求做拦截处理 2.1入门案例ribbon负载均衡调用9001/9002
spring.application.name=service-ribbon
eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureka
ereuka client相关注解,创建一个springboot框架管理的内存对象 @Bean @loadBalanced RestTemplate import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.loadbalancer.LoadBalanced; import org.springframework.cloud.netflix.eureka.EnableEurekaClient; import org.springframework.context.annotation.Bean; import org.springframework.web.client.RestTemplate;
@SpringBootApplication @EnableEurekaClient public class StarterRibbon { public static void main(String[] args) { SpringApplication.run(StarterRibbon.class, args); } @Bean //表明方法的返回值需要Spring管理 @LoadBalanced //添加负载均衡功能 public RestTemplate initRestTemplate(){ return new RestTemplate(); }} 2.2实现一个负载均衡的调用后段服务service-hi 编写一个ribbon的对外访问的url接口 localhost:9004/hi?name=wang
通过ribbon直接实现负载均衡访问9001/9002 HelloController @RestController public class HelloController { @Autowired private HelloService helloService; //客户端调用hi接口 @RequestMapping("hi") public String sayHi(String name){ return "RIBBON:"+helloService.sayHi(name); } } HelloService @Autowired private RestTemplate client;//会因为使用而创建过程
//@Bean+@LoadBalanced注解，ribbon会对restTemplate发送 //任何请求做拦截工作，将域名寻找抓取的服务名称做实力节点 //节点的ip:port的替换 public String sayHi(String name) { //http://service-hi/hello?name=wang String sayHi=client.getForObject( "http://service-hi/hello?name="+name, String.class); return sayHi; } 2.3实现动态扩充服务提供者 单独访问ribbon工程可以实现SpringCloud的ribbon组件做服务调用服务的功能测试,对于被调用的服务service-hi,只要启动9003作为扩容的节点,添加到eureka注册中心,注册中心维护的注册信息将会发生变动 ribbon工程整合了eureka client可以实现服务的抓起,每30秒重新更新抓取一次服务注册信息的map数据 2.4负载均衡的方式
ribbon组件会根据定义的bean对象实现负载均衡,只要创建的bean对象就可以,没有发现工程创建任何均衡对象,就会默认使用轮询 @Bean public Irule initRule(){ return new RandomRule(); } 2.5ribbon实现负载均衡访问服务的原理
注意: springcloud中只要是服务调用服务的过程都是通过ribbon+RestTemplate(zuul feign也是) 3.zuul网关集群的调用结构
完成时限eureka注册中心的高可用
springcloud的zuul组件 2019年11月13日 19:52 1.zuul组件 1.1 介绍 zuul是springcloud中提供的网关组件,可以实现整体微服务集群对外访问的入口,其他任何服务的提供者,服务的调用者的外界访问,都必须通过zuul来实现
1.2zuul测试工程
网关zuul默认过滤掉一些蜜柑header,其中就有cookie,关闭拦截敏感头,使得cookie生效(等号右侧不写即关闭)
@SpringBootApplication @EnableEurekaClient @EnableZuulProxy
#service-ribbon service-hi zuul.routes.hi.path=/zuul-hi/** zuul.routes.hi.serviceId=service-hi 所有的请求都要经过网关才能访问集群中的服务, hi: 自定义的路由名称 一对zuul.routes.hi.**相互关联 path: 访问zuul网关工程url匹配这个路由规则
serviceId: 符合path路由规则的url将会被转发到的服务(zuul封装ribbon的调用) 1.3zuul访问流程 eureka注册中心,eurekaclient service-hi,zuul网关 常见问题: zuul一旦启动,需要先抓取到注册信息,才能实现路由的转发和服务功能,启动后,不一定直接抓取到正确的服务列表,再找不到服务时,会出现forwarding error转发失败的提示,即无法找到有效地服务,异常信息: com.netflix.zuul.exception.ZuulException: Forwarding error Caused by: com.netflix.client.ClientException: Load balancer does not have available server for client: service-ribbon
访问service-hi的服务功能,需要根据zuul提供的对外暴露的接口访问服务: http://localhost:8103/zuul-hi/Hello?name=wang 过程
1.4zuul和nginx整合 http://www.ssm.com/hello?name=wang nginx配置访问网关集群 location /hello{ proxy_pass http://zuulserver/zuul-hi/hello; } upstream zuulserver{ server 127.0.0.1:8103; } 流转逻辑(必须掌握)
1.5zuul高可用集群 复制一个zuul工程,修改端口8104 nginx的upstream server 127.0.0.1:8104; 1.6转发给service-ribbon 如何配置zuul zuul.routes.ribbon.path=/zuul-ribbon/** zuul.routes.ribbon.serviceId=service-ribbon 如何配置nginx location /hi{ proxy_pass http://zuulserver/zuul-ribbon/hi } 如何访问 : http://www.ssm.com/hi?name=wang 访问的流转逻辑
最终访问: http://127.0.0.1:9004/hi?name=wang 微服务集群内部调用: http://127.0.0.1:9001或者9002/hello?name=wang 2.注册中心 eureka server高可用
注册中心高可用集群,即集群中的注册中心互为客户端,相互注册自己的信息到对方,相关抓取服务(注册true,抓取true),发现相同服务名称的内容合并同步,保持一致 2.1搭建高可用eureka注册中心 每一个注册中的客户端的配置中,需要配置一个ipAddressPrefer,底层通信记录以ip信息优先,否则会使用localhost(会使用域名),不会进行数据同步
开启客户端抓取功能 eureka.client.fetchRegister=true 配置相互注册的serviceUrl 8888配置8889端口 8889配置8888端口 server.port=8888 eureka.client.serviceUrl.defaultZone=http://localhost:8889/eureka
server.port=8889 eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureke
开启ip地址优先的配置 eureka.instance.prefer-ip-address=true
修改端口 注册中心地址
eureka.client.serverUrl.defaultZone=http://localhost:8888/eureka,http://localhost:8889/eureka
springcloud的feign 2019年11月20日 15:41 和ribbon的关系: feign是负载均衡访问/调用微服务客户端组件,底层封装了ribbon+restTemplate实现调用,并且利用声明式的注解来调用,开发代码简介----做公用服务调用统一的入口 2.开发一个feign客户端工程
3.注解使用 类注解: FeignClient(当前类访问拼接的服务名称) 方法注解: RequestMapping: 定义访问后端服务的url接口和访问的方式 RequestParam/RequestBody :定义参数携带的名称和方式 4. feign和ribbon的对比 ribbon: 可以在业务层中对于调用的前后逻辑做封装 feign: 服务调用过程只能通过注解实现,调用单一 应用场景: ribbon哪都能用 feign一般使用在公共服务的调用入口编程,feign的业务实现层实现代码中使用的注解,几乎和后端调用服务的注解相同(service--->后端controller) feign客户端中自动支持熔断机制的断路器和服务降级
SpringCloud的hystrix 2019年11月20日 15:55 1.熔断机制 微服务集群,服务调用关系,在微服务集群存在大量功能时,调用链,调用逻辑可能非常复杂,经常会出现同一个服务被不同的调用功能调用
为了解决一个服务中某个服务的实例故障或不可达导致请求压力积压问题,需要引入熔断机制 2.熔断机制的内容 工作原理: 牺牲局部保存全局,退而求其次的获取响应结果
直接牺牲后端不用的服务提供者,不再访问该服务的实例 断路器的三种状态: 断路器打开: 断路器一旦打开,后端服务提供者就不会被访问 断路器半开: 断路器尝试将一部分请求发送给故障后的服务实例 断路器关闭: 直接连接后端服务实例
断路器在牺牲局部的原则下使得大量的访问不会通过故障的服务实例返回请求,总会出现部分请求访问超时断开,不正常----服务降级,当该服务故障后,依然通过的各种请求,退而求其次的响应 3.基于ribbon功能添加熔断器hystrix实现断路器和服务降级 pom添加hystrix的依赖 启动类中添加断路器注解开启熔断机制 @EnableCircuitBreaker service的方法上添加服务降级的注解 /* * 通过使用熔断机制的注解HystrixCommand * 定义当前调用方法失败（后端超时，连接失败） * 后的降级逻辑 fallbackMethod的值，就是当前类中一个方法名称 */ @HystrixCommand(fallbackMethod="error") public String sayHi(String name) { //http://service-hi/hello?name=wang String sayHi=client.getForObject( "http://service-hi/hello?name="+name, String.class); return sayHi; } /*要保证和正常调用方法sayHi的参数结构一致，返回 *结构一致 */ @HystrixCommand(fallbackMethod="sayHi") public String error(String name){ //http://service-hi/hello?name=wang String sayHi=client.getForObject( "http://service-hi/hello?name="+name, String.class); return sayHi; }
面试题 微服务集群中如果登录集群的节点全部宕机,如何处理(服务降级)? 思路: 熔断机制描述, 断路器 服务降级 通过服务降级的逻辑当所有节点不可达时,可以通过(HystrixCommand注解的自定义实现),完成多级降级的自定义逻辑 可以实现当一个微服务集群中的服务全部启动,启动后被降级服务(解决极端现象的办法)
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||
ribbon组件会根据定义的bean对象实现负载均衡,只要创建的bean对象就可以,没有发现工程创建任何均衡对象,就会默认使用轮询
@Bean
public Irule initRule(){
return new RandomRule();
}
2.5ribbon实现负载均衡访问服务的原理
- ribbon具备注册和抓取的能力,启动后会将eureka注册中心的所有map数据抓取到本地存储,每隔30秒更新一次抓取内容
- RestTemplate的创建过程是通过LoadBalance,ribbon会对当前这个对象的所有请求做拦截处理,LoadBalancerInterceptor
- RestTemplate发送请求: http://service-hi/hello?name=wang
- ribbon通过拦截解析出service-hi的服务名称
- 通过抓取的map对象找到了service-hi value(三个节点的详细信息)
- 通过负载均衡对象IRule从三个节点选取一个节点的ip:port拼接到域名所在位置最终发送请求
注意: springcloud中只要是服务调用服务的过程都是通过ribbon+RestTemplate(zuul feign也是)
3.zuul网关集群的调用结构
完成时限eureka注册中心的高可用
springcloud的zuul组件
2019年11月13日
19:52
1.zuul组件
1.1 介绍
zuul是springcloud中提供的网关组件,可以实现整体微服务集群对外访问的入口,其他任何服务的提供者,服务的调用者的外界访问,都必须通过zuul来实现
1.2zuul测试工程
-
- pom文件导入相关依赖,springboot相关依赖,依赖eureka client zuul(底层封装了zuul)
- application.properties
- 端口: 8103
- 关闭敏感头: zuul.sensitive-headers=
网关zuul默认过滤掉一些蜜柑header,其中就有cookie,关闭拦截敏感头,使得cookie生效(等号右侧不写即关闭)
-
- 配置网关的路由规则(什么样的url访问到zuul之后,转发给哪个服务去处理)
- zuul的服务名称: zuul-service
- eureka注册中心地址
- 启动类
@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy
-
- 配置文件中,提供的路由转发规则自定义
#service-ribbon service-hi
zuul.routes.hi.path=/zuul-hi/**
zuul.routes.hi.serviceId=service-hi
所有的请求都要经过网关才能访问集群中的服务,
hi: 自定义的路由名称
一对zuul.routes.hi.**相互关联
path: 访问zuul网关工程url匹配这个路由规则
| ? | 匹配一个字符,/zuul/a可以匹配上 /zuul/?,但是无法匹配字符串和多级目录 |
| * | 匹配一个字符串,/zuul/abc可以匹配上/zuul/*,但是无法匹配多级目录 |
| ** | 匹配任意长度的字符串,任意多级目录, /zuul/abc/aa 可以匹配上/zuul/** |
serviceId: 符合path路由规则的url将会被转发到的服务(zuul封装ribbon的调用)
1.3zuul访问流程
eureka注册中心,eurekaclient service-hi,zuul网关
常见问题: zuul一旦启动,需要先抓取到注册信息,才能实现路由的转发和服务功能,启动后,不一定直接抓取到正确的服务列表,再找不到服务时,会出现forwarding error转发失败的提示,即无法找到有效地服务,异常信息:
com.netflix.zuul.exception.ZuulException: Forwarding error
Caused by: com.netflix.client.ClientException: Load balancer does not have available server for client: service-ribbon
访问service-hi的服务功能,需要根据zuul提供的对外暴露的接口访问服务:
http://localhost:8103/zuul-hi/Hello?name=wang
过程
-
- zuul接收到请求
- 匹配url地址和路由规则/zuul-hi/** /zuul-hi/hello
- 匹配后,底层调用ribbon+RestTemplate发起请求
- http://service-hi/Hello?name=wang
- ribbon做拦截,zuul已经通过抓取将注册信息存放在本地,拦截拼接匹配服务和实例
- 最终访问 http://127.0.0.1:9001/Hello?name=wang或者http://127.0.0.1:9002/Hello?name=wang
1.4zuul和nginx整合
http://www.ssm.com/hello?name=wang
nginx配置访问网关集群
location /hello{
proxy_pass http://zuulserver/zuul-hi/hello;
}
upstream zuulserver{
server 127.0.0.1:8103;
}
流转逻辑(必须掌握)
| 起始地址 | |
| hosts文件 | 127.0.0.1 www.ssm.com |
| 请求发送nginx | |
| server判断 | listen 80 server_name www.ssm.com |
| location匹配 /hello | / /hello优先级最高 |
| proxy_pass | |
| nginx找upstream | |
| zuul接收到请求 | /zuul-hi/** 匹配上 |
| serviceId | service-hi |
| ribbon+restTemplate | |
| ribbon负载均衡 | service-hi --->127.0.0.1:9001/9002 |
| 最终发送 |
1.5zuul高可用集群
复制一个zuul工程,修改端口8104
nginx的upstream server 127.0.0.1:8104;
1.6转发给service-ribbon
如何配置zuul
zuul.routes.ribbon.path=/zuul-ribbon/**
zuul.routes.ribbon.serviceId=service-ribbon
如何配置nginx
location /hi{
proxy_pass http://zuulserver/zuul-ribbon/hi
}
如何访问 : http://www.ssm.com/hi?name=wang
访问的流转逻辑
| nginx | 域名,端口,location /hi |
| 转发zuul | |
| nginx负载均衡 | |
| zuul接收 | 路由匹配规则 /zuul-ribbon/hi |
| 转发到服务 | service-ribbon |
| restTemplate | |
| ribbon负载均衡 | |
| 9004端口接收请求 | restTemplate http://service-hi/hello |
| 第二个负载均衡 |
最终访问: http://127.0.0.1:9004/hi?name=wang
微服务集群内部调用: http://127.0.0.1:9001或者9002/hello?name=wang
2.注册中心 eureka server高可用
注册中心高可用集群,即集群中的注册中心互为客户端,相互注册自己的信息到对方,相关抓取服务(注册true,抓取true),发现相同服务名称的内容合并同步,保持一致
2.1搭建高可用eureka注册中心
每一个注册中的客户端的配置中,需要配置一个ipAddressPrefer,底层通信记录以ip信息优先,否则会使用localhost(会使用域名),不会进行数据同步
-
- eureka server修改配置文件application.properties
开启客户端抓取功能
eureka.client.fetchRegister=true
配置相互注册的serviceUrl 8888配置8889端口 8889配置8888端口
server.port=8888
eureka.client.serviceUrl.defaultZone=http://localhost:8889/eureka
server.port=8889
eureka.client.serviceUrl.defaultZone=http://localhost:8888/eureke
开启ip地址优先的配置
eureka.instance.prefer-ip-address=true
-
- 拷贝成第二个
修改端口
注册中心地址
-
- 各种服务体用这注册地址,编写一个list
eureka.client.serverUrl.defaultZone=http://localhost:8888/eureka,http://localhost:8889/eureka
199
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
