Linux下Ruoyi前后端不分离版部署全攻略：从JDK配置到Docker实战
在当今快速迭代的软件开发领域，一套成熟的后台管理系统能够极大提升开发效率，让团队更专注于核心业务逻辑的实现。RuoYi作为国内广受欢迎的Java EE企业级快速开发平台，以其经典的技术栈组合（Spring Boot、Apache Shiro、MyBatis、Thymeleaf）和丰富的功能模块，成为了众多中大型项目的首选脚手架。对于需要在Linux生产环境中部署RuoYi前后端不分离版本的开发者而言，从零开始搭建一套稳定、高效的运行环境，既是必备技能，也常伴随着各种“坑点”。
本文旨在为中级开发者提供一份详尽、可落地的实战指南，不仅涵盖从JDK、Maven、Git等基础环境搭建到项目最终上线的全流程，更会深入探讨在阿里云等主流云服务器上部署时遇到的高频问题及其解决方案。我们将摒弃简单的命令罗列，转而从架构理解、配置原理和运维实践的角度，带你走完一次完整的部署之旅。无论你是首次接触RuoYi部署，还是希望优化现有部署流程，这篇文章都将提供有价值的参考。
1. 环境准备与规划：构建稳固的基石
部署任何Java Web项目前，一个清晰、隔离且易于维护的服务器目录结构是成功的第一步。这不仅能避免后续的混乱，也为自动化运维和问题排查打下基础。我个人的习惯是在/data目录下建立清晰的子目录，将不同类型的文件归类存放。
# 创建核心目录结构
sudo mkdir -p /data/{service,app,logs,backup,scripts}
# service: 存放所有软件环境，如JDK、Maven等
# app: 存放应用程序，如Ruoyi的jar包
# logs: 统一存放应用日志
# backup: 用于备份数据库、配置文件等
# scripts: 存放部署、维护用的Shell脚本
对于RuoYi前后端不分离版本，其核心依赖环境相对明确：
| 组件 | 最低版本要求 | 推荐版本 | 主要作用 |
|---|---|---|---|
| JDK | 1.8 | OpenJDK 11 / Oracle JDK 1.8 | Java程序运行环境 |
| Maven | 3.0 | 3.6.3+ | 项目构建与依赖管理 |
| Git | 2.x | 2.18.0+ | 代码版本控制与拉取 |
| MySQL | 5.7 | 5.7 / 8.0 | 关系型数据库 |
| Docker | 18.09+ | 20.10+ | 容器化运行MySQL（可选但推荐） |
提示：虽然RuoYi官方文档注明支持JDK 1.8，但在生产环境中，我强烈建议考虑使用OpenJDK 11或更高版本，以获得更好的性能、安全性和长期支持。不过，为了与大多数教程保持一致，本文仍以JDK 1.8为例进行演示。
在开始安装前，请确保你的Linux服务器（以CentOS 7/8或Ubuntu 20.04为例）已更新到最新状态，并具备基本的网络连接能力。一个常见的“坑”是服务器默认的软件源速度较慢，我们可以先替换为国内镜像源以加速后续的软件安装过程。
2. 核心环境安装与深度配置
2.1 JDK安装：不止于JAVA_HOME
许多教程会直接让你下载Oracle JDK的tar包并配置环境变量，但这存在几个问题：手动管理版本升级麻烦，且Oracle JDK的许可证可能带来商业风险。对于生产环境，我更倾向于使用系统包管理器安装OpenJDK，或者使用像jenv这样的多版本管理工具。
方案一：使用YUM/DNF安装OpenJDK（推荐用于生产环境）
# CentOS/RHEL
sudo yum install -y java-1.8.0-openjdk-devel
# 验证安装
java -version
# 输出应类似：openjdk version "1.8.0_402"
方案二：手动安装特定版本JDK（适用于需要精确控制版本的情况）
如果你确实需要某个特定的JDK版本（比如Oracle JDK 8u261），可以按以下步骤操作。首先，从官方或可信镜像站下载对应版本的tar.gz包，然后将其解压到我们规划好的/data/service目录。
# 假设已将jdk-8u261-linux-x64.tar.gz上传至服务器/tmp目录
cd /tmp
sudo tar -zxvf jdk-8u261-linux-x64.tar.gz -C /data/service/
接下来是配置环境变量的关键步骤。很多新手会直接修改/etc/profile，但这会影响所有用户。更优雅的做法是为你的应用创建一个专属的环境变量文件。
# 创建应用专用的环境变量文件
sudo tee /etc/profile.d/ruoyi_env.sh << 'EOF'
export JAVA_HOME=/data/service/jdk1.8.0_261
export PATH=$JAVA_HOME/bin:$PATH
# 设置JVM默认参数，根据服务器内存调整
export JAVA_OPTS="-Xms512m -Xmx1024m -XX:+UseG1GC"
EOF
# 使配置生效
source /etc/profile.d/ruoyi_env.sh
注意：
JAVA_OPTS中的内存参数需要根据你的服务器实际配置进行调整。对于2GB内存的服务器，-Xmx1024m是一个安全的起点；对于4GB或以上，可以考虑设置为-Xmx2048m。G1垃圾收集器在JDK 8u40及以上版本中表现稳定，适合大多数Web应用。
2.2 Maven配置：加速依赖下载的艺术
Maven的安装过程与JDK类似，但配置其镜像仓库是提升构建速度的关键。默认的中央仓库在国内访问速度堪忧，我们必须将其替换为阿里云镜像。
# 下载并解压Maven
cd /tmp
wget https://archive.apache.org/dist/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz
sudo tar -zxvf apache-maven-3.6.3-bin.tar.gz -C /data/service/
# 配置环境变量
sudo tee -a /etc/profile.d/ruoyi_env.sh << 'EOF'
export MAVEN_HOME=/data/service/apache-maven-3.6.3
export PATH=$MAVEN_HOME/bin:$PATH
EOF
source /etc/profile.d/ruoyi_env.sh
Maven的核心配置文件是settings.xml。除了配置镜像，我们还应优化本地仓库位置和并发下载线程数。
<!-- /data/service/apache-maven-3.6.3/conf/settings.xml 部分关键配置 -->
<settings>
<!-- 指定本地仓库路径，避免默认的~/.m2/repository -->
<localRepository>/data/service/maven_repo</localRepository>
<mirrors>
<mirror>
<id>aliyunmaven</id>
<mirrorOf>*</mirrorOf>
<name>阿里云公共仓库</name>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>
<!-- 可额外添加中央仓库镜像作为备用 -->
<mirror>
<id>central</id>
<mirrorOf>central</mirrorOf>
<name>Central Repository</name>
<url>https://repo.maven.apache.org/maven2</url>
</mirror>
</mirrors>
<profiles>
<profile>
<id>default</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<!-- 设置Maven编译时的编码 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- 增加编译线程数，加速构建 -->
<maven.compiler.fork>true</maven.compiler.fork>
<maven.compiler.threads>4</maven.compiler.threads>
</properties>
</profile>
</profiles>
</settings>
2.3 Git与SSH密钥：安全高效的代码获取方式
通过HTTPS克隆代码虽然简单，但在自动化脚本中可能需要频繁输入密码。使用SSH密钥方式则更加安全、便捷。生成密钥对时，建议使用更强的加密算法和更长的密钥。
# 安装Git编译依赖
sudo yum groupinstall "Development Tools" -y
sudo yum install -y wget curl-devel expat-devel gettext-devel openssl-devel zlib-devel perl-CPAN
# 下载并编译安装特定版本Git
cd /tmp
wget https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.38.1.tar.gz
tar -zxvf git-2.38.1.tar.gz
cd git-2.38.1
./configure --prefix=/data/service/git --with-curl --with-expat
make -j$(nproc) # 使用多核编译加速
sudo make install
# 配置环境变量
echo 'export PATH=/data/service/git/bin:$PATH' | sudo tee -a /etc/profile.d/ruoyi_env.sh
source /etc/profile.d/ruoyi_env.sh
接下来生成ED25519算法的SSH密钥（比传统的RSA更安全、更快速）：
ssh-keygen -t ed25519 -C "your_email@example.com" -f ~/.ssh/id_ed25519_ruoyi
# 一路回车，使用默认位置和空密码（或设置一个强密码）
# 查看公钥
cat ~/.ssh/id_ed25519_ruoyi.pub
将输出的公钥内容添加到你的Gitee或GitHub账户的SSH Keys设置中。之后，可以通过以下命令测试连接：
ssh -T git@gitee.com -i ~/.ssh/id_ed25519_ruoyi
# 成功会显示：Hi XXX! You've successfully authenticated...
最后，克隆RuoYi代码库到我们规划好的目录：
cd /data
git clone git@gitee.com:y_project/RuoYi.git
# 如果网络不稳定，可以添加深度克隆和重试参数
# git clone --depth 1 git@gitee.com:y_project/RuoYi.git
3. Docker化MySQL部署：告别环境不一致的烦恼
传统方式直接在宿主机安装MySQL虽然直接，但会带来版本管理、依赖冲突、清理困难等问题。使用Docker容器化部署MySQL，不仅能实现环境隔离，还能通过简单的命令完成备份、迁移和版本切换。
3.1 Docker安装与镜像加速
在CentOS 7上安装Docker的官方步骤已经非常成熟，但我们需要特别注意国内网络环境下的镜像加速问题。
# 1. 卸载旧版本（如果是全新系统可跳过）
sudo yum remove -y docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine
# 2. 安装必要工具
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
# 3. 添加Docker官方仓库（使用阿里云镜像加速仓库地址）
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 4. 安装Docker Engine
sudo yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
# 5. 启动并设置开机自启
sudo systemctl start docker
sudo systemctl enable docker
# 6. 验证安装
sudo docker --version
安装完成后，配置镜像加速器是必须的步骤，否则拉取镜像的速度会非常慢。这里我推荐使用阿里云容器镜像服务提供的加速地址（需要注册阿里云账号并获取专属加速器地址）。
# 创建Docker守护进程配置目录
sudo mkdir -p /etc/docker
# 配置镜像加速器（替换为你自己的阿里云加速器地址）
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": [
"https://your-aliyun-mirror.mirror.aliyuncs.com",
"https://docker.mirrors.ustc.edu.cn",
"https://registry.docker-cn.com"
],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m",
"max-file": "3"
},
"storage-driver": "overlay2"
}
EOF
# 重启Docker使配置生效
sudo systemctl daemon-reload
sudo systemctl restart docker
# 验证加速器是否生效
sudo docker info | grep -A 1 "Registry Mirrors"
3.2 MySQL容器部署实战
现在开始部署MySQL 5.7容器。我们将采用数据卷挂载的方式，确保数据库数据持久化，即使容器被删除，数据也不会丢失。
# 1. 拉取MySQL 5.7镜像
sudo docker pull mysql:5.7
# 2. 创建用于持久化数据和配置的目录
sudo mkdir -p /data/docker/mysql/{data,conf,logs}
sudo chmod -R 755 /data/docker/mysql
# 3. 创建自定义MySQL配置文件
sudo tee /data/docker/mysql/conf/my.cnf <<-'EOF'
[mysqld]
# 基础配置
user = mysql
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
# 禁用符号链接，增强安全性
symbolic-links = 0
# 禁用DNS反向解析，提升连接速度
skip-name-resolve
# 连接配置
max_connections = 500
max_connect_errors = 1000
# 连接超时设置
wait_timeout = 600
interactive_timeout = 600
# 缓冲区配置
key_buffer_size = 256M
max_allowed_packet = 64M
thread_stack = 256K
thread_cache_size = 64
sort_buffer_size = 4M
read_buffer_size = 2M
read_rnd_buffer_size = 4M
join_buffer_size = 4M
# 表缓存
table_open_cache = 2000
table_definition_cache = 1000
# InnoDB配置
innodb_buffer_pool_size = 512M
innodb_log_file_size = 256M
innodb_flush_log_at_trx_commit = 1
innodb_lock_wait_timeout = 50
innodb_file_per_table = 1
innodb_flush_method = O_DIRECT
# 日志配置
log-error = /var/log/mysql/error.log
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2
log_queries_not_using_indexes = 1
# 二进制日志（用于主从复制，单机可关闭）
# server-id = 1
# log-bin = /var/log/mysql/mysql-bin.log
# expire_logs_days = 7
[mysql]
default-character-set = utf8mb4
[client]
default-character-set = utf8mb4
EOF
注意：上面的
innodb_buffer_pool_size设置为512M，这是针对内存为2GB的服务器的保守配置。如果你的服务器内存更大（比如8GB），可以将其调整为2G或4G。这个参数对MySQL性能影响最大，通常建议设置为可用内存的50%-70%。
接下来创建并运行MySQL容器：
# 4. 运行MySQL容器
sudo docker run -d \
--name mysql-ruoyi \
--restart=always \
-p 3306:3306 \
-v /data/docker/mysql/data:/var/lib/mysql \
-v /data/docker/mysql/conf:/etc/mysql/conf.d \
-v /data/docker/mysql/logs:/var/log/mysql \
-e MYSQL_ROOT_PASSWORD=YourStrongPassword123! \
-e TZ=Asia/Shanghai \
mysql:5.7 \
--character-set-server=utf8mb4 \
--collation-server=utf8mb4_unicode_ci
# 参数解释：
# -d: 后台运行
# --name: 容器名称
# --restart=always: 容器退出时自动重启
# -p: 端口映射（宿主机端口:容器端口）
# -v: 数据卷挂载（宿主机目录:容器目录）
# -e: 环境变量（设置root密码和时区）
# 最后的参数是传递给MySQL容器的启动参数
等待几秒钟后，检查容器是否正常运行：
sudo docker ps | grep mysql-ruoyi
# 应该能看到容器状态为"Up"
# 查看容器日志，确保没有错误
sudo docker logs mysql-ruoyi --tail 50
3.3 数据库初始化与安全加固
容器运行起来后，我们需要进入容器内部进行一些必要的初始化操作。
# 进入MySQL容器
sudo docker exec -it mysql-ruoyi mysql -uroot -p
# 输入上面设置的密码：YourStrongPassword123!
在MySQL命令行中，执行以下操作：
-- 1. 创建Ruoyi专用数据库
CREATE DATABASE IF NOT EXISTS `ruoyi` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
-- 2. 创建专用用户（避免使用root用户连接应用）
CREATE USER 'ruoyi_user'@'%' IDENTIFIED BY 'RuoyiUserPassword456!';
GRANT ALL PRIVILEGES ON ruoyi.* TO 'ruoyi_user'@'%';
FLUSH PRIVILEGES;
-- 3. 安全加固：限制root用户只能本地访问
-- 先查看现有root用户的host
SELECT user, host FROM mysql.user WHERE user = 'root';
-- 通常会有'root'@'%'和'root'@'localhost'
-- 删除'root'@'%'（如果存在）
DROP USER 'root'@'%';
-- 4. 退出MySQL
EXIT;
现在我们需要将Ruoyi的SQL初始化脚本导入到新创建的数据库中。首先将SQL文件复制到容器的配置目录映射的宿主机路径：
# 从克隆的代码库中复制SQL文件
cp /data/RuoYi/sql/quartz.sql /data/docker/mysql/conf/
cp /data/RuoYi/sql/ry_20210210.sql /data/docker/mysql/conf/
# 进入容器执行SQL
sudo docker exec -i mysql-ruoyi mysql -uroot -pYourStrongPassword123! ruoyi < /data/docker/mysql/conf/quartz.sql
sudo docker exec -i mysql-ruoyi mysql -uroot -pYourStrongPassword123! ruoyi < /data/docker/mysql/conf/ry_20210210.sql
# 验证表是否创建成功
sudo docker exec -it mysql-ruoyi mysql -uroot -pYourStrongPassword123! -e "USE ruoyi; SHOW TABLES;"
4. 项目配置、构建与部署优化
4.1 项目配置文件深度调整
Ruoyi前后端不分离版本的核心配置文件主要位于ruoyi-admin/src/main/resources/目录下。我们需要根据实际环境调整这些配置。
application.yml - 服务器与文件上传配置
# 文件路径：/data/RuoYi/ruoyi-admin/src/main/resources/application.yml
# 开发环境配置
spring:
profiles:
active: prod # 使用生产环境配置
# 生产环境配置
---
spring:
profiles: prod
# 文件上传路径（确保目录存在且有写权限）
servlet:
multipart:
max-file-size: 50MB
max-request-size: 100MB
# 应用配置
ruoyi:
# 项目名称
name: RuoYi
# 版本
version: 3.8.5
# 版权年份
copyrightYear: 2024
# 实例演示开关
demoEnabled: false # 生产环境务必关闭演示模式！
# 获取ip地址开关
addressEnabled: false
# 服务器配置
server:
port: 8080 # 根据实际情况调整，避免与现有服务冲突
servlet:
context-path: /
# 会话超时时间（分钟）
session:
timeout: 30
tomcat:
# 最大连接数
max-connections: 10000
# 最大线程数
max-threads: 200
# 最小空闲线程数
min-spare-threads: 20
# 连接超时时间（毫秒）
connection-timeout: 20000
# 开启访问日志（生产环境建议关闭以提升性能）
accesslog:
enabled: false
# 日志配置
logging:
level:
com.ruoyi: INFO
org.springframework: WARN
file:
name: /data/logs/ruoyi/ruoyi-admin.log
logback:
rollingpolicy:
max-file-size: 50MB
max-history: 30
application-druid.yml - 数据库连接池配置 这是最关键的生产环境配置之一。Druid连接池的配置直接影响数据库性能和稳定性。
# 文件路径：/data/RuoYi/ruoyi-admin/src/main/resources/application-druid.yml
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
druid:
# 主库数据源
master:
url: jdbc:mysql://localhost:3306/ruoyi?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
username: ruoyi_user # 使用我们创建的专用用户，而非root
password: RuoyiUserPassword456!
# 连接池配置
initialSize: 5
minIdle: 5
maxActive: 50 # 根据实际并发调整
maxWait: 60000
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: SELECT 1
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
filters: stat,wall,slf4j
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
useGlobalDataSourceStat: true
重要安全提示：生产环境中，数据库密码等敏感信息绝对不应该硬编码在配置文件中。应该使用环境变量、配置中心或密钥管理服务。这里为了演示清晰才直接写出，实际部署时请使用
${DB_PASSWORD}这样的占位符，并通过启动参数或环境变量传入。
4.2 Maven构建优化与JAR包生成
进入项目根目录，开始构建过程。这里有几个优化构建速度的技巧：
cd /data/RuoYi
# 清理并跳过测试打包（生产环境构建）
mvn clean package -Dmaven.test.skip=true -Dmaven.compile.fork=true -T 4
# 参数解释：
# -Dmaven.test.skip=true: 跳过测试，加速构建
# -Dmaven.compile.fork=true: 启用fork编译，避免内存不足
# -T 4: 使用4个线程并行构建（根据CPU核心数调整）
构建完成后，JAR包会生成在ruoyi-admin/target/目录下。我们可以将其复制到专门的应用程序目录：
# 创建应用目录
sudo mkdir -p /data/app/ruoyi/{bin,conf,lib,logs}
# 复制JAR包和配置文件
cp /data/RuoYi/ruoyi-admin/target/ruoyi-admin.jar /data/app/ruoyi/lib/
cp /data/RuoYi/ruoyi-admin/src/main/resources/application*.yml /data/app/ruoyi/conf/
# 设置正确的权限
sudo chown -R $(whoami):$(whoami) /data/app/ruoyi
sudo chmod -R 755 /data/app/ruoyi
4.3 生产环境启动脚本与管理
直接使用java -jar命令启动虽然简单，但缺乏进程管理、日志轮转和监控功能。我推荐使用Systemd服务来管理Spring Boot应用，这是Linux系统的标准服务管理方式。
创建Systemd服务文件
sudo tee /etc/systemd/system/ruoyi.service << 'EOF'
[Unit]
Description=RuoYi Management System
After=network.target mysql.service
Wants=mysql.service
[Service]
Type=simple
User=ruoyi
Group=ruoyi
# 重要：创建专用用户运行服务
# sudo useradd -r -s /bin/false ruoyi
WorkingDirectory=/data/app/ruoyi
ExecStart=/usr/bin/java \
-Xms512m \
-Xmx1024m \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/data/app/ruoyi/logs/heapdump.hprof \
-XX:+PrintGCDetails \
-XX:+PrintGCDateStamps \
-Xloggc:/data/app/ruoyi/logs/gc.log \
-Dspring.profiles.active=prod \
-Dspring.config.location=/data/app/ruoyi/conf/ \
-Dlogging.file.path=/data/app/ruoyi/logs \
-jar /data/app/ruoyi/lib/ruoyi-admin.jar
# JVM参数说明：
# -Xms/-Xmx: 堆内存初始大小/最大大小
# -XX:+UseG1GC: 使用G1垃圾收集器
# -XX:MaxGCPauseMillis=200: 目标最大GC暂停时间
# -XX:+HeapDumpOnOutOfMemoryError: OOM时生成堆转储
# -XX:+PrintGCDetails: 打印GC详细信息
Restart=on-failure
RestartSec=10s
StartLimitInterval=60s
StartLimitBurst=3
# 安全限制
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ReadWritePaths=/data/app/ruoyi/logs /data/app/ruoyi/conf
# 日志配置
StandardOutput=journal
StandardError=journal
SyslogIdentifier=ruoyi
[Install]
WantedBy=multi-user.target
EOF
创建专用用户并设置权限
# 创建系统用户（无登录shell，适合运行服务）
sudo useradd -r -s /bin/false ruoyi
# 更改应用目录所有权
sudo chown -R ruoyi:ruoyi /data/app/ruoyi
sudo chmod 750 /data/app/ruoyi
# 确保日志目录可写
sudo mkdir -p /data/app/ruoyi/logs
sudo chown -R ruoyi:ruoyi /data/app/ruoyi/logs
sudo chmod 755 /data/app/ruoyi/logs
启动并管理服务
# 重新加载Systemd配置
sudo systemctl daemon-reload
# 启动Ruoyi服务
sudo systemctl start ruoyi
# 设置开机自启
sudo systemctl enable ruoyi
# 查看服务状态
sudo systemctl status ruoyi
# 查看实时日志
sudo journalctl -u ruoyi -f
# 如果服务启动失败，查看详细日志
sudo journalctl -u ruoyi --no-pager -n 100
4.4 防火墙与安全配置
在服务启动后，我们需要确保防火墙允许外部访问应用端口（默认为8080）。同时，强烈建议不要将管理后台直接暴露在公网，应该通过Nginx反向代理并配置访问控制。
# 如果使用firewalld（CentOS 7默认）
sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --reload
# 如果使用iptables
sudo iptables -A INPUT -p tcp --dport 8080 -j ACCEPT
sudo service iptables save # 保存规则
# 更安全的做法是只允许特定IP访问管理端口
# sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port protocol="tcp" port="8080" accept'
5. 高级部署策略与故障排查
5.1 使用Nginx作为反向代理
在生产环境中，直接通过8080端口访问应用既不安全也不专业。我们应该使用Nginx作为反向代理，实现负载均衡、SSL终止、静态文件缓存等功能。
安装并配置Nginx
# 安装Nginx
sudo yum install -y nginx
# 创建Ruoyi专用的Nginx配置
sudo tee /etc/nginx/conf.d/ruoyi.conf << 'EOF'
upstream ruoyi_backend {
# 可以配置多个后端实例实现负载均衡
server 127.0.0.1:8080 weight=10 max_fails=3 fail_timeout=30s;
# 备用服务器示例
# server 127.0.0.1:8081 backup;
keepalive 32; # 保持连接池
}
server {
listen 80;
server_name your-domain.com; # 替换为你的域名或IP
# 静态资源缓存
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
root /data/RuoYi/ruoyi-admin/src/main/resources/static;
expires 30d;
add_header Cache-Control "public, immutable";
access_log off;
}
# 反向代理到Spring Boot应用
location / {
proxy_pass http://ruoyi_backend;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# 超时设置
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;
# 缓冲区优化
proxy_buffering on;
proxy_buffer_size 4k;
proxy_buffers 8 4k;
proxy_busy_buffers_size 8k;
# 启用WebSocket支持（如果应用需要）
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
# 健康检查端点
location /actuator/health {
proxy_pass http://ruoyi_backend;
access_log off;
allow 127.0.0.1;
deny all;
}
# 限制访问管理端点
location ~ ^/(actuator|druid|swagger) {
proxy_pass http://ruoyi_backend;
allow 192.168.1.0/24; # 只允许内网访问
deny all;
auth_basic "Restricted Area";
auth_basic_user_file /etc/nginx/.htpasswd;
}
# 错误页面
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
}
EOF
# 创建基本的HTTP认证文件（用于保护管理界面）
sudo sh -c "echo -n 'admin:' >> /etc/nginx/.htpasswd"
sudo sh -c "openssl passwd -apr1 >> /etc/nginx/.htpasswd"
# 按提示输入密码
# 测试Nginx配置
sudo nginx -t
# 启动Nginx
sudo systemctl start nginx
sudo systemctl enable nginx
5.2 监控与日志管理
一个健壮的生产环境需要完善的监控体系。除了应用自身的日志，我们还应该监控系统资源、应用性能和业务指标。
配置日志轮转
# 创建Logrotate配置，防止日志文件无限增长
sudo tee /etc/logrotate.d/ruoyi << 'EOF'
/data/app/ruoyi/logs/*.log {
daily
missingok
rotate 30
compress
delaycompress
notifempty
create 644 ruoyi ruoyi
sharedscripts
postrotate
systemctl reload ruoyi > /dev/null 2>&1 || true
endscript
}
EOF
# 测试日志轮转配置
sudo logrotate -d /etc/logrotate.d/ruoyi
简单的健康检查脚本
# 创建健康检查脚本
sudo tee /data/scripts/check_ruoyi.sh << 'EOF'
#!/bin/bash
# 健康检查脚本
APP_URL="http://localhost:8080"
HEALTH_ENDPOINT="/actuator/health"
MAX_RETRIES=3
RETRY_DELAY=5
check_health() {
local response=$(curl -s -o /dev/null -w "%{http_code}" "${APP_URL}${HEALTH_ENDPOINT}" --max-time 10)
if [ "$response" = "200" ]; then
echo "$(date): RuoYi is healthy (HTTP $response)"
return 0
else
echo "$(date): RuoYi health check failed (HTTP $response)"
return 1
fi
}
# 重试逻辑
for i in $(seq 1 $MAX_RETRIES); do
if check_health; then
exit 0
fi
if [ $i -lt $MAX_RETRIES ]; then
echo "Retrying in ${RETRY_DELAY} seconds..."
sleep $RETRY_DELAY
fi
done
# 所有重试都失败，尝试重启服务
echo "$(date): All health checks failed, attempting to restart RuoYi..."
systemctl restart ruoyi
# 等待服务启动
sleep 30
# 最终检查
if check_health; then
echo "$(date): RuoYi restarted successfully"
exit 0
else
echo "$(date): RuoYi restart failed"
exit 1
fi
EOF
sudo chmod +x /data/scripts/check_ruoyi.sh
# 添加到cron定时任务，每5分钟检查一次
(crontab -l 2>/dev/null; echo "*/5 * * * * /data/scripts/check_ruoyi.sh >> /var/log/ruoyi_health.log 2>&1") | crontab -
5.3 常见问题排查指南
在实际部署过程中，你可能会遇到各种问题。这里整理了一些常见问题及其解决方法：
问题1：应用启动后无法访问
# 检查服务状态
sudo systemctl status ruoyi
# 查看应用日志
sudo journalctl -u ruoyi --no-pager -n 100
# 检查端口监听
sudo netstat -tlnp | grep :8080
sudo ss -tlnp | grep :8080
# 检查防火墙
sudo firewall-cmd --list-all
问题2：数据库连接失败
# 从容器内部测试数据库连接
sudo docker exec mysql-ruoyi mysql -uruoyi_user -pRuoyiUserPassword456! -e "SELECT 1;"
# 从宿主机测试
mysql -h 127.0.0.1 -P 3306 -uruoyi_user -pRuoyiUserPassword456! -e "SELECT 1;"
# 检查MySQL错误日志
sudo docker logs mysql-ruoyi --tail 50
问题3：内存不足导致应用崩溃
# 查看系统内存使用
free -h
# 查看Java进程内存
ps aux | grep java
top -p $(pgrep -f ruoyi-admin)
# 调整JVM参数（在systemd服务文件中修改）
# -Xms512m -Xmx1024m # 根据实际情况调整
问题4：上传文件大小限制
# 在application.yml中调整
spring:
servlet:
multipart:
max-file-size: 50MB
max-request-size: 100MB
# 同时需要在Nginx中调整（如果有反向代理）
# 在Nginx配置中添加：
client_max_body_size 100m;
5.4 备份与恢复策略
任何生产系统都需要完善的备份策略。对于Ruoyi系统，我们需要备份数据库、应用配置和上传的文件。
数据库备份脚本
sudo tee /data/scripts/backup_ruoyi_db.sh << 'EOF'
#!/bin/bash
# 备份配置
BACKUP_DIR="/data/backup/mysql"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30
# 创建备份目录
mkdir -p $BACKUP_DIR
# 备份数据库
sudo docker exec mysql-ruoyi mysqldump -uroot -pYourStrongPassword123! \
--single-transaction \
--routines \
--triggers \
--events \
ruoyi | gzip > $BACKUP_DIR/ruoyi_$DATE.sql.gz
# 备份quartz相关表
sudo docker exec mysql-ruoyi mysqldump -uroot -pYourStrongPassword123! \
--single-transaction \
quartz | gzip > $BACKUP_DIR/quartz_$DATE.sql.gz
# 清理旧备份
find $BACKUP_DIR -name "*.sql.gz" -mtime +$RETENTION_DAYS -delete
# 记录备份日志
echo "$(date): Backup completed - ruoyi_$DATE.sql.gz" >> /var/log/ruoyi_backup.log
EOF
sudo chmod +x /data/scripts/backup_ruoyi_db.sh
# 每天凌晨2点执行备份
(crontab -l 2>/dev/null; echo "0 2 * * * /data/scripts/backup_ruoyi_db.sh") | crontab -
应用文件备份
sudo tee /data/scripts/backup_ruoyi_app.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/data/backup/app"
DATE=$(date +%Y%m%d)
RETENTION_DAYS=7
mkdir -p $BACKUP_DIR
# 备份应用配置
tar -czf $BACKUP_DIR/ruoyi_config_$DATE.tar.gz \
/data/app/ruoyi/conf \
/data/app/ruoyi/lib/ruoyi-admin.jar \
/etc/systemd/system/ruoyi.service \
/etc/nginx/conf.d/ruoyi.conf 2>/dev/null
# 备份上传的文件（如果有）
if [ -d "/data/app/ruoyi/upload" ]; then
tar -czf $BACKUP_DIR/ruoyi_upload_$DATE.tar.gz /data/app/ruoyi/upload
fi
# 清理旧备份
find $BACKUP_DIR -name "*.tar.gz" -mtime +$RETENTION_DAYS -delete
echo "$(date): Application backup completed" >> /var/log/ruoyi_backup.log
EOF
sudo chmod +x /data/scripts/backup_ruoyi_app.sh
# 每周日凌晨3点执行应用备份
(crontab -l 2>/dev/null; echo "0 3 * * 0 /data/scripts/backup_ruoyi_app.sh") | crontab -
6. 性能优化与调优建议
部署完成后，我们可以根据实际运行情况进行性能调优。以下是一些经过实践验证的优化建议：
JVM调优参数（针对4GB内存服务器）
# 在/etc/systemd/system/ruoyi.service中调整JVM参数
ExecStart=/usr/bin/java \
-Xms1g \
-Xmx2g \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:InitiatingHeapOccupancyPercent=45 \
-XX:ParallelGCThreads=4 \
-XX:ConcGCThreads=2 \
-XX:+AlwaysPreTouch \
-XX:+UseStringDeduplication \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/data/app/ruoyi/logs/heapdump.hprof \
-XX:+PrintGCDetails \
-XX:+PrintGCDateStamps \
-Xloggc:/data/app/ruoyi/logs/gc.log \
-Djava.awt.headless=true \
-Djava.security.egd=file:/dev/./urandom \
-Dspring.profiles.active=prod \
-Dspring.config.location=/data/app/ruoyi/conf/ \
-Dlogging.file.path=/data/app/ruoyi/logs \
-jar /data/app/ruoyi/lib/ruoyi-admin.jar
MySQL性能优化
除了前面提到的my.cnf配置，还可以根据实际负载调整以下参数：
# 在/data/docker/mysql/conf/my.cnf中添加
[mysqld]
# 查询缓存（MySQL 8.0已移除，5.7可保留）
query_cache_type = 1
query_cache_size = 64M
# InnoDB额外优化
innodb_buffer_pool_instances = 4
innodb_log_buffer_size = 16M
innodb_flush_neighbors = 0
innodb_read_io_threads = 8
innodb_write_io_threads = 8
innodb_io_capacity = 2000
innodb_io_capacity_max = 4000
# 临时表配置
tmp_table_size = 64M
max_heap_table_size = 64M
Nginx优化配置
# 在/etc/nginx/nginx.conf的http块中添加
http {
# 基础优化
sendfile on;
tcp_nopush on;
tcp_nodelay on;
keepalive_timeout 65;
types_hash_max_size 2048;
client_max_body_size 100m;
# 压缩配置
gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_comp_level 6;
gzip_types text/plain text/css text/xml text/javascript
application/json application/javascript application/xml+rss
application/xml application/xhtml+xml image/svg+xml;
# 缓冲区优化
client_body_buffer_size 128k;
client_header_buffer_size 4k;
large_client_header_buffers 4 16k;
# 超时设置
client_body_timeout 12;
client_header_timeout 12;
send_timeout 10;
# 连接限制
limit_conn_zone $binary_remote_addr zone=perip:10m;
limit_conn perip 100;
include /etc/nginx/conf.d/*.conf;
}
经过以上步骤，你的Ruoyi前后端不分离版本应该已经稳定运行在Linux服务器上。这套部署方案考虑了安全性、可维护性和性能，适合中小型生产环境使用。实际部署中，你可能还需要根据具体业务需求调整某些参数，但整体框架和思路是通用的。
记得定期检查系统日志、应用日志和数据库日志，监控系统资源使用情况，并根据实际运行数据进一步优化配置。部署不是终点，而是持续运维的起点。
516
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
