如何为gRPC-Gateway生成的RESTful API添加RBAC权限控制？

针对你用gRPC-Gateway自动生成接口无法直接添加中间件的问题，这里提供三个可行的实现方案，按推荐优先级排序：

方案一：基于gRPC方法自定义选项的拦截器实现（推荐） #

这个方案把RBAC规则和proto服务定义绑定，统一维护，同时覆盖gRPC原生请求和REST请求（因为gRPC-Gateway的请求最终会转发到gRPC服务）。

步骤1：在proto中定义自定义权限选项 #

首先扩展proto的方法选项，用来标记接口所需的角色：

import "google/protobuf/descriptor.proto";

// 自定义方法选项，标记接口需要的角色
extend google.protobuf.MethodOptions {
  repeated string required_roles = 50001; // 自定义字段编号需符合proto规范
}

service UserService {
  // GET /v1/users 对应这个gRPC方法，要求user角色
  rpc ListUsers(ListUsersRequest) returns (ListUsersResponse) {
    option (required_roles) = "user";
  }
  // POST /v1/users 对应这个gRPC方法，要求admin角色
  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse) {
    option (required_roles) = "admin";
  }
}

步骤2：在gRPC认证拦截器中添加RBAC检查 #

修改你已有的AuthenticateInterceptor，在认证通过后，获取当前方法的自定义权限选项，对比用户角色：

func AuthenticateInterceptor(xyzSvc XYZService) grpc.UnaryServerInterceptor {
    return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
        // 原有认证逻辑：从上下文获取用户角色
        userRoles, err := xyzSvc.GetUserRolesFromContext(ctx)
        if err != nil {
            return nil, status.Error(codes.Unauthenticated, "认证失败")
        }

        // 获取当前gRPC方法的自定义权限选项
        methodOpts := info.Method.Options()
        requiredRoles, ok := proto.GetExtension(methodOpts, E_RequiredRoles).([]string)
        if !ok {
            // 未配置权限的接口，可默认拒绝或允许，根据业务调整
            return nil, status.Error(codes.PermissionDenied, "未配置权限规则")
        }

        // 检查用户角色是否匹配要求
        hasPermission := false
        for _, userRole := range userRoles {
            for _, reqRole := range requiredRoles {
                if userRole == reqRole {
                    hasPermission = true
                    break
                }
            }
            if hasPermission {
                break
            }
        }
        if !hasPermission {
            return nil, status.Error(codes.PermissionDenied, "无访问权限")
        }

        // 权限通过，继续处理请求
        return handler(ctx, req)
    }
}

方案二：gRPC-Gateway全局中间件实现 #

在Gateway层添加全局中间件，根据HTTP路径和方法匹配权限规则，适合不想修改proto的场景。

步骤1：定义路由权限映射表 #

先把需要控制的接口路径、HTTP方法和对应角色整理成映射：

var routePermissions = map[string]map[string][]string{
    "/v1/users": {
        http.MethodGet:  {"user"},
        http.MethodPost: {"admin"},
    },
    // 其他接口规则...
}

步骤2：编写RBAC中间件 #

func RBACMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 从上下文获取已认证的用户角色（需确保认证中间件已把角色存入上下文）
        userRoles, ok := r.Context().Value("user_roles").([]string)
        if !ok {
            http.Error(w, "未认证", http.StatusUnauthorized)
            return
        }

        // 获取当前请求的路径和方法
        reqPath := r.URL.Path
        reqMethod := r.Method

        // 匹配权限规则
        requiredRoles, ruleExists := routePermissions[reqPath][reqMethod]
        if !ruleExists {
            http.Error(w, "无访问权限", http.StatusForbidden)
            return
        }

        // 检查角色匹配
        hasPermission := false
        for _, ur := range userRoles {
            for _, rr := range requiredRoles {
                if ur == rr {
                    hasPermission = true
                    break
                }
            }
            if hasPermission {
                break
            }
        }
        if !hasPermission {
            http.Error(w, "无访问权限", http.StatusForbidden)
            return
        }

        // 权限通过，继续处理
        next.ServeHTTP(w, r)
    })
}

步骤3：包装Gateway的mux #

创建Gateway mux后，用RBAC中间件包装：

func main() {
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    mux := runtime.NewServeMux()
    grpcEndpoint := "localhost:9090"
    opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
    
    // 注册自动生成的gRPC-Gateway路由
    if err := user_service.RegisterUserServiceHandlerFromEndpoint(ctx, mux, grpcEndpoint, opts); err != nil {
        log.Fatal(err)
    }

    // 用RBAC中间件包装mux后启动服务
    log.Fatal(http.ListenAndServe(":8080", RBACMiddleware(mux)))
}

方案三：手动覆盖gRPC-Gateway路由（不推荐） #

通过手动添加相同路径的路由，在自定义处理函数中完成RBAC检查后调用原处理函数。缺点是需要同步维护路由，容易出错。

示例代码：

func main() {
    ctx := context.Background()
    mux := runtime.NewServeMux()
    grpcEndpoint := "localhost:9090"
    opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
    
    // 先注册自动生成的路由
    if err := user_service.RegisterUserServiceHandlerFromEndpoint(ctx, mux, grpcEndpoint, opts); err != nil {
        log.Fatal(err)
    }

    // 获取原GET /v1/users的处理函数
    getUsersHandler := mux.Handler(http.NewRequest(http.MethodGet, "/v1/users", nil))
    // 手动添加带RBAC检查的路由（优先级高于自动生成的路由）
    mux.HandlePath(http.MethodGet, "/v1/users", func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) {
        userRoles, ok := r.Context().Value("user_roles").([]string)
        if !ok || !contains(userRoles, "user") {
            http.Error(w, "无访问权限", http.StatusForbidden)
            return
        }
        // 调用原处理函数
        getUsersHandler.ServeHTTP(w, r)
    })

    // 同理处理POST /v1/users
    createUserHandler := mux.Handler(http.NewRequest(http.MethodPost, "/v1/users", nil))
    mux.HandlePath(http.MethodPost, "/v1/users", func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) {
        userRoles, ok := r.Context().Value("user_roles").([]string)
        if !ok || !contains(userRoles, "admin") {
            http.Error(w, "无访问权限", http.StatusForbidden)
            return
        }
        createUserHandler.ServeHTTP(w, r)
    })

    log.Fatal(http.ListenAndServe(":8080", mux))
}

// 辅助函数：检查切片是否包含指定元素
func contains(slice []string, item string) bool {
    for _, s := range slice {
        if s == item {
            return true
        }
    }
    return false
}

内容的提问来源于stack exchange，提问作者Arif