服务网关实践

概述

微服务架构由很多个微小的服务（微服务）组成系统，每个微服务有自己的主机和端口号。如果直接让客户端与各个微服务通信，带来的问题有：

• 客户端需要维护多个请求地址（主机和端口号）
• 每个微服务都需要独立认证
• 某些场景存在跨域问题

在客户端和各个微服务之间添加微服务网关可以解决如上问题，客户端的请求都先经过微服务网关，客户端就只需要知道网关的请求地址即可，添加网关的优点有：

• 统一入口，只需要维护一个请求地址（主机和端口号）
• 易于监控
• 统一认证

本文介绍的微服务网关技术是Spring Cloud GateWay。该项目提供了一个用于在 Spring WebFlux 或 Spring WebMVC 之上构建 API 网关的库。 Spring Cloud Gateway 旨在提供一种简单而有效的方法来路由到 API 并为其提供横切关注点，例如：安全性、监控。

本文的操作是在服务熔断保护实践--Sentinal的基础上进行。

环境说明

jdk1.8

maven3.6.3

mysql8

spring cloud2021.0.8

spring boot2.7.12

idea2022

步骤

创建子模块

在父工程下，创建子模块：api_gateway_server

添加依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
</dependencies>

启动类

package org.example.gateway;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class GatewayServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayServerApplication.class, args);
    }
}

路由配置

配置文件application.yml

server:
  port: 8080
spring:
  application:
    name: api-gateway-server
  cloud:
    gateway:
      routes:
        - id: product-service
          uri: http://127.0.0.1:9001
          predicates:
            - Path=/product/**

配置的作用：通过网关访问路径符合/product/开头时，网关会将请求转发到uri（http://127.0.0.1:9001）的对应的路径下。例如：访问localhost:8080/product/1，网关会将请求转发到http://127.0.0.1:9001/product/1，其中127.0.0.1与localhost可以互相替换。

启动网关服务报错如下

Spring MVC found on classpath, which is incompatible with Spring Cloud Gateway.

Action:

Please set spring.main.web-application-type=reactive or remove spring-boot-starter-web dependency.

启动报错原因：

SpringCloud Gateway使用的web框架为webflux，和SpringMVC不兼容，所以gateway不需要引入web依赖，否则造成依赖冲突。

解决启动报错：

父工程不全局引入web依赖，需要的子工程单独引入web依赖，不需要则不引入（例如：gateway工程不需要则不引入）

父工程，删除web依赖

在需要的子工程(order-service、order-service-feign_hystrix、product-service)里添加Web依赖

		<dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

刷新依赖

测试

启动eureka服务、启动product服务（确认product服务的端口号为9001）

浏览器访问

直接访问微服务

http://localhost:9001/product/1

 通过网关访问

http://localhost:8080/product/1

可以看到通过网关访问和直接访问微服务效果一样。

路由规则

Spring Cloud Gateway 的功能很强大，前面只是使用了 Predicates（断言） 进行了简单的条件匹配，其实Spring Cloud Gataway 帮我们内置了很多 Predicates 功能。在 Spring Cloud Gateway 中 Spring 利用Predicate 的特性实现了各种路由匹配规则，如：通过 Header、请求参数等不同的条件来进行作为条件匹配到对应的路由。

路由匹配示例

spring:
  cloud:
    gateway:
      routes:
        - id: product-service
          uri: https://xxxx.com
          predicates:
            # 路由断言之前匹配
            - Before=xxx
            # 路由断言之后匹配
            - After=xxx
            # 路由断言之间匹配
            - Between=xxx,xxx
            # 路由断言Cookie匹配,此predicate匹配给定名称(chocolate)和正则表达式(ch.p)
            - Cookie=chocolate, ch.p
            # 路由断言Header匹配，header名称匹配X-Request-Id,且正则表达式匹配\d+
            - Header=X-Request-Id, \d+
            # 路由断言匹配Host匹配，匹配下面Host主机列表,**代表可变参数
            - Host=**.somehost.org, **.anotherhost.org
            # 路由断言Method匹配，匹配的是请求的HTTP方法
            - Methos=GET
            # 路由断言访问路径匹配，{segment}为可变参数
            - Path=/foo/{segment},/bar/{segment}
            # 路由断言请求参数匹配，将请求的参数param(baz)进行匹配
            - Query=baz
            # 路由断言请求参数匹配，可以进行regexp正则表达式匹配 (参数包含foo,并且foo的值匹配ba.)
            - Query=foo,ba.
            # 路由断言RemoteAddr匹配，将匹配192.168.1.1~192.168.1.254之间的ip地址，其中24为子网掩码位  数即255.255.255.0
            - RemoteAddr=192.168.1.1/24

动态路由（面向服务的路由）

之前我们配置路由uri是直接配置了微服务的主机和端口号：uri: http://127.0.0.1:9001。

如果微服务地址有变化，需要修改网关配置uri，耦合度高。

Spring Cloud GateWay支持动态路由：即自动的从注册中心中获取服务列表并访问。

在api_gateway_server服务（网关服务）引入eureka依赖

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
        dependency>

修改网关服务配置文件application.yml

• 路由uri的值改为 lb://service-product

       lb代表从注册中心获取服务，同时具备赋值均衡功能，//后面接的是服务名称

• 添加配置eureka的注册中心相关信息

server:
  port: 8080
spring:
  application:
    name: api-gateway-server
  cloud:
    gateway:
      routes:
        - id: product-service
          uri: lb://service-product
          predicates:
            - Path=/product/**
# 配置eureka
eureka:
  client:
    service-url:
      defaultZone: http://localhost:9000/eureka/
  instance:
    prefer-ip-address: true

配置的作用：通过网关访问，如果路径包含/product开头，会转发到uri（lb://service-product） 对应的微服务接口。例如：访问localhost:8080/product/1符合断言路径的条件，网关将请求会转发到service-product微服务，微服务名称映射的主机和端口号从eureka注册中心得到，转发对应的接口为localhost:9001/product/1

测试

重启gateway服务

查看eureka服务

访问正常

http://localhost:8080/product/1

过滤器重写请求路径

为了让更好识别访问路径将转发到哪个服务，在网关访问路径中带有具有识别作用的特定路径，例如：用带有product-service的路径表示请求将转发到product服务。

完整的访问路径如下

http://localhost:8080/product-service/product/1

响应错误页面

要访问成功，可以使用过滤器重写请求路径，

application.yml配置如下：

          predicates:
            #- Path=/product/**
            - Path=/product-service/**
          filters:
            - RewritePath=/product-service/(?<segment>),/$\{segment} #路径重写的过滤器，把/product-service/xxx的路径重写为/xxx

重启网关服务

再次访问

http://localhost:8080/product-service/product/1

成功访问到数据

过滤器

过滤器类型：局部过滤器（GatewayFilter）和全局过滤器（GlobalFilter）。

局部过滤器（GatewayFilter）：应用到单个路由或者一个分组的路由上

全局过滤器（GlobalFilter）：应用到所有路由上。

局部过滤器

部分局部过滤器如下

每个过滤器工厂都对应一个实现类，并且这些类的名称必须以GatewayFilterFactory 结尾，这是Spring Cloud Gateway的一个约定，例如 AddRequestHeader 对应的实现类为AddRequestHeaderGatewayFilterFactory。

全局过滤器

全局过滤器（GlobalFilter）作用于所有路由。通过全局过滤器可以实现对权限的统一校验，安全性验证等功能。

GloabalFilter接口源码如下：

过滤器应用

网关统一鉴权

编写一个全局过滤器

package org.example.gateway.filter;
 
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
/**
 * 自定义全局过滤器
 */
