1、什么是Higress?

云原生网关，干啥的？用通俗易懂的话来说，微服务架构下Higress 就像是一个智能的“交通警察”，它站在你的网络世界里，负责指挥和调度所有进出的“车辆”（也就是数据流量）。它的主要工作包括：
        指挥交通：它告诉数据应该走哪条路，去哪个服务（就像告诉你去某个地方应该走哪条路）。
        保障安全：它检查进出的数据，防止坏人（比如黑客）进来搞破坏，保护你的网络世界安全。
        维护秩序：如果有太多数据同时涌进来（比如网站访问量突然暴增），它会采取措施，比如限制流量，确保系统不会因为太忙而崩溃。
        记录情况：它会记录所有车辆的行驶情况，如果出了问题，可以帮忙查找原因。
        适应各种路况：无论是云上的道路，还是自己家修的路（混合云环境），它都能管理得井井有条。
简而言之，Higress 就是帮助你的网络世界更加顺畅、安全、有序的一个工具。

2、Higress的安装

1、安装DockerCompose

序号	软件	版本
1	Centos	7.5
2	Linux内核	3.8之上

 卸载之前的docker

yum remove docker \
          docker-client \
          docker-client-latest \
          docker-common \
          docker-latest \
          docker-latest-logrotate \
          docker-logrotate \
          docker-selinux \
          docker-engine-selinux \
          docker-engine \
          docker-ce

防火墙关掉

systemctl stop firewalld

设置安装仓库

#安装yum的工具包
yum install -y yum-utils \
      device-mapper-persistent-data \
      lvm2 --skip-broken

# 设置docker镜像源
yum-config-manager \
  --add-repo \
   https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
  
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

#将软件包信息提前在本地索引缓存，用来提高搜索安装软件的速度,建议执行这个命令可以提升yum安装的速度。
yum makecache fast

 安装docker引擎

sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

启动docker

systemctl start docker

设置docker自启动（我不喜欢）

systemctl enable docker

检查是不是启动成功

docker version

2、搭建Higress

#创建Higress工作目录
mkdir higress;  

#进入Hogress文件夹
cd higress

#创建higress-ai容器
docker run -d --name higress-ai -v ${PWD}:/data \
     -p 8001:8001 -p 80:8080 -p 8443:8443  \
     higress-registry.cn-hangzhou.cr.aliyuncs.com/higress/all-in-one:latest

监听端口说明如下：

• 80 端口：Higress UI 控制台入口
• 8080 端口：网关 HTTP 协议入口
• 8443 端口：网关 HTTPS 协议入口

访问Higress控制台

http://192.168.66.100:8001/

自己设置密码即可，进去后创建服务来源为nacos

之后项目启动的时候需要先打开docker服务，然后再开启Higress的容器。 

 3、Higress配置Nacos注册中心

为啥要配置Nacos呢？因为微服务都在nacos上注册着。

nacos的下载安装见博客：

SpringCloudAlibaba技术栈-Nacos-CSDN博客

安装完成之后访问浏览器输入网址192.168.66.100:8848/nacos即可。

3、项目案例

1、创建网关微服务模块

