SpringCloud（21）：Gateway网关

港控/mmm° 2022-10-25 15:27 258阅读 0赞

一、什么是api网关

（1）分布式服务架构、微服务架构与 API 网关

  1. 在微服务架构里，服务的粒度被进一步细分，各个业务服务可以被独立的设计、开发、测试、部署和管理。这时，各个独立部署单元可以用不同的开发测试团队维护，可以使用不同的编程语言和技术平台进行设计，这就要求必须使用一种和平台无关的语言服务协议作为各个单元间的通讯方式。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70

（2）API 网关的定义

  • 网关的角色是作为一个 API 架构，用来保护、增强和控制对于 API 服务的访问。
  • API 网关是一个处于应用程序或服务（提供 REST API 接口服务）之前的系统，用来管理授权、访问控制和流量限制等，这样 REST API 接口服务就被 API 网关保护起来，对所有的调用者透明。因此，隐藏在 API 网关后面的业务系统就可以专注于创建和管理服务，而不用去处理这些策略性的基础设施。

（3）API 网关的职能

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 1

（4）API 网关的分类与功能

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 2

二、Gateway介绍

  1. Spring Cloud Gateway是Spring官方基于Spring 5.0，Spring Boot 2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供一种简单而有效的统一的API路由管理方式。Spring Cloud Gateway作为Spring Cloud生态系中的网关，目标是替代ZUUL，其不仅提供统一的路由方式，并且基于Filter链的方式提供了网关基本的功能，例如：安全，监控/埋点，和限流等。

（1）为什么使用Gateway

  • Spring Cloud Gateway 可以看做是一个 Zuul 1.x 的升级版和代替品，比 Zuul 2 更早的使用 Netty 实现异步 IO，从而实现了一个简单、比 Zuul 1.x 更高效的、与 Spring Cloud 紧密配合的 API 网关。
  • Spring Cloud Gateway 里明确的区分了 Router 和 Filter，并且一个很大的特点是内置了非常多的开箱即用功能，并且都可以通过 SpringBoot 配置或者手工编码链式调用来使用。
  • 比如内置了 10 种 Router，使得我们可以直接配置一下就可以随心所欲的根据 Header、或者 Path、或者 Host、或者 Query 来做路由。
  • 比如区分了一般的 Filter 和全局 Filter，内置了 20 种 Filter 和 9 种全局 Filter，也都可以直接用。当然自定义 Filter 也非常方便。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 3

format_png

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 4

三、Gateway使用

（1）创建Gateway模块

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70 5

（2）引入依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springcloud</artifactId>
  7.         <groupId>com.buba</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>springcloud-gateway-7004</artifactId>
  14.     <dependencies>
  16.         <!--        nacos 相关 -->
  17.         <dependency>
  18.             <groupId>com.alibaba.cloud</groupId>
  19.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  20.             <exclusions>
  21.                 <exclusion>
  22.                     <groupId>org.springframework.cloud</groupId>
  23.                     <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
  24.                 </exclusion>
  25.             </exclusions>
  26.         </dependency>
  27.         <!--        完善监控信息-->
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-actuator</artifactId>
  31.         </dependency>
  33.         <dependency>
  34.             <groupId>org.springframework.cloud</groupId>
  35.             <artifactId>spring-cloud-starter-gateway</artifactId>
  36.         </dependency>
  37.     </dependencies>
  39. </project>

