# 多源遥感数据集成与智能分析综合可视化平台 — 部署与运维说明文档

> 文档编号：WX-DEPLOY-001 | 版本：v2.1 | 密级：内部机密
> 编制日期：2026-06-13 | 编制单位：卫星陕西项目组
> 配套文档：[CODE_WIKI.md](./CODE_WIKI.md) | [REQUIREMENTS.md](./REQUIREMENTS.md) | [DEVELOPMENT.md](./DEVELOPMENT.md)

---

## 一、部署架构

### 1.1 整体部署拓扑

```mermaid
graph TB
    subgraph NET["内网安全区域"]
        NG[Nginx<br/>负载均衡<br/>192.168.1.10]

        subgraph APP["应用服务"]
            FE[前端服务<br/>Nginx<br/>192.168.1.11]
            API[API网关<br/>Spring Boot<br/>192.168.1.20]
            IMG[影像处理<br/>FastAPI + Celery<br/>192.168.1.21]
            AI[AI推理<br/>vLLM + GPU<br/>192.168.1.22]
            OPS[运维服务<br/>192.168.1.23]
        end

        subgraph DB["数据存储"]
            PG[PostgreSQL<br/>+ PostGIS<br/>192.168.1.31]
            MN[MinIO<br/>文件存储<br/>192.168.1.32]
            RD[Redis<br/>缓存<br/>192.168.1.33]
            MQ[RabbitMQ<br/>消息队列<br/>192.168.1.34]
            ES[Elasticsearch<br/>搜索引擎<br/>192.168.1.35]
        end

        subgraph GPU["GPU集群"]
            GP[GPU服务器<br/>A100 x2<br/>192.168.1.40]
        end

        subgraph NFS["共享存储"]
            NF[NFS/GlusterFS<br/>影像/瓦片/模型]
        end
    end

    NG --> FE
    NG --> API
    API --> IMG
    API --> AI
    API --> OPS
    IMG --> PG
    IMG --> MN
    IMG --> RD
    IMG --> MQ
    AI --> GP
    AI --> NF
    OPS --> ES
    OPS --> RD
    PG --> NF
    MN --> NF

    style NET fill:#F5F5F5,stroke:#424242,stroke-width:3px
    style NG fill:#E3F2FD,stroke:#1565C0,stroke-width:2px
    style APP fill:#E8F5E9,stroke:#2E7D32,stroke-width:2px
    style DB fill:#FFF3E0,stroke:#E65100,stroke-width:2px
    style GPU fill:#FCE4EC,stroke:#C2185B,stroke-width:2px
    style NFS fill:#E1F5FE,stroke:#0277BD,stroke-width:2px
```

### 1.2 服务器配置清单

| 服务器 | IP | 配置 | 用途 |
|--------|-----|------|------|
| Nginx | 192.168.1.10 | 4C/8G | 负载均衡、SSL终止、WAF |
| 前端 | 192.168.1.11 | 2C/4G | 静态资源服务 |
| API网关 | 192.168.1.20 | 8C/16G | Spring Boot业务服务 |
| 影像处理 | 192.168.1.21 | 16C/32G | FastAPI + Celery + MapProxy + COG切图 |
| AI推理 | 192.168.1.22 | 32C/64G + GPU | vLLM + MMDet + MMSeg |
| 运维 | 192.168.1.23 | 4C/8G | Prometheus + Grafana + Loki |
| PostgreSQL | 192.168.1.31 | 16C/64G + SSD | 数据库（PostGIS 3.4，EPSG:4490支持） |
| MinIO | 192.168.1.32 | 8C/16G + 50TB磁盘 | 文件存储 |
| Redis | 192.168.1.33 | 8C/32G | 缓存 |
| RabbitMQ | 192.168.1.34 | 4C/8G | 消息队列 |
| Elasticsearch | 192.168.1.35 | 16C/32G + SSD | 搜索引擎 |
| GPU服务器 | 192.168.1.40 | 64C/256G + A100×2 | AI推理（vLLM + MMDetection） |

---

## 二、环境准备

### 2.1 操作系统配置

