前言：

  1. 在微服务架构中，有一个组件可以说是必不可少的，那就是微服务网关，微服务网关处理了负载均衡，缓存，路由，访问控制，服务代理，监控，日志等。API网关在微服务架构中正是以微服务网关的身份存在。
  2. 一般在微服务架构中，网关都是部署多个服务的，以实现负载均衡和保证高可用。

一、使用 Nginx+Zuul 实现网关集群

1.互联网公司中网关都是集群 搭建集群: Nginx+Zuul 一主一备，或者轮询多个。 2.在微服务中，所有服务请求都会统一请求到Zuul网关上。

图示：
SpringCloud实现Zuul集群(负载均衡) - 图1
过程：客户端发送请求统一到Nginx上，在使用Nginx实现反向代理和负载均衡，采用轮询算法转发到网关上。
（Http请求的端口就是80端口）

1.创建Eurek注册中心、会员服务、订单服务 (略)

搭建Zull集群前，应该对Eureka注册中心，以及创建SpringBoot项目应该有了解，这里就不一 一赘述了。
实际上创建会员服务、订单服务这一步可以省略，因为我们仅仅是为了演示Nginx对Zuul网关的负载均衡效果。

会员服务配置:

  1. #会员服务
  2. server:
  3.   port: 8082
  4. spring:
  5.   application:
  6.     name: member-service    #服务名
  8. #Eureka配置
  9. eureka:
  10.   client:
  11.     service-url:
  12.       defaultZone: http://127.0.0.1:8761/eureka/     #注册中心的地址

订单服务:

  1. #订单服务
  2. server:
  3.   port: 8081
  4. spring:
  5.   application:
  6.     name: order-service   #服务名
  8. #Eureka配置
  9. eureka:
  10.   client:
  11.     service-url:
  12.       defaultZone: http://127.0.0.1:8761/eureka/      #注册中心地址

2. 创建Zuul服务

application.yml文件中配置 （Zull的配置生产时一般是放到配置中心中）

  1. #配置Zuul端口
  2. server:
  3.   port: 81
  4. spring:
  5.   application:
  6.     name: zull-gateway-service    #服务名
  7. #Eureka配置
  8. eureka:
  9.   client:
  10.     service-url:
  11.       defaultZone: http://127.0.0.1:8761/eureka/    #注册中心地址
  13. # 配置网关反向代理，例如访问/api-member/** 直接重定向到member-service服务,实现路由转发，隐藏服务的真实ip(服务都实在内网中)
  14. #zull根据服务名，去Eureka获取服务真实地址，并通过本地转发，而且默认开启Ribbon实现负载均衡
  15. #默认读取Eureka注册列表 默认30秒间隔  
  16. zuul:
  17.  routes:
  18.    api-a: #会员服务网关配置
  19.      path: /api-member/**   #访问只要是/api-member/ 开头的直接转发到member-service服务
  20.      #服务名
  21.      serviceId: member-service
  22.    api-b: #订单服务网关配置
  23.      path: /api-order/**
  24.      serviceId: order-service

创建TokenFilet类继承ZuulFilter，在run方法中输入网关的端口，调用服务时方便查看Nginx转发到哪个网关

  1. package com.example.zuul.filter;
  3. import com.netflix.zuul.ZuulFilter;
  4. import com.netflix.zuul.context.RequestContext;
  5. import com.netflix.zuul.exception.ZuulException;
  6. import io.micrometer.core.instrument.util.StringUtils;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.stereotype.Component;
  10. import javax.servlet.http.HttpServletRequest;
  12. @Component
  13. public class TokenFilter extends ZuulFilter {
  14.     //统计当前Zuul调用次数
  15.     int count = 0;
  17.     //获取Zuul服务端口号
  18.     @Value("${server.port}")
  19.     private String prot;
  21.     /**
  22.      * 指定该Filter的类型
  23.      * ERROR_TYPE = "error";
  24.      * POST_TYPE = "post";
  25.      * PRE_TYPE = "pre";
  26.      * ROUTE_TYPE = "route";
  27.      */
  28.     @Override
  29.     public String filterType() {
  30.         System.out.println("filterType()...");
  31.         return "pre";
  32.     }
  35.     /**
  36.      * 指定该Filter执行的顺序（Filter从小到大执行）
  37.      * DEBUG_FILTER_ORDER = 1;
  38.      * FORM_BODY_WRAPPER_FILTER_ORDER = -1;
  39.      * PRE_DECORATION_FILTER_ORDER = 5;
  40.      * RIBBON_ROUTING_FILTER_ORDER = 10;
  41.      * SEND_ERROR_FILTER_ORDER = 0;
  42.      * SEND_FORWARD_FILTER_ORDER = 500;
  43.      * SEND_RESPONSE_FILTER_ORDER = 1000;
  44.      * SIMPLE_HOST_ROUTING_FILTER_ORDER = 100;
  45.      * SERVLET_30_WRAPPER_FILTER_ORDER = -2;
  46.      * SERVLET_DETECTION_FILTER_ORDER = -3;
  47.      */
  48.     @Override
  49.     public int filterOrder() {
  50.         System.out.println("filterOrder()...");
  51.         return 0;
  52.     }
  54.     /**
  55.      * 指定需要执行该Filter的规则
  56.      * 返回true则执行run()
  57.      * 返回false则不执行run()
  58.      */
  59.     @Override
  60.     public boolean shouldFilter() {
  61.         System.out.println("shouldFilter()...");
  62.         return true;
  63.     }
  65.     /**
  66.      * 该Filter具体的执行活动
  67.      */
  68.     @Override
  69.     public Object run() throws ZuulException {
  70.         // 获取上下文
  71.         //RequestContext currentContext = RequestContext.getCurrentContext();
  72.         //HttpServletRequest request = currentContext.getRequest();
  73.         //获取userToken
  74.        // String userToken = request.getParameter("userToken");
  75.         //System.out.println("userToken: "+userToken);
  76.         //if (StringUtils.isEmpty(userToken)) {
  77.             //不会继续执行调用服务接口，网关直接响应给客户端
  78.             //currentContext.setSendZuulResponse(false);
  79.             //currentContext.setResponseStatusCode(401);
  80.            // currentContext.setResponseBody("userToken is Null");
  81.            // return null;
  82.        // }else if(!userToken.equals("10010")){
  83.            // currentContext.setSendZuulResponse(false);
  84.             //currentContext.setResponseStatusCode(401);
  85.             //currentContext.setResponseBody("userToken is Error");
  86.             //return null;
  87.         //}
  88.         // 否则正常执行业务逻辑，调用服务.....
  89.         System.out.println("访问Zuul网关端口为："+prot +"（total："+ ( count++) +"）");
  90.         return null;
  92.     }
  93. }

