tian/QAUP_Management
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

建立新的部署方案

Browse Source
This commit is contained in:
Tian jianyong 2025-08-05 14:37:44 +08:00
parent 519460ef86
commit 3d822eb6d9
14 changed files with 1043 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
deploy/.env.template
View File

@ -58,6 +58,9 @@ DATA_DIR=./data
# 日志存储目录
LOG_DIR=./logs
# 应用日志路径（容器内路径）
LOG_PATH=/app/logs
# 备份存储目录
BACKUP_DIR=./backup

1
deploy/docker-compose.prod.yml
View File

@ -36,6 +36,7 @@ services:
# 生产环境变量
environment:
SPRING_PROFILES_ACTIVE: prod
LOG_PATH: /app/logs
# 安全配置
MANAGEMENT_ENDPOINTS_WEB_EXPOSURE_INCLUDE: health,info,metrics
MANAGEMENT_ENDPOINT_HEALTH_SHOW_DETAILS: when_authorized

1
deploy/docker-compose.yml
View File

@ -88,6 +88,7 @@ services:
# 应用配置
SERVER_PORT: 8080
UPLOAD_PATH: /app/uploadPath
LOG_PATH: /app/logs
# JVM 配置
JVM_OPTS: ${JVM_OPTS:--Dname=qaup-admin.jar -Duser.timezone=Asia/Shanghai -Xms512m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m}

274
deploy/simple/DeployGuide.md Normal file
View File

