Demo 级项目：一个用户，所有权限，数据混在一起 → 能跑就行企业级平台：N 个租户 × M 个角色 × K 种资源 → 安全是生命线

用户(User) ──N:M──→ 角色(Role) ──1:N──→ 权限(Permission)   │                    │                      │ 张三               ”部门管理员”          ”kb:read”, ”kb:write”, 李四               ”普通成员”            ”agent:read” 王五               ”平台管理员”          ”ALL”

# 万悟真实源码结构（Go 单体仓库）internal/iam-service/# 身份与租户服务（gRPC 微服务）├── client/# IAM 客户端├── config/# 认证配置└── server/grpc/# gRPC 服务入口（用户/角色/权限/租户 CRUD）internal/bff-service/# BFF 网关（HTTP 入口，中间件挂载点）# 认证 → 租户注入 → 限流 → 鉴权 中间件链在此pkg/rsa-util/# RSA 加解密工具（密钥管理）# 万悟使用 Casbin 作为 RBAC 策略引擎，非自研权限框架

// 教学重建版（对应真实路径：internal/bff-service/ 中间件 + internal/iam-service/ JWT 验证）// AuthMiddleware 是全局认证中间件// 每个请求都必须经过这里funcAuthMiddleware(jwtService *JWTService) gin.HandlerFunc {    return func(c *gin.Context) {        // Step 1: 提取 Token        // 支持两种来源：Authorization Header 或 API Key Header        token := c.GetHeader(”Authorization”)        apiKey := c.GetHeader(”X-API-Key”)        var claims *Claims        var err error        if token != ”” {            // JWT 认证（前端用户）            token = strings.TrimPrefix(token, ”Bearer ”)            claims, err = jwtService.Verify(token)            if err != nil {                c.AbortWithStatusJSON(401, gin.H{”error”: ”invalid or expired token”})                return            }        } else if apiKey != ”” {            // API Key 认证（服务间调用）            claims, err = jwtService.VerifyAPIKey(apiKey)            if err != nil {                c.AbortWithStatusJSON(401, gin.H{”error”: ”invalid api key”})                return            }        } else {            c.AbortWithStatusJSON(401, gin.H{”error”: ”authentication required”})            return        }        // Step 2: 将用户信息注入上下文        // 后续所有 handler 都可以从 context 中获取当前用户        c.Set(”user_id”, claims.UserID)        c.Set(”tenant_id”, claims.TenantID)   // ← 关键！租户 ID        c.Set(”roles”, claims.Roles)        c.Set(”space_id”, claims.SpaceID)        c.Next()    }}

// 教学重建版（对应真实路径：internal/bff-service/ 租户中间件）// TenantMiddleware 确保所有数据操作都在租户边界内funcTenantMiddleware() gin.HandlerFunc {    return func(c *gin.Context) {        tenantID := c.GetString(”tenant_id”)        if tenantID == ”” {            c.AbortWithStatusJSON(403, gin.H{”error”: ”tenant context missing”})            return        }        // 将 tenant_id 注入到数据库查询上下文        // 所有 Repository 层的方法都会从 context 中读取这个值        ctx := context.WithValue(c.Request.Context(), TenantKey, tenantID)        c.Request = c.Request.WithContext(ctx)        c.Next()    }}// ===== Repository 层示例 =====// 教学重建版（对应真实路径：internal/knowledge-service/ 数据查询层）// ListByTenant 查询知识库列表// 注意：tenant_id 从 context 中获取，而非参数传入// 这保证了”不可能忘记加租户过滤”func(r *KBRepository) List(ctx context.Context) ([]KnowledgeBase, error) {    tenantID := ctx.Value(TenantKey).(string)    var kbs []KnowledgeBase    // GORM 查询自动带租户过滤    err := r.db.WithContext(ctx).        Where(”tenant_id = ?”, tenantID).  // ← 强制隔离        Find(&kbs).Error    return kbs, err}