启动两个Zuul服务，端口号分别为81和82

3. 下载Nginx服务器

这里演示使用Windows版本，Linux安装也很简单，后面操作都一样。
windows版下载地址：http://nginx.org/en/download.html
SpringCloud实现Zuul集群(负载均衡) - 图2
下载好后解压，进入conf目录找到nginx.conf文件打开，配置如下：

  1. #配置上游服务器 集群，默认轮询机制
  2.     upstream backServer{
  3.         server 127.0.0.1:81;
  4.         server 127.0.0.1:82;
  5.         # 补充: backup表示从服务器或者叫备用服务器  只有当主服务器（81、82端口）都不能访问时才会访问此（83端口）备用服务器 当主服务器恢复正常后 则访问主服务器
  6.         #server 127.0.0.1:83 backup;
  7.     }
  8.     server {
  9.         listen       80;
  10.         server_name  localhost;
  12.         #charset koi8-r;
  14.         #access_log  logs/host.access.log  main;
  16.         location / {
  17.             ##root   html;
  18.             #指定上游负载均衡服务器
  19.             proxy_pass http://backServer/;
  20.             index  index.html index.htm;
  21.         }
  22.     }

双击nginx.exe启动Nginx服务器

二、 测试

浏览器访问http://localhost/api-member
我们可以看到两个网关分别输出了日志，实现了负载均衡

SpringCloud实现Zuul集群(负载均衡) - 图3SpringCloud实现Zuul集群(负载均衡) - 图4
我们看到访问的次数不一样，这其实和使用Google浏览器有关，可以换其他浏览器试试。

三、补充

Nginx和网关的区别在什么地方？

  1. 都可以实现反向代理。
  2. 都可以实现负载均衡，Nginx是服务端负载均衡，Zuul是本地负载均衡。

Nginx也可以实现网关，为什么不用Nginx实现网关呢？
因为微服务网关是针对整个微服务实现统一的请求拦截，网关基本上都是采用自己熟悉的语言开发的，目的方便易学。

网关的作用:

  1. 网关对所有服务会话进行拦截
  2. 网关安全控制、统一异常处理、xxs、sql注入
  3. 权限控制、黑名单和白名单、性能监控、日志打印等

关于Nginx负债均衡故障转移：

  1. 设置备用服务器(主从架构)，只有当所有主服务器不可用时才会负载到备服务器，当主服务器恢复正常时则负载到主服务器。
  1. upstream backServer{
  2.         server 127.0.0.1:81;
  3.         server 127.0.0.1:82;
  4.         # 补充: backup表示从服务器或者叫备用服务器  只有当主服务器（81、82端口）都不能访问时才会访问此（83端口）备用服务器 当主服务器恢复正常后 则访问主服务器
  5.         server 127.0.0.1:83 backup;
  6.     }
  1. 设置Nginx转发请求超时时间
  1. upstream backServer{
  2.         server 127.0.0.1:81;
  3.         server 127.0.0.1:82;
  4.         server 127.0.0.1:83 backup;
  5.     }
  7. location / {
  8.         proxy_pass   http://backServer/;
  9.         proxy_redirect  default;
  10.         proxy_connect_timeout 1;  # 超时1s则转发到其他服务，宕机情况下也适用
  11.         proxy_read_timeout 1;
  12.         proxy_send_timeout 1;

相关文章推荐：

LVS+Keepalived+Nginx实现主从双机热备（7*24小时运行）

Nginx实战解决高并发（静态资源缓存）

Nginx+Tomcat实现动静分离