学习微服务网关zuul，看这篇就够了

最新推荐文章于 2024-08-13 21:36:02 发布
最新推荐文章于 2024-08-13 21:36:02 发布
阅读量1.5k 收藏
点赞数 2

戳蓝字“CSDN云计算”关注我们哦！


作者：爱撒谎的男孩
原文：https://chenjiabing666.github.io/2018/12/25/zuul%E6%9C%8D%E5%8A%A1%E7%BD%91%E5%85%B3/

本文系读者投稿，已获作者原创授权。

如果你有好文章，可以戳这里投稿。

Zuul

简介

Zuul包含了对请求的路由和过滤两个主要的功能，其中路由功能负责将外部的请求转发到具体的微服务实例上，是实现外部访问统一入口的基础上，而过滤功能则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。

Zuul和Eureka进行整合，将Zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获取其他微服务的信息，也即以后访问微服务都是通过Zuul跳转后获得。

代理+路由+过滤三大功能。

使用

需要和Eureka客户端结合使用，依赖如下：

1
2
3
4
5
6
7
8
9
10
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--zuul的依赖-->
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
 
 
 
 
添加配置，将其注册到eureka中，如下：
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
server:
  port: 9001
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:7001/eureka  # eureka的暴露地址，直接注册
  instance:
    instance-id: zuul.com
    prefer-ip-address: true
spring:
  application:
    name: zuul   #应用的名称，在同一个eureka中必须不重复
 
 
 
 
