若依微服务部署，裸服务部署、docker部署、k8s部署

MssGuo2023-10-10 15:33

目录

前言

环境：centos7、Win10

若依是一个合适新手部署练习的开源的微服务项目，本篇讲解Windows部署若依微服务、docker部署若依微服务、k8s部署若依微服务等3种方式。

若依是一个基于SpringBoot2.0的权限管理系统，同时使用到了mysql、redis、nacos等技术，这里更好理解一下java程序是如何使用nacos的。

windows 部署若依-微服务版本

下载若依的源代码：https://gitee.com/y_project/RuoYi-Cloud，克隆/下载，下载ZIP即可。下载后解压到D:\ruoyi-cloud文件夹即可。

按照官网，我们部署若依微服务版本：https://doc.ruoyi.vip/ruoyi-cloud/

bash 复制代码 
#官网写的部署环境要求,所以选择的版本要满足要求
JDK >= 1.8 (推荐1.8版本)
Mysql >= 5.7.0 (推荐5.7版本)
Redis >= 3.0
Maven >= 3.0
Node >= 12
nacos >= 2.0.4 (ruoyi-cloud < 3.0 需要下载nacos >= 1.4.x版本)
sentinel >= 1.6.0
bash 复制代码 
#windows安装jdk1.8
下载地址：https://javadl.oracle.com/webapps/download/GetFile/1.8.0_301-b09/d3c52aa6bfa54d3ca74e617f18309292/windows-i586/jdk-8u301-windows-x64.exe
1. 打开环境变量配置。计算机→属性→高级系统设置→高级→环境变量，在系统变量中配置。
2. 配置JAVA_HOME。新建，变量名JAVA_HOME，变量值=jdk路径，我的路径是C:\Program Files\Java\jdk1.8.0_301 （ 最后的路径不要写斜杠）保存。
3. 配置CLASSPATH。新建，变量名CLASSPATH，变量值等于.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar（第一个分号前面有一个点）。
4. 配置Path。选中Path变量，点编辑按钮，在变量值最前加入%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
5. 运行cmd，输入java -version，显示java版本则成功。
bash 复制代码 
#windows安装 apache-maven-3.8.8 
下载Windows的zip包：https://dlcdn.apache.org/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.zip
解压即可。
配置环境变量，变量名和值对应如下：
M2_HOME		D:\apache-maven-3.8.8\bin
MAVEN_HOME	D:\apache-maven-3.8.8
PATH	前面追加 %MAVEN_HOME%\bin;
#cmd验证是否正常
mvn -version
bash 复制代码 
#Windows安装安装node和npm命令
#npm命令用于生成前端制品，即给前端生成dist目录
https://nodejs.org/dist/v14.4.0/node-v14.4.0-win-x64.zip
解压到 D:/node-v14.4.0-win-x64
#配置环境变量
NODE_HOME	D:\node-v14.4.0-win-x64
PATH		前面追加 %NODE_HOME%;
#cmd验证是否正常
npm -v
node -v
bash 复制代码 
#这里为了方便，使用Linux部署mysql，当然使用Windows安装也是可以的，Windows安装也很简单。
#linux部署mysql5.7
mkdir mysql
cd mysql/
wget https://downloads.mysql.com/archives/get/p/23/file/mysql-5.7.38-1.el7.x86_64.rpm-bundle.tar
tar xf mysql-5.7.38-1.el7.x86_64.rpm-bundle.tar 
rpm -qa | grep mariadb
rpm -e --nodeps  mariadb-libs-5.5.68-1.el7.x86_64
ls /etc/my*
rpm -ivh mysql-community-common-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-libs-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-client-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-server-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-libs-compat-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-devel-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-embedded-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-embedded-compat-5.7.38-1.el7.x86_64.rpm
rpm -ivh mysql-community-embedded-devel-5.7.38-1.el7.x86_64.rpm
which mysqld
id mysql
#开始初始化mysql
mysqld --initialize --user=mysql
systemctl start mysqld
systemctl status  mysqld
systemctl enable  mysqld
grep "password" /var/log/mysqld.log
which mysql
mysql -uroot -p#%b9oE67kaj4
ALTER USER 'root'@'localhost' IDENTIFIED BY 'Aa123456';	#修改mysql root账号密码，记住这个密码
use mysql;
update user set host='%' where user='root';
FLUSH PRIVILEGES;
exit;
systemctl  restart mysqld

#mysql导入数据，初始化库和表
先执行源码包里的RuoYi-Cloud-master\sql目录下的ry_config_20220929.sql文件，该文件里面有创建ry_config库和表的语句；
windows使用Navicat Premium链接mysql数据库，选择运行SQL文件导入即可。
由于ry_20230706.sql文件没有创建库的语句，根据官网得知是要创建一个名称叫做ry-cloud的库，所以参照ry_config_20220929.sql文件里面的建
库语句，复制粘贴并添加到ry_20230706.sql文件开头即可，注意修改库名为ry-cloud：
DROP DATABASE IF EXISTS `ry-cloud`;
CREATE DATABASE  `ry-cloud` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
USE `ry-cloud`;

最后执行ry_20230706.sql文件即可。
这样两个必要的ry-cloud库和ry_config库都准备好了。
ry-cloud库是若依系统使用的库，ry_config库是nacos的库。
quartz.sql也可以导入ry-cloud库（可选）。
bash 复制代码 
#这里为了方便，使用Linux部署redis，当然使用Windows安装也是可以的，Windows安装也很简单。
#Linux安装redis3.2
yum install redis -y
vim /etc/redis.conf	
bind 192.168.244.150	#设置监听IP为本机IP
systemctl  enable --now  redis
redis服务器启动成功之后，在Windows使用Redis Desktop Manager 链接成功即可。这里默认redis没有配置密码。
bash 复制代码 
#这里为了方便，使用Linux部署nacos，当然使用Windows安装也是可以的，Windows安装也很简单。
#Linux部署nacos
nacos需要jdk环境,所以linux服务器也要安装jdk。
#linux安装jdk1.8
#去https://www.oracle.com/java/technologies/downloads/下载对应版本的tar.gz包
tar -zxvf jdk1.8.tar.gz  -C /usr/local/
cd /usr/local/
mv jdk1.8.0_211  java
cat >> /etc/profile <<'EOF'
export JAVA_HOME=/usr/local/java
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin
EOF
source /etc/profile
java -version

