ZUUL-API网关

ゝ一世哀愁。 2021-12-15 00:11 380阅读 0赞

## 更多干货 ##

*  [分布式实战（干货）][Link 1]
 *  [spring cloud 实战（干货）][spring cloud]
 *  [mybatis 实战（干货）][mybatis]
 *  [spring boot 实战（干货）][spring boot]
 *  [React 入门实战（干货）][React]
 *  [构建中小型互联网企业架构（干货）][Link 2]
 *  [python 学习持续更新][python]
 *  [ElasticSearch 笔记][ElasticSearch]
 *  [kafka storm 实战 (干货)][kafka storm _]
 *  [scala 学习持续更新][scala]
 *  [RPC][]
 *  [深度学习][Link 3]
 *  [GO 语言 持续更新][GO _]
 *  [Android 学习][Android]
 *  [nginx 相关文章][nginx]

## 一、内容概览 ##

本篇将介绍API网关的基本概念、[Zuul][]网关的功能和工作机制。结合代码介绍如何使用Zuul构建一个简单的网关、介绍Zuul的路由配置方式、了解Filter工作原理并实现一些扩展功能。

## 二、什么是API网关 ##

在微服务架构中，通常会有多个服务提供者。设想一个电商系统，可能会有商品、订单、支付、用户等多个类型的服务，而每个类型的服务数量也会随着整个系统体量的增大也会随之增长和变更。作为UI端，在展示页面时可能需要从多个微服务中聚合数据，而且服务的划分位置结构可能会有所改变。网关就可以对外暴露聚合API，屏蔽内部微服务的微小变动，保持整个系统的稳定性。

当然这只是网关众多功能中的一部分，它还可以做负载均衡，统一鉴权，协议转换，监控监测等一系列功能。

下图是一张典型的[Backend for Front-End][]网关：

![gateway.png][]

## 三、什么是Zuul ##

Zuul是Spring Cloud全家桶中的微服务API网关。

所有从设备或网站来的请求都会经过Zuul到达后端的Netflix应用程序。作为一个边界性质的应用程序，Zuul提供了动态路由、监控、弹性负载和安全功能。Zuul底层利用各种filter实现如下功能：

*  认证和安全 识别每个需要认证的资源，拒绝不符合要求的请求。
 *  性能监测 在服务边界追踪并统计数据，提供精确的生产视图。
 *  动态路由 根据需要将请求动态路由到后端集群。
 *  压力测试 逐渐增加对集群的流量以了解其性能。
 *  负载卸载 预先为每种类型的请求分配容量，当请求超过容量时自动丢弃。
 *  静态资源处理 直接在边界返回某些响应。

## 四、编写一个Zuul网关 ##

1、新建一个gateway-zuul-demo模块，在依赖项处添加【Cloud Discovery->Eureka Discovery和Cloud Rouing->Zuul】。

2、修改入口类，增加`EnableZuulProxy`注解

1.  `@SpringBootApplication`
2.  `@EnableZuulProxy`
3.  `public class GatewayZuulDemoApplication {`
4.   
5.  `public static void main(String[] args) {`
6.  `SpringApplication.run(GatewayZuulDemoApplication.class, args);`
7.  `}`
8.  `}`

3、修改appliation.yml

1.  `server:`
2.  `port: 9006`
3.  `spring:`
4.  `application:`
5.  `name: gateway-zuul-demo`
6.  `eureka:`
7.  `client:`
8.  `service-url:`
9.  `defaultZone: http://localhost:8761/eureka/,http://localhost:8762/eureka/`
10. `instance:`
11. `prefer-ip-address: true`

