spring cloud zuul 笔记

Zuul服务网关的介绍与用途

Zuul简介

zuul是Netflix设计用来为所有面向设备、web网站提供服务的所有应用的门面，zuul可以提供动态路由、监控、弹性扩展、安全认证等服务，他还可以根据需求将请求路由到多个应用中。

zuul是用来解决什么问题的

（1）- 权限控制和安全性--为每个请求提供身份认证，并拒绝不满足条件的请求。

（2）- 预警和监控--跟踪前端有意义的请求和统计数据，以便我们准确了解生产环境运行状况。

（3）- 动态路由--根据需求将请求动态地路由到不同的后端集群。

（4）- 压力测试--逐渐增大到集群的流量，以便进行性能评估。

（5）- 负载均衡--为每种类型的请求分配容量并丢弃超过限额的请求。

（6）- 静态资源处理--直接在Zuul处理静态资源并响应，而并非转发这些请求到内部集群中。

（7）- 多区域弹性--实现跨AWS区域请求路由，扩大了ELB的使用范围，并使前端服务更接近我们的成员。

Zuul网关的应用

https://www.cnblogs.com/jing99/p/11696192.html

网关依赖注入

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>
<!-- zuul网关的重试机制，不是使用ribbon内置的重试机制
   是借助spring-retry组件实现的重试
   开启zuul网关重试机制需要增加下述依赖
 -->
<dependency>
   <groupId>org.springframework.retry</groupId>
   <artifactId>spring-retry</artifactId>
</dependency>

网关启动器

/**
 * @EnableZuulProxy - 开启Zuul网关。
 *  当前应用是一个Zuul微服务网关。会在Eureka注册中心中注册当前服务。并发现其他的服务。
 *  Zuul需要的必要依赖是spring-cloud-starter-zuul。
 */
@SpringBootApplication
@EnableZuulProxy
public class ZuulApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZuulApplication.class, args);
    }
}

网关全局变量配置

URL路径匹配

在zuul中，路由匹配的路径表达式采用ant风格定义

通配符	说明
?	匹配任意单个字符
*	匹配任意数量的字符
**	匹配任意数量的字符，支持多级目录

 

 

 