在主启动类上添加@EnableZuulProxy这个注解，如下:
 
 
 
  
1
2
3
4
@SpringBootApplication
@EnableEurekaClient  //开启eurkea客户端
@EnableZuulProxy   //开启zuul
public class DeptGetWayZuul9001Application {
 
 
 
 
启动即可，在eureka中看到注册进入即可
 
 
之后只需要通过zuul访问其他的微服务提供者即可，比如服务提供者的实例名称为dept-provider，那么通过zuul访问的路径为
 
 
http://localhost:9001/dept-provider/dept/1
 
 
路由映射规则
 
 
代理名称
 
 
之前的配置访问的还是需要带上微服务的实例名称，但是我们不想微服务的实例名称暴露，那么此时就需要使用代理名称替代，配置如下:
 
 
  • 使用ignored-services忽略真实的服务名称访问，可以同时指定多个，其中服务名称必须和服务配置文件中一样。
  • 在routes下指定多个路由映射规则。
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
zuul:
# 忽略真实的服务名称实例访问，是一个Set集合，可以指定多个，取消全部使用 "*"即可
  ignored-services:
  - order-provider
#routes下面指定代理规则，可以同时指定多个
  routes:
#指定第一个规则，这里的名称任意
    api-order:
#指定的实例名称
      serviceId: order-provider
#指定可以访问的路由
      path: /api-order/**
 
 
 
 
按照上面的配置完成之后就可以直接使用映射的路由访问即可，如：
 
 
http://zuul.com:9001/api-order/order/1
 
 
设置统一前缀
 
 
我们可以在所有的访问uri前面加上统一的前缀，配置如下:
 
 
使用zuul.prefix加上统一的前缀即可
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
zuul:
#加上统一的前缀，那么访问的时候一定要加上这个前缀才可以访问到
  prefix: /chenjiabing
# 忽略真实的服务名称实例访问，是一个Set集合，可以指定多个，取消全部使用 "*"即可
  ignored-services:
  - order-provider
#routes下面指定代理规则，可以同时指定多个
  routes:
#指定第一个规则，这里的名称任意
    api-dept:
#指定的实例名称
      serviceId: order-provider
#指定可以访问的路由
      path: /api-order/**
 
 
 
 
通过上面的配置，此时的访问路径变成
 
 

 
 
http://zuul.com:9001/chenjiabing/api-order/order/1
 
 

 
 
某个uri取消路由
 
 
使用zuul.ignored-services是忽略一个或者多个微服务的全部接口，但是如果我们可以更细化
 
 
如果我们需要隐藏一些敏感的接口不给访问，我们可以在yml文件中配置，如下:
 
 
 
  
1
2
3
4
zuul:
  ignored-patterns:
  - /api-order/order/list   # 取消指定的一个
  - /api-order/order/**     # 使用通配符去掉order下的全部接口
 
 
 
 
传递敏感头信息
 
 
默认zuul是不能传递头信息的，比如cookie，默认的设置了三个字段，如下:
 
 
 
  
1
2
private Set<String> sensitiveHeaders = new LinkedHashSet<>(
 Arrays.asList("Cookie", "Set-Cookie", "Authorization"));
 
 
 
 
如果我们想让它不过滤，只需要将其设置为空，或者不配置其他的，如下：
 
 
  • 将sensitive-headers这个值设置为空即可
  • 这个配置只是针对order-provider这个微服务起作用
 
 
 
  
1
2
3
4
5
6
7
8
9
zuul:
  routes:
#指定第一个规则，这里的名称任意
    api-order:
#指定的实例名称
      serviceId: order-provider
#指定可以访问的路由
      path: /api-order/**
      sensitive-headers:   # 设置为空即可，那么就可以传递敏感头信息了
 
 
 
 
上面的配置是针对单个服务的设置，我们也可以配置针对所有的服务，如下：
 
 
 
  
1
2
zuul:
  sensitive-headers:   # 设置所有的服务都取消敏感头信息
 
 
 
 
过滤器
 
 
生命周期
 
 
Filter 的生命周期有 4 个，分别是 “PRE”、“ROUTING”、“POST” 和“ERROR”，整个生命周期可以用下图来表示
 
 
  • 640?wx_fmt=jpeg
 
 
生命周期解释如下：
 
 
  • PRE：这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、鉴权、限流、参数校验、请求转发，在集群中选择请求的微服务、记录调试信息等。
  • ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用 Apache HttpClient 或 Netfilx Ribbon 请求微服务。
  • POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的 HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。
  • ERROR：在其他阶段发生错误时执行该过滤器。 除了默认的过滤器类型，Zuul 还允许我们创建自定义的过滤器类型。例如，我们可以定制一种 STATIC 类型的过滤器，直接在 Zuul 中生成响应，而不将请求转发到后端的微服务。
 
 
前置过滤器的使用
 
 
利用前置过滤器实现检测token是否正确，如果不正确，那么直接返回权限不足401状态码，不路由微服务。
 
 
继承ZuulFilter。
 
 
注入到ioc容器中。
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
* 自定义过滤器，用于实现鉴权，前置过滤器
*   继承ZuulFilter
*/
@Component  //一定要注入到ioc容器中
public class TokenFilter extends ZuulFilter {
 /**
 * 判断过滤器是否被执行，返回true表示被会被执
 * 在这里我们可以限制过滤器的执行范围，可以根据指定的条件判断这个请求是否被过滤
 */
 @Override
 public boolean shouldFilter() {
 return true;
 }
 /**
 * 过滤器的具体实现逻辑
 * @return
 * @throws ZuulException
 */
 @Override
 public Object run() throws ZuulException {
 RequestContext requestContext = RequestContext.getCurrentContext();  //获取请求上下文
 HttpServletRequest request = requestContext.getRequest();  //获取HttpServletRequest
 String token = request.getParameter("token");  //获取传递过来的请求参数
 //如果token是空的，返回权限不足，一般返回的状态码是401
 if (StringUtils.isEmpty(token)) {
 requestContext.setSendZuulResponse(false);  //设置false，此时的zuul不对此路由
 requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());  //设置401
// requestContext.setResponseBody("no power");  //设置响应的消息
 }
 return null;
 }
 /**
 * 指定过滤器的类型，前置，后置.................
 * 1、其中FilterConstants这个常量类中定义了过滤器常用的变量
 *    public static final String ERROR_TYPE = "error";
 public static final String POST_TYPE = "post";
 public static final String PRE_TYPE = "pre";
 public static final String ROUTE_TYPE = "route"; 
 * @return
 */
 @Override
 public String filterType() {
 return FilterConstants.PRE_TYPE;    //前置过滤器 pre
 }
 /**
 * 过滤器执行的顺序，数字越小优先级越高
 * @return
 */
 @Override
 public int filterOrder() {
 //一般前置过滤器放在org.springframework.cloud.netflix.zuul.filters.pre.PreDecorationFilter这个过滤器之前即可，只需要将其对应的顺序-1
 return FilterConstants.PRE_DECORATION_FILTER_ORDER-1;
 }
}
 
 
 
 
后置过滤器的使用
 
 
利用后置过滤器在响应头中添加内容，和前置过滤器的使用一样，只是使用的过滤器的类型不用，如下：
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* 后置过滤器，在响应头中添加一些内容
*/
@Component //注入
public class AddResponseHeaderFilter extends ZuulFilter {
 @Override
 public boolean shouldFilter() {
 return true;
 }
 @Override
 public Object run() throws ZuulException {
 RequestContext requestContext = RequestContext.getCurrentContext();  //获取请求上下文
 HttpServletResponse response = requestContext.getResponse();  //获取HttpServletResponse
 response.addHeader("X-Foo", "add header");  //添加头信息
 return null;
 }
 @Override
 public String filterType() {
 return FilterConstants.POST_TYPE; //后置过滤器
 }
 @Override
 public int filterOrder() {
 //在org.springframework.cloud.netflix.zuul.filters.post.SendResponseFilter#filterOrder()这个过滤一起之前执行即可
 return FilterConstants.SEND_RESPONSE_FILTER_ORDER-1;
 }
}
 
 
 
 
禁用某种过滤器
 
 
如果我们想要禁用某种过滤器（自定义或者zuul自身的），我们可以在配置中设置，格式：zuul.<SimpleClassName>.<filterType>.disable=true，比如禁用我们TokenFilter，如下：
 
 
 
  
1
2
3
4
zuul:
  TokenFilter:  # 类的名字
    pre:        # 类型
      disable: true
 
 
 
 
