RuoYi-Cloud微服务项目部署到k8s集群

RuoYi-Cloud微服务项目部署到k8s集群

官方项目:https://ruoyi.vip/

前端项目地址:http://192.168.0.222/kubernetes/ruoyi-vue2.git

后端项目:http://192.168.0.222/kubernetes/ruoyi-cloud-springboot2.git

我已经将官方的前端项目代码和后端项目代码同步到了自己的gitlab仓库

部署ruoyi-cloud微服务的项目需要提前准备好的基础服务:Nacos、MySQL、Redis

MySQL和Redis用环境中已经部署好的,这里就不写部署的操作了;

Nacos服务也已经部署好了,部署在k8s集群中,参考文章《k8s集群中部署生产级Nacos服务》

本笔记只演示部署三个后端微服务和一个前端服务,用户能正常登录到系统即可。

集群内程序MySQL,Redis,Nacos用Service地址,信息如下:

1
2
3
4
5
6
7
8
9
10
[root@k8s-master01 ~]# kubectl get svc -n ruoyi
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
external-mysql-svc ClusterIP 10.96.105.207 <none> 3306/TCP 9d
external-redis-svc ClusterIP 10.96.28.65 <none> 6379/TCP 8d
nacos-cs ClusterIP 10.96.115.191 <none> 8848/TCP,9848/TCP,9849/TCP,7848/TCP 9d
nacos-hs ClusterIP None <none> 8848/TCP,9848/TCP,9849/TCP,7848/TCP 9d
ruoyi-auth ClusterIP 10.96.52.116 <none> 9200/TCP 7d23h
ruoyi-gateway ClusterIP 10.96.2.167 <none> 8080/TCP 7d9h
ruoyi-system ClusterIP 10.96.235.128 <none> 9201/TCP 8d
ruoyi-ui ClusterIP 10.96.57.74 <none> 80/TCP 7d6h

1.初始化数据库

1.1创建ruoyi程序专用的数据库用户

1
2
3
4
5
6
7
8
9
10
11
# 创建程序用的库ry-cloud
CREATE DATABASE `ry-cloud` CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

# 创建一个用户,给ruoyi的服务连接数据库用
CREATE USER 'ruoyi_app'@'%' IDENTIFIED BY 'ruoyi@mysql';

# 授权ruoyi_app用户有ry-cloud库所有权限
GRANT ALL ON `ry-cloud`.* TO 'ruoyi_app'@'%';

# 刷新
FLUSH PRIVILEGES;

1.2导入数据

在项目的sql文件夹中有如下几个sql文件,按需要导入:

ry_20260417.sql:若依主库(核心业务库),这是必须导入的主库脚本

quartz.sql:定时任务相关的表结构,如果需要定时任务管理相关功能那就要导入

ry_config_20250902.sql:若依配置中心库(Nacos 配置),必须导入

ry_seata_20210128.sql:Seata 分布式事务库,可选

注意:

  • 业务库脚本不含建库语句:sql/ry_20260417.sql 和 sql/quartz.sql 开头直接是 drop table / create table,没有 CREATE DATABASE ry-cloud;,所以导入前必须先手动创建 ry-cloud 数据库,1.1中已经执行。
  • ry_config_20250902.sql 是给 Nacos 服务端用,Nacos 服务如果连的是 **nacos**库,就导入到 nacos 库。这个sql文件不要导入到主库ry-cloud中。
  • ry_config_20250902.sql 开头写死了 DROP DATABASE IF EXISTS ry-config; 和 USE ry-config;,也就是说sql中默认nacos服务用的是ry-config库。
    • 如果 nacos 是全新的空库(还没建表):把脚本开头的 ry-config 全部替换成 nacos,然后整份导入即可。
    • 如果 nacos库里已经有了 Nacos 的 12 张表(甚至已经有你自己的登录账号):千万不要直接执行整份文件(开头的删库/建表语句或末尾的默认用户插入会冲突),只需要 use nacos;,然后单独执行里面的那条 insert into config_info ...(9 条配置数据)就行了。

因为我的Nacos服务已经可以正常登录了,所以这里只执行了ry_config_20250902.sql中的insert into config_info ...语句,执行后会在config_info表中有9条数据,同时登录Nacos的控制台在[配置管理]-[配置列表]中能看到如下图的数据:


恢复主库的数据,把ry_20260417.sql恢复到ry-cloud业务库中,表如下,QRTZ开头的表是从quartz.sql恢复的,我这里程序没用到定时任务,不恢复也没事:

上述基础工作准备好后开始部署ruoyi后端的微服务!

2.部署RuoYi微服务

后端微服务只演示ruoyi-system、ruoyi-auth、ruoyi-gateway,后端java服务制作jar包的过程不演示了,直接从制作镜像开始,因为后续会使用Jenkins+Gitlab+Harbor做CI/CD。

2.1部署ruoyi-system服务

编写Dockerfile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Dockerfile内容如下:
[root@harbor ruoyi-system]# cat Dockerfile
# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/openjdk:8u111-jdk
# author
MAINTAINER liujunwei

# 指定路径
WORKDIR /home/ruoyi
# 复制jar文件到路径
COPY ruoyi-modules-system.jar /home/ruoyi/ruoyi-modules-system.jar

# 暴露端口(系统模块通常是 9201)
EXPOSE 9201
# 启动系统服务
ENTRYPOINT ["java","-jar","ruoyi-modules-system.jar"]

把ruoyi-system服务的jar包上传到Dockerfile所在的目录中:

1
2
3
4
[root@harbor ruoyi-system]# ll
总用量 98516
-rw-r--r-- 1 root root 451 11月 9 22:26 Dockerfile
-rw-r--r-- 1 root root 100874437 11月 9 21:21 ruoyi-modules-system.jar

制作镜像:

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
# 在Dockerfile同级目录执行build指令
docker build -t registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-system:v1.0 .

# 构建过程如下:
[root@harbor ruoyi-system]# docker build -t registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-system:v1.0 .
Sending build context to Docker daemon 100.9MB
Step 1/6 : FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/openjdk:8u111-jdk
---> d23bdf5b1b1b
Step 2/6 : MAINTAINER ruoyi
---> Running in 27584bc3ceca
Removing intermediate container 27584bc3ceca
---> daf42d97cf93
Step 3/6 : WORKDIR /home/ruoyi
---> Running in b88c6a38e9fa
Removing intermediate container b88c6a38e9fa
---> c1ba4e87611b
Step 4/6 : COPY ruoyi-modules-system.jar /home/ruoyi/ruoyi-modules-system.jar
---> 66fa0cde22c1
Step 5/6 : EXPOSE 9201
---> Running in 633ce4f11f9b
Removing intermediate container 633ce4f11f9b
---> 5507eebc534c
Step 6/6 : ENTRYPOINT ["java","-jar","ruoyi-modules-system.jar"]
---> Running in bc58c10a8f5c
Removing intermediate container bc58c10a8f5c
---> 1af4cb592505
Successfully built 1af4cb592505
Successfully tagged registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-system:v1.0

将镜像推送到镜像仓库,这里我用的是阿里云的镜像仓库,公司中一般都有自己的Harbor,那就推送到Harbor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
docker push registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-system:v1.0

#执行过程如下:
[root@harbor ruoyi-system]# docker push registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-system:v1.0
The push refers to repository [registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-system]
ba13400d2963: Pushed
f1af2cd08557: Pushed
35c20f26d188: Layer already exists
c3fe59dd9556: Layer already exists
6ed1a81ba5b6: Layer already exists
a3483ce177ce: Layer already exists
ce6c8756685b: Layer already exists
30339f20ced0: Layer already exists
0eb22bfb707d: Layer already exists
a2ae92ffcd29: Layer already exists
v1.0: digest: sha256:9cef0c302bf9df3f7da87b3a2977308251876274febed40d58cdb4cd3f0124d5 size: 2419

查看镜像仓库是否有该镜像,后面在k8s创建服务时就从该仓库拉取镜像:


创建应用前先在 Nacos 控制台修改 ruoyi-system-dev.yml的配置,修改文件中连接MySQL,Redis的信息:

【配置管理】-【配置列表】找到服务的对应的yml点击【编辑】


修改Redis和MySQL的连接信息:

1
2
3
4
5
spring:
redis:
host: external-redis-svc # 集群内redis的地址
port: 6379 # redis服务的端口
password: asdqwe123 #redis的密码

1
2
3
4
5
6
7
datasource:
# 主库数据源
master:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://external-mysql-svc:3306/ry-cloud?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8 # external-mysql-svc:3306是集群内连接MySQL的地址
username: ruoyi_app #这是程序连接MySQL用的用户,在1.1中创建的用户
password: ruoyi@mysql # 指定ruoyi_app用户的密码,1.1中创建的


修改好后点击【发布】-【确认发布】即可。

接下来配置ruoyi-system应用清单:

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
73
74
75
76
77
78
79
80
81
82
83
84
# 创建ruoyi-system服务的yaml文件
[root@k8s-master01 ruoyi]# cat ruoyi-system.yaml
# 服务的Deployment配置
apiVersion: apps/v1
kind: Deployment
metadata:
name: ruoyi-system
namespace: ruoyi # 改成你的命名空间
labels:
app: ruoyi-system
spec:
replicas: 1 # 生产可改成 2
selector:
matchLabels:
app: ruoyi-system
template:
metadata:
labels:
app: ruoyi-system
spec:
# 如果阿里云仓库是私有的,取消注释并填写 secret 名称
# imagePullSecrets:
# - name: aliyun-registry-secret
containers:
- name: ruoyi-system
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-system:v1.0
imagePullPolicy: IfNotPresent
ports:
- containerPort: 9201
name: http
env:
# 强制指定 Nacos 地址(推荐用环境变量覆盖,最稳妥)
- name: SPRING_PROFILES_ACTIVE #使用配置文件的环境变量,激活哪个 Spring 环境配置(profile)。
value: "dev" #必须和 Nacos 控制台里实际存在的配置文件后缀一致。
- name: SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR #Nacos 服务发现(注册中心) 的地址。
value: "nacos-cs.ruoyi.svc.cluster.local:8848" # 改成自己的 Nacos Service 地址
#如果 Nacos 和 ruoyi-system 在同一个命名空间,也可以简写为:nacos-cs:8848
- name: SPRING_CLOUD_NACOS_CONFIG_SERVER_ADDR #Nacos 配置中心 的地址。
value: "nacos-cs.ruoyi.svc.cluster.local:8848" # 和服务发现的地址一致
- name: SPRING_CLOUD_NACOS_DISCOVERY_USERNAME #连接 Nacos 服务发现 时使用的账号密码
value: "nacos" #用nacos这个用户
- name: SPRING_CLOUD_NACOS_DISCOVERY_PASSWORD #密码的环境变量
value: "asdqwe123" # 上述nacos用户的密码,如果改了密码请同步修改
- name: SPRING_CLOUD_NACOS_CONFIG_USERNAME #连接 Nacos 配置中心 时使用的账号密码
value: "nacos" #配置中心和服务发现的账号密码保持一致即可
- name: SPRING_CLOUD_NACOS_CONFIG_PASSWORD
value: "asdqwe123"
# 健康检查
readinessProbe:
tcpSocket:
port: 9201
initialDelaySeconds: 40
periodSeconds: 10
failureThreshold: 6
livenessProbe:
tcpSocket:
port: 9201
initialDelaySeconds: 60
periodSeconds: 20
# 资源限额
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
cpu: 1000m
memory: 1536Mi
---
# 服务的Service配置
apiVersion: v1
kind: Service
metadata:
name: ruoyi-system
namespace: ruoyi
labels:
app: ruoyi-system
spec:
selector:
app: ruoyi-system
ports:
- name: http
port: 9201
targetPort: 9201
type: ClusterIP # 微服务一般不需要对外暴露,通过 Gateway + Nacos 调用即可

创建服务:

1
2
# 将服务创建在ruoyi空间	
[root@k8s-master01 ruoyi]# kubectl create -f ruoyi-system.yaml -n ruoyi

查看服务创建情况:

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
[root@k8s-master01 ruoyi]# kubectl get -f ruoyi-system.yaml -n ruoyi
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/ruoyi-system 1/1 1 1 8d

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/ruoyi-system ClusterIP 10.96.235.128 <none> 9201/TCP 8d

# pod已经成功运行
[root@k8s-master01 ruoyi]# kubectl get po -n ruoyi
NAME READY STATUS RESTARTS AGE
nacos-0 1/1 Running 0 32h
nacos-1 1/1 Running 0 32h
nacos-2 1/1 Running 0 32h
ruoyi-system-8686b47959-g4tgr 1/1 Running 0 32h