```bash
# CentOS 7+ 最小化安装后配置

# 1. 关闭防火墙外网访问（仅允许内网）
firewall-cmd --permanent --set-default-zone=drop
firewall-cmd --permanent --zone=trusted --add-source=192.168.1.0/24
firewall-cmd --reload

# 2. 禁用SELinux（或配置策略）
setenforce 0
sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/selinux/config

# 3. 系统参数优化
cat >> /etc/sysctl.conf << 'EOF'
vm.max_map_count=262144
vm.swappiness=1
net.core.somaxconn=65535
net.ipv4.tcp_max_syn_backlog=65535
fs.file-max=655360
EOF
sysctl -p

# 4. 文件描述符限制
cat >> /etc/security/limits.conf << 'EOF'
* soft nofile 655360
* hard nofile 655360
* soft nproc 655360
* hard nproc 655360
EOF
```

### 2.2 Docker 安装

```bash
# 安装Docker
yum install -y yum-utils
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum install -y docker-ce-24.0.9 docker-ce-cli-24.0.9 containerd.io

# 配置Docker（内网镜像仓库）
mkdir -p /etc/docker
cat > /etc/docker/daemon.json << 'EOF'
{
  "registry-mirrors": ["https://192.168.1.50:5000"],
  "data-root": "/data/docker",
  "storage-driver": "overlay2",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "5"
  }
}
EOF

systemctl enable docker && systemctl start docker

# 安装Docker Compose
curl -L https://github.com/docker/compose/releases/download/v2.27.0/docker-compose-linux-x86_64 \
  -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
```

### 2.3 GPU 服务器配置

```bash
# 安装NVIDIA驱动
yum install -y kernel-devel gcc
bash NVIDIA-Linux-x86_64-550.54.15.run

# 安装CUDA Toolkit 12.4
bash cuda_12.4.1_550.54.15_linux.run

# 安装nvidia-container-toolkit
yum install -y nvidia-container-toolkit
systemctl restart docker

# 验证GPU
nvidia-smi
docker run --rm --gpus all nvidia/cuda:12.4.1-base-ubuntu22.04 nvidia-smi
```

### 2.4 共享存储配置

```bash
# NFS服务器端（192.168.1.50）
yum install -y nfs-utils
mkdir -p /data/imagery /data/tiles /data/models /data/backup
cat >> /etc/exports << 'EOF'
/data/imagery 192.168.1.0/24(rw,sync,no_subtree_check)
/data/tiles   192.168.1.0/24(rw,sync,no_subtree_check)
/data/models  192.168.1.0/24(rw,sync,no_subtree_check)
/data/backup  192.168.1.0/24(rw,sync,no_subtree_check)
EOF
systemctl enable nfs-server && systemctl start nfs-server
exportfs -rav

# NFS客户端（各应用服务器）
yum install -y nfs-utils
mkdir -p /data/imagery /data/tiles /data/models
cat >> /etc/fstab << 'EOF'
192.168.1.50:/data/imagery /data/imagery nfs defaults 0 0
192.168.1.50:/data/tiles   /data/tiles   nfs defaults 0 0
192.168.1.50:/data/models  /data/models  nfs defaults 0 0
EOF
mount -a
```

---

## 三、Docker Compose 部署

### 3.1 主编排文件

