视频教程地址：https://www.bilibili.com/video/BV1Xh4y1q7aW/

项目准备

这次我准备了一个微服务项目，是依照RuoYi-Cloud(http://doc.ruoyi.vip/ruoyi-cloud/)进行了一些修改所得到的微服务项目。重点是修改了如图根据不同环境添加了不同的配置文件：

项目代码地址为：https://gitcode.net/m0_51510236/yueyang-cloud

打成使用Docker打成镜像

我们需要将项目的各个模块分别打成一个Docker镜像。这个步骤我们需要两步，分别是准备docker仓库和打包项目并推送镜像。

准备Docker仓库

这次我们为了方便就直接使用阿里云的镜像仓库了，为其新建一个命名空间 yueyang-cloud (修改为你们的实际项目名字)，如图为这个项目的镜像专门新建一个命名空间：

如果你有私有化仓库的需求，可以参考我写的这篇文章：https://blog.csdn.net/m0_51510236/article/details/125030239：

打包项目为Docker镜像

我们需要根据RuoYi-Cloud的官方文档在打包的服务器上安装上这么三个对应版本的大包工具，分别是JDK、Maven和Node：

因为我修改了一下里面的代码，所以JDK需要 >= 11：

这是我服务器上的软件版本：

在执行打包之前，你还需要按照Docker。如果你还没有安装，那么可以参考我的这篇文章将其安装上：https://blog.csdn.net/m0_51510236/article/details/115054073。如果你已经安装上了，你可以先将几个基础镜像给拉取下来（注意修改为自己需要的版本)：

docker pull nginx:1.23.4
docker pull openjdk:11-jre
docker pull mysql:5.7.43

拉取下来后的镜像列表：

来到项目的Docker目录下可以看到有一个 yueyang.sh 脚本，这是我写的打包整个项目的脚本：

但是你需要注意修改上面这两项。注意前面的一个写好前缀就行，脚本会将项目模块名自动拼接到后面的：

执行一下它获取使用文档，可以看到脚本有那么多的阶段：

执行这行命令打包maven和vuejs项目：

./yueyang.sh package

它会用maven和nodejs打包好前后端项目（一些警告不用管它）：

然后我们再执行这行命令来移动打包好的jar文件、前端文件和数据库文件到打包目录：

./yueyang.sh move

它会将打包好的jar文件、前端文件和数据库初始化脚本的压缩包全部移动/复制到打包的目录：

然后我们执行下面这行命令即可将所有模块打成Docker镜像：

./yueyang.sh build

执行完毕后可以看到各个模块的镜像就已经打好了：

最后我们需要推送镜像，你需要先docker login。执行这行命令：

docker login --username=docker的用户名 docker服务器地址

执行如图：

然后执行下面命令就可以将镜像推送到镜像仓库了：

./yueyang.sh push

可以看到镜像已经全部推送上来了：

接下来我们需要清理构建空间，接着执行这行命令：

./yueyang.sh clean

执行如图，会调用mvn clean和删除构建空间当中的jar文件、前端文件和数据库初始化脚本压缩包并且删除构建好的镜像：

构建好的镜像也被删除了：

部署应用到k8s

首先你需要准备一个k8s集群，如图我已经准备好了一个版本为 v1.26.9 的 k8s 集群（其他版本也没问题）：

创建nfs挂载目录

因为系统当中的mysql、nacos、redis和file文件模块需要持久化的文件存储，所以我们要为这些持久化的文件存储创建目录。这次我打算使用nfs，需要准备一台nfs服务器，为了方便我就直接使用k8s的主节点来充当nfs服务器了。先来安装 nfs-utils 软件包（注意所有k8s节点都要安装）：

yum install -y nfs-utils

如图我已经安装了，如果没有安装的需要安装上：

接下来需要在nfs服务器上创建目录，分别要创建以下目录（目录路径可根据需要修改）：

• MySQL: MySQL的数据目录：/data/nfs/yueyang-cloud/mysql
• Nacos:
  • Nacos数据目录: /data/nfs/yueyang-cloud/nacos/data
  • Nacos日志目录: /data/nfs/yueyang-cloud/nacos/logs
• redis: redis数据目录: /data/nfs/yueyang-cloud/redis
• file文件模块: file文件目录: /data/nfs/yueyang-cloud/file

我们执行这两行命令创建目录：

mkdir -p /data/nfs/yueyang-cloud/{mysql,nacos,redis,file}
mkdir /data/nfs/yueyang-cloud/nacos/{logs,data}

创建目录后如图：

接下来我们需要将这些目录暴露给内网访问，先执行下面这行命令修改nfs的配置文件：

cat >> /etc/exports << EOF
/data/nfs/yueyang-cloud/mysql *(rw,sync,no_root_squash)
/data/nfs/yueyang-cloud/nacos/logs *(rw,sync,no_root_squash)
/data/nfs/yueyang-cloud/nacos/data *(rw,sync,no_root_squash)
/data/nfs/yueyang-cloud/redis *(rw,sync,no_root_squash)
/data/nfs/yueyang-cloud/file *(rw,sync,no_root_squash)
EOF

然后再执行下面这行命令开启 nfs-server 并使它开机自启动：

systemctl enable --now nfs-server

然后可以使用下面这行命令查看目录的暴露是否成功（注意修改nfs服务器地址）：

showmount -e 192.168.1.160

检查所有节点暴露的nfs目录都是正常的：

创建一些基本资源

在这个步骤当中我们需要创建命名空间、拉取镜像的secret和java运行环境的profile的configmap。因为接下来会在其他环境当中部署，所以所有的部署步骤都会以yaml资源清单文件形式进行。

创建命名空间

我决定先创建一个 yueyang-cloud 命名空间来部署所有模块。执行下面这行命令获取创建命名空间的yaml资源清单文件：

kubectl create namespace yueyang-cloud --dry-run=client --output=yaml

执行结果：

生成的yaml资源清单文件：

apiVersion: v1
kind: Namespace
metadata:name: yueyang-cloud
spec: {}

保存这个资源清单文件并执行它：

创建拉取镜像的secret

因为我们的镜像仓库都是私有的，需要带上用户名和密码才能够拉取到。所以我们需要创建一个secret来保存这些密码。执行下面这行命令生成这个secret的yaml资源清单文件：

kubectl create secret docker-registry yueyang-image-account-secret \
--namespace=yueyang-cloud --docker-server='镜像服务器地址' \
--docker-username='用户名' --docker-password='密码' --docker-email='邮箱' \
--dry-run=client --output=yaml

生成的yaml资源清单文件如图：

最终生成的文件内容：

apiVersion: v1
data:# 你的服务器地址、用户名、密码和邮箱不同生成的密码字符串也不同.dockerconfigjson: ***
kind: Secret
metadata:name: yueyang-image-account-secretnamespace: yueyang-cloud
type: kubernetes.io/dockerconfigjson

我们保存它并执行它，可以看到创建成功：

创建java运行环境的profile

来到任意一个打包的Dockerfile，可以看到我们需要指定运行的Spring环境：

所以我们最好创建一个configmap来指定这个运行时环境，执行这行命令生成对应的资源清单文件，注意环境我们指定的是 prod ：

kubectl create configmap spring-profile-cm --namespace=yueyang-cloud --from-literal=spring-profiles-active=prod --dry-run=client --output=yaml

生成结果如图：

直接保存到一个文件当中并执行它：

部署mysql

我之前写过一篇关于在Kubernetes上部署MySQL主从集群的文章，这里为了方便就使用单节点了，如果你需要主从节点可以参考我写的这篇文章：https://blog.csdn.net/m0_51510236/article/details/133145221

在推送镜像的时候已经推送了mysql镜像如图：

接下来我们分为那么几个步骤部署这个MySQL：

1. 创建持久化的pv和pvc
2. 创建mysql root密码的secret
3. 创建mysql配置文件
4. 部署有状态的MySQL

创建持久化的pv和pvc

因为我们只需要挂载mysql的数据目录到nfs当中，所以我们创建一个pv和pvc就可以了。其yaml资源清单文件如下：

apiVersion: v1
kind: PersistentVolume
metadata:name: yueyang-mysql-pv
spec:capacity:# 申请的容量，生产环境注意修改storage: 1GiaccessModes:- ReadWriteManynfs:# nfs服务器地址和目录，注意修改为自己的server: 192.168.1.160path: /data/nfs/yueyang-cloud/mysql# 存储类类型，我们使用nfsstorageClassName: "nfs"---apiVersion: v1
kind: PersistentVolumeClaim
metadata:name: yueyang-mysql-pvcnamespace: yueyang-cloud
spec:accessModes:- ReadWriteMany# 存储类类型，我们使用nfsstorageClassName: "nfs"resources:requests:# 申请的容量，生产环境注意修改storage: 1GivolumeName: yueyang-mysql-pv

直接执行它，发现pv和pvc创建成功：

创建mysql root密码的secret

MySQL的root密码我们以secret的形式储存，执行下面命令生成secret的yaml资源清单，注意后面的 root 是mysql的密码，自己环境有密码复杂度要求的注意修改：

kubectl create secret generic yueyang-mysql-password-secret --namespace=yueyang-cloud --dry-run=client --output=yaml --from-literal=mysql-root-password=root

生成结果：

apiVersion: v1
data:mysql-root-password: cm9vdA==
kind: Secret
metadata:name: yueyang-mysql-password-secretnamespace: yueyang-cloud

保存到一个文件当中并执行它：

创建mysql配置文件

因为生成环境会调整配置文件当中的一些参数，所以首先先来创建一个名字为 my.cnf 的mysql配置文件，文件内容为（下面是docker镜像当中默认的配置文件内容）：

# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/5.7/en/server-configuration-defaults.html[mysqld]
#
# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M
#
# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin
#
# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M
skip-host-cache
skip-name-resolve
datadir=/var/lib/mysql
socket=/var/run/mysqld/mysqld.sock
secure-file-priv=/var/lib/mysql-files
user=mysql# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0#log-error=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid
[client]
socket=/var/run/mysqld/mysqld.sock!includedir /etc/mysql/conf.d/
!includedir /etc/mysql/mysql.conf.d/

然后根据它生成一个configmap的yaml资源清单文件，执行下面命令生成：

kubectl create configmap yueyang-mysql-config-cm --namespace=yueyang-cloud --from-file=my.cnf --dry-run=client --output=yaml

生成后如图：

文件内容：

apiVersion: v1
data:my.cnf: |# For advice on how to change settings please see# http://dev.mysql.com/doc/refman/5.7/en/server-configuration-defaults.html[mysqld]## Remove leading # and set to the amount of RAM for the most important data# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.# innodb_buffer_pool_size = 128M## Remove leading # to turn on a very important data integrity option: logging# changes to the binary log between backups.# log_bin## Remove leading # to set options mainly useful for reporting servers.# The server defaults are faster for transactions and fast SELECTs.# Adjust sizes as needed, experiment to find the optimal values.# join_buffer_size = 128M# sort_buffer_size = 2M# read_rnd_buffer_size = 2Mskip-host-cacheskip-name-resolvedatadir=/var/lib/mysqlsocket=/var/run/mysqld/mysqld.socksecure-file-priv=/var/lib/mysql-filesuser=mysql# Disabling symbolic-links is recommended to prevent assorted security riskssymbolic-links=0#log-error=/var/log/mysqld.logpid-file=/var/run/mysqld/mysqld.pid[client]socket=/var/run/mysqld/mysqld.sock!includedir /etc/mysql/conf.d/!includedir /etc/mysql/mysql.conf.d/
kind: ConfigMap
metadata:name: yueyang-mysql-config-cmnamespace: yueyang-cloud

为了方便将其保存在与secret相同的文件当中，注意多段yaml资源清单文件用三条横杠做分隔符：

我们执行它之后可以看到configmap就创建成功了：

部署有状态的MySQL

其他的都准备好了现在就差部署MySQL了，直接上yaml资源清单文件（文件里面有详细的注释，这里不再过多赘述）：

apiVersion: v1
kind: Service
metadata:name: yueyang-mysql-svcnamespace: yueyang-cloudlabels:app: yueyang-mysql
spec:ports:- port: 3306name: mysqltargetPort: 3306# 如果需要NodePort暴露则将这里打开# nodePort: 30306# 如果需要NodePort暴露则将这里注释clusterIP: Noneselector:app: yueyang-mysql# 如果需要NodePort暴露则将这里改为NodePort# ClusterIP, NodePort, LoadBalancertype: ClusterIP# 如果需要NodePort暴露则将这里改为ClientIP# ClientIP, NonesessionAffinity: None---apiVersion: apps/v1
kind: StatefulSet
metadata:name: yueyang-mysqlnamespace: yueyang-cloud
spec:selector:matchLabels:app: yueyang-mysqlserviceName: "yueyang-mysql-svc"replicas: 1template:metadata:labels:app: yueyang-mysqlspec:terminationGracePeriodSeconds: 10containers:# 一些部署MySQL的参数- args:- --character-set-server=utf8mb4- --collation-server=utf8mb4_unicode_ci- --lower_case_table_names=1- --default-time_zone=+8:00name: mysql# 注意修改为你自己的镜像地址image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/mysql:1.0.0# 存活探针，用于检查pod是否处于存活状态livenessProbe:# 初始化后20秒开始检查initialDelaySeconds: 20# 之后每过10秒检查一次periodSeconds: 10# 检查内容为3306端口是否存活tcpSocket:port: 3306ports:- containerPort: 3306name: mysqlvolumeMounts:- name: mysql-datamountPath: /var/lib/mysql- name: mysql-confmountPath: /etc/my.cnfreadOnly: truesubPath: my.cnfenv:- name: MYSQL_ROOT_PASSWORDvalueFrom:secretKeyRef:key: mysql-root-passwordname: yueyang-mysql-password-secretimagePullSecrets:- name: yueyang-image-account-secretvolumes:- name: mysql-datapersistentVolumeClaim:claimName: yueyang-mysql-pvc- name: mysql-confconfigMap:name: yueyang-mysql-config-cmitems:- key: my.cnfmode: 0644path: my.cnf

保存之后执行它：

最后查看结果显示部署成功：

我们执行这行命令即可进入数据库内部查看：

kubectl exec -itn yueyang-cloud pod/yueyang-mysql-0 -- mysql -uroot -p

进去之后可以看到项目所需要的数据库已经成功初始化在其中了：

部署nacos

我之前写过一篇关于在Kubernetes上部署多节点nacos集群的文章，这里为了方便就使用单节点了，如果你需要多节点nacos集群可以参考我写的这篇文章：https://blog.csdn.net/m0_51510236/article/details/132802919

接下来开始部署nacos。部署nacos分为以下几个阶段：

1. 为nacos创建关于日志和数据的pv和pvc
2. 为nacos的环境变量创建comfigmap
3. 部署nacos
4. 用ingress暴露nacos

为nacos创建关于日志和数据的pv和pvc

因为需要创建关于日志和数据的两个pv和pvc，所以这个yaml资源清单文件也是有两个pv和pvc的。直接上yaml文件：

apiVersion: v1
kind: PersistentVolume
metadata:name: yueyang-nacos-logs-pv
spec:capacity:# 申请的容量，生产环境注意修改storage: 1GiaccessModes:- ReadWriteManynfs:# nfs服务器地址和目录，注意修改为自己的server: 192.168.1.160path: /data/nfs/yueyang-cloud/nacos/logs# 存储类类型，我们使用nfsstorageClassName: "nfs"---apiVersion: v1
kind: PersistentVolumeClaim
metadata:name: yueyang-nacos-logs-pvcnamespace: yueyang-cloud
spec:accessModes:- ReadWriteMany# 存储类类型，我们使用nfsstorageClassName: "nfs"resources:requests:# 申请的容量，生产环境注意修改storage: 1GivolumeName: yueyang-nacos-logs-pv---apiVersion: v1
kind: PersistentVolume
metadata:name: yueyang-nacos-data-pv
spec:capacity:# 申请的容量，生产环境注意修改storage: 1GiaccessModes:- ReadWriteManynfs:# nfs服务器地址和目录，注意修改为自己的server: 192.168.1.160path: /data/nfs/yueyang-cloud/nacos/data# 存储类类型，我们使用nfsstorageClassName: "nfs"---apiVersion: v1
kind: PersistentVolumeClaim
metadata:name: yueyang-nacos-data-pvcnamespace: yueyang-cloud
spec:accessModes:- ReadWriteMany# 存储类类型，我们使用nfsstorageClassName: "nfs"resources:requests:# 申请的容量，生产环境注意修改storage: 1GivolumeName: yueyang-nacos-data-pv

将其保存在一个文件当中之后直接执行：

为nacos的环境变量创建comfigmap

我们需要创建的configmap总共有那么几个常量：

• jvm-xmn: jvm新生区的内存大小
• jvm-xms: jvm永久区的最小大小
• jvm-xmx: jvm永久区的最大大小
• mode: nacos启动模式，因为是单点启动，所以设置为 standalone
• mysql-database-num: nacos连接数据库的数量，设置为1
• mysql-service-db-name: mysql当中nacos数据库的名字。上一个步骤当中我们部署了mysql，里面关于nacos数据库的名字为yueyang_config
• mysql-service-db-param: nacos连接数据库的参数
• mysql-service-host: mysql数据库的地址
• mysql-service-port: mysql数据库的端口
• mysql-service-user: 连接mysql的用户名
• spring-datasource-platform: nacos连接数据库的平台，只支持mysql

所以可以得出用以下命令生成configmap的yaml资源清单文件：

kubectl create configmap yueyang-nacos-cm --namespace=yueyang-cloud --dry-run=client --output=yaml \
--from-literal=jvm-xmn=64m \
--from-literal=jvm-xms=128m \
--from-literal=jvm-xmx=128m \
--from-literal=mode=standalone \
--from-literal=mysql-database-num=1 \
--from-literal=mysql-service-db-name=yueyang_config \
--from-literal=mysql-service-db-param='characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useSSL=false&serverTimezone=UTC' \
--from-literal=mysql-service-host='yueyang-mysql-0.yueyang-mysql-svc.yueyang-cloud.svc.cluster.local' \
--from-literal=mysql-service-port=3306 \
--from-literal=mysql-service-user=root \
--from-literal=spring-datasource-platform=mysql

生成的yaml文件内容（idea开发工具当中加了引号，不加也可以）：

apiVersion: v1
data:jvm-xmn: "64m"jvm-xms: "128m"jvm-xmx: "128m"mode: "standalone"mysql-database-num: "1"mysql-service-db-name: "yueyang_config"mysql-service-db-param: "characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useSSL=false&serverTimezone=UTC"mysql-service-host: "yueyang-mysql-0.yueyang-mysql-svc.yueyang-cloud.svc.cluster.local"mysql-service-port: "3306"mysql-service-user: "root"spring-datasource-platform: "mysql"
kind: ConfigMap
metadata:name: yueyang-nacos-cmnamespace: yueyang-cloud

然后可以看到创建成功：

部署nacos

我们需要部署一个有状态的Nacos应用，yaml资源清单文件如下：

apiVersion: v1
kind: Service
metadata:name: yueyang-nacos-svcnamespace: yueyang-cloudlabels:app: yueyang-nacos
spec:ports:- port: 8848name: clienttargetPort: 8848# 如果你需要使用到NodePort或LoadBalancer暴露应用，那么你可以将这里打开# nodePort: 30848- port: 9848name: client-rpctargetPort: 9848# nodePort: 30948- port: 9849name: raft-rpctargetPort: 9849# nodePort: 30849- port: 7848name: old-raft-rpctargetPort: 7848# nodePort: 30748# 如果你需要使用到NodePort或LoadBalancer暴露应用，那么你需要注释掉clusterIPclusterIP: Noneselector:app: yueyang-nacos# ClusterIP, NodePort, LoadBalancertype: ClusterIP# 如果你需要使用到NodePort或LoadBalancer暴露应用，那么你需要将这里改为ClientIP# ClientIP, NonesessionAffinity: None---apiVersion: apps/v1
kind: StatefulSet
metadata:name: yueyang-nacosnamespace: yueyang-cloud
spec:selector:matchLabels:app: yueyang-nacosserviceName: "yueyang-nacos-svc"replicas: 1template:metadata:labels:app: yueyang-nacosspec:terminationGracePeriodSeconds: 10containers:- name: nacos# 这里一个是官方镜像，一个是我拉取的官方镜像然后推送到国内阿里云的镜像# image: docker.io/nacos/nacos-server:v2.0.4image: registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/nacos-server:v2.0.4# 存活探针livenessProbe:# 通过发送http的get请求确认nacos是否存活httpGet:# 请求8848端口的/nacos/actuator/health路径，如果返回为200则证明存活path: /nacos/actuator/healthport: 8848scheme: HTTP# pod初始化完成后多久开始进行存活探针的检查，这里设置为30秒initialDelaySeconds: 30# 之后每十秒检查一次是否存活periodSeconds: 10ports:- containerPort: 8848name: client- containerPort: 9848name: client-rpc- containerPort: 9849name: raft-rpc- containerPort: 7848name: old-raft-rpcvolumeMounts:# 挂载数据目录- name: nacos-datamountPath: /home/nacos/data# 挂载日志目录- name: nacos-logsmountPath: /home/nacos/logsenv:# 引用ConfigMap里面的各个属性- name: JVM_XMNvalueFrom:configMapKeyRef:key: jvm-xmnname: yueyang-nacos-cm- name: JVM_XMSvalueFrom:configMapKeyRef:key: jvm-xmsname: yueyang-nacos-cm- name: JVM_XMXvalueFrom:configMapKeyRef:key: jvm-xmxname: yueyang-nacos-cm- name: MODEvalueFrom:configMapKeyRef:key: modename: yueyang-nacos-cm- name: MYSQL_DATABASE_NUMvalueFrom:configMapKeyRef:key: mysql-database-numname: yueyang-nacos-cm- name: MYSQL_SERVICE_DB_NAMEvalueFrom:configMapKeyRef:key: mysql-service-db-namename: yueyang-nacos-cm- name: MYSQL_SERVICE_DB_PARAMvalueFrom:configMapKeyRef:key: mysql-service-db-paramname: yueyang-nacos-cm- name: MYSQL_SERVICE_HOSTvalueFrom:configMapKeyRef:key: mysql-service-hostname: yueyang-nacos-cm# 数据库的密码引用之前为MySQL创建的Secret- name: MYSQL_SERVICE_PASSWORDvalueFrom:secretKeyRef:key: mysql-root-passwordname: yueyang-mysql-password-secret- name: MYSQL_SERVICE_PORTvalueFrom:configMapKeyRef:key: mysql-service-portname: yueyang-nacos-cm- name: MYSQL_SERVICE_USERvalueFrom:configMapKeyRef:key: mysql-service-username: yueyang-nacos-cm- name: SPRING_DATASOURCE_PLATFORMvalueFrom:configMapKeyRef:key: spring-datasource-platformname: yueyang-nacos-cmvolumes:# 使用刚刚创建的数据目录的pvc- name: nacos-datapersistentVolumeClaim:claimName: yueyang-nacos-data-pvc# 使用刚刚创建的日志目录的pvc- name: nacos-logspersistentVolumeClaim:claimName: yueyang-nacos-logs-pvc

接下来根据这个资源文件部署引用：

用ingress暴露nacos

接下来我们需要暴露nacos给我本机访问，我打算采取ingress的方案。

我之前写过ingress相关的文章：

https: https://blog.csdn.net/m0_51510236/article/details/132563351

http: https://blog.csdn.net/m0_51510236/article/details/132536519

同时也有一篇关于自签名https证书的文章：https://blog.csdn.net/m0_51510236/article/details/124676341

这里ingress的搭建步骤就不再过多赘述，当然代码仓库里面我也已经准备好了关于ingress-nginx和metallb的yaml文件，但是要注意的是我准备的是ingress1.8.2的版本，只兼容1.27,1.26, 1.25, 1.24等几个版本的kubernetes，如果是更低的版本，那么需要参考我上面提到的文章。yaml资源清单文件在other文件夹当中：

我已经在Kubernetes集群上安装好了一个nginx类型的ingress：

接下来开始创建用于https的secret，可以看到我已经准备好了ssl证书：

接下来我们执行这行命令生成ssl的yaml资源清单文件（注意修改自己的证书文件）：

kubectl create secret tls yueyang-nacos-tls-secret --namespace=yueyang-cloud --dry-run=client --output=yaml --cert=nacos.yueyang.city.pem --key=nacos.yueyang.city.key

可以看到我们已经成功生成了对于的资源清单文件：

然后我们执行这行命令生成暴露nacos的ingress资源清单文件：

kubectl create ingress yueyang-nacos-ingress --namespace=yueyang-cloud --dry-run=client --output=yaml --class=nginx --rule="nacos.yueyang.city/*=yueyang-nacos-svc:8848,tls=yueyang-nacos-tls-secret"

注意后面的 --rule 选项的规则 域名/*=服务名:端口,tls=ssl证书的secret。接下来查看生成结果，可以看到生成成功：

两段yaml写在一个文件当中注意中间的分割鞋是三个横杠：

然后创建它，可以看到secret和ingress都创建成功：

之后注意将域名给解析道后面的IP地址上：

确定域名解析IP地址正确：

然后我们就可以通过域名访问nacos了：

部署redis

我之前写过一篇关于在Kubernetes上部署多主多从的redis集群的文章，这里为了方便就使用单节点了，如果你需要多主多从的redis集群可以参考我写的这篇文章：https://blog.csdn.net/m0_51510236/article/details/132744782

接下来开始部署redis。部署redis分为以下几个阶段：

1. 创建用于存放redis数据的pv和pvc
2. 创建redis配置文件和ConfigMap
3. 部署redis

创建用于存放redis数据的pv和pvc

因为我们只需要挂载redis的数据目录到nfs当中，所以我们创建一个pv和pvc就可以了。其yaml资源清单文件如下：

apiVersion: v1
kind: PersistentVolume
metadata:name: yueyang-redis-pv
spec:capacity:# 申请的容量，生产环境注意修改storage: 1GiaccessModes:- ReadWriteManynfs:# nfs服务器地址和目录，注意修改为自己的server: 192.168.1.160path: /data/nfs/yueyang-cloud/redis# 存储类类型，我们使用nfsstorageClassName: "nfs"---apiVersion: v1
kind: PersistentVolumeClaim
metadata:name: yueyang-redis-pvcnamespace: yueyang-cloud
spec:accessModes:- ReadWriteManystorageClassName: "nfs"resources:requests:# 申请的容量，生产环境注意修改storage: 1Gi# 存储类类型，我们使用nfsvolumeName: yueyang-redis-pv

将它保存到一个文件当中并执行它，可以看到创建成功：

创建redis配置文件和ConfigMap

先创建一个redis.conf配置文件，其中文件内容为：

# 关闭保护模式
protected-mode no# redis链接密码，如果需要密码，那么请取消注释
# requirepass redis# 日志级别
loglevel warning# 日志存放目录
logfile "/data/redis.log"# 数据文件目录
dir /data
dbfilename dump.rdb# 数据库数量
databases 16# 保存数据库到数据文件
save 900 1
save 300 10
save 60 10000

然后执行这行命令生成对应的configmap：

kubectl create configmap yueyang-redis-config-cm --namespace=yueyang-cloud --from-file=redis.conf --dry-run=client --output=yaml

生成的内容：

apiVersion: v1
data:redis.conf: |# 关闭保护模式protected-mode no# redis链接密码# requirepass redis# 日志级别loglevel warning# 日志存放目录logfile "/data/redis.log"# 数据文件目录dir /datadbfilename dump.rdb# 数据库数量databases 16# 保存数据库到数据文件save 900 1save 300 10save 60 10000
kind: ConfigMap
metadata:name: yueyang-redis-config-cmnamespace: yueyang-cloud

直接根据这个资源清单文件创建资源，然后查看结果，可以看到configmap创建成功：

部署redis

现在需要部署一个有状态的redis应用，部署的yaml资源清单文件：

apiVersion: v1
kind: Service
metadata:name: yueyang-redis-svcnamespace: yueyang-cloudlabels:app: yueyang-redis
spec:ports:- port: 6379name: redistargetPort: 6379# 如果需要NodePort暴露则将这里打开# nodePort: 30379# 如果需要NodePort暴露则将这里注释clusterIP: Noneselector:app: yueyang-redis# 如果需要NodePort暴露则将这里改为NodePort# ClusterIP, NodePort, LoadBalancertype: ClusterIP# 如果需要NodePort暴露则将这里改为ClientIP# ClientIP, NonesessionAffinity: None---apiVersion: apps/v1
kind: StatefulSet
metadata:name: yueyang-redisnamespace: yueyang-cloud
spec:selector:matchLabels:app: yueyang-redisserviceName: "yueyang-redis-svc"replicas: 1template:metadata:labels:app: yueyang-redisspec:terminationGracePeriodSeconds: 10containers:# 启动命令，使用指定配置文件启动- command:- "redis-server"- "/usr/local/etc/redis.conf"name: redis# 这里一个是官方镜像，一个是我拉取的官方镜像然后推送到国内阿里云的镜像# image: docker.io/library/redis:5.0.14image: registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/redis:5.0.14# 存活探针livenessProbe:# pod初始化完成后20秒开始检测initialDelaySeconds: 20# 之后每隔10秒检查一次periodSeconds: 10# 检查的流程是用tcp协议去查看6379端口是否存活tcpSocket:port: 6379ports:- containerPort: 6379name: redisvolumeMounts:# 挂载数据目录- name: redis-datamountPath: /data# 挂载配置文件- name: redis-configmountPath: /usr/local/etcreadOnly: truevolumes:# 挂载数据目录，使用之前创建的pvc- name: redis-datapersistentVolumeClaim:claimName: yueyang-redis-pvc# 挂载配置文件，引用之前创建的ConfigMap- name: redis-configconfigMap:name: yueyang-redis-config-cmitems:- key: redis.confpath: redis.conf

然后直接执行这个文件，可以看到redis部署成功：

部署sentinel

镜像准备

ruoyi-cloud需要使用到sentinel进行熔断限流，因为官方没有提供sentinel的镜像，所以我们只能自己制作，jar包下载地址为：https://github.com/alibaba/Sentinel/releases/download/1.8.6/sentinel-dashboard-1.8.6.jar，然后对应的Dockerfile：

FROM openjdk:11-jre# 作者
LABEL org.opencontainers.image.authors="XiaoHH <xiaohh@yueyang.city>"# jar 包下载地址：https://github.com/alibaba/Sentinel/releases/download/1.8.6/sentinel-dashboard-1.8.6.jar
# 将可执行的jar包放到容器当中去
ADD sentinel-dashboard-1.8.6.jar app.jar# 设置暴露的端口
ENV SERVER_PORT=8080
ENV API_PORT=8719# 暴露8080端口
EXPOSE 8080
EXPOSE 8719# JVM 调优参数
ENV JAVA_OPTION="-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"# JVM 内存默认值
ENV XMX=2g
ENV XMS=2g
ENV XMN=1g# 设置sentinel的用户名和密码
ENV SENTINEL_USERNAME="sentinel"
ENV SENTINEL_PASSWORD="sentinel"# 运行程序
ENTRYPOINT ["sh", "-c", "java -Djava.security.egd=file:/dev/./urandom -jar -Dsentinel.dashboard.auth.username=${SENTINEL_USERNAME} -Dsentinel.dashboard.auth.password=${SENTINEL_PASSWORD} -Xmx${XMX} -Xms${XMS} -Xmn${XMN} ${JAVA_OPTION} -Dserver.port=${SERVER_PORT} -Dcsp.sentinel.api.port=${API_PORT} /app.jar"]

我已经制作好了一个Sentinel镜像，你们可以直接使用。执行下面命令可以拉取这个镜像：

docker pull registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/sentinel:1.8.6

创建Sentinel的ConfigMap

可以看到镜像当中有一些环境变量，我们定义一个ConfigMap来存储它。执行下面这行命令生成对应ConfigMap的yaml资源清单文件：

kubectl create configmap yueyang-sentinel-cm --namespace=yueyang-cloud --dry-run=client --output=yaml \
--from-literal=api-port=8719 \
--from-literal=java-option='-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC' \
--from-literal=server-port=8718 \
--from-literal=xmn=64m \
--from-literal=xms=128m \
--from-literal=xmx=128m

生成结果：

apiVersion: v1
data:api-port: "8719"java-option: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"server-port: "8718"xmn: "64m"xms: "128m"xmx: "128m"
kind: ConfigMap
metadata:name: yueyang-sentinel-cmnamespace: yueyang-cloud

直接执行这个文件，可以看到创建成功：

创建secret

上一步可以看到sentinel的用户名和密码还没有创建，我打算用secret来存储sentinel的用户名和密码。直接执行下面这行命令生成这个secret的yaml资源清单文件（⚠️生产环境注意修改sentinel的用户名和密码）：

kubectl create secret generic yueyang-sentinel-password-secret --namespace=yueyang-cloud --dry-run=client --output=yaml \
--from-literal=sentinel-password=sentinel \
--from-literal=sentinel-username=sentinel

生成结果：

apiVersion: v1
data:sentinel-password: c2VudGluZWw=sentinel-username: c2VudGluZWw=
kind: Secret
metadata:name: yueyang-sentinel-password-secretnamespace: yueyang-cloud

直接执行这个文件可以看到secret创建成功：

部署sentinel

我们可以直接执行下面两行命令去生成部署sentinel的yaml资源清单文件：

kubectl create deployment yueyang-sentinel-deploy --namespace=yueyang-cloud --dry-run=client --output=yaml \
--image='registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/sentinel:1.8.6' --replicas=1 --port=8718
kubectl expose deployment yueyang-sentinel-deploy --namespace=yueyang-cloud --dry-run=client --output=yaml \
--name=yueyang-sentinel-svc --port=8718 --target-port=8718 --protocol=TCP --type='ClusterIP'

因为生成的文件还需要经过修改，所以这里直接贴上修改后的yaml资源清单文件：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-sentinel-deployname: yueyang-sentinel-deploynamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-sentinel-deploystrategy: {}template:metadata:labels:app: yueyang-sentinel-deployspec:containers:- image: registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/sentinel:1.8.6name: sentinel# 存活探针livenessProbe:# 使用http的get请求判断pod是否存活，请求8719端口的/clusterNode判断pod是否存活httpGet:path: /clusterNodeport: 8719scheme: HTTP# 在pod初始化完毕20秒后再开始进行存活探针initialDelaySeconds: 20# 之后每隔10秒检查一下应用是否存活periodSeconds: 10ports:- containerPort: 8718name: dashboardprotocol: TCP- containerPort: 8719name: apiprotocol: TCPenv:# 引用configmap当中各类配置- name: XMXvalueFrom:configMapKeyRef:key: xmxname: yueyang-sentinel-cm- name: XMSvalueFrom:configMapKeyRef:key: xmsname: yueyang-sentinel-cm- name: XMNvalueFrom:configMapKeyRef:key: xmnname: yueyang-sentinel-cm- name: API_PORTvalueFrom:configMapKeyRef:key: api-portname: yueyang-sentinel-cm- name: SERVER_PORTvalueFrom:configMapKeyRef:key: server-portname: yueyang-sentinel-cm- name: JAVA_OPTIONvalueFrom:configMapKeyRef:key: java-optionname: yueyang-sentinel-cm# 引用secret里面的用户名和密码- name: SENTINEL_USERNAMEvalueFrom:secretKeyRef:key: sentinel-usernamename: yueyang-sentinel-password-secret- name: SENTINEL_PASSWORDvalueFrom:secretKeyRef:key: sentinel-passwordname: yueyang-sentinel-password-secretresources: {}---apiVersion: v1
kind: Service
metadata:labels:app: yueyang-sentinel-deployname: yueyang-sentinel-svcnamespace: yueyang-cloud
spec:ports:- name: dashboardport: 8718protocol: TCPtargetPort: 8718# nodePort: 30718- name: apiport: 8719protocol: TCPtargetPort: 8719# nodePort: 30719selector:app: yueyang-sentinel-deploy# ClusterIP, NodePort, LoadBalancertype: ClusterIP

然后我们直接执行这个yaml资源清单文件，可以看到sentinel部署成功：

使用ingress暴露sentinel

因为有在本地访问sentinel控制台的需求，所以先准备好ssl证书，然后根据证书创建secret。如图我已将ssl证书准备完毕了：

执行下面命令创建对应的secret的yaml资源清单文件：

kubectl create secret tls yueyang-sentinel-tls-secret --namespace=yueyang-cloud --dry-run=client --output=yaml --cert=sentinel.yueyang.city.pem --key=sentinel.yueyang.city.key

资源清单文件生成如图：

然后我们根据这个secret生成ingress的yaml资源清单文件，执行这行命令：

kubectl create ingress yueyang-sentinel-ingress --namespace=yueyang-cloud --dry-run=client --output=yaml --class=nginx --rule="sentinel.yueyang.city/*=yueyang-sentinel-svc:8718,tls=yueyang-sentinel-tls-secret"

生成如图：

最后保存在一个文件当中并执行它们，可以看到ingress创建成功：

最后我们需要保证域名解析正确：

然后我们可以直接通过浏览器访问这个域名就能访问到sentinel了：

部署file模块

创建持久化的pv和pvc

把所有的业务模块中file模块放在最前面将是因为这个模块需要用到nfs文件存储。先将pv和pvc创建好：

apiVersion: v1
kind: PersistentVolume
metadata:name: yueyang-file-pv
spec:capacity:# 申请的容量，生产环境注意修改storage: 1GiaccessModes:- ReadWriteManynfs:# nfs服务器地址和目录，注意修改为自己的server: 192.168.1.160path: /data/nfs/yueyang-cloud/file# 存储类类型，我们使用nfsstorageClassName: "nfs"---apiVersion: v1
kind: PersistentVolumeClaim
metadata:name: yueyang-file-pvcnamespace: yueyang-cloud
spec:accessModes:- ReadWriteMany# 存储类类型，我们使用nfsstorageClassName: "nfs"resources:requests:# 申请的容量，生产环境注意修改storage: 1GivolumeName: yueyang-file-pv

执行之后可以看到创建成功：

部署file应用

可以用以下命令生成部署file模块的yaml资源清单文件的框架：

kubectl create deployment yueyang-file-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/file:1.0.0' --replicas=1 --port=10020

我们先来看看配置中心file模块的配置，可以看到文件上传地址为 data/file 所以需要将这个目录挂载到nfs上：

直接上修改过后的yaml资源清单文件：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-file-deploymentname: yueyang-file-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-file-deploymentstrategy: { }template:metadata:labels:app: yueyang-file-deploymentspec:imagePullSecrets:- name: yueyang-image-account-secretcontainers:- env:# 运行时环境，引用一开始创建的configmap，值为prod- name: SPRING_PROFILES_ACTIVEvalueFrom:configMapKeyRef:name: spring-profile-cmkey: spring-profiles-active# 设置一些jvm调优参数- name: JAVA_OPTIONvalue: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"- name: XMXvalue: "128m"- name: XMSvalue: "128m"- name: XMNvalue: "64m"image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/file:1.0.0name: file# 存活探针livenessProbe:# 发送http get请求到10020端口的/actuator/health路径检查pod是否健康httpGet:path: /actuator/healthport: 10020scheme: HTTP# pod初始化完毕20秒之后再开始initialDelaySeconds: 20# 之后每10秒进行一次健康检查periodSeconds: 10ports:- containerPort: 10020resources: { }# 挂载上传文件的目录volumeMounts:- mountPath: /data/filename: file-datavolumes:# 定义file-data，使用上一步创建的file模块的pvc- name: file-datapersistentVolumeClaim:claimName: yueyang-file-pvc

直接执行这个资源清单文件，可以看到file模块部署成功：

来到注册中心列表，可以看到file模块已经成功注册：

部署gateway

接下来部署gateway网关模块，这个模块总共需要部署两个资源：deploy和service。

部署gateway的deploy

可以使用这行命令创建部署gateway deployment的yaml资源清单文件的架构：

kubectl create deployment yueyang-gateway-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/gateway:1.0.0' --replicas=1 --port=8080

执行结果如图：

生成这个yaml资源清单文件之后还需要加入包括运行时环境、jvm调优参数、存活探针等内容。还有因为私有化镜像仓库，所以还需要加入拉取镜像时候带上的secret。修改之后的内容：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-gateway-deploymentname: yueyang-gateway-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-gateway-deploymentstrategy: { }template:metadata:labels:app: yueyang-gateway-deploymentspec:# 拉取镜像需要使用到的secretimagePullSecrets:- name: yueyang-image-account-secretcontainers:- env:# 运行时环境，引用一开始创建的configmap，值为prod- name: SPRING_PROFILES_ACTIVEvalueFrom:configMapKeyRef:name: spring-profile-cmkey: spring-profiles-active# 设置一些jvm调优参数- name: JAVA_OPTIONvalue: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"- name: XMXvalue: "128m"- name: XMSvalue: "128m"- name: XMNvalue: "64m"image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/gateway:1.0.0name: gateway# 存活探针livenessProbe:# 发送http get请求到8080端口的/actuator/health路径检查pod是否健康httpGet:path: /actuator/healthport: 8080scheme: HTTP# pod初始化完毕20秒之后再开始initialDelaySeconds: 20# 之后每10秒进行一次健康检查periodSeconds: 10ports:- containerPort: 8080resources: { }

修改完成之后直接执行，可以看到gateway部署成功：

并且nacos注册中心当中也有了gateway的注册内容：

创建gateway的service

可以通过以下命令创建暴露gateway的service的yaml资源文件清单：

kubectl expose deployment yueyang-gateway-deployment --name=yueyang-gateway-svc --port=8080 --target-port=8080 --protocol=TCP --type=ClusterIP --namespace=yueyang-cloud --dry-run=client --output=yaml

生成结果：

apiVersion: v1
kind: Service
metadata:labels:app: yueyang-gateway-deploymentname: yueyang-gateway-svcnamespace: yueyang-cloud
spec:ports:- port: 8080protocol: TCPtargetPort: 8080selector:app: yueyang-gateway-deploymenttype: ClusterIP

直接执行这个文件，可以看到service暴露成功：

因为并不需要再外界访问gateway，所以gateway只需要内部暴露就可以了。

部署system模块

创建system模块的deploy

system模块只需要创建一个deployment即可，可以使用下面这行命令创建system模块的yaml资源清单文件的框架：

kubectl create deployment yueyang-system-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/system:1.0.0' --replicas=1 --port=10050

生成如图：

然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-system-deploymentname: yueyang-system-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-system-deploymentstrategy: { }template:metadata:labels:app: yueyang-system-deploymentspec:# 拉取镜像的secretimagePullSecrets:- name: yueyang-image-account-secretcontainers:- env:# 运行时环境，引用一开始创建的configmap，值为prod- name: SPRING_PROFILES_ACTIVEvalueFrom:configMapKeyRef:name: spring-profile-cmkey: spring-profiles-active# 设置一些jvm调优参数- name: JAVA_OPTIONvalue: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"- name: XMXvalue: "128m"- name: XMSvalue: "128m"- name: XMNvalue: "64m"image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/system:1.0.0name: system# 存活探针livenessProbe:# 发送http get请求到10050端口的/actuator/health路径检查pod是否健康httpGet:path: /actuator/healthport: 10050scheme: HTTP# pod初始化完毕20秒之后再开始initialDelaySeconds: 20# 之后每10秒进行一次健康检查periodSeconds: 10ports:- containerPort: 10050resources: { }

保存到一个文件当中后执行它，可以看到system模块部署成功：

nacos注册中心当中也注册成功：

部署auth模块

创建auth模块的deploy

auth模块只需要创建一个deployment即可，可以使用下面这行命令创建auth模块的yaml资源清单文件的框架：

kubectl create deployment yueyang-auth-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/auth:1.0.0' --replicas=1 --port=10010

生成如图：

然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-auth-deploymentname: yueyang-auth-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-auth-deploymentstrategy: { }template:metadata:labels:app: yueyang-auth-deploymentspec:# 拉取镜像的secretimagePullSecrets:- name: yueyang-image-account-secretcontainers:- env:# 运行时环境，引用一开始创建的configmap，值为prod- name: SPRING_PROFILES_ACTIVEvalueFrom:configMapKeyRef:name: spring-profile-cmkey: spring-profiles-active# 设置一些jvm调优参数- name: JAVA_OPTIONvalue: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"- name: XMXvalue: "128m"- name: XMSvalue: "128m"- name: XMNvalue: "64m"image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/auth:1.0.0name: auth# 存活探针livenessProbe:# 发送http get请求到10010端口的/actuator/health路径检查pod是否健康httpGet:path: /actuator/healthport: 10010scheme: HTTP# pod初始化完毕20秒之后再开始initialDelaySeconds: 20# 之后每10秒进行一次健康检查periodSeconds: 10ports:- containerPort: 10010resources: { }

保存到一个文件当中后执行它，可以看到auth模块部署成功：

nacos注册中心当中也注册成功：

部署前端应用

ruoyi-cloud要求的小的服务器数量已经满足了

前端配置文件

前端应用其实就是一个携带了前端代码的nginx镜像。查看一下代码当中nginx配置文件，注意接口和文件系统部分要代理到后端的gateway上（service域名格式是：service名字.命名空间名字.svc.cluster.local）：

尝试使用k8s集群内部的dns解析一下这个地址查看是否正确：

创建前端项目的deploy

在推送镜像的步骤当中已经推送了前端打包好的镜像，如图名字为ui：

接下来可以使用这条命令生成部署前端deployment的yaml资源清单文件的框架：

kubectl create deployment yueyang-ui-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/ui:1.0.0' --replicas=1 --port=80

因为是前端项目，所以没有那么多的调优参数和环境参数，只需要加上一个拉取镜像的secret即可。顺便再加一个存活探针。修改后的yaml：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-ui-deploymentname: yueyang-ui-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-ui-deploymentstrategy: { }template:metadata:labels:app: yueyang-ui-deploymentspec:# 拉取镜像的secretimagePullSecrets:- name: yueyang-image-account-secretcontainers:- image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/ui:1.0.0name: ui# 存活探针livenessProbe:# 使用http get请求80的根目录，查看是否存活httpGet:path: /port: 80scheme: HTTP# pod初始化完毕20秒后再进行存活检查initialDelaySeconds: 20# 之后每隔10秒检查一次periodSeconds: 10ports:- containerPort: 80resources: { }

保存到一个文件当中之后直接执行，可以看到创建成功：

创建前端项目的service

因为前端项目是要暴露给外界访问的，所以需要为它暴露一个service(服务)。可以直接使用以下命令生成这个service的yaml资源清单文件：

kubectl expose deployment yueyang-ui-deployment --name=yueyang-ui-svc --port=80 --target-port=80 --protocol=TCP --type=ClusterIP --namespace=yueyang-cloud --dry-run=client --output=yaml

生成的文件如下：

apiVersion: v1
kind: Service
metadata:labels:app: yueyang-ui-deploymentname: yueyang-ui-svcnamespace: yueyang-cloud
spec:ports:- port: 80protocol: TCPtargetPort: 80selector:app: yueyang-ui-deploymenttype: ClusterIP

直接执行这个文件，可以看到service创建成功：

创建前端项目的ingress

上一个步骤暴露了前端项目的service，这个步骤需要将service交给ingress给外界暴露。首先先准备ssl域名证书，如图我已经准备好了域名证书：

现在就根据这个域名证书创建一个类型为tls的secret。可以根据这行命令生成secret的yaml资源清单文件：

kubectl create secret tls yueyang-ui-tls-secret --namespace=yueyang-cloud --dry-run=client --output=yaml --cert=cloud.yueyang.city.pem --key=cloud.yueyang.city.key

生成了如图：

直接将这些东西保存到一个文件当中，然后再执行以下命令生成ingress的yaml资源清单文件：

kubectl create ingress yueyang-ui-ingress --namespace=yueyang-cloud --dry-run=client --output=yaml --class=nginx --rule="cloud.yueyang.city/*=yueyang-ui-svc:80,tls=yueyang-ui-tls-secret"

生成内容如下：

保存之后直接执行，可以看到创建成功：

然后确定域名解析正常：

然后就可以直接通过域名访问系统了：

通过默认用户名和密码登录就可以访问系统了：

环境迁移

如果你本地环境较高可以跳过这个步骤。

创建集群

因为我本机的虚拟机无法满足配置要求了，所以我打算使用阿里云的容器服务Kubernetes。也可以使用其他的，如果本地环境服务器配置允许，那么可以不使用云Kubernetes服务：

选择地域和Kubernetes版本：

注意我们需要在本地远程连接Kubernetes的话一定要勾选使用EIP暴露API Server哦：

注意选择三台4c16g和40g硬盘的工作节点，生产环境根据自己的需要选择哦：

因为本地使用的是nginx-ingress，所以这里也选择nginx-ingress：

最后确认好配置和费用之后点击创建集群：

创建集群大概需要几分钟时间：

远程连接集群

在集群当中点击详情：

然后点击链接信息->复制：

将其保存在一个文件当中：

配置好kubectl的配置文件环境变量，具体内容参考我写的本地kubectl的文章：https://blog.csdn.net/m0_51510236/article/details/133710224：

然后可以获取阿里云的节点信息：

创建pv和pvc

需要将nacos、redis、mysql和file模块的pv和pvc给创建出来。首先我们要新建命名空间，在命令行中执行我们之前保存的命名空间的yaml资源清单文件，就可以看到命名空间创建成功：

在集群详情首页点击存储和存储卷，然后点击创建，按照提示创建出pv：

依次点击存储声明->选择刚创建的命名空间->创建：

然后按照提示输入pvc信息之后点击创建：

按照上面步骤将其他几个pv和pvc创建出来：

然后在命令行当中也能查看到这些pv和pvc：

修改拉取镜像的secret

因为镜像和集群都在阿里云深圳节点上，并且阿里云给我们提供了内网拉取镜像的地址。随便打开一个仓库查看内网地址：

需要将拉取镜像的secret地址改为 registry-vpc.cn-shenzhen.aliyuncs.com (地域不同地址不同)，执行以下命令生成新的secret并更新保存在secret文件当中：

kubectl create secret docker-registry yueyang-image-account-secret --namespace=yueyang-cloud --docker-server='registry-vpc.cn-shenzhen.aliyuncs.com' --docker-username='用户名' --docker-password='密码' --docker-email='邮箱' --dry-run=client --output=yaml

生成如图：

将其更新在文件当中之后执行可以看到创建成功：

部署应用

首先需要将所有的镜像当中的拉取镜像地址改为私网地址，这样拉取镜像会更快：

然后可以按照需求修改一下各个模块的内存大小：

然后执行除了pv和pvc以外的所有yaml文件，编写一个for循环一次性执行：

#!/bin/bash
yaml_list=$(find . -name '*.yaml' | grep -v 'pv-pvc.yaml' | grep -v 'other' | grep -v 'namespace.yaml' | grep -v 'yueyang-image-account-secret.yaml')
for yaml_file in ${yaml_list}; dokubectl apply -f "${yaml_file}"
done

执行这个脚本，可以看到所有资源都已经创建好了：

内网创建非常快，可以看到资源已经创建完毕：

可以看到ingress也创建好了：

然后确定域名解析没问题：

然后配置中心服务也注册成功：

系统也能访问：

部署job模块

创建job模块的deploy

job模块只需要创建一个deployment即可，可以使用下面这行命令创建job模块的yaml资源清单文件的框架：

kubectl create deployment yueyang-job-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/job:1.0.0' --replicas=1 --port=10040

内网：

kubectl create deployment yueyang-job-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/job:1.0.0' --replicas=1 --port=10040

生成如图：

然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-job-deploymentname: yueyang-job-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-job-deploymentstrategy: { }template:metadata:labels:app: yueyang-job-deploymentspec:# 拉取镜像的secretimagePullSecrets:- name: yueyang-image-account-secretcontainers:- env:# 运行时环境，引用一开始创建的configmap，值为prod- name: SPRING_PROFILES_ACTIVEvalueFrom:configMapKeyRef:name: spring-profile-cmkey: spring-profiles-active# 设置一些jvm调优参数- name: JAVA_OPTIONvalue: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"- name: XMXvalue: "1g"- name: XMSvalue: "1g"- name: XMNvalue: "512m"image: registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/job:1.0.0name: job# 存活探针livenessProbe:# 发送http get请求到10040端口的/actuator/health路径检查pod是否健康httpGet:path: /actuator/healthport: 10040scheme: HTTP# pod初始化完毕20秒之后再开始initialDelaySeconds: 20# 之后每10秒进行一次健康检查periodSeconds: 10ports:- containerPort: 10040resources: { }

保存到一个文件当中后执行它，可以看到job模块部署成功：

nacos注册中心当中也注册成功：

同时也能在系统当中的定时任务列表查看到已有的定时任务了：

部署gen模块

创建gen模块的deploy

gen模块只需要创建一个deployment即可，可以使用下面这行命令创建gen模块的yaml资源清单文件的框架：

kubectl create deployment yueyang-gen-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/gen:1.0.0' --replicas=1 --port=10030

内网：

kubectl create deployment yueyang-gen-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/gen:1.0.0' --replicas=1 --port=10030

生成如图：

然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-gen-deploymentname: yueyang-gen-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-gen-deploymentstrategy: { }template:metadata:labels:app: yueyang-gen-deploymentspec:# 拉取镜像的secretimagePullSecrets:- name: yueyang-image-account-secretcontainers:- env:# 运行时环境，引用一开始创建的configmap，值为prod- name: SPRING_PROFILES_ACTIVEvalueFrom:configMapKeyRef:name: spring-profile-cmkey: spring-profiles-active# 设置一些jvm调优参数- name: JAVA_OPTIONvalue: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"- name: XMXvalue: "1g"- name: XMSvalue: "1g"- name: XMNvalue: "512m"image: registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/gen:1.0.0name: gen# 存活探针livenessProbe:# 发送http get请求到10030端口的/actuator/health路径检查pod是否健康httpGet:path: /actuator/healthport: 10030scheme: HTTP# pod初始化完毕20秒之后再开始initialDelaySeconds: 20# 之后每10秒进行一次健康检查periodSeconds: 10ports:- containerPort: 10030resources: { }

保存到一个文件当中后执行它，可以看到gen模块部署成功：

nacos注册中心当中也注册成功：

同时也能在系统当中的代码生成功能当中去使用代码生成了：

部署monitor模块

这也是整个系统最后一个模块了。这个模块需要部署deploy、service和ingress，因为要暴露给外部访问。

创建monitor模块的deploy

可以使用下面这行命令创建monitor模块的yaml资源清单文件的框架：

kubectl create deployment yueyang-monitor-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/monitor:1.0.0' --replicas=1 --port=8088

内网：

kubectl create deployment yueyang-monitor-deployment --namespace=yueyang-cloud --dry-run=client --output=yaml --image='registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/monitor:1.0.0' --replicas=1 --port=8088

生成如图：

然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：

apiVersion: apps/v1
kind: Deployment
metadata:labels:app: yueyang-monitor-deploymentname: yueyang-monitor-deploymentnamespace: yueyang-cloud
spec:replicas: 1selector:matchLabels:app: yueyang-monitor-deploymentstrategy: { }template:metadata:labels:app: yueyang-monitor-deploymentspec:# 拉取镜像的secretimagePullSecrets:- name: yueyang-image-account-secretcontainers:- env:# 运行时环境，引用一开始创建的configmap，值为prod- name: SPRING_PROFILES_ACTIVEvalueFrom:configMapKeyRef:name: spring-profile-cmkey: spring-profiles-active# 设置一些jvm调优参数- name: JAVA_OPTIONvalue: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC"- name: XMXvalue: "1g"- name: XMSvalue: "1g"- name: XMNvalue: "512m"image: registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/monitor:1.0.0name: monitor# 存活探针livenessProbe:# 发送http get请求到8088端口的/actuator/health路径检查pod是否健康httpGet:path: /actuator/healthport: 8088scheme: HTTP# pod初始化完毕20秒之后再开始initialDelaySeconds: 20# 之后每10秒进行一次健康检查periodSeconds: 10ports:- containerPort: 8088resources: { }

保存到一个文件当中后执行它，可以看到monitor模块部署成功：

nacos注册中心当中也注册成功：

创建monitor模块的service

因为monitor模块是要暴露给外界访问的，所以需要为它暴露一个service(服务)。可以直接使用以下命令生成这个service的yaml资源清单文件：

kubectl expose deployment yueyang-monitor-deployment --name=yueyang-monitor-svc --port=8088 --target-port=8088 --protocol=TCP --type=ClusterIP --namespace=yueyang-cloud --dry-run=client --output=yaml

生成的文件如下：

apiVersion: v1
kind: Service
metadata:labels:app: yueyang-monitor-deploymentname: yueyang-monitor-svcnamespace: yueyang-cloud
spec:ports:- port: 8088protocol: TCPtargetPort: 8088selector:app: yueyang-monitor-deploymenttype: ClusterIP

直接执行这个文件，可以看到service创建成功：

创建monitor模块的ingress

上一个步骤暴露了前端项目的service，这个步骤需要将service交给ingress给外界暴露。首先先准备ssl域名证书，如图我已经准备好了域名证书：

现在就根据这个域名证书创建一个类型为tls的secret。可以根据这行命令生成secret的yaml资源清单文件：

kubectl create secret tls yueyang-monitor-tls-secret --namespace=yueyang-cloud --dry-run=client --output=yaml --cert=monitor.yueyang.city.pem --key=monitor.yueyang.city.key

生成了如图：

直接将这些东西保存到一个文件当中，然后再执行以下命令生成ingress的yaml资源清单文件：

kubectl create ingress yueyang-monitor-ingress --namespace=yueyang-cloud --dry-run=client --output=yaml --class=nginx --rule="monitor.yueyang.city/*=yueyang-monitor-svc:8088,tls=yueyang-monitor-tls-secret"

生成内容如下：

保存之后直接执行，可以看到创建成功：

然后确定域名解析成功：

接下来直接访问这个域名，可以看到访问成功：

用户名和密码配置在nacos注册中心当中：

可以看到应用墙访问是没有问题的：

好的Kubernetes上部署整个SpringCloud应用就已经部署完毕了，祝你们编码愉快！