（3）application.yml配置文件

  1. server:
  2.   port: 7004
  4. spring:
  5.   .application:
  6.     name: spring-cloud-gateway
  7.   cloud:
  8.     # nocos注册中心
  9.     nacos:
  10.       discovery:
  11.         server-addr: localhost:8848
  12.     gateway:
  13.       routes:
  14.         - id: gateway7004 # id值没有具体规则 保持唯一
  15.           uri: https://blog.csdn.net/ #路由到的地址
  16.           predicates: # 断言 这里使用路径方式
  17.             - Path= /qq_40298351/**

（4）启动类

  1. package com.buba.springcloud;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  7. @SpringBootApplication
  8. @EnableDiscoveryClient
  9. public class GateWay_7004 {
  10.     public static void main(String[] args) {
  11.         SpringApplication.run(GateWay_7004.class, args);
  12.     }
  13. }

（5）启动测试

  1. 访问地址：[http://localhost:7004/qq\_40298351/][http_localhost_7004_qq_40298351]，当访问路径匹配Path= /qq\_40298351/\*\*时，就会将地址路由到：https://blog.csdn.net/qq\_40298351/

20210201160520411.png

四、匹配方式

  1. Predicate 就是为了实现一组匹配规则，方便让请求过来找到对应的 Route 进行处理，接下来我们接下 Spring Cloud GateWay 内置几种 Predicate 的使用。

（1）通过时间匹配

  1. spring:
  2.   cloud:
  3.     gateway:
  4.       routes:
  5.        - id: time_route
  6.         uri: https://blog.csdn.net/
  7.         predicates:
  8.          - After=2018-01-20T06:06:06+08:00[Asia/Shanghai]
  10. Spring 是通过 ZonedDateTime 来对时间进行的对比，ZonedDateTime 是 Java 8 中日期时间功能里，用于表示带时区的日期与时间信息的类，ZonedDateTime 支持通过时区来设置时间，中国的时区是：`Asia/Shanghai`。After Route Predicate 是指在这个时间之后的请求都转发到目标地址。上面的示例是指，请求时间在 2018 年 1 月 20 日 6 点 6 分 6 秒之后的所有请求都转发到地址`http://ityouknow.com`。`+08:00`是指时间和 UTC 时间相差八个小时，时间地区为`Asia/Shanghai`。添加完路由规则之后，访问地址`http://localhost:7004`会自动转发到[https://blog.csdn.net/][https_blog.csdn.net]。
  12. Before Route Predicate 刚好相反，在某个时间之前的请求的请求都进行转发。我们把上面路由规则中的 After 改为 Before，如下：
  14. spring:
  15.   cloud:
  16.     gateway:
  17.       routes:
  18.        - id: after_route
  19.         uri: https://blog.csdn.net/
  20.         predicates:
  21.          - Before=2018-01-20T06:06:06+08:00[Asia/Shanghai]
  23. 就表示在这个时间之前可以进行路由，在这时间之后停止路由，修改完之后重启项目再次访问地址`http://localhost:7004`，页面会报 404 没有找到地址。
  25. 除过在时间之前或者之后外，Gateway 还支持限制路由请求在某一个时间段范围内，可以使用 Between Route Predicate 来实现。
  27. spring:
  28.   cloud:
  29.     gateway:
  30.       routes:
  31.        - id: after_route
  32.         uri: https://blog.csdn.net/
  33.         predicates:
  34.          - Between=2018-01-20T06:06:06+08:00[Asia/Shanghai], 2019-01-20T06:06:06+08:00[Asia/Shanghai]
  36. 这样设置就意味着在这个时间段内可以匹配到此路由，超过这个时间段范围则不会进行匹配。通过时间匹配路由的功能很酷，可以用在限时抢购的一些场景中。

（2）通过 Cookie 匹配

  1. Cookie Route Predicate 可以接收两个参数，一个是 Cookie name , 一个是正则表达式，路由规则会通过获取对应的 Cookie name 值和正则表达式去匹配，如果匹配上就会执行路由，如果没有匹配上则不执行。
  3. spring:
  4.   cloud:
  5.     gateway:
  6.       routes:
  7.        - id: cookie_route
  8.          uri: https://blog.csdn.net/
  9.          predicates:
  10.          - Cookie=csdn, buba
  12. 使用 curl 测试，命令行输入:
  14. curl http://localhost:8080 --cookie "csdn=buba"
  16. 则会返回页面代码，如果去掉`--cookie "csdn=buba"`，后台会报 404 错误。
  18. Header Route Predicate 和 Cookie Route Predicate 一样，也是接收 2 个参数，一个 header 中属性名称和一个正则表达式，这个属性值和正则表达式匹配则执行。
  20. spring:
  21.   cloud:
  22.     gateway:
  23.       routes:
  24.       - id: header_route
  25.         uri: https://blog.csdn.net/
  26.         predicates:
  27.         - Header=X-Request-Id, \d+
  29. 使用 curl 测试，命令行输入:
  31. curl http://localhost:7004  -H "X-Request-Id:666666"
  33. 则返回页面代码证明匹配成功。将参数`-H "X-Request-Id:666666"`改为`-H "X-Request-Id:neo"`再次执行时返回 404 证明没有匹配。

（3）通过 Host 匹配

  1. Host Route Predicate 接收一组参数，一组匹配的域名列表，这个模板是一个 ant 分隔的模板，用`.`号作为分隔符。它通过参数中的主机地址作为匹配规则。
  3. spring:
  4.   cloud:
  5.     gateway:
  6.       routes:
  7.       - id: host_route
  8.         uri: https://blog.csdn.net/
  9.         predicates:
  10.         - Host=**.blog.csdn.net
  12. 使用 curl 测试，命令行输入:
  14. curl http://localhost:7004  -H "Host: www.blog.csdn.net" 
  15. curl http://localhost:7004  -H "Host: md.blog.csdn.net"
  17. 经测试以上两种 host 均可匹配到 host\_route 路由，去掉 host 参数则会报 404 错误。

（4）通过请求方式匹配

  1. 可以通过是 POST、GET、PUT、DELETE 等不同的请求方式来进行路由。
  3. spring:
  4.   cloud:
  5.     gateway:
  6.       routes:
  7.       - id: method_route
  8.         uri: https://blog.csdn.net/
  9.         predicates:
  10.         - Method=GET
  12. 使用 curl 测试，命令行输入:
  14. # curl 默认是以 GET 的方式去请求
  15. curl http://localhost:7004
  17. 测试返回页面代码，证明匹配到路由，我们再以 POST 的方式请求测试。
  19. # curl 默认是以 GET 的方式去请求
  20. curl -X POST http://localhost:7004
  22. 返回 404 没有找到，证明没有匹配上路由

（5）通过请求路径匹配

  1. Path Route Predicate 接收一个匹配路径的参数来判断是否走路由。
  3. spring:
  4.   cloud:
  5.     gateway:
  6.       routes:
  7.       - id: host_route
  8.         uri: https://blog.csdn.net/
  9.         predicates:
  10.         - Path=/foo/{segment}
  12. 如果请求路径符合要求，则此路由将匹配，例如：/foo/1 或者 /foo/bar。
  14. 使用 curl 测试，命令行输入:
  16. curl http://localhost:7004/foo/1
  17. curl http://localhost:7004/foo/xx
  18. curl http://localhost:7004/boo/xx
  20. 经过测试第一和第二条命令可以正常获取到页面返回值，最后一个命令报 404，证明路由是通过指定路由来匹配。

（6）通过请求参数匹配

  1. Query Route Predicate 支持传入两个参数，一个是属性名一个为属性值，属性值可以是正则表达式。
  3. spring:
  4.   cloud:
  5.     gateway:
  6.       routes:
  7.       - id: query_route
  8.         uri: https://blog.csdn.net/
  9.         predicates:
  10.         - Query=smile
  12. 这样配置，只要请求中包含 smile 属性的参数即可匹配路由。
  14. 使用 curl 测试，命令行输入:
  16. curl localhost:7004?smile=x&id=2
  18. 经过测试发现只要请求汇总带有 smile 参数即会匹配路由，不带 smile 参数则不会匹配。
  20. 还可以将 Query 的值以键值对的方式进行配置，这样在请求过来时会对属性值和正则进行匹配，匹配上才会走路由。
  22. spring:
  23.   cloud:
  24.     gateway:
  25.       routes:
  26.       - id: query_route
  27.         uri: http://ityouknow.com
  28.         predicates:
  29.         - Query=keep, pu.
  31. 这样只要当请求中包含 keep 属性并且参数值是以 pu 开头的长度为三位的字符串才会进行匹配和路由。
  33. 使用 curl 测试，命令行输入:
  35. curl localhost:7004?keep=pub
  37. 测试可以返回页面代码，将 keep 的属性值改为 pubx 再次访问就会报 404, 证明路由需要匹配正则表达式才会进行路由。

（7）通过请求 ip 地址进行匹配

  1. Predicate 也支持通过设置某个 ip 区间号段的请求才会路由，RemoteAddr Route Predicate 接受 cidr 符号 (IPv4 或 IPv6) 字符串的列表(最小大小为 1)，例如 192.168.0.1/16 (其中 192.168.0.1 是 IP 地址，16 是子网掩码)。
  3. spring:
  4.   cloud:
  5.     gateway:
  6.       routes:
  7.       - id: remoteaddr_route
  8.         uri: https://blog.csdn.net/
  9.         predicates:
  10.         - RemoteAddr=192.168.1.1/24
  12. 可以将此地址设置为本机的 ip 地址进行测试。
  14. 如果请求的远程地址是 192.168.1.10，则此路由将匹配。

（8）组合使用

上面为了演示各个 Predicate 的使用，我们是单个单个进行配置测试，其实可以将各种 Predicate 组合起来一起使用。

例如：

  1. spring:
  2.   cloud:
  3.     gateway:
  4.       routes:
  5.        - id: host_foo_path_headers_to_httpbin
  6.         uri: https://blog.csdn.net/
  7.         predicates:
  8.         - Host=**.foo.org
  9.         - Path=/headers
  10.         - Method=GET
  11.         - Header=X-Request-Id, \d+
  12.         - Query=foo, ba.
  13.         - Query=baz
  14.         - Cookie=chocolate, ch.p
  15.         - After=2018-01-20T06:06:06+08:00[Asia/Shanghai]
  17. 各种 Predicates 同时存在于同一个路由时，请求必须同时满足所有的条件才被这个路由匹配。

发表评论

表情：
评论列表 （有 0 条评论，258人围观）

还没有评论，来说两句吧...

相关阅读