#安装nacos-2.2.1
#官网显示nacos >= 2.0.4，所以选择安装nacos-2.2.1
#nacos-2.2.2版本及之后的版本对登录验证有改变，需要自己配置，所以这里安装nacos-2.2.1版本
mkdir nacos-server
wget -c https://github.com/alibaba/nacos/releases/download/2.2.1/nacos-server-2.2.1.tar.gz
tar xvf nacos-server-2.2.1.tar.gz
cd nacos 
vim conf/application.properties			#添加下面的链接mysql的语句，注意修改mysql的IP和root密码
# db mysql
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://192.168.244.150:3306/ry-config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user=root
db.password=Aa123456

#发现启动报错，显示登录鉴权相关的报错，官网说2.2.2之后才需要自己配置登录信息，不知道2.2.1为什么也要配置，所以就配置：
#修改下面这个几个参数的值
nacos.core.auth.enabled=true
nacos.core.auth.server.identity.key=nacos
nacos.core.auth.server.identity.value=nacos
nacos.core.auth.plugin.nacos.token.secret.key=VkdocGMwbHpUWGxEZFhOMGIyMVRaV055WlhSTFpYa3dNVElocGMwbHpUWGxEZFhOMGIyMVRaV055WlhSTFpYa3dhZmR6TkRVMk56Zz0K

#单机模式启动nacos
cd bin/
./startup.sh  -m standalone
tail -222f /root/nacos-server/nacos/logs/start.out
#windows登录nacos
http://192.168.244.150:8848/nacos/#/login   账号密码：nacos/nacos
登录之后，一定要编辑修改每一个yml文件里面的全部的redis和mysql的相关配置，比如redis的IP，端口密码（这里我没有配置redis的密码），
mysql的IP端口root账号密码等信息，修改之后点击发布即可。
bash 复制代码 
#后端项目打包，即后端项目打jar包
将若依项目导入到Eclipse，打开Eclipse，菜单 File -> Import，然后选择 Maven -> Existing Maven Projects，点击 Next> 按钮，选择工作目录，然后点击 Finish 按钮，即可成功导入。
Eclipse会自动加载Maven依赖包，初次加载会比较慢（根据自身网络情况而定）
注意修改全部的bootstrap.yml文件的redis地址，nacos地址等信息，bootstrap.yml文件基本在下面这样的路径：
./ruoyi-auth/src/main/resources/bootstrap.yml
./ruoyi-gateway/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-file/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-gen/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-job/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-system/src/main/resources/bootstrap.yml
./ruoyi-visual/ruoyi-monitor/src/main/resources/bootstrap.yml
同时bootstrap.yml文件还要添加nacos的账号密码,如下：
.........
  profiles:
    # 环境配置
    active: dev		#这里保持默认是dev环境
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: 192.168.244.150:8848
        username: nacos		#添加nacos的登录账号密码
        password: nacos     #添加nacos的登录账号密码  	
      config:
        # 配置中心地址
        server-addr: 192.168.244.150:8848
        username: nacos		#添加nacos的登录账号密码
        password: nacos     #添加nacos的登录账号密码   	

#这里nacos没有配置命名空间，默认是public命名空间
#修改完bootstrap.yml文件后注意保存

在ruoyi项目的bin目录下执行package.bat打包Web工程，默认是生成jar包可执行文件。
打包完成之后会在对应的子项目下target目录下生成jar包。
clean.bat可以清除jar包，就是清除target目录下的文件。
jar包全都打包成功之后，可以启动jar包了，点击运行run-auth.bat文件运行启动auth即可，启动没报错显示启动正常即可，
由官网得知，只需启动下面这3个必须启动的模块即可：
（启动没有先后顺序）
RuoYiGatewayApplication （网关模块 必须）
RuoYiAuthApplication （认证模块 必须）
RuoYiSystemApplication （系统模块 必须）
RuoYiMonitorApplication （监控中心 可选）
RuoYiGenApplication （代码生成 可选）
RuoYiJobApplication （定时任务 可选）
RuoYFileApplication （文件服务 可选）