URL路径	说明
/user-service/?	它可以匹配/user-service/之后拼接一个任务字符的路径， 比如 /user-service/a 、/user-service/b 、/user-service/c
/user-service/*	它可以匹配/user-service/之后拼接任意字符的路径， 比如 /user-service/a 、/user-service/aaa 、/user-service/bbb。但 是它无法匹配/user-service/alb
/user-service/**	它可以匹配/user-service/*包含的内容之外， 还可以匹配形如 /user-service/alb的多级目录路径

具体配置如下:

# URL pattern
# 使用路径方式匹配路由规则。
# 参数key结构： zuul.routes.customName.path=xxx
# 用于配置路径匹配规则。
# 其中customName自定义。通常使用要调用的服务名称，方便后期管理
# 可使用的通配符有： * ** ?
# ? 单个字符
# * 任意多个字符，不包含多级路径
# ** 任意多个字符，包含多级路径
zuul.routes.eureka-application-service.path=/api/**
# 参数key结构： zuul.routes.customName.url=xxx
# url用于配置符合path的请求路径路由到的服务地址。
zuul.routes.eureka-application-service.url=http://127.0.0.1:8080/

服务名称匹配

# service id pattern 通过服务名称路由
# key结构 ： zuul.routes.customName.path=xxx
# 路径匹配规则
zuul.routes.eureka-application-service.path=/api/**
# key结构 ： zuul.routes.customName.serviceId=xxx
# serviceId用于配置符合path的请求路径路由到的服务名称。
zuul.routes.eureka-application-service.serviceId=eureka-application-service

服务名称匹配也可以使用简化的配置：

# simple service id pattern 简化配置方案
# 如果只配置path，不配置serviceId。则customName相当于服务名称。
# 符合path的请求路径直接路由到customName对应的服务上。
zuul.routes.eureka-application-service.path=/api/**

路由排除配置

# ignored service id pattern
# 配置不被zuul管理的服务列表。多个服务名称使用逗号','分隔。
# 配置的服务将不被zuul代理。
zuul.ignored-services=eureka-application-service
# 此方式相当于给所有新发现的服务默认排除zuul网关访问方式，只有配置了路由网关的服务才可以通过zuul网关访问
# 通配方式配置排除列表。
zuul.ignored-services=*
# 使用服务名称匹配规则配置路由列表，相当于只对已配置的服务提供网关代理。
zuul.routes.eureka-application-service.path=/api/**

# 通配方式配置排除网关代理路径。所有符合ignored-patterns的请求路径都不被zuul网关代理。
zuul.ignored-patterns=/**/test/**
zuul.routes.eureka-application-service.path=/api/**

路由前缀配置

# prefix URL pattern 前缀路由匹配
# 配置请求路径前缀，所有基于此前缀的请求都由zuul网关提供代理。
zuul.prefix=/api
# 使用服务名称匹配方式配置请求路径规则。
# 这里的配置将为：http://ip:port/api/appservice/**的请求提供zuul网关代理，可以将要访问服务进行前缀分类。
# 并将请求路由到服务eureka-application-service中。
zuul.routes.eureka-application-service.path=/appservice/**

一份yml配置例子

server:
  port: 10012   # 端口号
spring:
  application:
    name: zuul-service   # 网关服务名称
zuul:
  prefix: /api   # 访问网关路径的前缀（在映射路径的前面，一般用于区别开发的版本）
  routes:
    zuul-service01:       # 随意写的区分不同映射服务器的名称（只是区分不同的映射服务器）
      path: /user-service-zuul/**    # 自定义映射服务器路径的名称（相当于key，外部访问这个地址会映射到下面的service-id这个value值。然后从eureka服务列表找到对应服务名称，进而负载均衡的请求一个服务器）
#      url: http://127.0.0.1:8093  # 这是写的固定映射url，可代替service-id。但是不能实现服务器的负载均衡和高可用，因为总是访问同一服务器
      service-id: user-service     # eureka注册中心中要映射的服务名称，因为是双层map结构，所以可以实现负载均衡和高可用
    zuul-service02:               # 搭建另一个映射服务器，这里就简单的映射同一服务了。简单测试下而已
      path: /user-service-zuul-first/**
      service-id: user-service    # 映射服务器名称简单的使用上面的，仅供测试
#  因为zuul是整合ribbon和hystrix的另一个客户端，所以我们需要自己导入spring-retry坐标，并且开启服务
  retryable: true
#  配置zuul的连接时间，一般不需要配置
#  host:
#    max-per-route-connections:
#    socket-timeout-millis:
#    connect-timeout-millis:
#  ignored-services: microservice-comsumer-movie-ribbon-withhystrix    # 这是表示某一个服务不允许代理，上面配置的是需要代理的
eureka:
  client:
    registry-fetch-interval-seconds: 5    # 获取注册列表的周期
    service-url:
#    eureka注册中心地址
      defaultZone: http://127.0.0.1:8090/eureka,http://127.0.0.1:8091/eureka,http://127.0.0.1:8092/eureka
  instance:
    prefer-ip-address: true   # 返回ip地址而不是hostname
    ip-address: 127.0.0.1      # 本机地址
ribbon:
  ConnectTimeout: 250 # 连接超时时间（ms），默认值为250ms
  ReadTimeout: 2000 # 通信超时时间（ms），默认值为2000ms
  OkToRetryOnAllOperations: true # 是否对所有操作都进行重试
  MaxAutoRetriesNextServer: 2 # 对同一服务不同实例重试次数（同一服务下集群个数的重试次数）
  MaxAutoRetries: 2 # 对同一实例重试的次数（单个集群节点服务重试的次数）
# 开启熔断机制，超过六秒即开启熔断机制，网关内的时间排序：zuul的通信时间 > hystrix熔断时间 > retry重试时间
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 6000

Zuul网关过滤器

Zuul中提供了过滤器定义，可以用来过滤代理请求，提供额外功能逻辑。如：权限验证，日志记录等。

　　Zuul提供的过滤器是一个父类。父类是ZuulFilter。通过父类中定义的抽象方法filterType，来决定当前的Filter种类是什么。有前置过滤、路由后过滤、后置过滤、异常过滤。

• 前置过滤：是请求进入Zuul之后，立刻执行的过滤逻辑。
• 路由后过滤：是请求进入Zuul之后，并Zuul实现了请求路由后执行的过滤逻辑，路由后过滤，是在远程服务调用之前过滤的逻辑。
• 后置过滤：远程服务调用结束后执行的过滤逻辑。
• 异常过滤：是任意一个过滤器发生异常或远程服务调用无结果反馈的时候执行的过滤逻辑。无结果反馈，就是远程服务调用超时。

　　3.1 过滤器实现方式

继承父类ZuulFilter。在父类中提供了4个抽象方法，分别是：filterType, filterOrder, shouldFilter, run。其功能分别是：

• filterType：方法返回字符串数据，代表当前过滤器的类型。可选值有-pre, route, post, error。

pre - 前置过滤器，在请求被路由前执行，通常用于处理身份认证，日志记录等；

route - 在路由执行后，服务调用前被调用；

error - 任意一个filter发生异常的时候执行或远程服务调用没有反馈的时候执行（超时），通常用于处理异常；

post - 在route或error执行后被调用，一般用于收集服务信息，统计服务性能指标等，也可以对response结果做特殊处理。

• filterOrder：返回int数据，用于为同filterType的多个过滤器定制执行顺序，返回值越小，执行顺序越优先。
• shouldFilter：返回boolean数据，代表当前filter是否生效。
• run：具体的过滤执行逻辑。如pre类型的过滤器，可以通过对请求的验证来决定是否将请求路由到服务上；如post类型的过滤器，可以对服务响应结果做加工处理（如为每个响应增加footer数据）。

　　3.2 过滤器的生命周期

　　

代码示例

Pre type

/**
 * Zuul过滤器，必须继承ZuulFilter父类。
 * 当前类型的对象必须交由Spring容器管理。使用@Component注解描述。
 * 继承父类后，必须实现父类中定义的4个抽象方法。
 * shouldFilter、 run、 filterType、 filterOrder
 */