@Component
public class LoginFilter implements GlobalFilter, Ordered {
    /**
     * 过滤器逻辑
     */
    @Override
    public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println("执行了自定义的全局过滤器");
        return chain.filter(exchange);//放行，继续向下执行
    }
 
    /**
     * 指定过滤器执行顺序
     *  返回值越小，优先级越高
     */
    @Override
    public int getOrder() {
        return 0;
    }
}

重启网关服务

 访问

http://localhost:8080/product-service/product/1

看到数据如下

查看网关服务IDEA控制台的输出，看到执行了自定义的全局过滤器。

说明过滤器正常工作了。

鉴权逻辑：

• 当客户端第一次请求服务时，服务端对用户进行信息认证（登录）

• 认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证

• 以后每次请求，客户端都携带认证的token

• 服务端对token进行解密，判断是否有效

修改LoginFilter的filter方法

/**
 * 过滤器逻辑
 *  对请求参数中的access-token进行判断
 *  如果存在此参数：代表已经认证成功
 *  如果不存在此参数：代表认证失败
 * ServerWebExchange：相当于请求和响应的上下文（类似于zuul中的RequestContext）
 */
@Override
public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    System.out.println("执行了自定义的全局过滤器");
    //1.获取请求参数，例如：access-token
    String token = exchange.getRequest().getQueryParams().getFirst("access-token");
    //2.判断是否存在，不存在则认证失败，存在则放行
    if(token == null){
        System.out.println("没有登录");
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        return exchange.getResponse().setComplete();//请求结束
    }
    return chain.filter(exchange);//放行，继续向下执行
}

