# Serverless计算平台

**Repository Path**: sandbox-lang_tree/serverless-computing-platform

## Basic Information

- **Project Name**: Serverless计算平台
- **Description**: 我的期末大作业，看看就行，欢迎自己部署尝试，请勿商用，不要抄袭
- **Primary Language**: Python
- **License**: GPL-3.0
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2025-12-29
- **Last Updated**: 2026-03-20

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Serverless 计算任务托管平台

## 项目简介

本项目是一个基于微服务架构的Serverless计算任务托管平台，采用特定指令集的脚本语言和创新的虚拟机隔离技术，实现计算任务的自动调度、安全隔离执行和生命周期管理。平台提供了完整的Web管理界面、预定义数学计算服务和自定义脚本执行功能。经过压力测试验证，系统在高并发场景下表现优异，峰值吞吐量达到**511.67任务/秒**，成功率达**100%**。

## 系统架构

### 核心设计理念

- **事件驱动架构**：基于消息队列的任务调度机制
- **自动扩缩容**：根据负载动态调整计算资源
- **安全隔离**：基于特定指令集的虚拟机隔离技术
- **无状态服务**：所有状态信息外部化到数据库

### 节点设计与用途

| 节点名称           | 主要用途                         | 关键技术           |
|--------------------|----------------------------------|--------------------|
| **API Gateway**    | 提供统一的RESTful API入口        | FastAPI            |
| **Task Scheduler** | 核心调度器，管理任务队列和扩缩容 | 消息队列           |
| **VM Worker Node** | 基于特定指令集的虚拟机任务执行器 | 自定义指令集虚拟机 |
| **Database Node**  | 中心化的任务状态存储             | Redis              |

### 节点关系

节点之间关系如图：

```mermaid
graph LR
User-->/submit
/result-->User
subgraph API_Gateway
/submit-->TaskCache
TaskCache-->/result
end
TaskCache<-->DB
DB-->TaskQueue
ResultCache-->DB
subgraph TaskScheduler
TaskQueue-->VMWorker
VMWorker-->ResultCache
end
```

网关节点和任务调度节点之间通过两个DB节点进行任务信息传递，前后节点完全分离。任务调度节点自动扩缩容，根据负载情况动态调整VMWorker节点数量。

## 核心特性

### 1. 基于特定指令集的脚本执行

平台采用精简的类汇编指令集，所有数据操作均通过`"data"`字段进行索引访问，确保执行环境的简单性和可控性。

### 2. 预定义数学计算服务

平台内置了4个常用的数学计算服务，用户可以直接调用：

- **线性回归** - 使用最小二乘法进行线性回归分析
- **矩阵乘法** - 执行矩阵乘法运算 (A * B^T)  
- **矩阵转置** - 矩阵行列互换操作
- **向量归一化** - 将数值向量缩放到指定范围

### 3. 服务管理系统

完整的服务生命周期管理：

- ✅ 查看所有可用服务
- ✅ 添加自定义服务
- ✅ 编辑现有服务
- ✅ 删除不需要的服务
- ✅ 实时服务执行结果

### 4. 现代化Web界面

- 🌐 响应式设计，支持移动端
- 🎨 深色/浅色主题切换
- 📊 实时系统状态监控
- 🔄 实时任务状态更新
- 💻 代码编辑器集成

### 5. 数据库存储方案

使用**Redis**作为任务状态和元数据的持久化存储，提供高性能的消息队列和缓存功能。

**优势对比**：高性能、支持分布式、丰富的数据结构

### 6. 虚拟机隔离技术

采用基于特定指令集的特殊虚拟机作为任务执行环境，替代传统的Docker容器方案。

## 脚本语法规范

### 4.1 脚本格式

脚本采用类汇编格式，语法大幅简化，所有数据均从`"data"`字段中索引。

### 4.2 指令列表

1. `load` 指令
   1. **语法**：`load {var_name} from {data_key}[{index}]`
   2. **用途**：从`"data"`中加载数据到变量中
   3. **示例**：`load value1 from input_data[0]`
