[亲测]SpringCloud之网关Zuul

痛定思痛。 2022-04-08 10:58 198阅读 0赞

# 一.Zuul网关 #

为什么要学习网关？

答：作为网站的唯一入口，控制权限，保证网站安全

功能：控制权限（鉴权）、分发请求（动态路由）

使用Spring Cloud实现微服务的架构基本成型，大致是这样的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70]

我们使用Spring Cloud Netflix中的Eureka实现了服务注册中心以及服务注册与发现；而服务间通过Ribbon或Feign实现服务的消费以及均衡负载；为了使得服务集群更为健壮，使用Hystrix的融断机制来避免在微服务架构中个别服务出现异常时引起的故障蔓延。

在该架构中，我们的服务集群包含：内部服务Service A和Service B，他们都会注册与订阅服务至Eureka Server，而Open Service是一个对外的服务，通过均衡负载公开至服务调用方。我们把焦点聚集在对外服务这块，直接暴露我们的服务地址，这样的实现是否合理，或者是否有更好的实现方式呢？

先来说说这样架构需要做的一些事儿以及存在的不足：

*  首先，破坏了服务无状态特点。
    
     *  为了保证对外服务的安全性，我们需要实现对服务访问的权限控制，而开放服务的权限控制机制将会贯穿并污染整个开放服务的业务逻辑，这会带来的最直接问题是，破坏了服务集群中REST API无状态的特点。
     *  从具体开发和测试的角度来说，在工作中除了要考虑实际的业务逻辑之外，还需要额外考虑对接口访问的控制处理。
 *  其次，无法直接复用既有接口。
    
     *  当我们需要对一个即有的集群内访问接口，实现外部服务访问时，我们不得不通过在原有接口上增加校验逻辑，或增加一个代理调用来实现权限控制，无法直接复用原有的接口。

面对类似上面的问题，我们要如何解决呢？答案是：服务网关！

为了解决上面这些问题，我们需要将权限控制这样的东西从我们的服务单元中抽离出去，而最适合这些逻辑的地方就是处于对外访问最前端的地方，我们需要一个更强大一些的均衡负载器的 服务网关。

服务网关是微服务架构中一个不可或缺的部分。通过服务网关统一向外系统提供REST API的过程中，除了具备服务路由、均衡负载功能之外，它还具备了`权限控制`等功能。Spring Cloud Netflix中的Zuul就担任了这样的一个角色，为微服务架构提供了前门保护的作用，同时将权限控制这些较重的非业务逻辑内容迁移到服务路由层面，使得服务集群主体能够具备更高的可复用性和可测试性。

## 1.1.简介 ##

官网：[https://github.com/Netflix/zuul][https_github.com_Netflix_zuul]  
![在这里插入图片描述][2018121016231030.png]

为了让大家更好的理解Zuul，吓到大家了啊  
Zuul：维基百科：

电影《捉鬼敢死队》中的怪兽，Zuul，在纽约引发了巨大骚乱。

事实上，在微服务架构中，Zuul就是守门的大Boss！一夫当关，万夫莫开！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 1]

## 1.2.Zuul加入后的架构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 2]

*  不管是来自于客户端（PC或移动端）的请求，还是服务内部调用。一切对服务的请求都会经过Zuul这个网关，然后再由网关来实现 鉴权、动态路由等等操作。Zuul就是我们服务的统一入口。

## 1.3.快速入门 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 3]

### 1.3.1.新建工程 ###

填写基本信息：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 4]

添加Zuul依赖：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 5]

### 1.3.2.编写启动类 ###

通过`@EnableZuulProxy`注解开启Zuul的功能：

@SpringBootApplication
    @EnableZuulProxy // 开启Zuul的网关功能
    public class ZuulDemoApplication { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(ZuulDemoApplication.class, args);
    	}
    }

### 1.3.3.编写配置 ###

server:
      port: 10010 #服务端口
    spring: 
      application:  
        name: api-gateway #指定服务名

### 1.3.4.编写路由规则 ###

我们需要用Zuul来代理user-service服务，先看一下控制面板中的服务状态：

![在这里插入图片描述][20181210162140970.png]

*  ip为：127.0.0.1
 *  端口为：8081

映射规则：