```yaml
# docker-compose.yml
version: '3.8'

services:
  # ==================== 基础设施 ====================

  postgres:
    image: postgis/postgis:16-3.4
    container_name: zkxg-postgres
    restart: always
    environment:
      POSTGRES_DB: zkxg
      POSTGRES_USER: ${DB_USER:-zkxg}
      POSTGRES_PASSWORD: ${DB_PASS:-zkxg123}
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./postgres/init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5432:5432"
    networks:
      - zkxg-net
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U zkxg"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7.2-alpine
    container_name: zkxg-redis
    restart: always
    command: redis-server --requirepass ${REDIS_PASS:-redis123} --maxmemory 8gb --maxmemory-policy allkeys-lru
    volumes:
      - redisdata:/data
    ports:
      - "6379:6379"
    networks:
      - zkxg-net

  rabbitmq:
    image: rabbitmq:3.13-management-alpine
    container_name: zkxg-rabbitmq
    restart: always
    environment:
      RABBITMQ_DEFAULT_USER: ${MQ_USER:-zkxg}
      RABBITMQ_DEFAULT_PASS: ${MQ_PASS:-zkxg123}
    volumes:
      - mqdata:/var/lib/rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    networks:
      - zkxg-net

  elasticsearch:
    image: elasticsearch:8.13.4
    container_name: zkxg-elasticsearch
    restart: always
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"
    volumes:
      - esdata:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"
    networks:
      - zkxg-net

  minio:
    image: minio/minio:RELEASE.2024-06-06T09-36-42Z
    container_name: zkxg-minio
    restart: always
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: ${MINIO_ACCESS_KEY:-minioadmin}
      MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY:-minioadmin}
    volumes:
      - /data/imagery:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    networks:
      - zkxg-net

  # ==================== 应用服务 ====================

  backend:
    build:
      context: ../backend
      dockerfile: Dockerfile
    container_name: zkxg-backend
    restart: always
    environment:
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_NAME=zkxg
      - DB_USER=${DB_USER:-zkxg}
      - DB_PASS=${DB_PASS:-zkxg123}
      - REDIS_HOST=redis
      - MINIO_HOST=minio
      - ES_HOST=elasticsearch
      - MQ_HOST=rabbitmq
      - IMAGING_HOST=imaging
      - AI_HOST=ai
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
      minio:
        condition: service_started
    ports:
      - "8080:8080"
    volumes:
      - /data/imagery:/data/imagery
    networks:
      - zkxg-net

  imaging:
    build:
      context: ../imaging
      dockerfile: Dockerfile
    container_name: zkxg-imaging
    restart: always
    environment:
      - DB_HOST=postgres
      - REDIS_HOST=redis
      - MINIO_HOST=minio
      - MQ_HOST=rabbitmq
    depends_on:
      - postgres
      - redis
      - rabbitmq
    ports:
      - "8001:8001"
    volumes:
      - /data/imagery:/data/imagery
      - /data/tiles:/data/tiles
    networks:
      - zkxg-net

  imaging-worker:
    build:
      context: ../imaging
      dockerfile: Dockerfile
    container_name: zkxg-imaging-worker
    restart: always
    command: celery -A app.tasks worker --loglevel=info --concurrency=4
    environment:
      - DB_HOST=postgres
      - REDIS_HOST=redis
      - MINIO_HOST=minio
      - MQ_HOST=rabbitmq
    depends_on:
      - redis
      - rabbitmq
    volumes:
      - /data/imagery:/data/imagery
      - /data/tiles:/data/tiles
    networks:
      - zkxg-net
    deploy:
      replicas: 4

  mapproxy:
    image: mapproxy/mapproxy:1.15.0
    container_name: zkxg-mapproxy
    restart: always
    volumes:
      - ./mapproxy/mapproxy.yaml:/mapproxy/mapproxy.yaml
      - /data/tiles:/data/tiles
      - /data/mapproxy_cache:/data/mapproxy_cache
    ports:
      - "8003:8080"
    networks:
      - zkxg-net

  ai:
    build:
      context: ../ai
      dockerfile: Dockerfile
    container_name: zkxg-ai
    restart: always
    environment:
      - MODEL_PATH=/data/models
      - GPU_DEVICES=0,1
    volumes:
      - /data/models:/data/models
      - /data/imagery:/data/imagery:ro
    ports:
      - "8002:8002"
    networks:
      - zkxg-net
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

  frontend:
    build:
      context: ../frontend
      dockerfile: Dockerfile
    container_name: zkxg-frontend
    restart: always
    ports:
      - "80:80"
    networks:
      - zkxg-net

volumes:
  pgdata:
  redisdata:
  mqdata:
  esdata:

networks:
  zkxg-net:
    driver: bridge
```

### 3.2 环境变量文件