2. `store` 指令
   1. **语法**：`store {var_name} to {data_key}[{index}]`
   2. **用途**：将变量存储到`"data"`中
   3. **示例**：`store result to output_data[0]`
3. `let`指令
   1. **语法**：`let {var_name}={value}`
   2. **用途**：声明变量并赋值
   3. **示例**：`let final_result=calc(3+5)`;`let val1=10`
4. `print` 指令
   1. **语法**：`print {var_name}`
   2. **用途**：打印变量值
   3. **示例**：`print final_result`
5. `for`-`end for` 循环
   1. **语法**：`for i in {list_name}:<block>end for`
   2. **用途**：循环操作
   3. **示例**：参见下文for循环示例代码
6. `if`-`elif`-`else` 分支
   1. **语法**：`if {condition}:<block><elif {condition}:<block>>else:<block>end if`
   2. **用途**：条件分支
   3. **示例**：参见下文if分支示例代码
7. `loop`-`end loop`循环：
   1. **语法**：`loop {count}:<block>end loop`
   2. **用途**：循环操作
   3. **示例**：
      1. `loop 10:print(i)end loop`
      2. `loop len(data_list):print(data_list[idx])end loop`
8. `end`指令
   1. **语法**：`end`
   2. **用途**：结束当前程序
   3. **示例**：`end`
9. `save`指令
   1. **语法**：`save {var_name} to {key}`
   2. **用途**：保存数据到`"data"`中
   3. **示例**：`save result to result`
10. `alloc`指令
    1. **语法**：`alloc {var_name} length {length} type {type}`
    2. **用途**：分配内存空间
    3. **示例**：`alloc result length 10`
11. `return`指令
    1. **语法**：`return`
    2. **用途**：跳出当前循环
    3. **示例**：`return`

### 4.3 运算符

虚拟机指令集的运算符只允许在let语句和if语句中使用，不允许在其他语句中使用。支持的运算一览如下：

```python
import operator,math

SAFE_MATH_FUNCTIONS = {
    'int': int,
    'float': float,

    '+': operator.__add__,
    '-': operator.__sub__,
    '*': operator.__mul__,
    '/': operator.__truediv__,
    '//': operator.__floordiv__,
    '%': operator.__mod__,
    '**': operator.__pow__,

    '&': operator.__and__,
    '|': operator.__or__,
    '^': operator.__xor__,
    '~': operator.__invert__,
    '<<': operator.__lshift__,
    '>>': operator.__rshift__,

    'sqrt': math.sqrt,
    'log': math.log,
    'exp': math.exp,
    'sin': math.sin,
    'cos': math.cos,
    'tan': math.tan,
    'asin': math.asin,
    'acos': math.acos,
    'atan': math.atan,
    'tanh': math.tanh,

    'abs': abs,
    'min': min,
    'max': max,
    'sum': sum,
    'len': len,
    'round': round,

    '==': operator.__eq__,
    '!=': operator.__ne__,
    '>': operator.__gt__,
    '<': operator.__lt__,
    '>=': operator.__ge__,
    '<=': operator.__le__,

    'sigmoid': lambda x: 1 / (1 + math.exp(-x)),
    'relu': lambda x: max(x, 0),
    'softmax': lambda x: math.exp(x)/sum(math.exp(x)),
}
```

---

for循环示例脚本：

```text
for i in data_list:
    load item from data_list[i]
    result=calc(item * 2)
    store result to output[i]
end for
```

if分支示例脚本：

```text
if a > b:
print(a)
else:
print(b)
end if
```

```text
if a > b:
value=a+1
elif a < b:
value=b+1
else:
print(a + b)
end if
```

---

## API接口文档

### 服务管理接口

#### 获取所有服务

- **端点**：`GET /services`
- **响应**：所有可用服务的配置信息

#### 调用服务

- **端点**：`POST /service/{service_name}`
- **参数**：

```json
{
    "x": [1, 2, 3, 4, 5],
    "y": [1, 3, 2, 3, 5], 
    "size": [5]
}
```