4、启动Eureka Server、Rest-Demo和Gateway-Zuul-Demo，在浏览器中输入[http://localhost:9006/rest-demo/user/xdlysk][http_localhost_9006_rest-demo_user_xdlysk]获取返回结果。

从上面的例子中的地址可以看出来默认Zuul的路由方式是：http://ZUULHOST:ZUULPORT/serviceId/\*\*。

如果启动多个Rest-Demo可以发现Zuul里面还内置了Ribbon的负载均衡功能。

## 五、路由配置 ##

Zuul提供了一套简单且强大路由配置策略，利用路由配置我们可以完成对微服务和URL更精确的控制。

1、重写指定微服务的访问路径：

1.  `zuul:`
2.  `routes:`
3.  `rest-demo: /rest/**`

这表示将rest-demo微服务的地址映射到/rest/\*\*路径。

2、忽略指定微服务：

1.  `zuul:`
2.  `ignored-services: rest-demo,xxx-service`

使用“\*”可忽略所有微服务，多个指定微服务以半角逗号分隔。

3、忽略所有微服务，只路由指定微服务：

1.  `zuul:`
2.  `ignored-services: *`
3.  `routes:`
4.  `rest-demo: /rest/**`

4、路由别名：

1.  `zuul:`
2.  `routes:`
3.  `route-name: #路由别名，无其他意义，与例1效果一致`
4.  `service-id: rest-demo`
5.  `path: /rest/**`

5、指定path和URL

1.  `zuul:`
2.  `routes:`
3.  `route-name:`
4.  `url: http://localhost:8000/`
5.  `path: /rest/**`

此例将http://ZUULHOST:ZUULPORT/rest/**映射到http://localhost:8000/**。同时由于并非用service-id定位服务，所以也无法使用负载均衡功能。

6、即指定path和URL，又保留Zuul的Hystrix、Ribbon特性

1.  `zuul:`
2.  `routes:`
3.  `route-name: #路由别名，无其他意义，与例1效果一致`
4.  `service-id: rest-demo`
5.  `path: /rest/**`
6.  `ribbon:`
7.  `eureka:`
8.  `enable: false #为Ribbon禁用Eureka`
9.  `rest-demo:`
10. `ribbon:`
11. `listOfServers: localhost:9000,localhost:9001`

7、借助`PatternServiceRouteMapper`实现路由的正则匹配

1.  `@Bean`
2.  `public PatternServiceRouteMapper serviceRouteMapper(){`
3.  `/**`
4.  `* A RegExp Pattern that extract needed information from a service ID. Ex :`
5.  `* "(?<name>.*)-(?<version>v.*$)"`
6.  `*/`
7.  `//private Pattern servicePattern;`
8.  `/**`
9.  `* A RegExp that refer to named groups define in servicePattern. Ex :`
10. `* "${version}/${name}"`
11. `*/`
12. `//private String routePattern;`
13. `return new PatternServiceRouteMapper("(?<name>^.+)-(?<version>v.+$)", "${version}/${name}");`
14. `}`

此例可以将rest-demo-v1映射为/v1/rest-demo/\*\*。

8、路由前缀

1.  `zuul:`
2.  `prefix: /api`
3.  `strip-prefix: true`
4.  `routes:`
5.  `rest-demo: /rest/**`

此时访问Zuul的/api/rest/user/xdlysk会被转发到/rest-demo/user/xdlysk。

9、忽略某些微服务中的某些路径

1.  `zuul:`
2.  `ignoredPatterns: /**/user/* #忽略所有包含/user/的地址请求`
3.  `routes:`
4.  `route-demo:`
5.  `service-Id: rest-demo`
6.  `path: /rest/**`

更多的配置项和配置方法可以参考

spring-cloud-netflix-zuul/src/main/java/org/springframework/cloud/netflix/zuul/filters/ZuulProperties.java并结合上述例子扩展。在ZuulProperties.java中每个字段都会有注释解释其作用。

## 六、Filter工作原理 ##

6.1 Zuul中的Filter

Zuul是围绕一系列Filter展开的，这些Filter在整个HTTP请求过程中执行一连串的操作。

Zuul Filter有以下几个特征：

*  Type：用以表示路由过程中的阶段（内置包含PRE、ROUTING、POST和ERROR）
 *  Execution Order：表示相同Type的Filter的执行顺序
 *  Criteria：执行条件
 *  Action：执行体

Zuul提供了动态读取、编译和执行Filter的框架。各个Filter间没有直接联系，但是都通过`RequestContext`共享一些状态数据。

尽管Zuul支持任何基于JVM的语言，但是过滤器目前是用Groovy编写的。 每个过滤器的源代码被写入到Zuul服务器上的一组指定的目录中，这些目录将被定期轮询检查是否更新。Zuul会读取已更新的过滤器，动态编译到正在运行的服务器中，并后续请求中调用。

6.2 Filter Types

以下提供四种标准的Filter类型及其在请求生命周期中所处的位置：

*  PRE Filter：在请求路由到目标之前执行。一般用于请求认证、负载均衡和日志记录。
 *  ROUTING Filter：处理目标请求。这里使用Apache HttpClient或Netflix Ribbon构造对目标的HTTP请求。
 *  POST Filter：在目标请求返回后执行。一般会在此步骤添加响应头、收集统计和性能数据等。
 *  ERROR Filter：整个流程某块出错时执行。

除了上述默认的四种Filter类型外，Zuul还允许自定义Filter类型并显示执行。例如，我们定义一个STATIC类型的Filter，它直接在Zuul中生成一个响应，而非将请求在转发到目标。

6.3 Zuul请求生命周期

一图胜千言，下面通过官方的一张图来了解Zuul请求的生命周期。

![zuul-request-lifecycle.png][]

6.4 自定义一个Filter

1、添加一个`PreRequestLogFilter`:

1.  `public class PreRequestLogFilter extends ZuulFilter{`
2.   
3.  `@Override`
4.  `public String filterType() {`
5.  `return PRE_TYPE;`
6.  `}`
7.   
8.  `@Override`
9.  `public int filterOrder() {`
10. `return 0;`
11. `}`
12.  
13. `@Override`
14. `public boolean shouldFilter() {`
15. `return true;`
16. `}`
17.  
18. `@Override`
19. `public Object run() {`
20. `RequestContext currentContext = RequestContext.getCurrentContext();`
21. `HttpServletRequest request = currentContext.getRequest();`
22. `System.out.print(String.format("send %s request to %s",request.getMethod(),request.getRequestURL()));`
23. `return null;`
24. `}`
25. `}`

Java

Copy

2、修改启动类`GatewayZuulDemoApplication`，添加Filter注入：

1.  `@Bean`
2.  `public PreRequestLogFilter preRequestLogFilter(){`
3.  `return new PreRequestLogFilter();`
4.  `}`

3、启动服务并请求服务，观察控制台输出日志信息。

6.4 Filter的启用与禁用

我们自己写的Filter可以通过修改`shouldFilter()`启用或禁用。如果第三方的Filter怎样控制其启用及禁用呢？

很简单，通过配置文件就可以做到：

1.  `zuul:`
2.  `PreRequestLogFilter: #自定义Filter类名`
3.  `pre: #Type`
4.  `disable: true`

## 七、Zuul部分源码分析 ##

在前面提到在ROUTING过滤器中会选择使用Apache HttpClient或Netflix Ribbon请求目标服务，那么什么时候会使用Ribbon是么时候用Apache HttpClient呢？

这里涉及到两个关键Filter：`RibbonRoutingFilter`和`SimpleHostRoutingFilter`。从名字就可以看出来`RibbonRoutingFilter`是使用Ribbon请求目标服务，而`SimpleHostRoutingFilter`则是另一个。

通过`filterOrder()`可以看到`RibbonRoutingFilter`会在`SimpleHostRoutingFilter`之前执行。

1.  `//spring-cloud-netflix-zuul/src/main/java/org/springframework/cloud/netflix/zuul/filters/route/RibbonRoutingFilter.java`
2.   
3.  `@Override`
4.  `public boolean shouldFilter() {`
5.  `RequestContext ctx = RequestContext.getCurrentContext();`
6.  `return (ctx.getRouteHost() == null && ctx.get(SERVICE_ID_KEY) != null /*获取serviceId*/`
7.  `&& ctx.sendZuulResponse());`
8.  `}`

1.  `//spring-cloud-netflix-zuul/src/main/java/org/springframework/cloud/netflix/zuul/filters/route/SimpleHostRoutingFilter.java`
2.   
3.  `@Override`
4.  `public boolean shouldFilter() {`
5.  `return RequestContext.getCurrentContext().getRouteHost() != null`
6.  `&& RequestContext.getCurrentContext().sendZuulResponse();`
7.  `}`

对比两个Filter的生效条件可以看出当配置serviceId时`RibbonRoutingFilter`生效。

下面看看`RibbonRoutingFilter`是如何将Ribbon和Hystrix集成进来的：

1.  `//spring-cloud-netflix-zuul/src/main/java/org/springframework/cloud/netflix/zuul/filters/route/RibbonRoutingFilter.java`
2.   
3.  `public RibbonRoutingFilter(ProxyRequestHelper helper,`
4.  `RibbonCommandFactory<?> ribbonCommandFactory,`
5.  `List<RibbonRequestCustomizer> requestCustomizers) {`
6.  `this.helper = helper;`
7.  `this.ribbonCommandFactory = ribbonCommandFactory;`
8.  `this.requestCustomizers = requestCustomizers;`
9.  `// To support Servlet API 3.1 we need to check if getContentLengthLong exists`
10. `// Spring 5 minimum support is 3.0, so this stays`
11. `try {`
12. `HttpServletRequest.class.getMethod("getContentLengthLong");`
13. `} catch(NoSuchMethodException e) {`
14. `useServlet31 = false;`
15. `}`
16. `}`
17.  
18. `@Override`
19. `public Object run() {`
20. `RequestContext context = RequestContext.getCurrentContext();`
21. `this.helper.addIgnoredHeaders();`
22. `try {`
23. `RibbonCommandContext commandContext = buildCommandContext(context);`
24. `ClientHttpResponse response = forward(commandContext);`
25. `setResponse(response);`
26. `return response;`
27. `}`
28. `catch (ZuulException ex) {`
29. `throw new ZuulRuntimeException(ex);`
30. `}`
31. `catch (Exception ex) {`
32. `throw new ZuulRuntimeException(ex);`
33. `}`
34. `}`
35.  
36. `protected RibbonCommandContext buildCommandContext(RequestContext context) {`
37. `HttpServletRequest request = context.getRequest();`
38.  
39. `MultiValueMap<String, String> headers = this.helper`
40. `.buildZuulRequestHeaders(request);`
41. `MultiValueMap<String, String> params = this.helper`
42. `.buildZuulRequestQueryParams(request);`
43. `String verb = getVerb(request);`
44. `InputStream requestEntity = getRequestBody(request);`
45. `if (request.getContentLength() < 0 && !verb.equalsIgnoreCase("GET")) {`
46. `context.setChunkedRequestBody();`
47. `}`
48.  
49. `String serviceId = (String) context.get(SERVICE_ID_KEY);`
50. `Boolean retryable = (Boolean) context.get(RETRYABLE_KEY);`
51. `Object loadBalancerKey = context.get(LOAD_BALANCER_KEY);`
52.  
53. `String uri = this.helper.buildZuulRequestURI(request);`
54.  
55. `// remove double slashes`
56. `uri = uri.replace("//", "/");`
57.  
58. `long contentLength = useServlet31 ? request.getContentLengthLong(): request.getContentLength();`
59.  
60. `return new RibbonCommandContext(serviceId, verb, uri, retryable, headers, params,`
61. `requestEntity, this.requestCustomizers, contentLength, loadBalancerKey);`
62. `}`
63.  
64. `protected ClientHttpResponse forward(RibbonCommandContext context) throws Exception {`
65. `Map<String, Object> info = this.helper.debug(context.getMethod(),`
66. `context.getUri(), context.getHeaders(), context.getParams(),`
67. `context.getRequestEntity());`
68.  
69. `RibbonCommand command = this.ribbonCommandFactory.create(context);`
70. `try {`
71. `ClientHttpResponse response = command.execute();`
72. `this.helper.appendDebug(info, response.getRawStatusCode(), response.getHeaders());`
73. `return response;`
74. `}`
75. `catch (HystrixRuntimeException ex) {`
76. `return handleException(info, ex);`
77. `}`
78.  
79. `}`

上述代码在构造函数中注入了`ribbonCommandFactory`（实际类型为`RestClientRibbonCommandFactory`）。接着在`run()`方法中构造`RibbonCommandContext`，并通过`RestClientRibbonCommandFactory`创建一个`RibbonCommand`（实际类型为`RestClientRibbonCommand`）。`RestClientRibbonCommand`继承`AbstractRibbonCommand`时所带的泛型参数`RestClient`具备负载均衡能力。又由于在`RestClientRibbonCommand`的继承链上出现了`HystrixCommand`，所以通过该Filter发出的请求实际上就同时集成了Ribbon和Hystrix。

## 八、Zuul的容错与回退 ##

通过实现接口可以实现Zuul的容错与回退功能，下面这个例子来自Zuul的源码`DefaultFallbackProvider`，这里我稍微修改了下：

1.  `@Component`
2.  `public class DefaultFallbackProvider implements FallbackProvider {`
3.  `@Override`
4.  `public String getRoute() {`
5.  `//匹配微服务名字，*表示匹配所有`
6.  `return "*";`
7.  `}`
8.   
9.  `@Override`
10. `public ClientHttpResponse fallbackResponse() {`
11. `return null;`
12. `}`
13.  
14. `@Override`
15. `public ClientHttpResponse fallbackResponse(Throwable cause) {`
16. `return new ClientHttpResponse() {`
17. `@Override`
18. `public HttpStatus getStatusCode() throws IOException {`
19. `//当fallback时返回给调用者的状态码`
20. `return HttpStatus.OK;`
21. `}`
22.  
23. `@Override`
24. `public int getRawStatusCode() throws IOException {`
25. `return this.getStatusCode().value();`
26. `}`
27.  
28. `@Override`
29. `public String getStatusText() throws IOException {`
30. `//状态码的文本形式`
31. `return null;`
32. `}`
33.  
34. `@Override`
35. `public void close() {`
36.  
37. `}`
38.  
39. `@Override`
40. `public InputStream getBody() throws IOException {`
41. `//响应体`
42. `return new ByteArrayInputStream("default fallback".getBytes());`
43. `}`
44.  
45. `@Override`
46. `public HttpHeaders getHeaders() {`
47. `//设定headers`
48. `HttpHeaders headers = new HttpHeaders();`
49. `headers.setContentType(MediaType.TEXT_HTML);`
50. `return headers;`
51. `}`
52. `};`
53. `}`
54. `}`

停掉Rest-Demo后再请求，会发现返回了`DefaultFallbackProvider`中定义fallback的内容。

## 九、高可用 ##

作为网关这么重要的角色，高可用是非常有必要的。但是通常来说网关所面对的请求应该的是来于外部，所以虽然说网关可以注册到Eureka Server上，但是外部的客户端数量众多，是不可能向Eureka Server注册的。那么要实现高可用的，要么在网关前面再架一个前置代理（如Nginx），要么让客户端从Eureka Server处获取Zuul网关地址实现客户端负载均衡。

[Link 1]: http://blog.csdn.net/qq_27384769/article/details/79439782
[spring cloud]: http://blog.csdn.net/qq_27384769/article/details/79439801
[mybatis]: http://blog.csdn.net/qq_27384769/article/details/79439817
[spring boot]: http://blog.csdn.net/qq_27384769/article/details/79439844
[React]: http://blog.csdn.net/qq_27384769/article/details/79439915
[Link 2]: http://blog.csdn.net/qq_27384769/article/details/79439922
[python]: http://blog.csdn.net/qq_27384769/article/details/79490255
[ElasticSearch]: https://blog.csdn.net/qq_27384769/article/category/7521591
[kafka storm _]: https://blog.csdn.net/qq_27384769/article/details/80113336
[scala]: https://blog.csdn.net/qq_27384769/article/details/80410433
[RPC]: https://blog.csdn.net/qq_27384769/article/details/80661594
[Link 3]: https://blog.csdn.net/qq_27384769/article/details/80776598
[GO _]: https://blog.csdn.net/qq_27384769/article/details/81069097
[Android]: https://blog.csdn.net/qq_27384769/article/details/82964354
[nginx]: https://blog.csdn.net/qq_27384769/article/details/81230977
[Zuul]: https://github.com/Netflix/zuul
[Backend for Front-End]: http://microservices.io/patterns/apigateway.html
[gateway.png]: http://www.xdlysk.com/wp-content/uploads/2018/02/gateway.png
[http_localhost_9006_rest-demo_user_xdlysk]: http://localhost:9006/rest-demo/user/xdlysk
[zuul-request-lifecycle.png]: http://www.xdlysk.com/wp-content/uploads/2018/02/zuul-request-lifecycle.png