gateway网关入门级学习

gateway

一.网关介绍

网关介绍1

这样的架构，会存在着诸多的问题：

1.每个业务都会需要鉴权、限流、权限校验、跨域等逻辑，如果每个业务都各自为战，自己造轮子实现一遍，会很蛋疼，完全可以抽出来，放到一个统一的地方去做。

2.如果业务量比较简单的话，这种方式前期不会有什么问题，但随着业务越来越复杂，比如淘宝、亚马逊打开一个页面可能会涉及到数百个微服务协同工作，如果每一个微服务都分配一个域名的话，一方面客户端代码会很难维护，涉及到数百个域名，另一方面是连接数的瓶颈，想象一下你打开一个APP，通过抓包发现涉及到了数百个远程调用，这在移动端下会显得非常低效。

3.后期如果需要对微服务进行重构的话，也会变的非常麻烦，需要客户端配合你一起进行改造，比如商品服务，随着业务变的越来越复杂，后期需要进行拆分成多个微服务，这个时候对外提供的服务也需要拆分成多个，同时需要客户端配合你进行改造，非常蛋疼。

上面的这些问题可以借助API网关来解决

网关介绍2

所谓的 API网关，就是指系统的统一入口，它封装了应用程序的内部结构，为客户端提供统一服务，一些与业务本身功能无关的公共逻辑可以在这里实现，诸如认证、鉴权、监控、路由转发等等。

添加上API网关之后，系统的架构图变成了如下所示：

网关介绍3

二.什么是Spring Cloud Gateway

网关作为流量的入口，常用的功能包括路由转发，权限校验，限流等。

Spring Cloud Gateway 是Spring Cloud官方推出的第二代网关框架，定位于取代 Netflix Zuul1.0。相比 Zuul 来说，Spring Cloud Gateway 提供更优秀的性能，更强大的有功能，非阻塞的。（Zuul1.0是阻塞，Zuul2.0是非阻塞，2.0的性能和gateway差不多）

Spring Cloud Gateway 是由 WebFlux + Netty + Reactor 实现的响应式的 API 网关。它不能在传统的 servlet 容器中工作，也不能构建成 war 包。