- **响应**：

```json
{
    "task_id": "uuid",
    "result": {"k": 0.8, "b": 0.4},
    "service": "linear",
    "status": "completed"
}
```

#### 添加服务

- **端点**：`POST /services/add/{service_name}`
- **参数**：

```json
{
    "name": "我的服务",
    "required_params": ["input1", "input2"],
    "return_value": ["result"],
    "script": "let result = calc(input1 + input2)\nprint result"
}
```

#### 删除服务

- **端点**：`DELETE /services/remove/{service_name}`
- **响应**：`{"message": "服务 xxx 已删除成功"}`

### 自定义任务接口

#### 任务提交接口

- **端点**：`POST /submit`
- **参数**：

```json
{
    "script": "指令集脚本代码",
    "data": {"input_data": [1, 2, 3]}
}
```

- **响应**：`{"task_id": "uuid", "status": "submitted"}`

#### 结果查询接口

- **端点**：`GET /result/{task_id}`
- **响应**：任务执行状态和结果

#### 任务列表接口

- **端点**：`GET /tasks`
- **响应**：所有任务的列表和状态

### 系统接口

#### 健康检查接口

- **端点**：`GET /health`
- **响应**：服务健康状态

#### Web界面

- **端点**：`GET /`
- **响应**：完整的Web管理界面

## 部署指南

### 环境要求

- Python 3.8+
- Redis 5.0+
- 依赖包详见 requirements.txt

### 配置设置

1. **Redis配置**

   创建配置文件 `config.json`：
   ```json
   {
       "host": "localhost",
       "port": 6379,
       "password": "your_redis_password"
   }
   ```

2. **服务配置**

   - `services.json`: 预定义服务配置
   - `services/`: 服务脚本目录
   - `configs/local.json`: 本地环境配置

3. **安装依赖**

   ```bash
   pip install -r requirements.txt
   ```

### 启动系统

分别启动各组件（推荐）：

```bash
# 终端1：启动API网关 (默认端口8000)
python gateway.py

# 终端2：启动任务调度器
python scheduler.py
```

### 验证系统状态

访问以下URL验证系统运行状态：

- **Web管理界面**: <http://localhost:8000>
- **API文档**: <http://localhost:8000/docs> (FastAPI自动生成)
- **健康检查**: <http://localhost:8000/health>
- **服务列表**: <http://localhost:8000/services>
- **任务列表**: <http://localhost:8000/tasks>

## 📚 使用示例

### 1. 使用预定义服务

#### 线性回归服务

```python
import requests
import json

# 调用线性回归服务
data = {
    "x": [1, 2, 3, 4, 5],
    "y": [1, 3, 2, 3, 5], 
    "size": [5]
}

response = requests.post("http://localhost:8000/service/linear", json=data)
result = response.json()
print("线性回归结果:", result)
# 输出: {"k": 0.8, "b": 0.4}
```

#### 矩阵转置服务

```python
# 调用矩阵转置服务
data = {
    "x": [[1, 2, 3], [4, 5, 6]],
    "size": [2, 3]
}

response = requests.post("http://localhost:8000/service/mat_trans", json=data)
result = response.json()
print("转置结果:", result)
# 输出: {"y": [[1, 4], [2, 5], [3, 6]]}
```

### 2. 自定义服务管理

#### 添加新服务

```python
# 添加一个简单的加法服务
service_config = {
    "name": "数字加法",
    "required_params": ["a", "b"],
    "return_value": ["sum"],
    "script": """# 简单加法服务
let sum = calc(a + b)
print sum
"""
}

response = requests.post(
    "http://localhost:8000/services/add/addition",
    json=service_config
)
print("添加结果:", response.json())

# 使用新服务
data = {"a": 15, "b": 25}
response = requests.post("http://localhost:8000/service/addition", json=data)
print("计算结果:", response.json())
```

### 3. 自定义脚本任务

#### 基本计算任务