```bash
# .env
# 数据库
DB_USER=zkxg
DB_PASS=<CHANGE_ME>
DB_NAME=zkxg

# Redis
REDIS_PASS=<CHANGE_ME>

# RabbitMQ
MQ_USER=zkxg
MQ_PASS=<CHANGE_ME>

# MinIO
MINIO_ACCESS_KEY=<CHANGE_ME>
MINIO_SECRET_KEY=<CHANGE_ME>

# JWT
JWT_SECRET=<CHANGE_ME_32_CHARS_MIN>
```

---

## 四、部署步骤

### 4.1 首次部署

```bash
# 1. 克隆代码
cd /opt
git clone <repo-url> zkxg
cd zkxg

# 2. 配置环境变量
cp .env.example .env
vim .env  # 修改所有密码和密钥

# 3. 构建镜像
docker-compose build

# 4. 启动基础设施
docker-compose up -d postgres redis rabbitmq elasticsearch minio

# 5. 等待基础设施就绪
sleep 30

# 6. 初始化数据库（含PostGIS扩展和CGCS2000坐标系支持）
docker-compose exec postgres psql -U zkxg -c "CREATE EXTENSION IF NOT EXISTS postgis;"
docker-compose exec postgres psql -U zkxg -c "SELECT PostGIS_Full_Version();"
docker-compose exec backend java -jar init-db.jar

# 7. 初始化MinIO Bucket
docker-compose exec minio mc alias set local http://localhost:9000 $MINIO_ACCESS_KEY $MINIO_SECRET_KEY
docker-compose exec minio mc mb local/remote-sensing
docker-compose exec minio mc mb local/tiles

# 8. 初始化Elasticsearch索引
curl -X PUT http://localhost:9200/remote-data -H 'Content-Type: application/json' -d '
{
  "mappings": {
    "properties": {
      "fileName": { "type": "text", "analyzer": "ik_max_word" },
      "imagingTime": { "type": "date" },
      "satellite": { "type": "keyword" },
      "sensor": { "type": "keyword" },
      "dataLevel": { "type": "keyword" },
      "cloudCover": { "type": "double" },
      "resolution": { "type": "double" },
      "geometry": { "type": "geo_shape" }
    }
  }
}'

# 9. 部署AI模型（提前下载到内网）
# 将模型文件复制到共享存储
cp -r /path/to/models/* /data/models/

# 10. 启动所有服务
docker-compose up -d

# 11. 验证服务状态
docker-compose ps
curl http://localhost:8080/api/health
curl http://localhost:8001/docs
curl http://localhost:8002/docs
```

### 4.2 更新部署

```bash
# 滚动更新后端服务
docker-compose build backend
docker-compose up -d --no-deps backend

# 滚动更新影像处理服务
docker-compose build imaging imaging-worker
docker-compose up -d --no-deps imaging
docker-compose up -d --no-deps imaging-worker

# 滚动更新AI服务
docker-compose build ai
docker-compose up -d --no-deps ai

# 滚动更新前端
docker-compose build frontend
docker-compose up -d --no-deps frontend
```

---

## 五、数据备份与恢复

### 5.1 备份策略

| 数据类型 | 备份方式 | 频率 | 保留周期 |
|----------|----------|------|----------|
| PostgreSQL | pg_dump 全量 | 每日 02:00 | 30天 |
| PostgreSQL | WAL归档 | 实时 | 7天 |
| MinIO文件 | rclone镜像 | 每周日 03:00 | 4周 |
| Elasticsearch | snapshot | 每日 03:00 | 14天 |
| Redis | RDB快照 | 每15分钟 | 3天 |
| 系统配置 | 文件备份 | 每次变更 | 永久 |

### 5.2 备份脚本

```bash
#!/bin/bash
# scripts/backup.sh

BACKUP_DIR="/data/backup/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR

# PostgreSQL备份
docker-compose exec -T postgres pg_dump -U zkxg zkxg | gzip > $BACKUP_DIR/postgres_$(date +%Y%m%d_%H%M%S).sql.gz

# Elasticsearch备份
curl -X PUT "localhost:9200/_snapshot/backup/snapshot_$(date +%Y%m%d)?wait_for_completion=true"

# MinIO Bucket信息备份
docker-compose exec minio mc admin info local > $BACKUP_DIR/minio_info_$(date +%Y%m%d).txt

echo "备份完成: $BACKUP_DIR"
```