// 教学重建版（对应真实路径：Casbin 策略引擎 + internal/bff-service/ 鉴权中间件）// RequirePermission 是一个路由级中间件// 用法：router.GET(”/kb”, RequirePermission(”kb:read”), handler.ListKB)funcRequirePermission(requiredPerm string) gin.HandlerFunc {    return func(c *gin.Context) {        userID := c.GetString(”user_id”)        tenantID := c.GetString(”tenant_id”)        roles := c.GetStringSlice(”roles”)        // Step 1: 超级管理员直接放行        if contains(roles, ”super_admin”) {            c.Next()            return        }        // Step 2: 查询用户的所有权限（带缓存）        // 缓存策略：Redis，TTL 5 分钟        // Key: ”perms:{tenant_id}:{user_id}”        perms, err := getPermissionsWithCache(c, tenantID, userID)        if err != nil {            c.AbortWithStatusJSON(500, gin.H{”error”: ”permission check failed”})            return        }        // Step 3: 检查是否拥有所需权限        // 支持通配符：拥有 ”kb:*” 等同于拥有 ”kb:read”, ”kb:write”, ”kb:delete”        if !hasPermission(perms, requiredPerm) {            c.AbortWithStatusJSON(403, gin.H{                ”error”: fmt.Sprintf(”permission denied: requires '%s'”, requiredPerm),            })            return        }        c.Next()    }}// hasPermission 检查权限（支持通配符）funchasPermission(userPerms []string, required string) bool {    for _, p := range userPerms {        if p == required || p == ”*” {            return true        }        // 通配符匹配：”kb:*” 匹配 ”kb:read”        if strings.HasSuffix(p, ”:*”) {            prefix := strings.TrimSuffix(p, ”:*”)            if strings.HasPrefix(required, prefix+”:”) {                return true            }        }    }    return false}

// 教学重建版（对应真实路径：internal/iam-service/ 权限模型 + Casbin 策略）// 万悟的权限采用 ”资源:操作” 格式var AllPermissions = []string{    // 知识库    ”kb:read”, ”kb:write”, ”kb:delete”, ”kb:admin”,    // 智能体    ”agent:read”, ”agent:write”, ”agent:delete”, ”agent:admin”,    // 工作流    ”workflow:read”, ”workflow:write”, ”workflow:execute”, ”workflow:admin”,    // 模型    ”model:read”, ”model:write”, ”model:admin”,    // MCP 工具    ”mcp:read”, ”mcp:write”, ”mcp:admin”,    // 用户管理    ”user:read”, ”user:write”, ”user:admin”,    // 租户管理    ”tenant:admin”,    // 审计日志    ”audit:read”,}// 预定义角色var DefaultRoles = map[string][]string{    ”viewer”: {        ”kb:read”, ”agent:read”, ”workflow:read”, ”model:read”,    },    ”member”: {        ”kb:read”, ”kb:write”,        ”agent:read”, ”agent:write”,        ”workflow:read”, ”workflow:execute”,        ”model:read”,        ”mcp:read”,    },    ”admin”: {        ”kb:*”, ”agent:*”, ”workflow:*”, ”model:*”, ”mcp:*”,        ”user:read”, ”user:write”,        ”audit:read”,    },    ”super_admin”: {”*”},}

// 教学重建版（对应真实路径：internal/bff-service/ 限流中间件）// TenantRateLimiter 基于租户的 API 限流// 防止某个租户的大量请求影响其他租户funcTenantRateLimiter(redis *redis.Client) gin.HandlerFunc {    return func(c *gin.Context) {        tenantID := c.GetString(”tenant_id”)        // 从配置中获取该租户的限额        // 不同套餐：免费版 100 RPM，企业版 10000 RPM        limit := getTenantRateLimit(tenantID)        // 滑动窗口限流（Redis ZSET 实现）        key := fmt.Sprintf(”ratelimit:%s:%s”, tenantID, time.Now().Format(”200601021504”))        now := time.Now().UnixNano()        pipe := redis.Pipeline()        // 移除窗口外的记录        pipe.ZRemRangeByScore(c, key, ”0”, fmt.Sprintf(”%d”, now-int64(limit.Window)))        // 统计当前窗口内的请求数        countCmd := pipe.ZCard(c, key)        // 添加当前请求        pipe.ZAdd(c, key, &redis.Z{Score: float64(now), Member: now})        pipe.Expire(c, key, limit.Window*time.Second)        pipe.Exec(c)        count := countCmd.Val()        if count >= limit.MaxRequests {            c.AbortWithStatusJSON(429, gin.H{                ”error”: ”rate limit exceeded”,                ”retry_after”: limit.Window,            })            return        }        // 将剩余配额写入响应头（方便客户端感知）        c.Header(”X-RateLimit-Remaining”, fmt.Sprintf(”%d”, limit.MaxRequests-count))        c.Next()    }}