@ -0,0 +1,274 @@
# QAUP 系统部署和更新说明
## 开发环境操作
### 生成程序更新文件
当代码修改后，需要生成新的jar文件供客户更新：
#### 方式一：生成完整更新包（推荐给不熟悉的客户）
```bash
./deploy/simple/build-update.sh
```
生成包含详细说明的更新包：
- `qaup-admin.jar` - 应用程序
- `UPDATE-INSTRUCTIONS.md` - 详细更新说明
- `VERSION-INFO.txt` - 版本信息
#### 方式二：快速生成jar文件（适合熟悉的客户）
```bash
./deploy/simple/build-jar.sh
```
直接生成带时间戳的jar文件，方便快速传输。
### 生成完整部署包
```bash
./deploy/simple/package.sh
```
生成包含所有组件的完整部署包，用于首次部署或重大版本更新。
---
## 客户环境操作
### 首次部署
### 1. 解压部署包
```bash
unzip qaup-deploy-20250105-143022.zip
cd qaup-deploy
```
### 2. 执行部署
```bash
./deploy.sh
```
### 3. 验证部署
```bash
# 检查服务状态
docker compose ps
# 访问系统
curl http://localhost:8080/actuator/health
```
## 程序更新（仅更新jar文件）
### 更新前准备
1. **确认当前系统状态**：
```bash
cd qaup-deploy
docker compose ps
```
2. **备份重要数据**（可选但推荐）：
```bash
# 备份数据库
docker exec qaup-postgres pg_dump -U qaup qaup > backup-$(date +%Y%m%d).sql
# 备份配置文件
cp config.yml config.yml.backup
```
### 更新步骤
### 1. 准备新版本文件
#### 如果收到的是完整更新包（.zip文件）：
```bash
# 解压更新包
unzip qaup-update-20250105-143022.zip
cd qaup-update-20250105-143022
# 查看更新说明
cat UPDATE-INSTRUCTIONS.md
# 复制jar文件到部署目录
cd ../qaup-deploy
cp ../qaup-update-20250105-143022/qaup-admin.jar new-app.jar
```
#### 如果收到的是jar文件：
```bash
cd qaup-deploy
cp /path/to/qaup-admin-20250105-143022.jar new-app.jar
```
### 2. 执行程序更新
```bash
./update.sh
```
### 3. 验证更新结果
```bash
# 检查服务状态
docker compose ps
# 检查应用日志
docker compose logs -f qaup-app
# 访问系统确认功能正常
curl http://localhost:8080/actuator/health
```
## 更新失败处理
如果更新失败，脚本会自动尝试回滚。如果自动回滚也失败：
### 手动回滚：
```bash
# 停止应用
docker compose stop qaup-app
# 恢复备份文件
cp app.jar.backup.* app.jar
# 启动应用
docker compose start qaup-app
```
### 检查问题：
```bash
# 查看应用日志
docker compose logs qaup-app
# 查看所有服务状态
docker compose ps -a
```
## 配置文件更新
如果新版本需要更新配置文件：
1. **备份当前配置**：
```bash
cp config.yml config.yml.backup
```
2. **更新配置**：
```bash
# 编辑配置文件
vi config.yml
```
3. **重启应用**：
```bash
docker compose restart qaup-app
```
## 常见问题
### Q: 更新后无法访问系统
A: 检查端口是否被占用，查看应用日志：
```bash
docker compose logs qaup-app
netstat -tlnp | grep 8080
```
### Q: 数据库连接失败
A: 检查数据库服务状态：
```bash
docker compose logs qaup-postgres
docker exec qaup-postgres pg_isready -U qaup
```
### Q: 如何完全重新部署
A: 如果更新出现严重问题，可以重新部署：
```bash
# 停止所有服务
docker compose down
# 清理数据（注意：这会删除所有数据）
rm -rf data/
# 重新部署
./deploy.sh
```
## 完整系统重新部署
如果需要重新部署整个系统（包括更新Docker镜像、配置等）：
### 1. 获取新的部署包
```bash
# 解压新的部署包到新目录
unzip qaup-deploy-new-20250110-100000.zip
cd qaup-deploy-new
```
### 2. 迁移数据（如果需要保留数据）
```bash
# 从旧系统备份数据
cd ../qaup-deploy
docker exec qaup-postgres pg_dump -U qaup qaup > ../data-backup.sql
# 停止旧系统
docker compose down
# 在新系统中恢复数据
cd ../qaup-deploy-new
./deploy.sh
docker exec -i qaup-postgres psql -U qaup qaup < ../data-backup.sql
```
## 操作流程总结
### 开发环境 → 客户环境流程
#### 程序更新流程：
```
开发环境:
1. 代码修改完成
2. ./deploy/simple/build-jar.sh # 生成jar文件
3. 发送jar文件给客户
客户环境:
1. cd qaup-deploy
2. cp new-jar-file.jar new-app.jar # 重命名文件
3. ./update.sh # 执行更新
4. 验证更新结果
```
#### 完整部署流程：
```
开发环境:
1. ./deploy/simple/package.sh # 生成完整部署包
2. 发送部署包给客户
客户环境:
1. unzip qaup-deploy-xxx.zip # 解压部署包
2. cd qaup-deploy
3. ./deploy.sh # 执行部署
4. 验证部署结果
```
## 更新记录
建议记录每次更新的信息：
- 更新时间
- 版本号
- 更新人员
- 更新类型（程序更新/完整部署）
- 是否成功
- 遇到的问题
示例：
```
2025-01-05 14:30 - v1.0.1 → v1.0.2 - 张三 - 程序更新 - 成功
2025-01-10 09:15 - v1.0.2 → v1.0.3 - 李四 - 程序更新 - 失败，已回滚
2025-01-15 16:00 - v1.0.3 → v1.1.0 - 王五 - 完整部署 - 成功
```
## 文件说明
### 开发环境脚本：
- `deploy/simple/build-jar.sh` - 快速生成jar文件
- `deploy/simple/build-update.sh` - 生成完整更新包
- `deploy/simple/package.sh` - 生成完整部署包
### 客户环境脚本：
- `deploy.sh` - 首次部署脚本
- `update.sh` - 程序更新脚本
- `UPGRADE-README.md` - 本说明文档

45
deploy/simple/build-jar.sh Normal file
View File

@ -0,0 +1,45 @@
#!/bin/bash
# QAUP 快速构建jar文件脚本
# 用于快速生成jar文件供客户更新使用
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
# 颜色输出
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m'
print_message() {
echo -e "${1}${2}${NC}"
}
print_message $BLUE "=== QAUP 快速构建 ==="
# 构建应用
print_message $BLUE "构建应用..."
cd "$PROJECT_ROOT"
mvn clean package -DskipTests -q
# 检查并复制jar文件
JAR_FILE="$PROJECT_ROOT/qaup-admin/target/qaup-admin.jar"
if [ -f "$JAR_FILE" ]; then
# 复制到当前目录，方便传输
OUTPUT_NAME="qaup-admin-$(date +%Y%m%d-%H%M%S).jar"
cp "$JAR_FILE" "$OUTPUT_NAME"
print_message $GREEN "✅ 构建完成: $OUTPUT_NAME"
print_message $BLUE "文件大小: $(du -sh "$OUTPUT_NAME" | cut -f1)"
echo ""
echo "客户更新步骤:"
echo "1. 将 $OUTPUT_NAME 上传到服务器 qaup-deploy 目录"
echo "2. 重命名: cp $OUTPUT_NAME new-app.jar"
echo "3. 执行更新: ./update.sh"
else
echo "❌ jar文件构建失败"
exit 1
fi