### 5.3 恢复操作

```bash
# PostgreSQL恢复
gunzip -c /data/backup/20240601/postgres_20240601_020000.sql.gz | \
  docker-compose exec -T postgres psql -U zkxg zkxg

# Elasticsearch恢复
curl -X POST "localhost:9200/_snapshot/backup/snapshot_20240601/_restore"

# MinIO恢复（从备份存储）
rclone sync /data/backup/minio/ minio:remote-sensing/
```

---

## 六、监控与告警

### 6.1 监控体系

```mermaid
graph TB
    subgraph TOP["监控体系"]
        GF[Grafana<br/>监控大盘<br/>192.168.1.23:3000]
    end

    subgraph COL["数据采集"]
        PR[Prometheus<br/>指标采集]
        NE[Node Exporter<br/>主机监控]
        CA[cAdvisor<br/>容器监控]
    end

    subgraph LOG["日志采集"]
        PG_LOG[PostgreSQL<br/>日志采集]
        LO[Loki<br/>应用日志]
        DC[NVIDIA DCGM<br/>GPU监控]
    end

    PR --> GF
    NE --> PR
    CA --> PR
    PG_LOG --> LO
    LO --> GF
    DC --> GF

    style TOP fill:#E3F2FD,stroke:#1565C0,stroke-width:2px
    style COL fill:#E8F5E9,stroke:#2E7D32,stroke-width:2px
    style LOG fill:#FFF3E0,stroke:#E65100,stroke-width:2px
```

### 6.2 监控指标

| 类别 | 指标 | 告警阈值 |
|------|------|----------|
| **系统** | CPU使用率 | > 85% 持续5分钟 |
| **系统** | 内存使用率 | > 90% |
| **系统** | 磁盘使用率 | > 85% |
| **系统** | 磁盘IO等待 | > 50% 持续5分钟 |
| **GPU** | GPU使用率 | > 95% 持续10分钟 |
| **GPU** | GPU显存使用率 | > 95% |
| **GPU** | GPU温度 | > 85°C |
| **数据库** | 活跃连接数 | > 80%最大连接数 |
| **数据库** | 慢查询 | > 10秒 |
| **数据库** | 复制延迟 | > 30秒 |
| **应用** | API响应时间(P99) | > 5秒 |
| **应用** | API错误率 | > 1% |
| **应用** | Celery队列积压 | > 1000任务 |
| **存储** | MinIO磁盘使用率 | > 80% |
| **搜索** | ES集群状态 | 非GREEN |

### 6.3 告警通知

| 级别 | 通知方式 | 响应时间 |
|------|----------|----------|
| P0 - 紧急 | 电话 + 短信 + 即时消息 | 15分钟内 |
| P1 - 严重 | 短信 + 即时消息 | 30分钟内 |
| P2 - 一般 | 即时消息 | 2小时内 |
| P3 - 提示 | 邮件 | 次工作日 |

---

## 七、安全加固

### 7.1 网络安全

> **等保三级2025数据安全新规要求**：实施内网微隔离，按业务域划分安全区域（DMZ/应用区/数据区/存储区），域间流量管控。