#最后，auth、Gateway、System均启动正常。
bash 复制代码 
#前端项目打包，即前端项目打制品包，默认是dist目录
#先修改前端配置文件
展开Eclipse里的若依项目下的rouyi-ui工程，打开vue.config.js文件，修改网关IP地址：
  proxy: {
      // detail: https://cli.vuejs.org/config/#devserver-proxy
      [process.env.VUE_APP_BASE_API]: {
        target: `http://localhost:8080`,	#这个配置为gateway网关的IP和端口
        changeOrigin: true,
        pathRewrite: {
          ['^' + process.env.VUE_APP_BASE_API]: ''
        }
      }

#开始打包前端，生成制品
# cmd窗口进入若依项目目录，然后切换到ruoyi-ui目录
cd ruoyi-ui
# 安装依赖
#npm install	#执行下面这条吧
# 强烈建议不要用直接使用 cnpm 安装，会有各种诡异的 bug，可以通过重新指定 registry 来解决 npm 安装速度慢的问题。
npm install --registry=https://registry.npmmirror.com

# 本地开发 启动项目
npm run dev		#此命令是本地开发环境下直接启动前端，执行后会在cmd查看打印登录url，复制粘贴到浏览器打开若依登录页面即可，账号密码默认自动回显了
#ruoyi-ui下的README.md文件说明了如何启动构建前端制品。

浏览器验证

cmd窗口执行启动：npm run dev

登录若依：

成功添加了用户：

docker部署若依-微服务版本

上面windows演示的是dev开发环境，这次我们使用docker部署prod生产环境。

bash 复制代码 
#官网写的部署环境要求,所以选择的版本要满足要求
JDK >= 1.8 (推荐1.8版本)
Mysql >= 5.7.0 (推荐5.7版本)
Redis >= 3.0
Maven >= 3.0
Node >= 12
nacos >= 2.0.4 (ruoyi-cloud < 3.0 需要下载nacos >= 1.4.x版本)
sentinel >= 1.6.0
bash 复制代码 
#准备一台centos7服务器
#安装好docker,可参考https://blog.csdn.net/MssGuo/article/details/122694156，同时要安装docker-compose
mkdir RuoYi-Cloud
cd RuoYi-Cloud
下载若依的源代码：https://gitee.com/y_project/RuoYi-Cloud，克隆/下载，下载ZIP即可。下载后上传到RuoYi-Cloud目录即可。
bash 复制代码 
#安装jdk1.8
#去https://www.oracle.com/java/technologies/downloads/下载对应版本的tar.gz包
tar -zxvf jdk1.8.tar.gz  -C /usr/local/
cd /usr/local/
mv jdk1.8.0_211  java
cat >> /etc/profile <<'EOF'
export JAVA_HOME=/usr/local/java
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin
EOF
source /etc/profile
java -version
bash 复制代码 
#安装maven，maven用于给java程序打jar包
wget https://dlcdn.apache.org/maven/maven-3/3.9.5/binaries/apache-maven-3.9.5-bin.tar.gz
tar xf apache-maven-3.9.5-bin.tar.gz 
mv apache-maven-3.9.5 /opt/maven
cat >> /etc/profile <<'EOF'
export M2_HOME=/opt/maven
export MAVEN_HOME=/opt/maven
export PATH=${M2_HOME}/bin:${PATH}
EOF
source  /etc/profile
mvn -v
bash 复制代码 
#安装npm,npm用于生成前端制品，即给前端生成dist目录
wget https://nodejs.org/dist/v14.4.0/node-v14.4.0-linux-x64.tar.xz
tar -xvf node-v14.4.0-linux-x64.tar.xz
mv node-v14.4.0-linux-x64 /usr/local/node
cat >> /etc/profile<<'EOF'
export NODE_HOME=/usr/local/node
export PATH=$NODE_HOME/bin:$PATH
EOF
source  /etc/profile
npm -v
node -v
bash 复制代码 
#解压源码包
unzip  RuoYi-Cloud-master.zip 
cd RuoYi-Cloud-master/
[root@rancher RuoYi-Cloud-master]# ll docker/	#可以看到源码包里面已经有docker相关的脚本了
total 12
-rw-r--r--. 1 root root 1155 Oct  2 12:46 copy.sh	#复制项目的jar文件到对应docker路径，便于一键生成镜像
-rw-r--r--. 1 root root 1335 Oct  2 12:46 deploy.sh	#部署脚本
-rw-r--r--. 1 root root 3416 Oct  2 12:46 docker-compose.yml	#docker-compose文件，可以看到每个容器暴露的宿主机端口
drwxr-xr-x. 3 root root   34 Oct  2 12:46 mysql		#构建mysql镜像
drwxr-xr-x. 3 root root   36 Oct  2 12:46 nacos		#构建nacos镜像
drwxr-xr-x. 4 root root   48 Oct  2 12:46 nginx		#构建nginx镜像
drwxr-xr-x. 3 root root   36 Oct  2 12:46 redis		#构建redis镜像
drwxr-xr-x. 6 root root   62 Oct  2 12:46 ruoyi		#各个若依项目的Dockerfile构建镜像
[root@rancher RuoYi-Cloud-master]#
bash 复制代码 
#先修改后端各个子项目的bootstrap.yml配置文件
[root@rancher RuoYi-Cloud-master]# find ./ -name bootstrap.yml
./ruoyi-auth/src/main/resources/bootstrap.yml
./ruoyi-gateway/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-file/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-gen/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-job/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-system/src/main/resources/bootstrap.yml
./ruoyi-visual/ruoyi-monitor/src/main/resources/bootstrap.yml
[root@rancher RuoYi-Cloud-master]# 
#修改bootstrap.yml文件中的环境配置为prod，nacos IP端口，添加nacos账号密码，命名空间等配置，示例如下：
vim ./ruoyi-auth/src/main/resources/bootstrap.yml
..............
  profiles:
    # 环境配置
    active: prod		#修改为prod，原来默认是dev
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: 192.168.244.150:8848	#nacos的IP地址，因为等下nacos使用容器启动暴露的就是宿主机8848端口
        username: nacos		#添加nacos的账号密码
        password: nacos		#添加nacos的账号密码
      config:
        # 配置中心地址
        server-addr: 192.168.244.150:8848	#nacos的IP地址，因为等下nacos使用容器启动暴露的就是宿主机8848端口
        username: nacos		#添加nacos的账号密码
        password: nacos		#添加nacos的账号密码
        namespace: prod		#指定nacos的命名空间是prod
        # 配置文件格式
        file-extension: yml
        # 共享配置
        shared-configs:
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}

#再修改前端vue.config.js配置文件
vim ruoyi-ui/vue.config.js
.......
devServer: {
    host: '0.0.0.0',
    port: port,
    open: true,
    proxy: {
      // detail: https://cli.vuejs.org/config/#devserver-proxy
      [process.env.VUE_APP_BASE_API]: {
        target: `http://192.168.244.150:8080`,		#修改为gateway的IP和端口，等下docker启动的网关容器就是暴露8080端口
        changeOrigin: true,
        pathRewrite: {
          ['^' + process.env.VUE_APP_BASE_API]: ''
        }
      }
    },
    disableHostCheck: true
  },

.......
bash 复制代码 
#后端项目打包，即后端项目打jar包
[root@rancher RuoYi-Cloud-master]# ls
bin  docker  LICENSE  pom.xml  README.md  ruoyi-api  ruoyi-auth  ruoyi-common  ruoyi-gateway  ruoyi-modules  ruoyi-ui  ruoyi-visual  sql
[root@rancher RuoYi-Cloud-master]# mvn clean package -Dmaven.test.skip=true			#在项目的根路径执行打包
#以上打包命令执行完成会在每个子项目里面生成target命令，该target命令就存放有jar包

#前端项目打包
cd ruoyi-ui/	#进入前端项目目录
npm install --registry=https://registry.npmmirror.com
# 打包正式环境
npm run build:prod	#执行这个，因为我们就是要模拟prod环境
构建打包成功之后，会在根目录生成 dist 文件夹，里面就是构建打包好的文件，通常是 ***.js 、***.css、index.html 等静态文件。

#下面两个了解即可
npm run dev				# 本地开发 启动项目
npm run build:stage		# 打包预发布环境
#到底都有哪些环境？在前端目录下的package.json文件中定义了好几种配置环境，如下：
vim ruoyi-ui/package.json
  "scripts": {
    "dev": "vue-cli-service serve",
    "build:prod": "vue-cli-service build",
    "build:stage": "vue-cli-service build --mode staging",
    "preview": "node build/index.js --preview",
    "lint": "eslint --ext .js,.vue src"
  }