110
deploy/simple/build-update.sh Normal file
View File

@ -0,0 +1,110 @@
#!/bin/bash
# QAUP 程序更新打包脚本
# 用于生成仅包含jar文件的更新包
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m'
print_message() {
echo -e "${1}${2}${NC}"
}
print_message $BLUE "=== QAUP 程序更新打包 ==="
# 1. 构建应用
print_message $BLUE "构建应用..."
cd "$PROJECT_ROOT"
mvn clean package -DskipTests -q
# 检查jar文件是否生成成功
JAR_FILE="$PROJECT_ROOT/qaup-admin/target/qaup-admin.jar"
if [ ! -f "$JAR_FILE" ]; then
print_message $RED "❌ jar文件构建失败"
exit 1
fi
# 2. 创建更新包目录
UPDATE_DIR="qaup-update-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$UPDATE_DIR"
# 3. 复制jar文件
print_message $BLUE "准备更新文件..."
cp "$JAR_FILE" "$UPDATE_DIR/qaup-admin.jar"
# 4. 创建更新说明
cat > "$UPDATE_DIR/UPDATE-INSTRUCTIONS.md" << 'EOF'
# QAUP 程序更新包
## 包含内容
- `qaup-admin.jar` - 新版本应用程序
## 更新步骤
### 1. 上传文件到服务器
将 `qaup-admin.jar` 上传到服务器的 qaup-deploy 目录
### 2. 重命名文件
```bash
cd qaup-deploy
cp qaup-admin.jar new-app.jar
```
### 3. 执行更新
```bash
./update.sh
```
### 4. 验证更新
```bash
# 检查服务状态
docker compose ps
# 检查应用日志
docker compose logs -f qaup-app
# 访问系统确认功能正常
curl http://localhost:8080/actuator/health
```
## 注意事项
- 更新前建议备份数据库
- 如果更新失败，脚本会自动回滚
- 如有问题，请查看完整的部署更新说明文档
EOF
# 5. 创建版本信息
cat > "$UPDATE_DIR/VERSION-INFO.txt" << EOF
QAUP 程序更新包
构建时间: $(date)
构建主机: $(hostname)
Git提交: $(git rev-parse --short HEAD 2>/dev/null || echo "未知")
Maven版本: $(mvn --version | head -1)
Java版本: $(java -version 2>&1 | head -1)
文件大小: $(du -sh "$JAR_FILE" | cut -f1)
文件MD5: $(md5sum "$JAR_FILE" | cut -d' ' -f1)
EOF
# 6. 创建更新包
PACKAGE_NAME="${UPDATE_DIR}.zip"
zip -r "$PACKAGE_NAME" "$UPDATE_DIR/"
# 7. 清理临时目录
rm -rf "$UPDATE_DIR"
print_message $GREEN "✅ 程序更新包创建完成: $PACKAGE_NAME"
print_message $BLUE "包大小: $(du -sh "$PACKAGE_NAME" | cut -f1)"
echo ""
echo "使用说明:"
echo "1. 将 $PACKAGE_NAME 发送给客户"
echo "2. 客户解压后按照 UPDATE-INSTRUCTIONS.md 操作"
echo "3. 或者直接发送 qaup-admin.jar 文件给客户"

68
deploy/simple/config.yml Normal file
View File