重启网关服务

测试

• 未携带access-token测试

  http://localhost:8080/product-service/product/1

IDEA控制台提示没有登录  

• 携带access-token测试

  http://localhost:8080/product-service/product/1?access-token=1

网关限流

可以在网关阶段对服务调用进行限流，达到保护服务的作用。

限流算法

常见的限流算法有：计数器限流算法、滑动窗口算法、漏桶算法、令牌桶算法。

每种算法原理、优缺点、使用场景也各不一样，具体可参考 常见限流算法

限流后的处理方式

• 拒绝服务

• 排队等待

• 服务降级

基于filter的限流

Spring Cloud Gateway官方就提供了基于令牌桶的限流支持。基于其内置的过滤器工厂RequestRateLimiterGatewayFilterFactory 实现。在过滤器工厂中是通过redis和lua脚本结合的方式进行流量控制。

安装好redis

启动redis服务端

启动redis客户端，使用monitor命令监控redis数据变化信息

127.0.0.1:6379> monitor

在api_gateway_server服务中引入redis相关依赖（基于reactive的redis依赖）

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redis-reactiveartifactId>
        dependency>

 修改application.yml，配置redis和网关过滤器

server:
  port: 8080 #端口
spring:
  application:
    name: api-gateway-server #服务名称
  redis:
    host: localhost
    port: 6379
    database: 0
  cloud: #配置SpringCloudGateway的路由
    gateway:
      routes:
        - id: product-service
          uri: lb://service-product
          predicates:
            - Path=/product-service/**
          filters:
            - name: RequestRateLimiter
              args:
                # 使用SpEL从bean容器中获取对象
                key-resolver: '#{@pathKeyResolver}'
                # 令牌桶每秒填充平均速率
                redis-rate-limiter.replenishRate: 1
                # 令牌桶的上限
                redis-rate-limiter.burstCapacity: 3
            - RewritePath=/product-service/(?<segment>.*), /$\{segment}
#eureka注册中心
eureka:
  client:
    service-url:
      defaultZone: http://localhost:9000/eureka/
  instance:
    prefer-ip-address: true #使用ip地址注册

虽然args相关配置存在报错如下，但是经验证，不影响运行。

在org.example.gateway包下，新建config包，并在config包下编写KeyResolverConfiguration配置

package org.example.gateway.config;
 
import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Mono;
 
@Configuration
public class KeyResolverConfiguration {
    /**
     * 基于请求路径的限流
     */
    @Bean
    public KeyResolver pathKeyResolver() {
        return exchange -> Mono.just(
                exchange.getRequest().getPath().toString()
        );
    }
}

启动eureka、product、gateway服务

浏览器访问

http://localhost:8080/product-service/product/1?access-token=1

连续多次访问，每秒超过3次访问后，响应如下：

查看redis客户端监控的输出如下：

以上实现了基于请求路径的限流，其他方式限流，参考代码如下：

package org.example.gateway.config;
 
import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Mono;
 
@Configuration
public class KeyResolverConfiguration {
    /**
     * 基于请求路径的限流
     *  方法名称与yml中key-resolver的值对应
     */
    @Bean
    public KeyResolver pathKeyResolver() {
        return exchange -> Mono.just(
                exchange.getRequest().getPath().toString()
        );
    }
    
    // 如果是其他的方式限流，代码如下，同时注意修改yml的key-resolver的值。 注意只能有一个@Bean生效，否则启动出错
 
    /**
     * 基于请求ip地址的限流
     */
//    @Bean
//    public KeyResolver ipKeyResolver() {
//        return exchange -> Mono.just(
//                exchange.getRequest().getHeaders().getFirst("X-Forwarded-For")
//        );
//    }
 
    /**
     * 基于用户的限流（参数）
     */
//    @Bean
//    public KeyResolver userKeyResolver() {
//        return exchange -> Mono.just(
//                exchange.getRequest().getQueryParams().getFirst("user")
//        );
//    }
}

测试其他的限流，例如：基于用户参数的限流

注释其他Bean代码，让如下Bean生效

	/**
     * 基于请求参数的限流
     *  请求 ?userId=
     * @return
     */
    @Bean
    public KeyResolver userKeyResolver(){
        return exchange -> Mono.just(
                exchange.getRequest().getQueryParams().getFirst("userId")
        );
    }

修改application.yml

                key-resolver: '#{@userKeyResolver}'

测试

http://localhost:8080/product-service/product/1?userId=1&access-token=1

