lyzsys/lyzsys_backend
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

增加文档说明

Browse Source
This commit is contained in:
lpd
2026-01-19 18:34:10 +08:00
parent 0cbb63432e
commit 2863c963ca
8 changed files with 5883 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

805
doc/部署指南.md Normal file
View File

@@ -0,0 +1,805 @@
# Lyzsys 部署指南
## 📖 目录
- [部署概述](#部署概述)
- [环境准备](#环境准备)
- [后端部署](#后端部署)
- [前端部署](#前端部署)
- [数据库部署](#数据库部署)
- [缓存部署](#缓存部署)
- [文件存储部署](#文件存储部署)
- [生产环境部署](#生产环境部署)
- [容器化部署](#容器化部署)
- [监控部署](#监控部署)
---
## 部署概述
### 部署架构
```
┌─────────────────────────────────────────────────────────────┐
│ 用户端 │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ PC 浏览器 │ │ 移动 App │ │ 小程序 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Nginx │
│ (反向代理 + 静态资源) │
└─────────────────────────────────────────────────────────────┘
│
┌─────────────┴─────────────┐
│ │
▼ ▼
┌──────────────────────────┐ ┌──────────────────────────┐
│ 前端静态资源 │ │ 后端 API 服务 │
│ (Vue3 SPA 应用) │ │ (Spring Boot 应用) │
└──────────────────────────┘ └──────────────────────────┘
│
┌─────────────────────────┼─────────────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ MySQL │ │ Redis │ │ MinIO │
│ (主数据库) │ │ (缓存/会话) │ │ (文件存储) │
└──────────────────┘ └──────────────────┘ └──────────────────┘
```
### 部署方式
1. **传统部署**: 直接在服务器上部署
2. **Docker 部署**: 使用 Docker 容器部署
3. **Kubernetes 部署**: 使用 K8s 编排部署
---
## 环境准备
### 服务器要求
#### 最低配置
| 组件 | CPU | 内存 | 硬盘 |
|------|-----|------|------|
| 后端服务 | 2核 | 4GB | 20GB |
| MySQL | 1核 | 2GB | 50GB |
| Redis | 1核 | 1GB | 10GB |
| 前端 | 1核 | 1GB | 10GB |
#### 推荐配置
| 组件 | CPU | 内存 | 硬盘 |
|------|-----|------|------|
| 后端服务 | 4核 | 8GB | 50GB |
| MySQL | 4核 | 16GB | 500GB |
| Redis | 2核 | 4GB | 50GB |
| 前端 | 2核 | 2GB | 20GB |
### 软件要求
| 软件 | 版本 | 用途 |
|------|------|------|
| JDK | 8+ | 后端运行环境 |
| MySQL | 5.7+ / 8.0+ | 数据库 |
| Redis | 5.0+ | 缓存 |
| Nginx | 1.18+ | Web 服务器 |
| Node.js | 16+ | 前端构建 |
| Docker | 20.10+ | 容器化（可选） |
---
## 后端部署
### 方式一: JAR 包部署
#### 1. 打包项目
```bash
cd lyzsys_backend
mvn clean package -DskipTests
```
生成的 JAR 包位于 `lyzsys-server/target/lyzsys-server.jar`
#### 2. 上传文件
将 JAR 包上传到服务器：
```bash
scp lyzsys-server/target/lyzsys-server.jar user@server:/opt/lyzsys/
```
#### 3. 配置文件
创建配置文件 `application-prod.yaml`:
```yaml
spring:
# 数据源配置
datasource:
url: jdbc:mysql://mysql-server:3306/lyzsys?useSSL=false&serverTimezone=Asia/Shanghai
username: lyzsys
password: your_password
driver-class-name: com.mysql.cj.jdbc.Driver
# Redis 配置
redis:
host: redis-server
port: 6379
database: 1
password: your_redis_password
# 项目配置
lyzsys:
web:
api-prefix: /admin-api
security:
mock-enable: false
upload:
base-url: http://your-domain.com
```
#### 4. 启动服务
```bash
# 启动服务
java -jar lyzsys-server.jar --spring.profiles.active=prod
# 后台启动
nohup java -jar lyzsys-server.jar --spring.profiles.active=prod > lyzsys.log 2>&1 &
# 指定内存启动
java -Xms512m -Xmx1024m -jar lyzsys-server.jar --spring.profiles.active=prod
```
#### 5. 创建系统服务
创建 `/etc/systemd/system/lyzsys.service`:
```ini
[Unit]
Description=Lyzsys Server
After=syslog.target network.target
[Service]
Type=simple
ExecStart=/usr/bin/java -jar /opt/lyzsys/lyzsys-server.jar --spring.profiles.active=prod
ExecStop=/bin/kill -15 $MAINPID
User=lyzsys
Group=lyzsys
WorkingDirectory=/opt/lyzsys
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
```
启动服务：
```bash
# 重载配置
systemctl daemon-reload
# 启动服务
systemctl start lyzsys
# 开机启动
systemctl enable lyzsys
# 查看状态
systemctl status lyzsys
```
### 方式二: Docker 部署
#### 1. 创建 Dockerfile
创建 `Dockerfile`:
```dockerfile
FROM openjdk:8-jre-slim
LABEL maintainer="lyzsys"
# 设置工作目录
WORKDIR /opt/lyzsys
# 复制 JAR 包
COPY lyzsys-server/target/lyzsys-server.jar app.jar
# 暴露端口
EXPOSE 48080
# 启动应用
ENTRYPOINT ["java", "-jar", "app.jar"]
```
#### 2. 构建镜像
```bash
docker build -t lyzsys/lyzsys-server:latest .
```
#### 3. 运行容器
```bash
docker run -d \
--name lyzsys-server \
-p 48080:48080 \
-e SPRING_PROFILES_ACTIVE=prod \
-e SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/lyzsys \
-e SPRING_DATASOURCE_USERNAME=lyzsys \
-e SPRING_DATASOURCE_PASSWORD=your_password \
-e SPRING_DATA_REDIS_HOST=redis \
-e SPRING_DATA_REDIS_PASSWORD=your_redis_password \
lyzsys/lyzsys-server:latest
```
#### 4. 使用 Docker Compose
创建 `docker-compose.yml`:
```yaml
version: '3.8'
services:
lyzsys-server:
image: lyzsys/lyzsys-server:latest
container_name: lyzsys-server
ports:
- "48080:48080"
environment:
- SPRING_PROFILES_ACTIVE=prod
- SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/lyzsys
- SPRING_DATASOURCE_USERNAME=lyzsys
- SPRING_DATASOURCE_PASSWORD=your_password
- SPRING_DATA_REDIS_HOST=redis
- SPRING_DATA_REDIS_PASSWORD=your_redis_password
depends_on:
- mysql
- redis
restart: always
```
启动：
```bash
docker-compose up -d
```
---
## 前端部署
### 方式一: Nginx 部署
#### 1. 构建项目
```bash
cd lyzsys-ui-admin
# 安装依赖
pnpm install
# 构建生产版本
pnpm build:prod
```
生成的文件位于 `dist/` 目录
#### 2. 上传文件
将 `dist/` 目录上传到服务器：
```bash
scp -r dist/* user@server:/var/www/lyzsys/
```
#### 3. 配置 Nginx
创建 Nginx 配置 `/etc/nginx/conf.d/lyzsys.conf`:
```nginx
server {
listen 80;
server_name your-domain.com;
root /var/www/lyzsys;
index index.html;
# 前端路由
location / {
try_files $uri $uri/ /index.html;
}
# API 代理
location /admin-api/ {
proxy_pass http://localhost:48080/admin-api/;
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_read_timeout 60s;
proxy_send_timeout 60s;
}
# 静态资源缓存
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
expires 1y;
add_header Cache-Control "public, immutable";
}
# Gzip 压缩
gzip on;
gzip_types text/plain text/css application/json application/javascript;
gzip_min_length 1024;
}
```
#### 4. 重启 Nginx
```bash
nginx -t
nginx -s reload
```
### 方式二: Docker 部署
#### 1. 创建 Dockerfile
创建 `Dockerfile`:
```dockerfile
FROM nginx:alpine
# 复制构建文件
COPY dist/ /usr/share/nginx/html/
# 复制 Nginx 配置
COPY nginx.conf /etc/nginx/conf.d/default.conf
# 暴露端口
EXPOSE 80
# 启动 Nginx
CMD ["nginx", "-g", "daemon off;"]
```
#### 2. 构建镜像
```bash
docker build -t lyzsys/lyzsys-ui-admin:latest .
```
#### 3. 运行容器
```bash
docker run -d \
--name lyzsys-ui-admin \
-p 80:80 \
lyzsys/lyzsys-ui-admin:latest
```
---
## 数据库部署
### MySQL 部署
#### 1. 安装 MySQL
```bash
# CentOS/RHEL
yum install -y mysql-server
# Ubuntu/Debian
apt-get install -y mysql-server
```
#### 2. 配置 MySQL
编辑 `/etc/my.cnf`:
```ini
[mysqld]
# 基础配置
port = 3306
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
# 连接配置
max_connections = 500
max_connect_errors = 100
# 缓存配置
innodb_buffer_pool_size = 1G
query_cache_size = 128M
# 日志配置
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2
```
#### 3. 创建数据库
```bash
mysql -u root -p
CREATE DATABASE lyzsys CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'lyzsys'@'%' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON lyzsys.* TO 'lyzsys'@'%';
FLUSH PRIVILEGES;
```
#### 4. 导入数据
```bash
mysql -u lyzsys -p lyzsys < lyzsys.sql
```
### Docker 部署 MySQL
```bash
docker run -d \
--name mysql \
-p 3306:3306 \
-e MYSQL_ROOT_PASSWORD=root_password \
-e MYSQL_DATABASE=lyzsys \
-e MYSQL_USER=lyzsys \
-e MYSQL_PASSWORD=your_password \
-v /data/mysql:/var/lib/mysql \
mysql:8.0
```
---
## 缓存部署
### Redis 部署
#### 1. 安装 Redis
```bash
# CentOS/RHEL
yum install -y redis
# Ubuntu/Debian
apt-get install -y redis-server
```
#### 2. 配置 Redis
编辑 `/etc/redis/redis.conf`:
```ini
# 绑定地址
bind 0.0.0.0
# 端口
port 6379
# 密码
requirepass your_redis_password
# 持久化
save 900 1
save 300 10
save 60 10000
# 最大内存
maxmemory 1gb
maxmemory-policy allkeys-lru
```
#### 3. 启动 Redis
```bash
# 启动 Redis
redis-server /etc/redis/redis.conf
# 或使用 systemd
systemctl start redis
systemctl enable redis
```
### Docker 部署 Redis
```bash
docker run -d \
--name redis \
-p 6379:6379 \
-v /data/redis:/data \
redis:7-alpine \
redis-server --appendonly yes --requirepass your_redis_password
```
---
## 文件存储部署
### MinIO 部署
#### 1. Docker 部署 MinIO
```bash
docker run -d \
--name minio \
-p 9000:9000 \
-p 9001:9001 \
-e MINIO_ROOT_USER=admin \
-e MINIO_ROOT_PASSWORD=admin123 \
-v /data/minio:/data \
minio/minio server /data --console-address ":9001"
```
#### 2. 配置 MinIO
1. 访问 http://localhost:9001
2. 登录（admin / admin123）
3. 创建 Bucket: `lyzsys`
4. 创建 Access Key 和 Secret Key
5. 配置后端 `application.yaml`:
```yaml
lyzsys:
storage:
minio:
endpoint: http://localhost:9000
access-key: your_access_key
secret-key: your_secret_key
bucket-name: lyzsys
```
---
## 生产环境部署
### 安全配置
#### 1. 配置防火墙
```bash
# 开放必要端口
firewall-cmd --permanent --add-port=80/tcp
firewall-cmd --permanent --add-port=443/tcp
firewall-cmd --permanent --add-port=48080/tcp
firewall-cmd --reload
```
#### 2. 配置 SSL 证书
使用 Let's Encrypt 免费证书：
```bash
# 安装 certbot
yum install -y certbot
# 获取证书
certbot certonly --standalone -d your-domain.com
# 证书位置
# /etc/letsencrypt/live/your-domain.com/fullchain.pem
# /etc/letsencrypt/live/your-domain.com/privkey.pem
```
配置 Nginx SSL：
```nginx
server {
listen 443 ssl http2;
server_name your-domain.com;
ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers on;
# ... 其他配置
}
# HTTP 跳转 HTTPS
server {
listen 80;
server_name your-domain.com;
return 301 https://$server_name$request_uri;
}
```
### 性能优化
#### 1. MySQL 优化
```ini
# my.cnf
[mysqld]
innodb_buffer_pool_size = 4G
innodb_log_file_size = 512M
innodb_flush_log_at_trx_commit = 2
innodb_flush_method = O_DIRECT
```
#### 2. Redis 优化
```ini
# redis.conf
maxmemory 2gb
maxmemory-policy allkeys-lru
save ""
```
#### 3. JVM 优化
```bash
java -Xms2g -Xmx2g \
-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/opt/lyzsys/logs/ \
-jar lyzsys-server.jar
```
---
## 容器化部署
### Docker Compose 完整部署
创建 `docker-compose.yml`:
```yaml
version: '3.8'
services:
# MySQL
mysql:
image: mysql:8.0
container_name: lyzsys-mysql
environment:
- MYSQL_ROOT_PASSWORD=root_password
- MYSQL_DATABASE=lyzsys
- MYSQL_USER=lyzsys
- MYSQL_PASSWORD=your_password
volumes:
- mysql-data:/var/lib/mysql
ports:
- "3306:3306"
restart: always
# Redis
redis:
image: redis:7-alpine
container_name: lyzsys-redis
command: redis-server --appendonly yes --requirepass your_redis_password
volumes:
- redis-data:/data
ports:
- "6379:6379"
restart: always
# MinIO
minio:
image: minio/minio
container_name: lyzsys-minio
environment:
- MINIO_ROOT_USER=admin
- MINIO_ROOT_PASSWORD=admin123
volumes:
- minio-data:/data
ports:
- "9000:9000"
- "9001:9001"
command: server /data --console-address ":9001"
restart: always
# 后端服务
backend:
image: lyzsys/lyzsys-server:latest
container_name: lyzsys-backend
environment:
- SPRING_PROFILES_ACTIVE=prod
- SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/lyzsys
- SPRING_DATASOURCE_USERNAME=lyzsys
- SPRING_DATASOURCE_PASSWORD=your_password
- SPRING_DATA_REDIS_HOST=redis
- SPRING_DATA_REDIS_PASSWORD=your_redis_password
ports:
- "48080:48080"
depends_on:
- mysql
- redis
restart: always
# 前端服务
frontend:
image: lyzsys/lyzsys-ui-admin:latest
container_name: lyzsys-frontend
ports:
- "80:80"
depends_on:
- backend
restart: always
volumes:
mysql-data:
redis-data:
minio-data:
```
启动：
```bash
docker-compose up -d
```
---
## 监控部署
### Spring Boot Admin
#### 1. 添加依赖
```xml
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>
```
#### 2. 配置应用
```yaml
spring:
application:
name: lyzsys-admin-server
server:
port: 48081
```
#### 3. 客户端配置
```yaml
spring:
boot:
admin:
client:
url: http://localhost:48081
```
### SkyWalking
#### 1. 安装 SkyWalking
```bash
docker run -d \
--name skywalking \
-p 11800:11800 \
-p 12800:12800 \
apache/skywalking-oap-server
```
#### 2. 配置 Agent
```bash
java -javaagent:/path/to/skywalking-agent.jar \
-Dskywalking.agent.service_name=lyzsys \
-Dskywalking.collector.backend_service=localhost:11800 \
-jar lyzsys-server.jar
```
---
**文档版本**: v1.0.0
**最后更新**: 2025-01-19
**维护团队**: Lyzsys 运维团队