// 教学重建版（对应真实路径：internal/bff-service/ 路由注册）func SetupRoutes(r *gin.Engine) {    // 公开接口（无需认证）    public := r.Group(”/api/v1”)    {        public.POST(”/auth/login”, authHandler.Login)        public.POST(”/auth/register”, authHandler.Register)        public.GET(”/health”, healthHandler.Check)    }    // 需认证的接口    authorized := r.Group(”/api/v1”)    authorized.Use(        AuthMiddleware(jwtService),      // 1. 认证：你是谁？        TenantMiddleware(),              // 2. 租户：你属于哪个租户？        TenantRateLimiter(redisClient),  // 3. 限流：你的配额够吗？    )    {        // 知识库（需要 kb:read 权限）        kb := authorized.Group(”/knowledge-bases”)        kb.Use(RequirePermission(”kb:read”))        {            kb.GET(””, kbHandler.List)            kb.GET(”/:id”, kbHandler.Get)            // 写操作需要更高权限            kb.POST(””, RequirePermission(”kb:write”), kbHandler.Create)            kb.DELETE(”/:id”, RequirePermission(”kb:delete”), kbHandler.Delete)        }        // 智能体        agent := authorized.Group(”/agents”)        agent.Use(RequirePermission(”agent:read”))        {            agent.GET(””, agentHandler.List)            agent.POST(””, RequirePermission(”agent:write”), agentHandler.Create)            agent.POST(”/:id/chat”, agentHandler.Chat) // 对话只需 read        }        // 管理接口（需要 admin 权限）        admin := authorized.Group(”/admin”)        admin.Use(RequirePermission(”user:admin”))        {            admin.GET(”/users”, adminHandler.ListUsers)            admin.POST(”/roles”, adminHandler.CreateRole)            admin.GET(”/audit-logs”, RequirePermission(”audit:read”), adminHandler.AuditLogs)        }    }}

# 通过管理 API 创建受限 API Keycurl -X POST https://wanwu.example.com/api/v1/admin/api-keys \  -H ”Authorization: Bearer ” \  -H ”Content-Type: application/json” \  -d '{    ”name”: ”报表服务专用”,    ”permissions”: [”kb:read”, ”workflow:execute”],    ”expires_at”: ”2027-01-01T00:00:00Z”,    ”rate_limit”: 1000  }'# 响应{  ”api_key”: ”wk_live_a1b2c3d4e5f6...”,  ”name”: ”报表服务专用”,  ”permissions”: [”kb:read”, ”workflow:execute”],  ”created_at”: ”2026-08-01T11:00:00Z”}

# mini_rbac.py# 依赖：pip install flask pyjwtimport jwt, time, functoolsfrom flask import Flask, request, jsonify, gapp = Flask(__name__)SECRET = ”your-secret-key”# ===== 1. 模拟数据 =====USERS = {    ”u001”: {”name”: ”张总”, ”tenant”: ”T1”, ”roles”: [”admin”]},    ”u002”: {”name”: ”李工”, ”tenant”: ”T1”, ”roles”: [”member”]},    ”u003”: {”name”: ”王实习”, ”tenant”: ”T1”, ”roles”: [”viewer”]},    ”u004”: {”name”: ”赵总”, ”tenant”: ”T2”, ”roles”: [”admin”]},}ROLE_PERMS = {    ”admin”: [”kb:*”, ”agent:*”, ”user:read”],    ”member”: [”kb:read”, ”kb:write”, ”agent:read”],    ”viewer”: [”kb:read”, ”agent:read”],}# 模拟知识库（含 tenant_id）KNOWLEDGE_BASES = [    {”id”: ”KB-01”, ”name”: ”研发文档”, ”tenant”: ”T1”},    {”id”: ”KB-02”, ”name”: ”市场资料”, ”tenant”: ”T1”},    {”id”: ”KB-03”, ”name”: ”财务数据”, ”tenant”: ”T2”},]# ===== 2. 认证中间件 =====def auth_required(f):    @functools.wraps(f)    def wrapper(*args, **kwargs):        token = request.headers.get(”Authorization”, ””).replace(”Bearer ”, ””)        try:            payload = jwt.decode(token, SECRET, algorithms=[”HS256”])        except jwt.ExpiredSignatureError:            return jsonify({”error”: ”token expired”}), 401        except jwt.InvalidTokenError:            return jsonify({”error”: ”invalid token”}), 401        g.user_id = payload[”user_id”]        g.tenant_id = payload[”tenant_id”]        g.roles = payload[”roles”]        return f(*args, **kwargs)    return wrapper# ===== 3. RBAC 鉴权 =====def require_permission(perm):    def decorator(f):        @functools.wraps(f)        def wrapper(*args, **kwargs):# 收集用户所有权限            user_perms = set()            for role in g.roles:                user_perms.update(ROLE_PERMS.get(role, []))# 检查权限（支持通配符）            if not _has_perm(user_perms, perm):                return jsonify({”error”: f”forbidden: requires '{perm}'”}), 403            return f(*args, **kwargs)        return wrapper    return decoratordef _has_perm(user_perms, required):    for p in user_perms:        if p == required or p == ”*”:            return True        if p.endswith(”:*”) and required.startswith(p[:-1]):            return True    return False# ===== 4. 业务接口 =====@app.route(”/login”, methods=[”POST”])def login():    user_id = request.json[”user_id”]    user = USERS.get(user_id)    if not user:        return jsonify({”error”: ”user not found”}), 404    token = jwt.encode({        ”user_id”: user_id,        ”tenant_id”: user[”tenant”],        ”roles”: user[”roles”],        ”exp”: time.time() + 7200,    }, SECRET, algorithm=”HS256”)    return jsonify({”token”: token, ”user”: user[”name”]})@app.route(”/knowledge-bases”)@auth_required@require_permission(”kb:read”)def list_kb():# 租户隔离：只返回当前租户的数据    result = [kb for kb in KNOWLEDGE_BASES if kb[”tenant”] == g.tenant_id]    return jsonify({”data”: result, ”tenant”: g.tenant_id})@app.route(”/knowledge-bases”, methods=[”POST”])@auth_required@require_permission(”kb:write”)def create_kb():    name = request.json[”name”]    new_kb = {”id”: f”KB-{len(KNOWLEDGE_BASES)+1:02d}”, ”name”: name, ”tenant”: g.tenant_id}    KNOWLEDGE_BASES.append(new_kb)    return jsonify({”created”: new_kb}), 201@app.route(”/knowledge-bases/”, methods=[”DELETE”])@auth_required@require_permission(”kb:delete”)def delete_kb(kb_id):# 双重校验：权限 + 租户归属    kb = next((k for k in KNOWLEDGE_BASES if k[”id”] == kb_id), None)    if not kb or kb[”tenant”] != g.tenant_id:        return jsonify({”error”: ”not found”}), 404    KNOWLEDGE_BASES.remove(kb)    return jsonify({”deleted”: kb_id})# ===== 5. 测试 =====if __name__ == ”__main__”:    app.run(debug=True, port=5000)# 测试命令：# 1. 登录获取 Token#    curl -X POST localhost:5000/login -H ”Content-Type: application/json” -d '{”user_id”:”u003”}'## 2. 用 viewer 的 Token 查知识库（成功，有 kb:read）#    curl localhost:5000/knowledge-bases -H ”Authorization: Bearer ”#    → 只返回 T1 的 KB-01, KB-02（看不到 T2 的 KB-03）## 3. 用 viewer 的 Token 删知识库（403，没有 kb:delete）#    curl -X DELETE localhost:5000/knowledge-bases/KB-01 -H ”Authorization: Bearer ”#    → {”error”: ”forbidden: requires 'kb:delete'”}## 4. 用 T2 用户的 Token 访问 T1 的知识库（404，租户隔离）#    → 即使知道 KB-01 的 ID，也查不到

┌─────────────────────────────────────────────────────────────┐│                    万悟平台架构全景                           ││                                                             ││  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐       ││  │ 模型层  │  │ 知识层  │  │ 智能层  │  │ 编排层  │       ││  │(第2篇)  │  │(第3,4篇)│  │(第5,6篇)│  │(第7篇)  │       ││  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘       ││       └─────────────┴─────────────┴─────────────┘           ││                          │                                  ││                   ┌──────▼──────┐                           ││                   │  安全基座   │                           ││                   │  (第8篇)    │                           ││                   │ 认证·鉴权   │                           ││                   │ 隔离·限流   │                           ││                   │ 审计·合规   │                           ││                   └─────────────┘                           │└─────────────────────────────────────────────────────────────┘