@ -0,0 +1,68 @@
# QAUP 生产环境配置
server:
port: 8080
# 数据库配置
spring:
datasource:
url: jdbc:postgresql://qaup-postgres:5432/qaup
username: postgres
password: 123456
driver-class-name: org.postgresql.Driver
type: com.alibaba.druid.pool.DruidDataSource
druid:
initial-size: 5
min-idle: 5
max-active: 20
max-wait: 60000
validation-query: SELECT 1
test-while-idle: true
# Redis配置
data:
redis:
host: qaup-redis
port: 6379
database: 0
timeout: 10s
# JPA配置
jpa:
hibernate:
ddl-auto: none
show-sql: false
# 应用配置
qaup:
name: QAUP
version: 1.0.1
profile: /app/uploads
# 外部接口配置（客户可修改）
external:
airport-api:
base-url: http://192.168.1.100:8090
username: dianxin
password: dianxin@123
vehicle-api:
base-url: http://192.168.1.100:8090
# 日志配置
logging:
level:
com.qaup: info
org.springframework: warn
pattern:
console: "%d{HH:mm:ss} %-5level %logger{36} - %msg%n"
# 数据采集配置
data:
collector:
interval: 250
detection:
interval: 1000
# 坐标系统配置
coordinate-system:
airport:
center-longitude: 120.0834104
center-latitude: 36.35406879

71
deploy/simple/create-init-sql.sh Normal file
View File

@ -0,0 +1,71 @@
#!/bin/bash
# 创建简化的数据库初始化脚本
# 从现有的数据库架构文件生成init.sql
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
echo "=== 创建数据库初始化脚本 ==="
# 输出文件
INIT_SQL="$SCRIPT_DIR/init.sql"
# 创建初始化脚本
cat > "$INIT_SQL" << 'EOF'
-- QAUP 数据库初始化脚本
-- 简化版本：只创建必要的扩展和导入数据
-- 创建PostGIS扩展
CREATE EXTENSION IF NOT EXISTS postgis;
CREATE EXTENSION IF NOT EXISTS postgis_topology;
-- 显示扩展信息
SELECT 'PostGIS扩展安装完成' as message;
EOF
# 如果存在数据库架构文件，追加到初始化脚本
SCHEMA_FILE="$PROJECT_ROOT/deploy/docker/postgres/qaup_database_schema.sql"
if [ -f "$SCHEMA_FILE" ]; then
echo "-- 导入数据库架构" >> "$INIT_SQL"
cat "$SCHEMA_FILE" >> "$INIT_SQL"
echo "✓ 已添加数据库架构"
else
echo "⚠ 未找到数据库架构文件: $SCHEMA_FILE"
fi
# 添加完整初始数据（优先使用完整数据文件）
COMPLETE_DATA_FILE="$PROJECT_ROOT/deploy/docker/postgres/export/initial_data_complete.sql"
if [ -f "$COMPLETE_DATA_FILE" ]; then
echo "" >> "$INIT_SQL"
echo "-- 导入完整初始数据" >> "$INIT_SQL"
cat "$COMPLETE_DATA_FILE" >> "$INIT_SQL"
echo "✓ 已添加完整初始数据文件"
else
echo "⚠ 未找到完整初始数据文件: $COMPLETE_DATA_FILE"
echo "-- 注意：数据库将只包含基础结构，无初始数据" >> "$INIT_SQL"
fi
# 添加完成信息
cat >> "$INIT_SQL" << 'EOF'
-- 显示数据库信息
SELECT
current_database() as database_name,
current_user as current_user,
version() as postgresql_version;
-- 显示表数量
SELECT
schemaname,
COUNT(*) as table_count
FROM pg_tables
WHERE schemaname = 'public'
GROUP BY schemaname;
SELECT 'QAUP数据库初始化完成' as message;
EOF
echo "✅ 初始化脚本创建完成: $INIT_SQL"
echo "文件大小: $(du -sh "$INIT_SQL" | cut -f1)"

47
deploy/simple/deploy.sh Executable file
View File

@ -0,0 +1,47 @@
#!/bin/bash
# QAUP 一键部署脚本
set -e
echo "=== QAUP 一键部署 ==="
# 检查Docker
if ! command -v docker &> /dev/null; then
echo "❌ Docker 未安装"
exit 1
fi
# 载入镜像
echo "载入Docker镜像..."
docker load -i images.tar.gz
# 创建数据目录
echo "创建数据目录..."
mkdir -p data/postgres data/redis logs
# 启动服务
echo "启动服务..."
docker compose up -d
# 等待服务启动
echo "等待服务启动（60秒）..."
sleep 60
# 检查服务状态
if curl -f -s http://localhost:8080/actuator/health > /dev/null 2>&1; then
echo "✅ 部署成功！"
echo ""
echo "访问地址: http://localhost:8080"
echo "数据库: localhost:5432 (qaup/qaup123)"
echo "Redis: localhost:6379"
echo ""
echo "管理命令:"
echo " 查看状态: docker compose ps"
echo " 查看日志: docker compose logs -f qaup-app"
echo " 停止服务: docker compose down"
echo " 升级应用: ./update.sh"
else
echo "❌ 服务启动失败，请检查日志:"
docker compose logs
fi