@Component
public class LoggerFilter extends ZuulFilter {

    private static final Logger logger = LoggerFactory.getLogger(LoggerFilter.class);
    
    /**
     * 返回boolean类型。代表当前filter是否生效。
     * 默认值为false。
     * 返回true代表开启filter。
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * run方法就是过滤器的具体逻辑。
     * return 可以返回任意的对象，当前实现忽略。（spring-cloud-zuul官方解释）
     * 直接返回null即可。
     */
    @Override
    public Object run() throws ZuulException {
        // 通过zuul，获取请求上下文
        RequestContext rc = RequestContext.getCurrentContext();
        HttpServletRequest request = rc.getRequest();

        logger.info("LogFilter1.....method={},url={}",
                request.getMethod(),request.getRequestURL().toString());
        // 可以记录日志、鉴权，给维护人员记录提供定位协助、统计性能
        return null;
    }

    /**
     * 过滤器的类型。可选值有：
     * pre - 前置过滤
     * route - 路由后过滤
     * error - 异常过滤
     * post - 远程服务调用后过滤
     */
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
    }

    /**
     * 同种类的过滤器的执行顺序。
     * 按照返回值的自然升序执行。
     */
    @Override
    public int filterOrder() {
        return 0;
    }
}

Post type:

@Component
public class AddResponseHeaderFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return FilterConstants.POST_TYPE;
    }

    @Override
    public int filterOrder() {
        return FilterConstants.SEND_RESPONSE_FILTER_ORDER - 1;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletResponse response = requestContext.getResponse();
        response.setHeader("X-Foo", UUID.randomUUID().toString());

        return null;
    }
}

指定url进行网关过滤

@Component
public class AuthBuyerFilter extends ZuulFilter {

    private static final String ORDER_CREATE = "/order/buyer/order/create";

    @Override
    public String filterType() {
        // 声明过滤器的类型为Pre
        return FilterConstants.PRE_TYPE;
    }

    @Override
    public int filterOrder() {
        // 将这个过滤器的优先级放在 PRE_DECORATION_FILTER_ORDER 之前
        return FilterConstants.PRE_DECORATION_FILTER_ORDER - 1;
    }

    @Override
    public boolean shouldFilter() {
        RequestContext requestContext = RequestContext.getCurrentContext();
        // 从上下文中拿到请求对象
        HttpServletRequest request = requestContext.getRequest();

        // 如果访问的是 ORDER_CREATE 则进行拦截，否则不进行拦截
        return ORDER_CREATE.equals(request.getRequestURI());
    }

    /**
     * 这个方法用于自定义过滤器的处理代码
     *
     * @return Object
     * @throws ZuulException ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        RequestContext requestContext = RequestContext.getCurrentContext();
        // 从上下文中拿到请求对象
        HttpServletRequest request = requestContext.getRequest();

        // /buyer/order/create 只能买家访问 （cookie里有openid）
        Cookie cookie = CookieUtil.get(request, "openid");
        if (cookie == null || StringUtils.isBlank(cookie.getValue())) {
            requestContext.setSendZuulResponse(false);
            requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
        }

        return null;
    }
}

Zuul：跨域

现在我们的项目基本都是前后端分离的，前端通过ajax来请求后端接口。由于浏览器的同源策略，所以会出现跨域的问题。而在微服务架构中，我们可以在网关上统一解决跨域的问题。

package org.zero.springcloud.apigateway.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

/**
 * @program: api-gateway
 * @description: 跨域配置
 * @author: 01
 * @create: 2018-08-27 23:02
 **/
@Configuration
public class CorsConfig {

    private CorsConfiguration buildConfig() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        // 允许cookie跨域
        corsConfiguration.setAllowCredentials(true);
        // 允许任何域名使用
        corsConfiguration.addAllowedOrigin("*");
        // 允许任何头
        corsConfiguration.addAllowedHeader("*");
        // 允许任何方法（post、get等）
        corsConfiguration.addAllowedMethod("*");
        // 设置跨域缓存时间，单位为秒
        corsConfiguration.setMaxAge(300L);

        return corsConfiguration;
    }

    @Bean
    public CorsFilter corsFilter() {
        final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        // 对接口配置跨域设置
        source.registerCorsConfiguration("/**", buildConfig());

        return new CorsFilter(source);
    }
}

文章就介绍到这里.