06基于Gateway的网关路由-CSDN博客

本文链接：https://blog.csdn.net/yorickjun/article/details/116645778

一基于Gateway的路由

1.1 Gateway基础路由配置

导入依赖(注意SpringCloud Gateway使用的web框架为webflux，和SpringMVC不兼容，需要将父模块的web模块去掉)

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

配置启动类

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

编写配置文件

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
        - id: product # 我们自定义的路由 ID，保持唯一
          uri: http://localhost:9001 # 目标服务地址
          predicates: # 路由条件，Predicate 接受一个输入参数，返回一个布尔值结果
            - Path=/product/**

测试访问

http://localhost:8080/product/1

1.2 Gateway动态路由

自动从服务中心列表中获取地址

添加eureka客户端依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

动态路由的配置文件

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
        - id: product
          uri: lb://product # lb代表从注册中心获取服务
          predicates:
            - Path=/product/**
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    prefer-ip-address: true

1.3 重写转发路径

通过RewritePath配置重写转发的url

spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
        - id: product
          uri: lb://product # lb代表从注册中心获取服务
          predicates:
            - Path=/product-service/**
          filters: 
            - RewritePath=/product-service/(?<segment>.*), /$\{segment}

在网页上请求http://localhost:8080/product-service/product/1，此时会将请求转发到http://127.0.0.1:9001/product/1

二基于Gateway的过滤器

2.1 过滤器类型

GatewayFilter：：应用到单个路由或者一个分组的路由上。
GlobalFilter：应用到所有的路由上。通过全局过滤器可以实现对权限的统一校验，安全性验证等功能。

2.2 权限校验

image-20210101163743668.png

//自定义全局过滤器，需要实现GlobalFilter, Ordered两个接口
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {
    //实现过滤的逻辑
    //ServerWebExchange 当前请求和响应的上下文
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getQueryParams().getFirst("token");
        if (!"yorick".equals(token)){
            System.out.println("验证失败");
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            //拦截
            return exchange.getResponse().setComplete();
        }
        //放行
        return chain.filter(exchange);
    }
    
    //指定过滤器的优先级，越小级别越高
    @Override
    public int getOrder() {
        return 0;
    }
}

2.3 网关限流

常见的限流方法

计数器

计数器限流算法是最简单的一种限流实现方式。其本质是通过维护一个单位时间内的计数器，每次请求计数器加1，当单位时间内计数器累加到大于设定的阈值，则之后的请求都被拒绝，直到单位时间已经过去，再将计数器重置为零。

漏桶算法

漏桶算法可以很好地限制容量池的大小，从而防止流量暴增。漏桶可以看作是一个带有常量服务时间的单服务器队列，如果漏桶(包缓存)溢出，那么数据包会被丢弃。在网络中，漏桶算法可以控制端口的流量输出速率，平滑网络上的突发流量，实现流量整形，从而为网络提供一个稳定的流量。

为了更好的控制流量，漏桶算法需要通过两个变量进行控制：一个是桶的大小，支持流量突发增多时可以存多少的水(burst)，另一个是水桶漏洞的大小(rate)。

令牌桶算法

令牌桶算法是对漏桶算法的一种改进，桶算法能够限制请求调用的速率，而令牌桶算法能够在限制调用的平均速率的同时还允许一定程度的突发调用。在令牌桶算法中，存在一个桶，用来存放固定数量的令牌。算法中存在一种机制，以一定的速率往桶中放令牌。每次请求调用需要先获取令牌，只有拿到令牌，才有机会继续执行，否则选择等待可用的令牌或者直接拒绝。放令牌这个动作是持续不断的进行，如果桶中令牌数达到上限，就丢弃令牌，所以就存在这种情况，桶中一直有大量的可用令牌，这时进来的请求就可以直接拿到令牌执行，比如设置qps为100，那么限流器初始化完成一秒后，桶中就已经有100个令牌了，这时服务还没完全启动好，等启动完成对外提供服务时，该限流器可以抵挡瞬时的100个请求。所以，只有桶中没有令牌时，请求才会进行等待，最后相当于以一定的速率执行。

基于Filter的限流

在过滤器工厂中是通过Redis和lua脚本结合的方式进行流量控制。

导入redis依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

准备redis，并启动
修改yaml配置文件

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
      - id: product
        uri: lb://product # lb代表从注册中心获取服务
        predicates:
        - Path=/product-service/**
        filters:
        - RewritePath=/product-service/(?<segment>.*), /$\{segment}
        - name: RequestRateLimiter
          args:
            # 使用SpEL从容器中获取对象
            key-resolver: '#{@pathKeyResolver}'
            # 令牌桶每秒填充平均速率
            redis-rate-limiter.replenishRate: 1
            # 令牌桶的总容量
            redis-rate-limiter.burstCapacity: 3
  redis:
    host: localhost
    port: 6379
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    prefer-ip-address: true

配置KeyResolver

@Configuration
public class KeyResolverConfiguration {
    /**
     * 基于请求路径的限流
     */
    @Bean
    public KeyResolver pathKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest().getPath().toString()
        );
    }
    /**
     * 基于请求ip地址的限流
     */
    //@Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest().getHeaders().getFirst("X-Forwarded-For")
        );
    }
    /**
     * 基于用户的限流
     */
    //@Bean
    public KeyResolver userKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest().getQueryParams().getFirst("user")
        );
    }
}

测试发现，当有大量请求时可以做到限流的功能效果

三 Gateway的高可用

image-20210101170818053.png

启动多台gateway网关 (8080，8081)

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
      - id: product
        uri: lb://product # lb代表从注册中心获取服务
        predicates:
        - Path=/product-service/**
        filters:
        - RewritePath=/product-service/(?<segment>.*), /$\{segment}
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    prefer-ip-address: true

配置ngnix

#配置多台服务器(这里只在一台服务器上的不同端口)
upstream gateway {
server 127.0.0.1:8081;
server 127.0.0.1:8080;
}
#请求转向mysvr 定义的服务器列表
location / {
proxy_pass http://gateway;
}