|
|
# VBase 权限系统文档
|
|
|
|
|
|
## 1. 权限模型概述
|
|
|
|
|
|
VBase 是一个类似 **Supabase** 的 BaaS 平台，为 2C（个人开发者）和 2B（团队/企业）用户提供后端资源托管服务。权限系统采用 **RBAC + ABAC** 混合模型，支持三级权限体系：
|
|
|
|
|
|
- **平台级 (Platform)**: 用户管理自己的账号和数据
|
|
|
- **项目级 (Project)**: 项目内的成员管理和资源控制
|
|
|
- **资源级 (Resource)**: 具体资源的读写操作
|
|
|
|
|
|
---
|
|
|
|
|
|
## 2. 核心概念
|
|
|
|
|
|
### 2.1 权限层级
|
|
|
|
|
|
```
|
|
|
┌─────────────────────────────────────────────────────────────┐
|
|
|
│ 平台级权限 (Platform) │
|
|
|
│ - 管理自己的用户信息 │
|
|
|
│ - 创建新项目 │
|
|
|
│ - 管理第三方账号绑定 │
|
|
|
│ - 访问被邀请的项目 │
|
|
|
└─────────────────────────────────────────────────────────────┘
|
|
|
│
|
|
|
▼ (进入项目上下文)
|
|
|
┌─────────────────────────────────────────────────────────────┐
|
|
|
│ 项目级权限 (Project) │
|
|
|
│ - 项目设置管理 (所有者/管理员) │
|
|
|
│ - 成员邀请和管理 │
|
|
|
│ - 资源创建和管理 │
|
|
|
│ - 查看项目统计信息 │
|
|
|
└─────────────────────────────────────────────────────────────┘
|
|
|
│
|
|
|
▼ (访问具体资源)
|
|
|
┌─────────────────────────────────────────────────────────────┐
|
|
|
│ 资源级权限 (Resource) │
|
|
|
│ - 数据库读写操作 │
|
|
|
│ - 存储文件上传下载 │
|
|
|
│ - 函数调用和管理 │
|
|
|
│ - API 密钥管理 │
|
|
|
└─────────────────────────────────────────────────────────────┘
|
|
|
```
|
|
|
|
|
|
### 2.2 实体关系
|
|
|
|
|
|
```
|
|
|
User (平台用户)
|
|
|
├── Platform Permission (平台级权限)
|
|
|
│ └── 默认: 管理自己的数据
|
|
|
│
|
|
|
└── OrgMember (项目成员关系)
|
|
|
├── Org/Project (项目)
|
|
|
│ ├── Resource (项目资源)
|
|
|
│ └── Resource (项目资源)
|
|
|
│
|
|
|
└── Role (项目角色)
|
|
|
└── Policy (策略)
|
|
|
```
|
|
|
|
|
|
### 2.3 使用场景示例
|
|
|
|
|
|
**场景1: 个人开发者 (2C)**
|
|
|
```
|
|
|
小明 (User)
|
|
|
├── 个人信息管理 (平台级)
|
|
|
├── 我的项目A (Org)
|
|
|
│ ├── 数据库资源
|
|
|
│ └── 存储资源
|
|
|
└── 我的项目B (Org)
|
|
|
└── ...
|
|
|
```
|
|
|
|
|
|
**场景2: 团队协作 (2B)**
|
|
|
```
|
|
|
CEO (User)
|
|
|
├── 拥有的项目: WebApp, MobileApp
|
|
|
└── 角色: 所有者 (Owner)
|
|
|
|
|
|
CTO (User)
|
|
|
├── 参与的项目: WebApp (Admin), MobileApp (Developer)
|
|
|
└── 角色: 管理员/开发者
|
|
|
|
|
|
员工A (User)
|
|
|
├── 参与的项目: WebApp (Developer)
|
|
|
└── 角色: 开发者
|
|
|
```
|
|
|
|
|
|
### 2.2 策略 (Policy)
|
|
|
|
|
|
策略是权限控制的最小单元，定义了对特定资源的操作权限。
|
|
|
|
|
|
**策略结构：**
|
|
|
|
|
|
```go
|
|
|
type Policy struct {
|
|
|
Code string // 策略编码，唯一标识
|
|
|
Name string // 策略名称
|
|
|
Description string // 策略描述
|
|
|
Resource string // 资源类型: user/org/member/policy/role/*
|
|
|
Action string // 操作: create/read/update/delete/*
|
|
|
Effect string // 效果: allow/deny
|
|
|
Condition string // 条件表达式
|
|
|
Priority int // 优先级: 数字越大优先级越高
|
|
|
IsSystem bool // 是否系统策略
|
|
|
}
|
|
|
```
|
|
|
|
|
|
**策略分类：**
|
|
|
|
|
|
**平台级策略** (无 org_id 上下文)
|
|
|
| 策略 | 资源 | 操作 | 效果 | 条件 | 说明 |
|
|
|
|------|------|------|------|------|------|
|
|
|
| user:read:own | user | read | allow | owner | 读取自己的用户信息 |
|
|
|
| user:update:own | user | update | allow | owner | 更新自己的用户信息 |
|
|
|
| binding:manage | binding | * | allow | - | 管理第三方账号绑定 |
|
|
|
| org:create | org | create | allow | - | 创建新项目 |
|
|
|
|
|
|
**项目级策略** (需要 org_id 上下文)
|
|
|
| 策略 | 资源 | 操作 | 效果 | 条件 | 说明 |
|
|
|
|------|------|------|------|------|------|
|
|
|
| org:admin | * | * | allow | org_owner | 项目所有者拥有所有权限 |
|
|
|
| org:update | org | update | allow | admin | 更新项目设置 |
|
|
|
| member:read | member | read | allow | member | 读取项目成员列表 |
|
|
|
| member:manage | member | * | allow | admin | 管理项目成员 |
|
|
|
| resource:create | resource | create | allow | developer | 创建项目资源 |
|
|
|
| resource:delete | resource | delete | allow | admin | 删除项目资源 |
|
|
|
|
|
|
### 2.4 角色 (Role)
|
|
|
|
|
|
角色是一组策略的集合，在项目级别定义。
|
|
|
|
|
|
**角色结构：**
|
|
|
|
|
|
```go
|
|
|
type Role struct {
|
|
|
ID string // 角色ID
|
|
|
OrgID string // 所属项目
|
|
|
Name string // 角色名称
|
|
|
Description string // 角色描述
|
|
|
PolicyIDs []string // 关联的策略ID列表
|
|
|
Scope string // 作用域: project/resource
|
|
|
IsSystem bool // 是否系统角色
|
|
|
}
|
|
|
```
|
|
|
|
|
|
**系统内置角色：**
|
|
|
|
|
|
| 角色 | 适用对象 | 权限范围 | 说明 |
|
|
|
|------|----------|----------|------|
|
|
|
| **owner** | 项目所有者 | 全部权限 | 项目的创建者，拥有所有权限，可删除项目 |
|
|
|
| **admin** | 管理员 | 项目级管理 | 管理项目设置、成员、资源，但不能删除项目 |
|
|
|
| **developer** | 开发者 | 资源级操作 | 创建和管理资源（数据库、存储、函数） |
|
|
|
| **viewer** | 访客 | 只读访问 | 只能查看项目和资源信息，不能修改 |
|
|
|
|
|
|
### 2.4 条件 (Condition)
|
|
|
|
|
|
条件用于实现 ABAC，支持以下类型：
|
|
|
|
|
|
| 条件 | 说明 | 使用场景 |
|
|
|
|------|------|----------|
|
|
|
| "" | 无条件，始终匹配 | 通用权限 |
|
|
|
| "owner" | 资源所有者 | 只能操作自己的数据 |
|
|
|
| "org_member" | 项目成员 | 项目内数据访问 |
|
|
|
| "org_owner" | 项目所有者 | 项目所有者权限判断 |
|
|
|
|
|
|
---
|
|
|
|
|
|
## 3. 权限检查流程
|
|
|
|
|
|
### 3.1 权限检查流程
|
|
|
|
|
|
根据是否有项目上下文 (`org_id`)，权限检查分为两种方式：
|
|
|
|
|
|
#### 流程 A: 平台级权限检查 (无项目上下文)
|
|
|
|
|
|
```
|
|
|
┌─────────────────────────────┐
|
|
|
│ 请求进入 (无 org_id) │
|
|
|
│ user, resource, action │
|
|
|
└────────────┬────────────────┘
|
|
|
│
|
|
|
▼
|
|
|
┌─────────────────────────────┐ 命中 ┌─────────────────┐
|
|
|
│ 检查缓存 │────────────→│ 返回缓存结果 │
|
|
|
└────────────┬────────────────┘ └─────────────────┘
|
|
|
│ 未命中
|
|
|
▼
|
|
|
┌─────────────────────────────┐
|
|
|
│ 1. 检查是否是资源所有者 │
|
|
|
│ owner_id == user_id │
|
|
|
└────────────┬────────────────┘
|
|
|
│ 是
|
|
|
▼
|
|
|
┌──────────┐
|
|
|
│ 返回 Allow│
|
|
|
└──────────┘
|
|
|
│ 否
|
|
|
▼
|
|
|
┌─────────────────────────────┐
|
|
|
│ 2. 加载平台级默认策略 │
|
|
|
│ personal:* 策略 │
|
|
|
└────────────┬────────────────┘
|
|
|
│
|
|
|
▼
|
|
|
┌─────────────────────────────┐
|
|
|
│ 3. 评估策略 (Deny优先) │
|
|
|
└────────────┬────────────────┘
|
|
|
│
|
|
|
┌─────┴─────┐
|
|
|
▼ ▼
|
|
|
┌───────┐ ┌───────┐
|
|
|
│ Deny │ │ Allow │
|
|
|
└───────┘ └───────┘
|
|
|
```
|
|
|
|
|
|
#### 流程 B: 项目级权限检查 (有项目上下文)
|
|
|
|
|
|
```
|
|
|
┌─────────────────────────────┐
|
|
|
│ 请求进入 (有 org_id) │
|
|
|
│ user, org_id, resource... │
|
|
|
└────────────┬────────────────┘
|
|
|
│
|
|
|
▼
|
|
|
┌─────────────────────────────┐ 命中 ┌─────────────────┐
|
|
|
│ 检查缓存 │────────────→│ 返回缓存结果 │
|
|
|
└────────────┬────────────────┘ └─────────────────┘
|
|
|
│ 未命中
|
|
|
▼
|
|
|
┌─────────────────────────────┐
|
|
|
│ 1. 检查是否是项目所有者 │
|
|
|
│ org.owner_id == user_id │────────┐
|
|
|
└────────────┬────────────────┘ │
|
|
|
│ 是 │
|
|
|
▼ │
|
|
|
┌──────────┐ │
|
|
|
│ 返回 Allow│───────────────────┘
|
|
|
└──────────┘
|
|
|
│ 否
|
|
|
▼
|
|
|
┌─────────────────────────────┐
|
|
|
│ 2. 获取用户在项目的角色 │
|
|
|
│ 从 OrgMember 表查询 │
|
|
|
└────────────┬────────────────┘
|
|
|
│
|
|
|
▼
|
|
|
┌─────────────────────────────┐
|
|
|
│ 3. 获取角色关联的策略 │
|
|
|
└────────────┬────────────────┘
|
|
|
│
|
|
|
▼
|
|
|
┌─────────────────────────────┐
|
|
|
│ 4. 评估策略 (Deny优先) │
|
|
|
│ Deny策略 → Allow策略 │
|
|
|
└────────────┬────────────────┘
|
|
|
│
|
|
|
┌─────┴─────┐
|
|
|
▼ ▼
|
|
|
┌───────┐ ┌───────┐
|
|
|
│ Deny │ │ Allow │
|
|
|
└───────┘ └───────┘
|
|
|
```
|
|
|
|
|
|
### 3.2 决策规则
|
|
|
|
|
|
1. **Deny 优先**: 如果匹配到 Deny 策略，直接拒绝
|
|
|
2. **显式 Allow**: 必须匹配到 Allow 策略才允许
|
|
|
3. **默认拒绝**: 未匹配到任何策略时拒绝
|
|
|
4. **优先级**: 高优先级策略优先匹配
|
|
|
|
|
|
---
|
|
|
|
|
|
## 4. 使用指南
|
|
|
|
|
|
### 4.1 平台级权限检查
|
|
|
|
|
|
**场景**：用户管理自己的账号、创建新项目
|
|
|
|
|
|
```go
|
|
|
// 检查用户是否可以更新自己的信息
|
|
|
// orgID 传空字符串，表示平台级检查
|
|
|
result, err := checker.Check(userID, "", "user", "update", map[string]any{
|
|
|
"owner_id": userID, // 传入自己的ID
|
|
|
})
|
|
|
// 结果：允许（满足 owner 条件）
|
|
|
|
|
|
// 检查用户是否可以创建新项目
|
|
|
result, err := checker.Check(userID, "", "org", "create", nil)
|
|
|
// 结果：允许（平台级默认策略允许创建项目）
|
|
|
|
|
|
// 检查用户是否可以更新其他用户信息
|
|
|
result, err := checker.Check(userID, "", "user", "update", map[string]any{
|
|
|
"owner_id": otherUserID, // 传入他人ID
|
|
|
})
|
|
|
// 结果：拒绝（不满足 owner 条件）
|
|
|
```
|
|
|
|
|
|
### 4.2 项目级权限检查
|
|
|
|
|
|
**场景**：在项目内操作资源
|
|
|
|
|
|
```go
|
|
|
// 检查用户在项目内是否有管理员权限
|
|
|
result, err := checker.Check(userID, "project-123", "member", "invite", nil)
|
|
|
// 结果取决于用户在 project-123 中的角色
|
|
|
|
|
|
// 项目所有者检查（快速路径）
|
|
|
// 如果 userID == org.OwnerID，直接返回允许
|
|
|
|
|
|
// 普通成员检查
|
|
|
// 1. 查询 OrgMember 获取角色
|
|
|
// 2. 查询 Role 获取策略
|
|
|
// 3. 评估策略
|
|
|
```
|
|
|
|
|
|
### 4.3 完整示例：更新用户信息
|
|
|
|
|
|
```go
|
|
|
func UpdateUser(x *vigo.X, req *UpdateRequest) error {
|
|
|
userID := middleware.CurrentUser(x)
|
|
|
targetUserID := req.UserID
|
|
|
|
|
|
checker := service.NewPermissionChecker()
|
|
|
|
|
|
// 场景1: 更新自己的信息（平台级）
|
|
|
if targetUserID == userID {
|
|
|
result, err := checker.Check(userID, "", "user", "update", map[string]any{
|
|
|
"owner_id": userID,
|
|
|
})
|
|
|
if err != nil || !result.Allowed {
|
|
|
return vigo.ErrForbidden.WithString(result.Reason)
|
|
|
}
|
|
|
// 执行更新...
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
// 场景2: 管理员更新其他用户信息（需要平台级管理员权限）
|
|
|
result, err := checker.Check(userID, "", "user", "update", nil)
|
|
|
if err != nil || !result.Allowed {
|
|
|
return vigo.ErrForbidden.WithString("only admin can update other users")
|
|
|
}
|
|
|
// 执行更新...
|
|
|
return nil
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 4.4 完整示例：项目内操作
|
|
|
|
|
|
```go
|
|
|
func DeleteProjectResource(x *vigo.X, req *DeleteResourceRequest) error {
|
|
|
userID := middleware.CurrentUser(x)
|
|
|
orgID := middleware.CurrentOrg(x) // 从请求头 X-Org-ID 获取
|
|
|
|
|
|
if orgID == "" {
|
|
|
return vigo.ErrArgInvalid.WithString("org_id required")
|
|
|
}
|
|
|
|
|
|
checker := service.NewPermissionChecker()
|
|
|
|
|
|
// 检查用户在项目内是否有删除资源的权限
|
|
|
result, err := checker.Check(userID, orgID, "resource", "delete", map[string]any{
|
|
|
"resource_id": req.ResourceID,
|
|
|
})
|
|
|
|
|
|
if err != nil || !result.Allowed {
|
|
|
return vigo.ErrForbidden.WithString(result.Reason)
|
|
|
}
|
|
|
|
|
|
// 执行删除...
|
|
|
return nil
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 4.5 创建自定义策略
|
|
|
|
|
|
```go
|
|
|
// 项目级策略（需要关联到具体项目）
|
|
|
policy := &model.Policy{
|
|
|
Code: "custom:db:admin",
|
|
|
Name: "数据库管理员",
|
|
|
Description: "管理项目数据库",
|
|
|
Resource: "database",
|
|
|
Action: "*", // 所有操作
|
|
|
Effect: model.EffectAllow,
|
|
|
Condition: "", // 无条件限制
|
|
|
Scope: "project", // 项目级策略
|
|
|
OrgID: "project-123", // 所属项目
|
|
|
}
|
|
|
model.DB.Create(policy)
|
|
|
|
|
|
// 将策略添加到角色
|
|
|
role := &model.Role{
|
|
|
OrgID: "project-123",
|
|
|
Name: "DBAdmin",
|
|
|
PolicyIDs: "custom:db:admin",
|
|
|
}
|
|
|
model.DB.Create(role)
|
|
|
|
|
|
// 分配角色给用户
|
|
|
member := &model.OrgMember{
|
|
|
OrgID: "project-123",
|
|
|
UserID: "user-456",
|
|
|
RoleIDs: role.ID,
|
|
|
}
|
|
|
model.DB.Create(member)
|
|
|
```
|
|
|
|
|
|
---
|
|
|
|
|
|
## 5. 系统内置策略
|
|
|
|
|
|
### 5.1 用户相关
|
|
|
|
|
|
```go
|
|
|
// 读取自己
|
|
|
SysPolicyUserReadOwn = "sys:user:read:own"
|
|
|
Resource: "user"
|
|
|
Action: "read"
|
|
|
Condition: "owner"
|
|
|
|
|
|
// 更新自己
|
|
|
SysPolicyUserUpdateOwn = "sys:user:update:own"
|
|
|
Resource: "user"
|
|
|
Action: "update"
|
|
|
Condition: "owner"
|
|
|
|
|
|
// 删除自己
|
|
|
SysPolicyUserDeleteOwn = "sys:user:delete:own"
|
|
|
Resource: "user"
|
|
|
Action: "delete"
|
|
|
Condition: "owner"
|
|
|
```
|
|
|
|
|
|
### 5.2 组织相关
|
|
|
|
|
|
```go
|
|
|
// 组织管理员
|
|
|
SysPolicyOrgAdmin = "sys:org:admin"
|
|
|
Resource: "*"
|
|
|
Action: "*"
|
|
|
Condition: "org_owner"
|
|
|
Priority: 100
|
|
|
|
|
|
// 读取组织
|
|
|
SysPolicyOrgRead = "sys:org:read"
|
|
|
Resource: "org"
|
|
|
Action: "read"
|
|
|
Condition: "org_member"
|
|
|
```
|
|
|
|
|
|
### 5.3 成员相关
|
|
|
|
|
|
```go
|
|
|
// 读取成员
|
|
|
SysPolicyMemberRead = "sys:member:read"
|
|
|
Resource: "member"
|
|
|
Action: "read"
|
|
|
Condition: "org_member"
|
|
|
|
|
|
// 管理成员
|
|
|
SysPolicyMemberManage = "sys:member:manage"
|
|
|
Resource: "member"
|
|
|
Action: "*"
|
|
|
Condition: ""
|
|
|
```
|
|
|
|
|
|
### 5.4 角色策略相关
|
|
|
|
|
|
```go
|
|
|
// 读取角色
|
|
|
SysPolicyRoleRead = "sys:role:read"
|
|
|
Resource: "role"
|
|
|
Action: "read"
|
|
|
Condition: "org_member"
|
|
|
|
|
|
// 管理角色
|
|
|
SysPolicyRoleManage = "sys:role:manage"
|
|
|
Resource: "role"
|
|
|
Action: "*"
|
|
|
Condition: "admin"
|
|
|
|
|
|
// 读取策略
|
|
|
SysPolicyPolicyRead = "sys:policy:read"
|
|
|
Resource: "policy"
|
|
|
Action: "read"
|
|
|
Condition: "org_member"
|
|
|
|
|
|
// 管理策略
|
|
|
SysPolicyPolicyManage = "sys:policy:manage"
|
|
|
Resource: "policy"
|
|
|
Action: "*"
|
|
|
Condition: "admin"
|
|
|
```
|
|
|
|
|
|
### 5.5 资源级策略（BaaS 核心资源）
|
|
|
|
|
|
**数据库资源 (database)**
|
|
|
|
|
|
```go
|
|
|
// 查询数据库
|
|
|
SysPolicyDBRead = "sys:db:read"
|
|
|
Resource: "database"
|
|
|
Action: "read"
|
|
|
Condition: "org_member"
|
|
|
|
|
|
// 管理数据库（创建表、修改结构）
|
|
|
SysPolicyDBManage = "sys:db:manage"
|
|
|
Resource: "database"
|
|
|
Action: "*"
|
|
|
Condition: "developer"
|
|
|
```
|
|
|
|
|
|
**存储资源 (storage)**
|
|
|
|
|
|
```go
|
|
|
// 读取存储文件
|
|
|
SysPolicyStorageRead = "sys:storage:read"
|
|
|
Resource: "storage"
|
|
|
Action: "read"
|
|
|
Condition: "org_member"
|
|
|
|
|
|
// 上传/删除文件
|
|
|
SysPolicyStorageWrite = "sys:storage:write"
|
|
|
Resource: "storage"
|
|
|
Action: "create,update,delete"
|
|
|
Condition: "developer"
|
|
|
|
|
|
// 管理存储桶
|
|
|
SysPolicyStorageAdmin = "sys:storage:admin"
|
|
|
Resource: "storage"
|
|
|
Action: "*"
|
|
|
Condition: "admin"
|
|
|
```
|
|
|
|
|
|
**函数资源 (function)**
|
|
|
|
|
|
```go
|
|
|
// 调用函数
|
|
|
SysPolicyFunctionCall = "sys:function:call"
|
|
|
Resource: "function"
|
|
|
Action: "call"
|
|
|
Condition: "org_member"
|
|
|
|
|
|
// 管理函数（部署、删除）
|
|
|
SysPolicyFunctionManage = "sys:function:manage"
|
|
|
Resource: "function"
|
|
|
Action: "create,update,delete"
|
|
|
Condition: "developer"
|
|
|
```
|
|
|
|
|
|
**API 密钥管理 (apikey)**
|
|
|
|
|
|
```go
|
|
|
// 读取 API 密钥（只能读取自己创建的密钥）
|
|
|
SysPolicyAPIKeyRead = "sys:apikey:read"
|
|
|
Resource: "apikey"
|
|
|
Action: "read"
|
|
|
Condition: "owner"
|
|
|
|
|
|
// 管理 API 密钥
|
|
|
SysPolicyAPIKeyManage = "sys:apikey:manage"
|
|
|
Resource: "apikey"
|
|
|
Action: "*"
|
|
|
Condition: "developer"
|
|
|
```
|
|
|
|
|
|
### 5.6 平台超级管理员策略
|
|
|
|
|
|
```go
|
|
|
// 超级管理员 - 拥有所有权限
|
|
|
SysPolicySuperAdmin = "sys:super:admin"
|
|
|
Resource: "*"
|
|
|
Action: "*"
|
|
|
Condition: "is_super_admin"
|
|
|
Priority: 999
|
|
|
```
|
|
|
|
|
|
---
|
|
|
|
|
|
## 6. 权限缓存
|
|
|
|
|
|
### 6.1 缓存机制
|
|
|
|
|
|
```
|
|
|
缓存键: perm:{user_id}:{org_id}:{resource}:{action}
|
|
|
TTL: 1分钟
|
|
|
值: "allow" 或 "deny"
|
|
|
```
|
|
|
|
|
|
### 6.2 缓存失效
|
|
|
|
|
|
以下操作会触发缓存清除：
|
|
|
|
|
|
- 用户角色变更
|
|
|
- 角色策略变更
|
|
|
- 策略内容变更
|
|
|
- 组织成员变更
|
|
|
|
|
|
```go
|
|
|
// 清除用户权限缓存
|
|
|
service.ClearUserPermissionCache(userID)
|
|
|
|
|
|
// 清除组织权限缓存
|
|
|
service.ClearOrgPermissionCache(orgID)
|
|
|
```
|
|
|
|
|
|
### 6.3 缓存命中率优化
|
|
|
|
|
|
- 权限变更频率低，1分钟 TTL 平衡了性能和实时性
|
|
|
- 批量操作时建议先清除缓存，操作完成后统一刷新
|
|
|
|
|
|
---
|
|
|
|
|
|
## 7. 最佳实践
|
|
|
|
|
|
### 7.1 策略设计
|
|
|
|
|
|
1. **最小权限原则**: 只授予完成任务所需的最小权限
|
|
|
2. **职责分离**: 敏感操作需要多个角色共同完成
|
|
|
3. **策略命名规范**: `{resource}:{action}:{condition}`
|
|
|
|
|
|
### 7.2 BaaS 平台角色设计
|
|
|
|
|
|
VBase 作为 Supabase-like BaaS 平台，角色设计覆盖 **2C个人开发者** 和 **2B团队/企业** 场景：
|
|
|
|
|
|
#### 2C 个人开发者场景
|
|
|
|
|
|
```
|
|
|
个人项目角色体系:
|
|
|
├── owner (项目所有者)
|
|
|
│ └── 全部权限（可以删除项目）
|
|
|
└── developer (开发者)
|
|
|
└── 读写资源、调用 API
|
|
|
```
|
|
|
|
|
|
个人开发者通常自己就是项目所有者，不需要复杂的角色体系。
|
|
|
|
|
|
#### 2B 团队协作场景
|
|
|
|
|
|
```
|
|
|
团队项目角色体系:
|
|
|
├── owner (所有者)
|
|
|
│ └── 全部权限、可删除项目、管理账单
|
|
|
├── admin (管理员)
|
|
|
│ └── 管理成员、角色、资源设置
|
|
|
├── developer (开发者)
|
|
|
│ ├── 数据库: 创建表、查询、修改结构
|
|
|
│ ├── 存储: 上传/下载文件、管理存储桶
|
|
|
│ ├── 函数: 部署、调用、删除函数
|
|
|
│ └── API密钥: 创建、管理
|
|
|
├── viewer (访客/只读)
|
|
|
│ └── 查看数据、只读访问
|
|
|
└── auditor (审计员 - 可选)
|
|
|
└── 查看日志、审计记录
|
|
|
```
|
|
|
|
|
|
#### 角色权限对照表
|
|
|
|
|
|
| 角色 | 成员管理 | 资源管理 | 数据读写 | API密钥 | 项目设置 |
|
|
|
|------|----------|----------|----------|---------|----------|
|
|
|
| **owner** | ✓ | ✓ | ✓ | ✓ | ✓ |
|
|
|
| **admin** | ✓ | ✓ | ✓ | ✓ | ✗ |
|
|
|
| **developer** | ✗ | ✓ | ✓ | ✓ | ✗ |
|
|
|
| **viewer** | ✗ | ✗ | 只读 | ✗ | ✗ |
|
|
|
|
|
|
#### 系统角色配置示例
|
|
|
|
|
|
```go
|
|
|
// Owner 角色 - 绑定所有权限
|
|
|
var RoleOwner = model.Role{
|
|
|
Name: "owner",
|
|
|
Description: "项目所有者",
|
|
|
PolicyIDs: "sys:org:admin,sys:member:manage,sys:role:manage,sys:policy:manage",
|
|
|
IsSystem: true,
|
|
|
}
|
|
|
|
|
|
// Admin 角色 - 管理权限
|
|
|
var RoleAdmin = model.Role{
|
|
|
Name: "admin",
|
|
|
Description: "项目管理员",
|
|
|
PolicyIDs: "sys:member:manage,sys:role:read,sys:db:manage,sys:storage:admin,sys:function:manage",
|
|
|
IsSystem: true,
|
|
|
}
|
|
|
|
|
|
// Developer 角色 - 开发权限
|
|
|
var RoleDeveloper = model.Role{
|
|
|
Name: "developer",
|
|
|
Description: "开发者",
|
|
|
PolicyIDs: "sys:db:manage,sys:storage:write,sys:function:manage,sys:apikey:manage",
|
|
|
IsSystem: true,
|
|
|
}
|
|
|
|
|
|
// Viewer 角色 - 只读权限
|
|
|
var RoleViewer = model.Role{
|
|
|
Name: "viewer",
|
|
|
Description: "访客",
|
|
|
PolicyIDs: "sys:org:read,sys:db:read,sys:storage:read,sys:function:call",
|
|
|
IsSystem: true,
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 7.3 权限检查位置
|
|
|
|
|
|
**Controller 层检查:**
|
|
|
```go
|
|
|
func Handler(x *vigo.X) error {
|
|
|
// 先检查权限
|
|
|
if !hasPermission(x, "resource", "action") {
|
|
|
return vigo.ErrForbidden
|
|
|
}
|
|
|
// 执行业务逻辑
|
|
|
}
|
|
|
```
|
|
|
|
|
|
**Service 层检查（数据级）:**
|
|
|
```go
|
|
|
func UpdateUser(userID string, data map[string]any) error {
|
|
|
// 检查是否是本人或管理员
|
|
|
if !isOwner(userID) && !hasAdminRole() {
|
|
|
return ErrForbidden
|
|
|
}
|
|
|
// 执行更新
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 7.4 BaaS 平台权限场景示例
|
|
|
|
|
|
**场景1: 个人开发者创建项目**
|
|
|
|
|
|
```go
|
|
|
// 小明是个人开发者，注册后创建项目
|
|
|
// 1. 创建项目（平台级权限检查）
|
|
|
result, _ := checker.Check("xiaoming_user_id", "", "org", "create", nil)
|
|
|
// 结果: 允许（personal:org:create 策略）
|
|
|
|
|
|
// 2. 小明成为项目所有者
|
|
|
// org.owner_id = "xiaoming_user_id"
|
|
|
|
|
|
// 3. 小明在项目内操作数据库（项目级权限）
|
|
|
result, _ = checker.Check("xiaoming_user_id", "my-project", "database", "create", nil)
|
|
|
// 结果: 允许（小明是项目所有者）
|
|
|
```
|
|
|
|
|
|
**场景2: 团队协作开发**
|
|
|
|
|
|
```go
|
|
|
// CEO 创建 WebApp 项目，邀请 CTO 为管理员，员工为开发者
|
|
|
// - CEO: owner
|
|
|
// - CTO: admin
|
|
|
// - 员工A: developer
|
|
|
// - 外包人员: viewer
|
|
|
|
|
|
// CTO 邀请成员（有 member:manage 权限）
|
|
|
result, _ := checker.Check("cto_user_id", "webapp-project", "member", "create", nil)
|
|
|
// 结果: 允许（admin 角色有 member:manage 策略）
|
|
|
|
|
|
// 员工A 创建数据库表（有 db:manage 权限）
|
|
|
result, _ = checker.Check("employee_a_id", "webapp-project", "database", "create", nil)
|
|
|
// 结果: 允许（developer 角色有 db:manage 策略）
|
|
|
|
|
|
// 外包人员 尝试删除表（viewer 没有 delete 权限）
|
|
|
result, _ = checker.Check("contractor_id", "webapp-project", "database", "delete", nil)
|
|
|
// 结果: 拒绝（viewer 只有 db:read 权限）
|
|
|
```
|
|
|
|
|
|
**场景3: API 密钥访问控制**
|
|
|
|
|
|
```go
|
|
|
// 开发者创建 API 密钥用于后端服务
|
|
|
// 只能查看自己创建的密钥
|
|
|
|
|
|
result, _ := checker.Check("developer_id", "project-123", "apikey", "read", map[string]any{
|
|
|
"owner_id": "developer_id",
|
|
|
})
|
|
|
// 结果: 允许（满足 owner 条件）
|
|
|
|
|
|
// 尝试查看他人创建的密钥
|
|
|
result, _ = checker.Check("developer_id", "project-123", "apikey", "read", map[string]any{
|
|
|
"owner_id": "other_developer_id",
|
|
|
})
|
|
|
// 结果: 拒绝（不满足 owner 条件）
|
|
|
```
|
|
|
|
|
|
**场景4: 跨项目资源访问**
|
|
|
|
|
|
```go
|
|
|
// 用户小明在 project-A 是开发者，在 project-B 是访客
|
|
|
|
|
|
// 在 project-A 上传文件
|
|
|
result, _ := checker.Check("xiaoming_id", "project-A", "storage", "create", nil)
|
|
|
// 结果: 允许（developer 角色有 storage:write 权限）
|
|
|
|
|
|
// 在 project-B 上传文件
|
|
|
result, _ = checker.Check("xiaoming_id", "project-B", "storage", "create", nil)
|
|
|
// 结果: 拒绝（viewer 角色只有 storage:read 权限）
|
|
|
```
|
|
|
|
|
|
### 7.5 权限测试
|
|
|
|
|
|
```go
|
|
|
func TestPermissionCheck(t *testing.T) {
|
|
|
tests := []struct {
|
|
|
name string
|
|
|
userID string
|
|
|
orgID string
|
|
|
resource string
|
|
|
action string
|
|
|
data map[string]any
|
|
|
want bool
|
|
|
}{
|
|
|
{
|
|
|
name: "owner can update own profile",
|
|
|
userID: "user1",
|
|
|
orgID: "",
|
|
|
resource: "user",
|
|
|
action: "update",
|
|
|
data: map[string]any{"owner_id": "user1"},
|
|
|
want: true,
|
|
|
},
|
|
|
{
|
|
|
name: "user cannot update others profile",
|
|
|
userID: "user1",
|
|
|
orgID: "",
|
|
|
resource: "user",
|
|
|
action: "update",
|
|
|
data: map[string]any{"owner_id": "user2"},
|
|
|
want: false,
|
|
|
},
|
|
|
}
|
|
|
|
|
|
checker := service.NewPermissionChecker()
|
|
|
for _, tt := range tests {
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
result, _ := checker.Check(tt.userID, tt.orgID, tt.resource, tt.action, tt.data)
|
|
|
if result.Allowed != tt.want {
|
|
|
t.Errorf("Check() = %v, want %v", result.Allowed, tt.want)
|
|
|
}
|
|
|
})
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
---
|
|
|
|
|
|
## 8. 故障排查
|
|
|
|
|
|
### 8.1 权限检查失败
|
|
|
|
|
|
**检查步骤：**
|
|
|
|
|
|
**平台级权限检查失败（org_id 为空）:**
|
|
|
|
|
|
1. 确认用户已登录
|
|
|
2. 确认操作的是自己的资源（检查 owner_id 条件）
|
|
|
3. 检查用户是否有平台级管理员权限
|
|
|
4. 检查默认个人策略是否生效
|
|
|
|
|
|
**项目级权限检查失败（有 org_id）:**
|
|
|
|
|
|
1. 确认用户是项目成员（OrgMember 状态为 active）
|
|
|
2. 检查用户角色是否正确分配
|
|
|
3. 检查角色绑定的策略
|
|
|
4. 检查策略的 Effect 和 Condition
|
|
|
5. 确认资源所属的项目是否正确
|
|
|
|
|
|
**调试日志：**
|
|
|
|
|
|
```go
|
|
|
// 开启调试日志
|
|
|
checker := service.NewPermissionChecker()
|
|
|
result, err := checker.Check(userID, orgID, resource, action, data)
|
|
|
log.Printf("Permission check: user=%s, resource=%s, action=%s, allowed=%v, reason=%s",
|
|
|
userID, resource, action, result.Allowed, result.Reason)
|
|
|
```
|
|
|
|
|
|
### 8.2 缓存问题
|
|
|
|
|
|
```bash
|
|
|
# 清除 Redis 权限缓存
|
|
|
redis-cli KEYS "perm:*" | xargs redis-cli DEL
|
|
|
|
|
|
# 或重启应用（开发环境）
|
|
|
```
|
|
|
|
|
|
### 8.3 权限不生效
|
|
|
|
|
|
1. 检查策略是否保存成功
|
|
|
2. 检查角色是否正确绑定策略
|
|
|
3. 检查用户是否正确分配角色
|
|
|
4. 检查缓存是否已清除
|
|
|
|
|
|
---
|
|
|
|
|
|
## 9. 扩展开发
|
|
|
|
|
|
### 9.1 添加自定义条件
|
|
|
|
|
|
```go
|
|
|
// 在 permission.go 中扩展 evaluateCondition
|
|
|
func (pc *PermissionChecker) evaluateCondition(p *model.Policy, userID, orgID string, resourceData map[string]any) bool {
|
|
|
switch p.Condition {
|
|
|
case "owner":
|
|
|
// 现有逻辑...
|
|
|
case "custom_condition":
|
|
|
// 自定义条件逻辑
|
|
|
return checkCustomCondition(userID, orgID, resourceData)
|
|
|
default:
|
|
|
return true
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 9.2 添加 BaaS 资源类型
|
|
|
|
|
|
**步骤1: 定义资源常量**
|
|
|
|
|
|
```go
|
|
|
// 在 policy.go 中添加资源常量
|
|
|
const (
|
|
|
ResourceUser = "user"
|
|
|
ResourceOrg = "org"
|
|
|
ResourceMember = "member"
|
|
|
ResourceDatabase = "database"
|
|
|
ResourceStorage = "storage"
|
|
|
ResourceFunction = "function"
|
|
|
ResourceAPIKey = "apikey"
|
|
|
ResourceCustom = "custom_resource" // 新增资源类型
|
|
|
)
|
|
|
```
|
|
|
|
|
|
**步骤2: 创建资源级策略**
|
|
|
|
|
|
```go
|
|
|
// 为新增资源创建策略
|
|
|
func (pc *PermissionChecker) getCustomResourcePolicies() []model.Policy {
|
|
|
return []model.Policy{
|
|
|
{
|
|
|
Code: "custom:read",
|
|
|
Name: "读取自定义资源",
|
|
|
Resource: ResourceCustom,
|
|
|
Action: "read",
|
|
|
Effect: model.EffectAllow,
|
|
|
Condition: "org_member",
|
|
|
},
|
|
|
{
|
|
|
Code: "custom:manage",
|
|
|
Name: "管理自定义资源",
|
|
|
Resource: ResourceCustom,
|
|
|
Action: "create,update,delete",
|
|
|
Effect: model.EffectAllow,
|
|
|
Condition: "developer",
|
|
|
},
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
**步骤3: 在角色中使用**
|
|
|
|
|
|
```go
|
|
|
// 创建新角色使用自定义策略
|
|
|
customRole := &model.Role{
|
|
|
OrgID: orgID,
|
|
|
Name: "custom_manager",
|
|
|
Description: "自定义资源管理员",
|
|
|
PolicyIDs: "custom:read,custom:manage",
|
|
|
Scope: "resource",
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 9.3 多租户资源隔离
|
|
|
|
|
|
在 BaaS 平台中，资源需要严格的项目隔离：
|
|
|
|
|
|
```go
|
|
|
// 查询时自动添加 org_id 过滤
|
|
|
func ListResources(userID, orgID string) ([]Resource, error) {
|
|
|
// 检查用户在项目中的权限
|
|
|
checker := service.NewPermissionChecker()
|
|
|
result, err := checker.Check(userID, orgID, "custom_resource", "read", nil)
|
|
|
if err != nil || !result.Allowed {
|
|
|
return nil, vigo.ErrForbidden
|
|
|
}
|
|
|
|
|
|
// 查询该项目的资源（自动隔离）
|
|
|
var resources []Resource
|
|
|
err = model.DB.Where("org_id = ?", orgID).Find(&resources).Error
|
|
|
return resources, err
|
|
|
}
|
|
|
```
|
|
|
|
|
|
---
|
|
|
|
|
|
## 10. 参考
|
|
|
|
|
|
- [RBAC 模型](https://en.wikipedia.org/wiki/Role-based_access_control)
|
|
|
- [ABAC 模型](https://en.wikipedia.org/wiki/Attribute-based_access_control)
|
|
|
- [NIST RBAC 标准](https://csrc.nist.gov/projects/role-based-access-control)
|