Spring Cloud Gateway 旨在为微服务架构提供一种简单且有效的 API 路由的管理方式，并基于 Filter 的方式提供网关的基本功能，例如说安全认证、监控、限流等等。

	<!‐‐ gateway网关 Spring Cloud开发 ‐‐>
	<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring‐cloud‐starter‐gateway</artifactId>
	</dependency>

	server:
	port: 8088
	spring:
	application:
	name: api-gateway
	cloud:
	#gateway
	gateway:
	#路由规则
	routes:
	- id: order_route #路由的唯一标识，例如路由到order
	uri: http://localhost:8020 #需要转发的地址
	#断言规则用于路由规则的匹配
	predicates:
	- Path=/order‐serv/** #当请求路径满足Path指定的规则时,才进行路由转发
	#http://localhost:8088/order‐serv/order/add ——>路由到
	#http://localhost:8020/order‐serv/order/add
	filters:
	- StripPrefix=1 #路由转发之前去掉第一层路径，即/order‐serv/
	#- id: stock_route

	<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-gateway</artifactId>
	</dependency>
	<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
	</dependency>

	- Path=/order/**
	#http://localhost:8088/order/add ——>路由到
	#http://order-service/order/add

	gateway:
	routes:
	- id: weight_route1
	uri: host1
	predicates:
	- Path=/product/**
	- Weight=group3, 1
	- id: weight_route2
	uri: host2
	predicates:
	# 路径一致，组一致，权重不同
	- Path=/product/**
	- Weight= group3, 9

	@Component
	public class CheckAuthRoutePredicateFactory extends AbstractRoutePredicateFactory<CheckAuthRoutePredicateFactory.Config> {


	public CheckAuthRoutePredicateFactory() {
	super(CheckAuthRoutePredicateFactory.Config.class);
	}

	public List<String> shortcutFieldOrder() {
	//接受config的值
	return Arrays.asList("name");
	}

	public Predicate<ServerWebExchange> apply(CheckAuthRoutePredicateFactory.Config config) {
	return new GatewayPredicate() {
	public boolean test(ServerWebExchange exchange) {
	if(config.getName().equals("zxy")){
	return true;
	}
	return false;
	}

	};
	}

	//用于接受配置文件中断言的信息
	@Validated
	public static class Config {
	private String name;

	public String getName() {
	return name;
	}

	public void setName(String name) {
	this.name = name;
	}
	}
	}

	@Component
	public class CheckAuthGatewayFilterFactory
	extends AbstractGatewayFilterFactory<CheckAuthGatewayFilterFactory.Config> {


	public CheckAuthGatewayFilterFactory() {
	super(Config.class);
	}

	@Override
	public List<String> shortcutFieldOrder() {
	return Arrays.asList("value");
	}

	@Override
	public GatewayFilter apply(Config config) {
	return new GatewayFilter() {
	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
	String name=exchange.getRequest().getQueryParams().getFirst("name");

	if(StringUtils.isNotBlank(name)){
	if(config.getValue().equals(name)){
	return chain.filter(exchange);
	}
	else {
	// 返回404
	exchange.getResponse().setStatusCode(HttpStatus.NOT_FOUND);
	return exchange.getResponse().setComplete();
	}
	}
	// 正常请求
	return chain.filter(exchange);
	}
	};
	}
	public static class Config {
	private String value;

	public String getValue() {
	return value;
	}

	public void setValue(String value) {
	this.value = value;
	}
	}

	}

	filters:
	#- AddRequestHeader=X-Request-color,red #添加请求头 (请求过程)
	- PrefixPath=/mall‐order
	#添加前缀http://localhost:8088/order/add——>
	#http://localhost:8088/mall‐order/order/add
	#- RedirectTo=302,https://www.baidu.com/ #重定向
	#- SetStatus=404 #修改状态码
	- CheckAuth=xxx #自定义过滤器

	routes:
	- id: order_route
	uri: lb://order-service #lb: 使用nacos中的本地负载均衡策略
	predicates:
	- Path=/**
	filters:
	- PrefixPath=/mall‐order

	@Component
	public class LogFilter implements GlobalFilter {
	Logger log= LoggerFactory.getLogger(this.getClass());

	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

	log.info(exchange.getRequest().getPath().value());
	return chain.filter(exchange);
	}
	}

	server:
	port: 8088
	spring:
	application:
	name: api-gateway
	cloud:
	nacos:
	discovery:
	server-addr: 127.0.0.1:8848
	username: nacos
	password: nacos
	#gateway
	gateway:
	discovery:
	locator:
	enabled: true #是否启动自动识别nacos服务
	#以nacos中注册的服务名为断言，且不需要配置filter，会自动去除对于的第一次断言。
	#http://localhost:8088/order-service/order/add ->路由到
	#http://order-service/order-service/order/add ->filter后
	#http://order-service/order/add

	<appender name="accessLog" class="ch.qos.logback.core.FileAppender">
	<file>access_log.log</file>
	<encoder>
	<pattern>%msg%n</pattern>
	</encoder>
	</appender>
	<appender name="async" class="ch.qos.logback.classic.AsyncAppender">
	<appender‐ref ref="accessLog" />
	</appender>
	<logger name="reactor.netty.http.server.AccessLog" level="INFO" additivity="false">
	<appender‐ref ref="async"/>
	</logger>

	<!--输出为日志文本（可以搞也可以不搞，建议学习springboot日志）-->

	spring:
	cloud:
	gateway:
	globalcors:
	cors-configurations:
	'[/**]': #允许跨域的资源
	allowedOrigins: "https://docs.spring.io" #允许跨域的来源url
	allowedMethods: #允许跨域的请求方法
	- GET
	allowedHeaders: '*' #允许跨域的请求头
	# 预检请求的缓存时间（秒），即在这个时间段里对于相同的跨域请求不会再预检
	maxAge: 180

	@Configuration
	public class CorsConfig {

	@Bean
	public CorsWebFilter corsFilter() {
	CorsConfiguration config = new CorsConfiguration();
	// 允许cookies跨域
	config.setAllowCredentials(true);
	// #允许向该服务器提交请求的URI，表示全部允许，在SpringMVC中，如果设成，会自动转成当前请求头中的Origin
	config.addAllowedOrigin("*");
	// #允许访问的头信息,*表示全部
	config.addAllowedHeader("*");
	// 预检请求的缓存时间（秒）Long型，即在这个时间段里，对于相同的跨域请求不会再预检了
	config.setMaxAge(180L);
	//允许的方法可设置* 即允许全部http请求方法类型
	config.addAllowedMethod("OPTIONS");
	config.addAllowedMethod("HEAD");
	config.addAllowedMethod("GET");
	config.addAllowedMethod("PUT");
	config.addAllowedMethod("POST");
	config.addAllowedMethod("DELETE");
	config.addAllowedMethod("PATCH");
	UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
	source.registerCorsConfiguration("/**", config);
	return new CorsWebFilter(source);
	}
	}

	@Configuration
	public class GatewayConfig {

	@PostConstruct
	public void init(){
	BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
	@Override
	public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
	System.out.println(throwable);

	HashMap<String,String> map = new HashMap<>();
	map.put("code", HttpStatus.TOO_MANY_REQUESTS.toString());
	map.put("message","限流了");

	//自定义异常处理
	return ServerResponse.status(HttpStatus.OK)
	.contentType(MediaType.APPLICATION_JSON)
	.body(BodyInserters.fromValue(map));
	}
	};

	GatewayCallbackManager.setBlockHandler(blockRequestHandler);
	}
	}

	public class Result<T> {
	private Integer code;
	private String msg;
	private T data;

	public Integer getCode() {
	return code;
	}

	public void setCode(Integer code) {
	this.code = code;
	}

	public String getMsg() {
	return msg;
	}

	public void setMsg(String msg) {
	this.msg = msg;
	}

	public T getData() {
	return data;
	}

	public void setData(T data) {
	this.data = data;
	}

	public Result(Integer code, String msg, T data) {
	this.code = code;
	this.msg = msg;
	this.data = data;
	}

	public Result(Integer code, String msg) {
	this.code = code;
	this.msg = msg;
	}

	public static Result error(Integer code,String msg){
	return new Result(code,msg);
	}
	}

	#配置sentinel
	sentinel:
	transport:
	dashboard: 127.0.0.1:8080
	scg:
	fallback: #流控降级规则
	mode: response
	response-body: "{code:'1002',message:'limit limit'}"

kidzxy

gateway网关入门级学习

gateway

一.网关介绍

二.什么是Spring Cloud Gateway

2.1 Spring Cloud Gateway 功能特征

2.2 核心概念

2.3 工作原理

三.Spring Cloud Gateway快速开始

3.1引入依赖

3.2yml配置

四.Gateway整合nacos

五.内置路由断言工厂配置

1.基于Datetime类型的断言工厂

2.基于远程地址的断言工厂

3.基于Cookie的断言工厂

4.基于Header的断言工厂

5.基于Host的断言工厂

6.基于Method请求方法的断言工厂

7.基于Path请求路径的断言工厂

8.基于Query请求参数的断言工厂

9.基于路由权重的断言工厂

六.简单的自定义断言

七.过滤器工厂配置

1.内置的局部过滤器工厂配置

2.自定义局部过滤器工厂

3.全局过滤器（Global Filters）配置

LoadBalancerClientFilter

自定义全局过滤器

八.访问日志和跨域配置

访问日志

跨域配置

九.Gateway整合sentinel

1.导入依赖

2.添加yml配置

控制台实现方式：

十.整合sentinel的详细配置

流控规则（根据路由ID）

1.属性限流Client IP

2.属性限流Header

3.属性限流URL

4.属性限流Remote Host

5.属性限流 Cookie

降级规则（根据路由ID）

API分组

1.设置API分组

2.API分组流控

3.API分组降级

自定义流控降级返回

方法一（配置类）

方法二（yml配置）

十一.网关高可用

Gateway依赖和yml配置总合

公告

搜索

常用链接

随笔档案

阅读排行榜

评论排行榜

最新评论