tjt_czjs_backend/doc/部署指南.md

# 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 运维团队