67
deploy/simple/docker-compose.yml Normal file
View File

@ -0,0 +1,67 @@
services:
# PostgreSQL 数据库服务
qaup-postgres:
image: m.daocloud.io/docker.io/postgis/postgis:17-3.5-alpine
container_name: qaup-postgres
restart: unless-stopped
environment:
POSTGRES_DB: qaup
POSTGRES_USER: qaup
POSTGRES_PASSWORD: qaup123
volumes:
- ./data/postgres:/var/lib/postgresql/data
- ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro
ports:
- "5432:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U qaup"]
interval: 30s
timeout: 10s
retries: 5
# Redis 缓存服务
qaup-redis:
image: m.daocloud.io/docker.io/library/redis:8.0-alpine
container_name: qaup-redis
restart: unless-stopped
command: ["redis-server", "--maxmemory", "256mb", "--maxmemory-policy", "allkeys-lru"]
volumes:
- ./data/redis:/data
ports:
- "6379:6379"
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 30s
timeout: 10s
retries: 3
# QAUP 应用服务
qaup-app:
image: m.daocloud.io/docker.io/library/eclipse-temurin:17-jre
container_name: qaup-app
restart: unless-stopped
environment:
SPRING_PROFILES_ACTIVE: prod
LOG_PATH: /app/logs
volumes:
- ./app.jar:/app/app.jar
- ./config.yml:/app/config.yml
- ./logs:/app/logs
ports:
- "8080:8080"
depends_on:
qaup-postgres:
condition: service_healthy
qaup-redis:
condition: service_healthy
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
interval: 30s
timeout: 10s
retries: 5
start_period: 120s
command: ["java", "-jar", "/app/app.jar", "--spring.config.location=/app/config.yml"]
networks:
default:
name: qaup-network

73
deploy/simple/package.sh Executable file
View File

@ -0,0 +1,73 @@
#!/bin/bash
# QAUP 简化打包脚本
# 基于现有复杂方案，简化为一键打包
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m'
print_message() {
echo -e "${1}${2}${NC}"
}
print_message $BLUE "=== QAUP 简化打包脚本 ==="
# 1. 构建应用
print_message $BLUE "构建应用..."
cd "$PROJECT_ROOT"
mvn clean package -DskipTests -q
# 2. 准备镜像版本（使用国内镜像加速器）
POSTGRES_IMAGE="m.daocloud.io/docker.io/postgis/postgis:17-3.5-alpine"
REDIS_IMAGE="m.daocloud.io/docker.io/library/redis:8.0-alpine"
OPENJDK_IMAGE="m.daocloud.io/docker.io/library/eclipse-temurin:17-jre"
print_message $BLUE "拉取基础镜像..."
docker pull $POSTGRES_IMAGE
docker pull $REDIS_IMAGE
docker pull $OPENJDK_IMAGE
# 3. 导出镜像（只导出基础镜像，不需要构建自定义镜像）
print_message $BLUE "导出镜像..."
mkdir -p qaup-deploy
docker save $POSTGRES_IMAGE $REDIS_IMAGE $OPENJDK_IMAGE | gzip > qaup-deploy/images.tar.gz
# 5. 复制必要文件
print_message $BLUE "准备部署文件..."
cp qaup-admin/target/qaup-admin.jar qaup-deploy/app.jar
cp deploy/simple/docker-compose.yml qaup-deploy/
cp deploy/simple/config.yml qaup-deploy/
# 复制数据库相关文件
mkdir -p qaup-deploy/sql
cp deploy/docker/postgres/qaup_database_schema.sql qaup-deploy/sql/ 2>/dev/null || echo "⚠ 数据库架构文件不存在"
cp deploy/docker/postgres/export/initial_data_complete.sql qaup-deploy/sql/ 2>/dev/null || echo "⚠ 完整初始数据文件不存在"
# 创建数据库初始化脚本
./deploy/simple/create-init-sql.sh
cp deploy/simple/init.sql qaup-deploy/
cp deploy/simple/deploy.sh qaup-deploy/
cp deploy/simple/update.sh qaup-deploy/
cp deploy/simple/UPGRADE-README.md qaup-deploy/
# 6. 创建部署包
PACKAGE_NAME="qaup-deploy-$(date +%Y%m%d-%H%M%S).zip"
cd qaup-deploy && zip -r ../$PACKAGE_NAME . && cd ..
print_message $GREEN "✅ 打包完成: $PACKAGE_NAME"
print_message $BLUE "部署包大小: $(du -sh $PACKAGE_NAME | cut -f1)"
echo ""
echo "部署说明:"
echo "1. 将 $PACKAGE_NAME 传输到目标服务器"
echo "2. unzip $PACKAGE_NAME && cd qaup-deploy"
echo "3. ./deploy.sh"