限流
 
 
令牌桶算法
 
 
https://blog.csdn.net/tianyaleixiaowu/article/details/74942405
 
 
https://baike.baidu.com/item/%E4%BB%A4%E7%89%8C%E6%A1%B6%E7%AE%97%E6%B3%95/6597000?fr=aladdin
 
 
系统按照恒定的速率往指定大小的桶里添加令牌，每来一个请求就消耗一个令牌，如果桶内没有令牌表示此事的请求流量已经超过设置的大小了，应该做出相应的响应或者直接抛出异常
 
 
实现
 
 
使用前置过滤器，在请求被转发之前调用，限流的过滤器应该是所有过滤器中优先级最大的
 
 
使用google开源的组件Guava
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import com.google.common.util.concurrent.RateLimiter;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
/**
* 限流 ，前置过滤器
* 限流的过滤器的优先级应该是最高，数字最小
*/
@Component
public class RateFilter extends ZuulFilter {
 private static final RateLimiter RATE_LIMITER=RateLimiter.create(100);  //程每秒钟往桶里放置100个令牌
 
 @Override
 public boolean shouldFilter() {
 return true;
 }
 @Override
 public Object run() throws ZuulException {
 
 /**
 * tryAcquire()：如果获取不到一个令牌,表示流量超时了，没有等待时间
 *  tryAcquire(int permits, long timeout, TimeUnit unit)：获取permits个令牌，如果在指定的时间timeout内，还是没有获取到指定的permits个令牌，那么就返回false
 */
 if (!RATE_LIMITER.tryAcquire()) {
 RequestContext requestContext = RequestContext.getCurrentContext();
 requestContext.setSendZuulResponse(false);  //不路由
 requestContext.setResponseStatusCode(HttpStatus.FORBIDDEN.value());  //403拒绝访问
 }
 
 //也可以直接抛出异常
// if (!RATE_LIMITER.tryAcquire()) {
// throw new RuntimeException();  //抛出异常
// }
 return null;
 }
 @Override
 public String filterType() {
 return FilterConstants.PRE_TYPE;  //前置
 }
 @Override
 public int filterOrder() {
 //org.springframework.cloud.netflix.zuul.filters.pre.ServletDetectionFilter#filterOrder()这个过滤器的优先级是最高的，只需要-1即可
 return FilterConstants.SERVLET_DETECTION_FILTER_ORDER-1;
 }
}
 
 
 
 
多维度限流
 
 
https://segmentfault.com/a/1190000012252677
 
 
鉴权
 
 
https://www.jianshu.com/p/f89f5557990f
 
 
一些api只有具有某些权限的时候才可以被调用，比如用户的一些相关信息，只有在用户登录之后才可以调用，否则将会提示没有权限
 
 
实现
 
 
我们在用户登录成功之后会在返回头中添加cookie的值为openId=random(随机数)，并且将其保存在redis中（key=openId_userId，value=random）
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* 登录的方法，登录成功响应头返回添加cookie
* @param response
* @return
*/
@GetMapping("/user/login")
public String login(HttpServletResponse response) {
 //登录的逻辑。。。。。
 
 //设置cookie的值
 Cookie cookie=new Cookie("openId", UUID.randomUUID().toString());
 cookie.setMaxAge(60*60);
 response.addCookie(cookie);  //添加到响应头中
 
 //添加到redis中，key=openId_userId,value=uuid的值
 
 return "登录成功";
}
 
 
 
 
我们事先将指定权限的接口uri存放在数据库中，在zuul中定义一个鉴权的过滤器，如果请求过来了，判断这个uri是否需要某种权限才能调用，如果不需要直接路由即可，如果需要那么判断cookie中是否有openId，如果没有表示没有登录，权限不够，如果有，需要判断和redis中的值是否相同，如果相同，表示有权限，直接路由到服务即可。
 
 
这里将部分逻辑写在shouldFilter()方法中，限制范围（判断请求的uri是否需要鉴权），run()方法中只需要判断是否具有权限即可。
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/**
* 自定义过滤器，用于实现鉴权，前置过滤器
*   继承ZuulFilter
*/
@Component  //一定要注入到ioc容器中
public class TokenFilter extends ZuulFilter {
 
