在Kubernetes(k8s)上部署整个SpringCloud微服务应用

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

文章目录

• 项目准备
• 打成使用Docker打成镜像
• • 准备Docker仓库
  • 打包项目为Docker镜像
• 部署应用到k8s
• • 创建nfs挂载目录
  • 创建一些基本资源
  • • 创建命名空间
    • 创建拉取镜像的secret
    • 创建java运行环境的profile
  • 部署mysql
  • • 创建持久化的pv和pvc
    • [创建mysql root密码的secret](#创建mysql root密码的secret)
    • 创建mysql配置文件
    • 部署有状态的MySQL
  • 部署nacos
  • • 为nacos创建关于日志和数据的pv和pvc
    • 为nacos的环境变量创建comfigmap
    • 部署nacos
    • 用ingress暴露nacos
  • 部署redis
  • • 创建用于存放redis数据的pv和pvc
    • 创建redis配置文件和ConfigMap
    • 部署redis
  • 部署sentinel
  • • 镜像准备
    • 创建Sentinel的ConfigMap
    • 创建secret
    • 部署sentinel
    • 使用ingress暴露sentinel
  • 部署file模块
  • • 创建持久化的pv和pvc
    • 部署file应用
  • 部署gateway
  • • 部署gateway的deploy
    • 创建gateway的service
  • 部署system模块
  • • 创建system模块的deploy
  • 部署auth模块
  • • 创建auth模块的deploy
  • 部署前端应用
  • • 前端配置文件
    • 创建前端项目的deploy
    • 创建前端项目的service
    • 创建前端项目的ingress
  • 环境迁移
  • • 创建集群
    • 远程连接集群
    • 创建pv和pvc
    • 修改拉取镜像的secret
    • 部署应用
  • 部署job模块
  • • 创建job模块的deploy
  • 部署gen模块
  • • 创建gen模块的deploy
  • 部署monitor模块
  • • 创建monitor模块的deploy
    • 创建monitor模块的service
    • 创建monitor模块的ingress

项目准备

这次我准备了一个微服务项目，是依照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-secret
  namespace: 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: 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

直接执行它，发现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-secret
  namespace: 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 = 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

为了方便将其保存在与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

保存之后执行它：

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

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

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: 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

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

为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-cm
  namespace: yueyang-cloud

然后可以看到创建成功：

部署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

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

用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: 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

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

创建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 /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

直接根据这个资源清单文件创建资源，然后查看结果，可以看到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

然后直接执行这个文件，可以看到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-cm
  namespace: 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-secret
  namespace: 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-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

然后我们直接执行这个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: 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

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

部署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-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

直接执行这个资源清单文件，可以看到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-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: { }

修改完成之后直接执行，可以看到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-deployment
  name: yueyang-gateway-svc
  namespace: yueyang-cloud
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    app: yueyang-gateway-deployment
  type: 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-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: { }

保存到一个文件当中后执行它，可以看到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-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: { }

保存到一个文件当中后执行它，可以看到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-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: { }

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

创建前端项目的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-deployment
  name: yueyang-ui-svc
  namespace: yueyang-cloud
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: yueyang-ui-deployment
  type: 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}; do
  kubectl 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-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: { }

保存到一个文件当中后执行它，可以看到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-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: { }

保存到一个文件当中后执行它，可以看到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-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: { }

保存到一个文件当中后执行它，可以看到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-deployment
  name: yueyang-monitor-svc
  namespace: yueyang-cloud
spec:
  ports:
    - port: 8088
      protocol: TCP
      targetPort: 8088
  selector:
    app: yueyang-monitor-deployment
  type: 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应用就已经部署完毕了，祝你们编码愉快！