```python
# 提交简单加法任务
script = """
load a from input_data[0]
load b from input_data[1]
result=calc(a + b)
store result to output_data[0]
print(result)
"""

data = {
    "input_data": [10, 20]
}

response = requests.post("http://localhost:8000/submit", json={
    "script": script,
    "data": data
})

task_id = response.json()["task_id"]
print(f"任务ID: {task_id}")
```

#### 数组处理任务

```python
# 数组平方计算示例
script = """
for i in numbers:
    load num from numbers[i]
    squared=calc(num * num)
    store squared to squares[i]
end for
print(squares)
"""

data = {
    "numbers": [1, 2, 3, 4, 5]
}

response = requests.post("http://localhost:8000/submit", json={
    "script": script,
    "data": data
})
```

### 4. Web界面使用

1. **访问界面**：打开浏览器访问 `http://localhost:8000`
2. **使用预定义服务**：
   - 在"预定义服务"区域点击服务卡片
   - 查看服务信息和示例
   - 输入参数并执行
   - 实时查看计算结果
3. **管理服务**：
   - 点击"添加服务"创建自定义服务
   - 通过服务菜单编辑或删除服务
4. **自定义脚本**：
   - 在左侧表单中编写脚本
   - 输入JSON格式的数据
   - 提交任务并查看结果

## 📁 项目结构

```text
serverless-3.0-rc1/
├── gateway.py           # API网关服务 (FastAPI)
├── scheduler.py         # 任务调度器 (异步调度)
├── vm.py              # 虚拟机执行引擎 (自定义指令集)
├── database.py         # Redis数据库模块 (连接池)
├── services.py        # 服务管理系统 (动态服务)
├── services/          # 预定义服务脚本目录
│   ├── linear.txt          # 线性回归服务
│   ├── matmul.txt          # 矩阵乘法服务
│   ├── mat_trans.txt       # 矩阵转置服务
│   ├── normalization.txt   # 向量归一化服务
│   ├── logic_gate_inf.txt # 逻辑门推理服务
│   └── logic_gate_train.txt # 逻辑门训练服务
├── services.json      # 服务配置文件
├── basic_services.json # 基础服务配置
├── templates/         # Web界面模板
│   └── index.html          # 主页面 (响应式设计)
├── static/           # 静态资源
│   └── custom.css          # 自定义样式
├── stress/           # 压力测试结果目录
├── stress_test.py    # 压力测试脚本
├── test.py           # 基础测试脚本
├── config.py         # 配置管理模块
├── configs/          # 配置文件目录
│   └── local.json         # 本地配置示例
├── exapmle/          # 示例文件目录
│   └── services.json      # 服务配置示例
├── requirements.txt  # 依赖列表
├── readme.md         # 项目文档
└── report.md        # 详细技术报告
```

## 🔧 开发与测试

### 开发环境设置

```bash
# 安装开发依赖
pip install -r requirements.txt

# 运行基础功能测试
python test.py

# 进行压力测试 (可选)
python stress_test.py --help
```

## 🐛 故障排除

### 常见问题

1. **Redis连接失败**
   ```bash
   # 检查Redis服务状态
   redis-cli ping
   
   # 启动Redis服务
   redis-server
   ```

2. **端口被占用**
   ```bash
   # 查看端口占用
   netstat -an | grep 8000
   
   # 在gateway.py中修改端口
   uvicorn.run(app, host="0.0.0.0", port=8001)
   ```

3. **依赖安装失败**
   ```bash
   # 使用国内镜像源
   pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
   ```

4. **任务执行失败**
   - 检查脚本语法是否符合指令集规范
   - 确认数据格式为有效JSON
   - 查看控制台错误日志

### 日志查看

系统运行时会在控制台输出详细日志：

- 网关请求和响应信息
- 任务调度和状态变化
- 虚拟机执行详情
- Redis连接状态

## 📈 性能说明

系统经过优化，具备以下性能特征：

- 高并发处理能力
- 动态负载均衡
- 任务状态实时追踪
- 支持大规模任务调度

详细性能数据请参考 [技术报告](./report.md)

---

💡 **提示**: 适合开发和中小规模部署，支持水平扩展。