Files
AItst/AIMonitor/bt_deployment_guide.md
2026-02-08 14:33:45 +08:00

687 lines
16 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# AI监控系统 - BT离线部署指南
## 📋 概述
本指南介绍如何使用BitTorrentBT技术在无网络环境中部署AI监控系统到昇腾服务器包括种子制作、P2P传输和离线安装。
## 🔧 BT部署原理
### 工作流程
```
有网络环境 → 制作种子 → 分发种子 → P2P下载 → 离线安装
```
### 优势
- **高速传输**:多节点并行下载
- **带宽节省**P2P共享减少服务器压力
- **断点续传**:网络中断后可继续传输
- **完整性校验**:自动验证文件完整性
## 🌱 制作BT种子
### 1. 准备完整部署包
```bash
#!/bin/bash
# create_deployment_package.sh
echo "=== 制作AI监控系统部署包 ==="
# 创建部署目录结构
DEPLOY_DIR="AIMonitor_deploy_v1.0"
mkdir -p $DEPLOY_DIR/{packages,drivers,models,configs,scripts}
# 1. 复制项目文件
echo "1. 复制项目文件..."
cp -r *.py *.yaml *.md $DEPLOY_DIR/
cp -r requirements.txt $DEPLOY_DIR/
# 2. 下载Python依赖包
echo "2. 下载Python依赖包..."
pip download -r requirements.txt -d $DEPLOY_DIR/packages/ \
--platform linux_x86_64 --only-binary=:all:
# 3. 下载昇腾驱动和工具包
echo "3. 下载昇腾相关包..."
cd $DEPLOY_DIR/drivers/
# Atlas 300I驱动
wget https://ascend-repo.huawei.com/Atlas%20200I%20DK/Ascend-hdk-23.0.0-ubuntu20.04.aarch64.run
# CANN工具包
wget https://ascend-repo.huawei.com/CANN/CANN%205.0.2/Ascend-cann-toolkit_5.0.2_linux-aarch64.run
# 4. 准备模型文件
echo "4. 准备AI模型..."
cp -r YOLO_Weight/ $DEPLOY_DIR/models/
# 5. 创建配置文件模板
echo "5. 创建配置模板..."
cat > $DEPLOY_DIR/configs/config_template.yaml << EOF
cameras:
- id: 1
name: "摄像头1"
rtsp_url: "rtsp://admin:password@192.168.1.100:554/stream1"
- id: 2
name: "摄像头2"
rtsp_url: "rtsp://admin:password@192.168.1.101:554/stream1"
EOF
# 6. 创建安装脚本
echo "6. 创建安装脚本..."
cat > $DEPLOY_DIR/scripts/install.sh << 'EOF'
#!/bin/bash
echo "=== AI监控系统安装 ==="
# 安装系统依赖
sudo rpm -ivh packages/*.rpm 2>/dev/null || sudo dpkg -i packages/*.deb
# 安装Python依赖
python3 -m pip install packages/*.whl --no-index --find-links=packages/
# 安装昇腾驱动
sudo bash drivers/Ascend-hdk-*.run --silent
# 安装CANN工具包
sudo bash drivers/Ascend-cann-toolkit-*.run --silent
# 配置环境
echo "source /usr/local/Ascend/ascend-toolkit/set_env.sh" >> ~/.bashrc
echo "安装完成!"
EOF
chmod +x $DEPLOY_DIR/scripts/install.sh
# 7. 创建启动脚本
cat > $DEPLOY_DIR/scripts/start.sh << 'EOF'
#!/bin/bash
cd /opt/AIMonitor
source ~/.bashrc
python3 rtsp_service_ws.py &
python3 static_server.py &
EOF
chmod +x $DEPLOY_DIR/scripts/start.sh
# 8. 创建说明文档
cat > $DEPLOY_DIR/README.txt << EOF
AI监控系统离线部署包 v1.0
安装步骤:
1. 运行 sudo ./scripts/install.sh
2. 配置 configs/config.yaml
3. 运行 ./scripts/start.sh
技术支持:请参考 deploy_升腾.md
EOF
# 9. 压缩部署包
echo "7. 压缩部署包..."
tar -czf AIMonitor_deploy_v1.0.tar.gz $DEPLOY_DIR/
echo "✓ 部署包制作完成: AIMonitor_deploy_v1.0.tar.gz"
```
### 2. 制作BT种子
```bash
#!/bin/bash
# create_torrent.sh
echo "=== 制作BT种子 ==="
# 安装BT制作工具
pip install transmission-rpc
# 创建种子文件
transmission-create -o AIMonitor_deploy_v1.0.torrent \
-t "https://tracker1.example.com:6969/announce" \
-t "https://tracker2.example.com:6969/announce" \
-c "AI监控系统离线部署包 v1.0 - 昇腾服务器专用" \
AIMonitor_deploy_v1.0.tar.gz
# 创建带校验和的种子
transmission-show -i AIMonitor_deploy_v1.0.torrent
echo "✓ BT种子创建完成: AIMonitor_deploy_v1.0.torrent"
```
### 3. 创建私有Tracker
```bash
#!/bin/bash
# setup_tracker.sh
echo "=== 搭建私有BT Tracker ==="
# 使用opentracker作为tracker服务器
docker run -d \
--name bt-tracker \
-p 6969:6969 \
-v $(pwd)/tracker.conf:/etc/opentracker/tracker.conf \
--restart unless-stopped \
prologic/opentracker
# 创建tracker配置
cat > tracker.conf << EOF
listen.ipv4_addr = 0.0.0.0
listen.port = 6969
daemon = 0
access.log = access.log
error.log = error.log
debug.log = debug.log
EOF
echo "✓ Private Tracker started on port 6969"
```
## 🚀 P2P部署方案
### 方案一服务器间P2P传输
#### 1. 在有网络的服务器上
```bash
#!/bin/bash
# seed_deployment.sh
echo "=== 启动种子分享 ==="
# 1. 创建完整部署包
./create_deployment_package.sh
# 2. 制作BT种子
./create_torrent.sh
# 3. 启动Transmission作为种子服务器
transmission-daemon
transmission-remote -a AIMonitor_deploy_v1.0.torrent \
-w ./ \
--find
echo "✓ 开始分享AI监控系统部署包"
echo "Torrent Info:"
transmission-show -i AIMonitor_deploy_v1.0.torrent
```
#### 2. 在目标昇腾服务器上
```bash
#!/bin/bash
# download_deployment.sh
echo "=== 下载AI监控系统部署包 ==="
# 1. 安装下载工具
pip install transmission-cli
# 2. 从种子文件下载
transmission-cli -f AIMonitor_deploy_v1.0.torrent \
-w /tmp/ \
--seedlimit 0
# 3. 校验文件完整性
echo "校验下载文件..."
if [ -f "/tmp/AIMonitor_deploy_v1.0.tar.gz" ]; then
echo "✓ 文件下载完成"
# 4. 解压并安装
cd /tmp
tar -xzf AIMonitor_deploy_v1.0.tar.gz
cd AIMonitor_deploy_v1.0
# 5. 运行安装脚本
sudo ./scripts/install.sh
echo "✓ AI监控系统安装完成"
else
echo "✗ 文件下载失败"
fi
```
### 方案二:多节点分布式部署
#### 1. 主节点(有网络)
```bash
#!/bin/bash
# master_node.sh
echo "=== 主节点配置 ==="
# 1. 启动Tracker服务
docker-compose up -d
# 2. 创建多个种子版本
python3 create_multi_version_torrents.py
# 3. 启动种子服务
transmission-daemon
# 添加所有种子
for torrent in *.torrent; do
transmission-remote -a "$torrent" -w ./
done
echo "✓ 主节点启动完成"
```
#### 2. 从节点(无网络)
```bash
#!/bin/bash
# slave_node.sh
echo "=== 从节点部署 ==="
# 1. 连接到主节点Tracker
TRACKER_URL="http://master-server:6969/announce"
# 2. 下载种子文件
curl -O http://master-server:torrents/AIMonitor_deploy_v1.0.torrent
# 3. 多线程下载
transmission-cli \
-f AIMonitor_deploy_v1.0.torrent \
-w /tmp/ \
--peer-info \
--encryption-preferred
# 4. 验证并安装
if [ -f "/tmp/AIMonitor_deploy_v1.0.tar.gz" ]; then
cd /tmp && tar -xzf AIMonitor_deploy_v1.0.tar.gz
cd AIMonitor_deploy_v1.0
sudo ./scripts/install.sh
else
echo "下载失败,请检查网络连接"
fi
```
## 🛠️ BT部署工具
### 1. 自动化部署脚本
```python
#!/usr/bin/env python3
# bt_deployment_tool.py
import os
import sys
import hashlib
import subprocess
from pathlib import Path
class BTDeploymentTool:
def __init__(self):
self.deployment_dir = "AIMonitor_bt_deploy"
self.torrent_file = None
def create_deployment_package(self):
"""创建部署包"""
print("创建部署包...")
# 创建目录结构
Path(self.deployment_dir).mkdir(exist_ok=True)
Path(f"{self.deployment_dir}/packages").mkdir(exist_ok=True)
Path(f"{self.deployment_dir}/scripts").mkdir(exist_ok=True)
# 复制必要文件
essential_files = [
"rtsp_service_ws.py", "static_server.py", "monitor_gui.py",
"npu_yolo_onnx.py", "config.yaml", "requirements.txt"
]
for file in essential_files:
if os.path.exists(file):
os.system(f"cp {file} {self.deployment_dir}/")
print(f"✓ 部署包创建完成: {self.deployment_dir}")
def create_torrent(self, tracker_urls=None):
"""创建BT种子"""
print("创建BT种子...")
tracker_urls = tracker_urls or [
"https://tracker1.example.com:6969/announce",
"https://tracker2.example.com:6969/announce"
]
# 使用libtorrent创建种子
import libtorrent as lt
# 创建torrent
fs = lt.file_storage()
lt.add_files(fs, self.deployment_dir)
t = lt.create_torrent(fs)
t.add_tracker(tracker_urls[0])
t.set_creator("AI监控系统部署工具")
t.set_comment("昇腾AI监控系统离线部署包")
# 生成torrent文件
self.torrent_file = f"{self.deployment_dir}.torrent"
with open(self.torrent_file, 'wb') as f:
f.write(lt.bencode(t.generate()))
print(f"✓ BT种子创建完成: {self.torrent_file}")
return self.torrent_file
def calculate_checksum(self, file_path):
"""计算文件校验和"""
sha256_hash = hashlib.sha256()
with open(file_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
sha256_hash.update(chunk)
return sha256_hash.hexdigest()
def deploy_from_torrent(self, torrent_path, download_dir="/tmp"):
"""从种子部署"""
print(f"从种子部署: {torrent_path}")
# 使用transmission下载
cmd = [
"transmission-cli", "-f", torrent_path,
"-w", download_dir, "--seedlimit", "0"
]
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode == 0:
# 验证下载文件
expected_file = os.path.join(download_dir, self.deployment_dir + ".tar.gz")
if os.path.exists(expected_file):
print("✓ 下载完成,开始安装...")
# 解压并安装
os.chdir(download_dir)
os.system(f"tar -xzf {os.path.basename(expected_file)}")
install_script = os.path.join(self.deployment_dir, "scripts", "install.sh")
if os.path.exists(install_script):
os.system(f"sudo {install_script}")
print("✓ 部署完成")
else:
print("✗ 安装脚本不存在")
else:
print("✗ 下载文件不完整")
else:
print(f"✗ 下载失败: {result.stderr}")
def main():
tool = BTDeploymentTool()
if len(sys.argv) < 2:
print("使用方法:")
print(" python3 bt_deployment_tool.py create # 创建部署包")
print(" python3 bt_deployment_tool.py deploy # 从种子部署")
return
command = sys.argv[1]
if command == "create":
tool.create_deployment_package()
torrent_file = tool.create_torrent()
print(f"\n种子文件: {torrent_file}")
elif command == "deploy":
if len(sys.argv) < 3:
print("请提供种子文件路径")
return
tool.deploy_from_torrent(sys.argv[2])
else:
print(f"未知命令: {command}")
if __name__ == "__main__":
main()
```
### 2. Docker容器化BT部署
```dockerfile
# Dockerfile
FROM ubuntu:20.04
RUN apt-get update && apt-get install -y \
python3-pip \
transmission-cli \
curl \
tar \
&& rm -rf /var/lib/apt/lists/*
RUN pip3 install transmission-rpc libtorrent
WORKDIR /app
COPY . /app/
CMD ["python3", "bt_deployment_tool.py"]
```
```yaml
# docker-compose.yml
version: '3.8'
services:
bt-tracker:
image: prologic/opentracker
ports:
- "6969:6969"
volumes:
- ./tracker.conf:/etc/opentracker/tracker.conf
bt-seeder:
build: .
volumes:
- ./deployment:/app/deployment
command: ["python3", "bt_deployment_tool.py", "create"]
depends_on:
- bt-tracker
bt-downloader:
build: .
volumes:
- ./downloads:/app/downloads
command: ["python3", "bt_deployment_tool.py", "deploy", "/torrents/AIMonitor_deploy_v1.0.torrent"]
depends_on:
- bt-tracker
```
## 🔐 安全配置
### 1. 加密传输
```bash
# 启用加密传输
transmission-cli \
--encryption-preferred \
--encryption-required \
-f deployment.torrent
```
### 2. 访问控制
```python
# tracker访问控制
ALLOWED_PEERS = [
"192.168.1.0/24",
"10.0.0.0/8",
"172.16.0.0/12"
]
def is_peer_allowed(peer_ip):
"""检查对等节点是否被允许"""
import ipaddress
peer_addr = ipaddress.ip_address(peer_ip)
for network in ALLOWED_PEERS:
if peer_addr in ipaddress.ip_network(network):
return True
return False
```
### 3. 完整性验证
```bash
#!/bin/bash
# verify_deployment.sh
TORRENT_FILE=$1
DEPLOYMENT_FILE=$2
echo "验证部署包完整性..."
# 1. 验证torrent信息
transmission-show -i $TORRENT_FILE > torrent_info.txt
# 2. 计算实际文件校验和
ACTUAL_HASH=$(sha256sum $DEPLOYMENT_FILE | cut -d' ' -f1)
# 3. 验证文件大小
EXPECTED_SIZE=$(grep "Size:" torrent_info.txt | awk '{print $2}')
ACTUAL_SIZE=$(stat -c%s $DEPLOYMENT_FILE)
if [ "$EXPECTED_SIZE" = "$ACTUAL_SIZE" ]; then
echo "✓ 文件大小正确"
else
echo "✗ 文件大小不匹配"
exit 1
fi
echo "✓ 部署包验证通过"
```
## 📊 监控和管理
### 1. BT传输监控
```python
#!/usr/bin/env python3
# bt_monitor.py
import time
import transmission_rpc
from datetime import datetime
class BTMonitor:
def __init__(self, host='localhost', port=9091):
self.tc = transmission_rpc.Client(host=host, port=port)
def monitor_download(self, torrent_hash):
"""监控下载进度"""
while True:
try:
torrent = self.tc.get_torrent(torrent_hash)
progress = torrent.progress
status = torrent.status
print(f"[{datetime.now()}] 进度: {progress:.2f}%, 状态: {status}")
if status == 'seeding':
print("下载完成")
break
except Exception as e:
print(f"监控错误: {e}")
time.sleep(10)
def list_active_torrents(self):
"""列出活跃的种子"""
torrents = self.tc.get_torrents()
for torrent in torrents:
print(f"{torrent.name}: {torrent.progress:.2f}%")
if __name__ == "__main__":
monitor = BTMonitor()
monitor.list_active_torrents()
```
### 2. 自动重试机制
```bash
#!/bin/bash
# auto_retry_download.sh
TORRENT_FILE=$1
MAX_RETRIES=5
RETRY_DELAY=60
for ((i=1; i<=MAX_RETRIES; i++)); do
echo "尝试下载 (第 $i 次)..."
if transmission-cli -f $TORRENT_FILE -w /tmp/ --seedlimit 0; then
echo "✓ 下载成功"
exit 0
else
echo "✗ 下载失败,${RETRY_DELAY}秒后重试..."
sleep $RETRY_DELAY
fi
done
echo "✗ 达到最大重试次数,下载失败"
exit 1
```
## 🎯 部署流程
### 完整部署步骤
#### 1. 准备阶段(有网络环境)
```bash
# 1. 创建部署包
./create_deployment_package.sh
# 2. 制作BT种子
./create_torrent.sh
# 3. 启动种子服务
./seed_deployment.sh
```
#### 2. 传输阶段P2P
```bash
# 1. 分发种子文件
scp AIMonitor_deploy_v1.0.torrent user@target-server:/tmp/
# 2. 在目标服务器下载
./download_deployment.sh
```
#### 3. 安装阶段(离线环境)
```bash
# 1. 解压部署包
tar -xzf AIMonitor_deploy_v1.0.tar.gz
# 2. 运行安装脚本
sudo ./scripts/install.sh
# 3. 配置系统
./scripts/configure.sh
# 4. 启动服务
./scripts/start.sh
```
### 验证部署结果
```bash
# 1. 检查服务状态
systemctl status aimonitor
# 2. 验证端口监听
netstat -tulpn | grep -E "(8765|5000)"
# 3. 测试NPU功能
npu-smi
# 4. 启动GUI界面
python3 monitor_gui.py
```
---
**文档版本**: v1.0
**适用平台**: 昇腾Atlas系列服务器
**网络要求**: 支持P2P传输的内网环境