# aldux-proxy

**Repository Path**: caojp/aldux-proxy

## Basic Information

- **Project Name**: aldux-proxy
- **Description**: 一款高性能、安全可靠的分布式代理服务器解决方案，支持 SOCKS5 和 HTTP 代理协议，集成了 TLS 加密传输、WebSocket 伪装、多路复用等先进技术。
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-06-02
- **Last Updated**: 2026-06-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Aldux Proxy

一款高性能、安全可靠的分布式代理服务器解决方案，支持 SOCKS5 和 HTTP 代理协议，集成了 TLS 加密传输、WebSocket 伪装、多路复用等先进技术。

## 目录

- [项目介绍](#项目介绍)
- [技术栈](#技术栈)
- [系统架构](#系统架构)
- [快速开始](#快速开始)
- [部署指南](#部署指南)
  - [二进制部署](#二进制部署)
  - [Docker 部署](#docker-部署)
  - [systemd 部署](#systemd-部署)
- [配置说明](#配置说明)
- [客户端使用](#客户端使用)
  - [CLI 客户端](#cli-客户端)
  - [桌面客户端](#桌面客户端)
- [Web 管理面板](#web-管理面板)
- [API 文档](#api-文档)
- [常见问题](#常见问题)

---

## 项目介绍

Aldux Proxy 是一个企业级的代理服务器解决方案，采用分布式架构设计，包含管理节点（Manager）、代理节点（Node）和客户端（Client）三个核心组件。

### 主要特性

| 特性 | 描述 |
|------|------|
| **SOCKS5 代理** | 支持 Connect、Bind、UDP Associate 命令 |
| **HTTP 代理** | 支持 HTTP/HTTPS 透明代理 |
| **TLS 1.3 加密** | 基于 X25519 ECDHE 的安全传输 |
| **WebSocket 伪装** | 流量伪装成普通 WebSocket 连接 |
| **多路复用** | 基于 smux 的单一连接多流复用 |
| **协议伪装** | 随机填充、心跳、伪装 JSON 消息 |
| **UDP 转发** | SOCKS5 UDP Associate 支持 |
| **用户认证** | bcrypt 密码哈希、JWT 会话管理 |
| **双因素认证** | TOTP 基于时间的一次性密码 |
| **Web 管理面板** | React + TypeScript 现代化管理界面 |
| **IP ACL** | 白名单/黑名单访问控制 |
| **流量配额** | 用户流量限制和计费支持 |
| **负载均衡** | 多节点轮询/加权分配 |
| **多平台** | Windows/macOS/Linux 桌面客户端 |

### 应用场景

- 企业内网访问控制
- 跨境网络加速
- 数据采集与爬虫
- 安全审计与监控
- 多节点负载均衡

---

## 技术栈

### 后端技术栈

| 技术 | 版本 | 用途 |
|------|------|------|
| **Go** | 1.25.0 | 主要开发语言 |
| **GORM** | 1.31.1 | ORM 框架 |
| **SQLite/MySQL** | - | 数据存储 |
| **gRPC** | 1.65.0 | 节点间通信 |
| **WebSocket** | 1.5.1 | 客户端通信 |
| **JWT** | 4.5.2 | 用户认证 |
| **Prometheus** | 1.23.2 | 指标监控 |
| **smux** | 1.5.57 | 多路复用 |
| **uTLS** | 1.8.2 | TLS 指纹模拟 |

### 前端技术栈

| 技术 | 版本 | 用途 |
|------|------|------|
| **React** | 18.2.0 | UI 框架 |
| **TypeScript** | 5.3.3 | 类型安全 |
| **Vite** | 5.0.8 | 构建工具 |
| **Tailwind CSS** | 3.3.6 | 样式框架 |
| **Zustand** | 4.4.7 | 状态管理 |
| **React Router** | 6.20.0 | 路由管理 |
| **Lucide React** | 0.294.0 | 图标库 |

### 桌面客户端

| 技术 | 版本 | 用途 |
|------|------|------|
| **Electron** | 28.0.0 | 跨平台桌面应用 |
| **Electron Builder** | 24.9.1 | 打包工具 |

### 加密算法

- **密钥交换**: X25519 ECDHE
- **对称加密**: AES-256-GCM, ChaCha20-Poly1305
- **哈希算法**: SHA-256, SHA-512
- **密码哈希**: bcrypt
- **签名算法**: Ed25519

---

## 系统架构

### 整体架构

```
┌─────────────────────────────────────────────────────────────────┐
│                        客户端 (Client)                           │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌────────────────────────┐ │
│  │ SOCKS5 Proxy│  │ HTTP Proxy  │  │   Desktop Client UI    │ │
│  └──────┬──────┘  └──────┬──────┘  └───────────┬────────────┘ │
│         │                │                        │              │
│         └────────────────┼────────────────────────┘              │
│                          │                                       │
│                  ┌───────▼───────┐                               │
│                  │  Encrypted    │  TLS 1.3 + WebSocket         │
│                  │    Tunnel     │  + Multiplexing               │
│                  └───────┬───────┘                               │
└──────────────────────────┼───────────────────────────────────────┘
                           │  Internet
┌──────────────────────────┼───────────────────────────────────────┐
│                      代理节点 (Node)                             │
├──────────────────────────┼───────────────────────────────────────┤
│                  ┌───────▼───────┐                               │
│                  │  Encrypted    │  gRPC 通信                    │
│                  │    Tunnel     │                               │
│                  └───────┬───────┘                               │
│                          │                                       │
│                  ┌───────▼───────┐                               │
│                  │  Proxy Engine │  SOCKS5/HTTP 转发             │
│                  └───────┬───────┘                               │
│                          │                                       │
└──────────────────────────┼───────────────────────────────────────┘
                           │  Target Server
┌──────────────────────────┼───────────────────────────────────────┐
│                     管理节点 (Manager)                            │
├─────────────────────────────────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐  ┌───────────────────────┐  │
│  │  User Service│  │ Node Service │  │  Web Admin Dashboard  │  │
│  └──────┬───────┘  └──────┬───────┘  └───────────┬───────────┘  │
│         │                 │                        │              │
│         └─────────────────┼────────────────────────┘              │
│                           │                                       │
│                  ┌────────▼─────────┐                             │
│                  │    Database       │  SQLite/MySQL              │
│                  └──────────────────┘                             │
└─────────────────────────────────────────────────────────────────┘
```

### 组件说明

1. **Manager (管理节点)**
   - 用户管理与认证
   - 节点管理与监控
   - 流量统计与审计
   - Web 管理面板
   - gRPC API 服务

2. **Node (代理节点)**
   - SOCKS5/HTTP 代理服务
   - 加密隧道终端
   - 流量转发与负载均衡
   - 节点状态上报

3. **Client (客户端)**
   - 本地 SOCKS5/HTTP 代理
   - 加密隧道建立
   - 系统代理配置
   - 桌面 GUI 界面

---

## 快速开始

### 环境要求

| 组件 | 最低要求 | 推荐配置 |
|------|----------|----------|
| **Go** | 1.21+ | 1.25+ |
| **Node.js** | 16+ | 18+ |
| **CPU** | 1 核 | 2+ 核 |
| **内存** | 512 MB | 2 GB+ |
| **磁盘** | 1 GB | 10 GB+ |

### 克隆项目

```bash
git clone https://gitee.com/caojp/aldux-proxy.git
cd aldux-proxy
```

### 编译后端

```bash
# 编译管理节点
go build -o dist/manager ./manager/cmd

# 编译代理节点
go build -o dist/node ./node/cmd

# 编译 CLI 客户端
go build -o dist/client ./client/cmd/cli
```

### 编译 Web 管理面板

```bash
cd web-admin
npm install
npm run build
```

### 编译桌面客户端

```bash
cd desktop
npm install
npm run build:renderer
npm run build:main
npm run electron:build
```

---

## 部署指南

### 二进制部署

#### 1. 环境准备

##### 1.1 系统要求

| 资源 | 最低配置 | 推荐配置 |
|------|---------|---------|
| **操作系统** | Linux (Kernel 4.0+) | Ubuntu 20.04+, CentOS 7+ |
| **CPU** | 1 核 | 4 核及以上 |
| **内存** | 2GB | 8GB 及以上 |
| **磁盘** | 10GB | 50GB SSD 及以上 |
| **网络** | 1Mbps | 100Mbps 及以上 |

##### 1.2 安装系统依赖

```bash
# Ubuntu/Debian 系统
sudo apt update && sudo apt install -y wget tar openssl net-tools mysql-client redis-tools

# CentOS/RHEL 系统
sudo yum install -y wget tar openssl net-tools mysql redis
```

##### 1.3 准备 MySQL 数据库

确保已安装 MySQL 5.7+ 或 MariaDB 10.3+：

```sql
-- 登录数据库服务器
mysql -h 10.0.34.114 -u aldux -p'rF4ACb2EeaJL7i63'

-- 创建数据库
CREATE DATABASE IF NOT EXISTS aldux_proxy 
  CHARACTER SET utf8mb4 
  COLLATE utf8mb4_unicode_ci;

-- 验证数据库创建
SHOW DATABASES LIKE 'aldux_proxy';

-- 退出
EXIT;
```

测试数据库连接：

```bash
mysql -h 10.0.34.114 -u aldux -p'rF4ACb2EeaJL7i63' -e "SELECT VERSION();"
```

##### 1.4 准备 Redis 缓存

确保已安装 Redis 5.0+：

```bash
# 测试 Redis 连接
redis-cli -h 10.0.34.114 -p 6379 -a '7WeXa5JIfxWjjz' ping
# 应返回: PONG

# 查看 Redis 信息
redis-cli -h 10.0.34.114 -p 6379 -a '7WeXa5JIfxWjjz' info server
```

##### 1.5 创建目录结构

```bash
# 创建应用目录
sudo mkdir -p /opt/aldux-proxy/{bin,certs,data,configs,logs}

# 设置目录权限
sudo chown -R root:root /opt/aldux-proxy
sudo chmod 755 /opt/aldux-proxy
sudo chmod 700 /opt/aldux-proxy/certs
```

#### 2. 安装二进制文件

```bash
cd /opt/aldux-proxy

# 方式一：从 Release 下载（推荐）
# 访问 https://gitee.com/caojp/aldux-proxy/releases 下载最新版本
wget https://gitee.com/caojp/aldux-proxy/releases/download/v1.0.0/aldux-proxy-linux-amd64.tar.gz

# 方式二：本地编译上传（开发环境）
# scp dist/manager root@your-server:/opt/aldux-proxy/bin/
# scp dist/node root@your-server:/opt/aldux-proxy/bin/
# scp dist/initdb root@your-server:/opt/aldux-proxy/bin/

# 解压文件
tar -xzf aldux-proxy-linux-amd64.tar.gz -C bin/

# 赋予执行权限
chmod +x bin/*

# 验证安装
./bin/manager --version
./bin/node --version
./bin/initdb --version
```

#### 3. 生成 TLS 证书

```bash
cd /opt/aldux-proxy/certs

# ============================================
# 方案一：生成自签名证书（测试/内部环境）
# ============================================

# 生成 CA 根证书
openssl genrsa -out ca.key 4096
openssl req -new -x509 -days 3650 -key ca.key -out ca.crt \
  -subj "/C=CN/ST=Beijing/L=Beijing/O=AlduxProxy/OU=CA/CN=AlduxProxy Root CA"

# 生成管理节点 gRPC 证书
openssl genrsa -out manager.key 4096
openssl req -new -key manager.key -out manager.csr \
  -subj "/C=CN/ST=Beijing/L=Beijing/O=AlduxProxy/OU=Manager/CN=manager.aldux-proxy.com"
openssl x509 -req -in manager.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out manager.crt -days 3650

# 生成代理节点 gRPC 证书
openssl genrsa -out node.key 4096
openssl req -new -key node.key -out node.csr \
  -subj "/C=CN/ST=Beijing/L=Beijing/O=AlduxProxy/OU=Node/CN=node.aldux-proxy.com"
openssl x509 -req -in node.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out node.crt -days 3650

# 生成 WebSocket TLS 证书（用于代理连接）
openssl ecparam -genkey -name prime256v1 -out ws.key
openssl req -new -key ws.key -out ws.csr \
  -subj "/C=CN/ST=Beijing/L=Beijing/O=AlduxProxy/OU=Proxy/CN=your-domain.com"
openssl x509 -req -in ws.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out ws.crt -days 3650

# ============================================
# 方案二：使用 Let's Encrypt 证书（生产环境）
# ============================================

# 安装 certbot
# sudo apt install -y certbot
# sudo certbot certonly --standalone -d your-domain.com
# 
# 复制证书
# cp /etc/letsencrypt/live/your-domain.com/fullchain.pem ws.crt
# cp /etc/letsencrypt/live/your-domain.com/privkey.pem ws.key

# 设置证书权限
chmod 600 *.key
chmod 644 *.crt

# 验证证书
openssl x509 -in ca.crt -text -noout | head -20
```

#### 4. 配置文件

```bash
cd /opt/aldux-proxy

# 复制示例配置
cp /path/to/aldux-proxy/config/manager.example.yaml configs/manager.yaml
cp /path/to/aldux-proxy/config/node.example.yaml configs/node.yaml

# 编辑管理节点配置
vim configs/manager.yaml
```

**管理节点配置 (manager.yaml)**:

```yaml
server:
  http_addr: ":8090"
  grpc_addr: ":50051"

database:
  dsn: "aldux:rF4ACb2EeaJL7i63@tcp(10.0.34.114:3306)/aldux_proxy?charset=utf8mb4&parseTime=True&loc=Local"

redis:
  host: "10.0.34.114"
  port: 6379
  password: "7WeXa5JIfxWjjz"
  db: 0

jwt:
  secret: "change-this-to-your-own-secret-key-at-least-32-chars"
  expire_hours: 24

grpc:
  cert_file: "/opt/aldux-proxy/certs/manager.crt"
  key_file: "/opt/aldux-proxy/certs/manager.key"
  ca_file: "/opt/aldux-proxy/certs/ca.crt"

security:
  login_attempts:
    max_attempts: 5
    lockout_minutes: 15
  token_blacklist_cleanup_minutes: 60

logging:
  level: "info"
  format: "json"
  file: "/opt/aldux-proxy/logs/manager.log"
```

继续编辑代理节点配置：

```bash
vim configs/node.yaml
```

**代理节点配置 (node.yaml)**:

```yaml
node:
  id: "node-001"
  name: "Default Node"
  manager_address: "127.0.0.1:50051"
  secret: "node-secret-001-change-me"
  listen_address: ":8443"
  websocket_path: "/ws"
  location: "CN"
  max_connections: 1000
  max_bandwidth: 1000000000
  allowed_origins:
    - "https://yourdomain.com"
    - "http://localhost:8080"

grpc:
  cert_file: "/opt/aldux-proxy/certs/node.crt"
  key_file: "/opt/aldux-proxy/certs/node.key"
  ca_file: "/opt/aldux-proxy/certs/ca.crt"
  skip_verify: false

tls:
  cert_file: "/opt/aldux-proxy/certs/ws.crt"
  key_file: "/opt/aldux-proxy/certs/ws.key"

logging:
  level: "info"
  file: "/opt/aldux-proxy/logs/node.log"
```

#### 5. 初始化数据库

```bash
cd /opt/aldux-proxy

# 执行数据库迁移和初始化
./bin/initdb

# 预期输出:
# Connecting to database...
# Database connected successfully!
# Migrating database tables...
# Database migration completed!
# Inserting default data...
# ✅ Database initialization completed successfully!

# 验证数据库表
mysql -h 10.0.34.114 -u aldux -p'rF4ACb2EeaJL7i63' -e "USE aldux_proxy; SHOW TABLES;"

# 验证默认用户
mysql -h 10.0.34.114 -u aldux -p'rF4ACb2EeaJL7i63' -e "USE aldux_proxy; SELECT id, username, email FROM users;"
```

初始化后创建的默认账号：
- **管理员**: `admin` / `admin123`（10年有效期，无限流量）
- **测试用户**: `test` / `test123`（30天有效期，10GB流量）

#### 6. 启动服务（测试运行）

```bash
cd /opt/aldux-proxy

# 终端 1：启动管理节点（前台运行）
./bin/manager --config configs/manager.yaml

# 终端 2：启动代理节点（前台运行）
./bin/node --config configs/node.yaml

# 终端 3：验证服务
# 检查端口监听
netstat -tlnp | grep -E '8080|50051|8443'

# 测试健康检查接口
curl http://localhost:8080/api/health

# 测试登录
curl -X POST http://localhost:8080/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"admin123"}'

# 查看日志
tail -f logs/manager.log
tail -f logs/node.log
```

#### 7. 配置防火墙

```bash
# Ubuntu/Debian (ufw)
sudo ufw allow 8080/tcp    # Web 管理面板
sudo ufw allow 50051/tcp   # gRPC 管理通信
sudo ufw allow 8443/tcp    # WebSocket 代理端口
sudo ufw reload

# CentOS/RHEL (firewalld)
sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --permanent --add-port=50051/tcp
sudo firewall-cmd --permanent --add-port=8443/tcp
sudo firewall-cmd --reload

# 验证端口
sudo firewall-cmd --list-ports
```

### Docker 部署

#### 1. 环境准备

```bash
# 安装 Docker
curl -fsSL https://get.docker.com | bash

# 安装 Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker --version
docker-compose --version
```

#### 2. 方案 A：使用外部 MySQL 和 Redis（推荐）

如果您的服务器上已经安装了 MySQL 和 Redis，可以使用此方案：

```yaml
services:
  manager:
    build:
      context: .
      dockerfile: docker/Dockerfile.manager
    container_name: aldux-manager
    restart: unless-stopped
    environment:
      - DB_DSN=aldux:rF4ACb2EeaJL7i63@tcp(host.docker.internal:3306)/aldux_proxy?charset=utf8mb4&parseTime=True&loc=Local
      - REDIS_HOST=host.docker.internal
      - REDIS_PORT=6379
      - REDIS_PASSWORD=7WeXa5JIfxWjjz
      - REDIS_DB=0
      - JWT_SECRET=your-very-long-secure-secret-key-at-least-32-characters
    volumes:
      - ./configs:/app/configs
      - ./certs:/app/certs
      - ./logs:/app/logs
    ports:
      - "8080:8080"
      - "50051:50051"
    networks:
      - aldux-network
    extra_hosts:
      - "host.docker.internal:host-gateway"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/api/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  node:
    build:
      context: .
      dockerfile: docker/Dockerfile.node
    container_name: aldux-node
    restart: unless-stopped
    depends_on:
      manager:
        condition: service_healthy
    environment:
      - NODE_ID=node-001
      - NODE_NAME=Default Node
      - MANAGER_ADDRESS=manager:50051
    volumes:
      - ./configs:/app/configs
      - ./certs:/app/certs
      - ./logs:/app/logs
    ports:
      - "8443:8443"
    networks:
      - aldux-network
    extra_hosts:
      - "host.docker.internal:host-gateway"
    ulimits:
      nofile:
        soft: 65536
        hard: 65536

networks:
  aldux-network:
    driver: bridge
```

**注意**: 
- `host.docker.internal` 是 Docker 提供的访问宿主机的特殊域名
- Linux 系统需要 `extra_hosts` 配置，Windows/macOS Docker Desktop 自动支持
- 确保宿主机 MySQL 和 Redis 允许外部连接（绑定 0.0.0.0 或 172.17.0.1）

#### 3. 方案 B：Docker 内置 MySQL 和 Redis

如果希望全部使用 Docker 容器运行：

```yaml
services:
  mysql:
    image: mysql:8.0
    container_name: aldux-mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: 'root_password'
      MYSQL_DATABASE: 'aldux_proxy'
      MYSQL_USER: 'aldux'
      MYSQL_PASSWORD: 'rF4ACb2EeaJL7i63'
    volumes:
      - mysql-data:/var/lib/mysql
      - ./docker/mysql/init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "3306:3306"
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
      - --max-connections=1000
      - --innodb-buffer-pool-size=512M
    networks:
      - aldux-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "aldux", "-prF4ACb2EeaJL7i63"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    container_name: aldux-redis
    restart: unless-stopped
    command: redis-server --requirepass '7WeXa5JIfxWjjz' --appendonly yes
    volumes:
      - redis-data:/data
    ports:
      - "6379:6379"
    networks:
      - aldux-network
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "7WeXa5JIfxWjjz", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  manager:
    build:
      context: .
      dockerfile: docker/Dockerfile.manager
    container_name: aldux-manager
    restart: unless-stopped
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      - DB_DSN=aldux:rF4ACb2EeaJL7i63@tcp(mysql:3306)/aldux_proxy?charset=utf8mb4&parseTime=True&loc=Local
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - REDIS_PASSWORD=7WeXa5JIfxWjjz
      - REDIS_DB=0
      - JWT_SECRET=your-very-long-secure-secret-key-at-least-32-characters
    volumes:
      - ./configs:/app/configs
      - ./certs:/app/certs
      - ./logs:/app/logs
    ports:
      - "8080:8080"
      - "50051:50051"
    networks:
      - aldux-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/api/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  node:
    build:
      context: .
      dockerfile: docker/Dockerfile.node
    container_name: aldux-node
    restart: unless-stopped
    depends_on:
      manager:
        condition: service_healthy
    environment:
      - NODE_ID=node-001
      - NODE_NAME=Default Node
      - MANAGER_ADDRESS=manager:50051
    volumes:
      - ./configs:/app/configs
      - ./certs:/app/certs
      - ./logs:/app/logs
    ports:
      - "8443:8443"
    networks:
      - aldux-network
    ulimits:
      nofile:
        soft: 65536
        hard: 65536

volumes:
  mysql-data:
  redis-data:

networks:
  aldux-network:
    driver: bridge
```

#### 3. 创建 Dockerfile

创建 `docker/Dockerfile.manager`:

```dockerfile
FROM golang:1.25-alpine AS builder

WORKDIR /app

# 安装依赖
RUN apk add --no-cache git ca-certificates tzdata

# 复制 go mod 文件
COPY go.mod go.sum ./
RUN go mod download

# 复制源代码
COPY . .

# 构建管理节点
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o /tmp/manager ./manager/cmd
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o /tmp/initdb ./manager/cmd/initdb

# 最终镜像
FROM alpine:latest

RUN apk add --no-cache ca-certificates tzdata curl

WORKDIR /app

# 复制二进制文件
COPY --from=builder /tmp/manager /usr/local/bin/
COPY --from=builder /tmp/initdb /usr/local/bin/

# 复制配置和证书
COPY config/manager.example.yaml /app/configs/manager.yaml

# 创建目录
RUN mkdir -p /app/logs /app/certs

EXPOSE 8080 50051

CMD ["manager", "--config", "/app/configs/manager.yaml"]
```

创建 `docker/Dockerfile.node`:

```dockerfile
FROM golang:1.25-alpine AS builder

WORKDIR /app

RUN apk add --no-cache git ca-certificates tzdata

COPY go.mod go.sum ./
RUN go mod download

COPY . .

# 构建代理节点
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o /tmp/node ./node/cmd

FROM alpine:latest

RUN apk add --no-cache ca-certificates tzdata

WORKDIR /app

COPY --from=builder /tmp/node /usr/local/bin/
COPY config/node.example.yaml /app/configs/node.yaml

RUN mkdir -p /app/logs /app/certs

EXPOSE 8443

CMD ["node", "--config", "/app/configs/node.yaml"]
```

#### 4. 创建 MySQL 初始化脚本

创建 `docker/mysql/init.sql`:

```sql
-- 创建数据库
CREATE DATABASE IF NOT EXISTS aldux_proxy CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- 授权
GRANT ALL PRIVILEGES ON aldux_proxy.* TO 'aldux'@'%';
FLUSH PRIVILEGES;
```

#### 5. 启动服务

```bash
# 创建目录结构
mkdir -p docker/mysql configs certs logs

# 启动服务
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f manager
docker-compose logs -f node

# 初始化数据库（首次启动）
docker-compose exec manager initdb

# 停止服务
docker-compose stop

# 停止并删除容器
docker-compose down

# 停止并删除容器和数据卷（谨慎使用）
docker-compose down -v
```

#### 7. 验证部署

```bash
# 检查容器状态
docker ps --filter name=aldux

# 检查 MySQL 连接
docker exec -it aldux-mysql mysql -u aldux -p'rF4ACb2EeaJL7i63' -e "SELECT 1;"

# 检查 Redis 连接
docker exec -it aldux-redis redis-cli -a '7WeXa5JIfxWjjz' ping

# 测试管理节点 API
curl http://localhost:8090/api/health
```

### systemd 部署

#### 管理节点服务

创建 `/etc/systemd/system/aldux-manager.service`:

```ini
[Unit]
Description=Aldux Proxy Manager
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/opt/aldux-proxy
ExecStart=/opt/aldux-proxy/bin/manager --config /opt/aldux-proxy/configs/manager.yaml
Restart=always
RestartSec=5
LimitNOFILE=65536
StandardOutput=append:/opt/aldux-proxy/logs/manager.log
StandardError=append:/opt/aldux-proxy/logs/manager-error.log

[Install]
WantedBy=multi-user.target
```

#### 代理节点服务

创建 `/etc/systemd/system/aldux-node.service`:

```ini
[Unit]
Description=Aldux Proxy Node
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/opt/aldux-proxy
ExecStart=/opt/aldux-proxy/bin/node --config /opt/aldux-proxy/configs/node.yaml
Restart=always
RestartSec=5
LimitNOFILE=65536
StandardOutput=append:/opt/aldux-proxy/logs/node.log
StandardError=append:/opt/aldux-proxy/logs/node-error.log

[Install]
WantedBy=multi-user.target
```

#### 启动服务

```bash
# 重新加载 systemd
systemctl daemon-reload

# 启用开机自启
systemctl enable aldux-manager
systemctl enable aldux-node

# 启动服务
systemctl start aldux-manager
systemctl start aldux-node

# 查看状态
systemctl status aldux-manager
systemctl status aldux-node

# 查看日志
journalctl -u aldux-manager -f
journalctl -u aldux-node -f
```

---

## 配置说明

### 管理节点配置 (manager.yaml)

```yaml
server:
  http_addr: ":9090"
  grpc_addr: ":50051"

database:
  driver: sqlite
  dsn: data/aldux-proxy.db

security:
  jwt_secret: "your-secret-key-here"
  jwt_expires_hours: 24
  totp_required: false
  rate_limit:
    enabled: true
    requests_per_minute: 60
  ip_whitelist: []
  ip_blacklist: []

logging:
  level: info
  file: logs/manager.log
  max_size: 100
  max_backups: 10
  max_age: 30

metrics:
  enabled: true
  addr: ":9091"
```

### 代理节点配置 (node.yaml)

```yaml
server:
  listen_addr: ":443"
  ws_path: "/ws"
  tls_cert: "certs/server.crt"
  tls_key: "certs/server.key"

manager:
  address: "localhost:50051"
  node_id: "node-01"
  node_name: "Main Node"
  region: "CN-BJ"
  heartbeat_interval: 30

tunnel:
  cipher: "aes-256-gcm"
  key_rotation_interval: 1800
  obfuscation_enabled: true
  obfuscation_level: 3

mux:
  max_streams: 100
  keepalive_interval: 30
  stream_buffer_size: 65536

proxy:
  socks5_enabled: true
  socks5_addr: ":1080"
  http_enabled: true
  http_addr: ":8080"
  udp_enabled: true

logging:
  level: info
  file: logs/node.log
```

### 客户端配置 (client.yaml)

```yaml
server:
  address: "your-server.com:443"
  ws_path: "/ws"
  username: "user1"
  password: "password"
  totp_code: ""

proxy:
  socks5_addr: "127.0.0.1:1080"
  http_addr: "127.0.0.1:8080"
  system_proxy: true

tunnel:
  cipher: "aes-256-gcm"
  obfuscation_enabled: true

tls:
  insecure_skip_verify: false
  ca_cert: ""
  server_name: ""

logging:
  level: info
```

---

## 客户端使用

### CLI 客户端

#### 基本使用

```bash
# 使用配置文件启动
./client --config client.yaml

# 使用命令行参数启动
./client \
  --server your-server.com:443 \
  --username user1 \
  --password password \
  --socks5 127.0.0.1:1080 \
  --http 127.0.0.1:8080

# 指定日志级别
./client --log-level debug

# 启用系统代理
./client --system-proxy
```

#### 测试代理

```bash
# 测试 SOCKS5 代理
curl -x socks5://127.0.0.1:1080 https://httpbin.org/ip

# 测试 HTTP 代理
curl -x http://127.0.0.1:8080 https://httpbin.org/ip
```

### 桌面客户端

#### Windows

1. 下载 `Aldux Proxy Setup.exe`
2. 运行安装程序
3. 启动应用程序
4. 配置服务器地址和认证信息
5. 点击"连接"按钮

#### macOS

1. 下载 `Aldux Proxy.dmg`
2. 挂载 DMG 文件
3. 将应用拖到"应用程序"文件夹
4. 启动应用程序（首次启动可能需要允许来自未知开发者）
5. 配置服务器信息

#### Linux

1. 下载 `Aldux Proxy.AppImage`
2. 赋予执行权限: `chmod +x Aldux\ Proxy.AppImage`
3. 运行应用程序: `./Aldux\ Proxy.AppImage`

---

## Web 管理面板

### 访问地址

```
http://your-server:9090
```

### 默认账号

- **用户名**: `admin`
- **密码**: `Admin@2024!Proxy`

### 功能模块

1. **仪表盘**
   - 实时连接统计
   - 流量监控图表
   - 节点状态概览
   - 在线用户列表

2. **用户管理**
   - 用户增删改查
   - 密码重置
   - 流量配额设置
   - 账号启用/禁用

3. **节点管理**
   - 节点注册与配置
   - 节点状态监控
   - 负载均衡配置
   - 节点启用/禁用

4. **审计日志**
   - 登录日志
   - 操作日志
   - 流量日志
   - 错误日志

5. **安全设置**
   - 双因素认证
   - IP 黑白名单
   - 速率限制
   - 证书管理

---

## API 文档

### 认证接口

#### 登录

```http
POST /api/auth/login
Content-Type: application/json

{
  "username": "admin",
  "password": "Admin@2024!Proxy"
}

Response:
{
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "user": {
    "id": 1,
    "username": "admin",
    "role": "admin"
  }
}
```

#### 登出

```http
POST /api/auth/logout
Authorization: Bearer <token>
```

### 用户接口

#### 获取用户列表

```http
GET /api/users?page=1&page_size=20
Authorization: Bearer <token>
```

#### 创建用户

```http
POST /api/users
Authorization: Bearer <token>
Content-Type: application/json

{
  "username": "user1",
  "password": "password123",
  "enabled": true,
  "traffic_limit": 10737418240
}
```

#### 更新用户

```http
PUT /api/users
Authorization: Bearer <token>
Content-Type: application/json

{
  "id": 1,
  "enabled": false,
  "traffic_limit": 21474836480
}
```

#### 删除用户

```http
DELETE /api/users?id=1
Authorization: Bearer <token>
```

### 节点接口

#### 获取节点列表

```http
GET /api/nodes?page=1&page_size=20
Authorization: Bearer <token>
```

#### 获取在线节点

```http
GET /api/nodes/online
Authorization: Bearer <token>
```

#### 创建节点

```http
POST /api/nodes
Authorization: Bearer <token>
Content-Type: application/json

{
  "name": "Node 01",
  "address": "node01.example.com",
  "port": 443,
  "region": "CN-BJ",
  "enabled": true
}
```

### 统计接口

#### 获取仪表盘数据

```http
GET /api/dashboard
Authorization: Bearer <token>

Response:
{
  "total_users": 100,
  "online_users": 25,
  "total_nodes": 5,
  "online_nodes": 4,
  "total_traffic_today": 10737418240,
  "active_connections": 156
}
```

#### 获取流量统计

```http
GET /api/traffic?start_date=2024-01-01&end_date=2024-01-31
Authorization: Bearer <token>
```

---

## 常见问题

### 1. 如何修改默认管理员密码？

登录 Web 管理面板后，进入"个人设置"页面修改密码，或使用 API：

```bash
curl -X PUT http://localhost:9090/api/users \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"id": 1, "password": "new-password"}'
```

### 2. 如何添加新的代理节点？

1. 在管理面板的"节点管理"页面添加节点
2. 在节点服务器上配置 `node.yaml` 中的 `node_id` 和 `manager.address`
3. 启动节点服务，节点会自动向管理节点注册

### 3. 客户端无法连接怎么办？

检查以下几点：
- 确认服务器地址和端口正确
- 确认网络连通性: `telnet your-server.com 443`
- 检查防火墙是否开放端口
- 查看客户端和服务端日志
- 确认证书配置正确

### 4. 如何启用双因素认证？

1. 登录 Web 管理面板
2. 进入"安全设置"页面
3. 启用"TOTP 双因素认证"
4. 使用 Google Authenticator 扫描二维码
5. 输入验证码完成绑定

### 5. 如何配置负载均衡？

1. 添加多个代理节点
2. 在管理面板"节点管理"页面设置节点权重
3. 客户端会自动根据负载均衡策略选择节点

### 6. 日志文件在哪里？

- 管理节点: `/opt/aldux-proxy/logs/manager.log`
- 代理节点: `/opt/aldux-proxy/logs/node.log`
- 桌面客户端:
  - Windows: `%APPDATA%\Aldux Proxy\logs\`
  - macOS: `~/Library/Logs/Aldux Proxy/`
  - Linux: `~/.config/aldux-proxy/logs/`

### 7. 如何备份数据？

```bash
# 备份数据库
cp /opt/aldux-proxy/data/aldux-proxy.db /backup/aldux-proxy-$(date +%Y%m%d).db

# 备份证书
tar -czf /backup/certs-$(date +%Y%m%d).tar.gz /opt/aldux-proxy/certs/

# 备份配置
tar -czf /backup/configs-$(date +%Y%m%d).tar.gz /opt/aldux-proxy/configs/
```

### 8. 如何升级版本？

```bash
# 1. 停止服务
systemctl stop aldux-manager
systemctl stop aldux-node

# 2. 备份数据
cp -r /opt/aldux-proxy/data /opt/aldux-proxy/data.backup

# 3. 替换二进制文件
cp dist/manager /opt/aldux-proxy/bin/
cp dist/node /opt/aldux-proxy/bin/

# 4. 启动服务
systemctl start aldux-manager
systemctl start aldux-node

# 5. 检查状态
systemctl status aldux-manager
systemctl status aldux-node
```

---

## 许可证

MIT License

## 技术支持

- 文档: [doc/README.md](doc/README.md)
- API 文档: [doc/API.md](doc/API.md)
- 架构文档: [doc/ARCHITECTURE.md](doc/ARCHITECTURE-v2.md)

## 更新日志

### v1.0.0 (2026-01-01)

- 初始版本发布
- 支持 SOCKS5 和 HTTP 代理
- Web 管理面板
- 用户认证与管理
- 多节点支持
- 双因素认证