当前位置：首页 > news >正文

SpringCloudAlibaba技术栈-Higress

news 2025/7/12 11:57:41

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.reposed -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-servicecloud:nacos:discovery:# Nacos注册中心的地址server-addr:  192.168.66.100:8848server: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的认证方式：

业务流程：

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

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); // 添加自定义声明，这里是用户IDclaims.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 {@Autowiredprivate 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")){//颁发登录tokenString 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认证是一样的。