#通过logs 命令看到以下信息表示服务启动成功
[root@k8s-master01 ruoyi]# kubectl logs -f ruoyi-system-8686b47959-g4tgr -n ruoyi
(♥◠‿◠)ノ゙ 系统模块启动成功 ლ(´ڡ`ლ)゙
.-------. ____ __
| _ _ \ \ \ / /
| ( ' ) | \ _. / '
|(_ o _) / _( )_ .'
| (_,_).' __ ___(_ o _)'
| |\ \ | || |(_,_)'
| | \ `' /| `-' /
| | \ / \ /
''-' `'-' `-..-'

同时该服务也会注册到Nacos上,检查控制台:

2.2部署ruoyi-auth服务

编写Dockerfile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Dockerfile内容如下:
[root@harbor ruoyi-auth]# cat Dockerfile
# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/openjdk:8u111-jdk
# author
MAINTAINER ruoyi

# 指定路径
WORKDIR /home/ruoyi
# 复制jar文件到路径
COPY ruoyi-auth.jar /home/ruoyi/ruoyi-auth.jar
EXPOSE 9200
# 启动认证服务
ENTRYPOINT ["java","-jar","ruoyi-auth.jar"]

把ruoyi-auth服务的jar包上传到Dockerfile所在的目录中:

1
2
3
4
[root@harbor ruoyi-auth]# ll
总用量 85176
-rw-r--r-- 1 root root 373 11月 9 23:15 Dockerfile
-rw-r--r-- 1 root root 87215979 11月 9 23:14 ruoyi-auth.jar

制作镜像:

1
2
# 在Dockerfile同级目录执行build指令构建镜像
docker build -t registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-auth:v1.0 .

将镜像推送到镜像仓库,这里我用的是阿里云的镜像仓库,公司中一般都有自己的Harbor,那就推送到Harbor

1
docker push registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-auth:v1.0

查看镜像仓库是否有该镜像,后面在k8s创建服务时就从该仓库拉取镜像:


创建应用前先在 Nacos 控制台修改 ruoyi-auth-dev.yml的配置,修改文件中连接Redis的信息,步骤参考2.1中修改ruoyi-system-dev.yaml,修改后的结果如下图,修改好发布即可:

接下来配置ruoyi-auth应用清单:

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
73
74
75
76
77
78
79
# 创建ruoyi-auth服务的yaml文件
[root@k8s-master01 ruoyi]# cat ruoyi-auth.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: ruoyi-auth
namespace: ruoyi
labels:
app: ruoyi-auth
spec:
replicas: 1
selector:
matchLabels:
app: ruoyi-auth
template:
metadata:
labels:
app: ruoyi-auth
spec:
# 如果需要私有仓库认证,取消注释
# imagePullSecrets:
# - name: aliyun-registry-secret
containers:
- name: ruoyi-auth
# 改成自己服务的实际镜像地址
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-auth:v1.0
imagePullPolicy: IfNotPresent
ports:
- containerPort: 9200
name: http
env:
- name: SPRING_PROFILES_ACTIVE
value: "dev"
- name: SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR
value: "nacos-cs.ruoyi.svc.cluster.local:8848" # 请确认你的 Nacos Service 地址
- name: SPRING_CLOUD_NACOS_CONFIG_SERVER_ADDR
value: "nacos-cs.ruoyi.svc.cluster.local:8848"
- name: SPRING_CLOUD_NACOS_DISCOVERY_USERNAME
value: "nacos"
- name: SPRING_CLOUD_NACOS_DISCOVERY_PASSWORD
value: "asdqwe123"
- name: SPRING_CLOUD_NACOS_CONFIG_USERNAME
value: "nacos"
- name: SPRING_CLOUD_NACOS_CONFIG_PASSWORD
value: "asdqwe123"
readinessProbe:
tcpSocket:
port: 9200
initialDelaySeconds: 40
periodSeconds: 10
failureThreshold: 6
livenessProbe:
tcpSocket:
port: 9200
initialDelaySeconds: 60
periodSeconds: 20
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
cpu: 1000m
memory: 1536Mi
---
apiVersion: v1
kind: Service
metadata:
name: ruoyi-auth
namespace: ruoyi
labels:
app: ruoyi-auth
spec:
selector:
app: ruoyi-auth
ports:
- name: http
port: 9200
targetPort: 9200
type: ClusterIP

创建服务:

1
2
# 将服务创建在ruoyi空间	
[root@k8s-master01 ruoyi]# kubectl create -f ruoyi-auth.yaml -n ruoyi

查看服务创建情况:

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
[root@k8s-master01 ruoyi]# kubectl get  -f ruoyi-auth.yaml -n ruoyi
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/ruoyi-auth 0/1 1 0 8d

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/ruoyi-auth ClusterIP 10.96.52.116 <none> 9200/TCP 8d

# 等待ruoyi-auth的pod成功运行
[root@k8s-master01 ruoyi]# kubectl get po -n ruoyi
NAME READY STATUS RESTARTS AGE
nacos-0 1/1 Running 0 33h
nacos-1 1/1 Running 0 33h
nacos-2 1/1 Running 0 33h
ruoyi-auth-84fb685b45-tz2ct 0/1 Running 0 36s
ruoyi-system-8686b47959-g4tgr 1/1 Running 0 32h
ruoyi-ui-6dcc7b5497-zbxw9 1/1 Running 0 32h

#通过logs 命令看到以下信息表示服务启动成功
[root@k8s-master01 ruoyi]# kubectl logs -f ruoyi-auth-84fb685b45-tz2ct -n ruoyi
(♥◠‿◠)ノ゙ 认证授权中心启动成功 ლ(´ڡ`ლ)゙
.-------. ____ __
| _ _ \ \ \ / /
| ( ' ) | \ _. / '
|(_ o _) / _( )_ .'
| (_,_).' __ ___(_ o _)'
| |\ \ | || |(_,_)'
| | \ `' /| `-' /
| | \ / \ /
''-' `'-' `-..-'

同时该服务也会注册到Nacos上,检查控制台:

2.3部署ruoyi-gateway服务

编写Dockerfile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Dockerfile内容如下:
[root@harbor ruoyi-gateway]# cat Dockerfile
# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/openjdk:8u111-jdk
# author
MAINTAINER ruoyi

# 指定路径
WORKDIR /home/ruoyi
# 复制jar文件到路径
COPY ruoyi-gateway.jar /home/ruoyi/ruoyi-gateway.jar
EXPOSE 9200
# 启动网关服务
ENTRYPOINT ["java","-jar","ruoyi-gateway.jar"]

把ruoyi-gateway.jar服务的jar包上传到Dockerfile所在的目录中:

1
2
3
4
[root@harbor ruoyi-gateway]# ll
总用量 89940
-rw-r--r-- 1 root root 398 11月 10 13:23 Dockerfile
-rw-r--r-- 1 root root 92090986 11月 10 13:19 ruoyi-gateway.jar

制作镜像:

1
2
# 在Dockerfile同级目录执行build指令构建镜像
docker build -t registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-gateway:v1.0 .

将镜像推送到镜像仓库,这里我用的是阿里云的镜像仓库,公司中一般都有自己的Harbor,那就推送到Harbor

1
docker push registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-gateway:v1.0

查看镜像仓库是否有该镜像,后面在k8s创建服务时就从该仓库拉取镜像:


创建应用前先在 Nacos 控制台修改 ruoyi-gateway-dev.yml的配置,修改文件中连接Redis的信息,步骤参考2.1中修改ruoyi-system-dev.yaml,修改后的结果如下图,修改好发布即可:


接下来配置ruoyi-gateway应用清单:

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
73
74
75
76
77
78
79
# 创建ruoyi-auth服务的yaml文件
[root@k8s-master01 ruoyi]# cat ruoyi-gateway.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: ruoyi-gateway
namespace: ruoyi
labels:
app: ruoyi-gateway
spec:
replicas: 1
selector:
matchLabels:
app: ruoyi-gateway
template:
metadata:
labels:
app: ruoyi-gateway
spec:
# 如果镜像仓库需要认证,取消注释
# imagePullSecrets:
# - name: aliyun-registry-secret
containers:
- name: ruoyi-gateway
# 改成自己的仓库地址
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-gateway:v1.0
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8080
name: http
env:
- name: SPRING_PROFILES_ACTIVE
value: "dev"
- name: SPRING_CLOUD_NACOS_DISCOVERY_SERVER_ADDR
value: "nacos-cs.ruoyi.svc.cluster.local:8848" # 请确认与之前一致
- name: SPRING_CLOUD_NACOS_CONFIG_SERVER_ADDR
value: "nacos-cs.ruoyi.svc.cluster.local:8848"
- name: SPRING_CLOUD_NACOS_DISCOVERY_USERNAME
value: "nacos"
- name: SPRING_CLOUD_NACOS_DISCOVERY_PASSWORD
value: "asdqwe123"
- name: SPRING_CLOUD_NACOS_CONFIG_USERNAME
value: "nacos"
- name: SPRING_CLOUD_NACOS_CONFIG_PASSWORD
value: "asdqwe123"
readinessProbe:
tcpSocket:
port: 8080
initialDelaySeconds: 40
periodSeconds: 10
failureThreshold: 6
livenessProbe:
tcpSocket:
port: 8080
initialDelaySeconds: 60
periodSeconds: 20
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
cpu: 1000m
memory: 1536Mi
---
apiVersion: v1
kind: Service
metadata:
name: ruoyi-gateway
namespace: ruoyi
labels:
app: ruoyi-gateway
spec:
selector:
app: ruoyi-gateway
ports:
- name: http
port: 8080
targetPort: 8080
type: ClusterIP

创建服务:

1
2
# 将服务创建在ruoyi空间	
[root@k8s-master01 ruoyi]# kubectl create -f ruoyi-gateway.yaml -n ruoyi

查看服务创建情况:

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
[root@k8s-master01 ruoyi]# kubectl get -f ruoyi-gateway.yaml
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/ruoyi-gateway 0/1 1 0 7d10h

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/ruoyi-gateway ClusterIP 10.96.2.167 <none> 8080/TCP 7d10h

# 等待ruoyi-gateway的pod成功运行
[root@k8s-master01 ruoyi]# kubectl get po -n ruoyi
NAME READY STATUS RESTARTS AGE
nacos-0 1/1 Running 0 33h
nacos-1 1/1 Running 0 33h
nacos-2 1/1 Running 0 33h
ruoyi-auth-84fb685b45-tz2ct 1/1 Running 0 8m42s
ruoyi-gateway-7b76b798fd-gbqsj 0/1 Running 0 24s
ruoyi-system-8686b47959-g4tgr 1/1 Running 0 33h
ruoyi-ui-6dcc7b5497-zbxw9 1/1 Running 0 32h

#通过logs 命令看到以下信息表示服务启动成功
[root@k8s-master01 ruoyi]# kubectl logs -f ruoyi-gateway-7b76b798fd-gbqsj -n ruoyi
(♥◠‿◠)ノ゙ 若依网关启动成功 ლ(´ڡ`ლ)゙
.-------. ____ __
| _ _ \ \ \ / /
| ( ' ) | \ _. / '
|(_ o _) / _( )_ .'
| (_,_).' __ ___(_ o _)'
| |\ \ | || |(_,_)'
| | \ `' /| `-' /
| | \ / \ /
''-' `'-' `-..-'

同时该服务也会注册到Nacos上,检查控制台:

2.4部署前端服务

这里手动指令命令构建前端,执行完成后,前端项目根目录下会生成一个 dist 文件夹(里面有 index.html、static / assets 等静态文件)。因为后面会用Jenkins来发版,所以这里手动执行构建

1
2
3
4
5
6
7
8
9
10
# 准备前端的构建后的产物
[root@harbor ruoyi-ui]# ll dist
总用量 36
-rw-r--r-- 1 root root 5663 11月 18 2026 favicon.ico
drwxr-xr-x 2 root root 39 11月 18 2026 html
-rw-r--r-- 1 root root 12909 11月 18 2026 index.html
-rw-r--r-- 1 root root 4251 11月 18 2026 index.html.gz
-rw-r--r-- 1 root root 26 11月 18 2026 robots.txt
drwxr-xr-x 6 root root 51 11月 18 2026 static
drwxr-xr-x 3 root root 25 11月 18 2026 styles

准备制作前端镜像的Dockerfile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[root@harbor ruoyi-ui]# cat Dockerfile
# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
# 删除默认的 nginx 配置
RUN rm /etc/nginx/conf.d/default.conf
# 复制conf文件到路径
COPY nginx.conf /etc/nginx/conf.d/default.conf
# 复制html文件到路径
COPY dist/ /usr/share/nginx/html/

# 暴露端口
EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

准备nginx.conf文件,配置文件中不需要像传统的nginx配置那样指定后端服务的location,这部分会在Istio中配置:

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
[root@harbor ruoyi-ui]# cat nginx.conf
server {
listen 80;
server_name localhost;

gzip on;
gzip_min_length 1k;
gzip_comp_level 9;
gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png;
gzip_vary on;

location / {
root /usr/share/nginx/html;
try_files $uri $uri/ /index.html;
index index.html index.htm;
}

location ~ /\. {
deny all;
}

# 避免actuator暴露
if ($uri ~ "/actuator") {
return 403;
}

error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}

注意以下文件在同一个目录中,如果不在请修改Dockerfile中对应的路径

1
2
3
4
5
6
[root@harbor ruoyi-ui]# ll
总用量 3612
drwxr-xr-x 5 root root 122 11月 18 2026 dist
-rw-r--r-- 1 root root 3690220 11月 18 00:18 dist.zip
-rw-r--r-- 1 root root 362 11月 10 16:36 Dockerfile
-rw-r--r-- 1 root root 711 11月 10 16:56 nginx.conf

制作前端镜像:

1
docker build -t registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-ui:v1.7 .

推送镜像:

1
docker push -t registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-ui:v1.7 

接下来配置前端的应用清单:

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
# 创建前端ruoyi-ui服务的yaml文件
[root@k8s-master01 ruoyi]# cat ruoyi-ui.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: ruoyi-ui
namespace: ruoyi
labels:
app: ruoyi-ui
spec:
replicas: 1
selector:
matchLabels:
app: ruoyi-ui
template:
metadata:
labels:
app: ruoyi-ui
spec:
containers:
- name: ruoyi-ui
# 改成你的前端镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-ui:v1.7
ports:
- containerPort: 80
resources:
requests:
cpu: 100m
memory: 128Mi
limits:
cpu: 500m
memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
name: ruoyi-ui
namespace: ruoyi
spec:
selector:
app: ruoyi-ui
ports:
- name: http
port: 80
targetPort: 80
type: ClusterIP

创建服务:

1
2
3
4
# 将服务创建在ruoyi空间	
[root@k8s-master01 ruoyi]# kubectl create -f ruoyi-ui.yaml -n ruoyi
deployment.apps/ruoyi-ui created
service/ruoyi-ui created

查看服务创建情况:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[root@k8s-master01 ruoyi]# kubectl get -f ruoyi-ui.yaml  -n ruoyi
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/ruoyi-ui 1/1 1 1 18s

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/ruoyi-ui ClusterIP 10.96.43.165 <none> 80/TCP 18s

# 等待ruoyi-ui的pod成功运行
[root@k8s-master01 ruoyi]# kubectl get po -n ruoyi
NAME READY STATUS RESTARTS AGE
nacos-0 1/1 Running 0 34h
nacos-1 1/1 Running 0 34h
nacos-2 1/1 Running 0 33h
ruoyi-auth-84fb685b45-tz2ct 1/1 Running 0 46m
ruoyi-gateway-7b76b798fd-gbqsj 1/1 Running 0 38m
ruoyi-system-8686b47959-g4tgr 1/1 Running 0 33h
ruoyi-ui-6dcc7b5497-wxq89 1/1 Running 0 29s

2.5对外暴露服务

这里用Istio来对外暴露部分,也可以用Ingress,如果在公司的实际生产环境中后面需要项目做流量的精细化管理建议直接用Istio来代替Ingress。

Istio的相关知识点可以参考其他Istio的文章《服务网格Istio流量治理实践》

对外暴露服务只需要创建gateway和vs资源即可:

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
[root@k8s-master01 ruoyi]# cat ruoyi-ui-istio.yaml
# Gateway(入口)
apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
name: ruoyi-gateway
namespace: ruoyi
spec:
selector:
istio: ingressgateway
servers:
- port:
number: 80
name: http
protocol: HTTP
hosts:
- "ruoyi.istio.com" # 或写成你的域名

---
# VirtualService(核心路由)
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
name: ruoyi-vs
namespace: ruoyi
spec:
hosts:
- "ruoyi.istio.com"
gateways:
- ruoyi-gateway
http:
# 后端 API 优先匹配
- match:
- uri:
prefix: /prod-api/
rewrite:
uri: / # 把 /prod-api 去掉再转发给 Gateway
route:
- destination:
host: ruoyi-gateway.ruoyi.svc.cluster.local # 这里配置的是ruoyi-gateway的svc名字
port:
number: 8080

# 前端(兜底)
- match:
- uri:
prefix: /
route:
- destination:
host: ruoyi-ui.ruoyi.svc.cluster.local #这里配置的ruoyi-ui服务的svc名字
port:
number: 80[root@k8s-master01 ruoyi]#

创建上述资源:

1
[root@k8s-master01 ruoyi]# kubectl create -f ruoyi-ui-istio.yaml

配置hosts解析:

1
2
# 在C:\Windows\System32\drivers\etc\hosts文件中添加一条记录,192.168.0.81是k8s集群任意节点的ip,ruoyi.istio.com是上述在gateway资源中定义的hosts主机名
192.168.0.81 ruoyi.istio.com

web浏览器访问ruoyi项目:http://ruoyi.istio.com:30080/

这里的端口是Istio的服务所监听的端口,在实际的生产环境中是直接访问的域名,账号admin,密码admin


成功登录系统:


整个ruoyi项目的微服务在k8s集群中部署完成,这里只记录了三个后端服务的部署,其他服务也是同样的步骤,这里就不演示了。

3.Jenkins发布该项目

该小结只演示在Jenkins平台上发版ruoyi的几个服务,具体的DevOps平台搭建参考文章《DevOps平台搭建部署流程》

部署前先检查Jenkins、Gitlab、Harbor三个服务正常登录

3.1自动化构建ruoyi-system应用

在每个微服务模块的根目录下,同时放置该服务专属的 Dockerfile 和 **Jenkinsfile**,目录规划如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ruoyi-cloud/
├── pom.xml
├── ruoyi-auth/
│ ├── Dockerfile # 认证服务的 Dockerfile
│ ├── Jenkinsfile # 认证服务的 Jenkinsfile
│ └── pom.xml
├── ruoyi-gateway/
│ ├── Dockerfile # 网关服务的 Dockerfile
│ ├── Jenkinsfile # 网关服务的 Jenkinsfile
│ └── pom.xml
└── ruoyi-modules/
└── ruoyi-system/
├── Dockerfile # 系统服务的 Dockerfile
├── Jenkinsfile # 系统服务的 Jenkinsfile
└── pom.xml

在代码仓库的ruoyi-modules/ruoyi-system/路径下创建Dockerfile和Jenkinsfile:


Jenkinsfile内容如下:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
pipeline {
agent {
kubernetes {
cloud 'kubernetes-study'
slaveConnectTimeout 1200
workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "pipeline-cache", readOnly: false)
yaml '''
kind: Pod
apiVersion: v1
spec:
restartPolicy: Never
securityContext:
runAsUser: 0
fsGroup: 0
# nodeSelector:
# build: "true"
containers:
# jnlp容器,负责和Jenkins主节点通信,该容器中的配置不需要修改
- name: jnlp
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/jnlp-agent-docker:latest
args: [\'$(JENKINS_SECRET)\', \'$(JENKINS_NAME)\']
imagePullPolicy: IfNotPresent
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
# build容器,包含执行构建的命令,比如java的需要mvn构建,就可以用一个maven的镜像
- name: build #定义容器的名字,流水线的stage会用到改名字
# java程序使用maven镜像,包含mvn工具。如果是NodeJS项目可以使用node的镜像,根据实际情况修改
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/maven:3.5.3
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: workspace-volume
mountPath: /home/jenkins/agent
- name: maven-cache
mountPath: /root/.m2
readOnly: false
- name: localtime
mountPath: /etc/localtime
# kaniko 用来制作镜像的容器,可以是docker 或者其他可以用于构建镜像的工具
- name: kaniko
# 是示例中采用kaniko制作镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kaniko-executor:debug
imagePullPolicy: IfNotPresent
command:
- "sleep"
args:
- "99d"
tty: true
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
- name: docker-registry-config #挂载docker配置文件,用于kaniko连接镜像仓库
mountPath: /kaniko/.docker
readOnly: false
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
# 定义发版的镜像,因为最终是发版至 Kubernetes集群,所以需要有一个 kubectl 命令或者是其他的发版工具也可以,比如 helm,根据实际情况配置自己的发版镜像
- name: kubectl
# 发版的镜像根据实际需求进行变更,例如使用helm的镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kubectl:latest
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
volumes:
- name: localtime
hostPath:
path: /usr/share/zoneinfo/Asia/Shanghai
# 构建缓存的pvc
- name: maven-cache
persistentVolumeClaim:
claimName: maven-global-cache
readOnly: false
#docker认证信息的volume
- name: docker-registry-config
configMap:
name: docker-registry-config '''
}
}

//定义一些全局环境变量
environment {
COMMIT_ID = ""
HARBOR_ADDRESS = "192.168.0.89" //Harbor 地址
REGISTRY_DIR = "ruoyi-cloud" //Harbor 的项目目录,如果Harbor上没有该项目目录需要提前创建
IMAGE_NAME = "ruoyi-system" //镜像的名称
NAMESPACE = "ruoyi" //该应用在 ruoyi 中的命名空间
TAG = "" //镜像的 Tag,在此用 BUILD_TAG+COMMIT_ID 组成
GIT_URL = "git@192.168.0.222:kubernetes/ruoyi-cloud-springboot2.git" //代码仓库地址
MODULE_PATH = "ruoyi-modules/ruoyi-system" // 因为ruoyi-system在ruoyi-modules下所以是两层,网关则是直接填一层即可 "ruoyi-gateway"
}
parameters {
gitParameter(branch: '', branchFilter: 'origin/(.*)', defaultValue:'', description: 'Branch for build and deploy', name: 'BRANCH',quickFilterEnabled: false, selectedValue: 'NONE', sortMode: 'NONE',tagFilter: '*', type: 'PT_BRANCH')
}
// 接下来是拉代码的 stage,这个 stage 是一个并行的 stage,因为考虑了该流水线是手动触发还是触发
stages {
stage('拉取代码') {
steps {
script {
def branchToUse = env.gitlabBranch ?: params.BRANCH
// 加一个保护,防止两个来源都为空
if (!branchToUse) {
error "未指定构建分支,请检查触发方式或参数配置"
}
git(
url: "${GIT_URL}",
branch: branchToUse,
changelog: true,
poll: true,
credentialsId: 'gitlab-key'
)
COMMIT_ID = sh(returnStdout: true, script: "git log -n 1 --pretty=format:'%h'").trim()
TAG = "${env.BUILD_TAG}-${COMMIT_ID}"
echo "触发方式: ${env.gitlabBranch ? 'GitLab Webhook' : '手动触发'}"
echo "Branch: ${branchToUse}, Commit: ${COMMIT_ID}, Tag: ${TAG}"
}
}
}
stage('Building') {
steps {
container(name: 'build') {
sh """
mvn clean package -pl ${MODULE_PATH} -am -DskipTests
ls ${MODULE_PATH}/target/*.jar
"""
}
}
}
stage('Build for creating image') {
steps {
container(name: 'kaniko') {
sh """
executor -d ${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -c ${MODULE_PATH} -f ${MODULE_PATH}/Dockerfile --insecure --skip-tls-verify
"""
}
}
}
stage('部署到k8s') {
environment {
MY_KUBECONFIG = credentials('STUD_KUBECONFIG')
}
steps {
container(name: 'kubectl') {
sh """
kubectl --kubeconfig $MY_KUBECONFIG set image deployment/${IMAGE_NAME} ${IMAGE_NAME}=${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -n $NAMESPACE
"""
}
}
}
}
}

同样在ruoyi-modules/ruoyi-system/目录下创建Dockerfile文件,内容如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Dockerfile内容如下:
[root@harbor ruoyi-system]# cat Dockerfile
# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/openjdk:8u111-jdk
# author
MAINTAINER liujunwei

# 指定路径
WORKDIR /home/ruoyi
# 复制jar文件到路径
COPY target/ruoyi-modules-system.jar /home/ruoyi/ruoyi-modules-system.jar

# 暴露端口(系统模块通常是 9201)
EXPOSE 9201
# 启动系统服务
ENTRYPOINT ["java","-jar","ruoyi-modules-system.jar"]

添加后的文件如下,注意文件所在目录的位置,不要搞错位置:

接下载来Jenkins上创建任务-Job:

单击首页的创建任务(Job)选项(或者是 New Item)并配置任务信息(我单独创建了一个ruoyi-cloud视图,ruoyi所有任务都在该视图下),如图所示:

输入的 Job 的名称(使用微服务的名字即可,方便区分),类型为 Pipeline,最后点 击 OK 即可:


在新页面,点击 Pipeline,输入 Git 仓库地址、选择之前配置 GitLab Key、分支为 main, 点击 Save 即可:

配置完成后点击save保存,点击 Build Now(由于 Jenkins 参数由 Jenkinsfile 生成,所以第一次执行流水 线会失败),第一次构建结束后,可以看到 Build Now 变成了 Build with Parameters。点击 Build with Parameters 后,可以读取到 Git 仓库的分支,之后可以选择分支进行手动构建:

选择分支,之后点击 Build,然后点击进度条即可看到构建日志:


构建完成后检查Harbor中是否存在镜像:


最后查看k8s集群中ruoyi-system的deployment镜像版本:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[root@k8s-master01 ~]# kubectl get deployments.apps -n ruoyi ruoyi-system -oyaml|grep image
image: 192.168.0.89/ruoyi-cloud/ruoyi-system:jenkins-ruoyi-system-4-68a4043
imagePullPolicy: IfNotPresent

#查看pod状态,ruoyi-system-587bfbc4dd-qqlxq运行正常
[root@k8s-master01 ~]# kubectl get po -n ruoyi
NAME READY STATUS RESTARTS AGE
nacos-0 1/1 Running 0 2d2h
nacos-1 1/1 Running 0 2d2h
nacos-2 1/1 Running 0 2d2h
ruoyi-auth-84fb685b45-tz2ct 1/1 Running 0 17h
ruoyi-gateway-7b76b798fd-gbqsj 1/1 Running 0 16h
ruoyi-system-587bfbc4dd-qqlxq 1/1 Running 0 111s
ruoyi-ui-6dcc7b5497-wxq89 1/1 Running 0 16h

上述配置过程中需要注意的是在Jenkinsfile中定义的Harbor项目目录环境变量要提前在Harbor控制台上创建好

1
REGISTRY_DIR = "ruoyi-cloud"  //Harbor 的项目目录,如果Harbor上没有该项目目录需要提前创建ruoyi-cloud

如果harbor上的镜像仓库不是公开的还需要提前创建一个拉取镜像的secret,配置到服务的deployment中

3.2自动化构建ruoyi-auth服务

接下来配置ruoyi-auth服务,流程参考ruoyi-system的配置流程即可。

首先在代码仓库的ruoyi-auth路径下创建Dockerfile和Jenkinsfile:


Dockerfile内容如下:

1
2
3
4
5
6
7
8
9
10
11
12
# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/openjdk:8u111-jdk
# author
MAINTAINER liujunwei

# 指定路径
WORKDIR /home/ruoyi
# 复制jar文件到路径
COPY target/ruoyi-auth.jar /home/ruoyi/ruoyi-auth.jar
EXPOSE 9201
# 启动认证服务
ENTRYPOINT ["java","-jar","ruoyi-auth.jar"]


Jenkinsfile文件内容如下:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
pipeline {
agent {
kubernetes {
cloud 'kubernetes-study'
slaveConnectTimeout 1200
workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "pipeline-cache", readOnly: false)
yaml '''
kind: Pod
apiVersion: v1
spec:
restartPolicy: Never
securityContext:
runAsUser: 0
fsGroup: 0
# nodeSelector:
# build: "true"
containers:
# jnlp容器,负责和Jenkins主节点通信,该容器中的配置不需要修改
- name: jnlp
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/jnlp-agent-docker:latest
args: [\'$(JENKINS_SECRET)\', \'$(JENKINS_NAME)\']
imagePullPolicy: IfNotPresent
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
# build容器,包含执行构建的命令,比如java的需要mvn构建,就可以用一个maven的镜像
- name: build #定义容器的名字,流水线的stage会用到改名字
# java程序使用maven镜像,包含mvn工具。如果是NodeJS项目可以使用node的镜像,根据实际情况修改
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/maven:3.5.3
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: workspace-volume
mountPath: /home/jenkins/agent
- name: maven-cache
mountPath: /root/.m2
readOnly: false
- name: localtime
mountPath: /etc/localtime
# kaniko 用来制作镜像的容器,可以是docker 或者其他可以用于构建镜像的工具
- name: kaniko
# 是示例中采用kaniko制作镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kaniko-executor:debug
imagePullPolicy: IfNotPresent
command:
- "sleep"
args:
- "99d"
tty: true
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
- name: docker-registry-config #挂载docker配置文件,用于kaniko连接镜像仓库
mountPath: /kaniko/.docker
readOnly: false
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
# 定义发版的镜像,因为最终是发版至 Kubernetes集群,所以需要有一个 kubectl 命令或者是其他的发版工具也可以,比如 helm,根据实际情况配置自己的发版镜像
- name: kubectl
# 发版的镜像根据实际需求进行变更,例如使用helm的镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kubectl:latest
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
volumes:
- name: localtime
hostPath:
path: /usr/share/zoneinfo/Asia/Shanghai
# 构建缓存的pvc
- name: maven-cache
persistentVolumeClaim:
claimName: maven-global-cache
readOnly: false
#docker认证信息的volume
- name: docker-registry-config
configMap:
name: docker-registry-config '''
}
}

//定义一些全局环境变量
environment {
COMMIT_ID = ""
HARBOR_ADDRESS = "192.168.0.89" //Harbor 地址
REGISTRY_DIR = "ruoyi-cloud" //Harbor 的项目目录,如果Harbor上没有该项目目录需要提前创建
IMAGE_NAME = "ruoyi-auth" //镜像的名称
NAMESPACE = "ruoyi" //该应用在 ruoyi 中的命名空间
TAG = "" //镜像的 Tag,在此用 BUILD_TAG+COMMIT_ID 组成
GIT_URL = "git@192.168.0.222:kubernetes/ruoyi-cloud-springboot2.git" //代码仓库地址
MODULE_PATH = "ruoyi-auth" // 因为ruoyi-system在ruoyi-modules下所以是两层,ruoyi-auth则是直接填一层即可 "ruoyi-auth"
}
parameters {
gitParameter(branch: '', branchFilter: 'origin/(.*)', defaultValue:'', description: 'Branch for build and deploy', name: 'BRANCH',quickFilterEnabled: false, selectedValue: 'NONE', sortMode: 'NONE',tagFilter: '*', type: 'PT_BRANCH')
}
// 接下来是拉代码的 stage,这个 stage 是一个并行的 stage,因为考虑了该流水线是手动触发还是触发
stages {
stage('拉取代码') {
steps {
script {
def branchToUse = env.gitlabBranch ?: params.BRANCH
// 加一个保护,防止两个来源都为空
if (!branchToUse) {
error "未指定构建分支,请检查触发方式或参数配置"
}
git(
url: "${GIT_URL}",
branch: branchToUse,
changelog: true,
poll: true,
credentialsId: 'gitlab-key'
)
COMMIT_ID = sh(returnStdout: true, script: "git log -n 1 --pretty=format:'%h'").trim()
TAG = "${env.BUILD_TAG}-${COMMIT_ID}"
echo "触发方式: ${env.gitlabBranch ? 'GitLab Webhook' : '手动触发'}"
echo "Branch: ${branchToUse}, Commit: ${COMMIT_ID}, Tag: ${TAG}"
}
}
}
stage('Building') {
steps {
container(name: 'build') {
sh """
mvn clean package -pl ${MODULE_PATH} -am -DskipTests
ls ${MODULE_PATH}/target/*.jar
"""
}
}
}
stage('Build for creating image') {
steps {
container(name: 'kaniko') {
sh """
executor -d ${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -c ${MODULE_PATH} -f ${MODULE_PATH}/Dockerfile --insecure --skip-tls-verify
"""
}
}
}
stage('部署到k8s') {
environment {
MY_KUBECONFIG = credentials('STUD_KUBECONFIG')
}
steps {
container(name: 'kubectl') {
sh """
kubectl --kubeconfig $MY_KUBECONFIG set image deployment/${IMAGE_NAME} ${IMAGE_NAME}=${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -n $NAMESPACE
"""
}
}
}
}
}

接下载来Jenkins上创建任务-Job:单击首页的创建任务(Job)选项(或者是 New Item)并配置任务信息(我单独创建了一个ruoyi-cloud视图,ruoyi所有任务都在该视图下),如图所示:


配置从上一个名字是ruoyi-system的任务拷贝,创建后根据ruoyi-auth的服务修改参数即可:

指定ruoyi-auth服务的Jenkinsfile路径的位置:

接下来构建该服务:

1
2
3
4
# 查看发版前的镜像版本
[root@k8s-master01 ~]# kubectl get deployments.apps -n ruoyi ruoyi-auth -oyaml|grep image
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/ruoyi-auth:v1.0
imagePullPolicy: IfNotPresent


等待任务执行成功,检查pod镜像是否已经更新:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 镜像已经更新
[root@k8s-master01 ~]# kubectl get deployments.apps -n ruoyi ruoyi-auth -oyaml|grep image
image: 192.168.0.89/ruoyi-cloud/ruoyi-auth:jenkins-ruoyi-auth-1-6bf85d2
imagePullPolicy: IfNotPresent

# pod状态正常,发版成功
[root@k8s-master01 ~]# kubectl get po -n ruoyi
NAME READY STATUS RESTARTS AGE
nacos-0 1/1 Running 0 2d2h
nacos-1 1/1 Running 0 2d2h
nacos-2 1/1 Running 0 2d2h
ruoyi-auth-5d5fcc4d59-f7msv 1/1 Running 0 4m19s
ruoyi-gateway-7b76b798fd-gbqsj 1/1 Running 0 17h
ruoyi-system-587bfbc4dd-qqlxq 1/1 Running 0 45m
ruoyi-ui-6dcc7b5497-wxq89 1/1 Running 0 16h

3.3自动化构建ruoyi-gateway服务

同理,接下来配置ruoyi-gateway的自动化发版,这里就不详细写了,思路和上述两个服务都是一样的

创建Dockerfile和Jenkinsfile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Dockerfile文件内容如下:

# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/openjdk:8u111-jdk
# author
MAINTAINER ruoyi

# 指定路径
WORKDIR /home/ruoyi
# 复制jar文件到路径
COPY target/ruoyi-gateway.jar /home/ruoyi/ruoyi-gateway.jar
EXPOSE 9200
# 启动网关服务
ENTRYPOINT ["java","-jar","ruoyi-gateway.jar"]
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
# Jenkinsfile内容如下:
pipeline {
agent {
kubernetes {
cloud 'kubernetes-study'
slaveConnectTimeout 1200
workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "pipeline-cache", readOnly: false)
yaml '''
kind: Pod
apiVersion: v1
spec:
restartPolicy: Never
securityContext:
runAsUser: 0
fsGroup: 0
# nodeSelector:
# build: "true"
containers:
# jnlp容器,负责和Jenkins主节点通信,该容器中的配置不需要修改
- name: jnlp
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/jnlp-agent-docker:latest
args: [\'$(JENKINS_SECRET)\', \'$(JENKINS_NAME)\']
imagePullPolicy: IfNotPresent
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
# build容器,包含执行构建的命令,比如java的需要mvn构建,就可以用一个maven的镜像
- name: build #定义容器的名字,流水线的stage会用到改名字
# java程序使用maven镜像,包含mvn工具。如果是NodeJS项目可以使用node的镜像,根据实际情况修改
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/maven:3.5.3
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: workspace-volume
mountPath: /home/jenkins/agent
- name: maven-cache
mountPath: /root/.m2
readOnly: false
- name: localtime
mountPath: /etc/localtime
# kaniko 用来制作镜像的容器,可以是docker 或者其他可以用于构建镜像的工具
- name: kaniko
# 是示例中采用kaniko制作镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kaniko-executor:debug
imagePullPolicy: IfNotPresent
command:
- "sleep"
args:
- "99d"
tty: true
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
- name: docker-registry-config #挂载docker配置文件,用于kaniko连接镜像仓库
mountPath: /kaniko/.docker
readOnly: false
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
# 定义发版的镜像,因为最终是发版至 Kubernetes集群,所以需要有一个 kubectl 命令或者是其他的发版工具也可以,比如 helm,根据实际情况配置自己的发版镜像
- name: kubectl
# 发版的镜像根据实际需求进行变更,例如使用helm的镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kubectl:latest
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
volumes:
- name: localtime
hostPath:
path: /usr/share/zoneinfo/Asia/Shanghai
# 构建缓存的pvc
- name: maven-cache
persistentVolumeClaim:
claimName: maven-global-cache
readOnly: false
#docker认证信息的volume
- name: docker-registry-config
configMap:
name: docker-registry-config '''
}
}

//定义一些全局环境变量
environment {
COMMIT_ID = ""
HARBOR_ADDRESS = "192.168.0.89" //Harbor 地址
REGISTRY_DIR = "ruoyi-cloud" //Harbor 的项目目录,如果Harbor上没有该项目目录需要提前创建
IMAGE_NAME = "ruoyi-gateway" //镜像的名称
NAMESPACE = "ruoyi" //该应用在 ruoyi 中的命名空间
TAG = "" //镜像的 Tag,在此用 BUILD_TAG+COMMIT_ID 组成
GIT_URL = "git@192.168.0.222:kubernetes/ruoyi-cloud-springboot2.git" //代码仓库地址
MODULE_PATH = "ruoyi-gateway" // 因为ruoyi-system在ruoyi-modules下所以是两层,ruoyi-gateway则是直接填一层即可 "ruoyi-gateway"
}
parameters {
gitParameter(branch: '', branchFilter: 'origin/(.*)', defaultValue:'', description: 'Branch for build and deploy', name: 'BRANCH',quickFilterEnabled: false, selectedValue: 'NONE', sortMode: 'NONE',tagFilter: '*', type: 'PT_BRANCH')
}
// 接下来是拉代码的 stage,这个 stage 是一个并行的 stage,因为考虑了该流水线是手动触发还是触发
stages {
stage('拉取代码') {
steps {
script {
def branchToUse = env.gitlabBranch ?: params.BRANCH
// 加一个保护,防止两个来源都为空
if (!branchToUse) {
error "未指定构建分支,请检查触发方式或参数配置"
}
git(
url: "${GIT_URL}",
branch: branchToUse,
changelog: true,
poll: true,
credentialsId: 'gitlab-key'
)
COMMIT_ID = sh(returnStdout: true, script: "git log -n 1 --pretty=format:'%h'").trim()
TAG = "${env.BUILD_TAG}-${COMMIT_ID}"
echo "触发方式: ${env.gitlabBranch ? 'GitLab Webhook' : '手动触发'}"
echo "Branch: ${branchToUse}, Commit: ${COMMIT_ID}, Tag: ${TAG}"
}
}
}
stage('Building') {
steps {
container(name: 'build') {
sh """
mvn clean package -pl ${MODULE_PATH} -am -DskipTests
ls ${MODULE_PATH}/target/*.jar
"""
}
}
}
stage('Build for creating image') {
steps {
container(name: 'kaniko') {
sh """
executor -d ${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -c ${MODULE_PATH} -f ${MODULE_PATH}/Dockerfile --insecure --skip-tls-verify
"""
}
}
}
stage('部署到k8s') {
environment {
MY_KUBECONFIG = credentials('STUD_KUBECONFIG')
}
steps {
container(name: 'kubectl') {
sh """
kubectl --kubeconfig $MY_KUBECONFIG set image deployment/${IMAGE_NAME} ${IMAGE_NAME}=${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -n $NAMESPACE
"""
}
}
}
}
}