bash 复制代码 
#拷贝文件
#先修改mysql的建库建表语句，不然mysql容器没有创建若依的数据库
[root@rancher ]# cd RuoYi-Cloud-master
[root@rancher RuoYi-Cloud-master]# ls sql/
quartz.sql  ry_20230706.sql  ry_config_20220929.sql  ry_seata_20210128.sql
#ry_20230706.sql是若依系统表，ry_config_20220929.sql是nacos的库和表
#因为ry_20230706.sql文件里没有写创建库的语句，所以这里手动添加创建ry-cloud库的语句，库名是官网规定的。
#如下，在ry_20230706.sql文件开头添加即可：
DROP DATABASE IF EXISTS `ry-cloud`;
CREATE DATABASE  `ry-cloud` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
USE `ry-cloud`;

#nacos配置的数据库源在application.properties文件
#检查确认即可，一般不用修改
[root@rancher docker]# ls nacos/conf/application.properties
[root@rancher ]# cd docker/		#进入docker目录
[root@rancher docker]# sh copy.sh 	#执行脚本，脚本作用是拷贝前端、后端，SQL文件到当前docker目录对应的目录下
bash 复制代码 
#启动、创建mysql、nacos、redis容器
cd RuoYi-Cloud-master/docker
cat deploy.sh 	#查看脚本内容
[root@rancher docker]# sh deploy.sh -h
Usage: sh 执行脚本.sh [port|base|modules|stop|rm]
[root@rancher docker]# sh deploy.sh base	#构建mysql、redis、nacos镜像并启动容器
[root@rancher docker]# docker ps -a			#查看启动的容器
CONTAINER ID   IMAGE                COMMAND                  CREATED              STATUS              PORTS                                                                                                      NAMES
e2a889d611e2   nacos/nacos-server   "bin/docker-startup...."   About a minute ago   Up About a minute   0.0.0.0:8848->8848/tcp, :::8848->8848/tcp, 0.0.0.0:9848-9849->9848-9849/tcp, :::9848-9849->9848-9849/tcp   ruoyi-nacos
7bb841dc0b2e   mysql:5.7            "docker-entrypoint.s..."   About a minute ago   Up About a minute   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp                                                       ruoyi-mysql
220a10a7cae2   redis                "docker-entrypoint.s..."   About a minute ago   Up About a minute   0.0.0.0:6379->6379/tcp, :::6379->6379/tcp                                                                  ruoyi-redis
#检查redis容器的日志输出，正常，在windows使用Redis Desktop Manager 正常链接redis
#检查mysql容器的日志，显示异常
2023-10-09T15:26:31.877145Z 2 [Note] Unknown database 'ry-config'
2023-10-09T15:26:34.922364Z 3 [Note] Unknown database 'ry-config'
2023-10-09T15:26:34.923423Z 4 [Note] Unknown database 'ry-config'
2023-10-09T15:26:36.925682Z 5 [Note] Unknown database 'ry-config'
#登录mysql 容器检查
[root@rancher docker]# docker exec -it ruoyi-mysql bash
root@43f59febb6b2:/# mysql -ppassword			#默认的root密码在docker-compose.yml中写有
mysql> show databases;		#发现没有创建ry-config库
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| ry-cloud           |
| sys                |
+--------------------+
mysql> use ry-cloud;
mysql> show tables;		#ry-cloud也没有创建表
Empty set (0.00 sec)
mysql> exit
root@43f59febb6b2:/# ls /docker-entrypoint-initdb.d/	#发现这里面没有我们的建库建表文件
root@43f59febb6b2:/# exit
[root@rancher mysql]# pwd
/root/RuoYi-Cloud/RuoYi-Cloud-master/docker/mysql
[root@rancher mysql]# ls
conf  data  db  dockerfile  logs
[root@rancher mysql]# cat dockerfile 	#查看dockerfile文件是怎么构建mysql镜像的
# 基础镜像
FROM mysql:5.7
# author
MAINTAINER ruoyi
# 执行sql脚本
ADD ./db/*.sql /docker-entrypoint-initdb.d/
[root@rancher mysql]# 
#这说明构建后的镜像里面根本没有建库建表的文件，而ry-cloud库是docker-compose.yml文件指定的创建库名而已
#所以说根本没有执行建库建表初始化操作
#手动执行初始化
docker cp mysql/db/ry_20230706.sql  ruoyi-mysql:/docker-entrypoint-initdb.d/
docker cp mysql/db/ry_config_20220929.sql  ruoyi-mysql:/docker-entrypoint-initdb.d/
docker exec -it ruoyi-mysql bash
mysql -ppassword
mysql> source /docker-entrypoint-initdb.d/ry_20230706.sql;
mysql> source /docker-entrypoint-initdb.d/ry_config_20220929.sql;
mysql> use mysql;		#授权让mysql可以在windows链接
mysql> update user set host='%' where user='root';
mysql> FLUSH PRIVILEGES;
mysql> exit;
docker restart ruoyi-mysql
docker logs -f  ruoyi-mysql
#windows使用Navicat Premium链接mysql数据库正常。

#重启nacos，因为mysql仓库刚刚创建好，所需要重启nacos容器
#nacos容器正常，浏览器登录nacos
http://192.168.244.150:8848/nacos/index.html	登录账号密码：nacos/nacos
#由于前面我们java项目的bootstrap.yml配置文件定义的nacos命名空间是prod，所以在nacos上需要创建一个名称叫做prod的命名空间
权限控制-->命名空间-->新建命名空间 --> 命名空间名称填写：prod -->描述写生产环境即可-->确定
#克隆public命名空间的yml文件到prod 命名空间
配置管理--> 配置列表 --> 选择public命名空间 -->勾选全部的yml文件 -->底部点击克隆按钮 -->目标空间选择prod -->把每一个文件名中的dev改成prod，如ruoyi-gateway-prod.yml--> 点击克隆按钮完成克隆即可

前面后端项目中的bootstrap.yml配置文件中的环境配置是prod，所以nacos中要存在"应用名称-环境配置.配置文件格式"拼接起来的文件，如ruoyi-gateway-prod.yml，所以上面克隆的时候我们修改了文件的名称。
最后，修改prod命名空间下的每个yml文件中的redis，mysql相关的配置，最后发布即可。
bash 复制代码 
#启动、创建前端和后端容器
#从该文件可以看到前端使用nginx配置，nginx配置文件中配置了代理的网关IP地址，默认不用修改该文件
[root@rancher docker]# cat nginx/conf/nginx.conf 
[root@rancher docker]# grep -B 2 deploy.sh	#查看启动服务
modules(){
	docker-compose up -d ruoyi-nginx ruoyi-gateway ruoyi-auth ruoyi-modules-system
}

[root@rancher docker]# sh deploy.sh modules					#部署前端后端容器
[root@rancher docker]# docker logs -f ruoyi-modules-system	#日志正常
[root@rancher docker]# docker logs -f ruoyi-gateway			#日志正常
[root@rancher docker]# docker logs -f ruoyi-auth			#日志正常
[root@rancher docker]# docker logs -f ruoyi-nginx			#日志正常
[root@rancher docker]# docker port ruoyi-nginx				#前端暴露的80端口
80/tcp -> 0.0.0.0:80
80/tcp -> :::80

浏览器验证

浏览器验证：宿主机IP:80

添加用户正常：

k8s部署若依-微服务版本

1、首先需要一个k8s集群，默认你已经安装好了k8s集群并且有动态存储供给。

2、下载若依的源码包并上传到服务器master节点上，也可以放到一台单独的服务。

bash 复制代码 
#创建mysql pod
cat >>mysql.yaml<<'EOF' 
apiVersion: apps/v1
kind: StatefulSet
metadata:
  labels:
    app: mysql
  name: mysql
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  serviceName: mysql-svc
  template:
    metadata:
      annotations:
      labels:
        app: mysql
    spec:
      containers:
      - env:
        - name: MYSQL_ROOT_PASSWORD
          value: Aa123456
        image: mysql:5.7.35
        imagePullPolicy: IfNotPresent
        name: mysql
        ports:
        - containerPort: 3306
          name: tcp-3306
          protocol: TCP
        - containerPort: 33060
          name: tcp-33060
          protocol: TCP
        securityContext:
          privileged: true
        volumeMounts:
        - mountPath: /etc/localtime
          name: host-time
        - mountPath: /var/lib/mysql
          name: mysql
      restartPolicy: Always
      volumes:
      - hostPath:
          path: /etc/localtime
          type: ""
        name: host-time
  updateStrategy:
    rollingUpdate:
      partition: 0
    type: RollingUpdate
  volumeClaimTemplates:
  - apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: mysql
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
      storageClassName: nfs-storageclass
      volumeMode: Filesystem
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: mysql-svc
  name: mysql-svc
  namespace: default
spec:
  clusterIP: None
  ports:
  - name: tcp-3306
    port: 3306
    protocol: TCP
    targetPort: 3306
  - name: tcp-33060
    port: 33060
    protocol: TCP
    targetPort: 33060
  selector:
    app: mysql
  sessionAffinity: None
  type: ClusterIP
EOF  
kubectl apply -f mysql.yml
#mysql导入数据
[root@master01 ~]# cd RuoYi-Cloud-master/sql/
[root@master01 sql]# ls
quartz.sql  ry_20230706.sql  ry_config_20220929.sql  ry_seata_20210128.sql
#ry_20230706.sql是若依系统表，ry_config_20220929.sql是nacos的库和表
#因为ry_20230706.sql文件里没有写创建库的语句，所以这里手动添加创建ry-cloud库的语句，库名是官网规定的。
#如下，在ry_20230706.sql文件开头添加即可：
DROP DATABASE IF EXISTS `ry-cloud`;
CREATE DATABASE  `ry-cloud` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
USE `ry-cloud`;

[root@master01 sql]# kubectl  cp ry_20230706.sql mysql-0:/
[root@master01 sql]# kubectl  cp ry_config_20220929.sql mysql-0:/
[root@master01 sql]# kubectl  exec -it  mysql-0 -- bash
root@mysql-0:/# mysql -uroot -pAa123456
mysql> source /ry_20230706.sql;
mysql> source /ry_config_20220929.sql;
mysql> exit;
bash 复制代码 
#创建redis
cat >>redis.yaml <<'EOF' 
apiVersion: apps/v1
kind: StatefulSet
metadata:
  labels:
    app: redis
  name: redis
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  serviceName: redis-svc
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - args:
        - /etc/redis/redis.conf
        command:
        - redis-server
        image: redis:7.0.7
        imagePullPolicy: IfNotPresent
        name: redis
        ports:
        - containerPort: 6379
          name: tcp-6379
          protocol: TCP
        volumeMounts:
        - mountPath: /etc/localtime
          name: host-time
        - mountPath: /data
          name: reids-pvc
        - mountPath: /etc/redis
          name: redis-conf
          readOnly: true
      restartPolicy: Always
      volumes:
      - hostPath:
          path: /etc/localtime
          type: ""
        name: host-time
      - configMap:
          defaultMode: 420
          name: redis-config
        name: redis-conf
  volumeClaimTemplates:
  - apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: reids-pvc
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
      storageClassName: nfs-storageclass
      volumeMode: Filesystem
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: redis-svc
  name: redis-svc
  namespace: default
spec:
  clusterIP: None
  ports:
  - name: tcp-6379
    port: 6379
    protocol: TCP
    targetPort: 6379
  selector:
    app: redis
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: v1
data:
  redis.conf: |-
    appendonly yes
    port 6379
    bind 0.0.0.0
    requirepass Aa123456	#redis 设置了密码
kind: ConfigMap
metadata:
  name: redis-config
  namespace: default
EOF
kubectl apply -f redis.yml
bash 复制代码 
#部署nacos
cat >> nacos.yml <<'EOF' 
---
apiVersion: v1
kind: Service
metadata:
  name: nacos-svc
  namespace: default
  labels:
    app: nacos
spec:
  ports:
    - port: 8848
      name: server
      targetPort: 8848
      nodePort: 30848
  type: NodePort
  selector:
    app: nacos
---
apiVersion: v1
kind: Service
metadata:
  name: nacos-headless
  namespace: default
  labels:
    app: nacos
spec:
  publishNotReadyAddresses: true 
  ports:
    - port: 8848
      name: server
      targetPort: 8848
  clusterIP: None
  selector:
    app: nacos
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: nacos-cm
  namespace: default
data:
  mysql.host: "mysql-svc.default"
  mysql.db.name: "ry-config"	#nacos要连接ry-config数据库
  mysql.port: "3306"
  mysql.user: "root"
  mysql.password: "Aa123456"
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: nacos
  namespace: default
spec:
  serviceName: nacos-headless
  replicas: 1 
  template:
    metadata:
      labels:
        app: nacos
      annotations:
        pod.alpha.kubernetes.io/initialized: "true"
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: "app"
                    operator: In
                    values:
                      - nacos
              topologyKey: "kubernetes.io/hostname"
      containers:
        - name: nacos
          imagePullPolicy: Always
          image: nacos/nacos-server:latest
          resources:
            requests:
              memory: "1Gi"
              cpu: "800m"
          ports:
            - containerPort: 8848
              name: client-port
          env:  
            - name: NACOS_AUTH_TOKEN            
              value: "Ym1GamIzTWdhWE1nZG1WeWVTQm5iMjlrSUhOdlpuUjNZWEpsQ2c9PQo="
            - name: NACOS_AUTH_IDENTITY_KEY
              value: "nacos"
            - name: NACOS_AUTH_IDENTITY_VALUE
              value: "nacos" 
            - name: MODE    
              value: "standalone"                                                                                       
            - name: NACOS_REPLICAS
              value: "1"
            - name: SERVICE_NAME
              value: "nacos-headless"
            - name: DOMAIN_NAME
              value: "cluster.local"
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: metadata.namespace
            - name: MYSQL_SERVICE_HOST
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.host
            - name: MYSQL_SERVICE_DB_NAME
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.db.name
            - name: MYSQL_SERVICE_PORT
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.port
            - name: MYSQL_SERVICE_USER
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.user
            - name: MYSQL_SERVICE_PASSWORD
              valueFrom:
                configMapKeyRef:
                  name: nacos-cm
                  key: mysql.password
            - name: SPRING_DATASOURCE_PLATFORM
              value: "mysql"
            - name: NACOS_SERVER_PORT
              value: "8848"
            - name: NACOS_APPLICATION_PORT
              value: "8848"
          volumeMounts:
            - name: data
              mountPath: /home/nacos/data
              subPath: data
            - name: data
              mountPath: /home/nacos/logs
              subPath: logs
  volumeClaimTemplates:
    - metadata:
        name: data
        annotations:
          volume.beta.kubernetes.io/storage-class: "nfs-storageclass"
      spec:
        accessModes: [ "ReadWriteMany" ]
        resources:
          requests:
            storage: 1Gi
  selector:     
    matchLabels:
      app: nacos
EOF
kubectl apply -f nacos.yml
#浏览器登录nacos: http://192.168.244.151:30848/nacos  账号密码：nacos/nacos
bash 复制代码 
#在若依源码包服务器上配置服务器环境，这里是master01节点
#安装jdk1.8
#去https://www.oracle.com/java/technologies/downloads/下载对应版本的tar.gz包
tar -zxvf jdk1.8.tar.gz  -C /usr/local/
cd /usr/local/
mv jdk1.8.0_211  java
cat >> /etc/profile <<'EOF'
export JAVA_HOME=/usr/local/java
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin
EOF
source /etc/profile
java -version

#安装maven，maven用于给java程序打jar包
wget https://dlcdn.apache.org/maven/maven-3/3.9.5/binaries/apache-maven-3.9.5-bin.tar.gz
tar xf apache-maven-3.9.5-bin.tar.gz 
mv apache-maven-3.9.5 /opt/maven
cat >> /etc/profile <<'EOF'
export M2_HOME=/opt/maven
export MAVEN_HOME=/opt/maven
export PATH=${M2_HOME}/bin:${PATH}
EOF
source  /etc/profile
mvn -v

#安装npm,npm用于生成前端制品，即给前端生成dist目录
wget https://nodejs.org/dist/v14.4.0/node-v14.4.0-linux-x64.tar.xz
tar -xvf node-v14.4.0-linux-x64.tar.xz
mv node-v14.4.0-linux-x64 /usr/local/node
cat >> /etc/profile<<'EOF'
export NODE_HOME=/usr/local/node
export PATH=$NODE_HOME/bin:$PATH
EOF
source  /etc/profile
npm -v
node -v
bash 复制代码 
#先修改后端各个子项目的bootstrap.yml配置文件
[root@rancher RuoYi-Cloud-master]# find ./ -name bootstrap.yml
./ruoyi-auth/src/main/resources/bootstrap.yml
./ruoyi-gateway/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-file/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-gen/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-job/src/main/resources/bootstrap.yml
./ruoyi-modules/ruoyi-system/src/main/resources/bootstrap.yml
./ruoyi-visual/ruoyi-monitor/src/main/resources/bootstrap.yml
[root@rancher RuoYi-Cloud-master]# 
#修改bootstrap.yml文件中的环境配置为prod，nacos IP端口，添加nacos账号密码，命名空间等配置，示例如下：
vim ./ruoyi-auth/src/main/resources/bootstrap.yml
..............
  profiles:
    # 环境配置
    active: prod		#修改为prod，原来默认是dev
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: nacos-headless.default:8848	#nacos的svc地址
        username: nacos		#添加nacos的账号密码
        password: nacos		#添加nacos的账号密码
      config:
        # 配置中心地址
        server-addr: nacos-headless.default:8848	#nacos的svc地址
        username: nacos		#添加nacos的账号密码
        password: nacos		#添加nacos的账号密码
        namespace: prod		#指定nacos的命名空间是prod
        # 配置文件格式
        file-extension: yml
        # 共享配置
        shared-configs:
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}

#再修改前端vue.config.js配置文件
vim ruoyi-ui/vue.config.js
.......
    proxy: {
      // detail: https://cli.vuejs.org/config/#devserver-proxy
      [process.env.VUE_APP_BASE_API]: {
        target: `http://gateway-svc.default:8080`,		#修改为gateway的svc地址和端口，后面会创建gateway-svc这个service
        changeOrigin: true,
.......
bash 复制代码 
#后端项目打包，即后端项目打jar包
[root@rancher RuoYi-Cloud-master]# mvn clean package -Dmaven.test.skip=true			#在项目的根路径执行打包
#以上打包命令执行完成会在每个子项目里面生成target命令，该target命令就存放有jar包

#前端项目打包
cd ruoyi-ui/	#进入ruoyi-ui前端项目目录
npm install --registry=https://registry.npmmirror.com
# 打包正式环境
npm run build:prod	#执行这个，因为我们就是要上限prod环境，bootstrap.yml配置的环境也是prod
构建打包成功之后，会在根目录生成 dist 文件夹，里面就是构建打包好的前端文件，通常是 ***.js 、***.css、index.html 等静态文件。
bash 复制代码 
#浏览器登录nacos,创建prod命名空间
浏览器登录nacos: http://192.168.244.151:30848/nacos  账号密码：nacos/nacos
#由于前面我们java项目的bootstrap.yml配置文件定义的nacos命名空间是prod，所以在nacos上需要创建一个名称叫做prod的命名空间
权限控制-->命名空间-->新建命名空间 --> 命名空间名称填写：prod -->描述写生产环境即可-->确定
#克隆public命名空间的yml文件到prod 命名空间
配置管理--> 配置列表 --> 选择public命名空间 -->勾选全部的yml文件 -->底部点击克隆按钮 -->目标空间选择prod -->把每一个文件名中的dev改成prod，如ruoyi-gateway-prod.yml--> 点击克隆按钮完成克隆即可

前面后端项目中的bootstrap.yml配置文件中的环境配置是prod，所以nacos中要存在"应用名称-环境配置.配置文件格式"拼接起来的文件，如ruoyi-gateway-prod.yml，所以上面克隆的时候我们修改了文件的名称。
最后，修改prod命名空间下的每个yml文件中的redis，mysql相关的配置，相关的IP需要配置为svc域名，如：
 redis:
    host: redis-svc.default			#redis的域名
    port: 6379	
    password: Aa123456				#redis的密码
datasource:							#mysql的域名nacos-headless.default
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://mysql-svc.default:3306/ry-cloud?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    username: root
    password: Aa123456				#mysql的密码
最后点击发布即可。
bash 复制代码 
#制作后端镜像
[root@master01 RuoYi-Cloud-master]# cd docker/
[root@master01 docker]# sh copy.sh 	#执行脚本复制子项目的jar到当前docker目录下的对应目录
#构建auth镜像
[root@master01 docker]# cd ruoyi/auth
[root@master01 auth]# docker build -t docker-ruoyi-auth:latest .
#构建gateway镜像
[root@master01 docker]# cd ruoyi/gateway/
[root@master01 gateway]# docker build -t docker-ruoyi-gateway:latest .
#构建model-system镜像
[root@master01 docker]# cd ruoyi/modules/system/
[root@master01 system]# docker build -t docker-ruoyi-system:latest .
#制作前端镜像
[root@master01 docker]# cd nginx/
[root@master01 nginx]# vim  conf/nginx.conf		#编辑配置文件
     location /prod-api/{
			.......
            proxy_pass http://gateway-svc.default:8080/;			#修改proxy_pass参数的gateway域名
        }
[root@master01 nginx]# docker build -t nginx:v1 .	#注意前端镜像tag不要写latest,否则构建出来的镜像会有问题，因为dockerfile中FROM就是nginx
bash 复制代码 
#创建auth的k8s资源
cat >>ruoyi-auth.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ruoyi-auth
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: auth
  template:
    metadata:
      labels:
        app: auth
    spec:
      nodeName: master01
      containers:
      - image: docker-ruoyi-auth
        imagePullPolicy: IfNotPresent
        name: ruoyi-auth
        ports:
        - containerPort: 9200
          name: auth-9200
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: auth-svc
  name: auth-svc
  namespace: default
spec:
  ports:
  - name: auth-svc
    port: 9200
    protocol: TCP
    targetPort: 9200
  selector:
    app: auth 
  sessionAffinity: None
  type: ClusterIP
EOF
kubectl  apply  -f ruoyi-auth.yaml 
kubectl  logs  -f ruoyi-auth-7f9f89c4cb-c6wm5 

#创建gateway相关的k8s资源
cat >>ruoyi-gateway.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ruoyi-gateway
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gateway 
  template:
    metadata:
      labels:
        app: gateway
    spec:
      nodeName: master01
      containers:
      - image: docker-ruoyi-gateway
        imagePullPolicy: IfNotPresent
        name: ruoyi-gateway
        ports:
        - containerPort: 8080
          name: gateway-8080
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: gateway-svc
  name: gateway-svc
  namespace: default
spec:
  ports:
  - name: gateway-svc		#这个svc在前端的配置文件中引用了
    port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    app: gateway 
  sessionAffinity: None
  type: ClusterIP
EOF
kubectl  apply  -f ruoyi-gateway.yaml 
kubectl  logs  -f ruoyi-gateway-6f6497d6fb-5bl7h 
#创建gateway相关的k8s资源
cat >>ruoyi-system.yaml<<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ruoyi-system
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: system
  template:
    metadata:
      labels:
        app: system
    spec:
      nodeName: master01
      containers:
      - image: docker-ruoyi-system
        imagePullPolicy: IfNotPresent
        name: ruoyi-system
        ports:
        - containerPort: 9201
          name: system-9201
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: system-svc
  name: system-svc
  namespace: default
spec:
  ports:
  - name: system-svc
    port: 9201
    protocol: TCP
    targetPort: 9201
  selector:
    app: system
  sessionAffinity: None
  type: ClusterIP
EOF
kubectl  apply  -f ruoyi-system.yaml
kubectl  logs  -f ruoyi-system-7d5858d47d-fr7wc 
#创建前端nginx的k8s资源
cat >>ruoyi-nginx.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: ruoyi-nginx
  name: ruoyi-nginx
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ruoyi-nginx
  template:
    metadata:
      labels:
        app: ruoyi-nginx
    spec:
      nodeName: master01
      containers:
      - image: nginx:v1
        imagePullPolicy: IfNotPresent
        name: ruoyi-nginx
        ports:
        - containerPort: 80
          name: tcp-80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: ruoyi-nginx-svc
  name: ruoyi-nginx-svc 
  namespace: default
spec:
  ports:
  - nodePort: 30888
    port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: ruoyi-nginx
  type: NodePort
EOF
kubectl appl -f ruoyi-nginx.yaml
[root@master01 docker]# kubectl  get -f ruoyi-nginx.yaml 
NAME                          READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/ruoyi-nginx   1/1     1            1           3h28m

NAME                      TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
service/ruoyi-nginx-svc   NodePort   10.106.135.173   <none>        80:30888/TCP   3h28m
#nginx 访问端口就是30888

浏览器验证

登录：

url为master节点IP+ruoyi-nginx-svc的外部端口30888。

创建用户正常：

总结

1、关于nacos的配置

以上我们熟悉了在java程序中nacos是如何配置的，即在每一个子项目中都会有一个bootstrap.yml文件，我们来仔细解读一下该文件：

bash 复制代码 
cat ./ruoyi-auth/src/main/resources/bootstrap.yml
# Tomcat
server: 
  port: 9200	#程序的端口
# Spring
spring: 
  application:
    # 应用名称
    name: ruoyi-auth	#应用名称，nacos中配置文件一般也与应用名称对应
  profiles:
    # 环境配置
    active: prod		#指定环境配置，程序启动时会激活对应的环境，nacos会根据这个环境来读取对应的文件，
#现在环境配置是prod，那么nacos中会存在"应用名称-环境配置.配置文件格式"拼接起来的文件，如ruoyi-auth-prod.yml，程序启动时就会读该文件
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: 192.168.244.150:8848	#nacos的IP地址
        username: nacos		#nacos的账号密码
        password: nacos		#nacos的账号密码
      config:
        # 配置中心地址
        server-addr: 192.168.244.150:8848	#nacos的IP地址，因为等下nacos使用容器启动暴露的就是宿主机8848端口
        username: nacos		#nacos的账号密码
        password: nacos		#nacos的账号密码
        namespace: prod		#指定nacos的命名空间，默不写该参数默认是public命名空间
        # 配置文件格式
        file-extension: yml	#一般与nacos的配置文件对应
        # 共享配置
        shared-configs:		#可以看到这个参数拼接起来就是application-prod.yml文件，而这个文件是nacos上面有的
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
#下面是一段ruoyi-auth启动日志
#可以看的出来，激活的是prod环境，读取的配置文件是ruoyi-auth.yml
16:28:03.574 [main] WARN  c.a.c.n.c.NacosPropertySourceBuilder - [loadNacosData,87] - Ignore the empty nacos configuration and get it based on dataId[ruoyi-auth] & group[DEFAULT_GROUP]
16:28:03.581 [main] WARN  c.a.c.n.c.NacosPropertySourceBuilder - [loadNacosData,87] - Ignore the empty nacos configuration and get it based on dataId[ruoyi-auth.yml] & group[DEFAULT_GROUP]
16:28:03.607 [main] INFO  c.r.a.RuoYiAuthApplication - [logStartupProfileInfo,637] - The following 1 profile is active: "prod"
16:28:05.975 [main] INFO  o.a.c.h.Http11NioProtocol - [log,173] - Initializing ProtocolHandler ["http-nio-9200"]
16:28:05.988 [main] INFO  o.a.c.c.StandardService - [log,173] - Starting service [Tomcat]


#前端链接后端是如何配置的，答案是在前端的配置文件里面配置了网关的IP和端口
#前端vue.config.js配置文件
vim ruoyi-ui/vue.config.js
.......
devServer: {
    host: '0.0.0.0',
    port: port,
    open: true,
    proxy: {
      // detail: https://cli.vuejs.org/config/#devserver-proxy
      [process.env.VUE_APP_BASE_API]: {
        target: `http://192.168.244.150:8080`,		#gateway网关的IP和端口，表示前端的请求要转发给这个网关
        changeOrigin: true,
        pathRewrite: {
          ['^' + process.env.VUE_APP_BASE_API]: ''
        }
      }
    },
    disableHostCheck: true
  },
#前端打包时到底都有哪些环境？在前端目录下的package.json文件中定义了好几种配置环境，如下：
vim ruoyi-ui/package.json
  "scripts": {
    "dev": "vue-cli-service serve",
    "build:prod": "vue-cli-service build",
    "build:stage": "vue-cli-service build --mode staging",
    "preview": "node build/index.js --preview",
    "lint": "eslint --ext .js,.vue src"
  }
所以进入前端项目目录
cd ruoyi-ui/	
npm install --registry=https://registry.npmmirror.com
npm run build:prod		# 打包正式环境
npm run dev				# 本地开发 启动项目
npm run build:stage		# 打包预发布环境  
构建打包成功之后，会在根目录生成dist目录，里面就是构建打包好的文件，通常是 ***.js 、***.css、index.html 等静态文件。
然后将dist目录的静态文件发布nginx服务器即可启动前端。这个dist目录也是可以配置的，在ruoyi-ui/vue.config.js配置文件中的outputDir参数配置。
#settings.js配置文件
vim ruoyi-ui/src/settings.js	#settings.js配置文件可以定义前端显示的布局

2、前端使用nginx启动

前端使用nginx启动，在nginx.conf文件配置了反向代理到网关地址。

3、下面是auth程序启动日志

可以看到，程序启动时区注册nacos，并且激活的是prod环境，链接的配置文件是ruoyi-auth.yml文件。

jar包中bootstrap.yml文件：

vim ruoyi-auth.jar

相关推荐
一勺菠萝丶1 小时前
MongoDB 常用操作指南（Docker 环境下）
数据库·mongodb·docker
Mitch3111 小时前
【漏洞复现】CVE-2015-3337 Arbitrary File Reading
elasticsearch·网络安全·docker·漏洞复现
Mitch3111 小时前
【漏洞复现】CVE-2015-5531 Arbitrary File Reading
web安全·elasticsearch·网络安全·docker·漏洞复现
我自飞扬临天下3 小时前
Docker常用命令
docker
科技互联人生3 小时前
微服务常用的中间件及其用途
微服务·中间件·系统架构
小蜗牛慢慢爬行4 小时前
如何在 Spring Boot 微服务中设置和管理多个数据库
java·数据库·spring boot·后端·微服务·架构·hibernate
码农土豆5 小时前
PaddlePaddle飞桨Linux系统Docker版安装
linux·docker·paddlepaddle
小扳7 小时前
微服务篇-深入了解 MinIO 文件服务器（你还在使用阿里云 0SS 对象存储图片服务？教你使用 MinIO 文件服务器：实现从部署到具体使用）
java·服务器·分布式·微服务·云原生·架构
明 庭15 小时前
Ubuntu下通过Docker部署NGINX服务器
服务器·ubuntu·docker
dessler16 小时前
Docker-run命令详细讲解
linux·运维·后端·docker
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10RAG 实践- Ollama+RagFlow 部署本地知识库