zuul:
      routes:
        user-service: # 这里是路由id，随意写
          path: /user-service/** # 这里是映射路径
          url: http://127.0.0.1:8081 # 映射路径对应的实际url地址

我们将符合`path` 规则的一切请求，都代理到 `url`参数指定的地址

本例中，我们将 `/user-service/**`开头的请求，代理到http://127.0.0.1:8081

### 1.3.5.启动测试： ###

访问的路径中需要加上配置规则的映射路径，我们访问：[http://127.0.0.1:8081/user-service/user/10][http_127.0.0.1_8081_user-service_user_10]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 6]

## 1.4.面向服务的路由 ##

在刚才的路由规则中，我们把路径对应的服务地址写死了！如果同一服务有多个实例的话，这样做就无法负载均衡

我们应该根据服务的名称，去Eureka注册中心查找 服务对应的所有实例列表，然后进行**动态路由**才对！

### 1.4.1.添加Eureka客户端依赖：zuul整合eureka ###

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

### 1.4.2.开启Eureka客户端发现功能 ###

@SpringBootApplication
    @EnableZuulProxy // 开启Zuul的网关功能
    @EnableDiscoveryClient
    public class ZuulDemoApplication { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(ZuulDemoApplication.class, args);
    	}
    }

### 1.4.3.添加Eureka配置，获取服务信息 ###

eureka:
      client:
        registry-fetch-interval-seconds: 5 # 获取服务列表的周期：5s
        service-url:
          defaultZone: http://127.0.0.1:10086/eureka
      instance:
        prefer-ip-address: true
        ip-address: 127.0.0.1

### 1.4.4.修改映射配置，通过服务名称获取 ###

因为已经有了Eureka客户端，我们可以从Eureka获取服务的地址信息，因此映射时无需指定IP地址，而是通过服务名称来访问，而且Zuul已经集成了Ribbon的负载均衡功能。

zuul:
      routes:
        user-service: # 这里是路由id，随意写
          path: /user-service/** # 这里是映射路径
          service-id: user-service # 指定服务名称

### 1.4.5.启动测试 ###

再次启动，这次Zuul进行代理时，会利用Ribbon进行负载均衡访问：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 7]

日志中可以看到使用了负载均衡器：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 8]

## 1.5.简化的路由配置 ##

在刚才的配置中，我们的规则是这样的：

*  `zuul.routes.<route>.path=/xxx/**`： 来指定映射路径。`<route>`是自定义的路由名
 *  `zuul.routes.<route>.serviceId=/user-service`：来指定服务名。

而大多数情况下，我们的`<route>`路由名称往往和 服务名会写成一样的。因此Zuul就提供了一种简化的配置语法：`zuul.routes.<serviceId>=<path>`

比方说上面我们关于user-service的配置可以简化为一条：

zuul:
      routes:
        user-service: /user-service/** # 这里是映射路径

省去了对服务名称的配置。

## 1.6.默认的路由规则 ##

在使用Zuul的过程中，上面讲述的规则已经大大的简化了配置项。但是当服务较多时，配置也是比较繁琐的。因此Zuul就指定了默认的路由规则：

*  默认情况下，一切服务的映射路径就是服务名本身。
    
     *  例如服务名为：`user-service`，则默认的映射路径就是：`/user-service/**`

也就是说，刚才的映射规则我们完全不配置也是OK的，不信就试试看。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 9]

## 1.7.路由前缀 ##

配置示例：

zuul:
      prefix: /api # 添加路由前缀
      routes:
          user-service: # 这里是路由id，随意写
            path: /user-service/** # 这里是映射路径
            service-id: user-service # 指定服务名称

我们通过`zuul.prefix=/api`来指定了路由的前缀，这样在发起请求时，路径就要以/api开头。

路径`/api/user-service/user/1`将会被代理到`/user-service/user/1`

zuul 动态路由 end

zuul 过滤器：鉴定权限 start

## 3.8.过滤器 ##

Zuul作为网关的其中一个重要功能，就是实现请求的鉴权。而这个动作我们往往是通过Zuul提供的过滤器来实现的。

### 3.8.1.ZuulFilter ###

ZuulFilter是过滤器的顶级父类。在这里我们看一下其中定义的4个最重要的方法：

public abstract class ZuulFilter implements IZuulFilter{ 
    
        abstract public String filterType();
    
        abstract public int filterOrder();
        
        boolean shouldFilter();// 来自IZuulFilter
    
        Object run() throws ZuulException;// IZuulFilter
    }

*  `shouldFilter`：返回一个`Boolean`值，判断该过滤器是否需要执行。返回true执行，返回false不执行。
 *  `run`：过滤器的具体业务逻辑。
 *  `filterType`：返回字符串，代表过滤器的类型。包含以下4种：
    
     *  `pre`：请求在被路由之前执行
     *  `routing`：在路由请求时调用
     *  `post`：在routing和errror过滤器之后调用
     *  `error`：处理请求时发生错误调用
 *  `filterOrder`：通过返回的int值来定义过滤器的执行顺序，数字越小优先级越高。

### 1.8.2.过滤器执行生命周期： ###

这张是Zuul官网提供的请求生命周期图，清晰的表现了一个请求在各个过滤器的执行顺序。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 10]

*  正常流程：
    
     *  请求到达首先会经过pre类型过滤器，而后到达routing类型，进行路由，请求就到达真正的服务提供者，执行请求，返回结果后，会到达post过滤器。而后返回响应。
 *  异常流程：
    
     *  整个过程中，pre或者routing过滤器出现异常，都会直接进入error过滤器，再error处理完毕后，会将请求交给POST过滤器，最后返回给用户。
     *  如果是error过滤器自己出现异常，最终也会进入POST过滤器，而后返回。
     *  如果是POST过滤器出现异常，会跳转到error过滤器

所有内置过滤器列表：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 11]

### 3.8.3.使用场景 ###

过滤器场景非常多：

*  **请求鉴权**：一般放在pre类型，如果发现没有访问权限，直接就拦截了
 *  异常处理：一般会在error类型和post类型过滤器中结合来处理。
 *  服务调用时长统计：pre和post结合使用。

## 3.9.自定义过滤器 ##

接下来我们来自定义一个过滤器，模拟一个登录的校验。基本逻辑：如果请求中有access-token=123参数，则认为请求有效，放行。

### 3.9.1.定义过滤器类 ###

@Component
    public class LoginFilter extends ZuulFilter{ 
        @Override
        public String filterType() { 
            // 登录校验，肯定是在前置拦截
            return "pre";
        }
    
        @Override
        public int filterOrder() { 
            // 顺序设置为1
            return 1;
        }
    
        @Override
        public boolean shouldFilter() { 
            // 返回true，代表过滤器生效。
            return true;
        }
    
        @Override
        public Object run() throws ZuulException { 
            // 登录校验逻辑。
            // 1）获取Zuul提供的请求上下文对象
            RequestContext ctx = RequestContext.getCurrentContext();
            // 2) 从上下文中获取request对象
            HttpServletRequest req = ctx.getRequest();
            // 3) 从请求中获取token
            String token = req.getParameter("access-token");
            // 4) 判断
            if(token == null || "".equals(token.trim())){ 
                // 没有token，登录校验失败，拦截
                ctx.setSendZuulResponse(false);
                // 返回401状态码。也可以考虑重定向到登录页。
                ctx.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
            }
            // 校验通过，可以考虑把用户信息放入上下文，继续向后执行
            return null;
        }
    }

### 1.9.2.测试 ###

没有token参数时，访问失败：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 12]  
添加token参数后：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 13]

## 1.10.负载均衡和熔断 ##

Zuul中默认就已经集成了Ribbon负载均衡和Hystix熔断机制。但是所有的超时策略都是走的默认值，比如熔断超时时间只有1S，很容易就触发了。因此建议我们手动进行配置：

zuul:
      retryable: true
    ribbon:
      ConnectTimeout: 250 # 连接超时时间(ms)
      ReadTimeout: 2000 # 通信超时时间(ms)
      OkToRetryOnAllOperations: true # 是否对所有操作重试
      MaxAutoRetriesNextServer: 2 # 同一服务不同实例的重试次数
      MaxAutoRetries: 1 # 同一实例的重试次数
    hystrix:
      command:
      	default:
            execution:
              isolation:
                thread:
                  timeoutInMilliseconds: 6000 # 熔断超时时长：6000ms

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 14]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 15]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70]: /images/20220406/fa65a876d18e48f4b28f1eb6a0803b6f.png
[https_github.com_Netflix_zuul]: https://github.com/Netflix/zuul
[2018121016231030.png]: /images/20220406/4444044deb0541f492918d9e3de536d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 1]: /images/20220406/acfc6be2913e433baa6bc281a1860945.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 2]: /images/20220406/d1ce39c3bb154ac8a2041e4e7333b4be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 3]: /images/20220406/1f1d18f470904712b140a917cfc15168.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 4]: /images/20220406/d2f86c2915944816831cd5e892eaef70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 5]: /images/20220406/9370a0a753b04dc49867831c1db4d774.png
[20181210162140970.png]: /images/20220406/f073e3834a7b4daf88a32a05fe57b2ad.png
[http_127.0.0.1_8081_user-service_user_10]: http://127.0.0.1:8081/user-service/user/10
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 6]: /images/20220406/313e99322d70466d922457a53f7dfb03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 7]: /images/20220406/435dc45412214c239d9c94f51915e66f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 8]: /images/20220406/6c0578ccd30547dd8d1000c06882e0a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 9]: /images/20220406/5c6189fdfb2e4259aff4041ac1614d4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 10]: /images/20220406/59c8ea9a54bc479caad643e2fef83eee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 11]: /images/20220406/7aeaf838fc46492daf775712fdb899bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 12]: /images/20220406/2563fdb7c8654ebdb4150c2840ae32f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 13]: /images/20220406/1b1b443e33a346a591ddd3224caa86e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 14]: /images/20220406/1d4b352bfcaa4302bd01b7027f56876e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyNTA5_size_16_color_FFFFFF_t_70 15]: /images/20220406/4c96fe432384473684691ce432089e26.png