接下来在Jenkins上创建构建任务:

保存后执行Build with Parameters:

等待发版成功,查看pod镜像是否更新:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 检查pod镜像
[root@k8s-master01 ~]# kubectl get deployments.apps -n ruoyi ruoyi-gateway -oyaml|grep image
image: 192.168.0.89/ruoyi-cloud/ruoyi-gateway:jenkins-ruoyi-gateway-1-808f0f6
imagePullPolicy: IfNotPresent

# ruoyi-gateway的pod也成功运行
[root@k8s-master01 ~]# kubectl get po -n ruoyi
NAME READY STATUS RESTARTS AGE
nacos-0 1/1 Running 0 2d4h
nacos-1 1/1 Running 0 2d4h
nacos-2 1/1 Running 0 2d4h
ruoyi-auth-5d5fcc4d59-f7msv 1/1 Running 0 90m
ruoyi-gateway-d8856d56c-cjdcr 1/1 Running 0 53m
ruoyi-system-587bfbc4dd-qqlxq 1/1 Running 0 131m
ruoyi-ui-6dcc7b5497-wxq89 1/1 Running 0 18h

Harbor仓库中也有了对应服务的镜像:

3.4自动化构建前端应用

添加 Jenkinsfile 至项目根目录:


Jenkins文件内容如下:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
pipeline {
agent {
kubernetes {
cloud 'kubernetes-study'
slaveConnectTimeout 1200
//这里的工作目录单独定义一个pvc,不和java的共用一个,当然也可以共用,自己决定。
workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "vue-pipeline-cache", readOnly: false)
yaml '''
kind: Pod
apiVersion: v1
spec:
restartPolicy: Never
securityContext:
runAsUser: 0
fsGroup: 0
# nodeSelector:
# build: "true"
containers:
# jnlp容器,负责和Jenkins主节点通信,该容器中的配置不需要修改
- name: jnlp
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/jnlp-agent-docker:latest
args: [\'$(JENKINS_SECRET)\', \'$(JENKINS_NAME)\']
imagePullPolicy: IfNotPresent
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
# build容器,使用node的镜像来构建vue项目
- name: build #定义容器的名字,流水线的stage会用到改名字
#NodeJS项目可以使用node的镜像,如果是公司项目需要用你们自己对应的版本
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/node:lts
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: workspace-volume
mountPath: /home/jenkins/agent
#- name: maven-cache # vue的项目这里用不到,注释掉
# mountPath: /root/.m2
# readOnly: false
- name: localtime
mountPath: /etc/localtime
# kaniko 用来制作镜像的容器,可以是docker 或者其他可以用于构建镜像的工具
- name: kaniko
# 是示例中采用kaniko制作镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kaniko-executor:debug
imagePullPolicy: IfNotPresent
command:
- "sleep"
args:
- "99d"
tty: true
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
- name: docker-registry-config #挂载docker配置文件,用于kaniko连接镜像仓库
mountPath: /kaniko/.docker
readOnly: false
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
# 定义发版的镜像,因为最终是发版至 Kubernetes集群,所以需要有一个 kubectl 命令或者是其他的发版工具也可以,比如 helm,根据实际情况配置自己的发版镜像
- name: kubectl
# 发版的镜像根据实际需求进行变更,例如使用helm的镜像
image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/kubectl:latest
imagePullPolicy: IfNotPresent
tty: true
command:
- "cat"
env:
- name: "LANGUAGE"
value: "en_US:en"
- name: "LC_ALL"
value: "en_US.UTF-8"
- name: "LANG"
value: "en_US.UTF-8"
volumeMounts:
- name: localtime
mountPath: /etc/localtime
readOnly: false
volumes:
- name: localtime
hostPath:
path: /usr/share/zoneinfo/Asia/Shanghai
# 构建缓存的pvc,vue的项目不在单独定义缓存目录了,直接用workspaceVolume定义的pvc即可
#- name: maven-cache
# persistentVolumeClaim:
# claimName: maven-global-cache
# readOnly: false
#docker认证信息的volume
- name: docker-registry-config
configMap:
name: docker-registry-config '''
}
}