 @Resource  
 private UriService uriservice;   //注入
@Resource
private RedisTemplate redisTemplate; //redis
 
 /**
 * 判断过滤器是否被执行，返回true表示被会被执行（经过run方法）
 * 只需要判断请求的uri是存在数据库中即可
 */
 @Override
 public boolean shouldFilter() {
 RequestContext context=RequestContext.getCurrentContext();  //获取上下文
 HttpServletRequest request = context.getRequest();  //获取request
 String uri=request.getRequestURI();  //获取请求的uri
 /**
 * 伪代码如下：
 * 1、List<URL> uriList=uriservice.getUrlList();  //获取需要权限访问的uri列表
 * 2、判断请求的uri是否在uriList中
 * 1、如果不存在，return false，表示不用执行过滤的逻辑（run方法）直接路由到指定的服务即可
 * 2、如果不存在返回true，表示执行过滤的逻辑（run方法）
 */
 return true;
 }
 /**
 *   过滤器的具体实现逻辑，经过shouldFilter方法之后，能够执行到这里的表示这个请求的uri需要验证权限
 * @return
 * @throws ZuulException
 */
 @Override
 public Object run() throws ZuulException {
 RequestContext requestContext = RequestContext.getCurrentContext();  //获取请求上下文
 HttpServletRequest request = requestContext.getRequest();  //获取HttpServletRequest
 Cookie[] cookies = request.getCookies();   //获取cookie
 
 /**
 *  伪代码如下：
 * 1、判断cookie中是否存在openId
 * 1、如果不存在，返回权限不足的提示信息
 * 2、如果存在，需要判断redis中存储的openId的值是否和携带过来的cookie值相同
 * 1、如果不相同，返回权限不足的提示信息
 * 2、如果相同，表示这个请求具有相应的权限
 */
 return null;
 }
 @Override
 public String filterType() {
 return FilterConstants.PRE_TYPE;    //前置过滤器 pre
 }
 @Override
 public int filterOrder() {
 //一般前置过滤器放在org.springframework.cloud.netflix.zuul.filters.pre.PreDecorationFilter这个过滤器之前即可，只需要将其对应的顺序-1
 return FilterConstants.PRE_DECORATION_FILTER_ORDER-1;
 }
}
 
 
 
 
跨域
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Arrays;
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;
/**
* 跨域的配置类
*/
@Configuration   //配置类
public class CorsConfig {
 @Bean
 public CorsFilter corsFilter() {
 final UrlBasedCorsConfigurationSource source=new UrlBasedCorsConfigurationSource();
 final CorsConfiguration config=new CorsConfiguration();
 config.setAllowCredentials(true);   //支持cookie跨域
 config.setAllowedOrigins(Arrays.asList("*"));  //配置允许跨域访问的域名，这里*表示全部
 config.setAllowedHeaders(Arrays.asList("*"));  //设置允许的头
 config.setAllowedMethods(Arrays.asList("*")); //设置允许跨域的方法，GET,POST....,这里表示允许全部
 config.setMaxAge(300l);  //缓存时间，在指定的时间内，对于相同的请求就不需要再次检查了
 source.registerCorsConfiguration("/**", config);
 return new CorsFilter(source);
 }
}
 
 
 
 
超时时间设置
 
 
我们在使用zuul访问服务的时候，一旦服务超过很短的时间没有响应，那么zuul就会自动熔断，默认的时间是2秒，但是可以通过配置修改，如下：由于zuul使用ribbon实现负载均衡，因此这里还需要配置ribbon的超时时间，否则配置将不会生效
 
 
 
  
1
2
3
4
5
6
7
8
zuul:
    host:  # 配置zuul的超时时间
        connect-timeout-millis: 60000  # 默认2秒，  
        socket-timeout-millis: 60000