46
deploy/simple/update.sh Executable file
View File

@ -0,0 +1,46 @@
#!/bin/bash
# QAUP 一键升级脚本
set -e
echo "=== QAUP 一键升级 ==="
# 检查新版本文件
if [ ! -f "new-app.jar" ]; then
echo "❌ 请先将新版本文件重命名为 new-app.jar"
echo " 例如: cp qaup-admin-1.0.2.jar new-app.jar"
exit 1
fi
# 备份当前版本
echo "备份当前版本..."
cp app.jar app.jar.backup.$(date +%Y%m%d-%H%M%S)
# 停止应用
echo "停止应用服务..."
docker compose stop qaup-app
# 替换应用
echo "更新应用文件..."
cp new-app.jar app.jar
# 启动应用
echo "启动应用服务..."
docker compose start qaup-app
# 等待启动
echo "等待服务启动（30秒）..."
sleep 30
# 检查服务状态
if curl -f -s http://localhost:8080/actuator/health > /dev/null 2>&1; then
echo "✅ 升级成功！"
echo "备份文件已保存，如有问题可手动回滚"
else
echo "❌ 升级失败，尝试回滚..."
docker compose stop qaup-app
cp app.jar.backup.* app.jar 2>/dev/null || echo "未找到备份文件"
docker compose start qaup-app
echo "请检查日志: docker compose logs qaup-app"
fi

236
doc/deploy/deploy-design.md Normal file
View File