访问达不到限流条件时

访问达到限流条件时

基于sentinel的限流

在api_gateway_server服务添加如下依赖

		
        <dependency>
            <groupId>com.alibaba.cspgroupId>
            <artifactId>sentinel-spring-cloud-gateway-adapterartifactId>
        dependency>

添加配置类

package org.example.gateway.config;
 
import com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayParamFlowItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
import javax.annotation.PostConstruct;
import java.nio.charset.StandardCharsets;
import java.util.*;
 
@Configuration
public class GatewayConfiguration {
 
	private final List viewResolvers;
 
	private final ServerCodecConfigurer serverCodecConfigurer;
 
	public GatewayConfiguration(ObjectProvider> viewResolversProvider,
	                            ServerCodecConfigurer serverCodecConfigurer) {
		this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
		this.serverCodecConfigurer = serverCodecConfigurer;
	}
 
	/**
	 * 配置限流的异常处理器:SentinelGatewayBlockExceptionHandler
	 */
	@Bean
	@Order(Ordered.HIGHEST_PRECEDENCE)
	public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
		return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
	}
 
	/**
	 * 配置限流过滤器
	 */
	@Bean
	@Order(Ordered.HIGHEST_PRECEDENCE)
	public GlobalFilter sentinelGatewayFilter() {
		return new SentinelGatewayFilter();
	}
 
	/**
	 * 配置初始化的限流参数
	 */
	@PostConstruct
	public void initGatewayRules() {
		Set rules = new HashSet<>();
//		rules.add(
//			new GatewayFlowRule("order-service") //资源名称
//					.setCount(1) // 限流阈值
//					.setIntervalSec(1) // 统计时间窗口，单位是秒，默认是 1 秒
//		);
//		rules.add(new GatewayFlowRule("order-service")
//				.setCount(1)
//				.setIntervalSec(1)
//				.setParamItem(new GatewayParamFlowItem()
//						.setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_URL_PARAM).setFieldName("id")
//				)
//		);
		//限流规则对访问路径匹配product-service开头的路径生效
		rules.add(new GatewayFlowRule("product-service")
				.setCount(1)
				.setIntervalSec(1)
		);
//		rules.add(new GatewayFlowRule("product_api")
//				.setCount(1)
//				.setIntervalSec(1)
//		);
//		rules.add(new GatewayFlowRule("order_api")
//				.setCount(1)
//				.setIntervalSec(1)
//		);
		GatewayRuleManager.loadRules(rules);
	}
 
//	@PostConstruct
//	public void initBlockHandlers() {
//		BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
//			public Mono handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
//				Map map = new HashMap<>();
//				map.put("code", 001);
//				map.put("message", "对不起,接口限流了");
//				return ServerResponse.status(HttpStatus.OK).
//						contentType(MediaType.APPLICATION_JSON_UTF8).
//						body(BodyInserters.fromObject(map));
//			}
//		};
//		GatewayCallbackManager.setBlockHandler(blockRequestHandler);
//	}
 
//	@PostConstruct
//	private void initCustomizedApis() {
//		Set definitions = new HashSet<>();
//		ApiDefinition api1 = new ApiDefinition("product_api")
//				.setPredicateItems(new HashSet() {{
//					add(new ApiPathPredicateItem().setPattern("/product-service/product/**").
//							setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
//				}});
//		ApiDefinition api2 = new ApiDefinition("order_api")
//				.setPredicateItems(new HashSet() {{
//					add(new ApiPathPredicateItem().setPattern("/order-service/order"));
//				}});
//		definitions.add(api1);
//		definitions.add(api2);
//		GatewayApiDefinitionManager.loadApiDefinitions(definitions);
//	}
}

以上配置，根据路由（访问路径）进行限流，限流规则对访问路径匹配product-service开头的路径生效。

修改application.yml

• 注释RequestRateLimiter filter相关配置

          filters:
#            - name: RequestRateLimiter
#              args:
#                # 以下上个配置项目报错，不能解析，但不影响使用
#                # 使用SpEL从容器中获取对象
#                #key-resolver: '#{@pathKeyResolver}'
#                key-resolver: '#{@userKeyResolver}'
#                # 令牌桶每秒填充平均速率
#                redis-rate-limiter.replenishRate: 1
#                # 令牌桶的上限
#                redis-rate-limiter.burstCapacity: 3
            - RewritePath=/product-service/(?.*), /$\{segment}

•  注释掉redis相关配置

#  redis:
#    host: localhost
#    port: 6379
#    database: 0

为了防止启动服务报redis连接拒绝，注释掉redis依赖，同时注意刷新依赖生效