//定义一些全局环境变量
environment {
COMMIT_ID = ""
HARBOR_ADDRESS = "192.168.0.89" //Harbor 地址
REGISTRY_DIR = "ruoyi-cloud" //Harbor 的项目目录
IMAGE_NAME = "ruoyi-ui" //镜像的名称。
NAMESPACE = "ruoyi" //该应用在ruoyi 中的命名空间
TAG = "" //镜像的 Tag,在此用 BUILD_TAG+COMMIT_ID 组成
GIT_URL = "git@192.168.0.222:kubernetes/ruoyi-vue2.git" //前端代码仓库地址
}
parameters {
gitParameter(branch: '', branchFilter: 'origin/(.*)', defaultValue:'', description: 'Branch for build and deploy', name: 'BRANCH',quickFilterEnabled: false, selectedValue: 'NONE', sortMode: 'NONE',tagFilter: '*', type: 'PT_BRANCH')
}
// 接下来是拉代码的 stage,这个 stage 是一个并行的 stage,因为考虑了该流水线是手动触发还是触发
stages {
stage('拉取代码') {
steps {
script {
def branchToUse = env.gitlabBranch ?: params.BRANCH
// 加一个保护,防止两个来源都为空
if (!branchToUse) {
error "未指定构建分支,请检查触发方式或参数配置"
}
git(
url: "${GIT_URL}",
branch: branchToUse,
changelog: true,
poll: true,
credentialsId: 'gitlab-key'
)
COMMIT_ID = sh(returnStdout: true, script: "git log -n 1 --pretty=format:'%h'").trim()
TAG = "${env.BUILD_TAG}-${COMMIT_ID}"
echo "触发方式: ${env.gitlabBranch ? 'GitLab Webhook' : '手动触发'}"
echo "Branch: ${branchToUse}, Commit: ${COMMIT_ID}, Tag: ${TAG}"
}
}
}
stage('Building') {
steps {
container(name: 'build') {
sh '''
npm config set registry https://registry.npmmirror.com
npm install --legacy-peer-deps
npm run build:prod
echo "✅ 构建完成!dist 文件夹已生成"
'''
}
}
}
stage('Build for creating image') {
steps {
container(name: 'kaniko') {
sh """
executor -d ${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -c . --insecure --skip-tls-verify
"""
}
}
}
stage('部署到k8s') {
environment {
MY_KUBECONFIG = credentials('STUD_KUBECONFIG')
}
steps {
container(name: 'kubectl') {
sh """
kubectl --kubeconfig $MY_KUBECONFIG set image deployment/${IMAGE_NAME} ${IMAGE_NAME}=${HARBOR_ADDRESS}/${REGISTRY_DIR}/${IMAGE_NAME}:${TAG} -n $NAMESPACE
"""
}
}
}
}
}

