热门标签
热门文章
- 1creo视图管理器使用方法_5.3 视图管理-样式、截面
- 2YOLOv9改进策略 ： C2f改进 | 引入YOLOv8 C2f结构
- 3数据结构-算法的空间复杂度（1.2）_long long fib(int n)
- 4鸿蒙生态蓬勃发展，人才短缺？这份《HarmonyOS开发学习指南》助你抢占风口，快速转型
- 5分句_cut sentences csdn
- 6一个小型的物联网实验，让stm32实验板和Android studio写的APP同时连接上mqtt服务器实现远程控制实验板状态_app开发android studio 连接stm32单片机
- 7CANN媒体数据处理代码V2再学习_cann 媒体数据处理v2 视频解码
- 8Keil 5.37版本及以上安装（兼容低版本），解决‘Default Compiler Version 5‘ Which is not available_default compiler version 5' which is not available
- 9应用程序开发（ArkTS)_arkts单例模式
- 10facenet训练个人数据集_一种数学想法，可以显著减少训练 AI 系统所需的数据集大小...
当前位置: article > 正文
在Kubernetes(k8s)上部署整个SpringCloud微服务应用_kubernetes部署应用
作者：从前慢现在也慢 | 2024-04-07 12:20:26
赞
踩
kubernetes部署应用
视频教程地址：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
- 1
- 2
- 3
拉取下来后的镜像列表：
来到项目的Docker目录下可以看到有一个 yueyang.sh 脚本，这是我写的打包整个项目的脚本：
但是你需要注意修改上面这两项。注意前面的一个写好前缀就行，脚本会将项目模块名自动拼接到后面的：
执行一下它获取使用文档，可以看到脚本有那么多的阶段：
执行这行命令打包maven和vuejs项目：
./yueyang.sh package
- 1
它会用maven和nodejs打包好前后端项目（一些警告不用管它）：
然后我们再执行这行命令来移动打包好的jar文件、前端文件和数据库文件到打包目录：
./yueyang.sh move
- 1
它会将打包好的jar文件、前端文件和数据库初始化脚本的压缩包全部移动/复制到打包的目录：
然后我们执行下面这行命令即可将所有模块打成Docker镜像：
./yueyang.sh build
- 1
执行完毕后可以看到各个模块的镜像就已经打好了：
最后我们需要推送镜像，你需要先docker login。执行这行命令：
docker login --username=docker的用户名 docker服务器地址
- 1
执行如图：
然后执行下面命令就可以将镜像推送到镜像仓库了：
./yueyang.sh push
- 1
可以看到镜像已经全部推送上来了：
接下来我们需要清理构建空间，接着执行这行命令：
./yueyang.sh clean
- 1
执行如图，会调用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
- 1
如图我已经安装了，如果没有安装的需要安装上：
接下来需要在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}
- 1
- 2
创建目录后如图：
接下来我们需要将这些目录暴露给内网访问，先执行下面这行命令修改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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
然后再执行下面这行命令开启 nfs-server 并使它开机自启动：
systemctl enable --now nfs-server
- 1
然后可以使用下面这行命令查看目录的暴露是否成功（注意修改nfs服务器地址）：
showmount -e 192.168.1.160
- 1
检查所有节点暴露的nfs目录都是正常的：
创建一些基本资源
在这个步骤当中我们需要创建命名空间、拉取镜像的secret和java运行环境的profile的configmap。因为接下来会在其他环境当中部署，所以所有的部署步骤都会以yaml资源清单文件形式进行。
创建命名空间
我决定先创建一个 yueyang-cloud 命名空间来部署所有模块。执行下面这行命令获取创建命名空间的yaml资源清单文件：
kubectl create namespace yueyang-cloud --dry-run=client --output=yaml
- 1
执行结果：
生成的yaml资源清单文件：
apiVersion: v1
kind: Namespace
metadata:
name: yueyang-cloud
spec: {}
- 1
- 2
- 3
- 4
- 5
保存这个资源清单文件并执行它：
创建拉取镜像的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
- 1
- 2
- 3
- 4
生成的yaml资源清单文件如图：
最终生成的文件内容：
apiVersion: v1
data:
# 你的服务器地址、用户名、密码和邮箱不同生成的密码字符串也不同
.dockerconfigjson: ***
kind: Secret
metadata:
name: yueyang-image-account-secret
namespace: yueyang-cloud
type: kubernetes.io/dockerconfigjson
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
我们保存它并执行它，可以看到创建成功：
创建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
- 1
生成结果如图：
直接保存到一个文件当中并执行它：
部署mysql
我之前写过一篇关于在Kubernetes上部署MySQL主从集群的文章，这里为了方便就使用单节点了，如果你需要主从节点可以参考我写的这篇文章：https://blog.csdn.net/m0_51510236/article/details/133145221
在推送镜像的时候已经推送了mysql镜像如图：
接下来我们分为那么几个步骤部署这个MySQL：
- 创建持久化的pv和pvc
- 创建mysql root密码的secret
- 创建mysql配置文件
- 部署有状态的MySQL
创建持久化的pv和pvc
因为我们只需要挂载mysql的数据目录到nfs当中，所以我们创建一个pv和pvc就可以了。其yaml资源清单文件如下：
apiVersion: v1 kind: PersistentVolume metadata: name: yueyang-mysql-pv spec: capacity: # 申请的容量，生产环境注意修改 storage: 1Gi accessModes: - ReadWriteMany nfs: # nfs服务器地址和目录，注意修改为自己的 server: 192.168.1.160 path: /data/nfs/yueyang-cloud/mysql # 存储类类型，我们使用nfs storageClassName: "nfs" --- apiVersion: v1 kind: PersistentVolumeClaim metadata: name: yueyang-mysql-pvc namespace: yueyang-cloud spec: accessModes: - ReadWriteMany # 存储类类型，我们使用nfs storageClassName: "nfs" resources: requests: # 申请的容量，生产环境注意修改 storage: 1Gi volumeName: yueyang-mysql-pv
- 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
直接执行它，发现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
- 1
生成结果：
apiVersion: v1
data:
mysql-root-password: cm9vdA==
kind: Secret
metadata:
name: yueyang-mysql-password-secret
namespace: yueyang-cloud
- 1
- 2
- 3
- 4
- 5
- 6
- 7
保存到一个文件当中并执行它：
创建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/
- 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
然后根据它生成一个configmap的yaml资源清单文件，执行下面命令生成：
kubectl create configmap yueyang-mysql-config-cm --namespace=yueyang-cloud --from-file=my.cnf --dry-run=client --output=yaml
- 1
生成后如图：
文件内容：
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 = 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/ kind: ConfigMap metadata: name: yueyang-mysql-config-cm namespace: yueyang-cloud
- 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
为了方便将其保存在与secret相同的文件当中，注意多段yaml资源清单文件用三条横杠做分隔符：
我们执行它之后可以看到configmap就创建成功了：
部署有状态的MySQL
其他的都准备好了现在就差部署MySQL了，直接上yaml资源清单文件（文件里面有详细的注释，这里不再过多赘述）：
apiVersion: v1 kind: Service metadata: name: yueyang-mysql-svc namespace: yueyang-cloud labels: app: yueyang-mysql spec: ports: - port: 3306 name: mysql targetPort: 3306 # 如果需要NodePort暴露则将这里打开 # nodePort: 30306 # 如果需要NodePort暴露则将这里注释 clusterIP: None selector: app: yueyang-mysql # 如果需要NodePort暴露则将这里改为NodePort # ClusterIP, NodePort, LoadBalancer type: ClusterIP # 如果需要NodePort暴露则将这里改为ClientIP # ClientIP, None sessionAffinity: None --- apiVersion: apps/v1 kind: StatefulSet metadata: name: yueyang-mysql namespace: yueyang-cloud spec: selector: matchLabels: app: yueyang-mysql serviceName: "yueyang-mysql-svc" replicas: 1 template: metadata: labels: app: yueyang-mysql spec: terminationGracePeriodSeconds: 10 containers: # 一些部署MySQL的参数 - args: - --character-set-server=utf8mb4 - --collation-server=utf8mb4_unicode_ci - --lower_case_table_names=1 - --default-time_zone=+8:00 name: mysql # 注意修改为你自己的镜像地址 image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/mysql:1.0.0 # 存活探针，用于检查pod是否处于存活状态 livenessProbe: # 初始化后20秒开始检查 initialDelaySeconds: 20 # 之后每过10秒检查一次 periodSeconds: 10 # 检查内容为3306端口是否存活 tcpSocket: port: 3306 ports: - containerPort: 3306 name: mysql volumeMounts: - name: mysql-data mountPath: /var/lib/mysql - name: mysql-conf mountPath: /etc/my.cnf readOnly: true subPath: my.cnf env: - name: MYSQL_ROOT_PASSWORD valueFrom: secretKeyRef: key: mysql-root-password name: yueyang-mysql-password-secret imagePullSecrets: - name: yueyang-image-account-secret volumes: - name: mysql-data persistentVolumeClaim: claimName: yueyang-mysql-pvc - name: mysql-conf configMap: name: yueyang-mysql-config-cm items: - key: my.cnf mode: 0644 path: my.cnf
- 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
保存之后执行它：
最后查看结果显示部署成功：
我们执行这行命令即可进入数据库内部查看：
kubectl exec -itn yueyang-cloud pod/yueyang-mysql-0 -- mysql -uroot -p
- 1
进去之后可以看到项目所需要的数据库已经成功初始化在其中了：
部署nacos
我之前写过一篇关于在Kubernetes上部署多节点nacos集群的文章，这里为了方便就使用单节点了，如果你需要多节点nacos集群可以参考我写的这篇文章：https://blog.csdn.net/m0_51510236/article/details/132802919
接下来开始部署nacos。部署nacos分为以下几个阶段：
- 为nacos创建关于日志和数据的pv和pvc
- 为nacos的环境变量创建comfigmap
- 部署nacos
- 用ingress暴露nacos
为nacos创建关于日志和数据的pv和pvc
因为需要创建关于日志和数据的两个pv和pvc，所以这个yaml资源清单文件也是有两个pv和pvc的。直接上yaml文件：
apiVersion: v1 kind: PersistentVolume metadata: name: yueyang-nacos-logs-pv spec: capacity: # 申请的容量，生产环境注意修改 storage: 1Gi accessModes: - ReadWriteMany nfs: # nfs服务器地址和目录，注意修改为自己的 server: 192.168.1.160 path: /data/nfs/yueyang-cloud/nacos/logs # 存储类类型，我们使用nfs storageClassName: "nfs" --- apiVersion: v1 kind: PersistentVolumeClaim metadata: name: yueyang-nacos-logs-pvc namespace: yueyang-cloud spec: accessModes: - ReadWriteMany # 存储类类型，我们使用nfs storageClassName: "nfs" resources: requests: # 申请的容量，生产环境注意修改 storage: 1Gi volumeName: yueyang-nacos-logs-pv --- apiVersion: v1 kind: PersistentVolume metadata: name: yueyang-nacos-data-pv spec: capacity: # 申请的容量，生产环境注意修改 storage: 1Gi accessModes: - ReadWriteMany nfs: # nfs服务器地址和目录，注意修改为自己的 server: 192.168.1.160 path: /data/nfs/yueyang-cloud/nacos/data # 存储类类型，我们使用nfs storageClassName: "nfs" --- apiVersion: v1 kind: PersistentVolumeClaim metadata: name: yueyang-nacos-data-pvc namespace: yueyang-cloud spec: accessModes: - ReadWriteMany # 存储类类型，我们使用nfs storageClassName: "nfs" resources: requests: # 申请的容量，生产环境注意修改 storage: 1Gi volumeName: yueyang-nacos-data-pv
- 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
将其保存在一个文件当中之后直接执行：
为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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
生成的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-cm namespace: yueyang-cloud
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
然后可以看到创建成功：
部署nacos
我们需要部署一个有状态的Nacos应用，yaml资源清单文件如下：
apiVersion: v1 kind: Service metadata: name: yueyang-nacos-svc namespace: yueyang-cloud labels: app: yueyang-nacos spec: ports: - port: 8848 name: client targetPort: 8848 # 如果你需要使用到NodePort或LoadBalancer暴露应用，那么你可以将这里打开 # nodePort: 30848 - port: 9848 name: client-rpc targetPort: 9848 # nodePort: 30948 - port: 9849 name: raft-rpc targetPort: 9849 # nodePort: 30849 - port: 7848 name: old-raft-rpc targetPort: 7848 # nodePort: 30748 # 如果你需要使用到NodePort或LoadBalancer暴露应用，那么你需要注释掉clusterIP clusterIP: None selector: app: yueyang-nacos # ClusterIP, NodePort, LoadBalancer type: ClusterIP # 如果你需要使用到NodePort或LoadBalancer暴露应用，那么你需要将这里改为ClientIP # ClientIP, None sessionAffinity: None --- apiVersion: apps/v1 kind: StatefulSet metadata: name: yueyang-nacos namespace: yueyang-cloud spec: selector: matchLabels: app: yueyang-nacos serviceName: "yueyang-nacos-svc" replicas: 1 template: metadata: labels: app: yueyang-nacos spec: terminationGracePeriodSeconds: 10 containers: - name: nacos # 这里一个是官方镜像，一个是我拉取的官方镜像然后推送到国内阿里云的镜像 # image: docker.io/nacos/nacos-server:v2.0.4 image: 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/health port: 8848 scheme: HTTP # pod初始化完成后多久开始进行存活探针的检查，这里设置为30秒 initialDelaySeconds: 30 # 之后每十秒检查一次是否存活 periodSeconds: 10 ports: - containerPort: 8848 name: client - containerPort: 9848 name: client-rpc - containerPort: 9849 name: raft-rpc - containerPort: 7848 name: old-raft-rpc volumeMounts: # 挂载数据目录 - name: nacos-data mountPath: /home/nacos/data # 挂载日志目录 - name: nacos-logs mountPath: /home/nacos/logs env: # 引用ConfigMap里面的各个属性 - name: JVM_XMN valueFrom: configMapKeyRef: key: jvm-xmn name: yueyang-nacos-cm - name: JVM_XMS valueFrom: configMapKeyRef: key: jvm-xms name: yueyang-nacos-cm - name: JVM_XMX valueFrom: configMapKeyRef: key: jvm-xmx name: yueyang-nacos-cm - name: MODE valueFrom: configMapKeyRef: key: mode name: yueyang-nacos-cm - name: MYSQL_DATABASE_NUM valueFrom: configMapKeyRef: key: mysql-database-num name: yueyang-nacos-cm - name: MYSQL_SERVICE_DB_NAME valueFrom: configMapKeyRef: key: mysql-service-db-name name: yueyang-nacos-cm - name: MYSQL_SERVICE_DB_PARAM valueFrom: configMapKeyRef: key: mysql-service-db-param name: yueyang-nacos-cm - name: MYSQL_SERVICE_HOST valueFrom: configMapKeyRef: key: mysql-service-host name: yueyang-nacos-cm # 数据库的密码引用之前为MySQL创建的Secret - name: MYSQL_SERVICE_PASSWORD valueFrom: secretKeyRef: key: mysql-root-password name: yueyang-mysql-password-secret - name: MYSQL_SERVICE_PORT valueFrom: configMapKeyRef: key: mysql-service-port name: yueyang-nacos-cm - name: MYSQL_SERVICE_USER valueFrom: configMapKeyRef: key: mysql-service-user name: yueyang-nacos-cm - name: SPRING_DATASOURCE_PLATFORM valueFrom: configMapKeyRef: key: spring-datasource-platform name: yueyang-nacos-cm volumes: # 使用刚刚创建的数据目录的pvc - name: nacos-data persistentVolumeClaim: claimName: yueyang-nacos-data-pvc # 使用刚刚创建的日志目录的pvc - name: nacos-logs persistentVolumeClaim: claimName: yueyang-nacos-logs-pvc
- 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
接下来根据这个资源文件部署引用：
用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
- 1
可以看到我们已经成功生成了对于的资源清单文件：
然后我们执行这行命令生成暴露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"
- 1
注意后面的 --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分为以下几个阶段：
- 创建用于存放redis数据的pv和pvc
- 创建redis配置文件和ConfigMap
- 部署redis
创建用于存放redis数据的pv和pvc
因为我们只需要挂载redis的数据目录到nfs当中，所以我们创建一个pv和pvc就可以了。其yaml资源清单文件如下：
apiVersion: v1 kind: PersistentVolume metadata: name: yueyang-redis-pv spec: capacity: # 申请的容量，生产环境注意修改 storage: 1Gi accessModes: - ReadWriteMany nfs: # nfs服务器地址和目录，注意修改为自己的 server: 192.168.1.160 path: /data/nfs/yueyang-cloud/redis # 存储类类型，我们使用nfs storageClassName: "nfs" --- apiVersion: v1 kind: PersistentVolumeClaim metadata: name: yueyang-redis-pvc namespace: yueyang-cloud spec: accessModes: - ReadWriteMany storageClassName: "nfs" resources: requests: # 申请的容量，生产环境注意修改 storage: 1Gi # 存储类类型，我们使用nfs volumeName: yueyang-redis-pv
- 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
将它保存到一个文件当中并执行它，可以看到创建成功：
创建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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
然后执行这行命令生成对应的configmap：
kubectl create configmap yueyang-redis-config-cm --namespace=yueyang-cloud --from-file=redis.conf --dry-run=client --output=yaml
- 1
生成的内容：
apiVersion: v1 data: 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 kind: ConfigMap metadata: name: yueyang-redis-config-cm namespace: yueyang-cloud
- 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
直接根据这个资源清单文件创建资源，然后查看结果，可以看到configmap创建成功：
部署redis
现在需要部署一个有状态的redis应用，部署的yaml资源清单文件：
apiVersion: v1 kind: Service metadata: name: yueyang-redis-svc namespace: yueyang-cloud labels: app: yueyang-redis spec: ports: - port: 6379 name: redis targetPort: 6379 # 如果需要NodePort暴露则将这里打开 # nodePort: 30379 # 如果需要NodePort暴露则将这里注释 clusterIP: None selector: app: yueyang-redis # 如果需要NodePort暴露则将这里改为NodePort # ClusterIP, NodePort, LoadBalancer type: ClusterIP # 如果需要NodePort暴露则将这里改为ClientIP # ClientIP, None sessionAffinity: None --- apiVersion: apps/v1 kind: StatefulSet metadata: name: yueyang-redis namespace: yueyang-cloud spec: selector: matchLabels: app: yueyang-redis serviceName: "yueyang-redis-svc" replicas: 1 template: metadata: labels: app: yueyang-redis spec: terminationGracePeriodSeconds: 10 containers: # 启动命令，使用指定配置文件启动 - command: - "redis-server" - "/usr/local/etc/redis.conf" name: redis # 这里一个是官方镜像，一个是我拉取的官方镜像然后推送到国内阿里云的镜像 # image: docker.io/library/redis:5.0.14 image: registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/redis:5.0.14 # 存活探针 livenessProbe: # pod初始化完成后20秒开始检测 initialDelaySeconds: 20 # 之后每隔10秒检查一次 periodSeconds: 10 # 检查的流程是用tcp协议去查看6379端口是否存活 tcpSocket: port: 6379 ports: - containerPort: 6379 name: redis volumeMounts: # 挂载数据目录 - name: redis-data mountPath: /data # 挂载配置文件 - name: redis-config mountPath: /usr/local/etc readOnly: true volumes: # 挂载数据目录，使用之前创建的pvc - name: redis-data persistentVolumeClaim: claimName: yueyang-redis-pvc # 挂载配置文件，引用之前创建的ConfigMap - name: redis-config configMap: name: yueyang-redis-config-cm items: - key: redis.conf path: redis.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
- 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
然后直接执行这个文件，可以看到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"]
- 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
我已经制作好了一个Sentinel镜像，你们可以直接使用。执行下面命令可以拉取这个镜像：
docker pull registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/sentinel:1.8.6
- 1
创建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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
生成结果：
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-cm
namespace: yueyang-cloud
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
直接执行这个文件，可以看到创建成功：
创建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
- 1
- 2
- 3
生成结果：
apiVersion: v1
data:
sentinel-password: c2VudGluZWw=
sentinel-username: c2VudGluZWw=
kind: Secret
metadata:
name: yueyang-sentinel-password-secret
namespace: yueyang-cloud
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
直接执行这个文件可以看到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'
- 1
- 2
- 3
- 4
因为生成的文件还需要经过修改，所以这里直接贴上修改后的yaml资源清单文件：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-sentinel-deploy name: yueyang-sentinel-deploy namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-sentinel-deploy strategy: {} template: metadata: labels: app: yueyang-sentinel-deploy spec: containers: - image: registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/sentinel:1.8.6 name: sentinel # 存活探针 livenessProbe: # 使用http的get请求判断pod是否存活，请求8719端口的/clusterNode判断pod是否存活 httpGet: path: /clusterNode port: 8719 scheme: HTTP # 在pod初始化完毕20秒后再开始进行存活探针 initialDelaySeconds: 20 # 之后每隔10秒检查一下应用是否存活 periodSeconds: 10 ports: - containerPort: 8718 name: dashboard protocol: TCP - containerPort: 8719 name: api protocol: TCP env: # 引用configmap当中各类配置 - name: XMX valueFrom: configMapKeyRef: key: xmx name: yueyang-sentinel-cm - name: XMS valueFrom: configMapKeyRef: key: xms name: yueyang-sentinel-cm - name: XMN valueFrom: configMapKeyRef: key: xmn name: yueyang-sentinel-cm - name: API_PORT valueFrom: configMapKeyRef: key: api-port name: yueyang-sentinel-cm - name: SERVER_PORT valueFrom: configMapKeyRef: key: server-port name: yueyang-sentinel-cm - name: JAVA_OPTION valueFrom: configMapKeyRef: key: java-option name: yueyang-sentinel-cm # 引用secret里面的用户名和密码 - name: SENTINEL_USERNAME valueFrom: secretKeyRef: key: sentinel-username name: yueyang-sentinel-password-secret - name: SENTINEL_PASSWORD valueFrom: secretKeyRef: key: sentinel-password name: yueyang-sentinel-password-secret resources: {} --- apiVersion: v1 kind: Service metadata: labels: app: yueyang-sentinel-deploy name: yueyang-sentinel-svc namespace: yueyang-cloud spec: ports: - name: dashboard port: 8718 protocol: TCP targetPort: 8718 # nodePort: 30718 - name: api port: 8719 protocol: TCP targetPort: 8719 # nodePort: 30719 selector: app: yueyang-sentinel-deploy # ClusterIP, NodePort, LoadBalancer type: ClusterIP
- 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
然后我们直接执行这个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
- 1
资源清单文件生成如图：
然后我们根据这个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"
- 1
生成如图：
最后保存在一个文件当中并执行它们，可以看到ingress创建成功：
最后我们需要保证域名解析正确：
然后我们可以直接通过浏览器访问这个域名就能访问到sentinel了：
部署file模块
创建持久化的pv和pvc
把所有的业务模块中file模块放在最前面将是因为这个模块需要用到nfs文件存储。先将pv和pvc创建好：
apiVersion: v1 kind: PersistentVolume metadata: name: yueyang-file-pv spec: capacity: # 申请的容量，生产环境注意修改 storage: 1Gi accessModes: - ReadWriteMany nfs: # nfs服务器地址和目录，注意修改为自己的 server: 192.168.1.160 path: /data/nfs/yueyang-cloud/file # 存储类类型，我们使用nfs storageClassName: "nfs" --- apiVersion: v1 kind: PersistentVolumeClaim metadata: name: yueyang-file-pvc namespace: yueyang-cloud spec: accessModes: - ReadWriteMany # 存储类类型，我们使用nfs storageClassName: "nfs" resources: requests: # 申请的容量，生产环境注意修改 storage: 1Gi volumeName: yueyang-file-pv
- 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
执行之后可以看到创建成功：
部署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
- 1
我们先来看看配置中心file模块的配置，可以看到文件上传地址为 data/file 所以需要将这个目录挂载到nfs上：
直接上修改过后的yaml资源清单文件：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-file-deployment name: yueyang-file-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-file-deployment strategy: { } template: metadata: labels: app: yueyang-file-deployment spec: imagePullSecrets: - name: yueyang-image-account-secret containers: - env: # 运行时环境，引用一开始创建的configmap，值为prod - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: spring-profile-cm key: spring-profiles-active # 设置一些jvm调优参数 - name: JAVA_OPTION value: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC" - name: XMX value: "128m" - name: XMS value: "128m" - name: XMN value: "64m" image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/file:1.0.0 name: file # 存活探针 livenessProbe: # 发送http get请求到10020端口的/actuator/health路径检查pod是否健康 httpGet: path: /actuator/health port: 10020 scheme: HTTP # pod初始化完毕20秒之后再开始 initialDelaySeconds: 20 # 之后每10秒进行一次健康检查 periodSeconds: 10 ports: - containerPort: 10020 resources: { } # 挂载上传文件的目录 volumeMounts: - mountPath: /data/file name: file-data volumes: # 定义file-data，使用上一步创建的file模块的pvc - name: file-data persistentVolumeClaim: claimName: yueyang-file-pvc
- 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
直接执行这个资源清单文件，可以看到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
- 1
执行结果如图：
生成这个yaml资源清单文件之后还需要加入包括运行时环境、jvm调优参数、存活探针等内容。还有因为私有化镜像仓库，所以还需要加入拉取镜像时候带上的secret。修改之后的内容：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-gateway-deployment name: yueyang-gateway-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-gateway-deployment strategy: { } template: metadata: labels: app: yueyang-gateway-deployment spec: # 拉取镜像需要使用到的secret imagePullSecrets: - name: yueyang-image-account-secret containers: - env: # 运行时环境，引用一开始创建的configmap，值为prod - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: spring-profile-cm key: spring-profiles-active # 设置一些jvm调优参数 - name: JAVA_OPTION value: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC" - name: XMX value: "128m" - name: XMS value: "128m" - name: XMN value: "64m" image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/gateway:1.0.0 name: gateway # 存活探针 livenessProbe: # 发送http get请求到8080端口的/actuator/health路径检查pod是否健康 httpGet: path: /actuator/health port: 8080 scheme: HTTP # pod初始化完毕20秒之后再开始 initialDelaySeconds: 20 # 之后每10秒进行一次健康检查 periodSeconds: 10 ports: - containerPort: 8080 resources: { }
- 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
修改完成之后直接执行，可以看到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
- 1
生成结果：
apiVersion: v1
kind: Service
metadata:
labels:
app: yueyang-gateway-deployment
name: yueyang-gateway-svc
namespace: yueyang-cloud
spec:
ports:
- port: 8080
protocol: TCP
targetPort: 8080
selector:
app: yueyang-gateway-deployment
type: ClusterIP
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
直接执行这个文件，可以看到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
- 1
生成如图：
然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-system-deployment name: yueyang-system-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-system-deployment strategy: { } template: metadata: labels: app: yueyang-system-deployment spec: # 拉取镜像的secret imagePullSecrets: - name: yueyang-image-account-secret containers: - env: # 运行时环境，引用一开始创建的configmap，值为prod - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: spring-profile-cm key: spring-profiles-active # 设置一些jvm调优参数 - name: JAVA_OPTION value: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC" - name: XMX value: "128m" - name: XMS value: "128m" - name: XMN value: "64m" image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/system:1.0.0 name: system # 存活探针 livenessProbe: # 发送http get请求到10050端口的/actuator/health路径检查pod是否健康 httpGet: path: /actuator/health port: 10050 scheme: HTTP # pod初始化完毕20秒之后再开始 initialDelaySeconds: 20 # 之后每10秒进行一次健康检查 periodSeconds: 10 ports: - containerPort: 10050 resources: { }
- 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
保存到一个文件当中后执行它，可以看到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
- 1
生成如图：
然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-auth-deployment name: yueyang-auth-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-auth-deployment strategy: { } template: metadata: labels: app: yueyang-auth-deployment spec: # 拉取镜像的secret imagePullSecrets: - name: yueyang-image-account-secret containers: - env: # 运行时环境，引用一开始创建的configmap，值为prod - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: spring-profile-cm key: spring-profiles-active # 设置一些jvm调优参数 - name: JAVA_OPTION value: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC" - name: XMX value: "128m" - name: XMS value: "128m" - name: XMN value: "64m" image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/auth:1.0.0 name: auth # 存活探针 livenessProbe: # 发送http get请求到10010端口的/actuator/health路径检查pod是否健康 httpGet: path: /actuator/health port: 10010 scheme: HTTP # pod初始化完毕20秒之后再开始 initialDelaySeconds: 20 # 之后每10秒进行一次健康检查 periodSeconds: 10 ports: - containerPort: 10010 resources: { }
- 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
保存到一个文件当中后执行它，可以看到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
- 1
因为是前端项目，所以没有那么多的调优参数和环境参数，只需要加上一个拉取镜像的secret即可。顺便再加一个存活探针。修改后的yaml：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-ui-deployment name: yueyang-ui-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-ui-deployment strategy: { } template: metadata: labels: app: yueyang-ui-deployment spec: # 拉取镜像的secret imagePullSecrets: - name: yueyang-image-account-secret containers: - image: registry.cn-shenzhen.aliyuncs.com/yueyang-cloud/ui:1.0.0 name: ui # 存活探针 livenessProbe: # 使用http get请求80的根目录，查看是否存活 httpGet: path: / port: 80 scheme: HTTP # pod初始化完毕20秒后再进行存活检查 initialDelaySeconds: 20 # 之后每隔10秒检查一次 periodSeconds: 10 ports: - containerPort: 80 resources: { }
- 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
保存到一个文件当中之后直接执行，可以看到创建成功：
创建前端项目的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
- 1
生成的文件如下：
apiVersion: v1
kind: Service
metadata:
labels:
app: yueyang-ui-deployment
name: yueyang-ui-svc
namespace: yueyang-cloud
spec:
ports:
- port: 80
protocol: TCP
targetPort: 80
selector:
app: yueyang-ui-deployment
type: ClusterIP
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
直接执行这个文件，可以看到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
- 1
生成了如图：
直接将这些东西保存到一个文件当中，然后再执行以下命令生成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"
- 1
生成内容如下：
保存之后直接执行，可以看到创建成功：
然后确定域名解析正常：
然后就可以直接通过域名访问系统了：
通过默认用户名和密码登录就可以访问系统了：
环境迁移
如果你本地环境较高可以跳过这个步骤。
创建集群
因为我本机的虚拟机无法满足配置要求了，所以我打算使用阿里云的容器服务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
- 1
生成如图：
将其更新在文件当中之后执行可以看到创建成功：
部署应用
首先需要将所有的镜像当中的拉取镜像地址改为私网地址，这样拉取镜像会更快：
然后可以按照需求修改一下各个模块的内存大小：
然后执行除了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}; do
kubectl apply -f "${yaml_file}"
done
- 1
- 2
- 3
- 4
- 5
执行这个脚本，可以看到所有资源都已经创建好了：
内网创建非常快，可以看到资源已经创建完毕：
可以看到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
- 1
内网：
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
- 1
生成如图：
然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-job-deployment name: yueyang-job-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-job-deployment strategy: { } template: metadata: labels: app: yueyang-job-deployment spec: # 拉取镜像的secret imagePullSecrets: - name: yueyang-image-account-secret containers: - env: # 运行时环境，引用一开始创建的configmap，值为prod - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: spring-profile-cm key: spring-profiles-active # 设置一些jvm调优参数 - name: JAVA_OPTION value: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC" - name: XMX value: "1g" - name: XMS value: "1g" - name: XMN value: "512m" image: registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/job:1.0.0 name: job # 存活探针 livenessProbe: # 发送http get请求到10040端口的/actuator/health路径检查pod是否健康 httpGet: path: /actuator/health port: 10040 scheme: HTTP # pod初始化完毕20秒之后再开始 initialDelaySeconds: 20 # 之后每10秒进行一次健康检查 periodSeconds: 10 ports: - containerPort: 10040 resources: { }
- 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
保存到一个文件当中后执行它，可以看到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
- 1
内网：
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
- 1
生成如图：
然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-gen-deployment name: yueyang-gen-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-gen-deployment strategy: { } template: metadata: labels: app: yueyang-gen-deployment spec: # 拉取镜像的secret imagePullSecrets: - name: yueyang-image-account-secret containers: - env: # 运行时环境，引用一开始创建的configmap，值为prod - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: spring-profile-cm key: spring-profiles-active # 设置一些jvm调优参数 - name: JAVA_OPTION value: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC" - name: XMX value: "1g" - name: XMS value: "1g" - name: XMN value: "512m" image: registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/gen:1.0.0 name: gen # 存活探针 livenessProbe: # 发送http get请求到10030端口的/actuator/health路径检查pod是否健康 httpGet: path: /actuator/health port: 10030 scheme: HTTP # pod初始化完毕20秒之后再开始 initialDelaySeconds: 20 # 之后每10秒进行一次健康检查 periodSeconds: 10 ports: - containerPort: 10030 resources: { }
- 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
保存到一个文件当中后执行它，可以看到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
- 1
内网：
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
- 1
生成如图：
然后我们还要加上如拉取镜像的secret、jvm调优参数、存活探针和引用生产环境的configmap等。修改后的yaml内容：
apiVersion: apps/v1 kind: Deployment metadata: labels: app: yueyang-monitor-deployment name: yueyang-monitor-deployment namespace: yueyang-cloud spec: replicas: 1 selector: matchLabels: app: yueyang-monitor-deployment strategy: { } template: metadata: labels: app: yueyang-monitor-deployment spec: # 拉取镜像的secret imagePullSecrets: - name: yueyang-image-account-secret containers: - env: # 运行时环境，引用一开始创建的configmap，值为prod - name: SPRING_PROFILES_ACTIVE valueFrom: configMapKeyRef: name: spring-profile-cm key: spring-profiles-active # 设置一些jvm调优参数 - name: JAVA_OPTION value: "-Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:+PrintGCDetails -Xloggc:/var/log/devops-example.gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC" - name: XMX value: "1g" - name: XMS value: "1g" - name: XMN value: "512m" image: registry-vpc.cn-shenzhen.aliyuncs.com/yueyang-cloud/monitor:1.0.0 name: monitor # 存活探针 livenessProbe: # 发送http get请求到8088端口的/actuator/health路径检查pod是否健康 httpGet: path: /actuator/health port: 8088 scheme: HTTP # pod初始化完毕20秒之后再开始 initialDelaySeconds: 20 # 之后每10秒进行一次健康检查 periodSeconds: 10 ports: - containerPort: 8088 resources: { }
- 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
保存到一个文件当中后执行它，可以看到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
- 1
生成的文件如下：
apiVersion: v1
kind: Service
metadata:
labels:
app: yueyang-monitor-deployment
name: yueyang-monitor-svc
namespace: yueyang-cloud
spec:
ports:
- port: 8088
protocol: TCP
targetPort: 8088
selector:
app: yueyang-monitor-deployment
type: ClusterIP
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
直接执行这个文件，可以看到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
- 1
生成了如图：
直接将这些东西保存到一个文件当中，然后再执行以下命令生成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"
- 1
生成内容如下：
保存之后直接执行，可以看到创建成功：
然后确定域名解析成功：
接下来直接访问这个域名，可以看到访问成功：
用户名和密码配置在nacos注册中心当中：
可以看到应用墙访问是没有问题的：
好的Kubernetes上部署整个SpringCloud应用就已经部署完毕了，祝你们编码愉快！
声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签