测试

启动eureka、product、gateway服务

访问

http://localhost:8080/product-service/product/1?access-token=1

访问超过阈值后，响应

Blocked by Sentinel: ParamFlowException

因为路径中包含product-service开头，符合限流规则，所以当访问超出哦阈值后，执行限流操作，看到如上默认的响应信息。

为了更加友好的限流提示，可以自定义响应信息，如下：

取消initBlockHandlers方法的注释

	/**
	 * 自定义限流提示
	 */
	@PostConstruct
	public void initBlockHandlers() {
		BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
			public Mono handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
				Map map = new HashMap<>();
				map.put("code", 001);
				map.put("message", "对不起,接口限流了");
				return ServerResponse.status(HttpStatus.OK).
						contentType(MediaType.APPLICATION_JSON_UTF8).
						body(BodyInserters.fromObject(map));
			}
		};
		GatewayCallbackManager.setBlockHandler(blockRequestHandler);
	}

重启gateway服务

测试，访问超过限流阈值时，响应如下

以上是基于路由的限流规则，这个路由下的所有资源都受到这个限流规则限制，sentinel也支持自定义API限流规则，去掉initCustomizedApis()方法注释

/**
 * 自定义API限流规则
 *        1.定义分组,例如：product_api和order_api
 *        2.在initGatewayRules方法对小组配置限流规则
 */
@PostConstruct
private void initCustomizedApis() {
   Set definitions = new HashSet<>();
   ApiDefinition api1 = new ApiDefinition("product_api")
         .setPredicateItems(new HashSet() {{
            add(new ApiPathPredicateItem().setPattern("/product-service/product/**").
                  setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
         }});
   ApiDefinition api2 = new ApiDefinition("order_api")
         .setPredicateItems(new HashSet() {{
            add(new ApiPathPredicateItem().setPattern("/order-service/order"));
         }});
   definitions.add(api1);
   definitions.add(api2);
   GatewayApiDefinitionManager.loadApiDefinitions(definitions);
}

在initGatewayRules方法对小组配置限流规则

@PostConstruct
	public void initGatewayRules() {
		Set rules = new HashSet<>();
 
		rules.add(new GatewayFlowRule("product_api")
				.setCount(1)
				.setIntervalSec(1)
		);
//		rules.add(new GatewayFlowRule("order_api")
//				.setCount(1)
//				.setIntervalSec(1)
//		);
		GatewayRuleManager.loadRules(rules);
	}

重启gateway服务

测试

访问超过阈值后，同样能够起到限流效果

网关高可用

所有请求都需要先经过网关才到具体的微服务，网关只有一个节点会存在单点故障，解决办法是使用多个网关服务构成网关集群，实现网关高可用，当一个网关服务不可用，还有其他网关服务可用。实现架构如下图所示：

为了方便测试，取消网关限流配置，注释@Configuration注解

//@Configuration
public class GatewayConfiguration {

重启网关服务（8080端口）

复制配置得到另一个网关服务

修改api_gateway_server网关服务的配置文件 application.yml，将端口号改为8081，通过选中运行中的GatewayServerApplication，右键-->Copy Configuration复制配置得到另一个网关服务运行实例

运行复制得到的网关服务（8081端口）

访问8080和8081均能访问到服务

http://localhost:8080/product-service/product/1?access-token=1

http://localhost:8081/product-service/product/1?access-token=1

官网下载并解压nginx安装包

修改nginx配置，进入conf目录，修改nginx.conf文件

注释掉原来location /的配置，添加如下配置

http {
   upstream gateway{
        server 127.0.0.1:8080;
        server 127.0.0.1:8081;
    }
    server {
        ...
	    location / {
            	proxy_pass http://gateway;
        }
        ...
    }  
}

配置后，如图 

启动nginx

浏览器访问

http://localhost/product-service/product/1?access-token=1

如果需要改策略，可以修改nginx配置，配置案例如下

IP哈希（IP Hash）策略

upstream gateway {
        ip_hash;
        server 127.0.0.1:8080;
        server 127.0.0.1:8081;
    }

重启nginx，同一机器访问服务三次，均是8080网关提供服务

最少连接（Least Connections）策略

upstream gateway {
        least_conn;
        server 127.0.0.1:8080;
        server 127.0.0.1:8081;
    }

加权轮询（Weighted Round Robin）策略

upstream gateway {
        server 127.0.0.1:8080 weight=3;
        server 127.0.0.1:8081 weight=1;
    }

模拟故障，停掉一个网关服务

依然能访问，实现了网关的高可用。

完成！enjoy it!