前端应用构建后一般会在 dist 文件下产生 html 文件,只需要拷贝到 nginx 的根目录下即可,定义前端的Dockerfile:

1
2
3
4
5
6
7
8
9
10
11
12
13
# 基础镜像
FROM registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:1.24.0
# 删除默认的 nginx 配置
RUN rm /etc/nginx/conf.d/default.conf
# 拷贝自定义 nginx 配置
COPY nginx/nginx.conf /etc/nginx/conf.d/default.conf
# 复制html文件到路径
COPY dist/ /usr/share/nginx/html/

# 暴露端口
EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

因为在Dockerfile中单独配置了nginx.conf文件,所以还需要在仓库中添加一个nginx.conf文件:

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
# nginx.conf内容如下:
server {
listen 80;
server_name localhost;

gzip on;
gzip_min_length 1k;
gzip_comp_level 9;
gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png;
gzip_vary on;

location / {
root /usr/share/nginx/html;
try_files $uri $uri/ /index.html;
index index.html index.htm;
}

location ~ /\. {
deny all;
}

# 避免actuator暴露
if ($uri ~ "/actuator") {
return 403;
}

error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}

在执行构建前先创建一个pvc,这里单独为vue项目准备了pvc:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[root@k8s-master01 36-cicd]# cat vue2-pipeline-cache.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
#pvc指定的名字要和流水线中workspaceVolume persistentVolumeClaimWorkspaceVolume(claimName: "ruoyi-vue2-pipeline-cache", readOnly: false) 配置的claimName引用的名字保持一致
name: ruoyi-vue2-pipeline-cache
# 【重要提醒】:这里必须填写你的 Jenkins 动态 Agent Pod 所在的命名空间
# 如果你的 Jenkins 运行在 'jenkins' 命名空间,请改为 'jenkins'
namespace: default
spec:
volumeMode: Filesystem #卷模式要用文件系统,不指定默认是文件系统。 不能使用块存储
accessModes:
# CubeFS 支持多点读写,这对于并发构建非常重要,能防止卷被独占锁死
- ReadWriteMany
storageClassName: cfs-sc
resources:
requests:
# 分配 20G 给 Maven 本地仓库通常比较充裕,可根据实际团队规模调整
storage: 20Gi

创建pvc:

1
2
[root@k8s-master01 ruoyi]# kubectl create -f vue2-pipeline-cache.yaml
persistentvolumeclaim/ruoyi-vue2-pipeline-cache created

接下来在Jenkins上创建Job:任务名字定义ruoyi-ui,还是从其他job中拷贝配置


配置修改好后保存即可,接下来就可以Build发版了:


发版成功后检查容器镜像版本:

1
2
3
[root@k8s-master01 ~]# kubectl get deployments.apps -n ruoyi ruoyi-ui -oyaml|grep image
- image: 192.168.0.89/ruoyi-cloud/ruoyi-ui:jenkins-ruoyi-ui-10-bda15ef
imagePullPolicy: IfNotPresent

Harbor仓库中也已经有了镜像:


整个项目已经实现CI/CD流水线的发版!