创建完父项目添加依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.zj</groupId>
  <artifactId>testHigress</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <name>testHigress</name>
  <url>http://maven.apache.org</url>

  <modules>
    <module>order-service</module>
    <module>auth</module>
  </modules>

  <properties>
    <dubbo.version>3.2.4</dubbo.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>17</java.version>
    <spring-boot.version>3.0.2</spring-boot.version>
    <spring-cloud.version>2022.0.0</spring-cloud.version>
    <spring-cloud-alibaba.version>2022.0.0.0</spring-cloud-alibaba.version>
    <lombok.version>1.8.28</lombok.version>
  </properties>


  <dependencyManagement>

  <dependencies>


    <!-- SpringCloud 微服务 -->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <version>${spring-cloud.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>


    <!-- SpringCloud Alibaba 微服务 -->
    <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-alibaba-dependencies</artifactId>
      <version>${spring-cloud-alibaba.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>


    <!-- SpringBoot 依赖配置 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>${spring-boot.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>


  </dependencies>

  </dependencyManagement>
</project>

创建子项目order-service并添加依赖。

        <!--   springboot依赖包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--   nacos依赖包  -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

在resources文件夹下面创建application.yml文件。

spring:
  application:
  # 应用名字
   name: order-service
  cloud:
   nacos:
    discovery:
    # Nacos注册中心的地址
     server-addr:  192.168.66.100:8848

server:
  port: 8889

主要是为了将order-service服务注册到Nacos上。

 编写主启动类。

@SpringBootApplication
@EnableDiscoveryClient
public class OderServiceApplication
{
    public static void main( String[] args )
    {
        SpringApplication.run(OderServiceApplication.class, args);
    }
}

编写测试控制器。

package com.zj.controller;

/*控制器*/
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/order")
public class indexController {

    @GetMapping("/index")
    public String index(){
        return "hello higress";
    }
}

启动项目，检查nacos客户端是不是存在该服务。

浏览器访问控制器，检查是不是创建成功。localhost:8888/order/index  出现hi gress表示成功。

2、Higress路由配置

它的作用是根据一定的规则，将访问者的请求正确地发送到对应的服务或者后端服务器上。

安装Switchhosts

Switchhosts：切换hosts与编辑hosts，实现域名和地址的映射。

会出现写数据没权限的情况看这篇文章：

switchHosts应用时，没有写入 Hosts 文件的权限_没有写入 hosts 文件的权限。-CSDN博客

在Higress中创建数据来源：

 在域名管理中创建域名：

配置访问order-service服务的路由：

 如果不存在一级路由的话还需要重写路由（这里存在一级路由）：

 这样访问的时候由原来的localhost:8888/order/index  变为  www.zj.com/order/index  为啥呢?因为微服务在nacos上，higress会根据/order/index找到匹配的服务。 

浏览器访问地址:

 3、Higress策略配置-跨域配置

什么是跨域

当一个请求url的协议、域名、端口三者之间任意一个与当前页面url不同即为跨域

当前页面url	被请求页面url	是否跨域	原因
http://www.test.com/	http://www.test.com/index.html	否	同源（协议、域名、端口号相同）
http://www.test.com/	https://www.test.com/index.html	跨域	协议不同（http/https）
http://www.test.com/	百度一下，你就知道	跨域	主域名不同（test/baidu）
http://www.test.com/	http://blog.test.com/	跨域	子域名不同（www/blog）
http://www.test.com:8080/	http://www.test.com:7001/	跨域	端口号不同（8080/7001）

 常见的报错就是：Access-Control-Allow-Origin。 

Higress配置跨域访问order-service服务：

 4、HTTP认证

Higress HTTP认证是一种保护网页或服务的机制，需要用户输入用户名和密码才能访问。这就像给你的网站或服务加了一把锁，只有知道密码的人才能进入。

常见的验证方案包括

1、Basic Authentication（基本认证）

Basic认证是最常见的HTTP认证方式之一。在Basic认证中，客户端发送请求时，会在请求头中包含一个"Authorization"字段，该字段包含了经过Base64编码的用户名和密码。

2、Digest Authentication（摘要认证）

Digest认证是一种更安全的认证方式。在Digest认证中，服务器会向客户端发送一个随机数（称为"nonce"），客户端根据该随机数和用户密码计算一个摘要，并将其发送给服务器。服务器收到摘要后，会验证其有效性。Digest认证相对于Basic认证而言，更难以被中间人攻击截获密码。

3、Bearer Token Authentication（令牌认证）

Bearer认证是一种使用令牌（Token）进行身份验证的方式。在Bearer认证中，客户端在请求头中添加一个"Authorization"字段，该字段包含了一个令牌信息。服务器在接收到请求后，会验证令牌的有效性，并根据令牌来识别用户身份。

4、OAuth（开放授权）

OAuth认证是一种开放标准的身份验证协议，用于授权第三方应用程序访问用户资源。在OAuth认证中，用户可以通过授权服务器授权第三方应用程序访问自己的资源。这种方式可以避免用户将密码直接提供给第三方应用程序。

（1）Basic 认证

暂略。

（2）JWT认证

啥叫JWT认证？JWT认证是一种通过令牌（token）来验证用户身份的方法。用户登录后，服务器会发一个像密码一样的令牌给用户，用户每次访问网站时都带上这个令牌，服务器检查令牌来确定用户是谁。这种方法不需要服务器记住用户的登录状态，令牌里有用户信息，还能保证安全。

传统的session认证的缺点：

• 安全性：CSRF攻击因为基于cookie来进行用户识别, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。
• 扩展性：对于分布式应用，需要实现 session 数据共享
• 性能：每一个用户经过后端应用认证之后，后端应用都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大，与REST风格不匹配。因为它在一个无状态协议里注入了状态。

JWT的认证方式：

业务流程：

1. 客户端向API网关发起认证请求，请求中一般会携带终端用户的用户名和密码；
2. 网关将请求直接转发给后端服务也就是auth服务模块；
3. 后端服务读取请求中的验证信息（比如用户名、密码）进行验证，验证通过后使用私钥生成标准的token，返回给网关；
4. 网关将携带token的应答返回给客户端，客户端需要将这个token缓存到本地；
5. 客户端向API网关发送业务请求，请求中携带token；
6. 网关使用用户设定的公钥对请求中的token进行验证，验证通过后，将请求透传给后端服务；
7. 后端服务进行业务处理后应答；
8. 网关将业务应答返回给客户端

JWT 结构

头部 / header

JSON对象，描述 JWT 的元数据。其中 alg 属性表示签名的算法（algorithm），默认是 HMAC SHA256（写成 HS256）；typ 属性表示这个令牌（token）的类型（type），统一写为 JWT。

    {
       "alg": "HS256",
       "typ": "JWT"
    }
alg属性表示签名的算法（algorithm），默认是 HMAC SHA256（写成 HS256）；typ属性表示这个令牌（token）的类型（type），JWT 令牌统一写为JWT然后将头部进行Base64编码构成了第一部分，Base64是一种用64个字符来表示任意二进制数据的方法，Base64是一种任意二进制到文本字符串的编码方法，常用于在URL、Cookie、网页中传输少量二进制数据。

载荷 / Payload

Payload 部分也是一个 JSON 对象，用来存放实际需要传递的数据。JWT 指定七个默认字段供选择。除了默认字段之外，你完全可以添加自己想要的任何字段，一般用户登录成功后，就将用户信息存放在这里

iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT

{
 "iss": "xxxxxxx",
 "sub": "xxxxxxx",
 "aud": "xxxxxxx",
 "user": {
     'username': 'itbaizhan',
     'userId': 1
  } 
}

签名 / Signature

• 签名部分是对上面的 头部、载荷 两部分数据进行的数据签名
• 为了保证数据不被篡改，则需要指定一个密钥，而这个密钥一般只有你知道，并且存放在服务端

（3）Higress策略配置-创建认证中心微服务

添加依赖

    <dependencies>
        <!--springboot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--注册中心，当前的认证服务也需要将自己注册到注册中心才能被其他服务调用-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--JWT认证包-->
        <dependency>
            <groupId>org.bitbucket.b_c</groupId>
            <artifactId>jose4j</artifactId>
            <version>0.7.0</version>
        </dependency>
        <!--工具包-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.18</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

在resources文件夹下面创建application.yml文件。

#微服务名称
spring:
  application:
    name: auth-service
#    注册中心地址
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.66.100:8848
#端口
server:
  port: 8889


#还能添加数据库的配置信息，从数据库获取用户的信息认证用户的身份

 创建主启动类

@SpringBootApplication
@EnableDiscoveryClient
public class authApplication
{
    public static void main( String[] args )
    {
        SpringApplication.run(authApplication.class, args);
    }
}

（4）编写JWT工具类生成JWT

在此之前一定要把Linux的时间设置成北京时间。

生成公钥和私钥，用户也可以在这个站点https://mkjwk.org 生成用于token生成与验证的私钥与公钥。

public static void main(String[] args) {
    RsaJsonWebKey rsaJsonWebKey = RsaJwkGenerator.generateJwk(2048);
    final String publicKeyString = rsaJsonWebKey.toJson(JsonWebKey.OutputControlLevel.PUBLIC_ONLY);
    final String privateKeyString = rsaJsonWebKey.toJson(JsonWebKey.OutputControlLevel.INCLUDE_PRIVATE);
    System.out.println(publicKeyString);
    System.out.println(privateKeyString);
}

 JWT工具类

package com.zj.utils;

import org.jose4j.json.JsonUtil;
import org.jose4j.jwa.AlgorithmConstraints;
import org.jose4j.jwk.JsonWebKey;
import org.jose4j.jwk.RsaJsonWebKey;
import org.jose4j.jws.AlgorithmIdentifiers;
import org.jose4j.jws.JsonWebSignature;
import org.jose4j.jwt.JwtClaims;
import org.jose4j.jwt.consumer.InvalidJwtException;
import org.jose4j.jwt.consumer.JwtConsumer;
import org.jose4j.jwt.consumer.JwtConsumerBuilder;
import org.jose4j.lang.JoseException;

import java.security.PrivateKey;
import java.security.PublicKey;

// Jwt工具类，包含生成和验证JWT令牌的方法
public class JwtUtils {

    // 私钥字符串，用于签名JWT令牌，这里存储的是RSA私钥的JSON表示
    public final static String privatejson = "{\"kty\":\"RSA\",\"n\":\"...\",\"e\":\"...\",\"d\":\"...\",\"p\":\"...\",\"q\":\"...\",\"dp\":\"...\",\"dq\":\"...\",\"qi\":\"...\"}";
    // 公钥字符串，用于验证JWT令牌，这里存储的是RSA公钥的JSON表示
    public final static String publicjson = "{\"kty\":\"RSA\",\"n\":\"...\",\"e\":\"...\"}";

    /**
     * 生成JWT令牌
     * @param userId 用户ID，将作为JWT负载的一部分
     * @param username 用户名，将作为JWT负载的一部分
     * @return 返回生成的JWT令牌字符串
     */
    public static String sign(Long userId, String username) throws JoseException {
        // 创建JWT的声明部分，JwtClaims对象包含JWT的有效负载
        JwtClaims claims = new JwtClaims();
        claims.setIssuer("abcd"); // 设置JWT的发行者，通常是创建JWT的应用的名称
        claims.setAudience("audience"); // 设置JWT的接收者，通常是接收JWT的应用的名称
        claims.setExpirationTimeMinutesInTheFuture(10000); // 设置JWT的过期时间，这里设置为10000分钟后过期
        claims.setGeneratedJwtId(); // 自动生成JWT的唯一标识符
        claims.setIssuedAtToNow(); // 设置JWT的发行时间，即当前时间
        claims.setNotBeforeMinutesInThePast(2); // 设置JWT生效时间，即2分钟前
        claims.setSubject("subject"); // 设置JWT的主题，通常是关于JWT的描述信息
        claims.setClaim("userId", userId); // 添加自定义声明，这里是用户ID
        claims.setClaim("username", username); // 添加自定义声明，这里是用户名

        // 创建JWT签名对象，用于生成签名后的JWT令牌
        JsonWebSignature jws = new JsonWebSignature();
        jws.setPayload(claims.toJson()); // 设置JWT的有效负载，即上面的claims对象转换成JSON字符串

        // 使用私钥签名JWT，私钥用于加密签名，确保JWT的完整性和真实性
        PrivateKey privateKey = new RsaJsonWebKey(JsonUtil.parseJson(privatejson)).getPrivateKey();
        jws.setKey(privateKey);

        // 设置密钥ID，可以用于区分不同的密钥对
        jws.setKeyIdHeaderValue("keyId");

        // 设置签名算法，这里使用RSA SHA-256算法
        jws.setAlgorithmHeaderValue(AlgorithmIdentifiers.RSA_USING_SHA256);

        // 生成JWT令牌，即对有效负载进行签名并返回签名后的字符串
        String jwt = jws.getCompactSerialization();

        return jwt;
    }

    /**
     * 验证JWT令牌
     * @param token 要验证的JWT令牌字符串
     */
    public static void checkJwt(String token) throws JoseException {
        // 使用公钥验证JWT，公钥用于解密签名，验证JWT的完整性和真实性
        PublicKey publicKey = new RsaJsonWebKey(JsonUtil.parseJson(publicjson)).getPublicKey();

        // 创建JWT消费者，用于验证和解码JWT令牌
        JwtConsumer jwtConsumer = new JwtConsumerBuilder()
                .setRequireExpirationTime() // 要求JWT包含过期时间字段
                .setAllowedClockSkewInSeconds(30) // 允许时间偏移量，即服务器时间与JWT生成时间之间的差异
                .setRequireSubject() // 要求JWT包含主题字段
                .setExpectedIssuer("abcd") // 预期的发行者，必须与JWT中的发行者匹配
                .setExpectedAudience("audience") // 预期的接收者，必须与JWT中的接收者匹配
                .setVerificationKey(publicKey) // 设置用于验证签名的公钥
                .setJwsAlgorithmConstraints(new AlgorithmConstraints(AlgorithmConstraints.ConstraintType.WHITELIST, AlgorithmIdentifiers.RSA_USING_SHA256))// 设置只允许使用RSA SHA-256算法的JWT
                .build();


                try {
                    // 解析和验证JWT令牌
                    JwtClaims jwtClaims = jwtConsumer.processToClaims(token);
                    System.out.println("JWT验证成功！");
                    // 输出JWT中的声明信息
                    System.out.println("JWT内容: " + jwtClaims);
                } catch (InvalidJwtException e) {
                    // 如果JWT验证失败，打印错误信息
                    System.out.println("JWT验证失败: " + e);
                }
            }

            // 主函数，用于测试JWT的生成和验证
            public static void main(String[] args) throws JoseException {
                // 生成JWT令牌
                String token = sign(123L, "testUser");
                System.out.println("生成的JWT令牌: " + token);

                // 验证JWT令牌
                checkJwt(token);
            }
        }

(5)编写认证中心控制器和服务层

package com.zj.controller;

import com.zj.domain.LoginBodyDTO;
import com.zj.domain.R;
import com.zj.service.LoginService;
import org.jose4j.lang.JoseException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用户层
 */
@RestController
@RequestMapping("/auth")
public class LoginController {

    @Autowired
    private LoginService loginService;

    /**
     * @RequestBody:将数据转换为java对象
     * @param loginBodyDTO
     * @return
     */
    @PostMapping("/login")
    public R login(@RequestBody LoginBodyDTO loginBodyDTO) throws JoseException {
        System.out.println("啊哈哈哈哈");
        R login = loginService.login(loginBodyDTO);
        return login;
    }
}

编写统一结果返回集

package com.zj.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

/**
 * 统一结果返回集
 */
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class R {
    private Integer code;
    private String msg;
    public Object data;

    public static R fail( String msg) {
        R r = new R();
        r.setCode(500);
        r.setMsg(msg);
        return r;
    }

    public static R success( Object data) {
        R r = new R();
        r.setCode(200);
        r.setMsg("success");
        r.setData(data);
        return r;
    }
}

登录业务层

package com.zj.service;

import com.zj.domain.LoginBodyDTO;
import com.zj.domain.R;
import com.zj.utils.JwtUtils;
import org.jose4j.lang.JoseException;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Service
public class LoginService {

    //登录
    public R login(LoginBodyDTO loginBodyDTO) throws JoseException {
        //1.用户名密码数据库校验
        if(StringUtils.isEmpty(loginBodyDTO.getUsername()) || StringUtils.isEmpty(loginBodyDTO.getPassword())){
            return R.fail("用户名或者密码为空");

        }
        //TODO 数据操作验证用户信息
        if(loginBodyDTO.getUsername().equals("admin") && loginBodyDTO.getPassword().equals("123456")){
            //颁发登录token
            String token = JwtUtils.sign(1001L,"admin");
            return R.success(token);

        }else{
            return R.fail("登录信息错误");
        }
    }

}

创建Higess路由

 

启动项目验证授权服务是不是成功了

这就成功了。

(6)Higress策略配置-JWT配置

这个配置主要是针对微服务的这里主要是order-service，不是针对验证模块的，验证模块不需要添加，总不能让用户第一次登录就带着token吧。

因为在JWT认证流程中需要网关对用户的请求进行验证，也就是需要对用户的请求进行解密，解密成功才能访问微服务，否则直接不让访问。

因为访问每个微服务都需要进行身份的验证，因此需要全局配置JWT，在插件市场配置就是全局配置。

参数配置见文档：https://higress.cn/docs/latest/plugins/authentication/jwt-auth/?spm=36971b57.2ef5001f.0.0.2a932c1fXPZUk1

name	string	必填	-	配置该consumer的名称，每个consumer相当于是一个策略。
jwks	string	必填	-	https://www.rfc-editor.org/rfc/rfc7517 指定的json格式字符串，是由验证JWT中签名的公钥（或对称密钥）组成的Json Web Key Set，其实就是公钥。
issuer	string	必填	-	JWT的签发者，需要和payload中的iss字段保持一致

 开启order-service微服务权限认证。

idea上开启auth服务和order-serice服务测试：

先直接访问order-service模块显然没验证成功：

 再登录一下获取token

再次请求order-service这次带上token

 要注意Authorization的参数: Bearer+token

这样最基础的认证就OK 啦！

（7） Higress策略配置-Key 认证

global_auth	bool	选填（仅实例级别配置）	-	只能在实例级别配置，若配置为true，则全局生效认证机制; 若配置为false，则只对做了配置的域名和路由生效认证机制，若不配置则仅当没有域名和路由配置时全局生效（兼容老用户使用习惯）。
consumers	array of object	必填	-	配置服务的调用者，用于对请求进行认证
keys	array of string	必填	-	API Key 的来源字段名称，可以是 URL 参数或者 HTTP 请求头名称
in_query	bool	in_query 和 in_header 至少有一个为 true	true	配置 true 时，网关会尝试从 URL 参数中解析 API Key
in_header	bool	in_query 和 in_header 至少有一个为 true	true	配置 true 时，网关会尝试从 HTTP 请求头中解析 API Key

在key认证的全局配置添加下面的配置：

credential: 2bda943c-ba2b-11ec-ba07-00163e1250b5  通过UUID生成的。keys就是在请求的时候要携带的参数，in_header就是放在请求的header中，in_query就是携带到请求的参数上。

在order-sevice服务上使用配置的key认证：

 在不携带apikey参数的时候请求登录是不行的。

带上参数就能访问了。

带上参数访问order-service。

 对于in_header式key认证是一样的。