```bash
# 防火墙规则（仅允许内网访问）
firewall-cmd --permanent --zone=trusted --add-source=192.168.1.0/24
firewall-cmd --permanent --zone=public --remove-port=80/tcp
firewall-cmd --permanent --zone=public --remove-port=443/tcp
firewall-cmd --reload

# 禁止外网访问
iptables -A OUTPUT -d 0.0.0.0/0 -j DROP
iptables -I OUTPUT -d 192.168.0.0/16 -j ACCEPT
iptables -I OUTPUT -d 10.0.0.0/8 -j ACCEPT
iptables -I OUTPUT -d 172.16.0.0/12 -j ACCEPT

# 内网微隔离：限制应用区仅访问数据区指定端口
# 应用区(192.168.1.20-23) -> 数据区(192.168.1.31-35)
iptables -A FORWARD -s 192.168.1.20/24 -d 192.168.1.31 -p tcp --dport 5432 -j ACCEPT
iptables -A FORWARD -s 192.168.1.20/24 -d 192.168.1.32 -p tcp --dport 9000 -j ACCEPT
iptables -A FORWARD -s 192.168.1.20/24 -d 192.168.1.33 -p tcp --dport 6379 -j ACCEPT
iptables -A FORWARD -s 192.168.1.20/24 -d 192.168.1.34 -p tcp --dport 5672 -j ACCEPT
iptables -A FORWARD -s 192.168.1.20/24 -d 192.168.1.35 -p tcp --dport 9200 -j ACCEPT
iptables -A FORWARD -s 192.168.1.20/24 -d 192.168.1.30/24 -j DROP
```

### 7.2 服务安全

| 措施 | 说明 |
|------|------|
| TLS加密 | 内部服务间通信启用TLS 1.3 |
| 数据库访问 | PostgreSQL仅允许应用服务器IP连接 |
| MinIO访问 | 关闭公网访问，仅内网可达 |
| Redis认证 | 启用requirepass认证 |
| API认证 | JWT令牌 + HTTPS |
| 文件权限 | 影像文件只读挂载给AI服务 |
| 日志脱敏 | 日志中禁止记录文件路径、凭证 |
| 数据分类分级 | 按分辨率/区域对影像数据分级标记，不同级别差异化访问控制 |
| 国密算法 | 密码存储使用SM3，敏感字段加密使用SM4（信创环境） |

### 7.3 安全审计

```bash
# 定期安全扫描
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy image --severity HIGH,CRITICAL zkxg-backend:latest

# 依赖漏洞扫描
cd backend && mvn org.owasp:dependency-check-maven:check
```

---

## 八、日常运维

### 8.1 常用运维命令

```bash
# 查看服务状态
docker-compose ps
docker-compose logs -f --tail=100 backend
docker-compose logs -f --tail=100 imaging-worker

# 重启服务
docker-compose restart backend
docker-compose restart imaging-worker

# 扩容Celery Worker
docker-compose up -d --scale imaging-worker=8

# 数据库维护
docker-compose exec postgres vacuumdb -U zkxg -z
docker-compose exec postgres reindexdb -U zkxg

# 清理Docker资源
docker system prune -af --volumes

# GPU状态
nvidia-smi
watch -n 1 nvidia-smi
```

### 8.2 日志管理

```bash
# 应用日志位置
# Spring Boot:  docker logs zkxg-backend
# FastAPI:      docker logs zkxg-imaging
# Celery:       docker logs zkxg-imaging-worker
# AI:           docker logs zkxg-ai

# 日志清理策略（docker-compose.yml已配置）
# 单个日志文件最大100MB，最多5个文件

# 集中式日志查询（Loki）
curl "http://192.168.1.23:3100/loki/api/v1/query_range" \
  --data-urlencode 'query={app="zkxg-backend"} |= "ERROR"' \
  --data-urlencode "start=$(date -d '1 hour ago' +%s)000000000" \
  --data-urlencode "end=$(date +%s)000000000"
```

### 8.3 性能调优

#### PostgreSQL 调优

```sql
-- postgresql.conf 关键参数
shared_buffers = 16GB
effective_cache_size = 48GB
work_mem = 256MB
maintenance_work_mem = 2GB
max_connections = 200
checkpoint_completion_target = 0.9
wal_buffers = 16MB
default_statistics_target = 100
random_page_cost = 1.1  -- SSD
effective_io_concurrency = 200  -- SSD
```

#### Elasticsearch 调优

```yaml
# elasticsearch.yml
indices.memory.index_buffer_size: 30%
thread_pool.search.size: 16
thread_pool.search.queue_size: 2000
```

#### Redis 调优

```bash
# redis.conf
maxmemory 8gb
maxmemory-policy allkeys-lru
save 900 1
save 300 10
save 60 10000
```

---

## 九、故障处理

### 9.1 常见故障与处理

| 故障现象 | 可能原因 | 处理方式 |
|----------|----------|----------|
| API响应慢 | 数据库慢查询 | 检查pg_stat_activity，优化查询/索引 |
| 影像上传失败 | MinIO磁盘满 | 检查磁盘空间，清理或扩容 |
| 瓦片加载空白 | MapProxy缓存异常 | 清理缓存目录，重建瓦片 |
| AI推理超时 | GPU显存不足 | 减小batch_size，重启AI服务 |
| Celery任务积压 | Worker不足 | 扩容Worker数量 |
| ES检索慢 | 索引碎片化 | 执行_force_merge，调整分片数 |
| 服务OOM | 内存泄漏/不足 | 增加内存限制，排查内存泄漏 |

### 9.2 应急预案

```bash
# 数据库故障恢复
docker-compose stop backend
docker-compose exec postgres pg_resetwal -f /var/lib/postgresql/data
docker-compose start postgres
docker-compose start backend

# 全服务重启
docker-compose down
docker-compose up -d

# 紧急回滚
docker-compose down
git checkout <stable-tag>
docker-compose build
docker-compose up -d
```

---

## 十、容量规划

### 10.1 存储容量规划

| 数据类型 | 年增长量 | 3年总量 | 存储方案 |
|----------|----------|---------|----------|
| 原始影像 | 20TB | 60TB+ | MinIO + NFS |
| 影像瓦片 | 10TB | 30TB+ | NFS + MapProxy缓存 + COG按需切图 |
| 元数据 | 10GB | 30GB | PostgreSQL |
| AI模型 | 50GB | 150GB | NFS |
| 日志 | 100GB | 300GB | Elasticsearch + 归档 |

### 10.2 计算资源规划

| 服务 | 当前配置 | 扩容触发条件 | 扩容方案 |
|------|----------|-------------|----------|
| API网关 | 8C/16G × 1 | CPU > 70% | 水平扩展至2-3实例 |
| 影像处理 | 16C/32G × 1 | 队列积压 > 500 | Worker扩至8 |
| AI推理 | 32C/64G + A100×2 | GPU > 90% | 增加GPU服务器 |
| PostgreSQL | 16C/64G | 慢查询增多 | 读写分离 + 从库 |

---

## 十一、版本发布

### 11.1 发布流程

```mermaid
graph LR
    A[开发完成] --> B[代码审查]
    B --> C[自动化测试]
    C --> D{测试通过?}
    D -->|否| A
    D -->|是| E[预发布环境验证]
    E --> F{验证通过?}
    F -->|否| A
    F -->|是| G[生产部署]
    G --> H[冒烟测试]
    H --> I{测试通过?}
    I -->|否| J[紧急回滚]
    I -->|是| K[发布完成]
    J --> A

    style A fill:#E3F2FD,stroke:#1565C0
    style B fill:#E3F2FD,stroke:#1565C0
    style C fill:#E3F2FD,stroke:#1565C0
    style D fill:#FFF3E0,stroke:#E65100
    style E fill:#E8F5E9,stroke:#2E7D32
    style F fill:#FFF3E0,stroke:#E65100
    style G fill:#E8F5E9,stroke:#2E7D32
    style H fill:#E8F5E9,stroke:#2E7D32
    style I fill:#FFF3E0,stroke:#E65100
    style J fill:#FFEBEE,stroke:#C62828
    style K fill:#E8F5E9,stroke:#2E7D32
```

### 11.2 版本号规范

```
主版本号.次版本号.修订号

v1.0.0 - 首次发布
v1.1.0 - 新增AI分析功能
v1.1.1 - 修复检索性能问题
v2.0.0 - 架构重大升级
```

### 11.3 发布检查清单

- [ ] 所有单元测试通过
- [ ] 集成测试通过
- [ ] 安全扫描无高危漏洞
- [ ] 数据库迁移脚本验证
- [ ] 配置文件更新确认
- [ ] 回滚方案准备
- [ ] 发布通知已发送
- [ ] 监控告警已配置