@ -0,0 +1,236 @@
# QAUP 极简离线部署方案
Spring Boot + Redis + PostgreSQL（一键部署、一键升级）
## 1. 设计原则
- **极简优先**：最少的文件，最少的步骤
- **离线部署**：预打包所有依赖，无需联网
- **一键操作**：部署和升级都是一条命令
- **配置灵活**：关键配置可外部修改
## 2. 打包准备（开发环境执行一次）
### 2.1 打包脚本（package.sh）
```bash
#!/bin/bash
echo "=== QAUP 打包脚本 ==="
# 1. 构建应用
mvn clean package -DskipTests
# 2. 拉取并导出镜像
docker pull openjdk:17-jre-alpine
docker pull redis:7-alpine
docker pull postgres:15-alpine
docker save openjdk:17-jre-alpine redis:7-alpine postgres:15-alpine | gzip > images.tar.gz
# 3. 准备部署包
mkdir -p qaup-deploy
cp qaup-admin/target/qaup-admin.jar qaup-deploy/app.jar
cp deploy/simple/* qaup-deploy/
cp images.tar.gz qaup-deploy/
# 4. 打包
cd qaup-deploy && zip -r ../qaup-deploy-$(date +%Y%m%d).zip .
echo "打包完成: qaup-deploy-$(date +%Y%m%d).zip"
```
### 2.2 部署包结构（极简版）
```
qaup-deploy.zip
├── images.tar.gz # Docker镜像包
├── docker-compose.yml # 服务编排
├── app.jar # 应用程序
├── config.yml # 外部配置（可修改）
├── init.sql # 数据库初始化脚本
├── deploy.sh # 一键部署
└── update.sh # 一键升级
```
## 3. docker-compose.yml（极简版）
```yaml
services:
app:
image: openjdk:17-jre-alpine
container_name: qaup-app
restart: always
ports:
- "8080:8080"
volumes:
- ./app.jar:/app.jar
- ./config.yml:/config.yml
command: ["java", "-jar", "/app.jar", "--spring.config.location=/config.yml"]
depends_on:
- db
- redis
redis:
image: redis:7-alpine
container_name: qaup-redis
restart: always
command: ["redis-server", "--maxmemory", "256mb", "--maxmemory-policy", "allkeys-lru"]
db:
image: postgres:15-alpine
container_name: qaup-db
restart: always
environment:
POSTGRES_DB: qaup
POSTGRES_USER: qaup
POSTGRES_PASSWORD: qaup123
volumes:
- ./data:/var/lib/postgresql/data
- ./init.sql:/docker-entrypoint-initdb.d/init.sql
```
## 4. 外部配置文件（config.yml）
```yaml
# 服务器配置
server:
port: 8080
# 数据库配置
spring:
datasource:
url: jdbc:postgresql://qaup-db:5432/qaup
username: qaup
password: qaup123
driver-class-name: org.postgresql.Driver
# Redis配置
data:
redis:
host: qaup-redis
port: 6379
database: 0
# 应用配置
qaup:
# 文件上传路径
profile: /tmp/uploads
# 外部接口配置（客户可修改）
external:
api-host: 192.168.1.100
api-port: 8090
# 日志配置（简化）
logging:
level:
com.qaup: info
pattern:
console: "%d{HH:mm:ss} %-5level %logger{36} - %msg%n"
```
## 5. 数据库初始化（init.sql）
```sql
-- 创建基础表结构
CREATE TABLE IF NOT EXISTS sys_user (
user_id SERIAL PRIMARY KEY,
user_name VARCHAR(30) NOT NULL,
nick_name VARCHAR(30) NOT NULL,
password VARCHAR(100) DEFAULT '',
status CHAR(1) DEFAULT '0',
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- 插入默认管理员
INSERT INTO sys_user (user_name, nick_name, password)
VALUES ('admin', '管理员', '$2a$10$7JB720yubVSOfvam/RtmyO4wV/hOoLsKpHpJI.VqSb/VXaVzqQqhu')
ON CONFLICT DO NOTHING;
-- 其他标准数据...
```
## 6. 一键部署（deploy.sh）
```bash
#!/bin/bash
echo "=== QAUP 一键部署 ==="
# 载入镜像
echo "载入Docker镜像..."
docker load -i images.tar.gz
# 创建数据目录
mkdir -p data
# 启动服务
echo "启动服务..."
docker compose up -d
# 等待启动
echo "等待服务启动（30秒）..."
sleep 30
echo "✅ 部署完成！访问: http://localhost:8080"
echo "默认账号: admin / admin123"
```
## 7. 客户部署（1条命令）
```bash
unzip qaup-deploy.zip && cd qaup-deploy && ./deploy.sh
```
## 8. 一键升级（update.sh）
```bash
#!/bin/bash
echo "=== QAUP 一键升级 ==="
# 检查新版本文件
if [ ! -f "new-app.jar" ]; then
echo "❌ 请先将新版本文件重命名为 new-app.jar"
exit 1
fi
# 备份当前版本
cp app.jar app.jar.backup
echo "已备份当前版本"
# 停止应用
echo "停止应用服务..."
docker compose stop app
# 替换应用
cp new-app.jar app.jar
echo "已更新应用文件"
# 启动应用
echo "启动应用服务..."
docker compose start app
# 等待启动
echo "等待服务启动（30秒）..."
sleep 30
echo "✅ 升级完成！"
echo "如有问题，可执行回滚: cp app.jar.backup app.jar && docker compose restart app"
```
## 9. 操作总结
### 开发环境（一次性）
```bash
./package.sh # 打包部署文件
```
### 客户环境
```bash
# 首次部署
unzip qaup-deploy.zip && cd qaup-deploy && ./deploy.sh
# 日常升级
./update.sh
# 查看状态
docker compose ps
# 查看日志
docker compose logs -f app
```
## 10. 优势总结
✅ **极简部署**：解压 → 运行脚本，2步完成
✅ **极简升级**：替换jar → 运行脚本，自动完成
✅ **离线友好**：所有依赖预打包，无需联网
✅ **配置灵活**：关键配置外部文件，可随时修改
✅ **自动初始化**：数据库结构和标准数据自动创建
✅ **一键回滚**：升级失败可快速回滚到上一版本

2
qaup-admin/src/main/resources/logback.xml
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- 日志存放路径 -->
<property name="log.path" value="${LOG_PATH:-/app/logs}" />
<property name="log.path" value="${LOG_PATH:-logs}" />
<!-- 日志输出格式 -->
<property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />