# network-automation-platform

**Repository Path**: code_xiaohui/network-automation-platform

## Basic Information

- **Project Name**: network-automation-platform
- **Description**: 基于 Ansible 的网络自动化运维平台
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-12-02
- **Last Updated**: 2026-01-06

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 网络自动化运维平台

基于 Ansible 的网络自动化运维平台，提供可视化的网络设备管理、配置备份、任务调度等功能。

## 📋 目录

- [功能特性](#功能特性)
- [技术架构](#技术架构)
- [环境要求](#环境要求)
- [快速开始](#快速开始)
- [详细部署](#详细部署)
- [项目结构](#项目结构)
- [API文档](#api文档)
- [使用指南](#使用指南)
- [常见问题](#常见问题)

---

## 🚀 功能特性

### 设备管理 (Inventory)
- ✅ 可视化管理网络设备清单
- ✅ 支持按机房、设备类型分组
- ✅ 设备连接状态检测
- ✅ 多厂商支持（Cisco、华为、H3C、Juniper、Arista）

### 运维操作
- ✅ 配置备份与恢复
- ✅ 接口启停控制
- ✅ VLAN 配置管理
- ✅ 命令批量执行
- ✅ 自定义 Playbook 执行

### 任务调度
- ✅ 定时任务配置（每天/每周/每月/Cron）
- ✅ 任务执行历史记录
- ✅ 执行结果日志查看

### 权限控制
- ✅ 多用户登录认证
- ✅ 角色权限控制（管理员/操作员/查看者）
- ✅ 操作审计日志

---

## 🏗️ 技术架构

```
┌─────────────────────────────────────────────────────────────┐
│                        前端 (Vue 3)                          │
│         Element Plus + Axios + Vue Router + Pinia           │
└─────────────────────────────────────────────────────────────┘
                              │
                              │ HTTP/REST API
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                      后端 (FastAPI)                          │
│              Python 3.11 + SQLAlchemy + JWT                 │
└─────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
        ┌──────────┐   ┌──────────┐   ┌──────────────┐
        │  MySQL   │   │  Redis   │   │   Ansible    │
        │ 数据存储  │   │ 缓存/队列 │   │ 自动化引擎   │
        └──────────┘   └──────────┘   └──────────────┘
                                             │
                                             ▼
                              ┌─────────────────────────┐
                              │      网络设备           │
                              │ Cisco/华为/H3C/Juniper  │
                              └─────────────────────────┘
```

---

## 💻 环境要求

### 基础环境
| 组件 | 版本要求 | 说明 |
|------|---------|------|
| Python | >= 3.10 | 后端运行环境 |
| Node.js | >= 18.0 | 前端构建环境 |
| MySQL | >= 8.0 | 数据库 |
| Redis | >= 6.0 | 缓存与消息队列 |

### Docker 部署（推荐）
| 组件 | 版本要求 |
|------|---------|
| Docker | >= 20.10 |
| Docker Compose | >= 2.0 |

---

## ⚡ 快速开始

### 方式一：Docker Compose 一键部署（推荐）

```bash
# 1. 克隆项目
git clone https://github.com/your-repo/network-automation-platform.git
cd network-automation-platform

# 2. 配置环境变量
cp .env.example .env
# 编辑 .env 文件，修改数据库密码等配置

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

# 4. 查看服务状态
docker-compose ps

# 5. 初始化数据库（首次运行）
docker-compose exec backend python init_db.py

# 6. 访问应用
# 前端界面: http://localhost
# API文档:  http://localhost:8000/docs
# 默认账号: admin / admin123
```

### 方式二：本地开发环境

```bash
# 1. 克隆项目
git clone https://github.com/your-repo/network-automation-platform.git
cd network-automation-platform

# 2. 启动数据库服务（使用 Docker）
docker run -d --name mysql \
  -e MYSQL_ROOT_PASSWORD=rootpassword \
  -e MYSQL_DATABASE=network_automation \
  -p 3306:3306 \
  mysql:8.0

docker run -d --name redis \
  -p 6379:6379 \
  redis:7-alpine

# 3. 启动后端
cd backend
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt
python init_db.py  # 初始化数据库
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

# 4. 启动前端（新开终端）
cd frontend
npm install
npm run dev

# 5. 访问应用
# 前端界面: http://localhost:3000
# API文档:  http://localhost:8000/docs
```

---

## 📦 详细部署

### 1. 环境准备

#### 1.1 创建项目目录
```bash
mkdir -p /opt/network-automation
cd /opt/network-automation
```

#### 1.2 创建环境配置文件
```bash
cat > .env << 'EOF'
# 应用配置
APP_NAME=网络自动化运维平台
DEBUG=false

# 数据库配置
MYSQL_ROOT_PASSWORD=your_root_password
MYSQL_DATABASE=network_automation
MYSQL_USER=netauto
MYSQL_PASSWORD=your_db_password
DATABASE_URL=mysql+pymysql://netauto:your_db_password@mysql:3306/network_automation

# Redis配置
REDIS_URL=redis://redis:6379/0

# JWT配置
SECRET_KEY=your-super-secret-key-change-this-in-production
ACCESS_TOKEN_EXPIRE_MINUTES=1440

# Ansible配置
ANSIBLE_HOST_KEY_CHECKING=False
EOF
```

### 2. 后端部署

#### 2.1 创建后端目录结构
```bash
mkdir -p backend/{app,ansible,logs}
mkdir -p backend/ansible/{inventory,playbooks,roles}
```

#### 2.2 安装 Python 依赖

创建 `backend/requirements.txt`:
```txt
fastapi==0.104.1
uvicorn[standard]==0.24.0
sqlalchemy==2.0.23
alembic==1.12.1
pymysql==1.1.0
cryptography==41.0.7
python-jose[cryptography]==3.3.0
passlib[bcrypt]==1.7.4
python-multipart==0.0.6
pydantic==2.5.0
pydantic-settings==2.1.0
ansible-runner==2.3.4
apscheduler==3.10.4
redis==5.0.1
aiofiles==23.2.1
httpx==0.25.2
```

```bash
cd backend
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```

#### 2.3 安装 Ansible Collections
```bash
ansible-galaxy collection install cisco.ios
ansible-galaxy collection install cisco.nxos
ansible-galaxy collection install arista.eos
ansible-galaxy collection install junipernetworks.junos
ansible-galaxy collection install community.network
```

#### 2.4 创建数据库初始化脚本

创建 `backend/init_db.py`:
```python
#!/usr/bin/env python3
"""数据库初始化脚本"""
import sys
sys.path.insert(0, '.')

from app.database import engine, Base, SessionLocal
from app.models.user import User, UserRole
from app.models.device import DataCenter, DeviceGroup, Device
from app.models.task import Task, TaskExecution
from app.models.log import ExecutionLog, ConfigBackup
from app.core.security import get_password_hash

def init_database():
    """初始化数据库表"""
    print("正在创建数据库表...")
    Base.metadata.create_all(bind=engine)
    print("数据库表创建完成！")

def create_admin_user():
    """创建管理员账号"""
    db = SessionLocal()
    try:
        # 检查是否已存在管理员
        admin = db.query(User).filter(User.username == "admin").first()
        if admin:
            print("管理员账号已存在，跳过创建")
            return
        
        # 创建管理员
        admin = User(
            username="admin",
            email="admin@example.com",
            hashed_password=get_password_hash("admin123"),
            role=UserRole.ADMIN,
            is_active=True
        )
        db.add(admin)
        db.commit()
        print("管理员账号创建成功！")
        print("  用户名: admin")
        print("  密码: admin123")
        print("  请登录后立即修改密码！")
    finally:
        db.close()

def create_sample_data():
    """创建示例数据"""
    db = SessionLocal()
    try:
        # 创建示例机房
        if not db.query(DataCenter).first():
            data_centers = [
                DataCenter(name="北京机房", location="北京市朝阳区", description="主要生产机房"),
                DataCenter(name="上海机房", location="上海市浦东新区", description="灾备机房"),
            ]
            db.add_all(data_centers)
            db.commit()
            print("示例机房数据创建完成！")
        
        # 创建示例设备分组
        if not db.query(DeviceGroup).first():
            groups = [
                DeviceGroup(name="核心层", description="核心交换机"),
                DeviceGroup(name="汇聚层", description="汇聚交换机"),
                DeviceGroup(name="接入层", description="接入交换机"),
            ]
            db.add_all(groups)
            db.commit()
            print("示例设备分组创建完成！")
    finally:
        db.close()

if __name__ == "__main__":
    print("=" * 50)
    print("Mini NetDevOps 中台 - 数据库初始化")
    print("=" * 50)
    
    init_database()
    create_admin_user()
    create_sample_data()
    
    print("=" * 50)
    print("初始化完成！")
    print("=" * 50)
```

```bash
python init_db.py
```

### 3. 前端部署

#### 3.1 安装依赖并构建
```bash
cd frontend
npm install
npm run build
```

#### 3.2 Nginx 配置

创建 `frontend/nginx.conf`:
```nginx
server {
    listen 80;
    server_name localhost;
    
    root /usr/share/nginx/html;
    index index.html;
    
    # Gzip 压缩
    gzip on;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml;
    gzip_min_length 1000;
    
    # 前端路由
    location / {
        try_files $uri $uri/ /index.html;
    }
    
    # API 代理
    location /api {
        proxy_pass http://backend:8000;
        proxy_http_version 1.1;
        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 300s;
    }
    
    # 静态资源缓存
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }
}
```

### 4. Docker 部署

#### 4.1 后端 Dockerfile

创建 `backend/Dockerfile`:
```dockerfile
FROM python:3.11-slim

WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    libffi-dev \
    libssl-dev \
    sshpass \
    openssh-client \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件
COPY requirements.txt .

# 安装 Python 依赖
RUN pip install --no-cache-dir -r requirements.txt

# 安装 Ansible Collections
RUN ansible-galaxy collection install \
    cisco.ios \
    cisco.nxos \
    arista.eos \
    junipernetworks.junos \
    community.network

# 复制应用代码
COPY . .

# 创建必要目录
RUN mkdir -p ansible/inventory ansible/playbooks ansible/backups logs

# 设置环境变量
ENV PYTHONUNBUFFERED=1
ENV ANSIBLE_HOST_KEY_CHECKING=False

EXPOSE 8000

# 启动命令
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
```

#### 4.2 前端 Dockerfile

创建 `frontend/Dockerfile`:
```dockerfile
# 构建阶段
FROM node:18-alpine as builder

WORKDIR /app

# 复制 package 文件
COPY package*.json ./

# 安装依赖
RUN npm ci --registry=https://registry.npmmirror.com

# 复制源代码
COPY . .

# 构建
RUN npm run build

# 生产阶段
FROM nginx:alpine

# 复制构建产物
COPY --from=builder /app/dist /usr/share/nginx/html

# 复制 Nginx 配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]
```

#### 4.3 Docker Compose 配置

创建 `docker-compose.yml`:
```yaml
version: '3.8'

services:
  # MySQL 数据库
  mysql:
    image: mysql:8.0
    container_name: netauto-mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-rootpassword}
      MYSQL_DATABASE: ${MYSQL_DATABASE:-network_automation}
      MYSQL_USER: ${MYSQL_USER:-netauto}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-netautopassword}
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
      - ./mysql/init:/docker-entrypoint-initdb.d
    command: --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - netauto

  # Redis
  redis:
    image: redis:7-alpine
    container_name: netauto-redis
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - netauto

  # 后端服务
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    container_name: netauto-backend
    restart: always
    environment:
      - DATABASE_URL=mysql+pymysql://${MYSQL_USER:-netauto}:${MYSQL_PASSWORD:-netautopassword}@mysql:3306/${MYSQL_DATABASE:-network_automation}
      - REDIS_URL=redis://redis:6379/0
      - SECRET_KEY=${SECRET_KEY:-your-secret-key}
      - DEBUG=${DEBUG:-false}
    ports:
      - "8000:8000"
    volumes:
      - ./backend/ansible:/app/ansible
      - ./backend/logs:/app/logs
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    networks:
      - netauto

  # 前端服务
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    container_name: netauto-frontend
    restart: always
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - netauto

volumes:
  mysql_data:
    driver: local
  redis_data:
    driver: local

networks:
  netauto:
    driver: bridge
```

#### 4.4 启动服务
```bash
# 构建并启动
docker-compose up -d --build

# 查看日志
docker-compose logs -f

# 初始化数据库
docker-compose exec backend python init_db.py

# 查看服务状态
docker-compose ps

# 停止服务
docker-compose down

# 停止并删除数据
docker-compose down -v
```

---

## 📁 项目结构

```
network-automation-platform/
├── backend/                          # 后端服务
│   ├── app/
│   │   ├── __init__.py
│   │   ├── main.py                   # FastAPI 应用入口
│   │   ├── config.py                 # 配置文件
│   │   ├── database.py               # 数据库连接
│   │   ├── models/                   # 数据模型
│   │   │   ├── user.py               # 用户模型
│   │   │   ├── device.py             # 设备模型
│   │   │   ├── task.py               # 任务模型
│   │   │   └── log.py                # 日志模型
│   │   ├── schemas/                  # Pydantic 模式
│   │   │   ├── user.py
│   │   │   ├── device.py
│   │   │   └── task.py
│   │   ├── api/                      # API 路由
│   │   │   ├── auth.py               # 认证接口
│   │   │   ├── devices.py            # 设备接口
│   │   │   ├── tasks.py              # 任务接口
│   │   │   ├── ansible_ops.py        # Ansible 操作接口
│   │   │   └── logs.py               # 日志接口
│   │   ├── services/                 # 业务服务
│   │   │   ├── ansible_service.py    # Ansible 服务
│   │   │   └── scheduler_service.py  # 调度服务
│   │   ├── core/                     # 核心模块
│   │   │   ├── security.py           # 安全认证
│   │   │   └── deps.py               # 依赖注入
│   │   └── utils/                    # 工具类
│   ├── ansible/                      # Ansible 相关
│   │   ├── inventory/                # 动态 inventory
│   │   ├── playbooks/                # Playbook 文件
│   │   │   ├── backup_config.yml
│   │   │   ├── interface_toggle.yml
│   │   │   ├── vlan_config.yml
│   │   │   └── show_command.yml
│   │   └── roles/                    # 角色
│   ├── logs/                         # 日志目录
│   ├── requirements.txt              # Python 依赖
│   ├── Dockerfile
│   └── init_db.py                    # 数据库初始化脚本
│
├── frontend/                         # 前端服务
│   ├── src/
│   │   ├── api/                      # API 接口
│   │   ├── components/               # 公共组件
│   │   │   └── Layout/               # 布局组件
│   │   ├── views/                    # 页面
│   │   │   ├── Login.vue
│   │   │   ├── Dashboard.vue
│   │   │   ├── devices/              # 设备管理
│   │   │   ├── tasks/                # 任务管理
│   │   │   ├── operations/           # 运维操作
│   │   │   └── logs/                 # 日志查看
│   │   ├── router/                   # 路由配置
│   │   ├── store/                    # 状态管理
│   │   ├── utils/                    # 工具函数
│   │   ├── App.vue
│   │   └── main.js
│   ├── package.json
│   ├── vite.config.js
│   ├── nginx.conf
│   └── Dockerfile
│
├── mysql/
│   └── init/                         # MySQL 初始化脚本
│       └── 01-schema.sql
│
├── docker-compose.yml
├── .env.example
├── .gitignore
└── README.md
```

---

## 📖 API文档

启动后端服务后，访问以下地址查看 API 文档：

- **Swagger UI**: http://localhost:8000/docs
- **ReDoc**: http://localhost:8000/redoc

### 主要 API 接口

| 模块 | 接口 | 方法 | 说明 |
|------|------|------|------|
| 认证 | `/api/v1/auth/login` | POST | 用户登录 |
| 认证 | `/api/v1/auth/me` | GET | 获取当前用户信息 |
| 设备 | `/api/v1/devices` | GET | 获取设备列表 |
| 设备 | `/api/v1/devices` | POST | 创建设备 |
| 设备 | `/api/v1/devices/{id}` | PUT | 更新设备 |
| 设备 | `/api/v1/devices/{id}/test-connection` | POST | 测试设备连接 |
| 任务 | `/api/v1/tasks` | GET | 获取任务列表 |
| 任务 | `/api/v1/tasks` | POST | 创建任务 |
| 任务 | `/api/v1/tasks/{id}/execute` | POST | 执行任务 |
| 操作 | `/api/v1/ansible/backup-config` | POST | 配置备份 |
| 操作 | `/api/v1/ansible/interface-toggle` | POST | 接口启停 |
| 操作 | `/api/v1/ansible/vlan-config` | POST | VLAN配置 |
| 操作 | `/api/v1/ansible/show-command` | POST | 执行命令 |
| 日志 | `/api/v1/logs/executions` | GET | 获取执行记录 |

---

## 📘 使用指南

### 1. 登录系统

使用默认管理员账号登录：
- 用户名：`admin`
- 密码：`admin123`

> ⚠️ 请在首次登录后立即修改密码！

### 2. 添加设备

1. 进入 **设备管理 > 设备列表**
2. 点击 **添加设备** 按钮
3. 填写设备信息：
   - 主机名
   - IP 地址
   - 设备类型（Cisco IOS/华为/H3C 等）
   - SSH 端口（默认 22）
   - 用户名和密码
   - 所属机房和分组（可选）
4. 点击 **测试连接** 验证配置
5. 保存设备

### 3. 配置备份

1. 进入 **运维操作 > 配置备份**
2. 选择要备份的设备（可多选）
3. 点击 **执行备份**
4. 在备份历史中查看结果

### 4. 创建定时任务

1. 进入 **任务管理 > 创建任务**
2. 填写任务信息：
   - 任务名称
   - 任务类型（配置备份/接口启停/VLAN配置等）
   - 目标设备
   - 任务参数
3. 开启 **定时执行**
4. 配置调度规则（每天/每周/Cron表达式）
5. 保存任务

### 5. 查看执行日志

1. 进入 **执行日志**
2. 可按状态、时间范围筛选
3. 点击 **详情** 查看具体执行结果

---

## 🔐 权限说明

| 角色 | 权限说明 |
|------|---------|
| **admin** (管理员) | 所有权限，包括用户管理、设备增删改、配置下发 |
| **operator** (操作员) | 设备查看、配置备份、命令执行、任务管理 |
| **viewer** (查看者) | 仅查看权限，不能执行任何配置变更操作 |

---

## ❓ 常见问题

### 1. 无法连接数据库

```bash
# 检查 MySQL 容器状态
docker-compose ps mysql

# 查看 MySQL 日志
docker-compose logs mysql

# 验证数据库连接
docker-compose exec mysql mysql -u netauto -p -e "SHOW DATABASES;"
```

### 2. 设备连接失败

检查以下配置：
- 设备 IP 地址是否正确
- SSH 端口是否正确（默认 22）
- 用户名密码是否正确
- 防火墙是否放行 SSH 端口
- 后端服务器是否能访问设备网络

```bash
# 在后端容器中测试连接
docker-compose exec backend ssh admin@192.168.1.1
```

### 3. Ansible 执行失败

```bash
# 查看 Ansible 日志
docker-compose exec backend cat /app/logs/ansible.log

# 手动测试 Ansible
docker-compose exec backend ansible all -i "192.168.1.1," -m ping -u admin -k
```

### 4. 前端无法访问 API

```bash
# 检查后端服务状态
docker-compose ps backend
curl http://localhost:8000/health

# 检查 Nginx 配置
docker-compose exec frontend cat /etc/nginx/conf.d/default.conf
```

### 5. 重置管理员密码

```bash
docker-compose exec backend python << 'EOF'
from app.database import SessionLocal
from app.models.user import User
from app.core.security import get_password_hash

db = SessionLocal()
admin = db.query(User).filter(User.username == "admin").first()
if admin:
    admin.hashed_password = get_password_hash("newpassword123")
    db.commit()
    print("密码已重置为: newpassword123")
db.close()
EOF
```

---

## 🔧 开发指南

### 本地开发

```bash
# 后端热重载
cd backend
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

# 前端热重载
cd frontend
npm run dev
```

### 代码规范

```bash
# Python 代码格式化
pip install black isort
black app/
isort app/

# 前端代码检查
npm run lint
```

### 运行测试

```bash
# 后端测试
cd backend
pip install pytest pytest-asyncio httpx
pytest tests/

# 前端测试
cd frontend
npm run test
```

---

## 📄 许可证

MIT License

---

## 🤝 贡献

欢迎提交 Issue 和 Pull Request！

---

## 📞 联系方式

- 项目地址：https://gitee.com/code_xiaohui/network-automation-platform
- 问题反馈：https://gitee.com/code_xiaohui/network-automation-platform/issues