ribbon:   # zuul使用服务发现的时候，要想让上面的配置生效，必须配置ribbon的超时时间
  ReadTimeout: 60000     # 请求处理时间。
  ConnectTimeout: 60000   # 请求连接时间。
 
 
 
 
服务熔断
 
 
当请求的服务响应时间超时或者服务不可用的时候zuul会直接响应异常，我们可以设置熔断，只需要在zuul的服务中配置即可，如下：
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package cn.tedu.zuul.hystrix;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;
/**
* 设置zuul的熔断
* 实现FallbackProvider接口
* 出现熔断的情况如下：
* 1、当请求的服务响应超时
* 2、当请求的服务不能正常提供服务
*/
@Component  //注入到IOC容器
public class OrderFallback implements FallbackProvider {
 /**
 * 这个方法返回的是serviceId，如果返回的单个服务，那么只针对一个服务熔断
 * 如果想要针对所有的服务进行配置熔断，只需要返回*即可
 */
 @Override
 public String getRoute() {
 return "order-provider";
 }
 /**
 * 发生熔断的响应方法
 */
 @Override
 public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
 return new ClientHttpResponse() {
 @Override
 public HttpStatus getStatusCode() throws IOException {
 return HttpStatus.OK;
 }
 @Override
 public int getRawStatusCode() throws IOException {
 return 200;
 }
 @Override
 public String getStatusText() throws IOException {
 return "OK";
 }
 @Override
 public void close() {
 }
 
 //设置响应的内容
 @Override
 public InputStream getBody() throws IOException {
 return new ByteArrayInputStream("fallback".getBytes());
 }
 @Override
 public HttpHeaders getHeaders() {
 HttpHeaders headers = new HttpHeaders();
 headers.setContentType(MediaType.APPLICATION_JSON);
 return headers;
 }
 };
 }
}
 
 
 
 
zuul的重试
 
 
有时候因为网络或者其它原因，服务可能会暂时的不可用，这个时候我们希望可以再次对服务进行重试，Zuul也帮我们实现了此功能，需要结合Spring Retry 一起来实现
 
 
依赖：
 
 
 
  
1
2
3
4
5
<!-- 超时重试 -->
<dependency>
 <groupId>org.springframework.retry</groupId>
 <artifactId>spring-retry</artifactId>
</dependency>
 
 
 
 
在配置文件中配置如下：
 
 
  • 在zuul中开启重试机制
  • 配置ribbon的重试次数
  • 默认请求超时时间很短，还可以配置ribbon的超时时间
 
 
 
  
1
2
3
4
5
6
zuul:
  retryable: true  # 开启重试机制
ribbon:    # zuul内部使用的是ribbon实现负载均衡的，因此配置ribbon的重试次数
  MaxAutoRetries: 2   # 同一个服务的最大重试次数
  MaxAutoRetriesNextServer: 2   # 对于切换的下一个实例的重试次数
 
 
 
 
Zuul的高可用
 
 
将多个zuul的微服务注册到Eureka中的（集群）
 
 
Nginx和Zuul混搭的方式，可以将Nginx的请求转发到多个zuul中，zuul再路由给指定的微服务
 
 
完整的配置
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
zuul:
#  TokenFilter:
#    pre:
#      disable: true
# 忽略真实的服务名称实例访问，是一个Set集合，可以指定多个，取消全部使用 "*"即可
  sensitive-headers:   # 设置所有的服务都取消敏感头信息
  ignored-services:
  - order-provider
#  ignored-patterns:
#  - /api-order/order/list   # 取消指定的一个
#  - /api-order/order/**     # 使用通配符去掉order下的全部接口
#routes下面指定代理规则，可以同时指定多个
  routes:
#指定第一个规则，这里的名称任意
    api-order:
#指定的实例名称
      serviceId: order-provider
#指定可以访问的路由
      path: /api-order/**
 
 
 
 
消费端的使用
 
 
前提：
 
 
  • zuul微服务（zuul-server）注册到eureka注册中心
  • 微服务提供者注册到Eureka注册中心，zuul-server配置的路由是api-order
  • 服务消费者注册到Eureka中
 
 
那么如果消费者想用通过zuul-server访问到服务提供者，那么可以直接写http://zuul-server/api-order/order/{id}
 
 
 
  
1
2
3
4
5
6
7
8
9
10
11
12
@RestController
public class OrderController {
 private final static String URI_PRFIX="http://zuul-server/api-order";  //直接使用zuul网管连接订单的服务提供者
 
 @Resource
 private RestTemplate restTemplate;
 
 @GetMapping("/order/{id}")
 public Order getOrder(@PathVariable("id")Integer id) {
 return restTemplate.getForObject(URI_PRFIX+"/order/"+id, Order.class);
 }
}
 
 
 
 
源码
 
 
https://gitee.com/chenjiabing666/zuul-server.git
 
 
参考文章
 
 
https://windmt.com/2018/04/23/spring-cloud-11-zuul-filter/
 
 
https://cloud.spring.io/spring-cloud-netflix/2.0.x/single/spring-cloud-netflix.html#_router_and_filter_zuul
 
 
https://mp.weixin.qq.com/s/FsvZgkvpI0S6rposacGiiQ
 
 

 
 

 
 
推荐阅读
 
  
 

 
 
1.微信群：
 
 
添加小编微信：color_ld，备注“进群+姓名+公司职位”即可，加入【云计算学习交流群】，和志同道合的朋友们共同打卡学习！
 
 

 
 
2.征稿：
 
 
投稿邮箱：liudan@csdn.net；微信号：color_ld。请备注投稿+姓名+公司职位。
 
 640?wx_fmt=png 
 喜欢就点击“好看”吧！ 


                

        

        

    

  


    

      

        

            

              
                
                  csdn业界要闻
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Zuul的使用以及踩坑404问题

				
			

			

				

					月落孤城的博客
				

				

					09-07
					
					1591
					
				

			

		

		

			
				
文章目录zuul的基本使用zuul的坐标将zuul作为服务注册在主启动类上添加@EnableZuulProxy进行访问测试失败404：http://localhost:9528/CLOUD-PAYMENT-SERVICE/payment/get/1成功：http://localhost:9528/cloud-payment-service/payment/get/1失败原因
zuul的基本使用
zuul的坐标
<dependency>
            <groupId>org

			
		

	



                

            
              



	

		

			

				
					
zuul入门（1）zuul 的概念和原理

				
			

			

				

					weixin_34357267的博客
				

				

					06-26
					
					2848
					
				

			

		

		

			
				
一、zuul是什么
zuul 是netflix开源的一个API Gateway 服务器, 本质上是一个web servlet应用。
Zuul 在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。
zuul的例子可以参考 netflix 在github上的 simple webapp，可以按照netflix 在...

			
		

	



              


  
              

                


	

		

			

				
					
网关服务---Zuul

					
最新发布

				
			

			

				

					weixin_59248828的博客
				

				

					08-13
					
					2338
					
				

			

		

		

			
				
Zuul是Netflix的一个开源组件，它是通过Servlet实现的。通过把网关和服务治理整合到一起，Zuul可以获取到服务注册信息，结合RibbonHystrix等更好地实现路由转发、负载均衡等功能。为什么用Hystrix?我们可以搭建简单的微服务架构系统并实现各服务之间的调用，但是不同的微服务一般会有不同的网络地址，而外部客户端（例如手机APP）可能需要调用多个服务的接口才能完成一个业务需求。而客户端直接与各个微服务通信，这样会有许多问题出现。

			
		

	





	

		

			

				
					
zuul的基本使用

				
			

			

				

					Leon_Jinhai_Sun的博客
				

				

					02-01
					
					349
					
				

			

		

		

			
				
快速入门

新建工程

填写基本信息：

添加Zuul依赖：

编写配置


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

编写引导类

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


@SpringBootApplication
@EnableZuulProxy ...

			
		

	



		

			
		



	

		

			

				
					
Zuul入门实战(完整版)

					
热门推荐

				
			

			

				

					三少说
				

				

					10-15
					
					3万+
					
				

			

		

		

			
				
11 Zuul学习
11.1 为什么要使用微服务网关
经过上面的学习，微服务架构已经初具雏形，但还有一些问题，不同的微服务一般会有不同的网络地址，而外部客户端（例如手机APP）可能需要调用多个服务的接口才能完成一个业务需求。
例如一个电影购票的手机APP,可能会调用多个微服务的接口，才能完成一次购票的业务流程。

如果让客户端直接与各个微服务通信，会有以下的问题：

客户端会多次请求不同的微服务，增加了客户端的复杂性。
存在跨域请求，在一定场景下处理相对复杂。
认证复杂，每个服务都需要独立认证。
难以重构，

			
		

	





	

		

			

				
					
Zuul的使用（路由器）

				
			

			

				

					river66的博客
				

				

					03-12
					
					296
					
				

			

		

		

			
				
什么是Zuul?

Zuul是Netflix的基于JVM的路由器和服务器端负载均衡器。

为什么需要Zuul?

一个项目是由多个微服务组成的，每一个微服务对应的地址和端口（ip、port）都是不一样的。这个对于客户端来说，访问会变得繁琐。这时，就需要统一的URL来负责反向代理这些请求，实现路由功能。

Zuul的使用如下：

一、添加依赖


    <dependency>
   ...

			
		

	





	

		

			

				
					
微服务网关zuul

				
			

			

				

					zengqingfa123的博客
				

				

					02-18
					
					367
					
				

			

		

		

			
				
zuul
解决问题：
不同的微服务一般会有不同的网络地址，客户端在访问这些微服务时必须记住几十甚至几百个地址，这对于客户端方来说太复杂也难以维护。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-neRUtMiV-1613658706664)(…/image/image-20200813101956296.png)]
如果让客户端直接与各个微服务通讯，可能会有很多问题：
客户端会请求多个不同的服务，需要维护不同的请求地址，增加开发难度
在某些场景下存在跨域请求的问题
加大身份认

			
		

	





	

		

			

				
					
微服务实战微服务网关Zuul入门与实战

				
			

			

				

					m0_67391683的博客
				

				

					07-30
					
					315
					
				

			

		

		

			
				
Zuul是Netflix公司开源的产品，被称为第一代网关，也是SpringCloud前几个版本默认使用的一款提供动态路由微服务网关组件。Zuul接收所有外来请求，并将请求转发到对应的后端服务。作为一个前置服务，Zuul旨在实现动态路由，监控，弹性和安全性等功能。权限控制和安全性可以识别认证需要的信息和拒绝不满足条件的请求。监控与边缘位置追踪有意义的数据和统计结果，从而带来精确的生产视图。动态路由根据需要动态地路由请求到后台的不同集群。压力测试httpshttps。...

			
		

	





	

		

			

				
					
微服务网关|Zuul1.0和2.0我们该如何选择？

				
			

			

				

					02-24
				

			

		

		

			
				
在今年5月中，Netflix终于开源了它的支持异步调用模式的Zuul网关2.0版本，真可谓千呼万唤始出来。从Netflix的官方博文[附录1]中，我们获得的信息也比较令人振奋：...

			
		

	





	

		

			

				
					
Spring Cloud GateWay学习之微服务网关Zuul、Gateway、nginx的区别和Spring Cloud GateWay的使用。

				
			

			

				

					莫忘莫忧的博客
				

				

					03-24
					
					2529
					
				

			

		

		

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

			
		

	





	

		

			

				
					
微服务入门（Nacos,Feign,网关Zuul）

				
			

			

				

					weixin_45773628的博客
				

				

					08-02
					
					2773
					
				

			

		

		

			
				
日志级别尽量用basic使用HttpClient或OKHttp代替URLConnection引入feign-httpClient依赖配置文件开启httpClient功能，设置连接池参数。

			
		

	





	

		

			

				
					
微服务springcloud之zuul使用demo

				
			

			

				

					08-13
				

			

		

		

			
				
Zuul 网关是具体核心业务服务的看门神，相比具体实现业务的系统服务来说它是一个边缘服务，主要提供动态路由，监控，弹性，安全性等功能。在分布式的微服务系统中，系统被拆为了多套系统，通过 Zuul 网关来对用户的请求进行路由，转发到具体的后台服务系统中，大神必备神器，导入即用，无需更改和配置！

			
		

	





	

		

			

				
					
SpringCloud Zuul路由网关使用详解

				
			

			

				

					小小默：进无止境
				

				

					07-27
					
					2944
					
				

			

		

		

			
				
【1】Zuul是什么

Zuul是从设备和网站到Netflix流应用程序后端的所有请求的前门。作为边缘服务应用程序，Zuul旨在实现动态路由，监控，弹性和安全性。它还可以根据需要将请求路由到多个合适的Amazon弹性收缩组。

为什么创建Zuul？

Netflix API流量的数量和多样性有时会导致生产问题迅速而且没有任何警告。我们需要一个允许我们快速改变行为的系统，以便对这些情况做出反应。

...

			
		

	





	

		

			

				
					
springcloud教程 -- 4.网关zuul的使用详解

				
			

			

				

					叶巨岩的博客
				

				

					03-20
					
					5294
					
				

			

		

		

			
				
zuul


			
		

	





	

		

			

				
					
SpringCloud教程第5篇：Zuul（F版本）

				
			

			

				

					qq_43623447的博客
				

				

					07-03
					
					601
					
				

			

		

		

			
				
文章目录一、Zuul简介二、准备工作三、创建service-zuul工程四、服务过滤五、参考资料：
在微服务架构中，需要几个基础的服务治理组件，包括服务注册与发现、服务消费、负载均衡、断路器、智能路由、配置管理等，由这几个基础组件相互协作，共同组建了一个简单的微服务系统。一个简答的微服务系统如下图：

注意：A服务和B服务是可以相互调用的，作图的时候忘记了。并且配置服务也是注册到服务注册中心的。 在Spring Cloud微服务系统中，一种常见的负载均衡方式是，客户端的请求首先经过负载均衡（zuul、Ngn

			
		

	





	

		

			

				
					
Zuul网关使用步骤

				
			

			

				

					CSDN__luo的博客
				

				

					08-06
					
					419
					
				

			

		

		

			
				
Zuul网关使用步骤
1.在父项目中导入依赖SpringCloud管理
<dependencyManagement>
        <dependencies>
            <dependency>
              <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies&

			
		

	





	

		

			

				
					
Spring Cloud微服务网关Zuul基础入门使用

				
			

			

				

					weixin_42008170的博客
				

				

					02-13
					
					1161
					
				

			

		

		

			
				
Zuul是从设备和网络到后端应用程序所有请求的后门，为内部服务提供可配置的对外URL到服务的映射关系，基于JVM的后端路由器。具有一下的功能：

			
		

	





	

		

			

				
					
微服务教程5：spring-cloud 的Zuul 官网 的用法

				
			

			

				

					weixin_39285027的博客
				

				

					05-29
					
					2万+
					
				

			

		

		

			
				
今天，来记录Zuul  ，spring cloud 的网关组件的使用方法
Zuul 的使用场景，就是api的一个入口，当某些权限验证，以及过滤器 等 ，都在此处做处理；
1, 先创建 Zuul 的项目



<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

			
		

	





	

		

			

				
					
一个简单的微服务

				
			

			

				

					安澜公子的博客
				

				

					07-12
					
					707
					
				

			

		

		

			
				
文章目录一个简单的微服务微服务示例服务架构编写服务提供者编写服务消费者整合Spring Boot Actuator
一个简单的微服务

参考:《Srping Cloud与Docker微服务架构实战 周立著》

微服务示例
微服务构建的是分布式系统，微服务间通过网络进行通信。微服务中使用服务消费者与服务提供者来描述微服务之间的关系

服务提供者：服务的被调用方
服务消费者：服务的调用方
这里使用书中...

			
		

	





	

		

			

				
					
SpringCloud微服务网关Zuul：API管理与接入策略

				
			

			

				

					
				

			

		

		

			
				
"本文主要介绍了SpringCloud API网关Zuul的相关知识，包括开放API的概念、微服务网关的功能、API服务管理平台的重要性以及网关的设计考虑。文章着重阐述了Zuul在微服务架构中的角色，以及它如何处理负载均衡、路由、...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值