RBAC 一篇文章 带你学会

原创 已于 2024-10-31 10:56:18 修改 · 3.8k 阅读 · 28 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#node.js #express #mongodb #设计模式
于 2024-10-31 10:42:12 首次发布

1.什么是 RBAC?

        基于角色的访问控制（Role-Based Access Control，简称 RBAC）是一种访问控制机制，通过为用户分配角色来管理权限。RBAC 模型使得权限的管理更加简便高效，尤其适用于复杂的系统架构。

1.1 RBAC 重要概念

         用户 （User）、角色（Role）、权限（Permission）

  • 一个用户拥有若干角色
  • 一个角色拥有若干的权限
  • 这样就构成了 用户 - 角色 - 权限 的授权模型

RBAC 就是用户通过角色与权限进行关联。在这种模型中，用户与角色之间，角色与权限之间一般是多对多的关系

        

1.2 RBAC 有什么优势？

        RBAC 的优势包括权限管理的模块化、易维护性和安全性。它能够减少权限管理的复杂度，使开发者只需管理角色和权限的关系，而不必直接管理用户与权限的关系。

2.核心模块

用户管理
  • 用户列表
  • 添加用户
  • 编辑用户
  • 删除用户
  • 设置用户角色（可以有多个角色）
角色管理
  • 角色列表
  • 添加角色
  • 编辑角色
  • 删除角色
  • 分配用户权限（可以有多个权限）
权限管理
  • 权限列表
  • 添加权限
  • 编辑权限
  • 删除权限

3.技术栈

        实际上，你编写 RBAC 不需要指定的技术去实现。因为 RBAC 它只是一个权限管理模型，没有技术的限制，为了方便，我这里使用的是 Node.js,Express,MongoDB，mongoose,JWT。这里只是举例子，你用什么技术栈都可以（重要的是理解 RBAC 流程）

4.RBAC 结构设计

4.1 后端 API 路由设计
// 用户管理路由
router
  .get("/users", userCtrl.list) // 获取用户列表
  .post("/users", userCtrl.create) // 新增用户
  .put("/users/:id", userCtrl.update) // 修改用户
  .delete("/users/:id", userCtrl.delete) // 删除用户
  .get("/users/:id", userCtrl.one) // 获取单个用户
  .patch("/users/:id/roles", userCtrl.updateRoles); // 给用户分配角色
// 角色管理路由
router
  .get("/roles", rolesCtrl.list) // 获取角色列表
  .post("/roles", rolesCtrl.create) // 新增角色
  .put("/roles/:id", rolesCtrl.update) // 修改角色
  .delete("/roles/:id", rolesCtrl.delete) // 删除角色
  .get("/roles/:id", rolesCtrl.one) // 获取单个角色
  .patch("/roles/:id/menus", rolesCtrl.updateMenus); // 给角色分配权限

// 权限管理路由
router
  .get("/menus", menuCtrl.list) // 获取权限列表
  .post("/menus", menuCtrl.create) // 新增权限
  .put("/menus/:id", menuCtrl.update) // 修改权限
  .delete("/menus/:id", menuCtrl.delete) // 删除权限
  .get("/menus/:id", menuCtrl.one); // 获取单个权限
4.2 表结构设计

        这里拿 User 表举例子

const { Schema } = require("mongoose");

const userSchema = new Schema({
  /**
   * 用户名
   */
  username: {
    type: String,
    required: true,
    unique: true,
  },
  /**
   * 密码
   */
  password: {
    type: String,
    required: true,
    select: false,
  },
  /**
   * 邮件
   */
  email: {
    type: String,
    unique: true,
  },
  /**
   * 姓名
   */
  name: {
    type: String,
    default: "",
  },
  /**
   * 角色
   */
  roles: {
    type: [Schema.Types.ObjectId],
    ref: "Role",
  },
  /**
   * 状态
   * 0:未启用
   * 1:已启用
   */
  status: {
    type: Number,
    default: 0,
  },
  //   创建时间
  createAt: {
    type: Date,
    default: Date.now,
  },
  //   更新时间
  updateAt: {
    type: Date,
    default: Date.now,
  },
  /**
   * 是否为超级管理员
   */
  isAdmin: {
    type: Boolean,
    default: false,
  },
});

module.exports = userSchema
4.3 表逻辑操作设计

        还是 User 表举例

// 用户处理模块
const { User } = require("../model");

// 获取用户列表
exports.list = async (req, res) => {
  try {
    const ret = await User.find().populate("roles");
    res.status(200).json(ret);
  } catch (err) {
    res.send(err);
  }
};

// 新增用户
exports.create = async (req, res) => {
  try {
    const ret = await new User(req.body).save();
    res.status(200).json(ret);
  } catch (err) {
    res.send(err);
  }
};

// 更新用户列表
exports.update = async (req, res) => {
  try {
    const ret = await User.findById(req.params.id);
    // 将客户端提交的数据合并到数据对象中
    Object.assign(ret, req.body);
    // 将修改之后的数据对象保存到数据库
    await ret.save();
    res.status(201).json(ret);
  } catch (err) {
    res.send(err);
  }
};
exports.delete = async (req, res) => {
  try {
    await User.findByIdAndDelete(req.params.id);
    res.status(204).end();
  } catch (err) {
    res.send(err);
  }
};
exports.one = async (req, res) => {
  try {
    const ret = await User.findById(req.params.id);
    res.status(200).json(ret);
  } catch (err) {
    res.send(err);
  }
};
exports.updateRoles = async (req, res,next) => {
  try{
    const ret = await User.findById(req.params.id);
    ret.roles = req.body.roles
    await ret.save();
    res.status(201).json(ret);
  }catch{
    next(err);
  }
};
4.4 配置 连接数据库
const mongoose = require("mongoose");

// 调用 main 函数，并在发生错误的时候捕获错误并打印到控制台
main().catch((err) => console.log(err));

// 连接数据库
async function main() {
  await mongoose.connect("mongodb://127.0.0.1:27017/rbac");
}

module.exports = {
  // 导入我们的模型，传递两个参数，第一个是模型名称，第二个是模型结构
  User: mongoose.model("User", require("./user")),
  Role: mongoose.model("Role", require("./role")),
  Menu: mongoose.model("Menu", require("./menu")),
  Product: mongoose.model("Product", require("./product")),
  Categorie: mongoose.model("Categorie", require("./categorie")),
};
4.5 获取用户权限
const { User } = require("../model");
const jwt = require("jsonwebtoken");

exports.login = async (req, res, next) => {
  try {
    // 根据用户名查询用户
    const user = await User.findOne({ username: req.body.username }).select(
      "+password"
    );
    // 如果没用用户，结束响应
    if (!user) {
      return res.status(400).json({
        msg: "用户名不存在",
      });
    }

    // console.log(req.body, user);

    if (req.body.password !== user.password) {
      return res.status(400).json({
        msg: "密码不正确",
      });
    }

    const token = jwt.sign(
      {
        userId: user._id,
      },
      "e5a10b19-d3c5-4a0c-8b35-388e8e237e27"
    );
    console.log(req.user);
    
    res.status(200).json({
      token,
      ...req.user,
      user
    });
  } catch (error) {
    next(error);
  }
};

exports.permissions = async (req, res, next) => {
  try {
    // 获取用户的权限
    const ret = await req.user.populate({
      path: "roles",
      populate: {
        path: "menus",
      },
    });
    res.status(200).json(ret);
  } catch (err) {
    next(err);
  }
};
4.6 token 验证

        如果我们对 token 有要求，可以自己编写登录的逻辑

4.7 动态路由实现

        我这里用到的是 判断用户权限 进行路由的添加实现的

import { createRouter, createWebHistory } from "vue-router";
import { useCounterStore } from "@/stores/counter";
import axios from "axios";
import { ElNotification } from "element-plus";

const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes: [
    {
      path: "/",
      // 重定向
      redirect: "/container",
    },
    {
      path: "/login",
      name: "login",
      // 按需导入
      component: () => import("../views/Login/LoginView.vue"),
    },
    {
      path: "/container",
      name: "container",
      component: () => import("../views/ContainerView.vue"),
      children: [],
    },
  ],
});
const dynamicRoutes = [
  {
    path: "/container",
    redirect: "/home",
  },
  {
    path: "/home",
    name: "home",
    component: () => import("../views/Main/home/HomeView.vue"),
    meta: { public: true },
  },
  {
    path: "/order",
    name: "order",
    component: () => import("../views/Main/order/OrderView.vue"),
    meta: { roles: ["管理员", "客服", "运营人员"] },
  },
  {
    path: "/cashier",
    name: "cashier",
    component: () => import("../views/Main/order/CashierOrderView.vue"),
    meta: { roles: ["管理员", "客服"] },
  },
  {
    path: "/admin",
    name: "admin",
    component: () => import("../views/Main/set/AdminView.vue"),
    meta: { roles: ["管理员"] },
  },
  {
    path: "/system",
    name: "system",
    component: () => import("../views/Main/set/SystemView.vue"),
    meta: { roles: ["管理员"] },
  },
  {
    path: "/trade",
    name: "trade",
    component: () => import("../views/Main/trade/TradeView.vue"),
    meta: { roles: ["管理员", "商品管理者"] },
  },
  {
    path: "/TradeClass",
    name: "TradeClass",
    component: () => import("../views/Main/trade/TradeClassView.vue"),
    meta: { roles: ["管理员", "商品管理者"] },
  },
  {
    path: "/user",
    name: "user",
    component: () => import("../views/Main/user/UserView.vue"),
    meta: { roles: ["管理员", "运营人员"] },
  },
  {
    path: "/UserClass",
    name: "UserClass",
    component: () => import("../views/Main/user/UserClass.vue"),
    meta: { roles: ["管理员", "运营人员"] },
  },
];
router.beforeEach(async (to, from, next) => {
  const counterStore = useCounterStore();
  const token = counterStore.token;
  const userRoles = Array.from(counterStore.userRoles);

  if (to.path !== "/login") {
    if (!token) {
      ElNotification({
        title: "提醒",
        message: "您还没有登录，请先登录",
        type: "warning",
      });

      return next({ path: "/login" });
    }

    try {
      // console.log("我验证过了");
      const as = await axios.get("/validata-token", {
        headers: {
          Authentication: `Bearer ${token}`,
        },
      });

      dynamicRoutes.forEach((route) => {
        if (route.name) {
          const existingRoute = router
            .getRoutes()
            .find((r) => r.name === route.name);
          if (existingRoute) {
            router.removeRoute(route.name);
          }
        }
      });

      // 获取用户角色信息
      const roles: string[] = userRoles ?? [];
      const accessibleRoutes = dynamicRoutes.filter((route) => {
        // 打印是否包含在路由中
        return (
          !route.meta?.roles ||
          route.meta.roles.some((role: string) => roles.includes(role))
        );
      });
      // 将符合规则的路由 添加到 container 路由
      accessibleRoutes.forEach((route) => {
        router.addRoute("container", route);
        // console.log(`添加路由：${route.name}，路径：${route.path}`);
        // 打印添加的路由
      });

       // 检查目标路由是否存在于已添加的动态路由中
       const routeExists = router.getRoutes().some(route => route.path === to.path);
       if (!routeExists) {
         ElNotification({
           title: "权限提醒",
           message: "您没有权限访问该页面",
           type: "warning",
         });
         return next(false); // 阻止路由跳转
       }

      next(); // 如果是有效的token，必须访问目标路由
    } catch (error) {
      ElNotification({
        title: "提醒",
        message: "您的token已经过期，请重新登录",
        type: "warning",
      });
      console.log("error", error);
      counterStore.setToken(""); //清空无效的token
      counterStore.setUser(null);
      dynamicRoutes.forEach((route) => {
        if (route.name) {
          router.removeRoute(route.name);
        }
      });
      next({ path: "/login" }); // 跳转到登录页面
    }
  } else {
    next();
  }
});

export default router;
export { dynamicRoutes };

4.8 按钮级别

        这里就是根据我们提供的权限自行添加判断（后续会更新）

5.使用场景

        RBAC 在多用户的企业级应用、电商平台、金融系统等场景下应用广泛，特别是在系统权限需要多层级、精细化管理的情况下。对于快速发展的业务需求，RBAC 可以通过增加角色或权限来灵活应对。

6.总结

        RBAC 模型在权限管理中极大地简化了权限分配的复杂性和维护成本，尤其在角色权限关系复杂的系统中尤为适用。通过用户、角色、权限的分层管理，RBAC 实现了灵活、模块化的权限控制，使得系统在安全性和管理便捷性上都得到了提升。此外，RBAC 的可扩展性也较高，可以根据系统需求进一步扩展角色或权限的粒度，灵活适应不同的业务场景。

RBAC权限详解
xm1037782843的博客
07-30 9645
RBAC权限详解
RBAC用户角色权限管理
qq_51386003的博客
08-22 5917
RBAC（Role-Based Access Control，基于角色的访问控制），就是用户通过角色与权限进行关联。简单地说，一个用户拥有若干角色，每一个角色拥有若干权限。这样，就构造成“用户-角色-权限”的授权模型。在这种模型中，用户与角色之间，角色与权限之间，一般者是多对多的关系。可以看出角色表起到了一个承接的作用把权限下发给每一个角色，而用户可以选择角色来间接的获取权限User（用户）：每个用户都有唯一的UID识别，并被授予不同的角色Role（角色）：不同角色具有不同的权限。
RBAC-基于角色的访问控制
最新发布
qq_64904144的博客
05-11 175
仅自己对于RBAC的学习理解。
【设计模式】RBAC 模型详解_rbac模式，知识点总结+面试题解析
m0_61331573的博客
04-09 2219
随着软件系统的复杂性和规模的不断增长，权限管理成为了一个至关重要的问题。在大型多人协作的系统中，如何有效地管理不同用户的访问权限，确保系统的安全性和稳定性，是每一个开发者都需要面对的挑战。为了解决这一问题，业界提出了一种被广泛应用的权限管理模型——基于角色的访问控制（Role-Based Access Control，简称RBAC）。希望通过本篇博客的学习，您能够深入了解RBAC模型的核心思想和实现原理，掌握如何在实际项目中应用RBAC模型来提高系统的安全性和可维护性。
RBAC——基于角色权限的模型
热门推荐
林隐的博客
10-21 10万+
学习RBAC——基于角色权限的模型
RBAC权限管理
haoa0320的博客
02-24 1万+
RBAC权限管理
教你学会RBAC权限模型设计
个人博客，欢迎收藏。
01-12 1921
教你学会RBAC权限系统设计方案。
一篇文章教你如何设计权限控制系统——RBAC模型详解
CodeJR
09-09 1182
RBAC模型是一种将用户与权限通过角色进行关联的权限管理机制。在这种模型中，权限不是直接分配给用户，而是分配给角色，用户通过拥有角色来间接获得权限。这种间接的权限分配方式简化了权限管理，提高了系统的安全性和灵活性。那为什么需要角色这个概念呢？
RBAC 模型梳理
cliffordl的专栏
06-07 1万+
权限是资源的集合，这里的资源指的是软件中所有的内容，包括模块、菜单、页面、字段、操作功能（增删改查）等等。页面权限操作权限和数据权限。
【Ruoyi】一篇文章带你深入了解若依框架
qq_38196449的博客
12-09 2万+
若依内置的数据字典，用于维护系统中常见的静态数据。例如：性别、状态…功能包括：字典类型管理、字典数据管理若依为定时任务功能提供方便友好的web界面，实现动态管理任务。ruoyi-vue数据库设计包含了多个表结构，用于支持系统的各种功能模块。这些表可以根据它们的功能和用途进行分类，以便在后期使用时能够快速定位和理解。
RBAC简介（*）
weixin_42408447的博客
11-05 1万+
一.RBAC是什么 1.RBAC模型概述 RBAC是Role Based Access Control的英文缩写，意思是基于角色访问控制。 RBAC实际上就是针对产品去发掘需求时所用到的Who（角色）、What（拥有什么资源）、How（有哪些操作）的方式。 在RBAC模型中，who、what、how构成了访问权限三元组，也就是“Who对What进行How的操作。 RBAC主要包含四个子模型：RBAC0、RBAC1、RBAC2和RBAC3，整体又叫做RBAC96。 RBAC0 RBAC0是RBAC96模型家
一文带你了解多数企业系统都在用的 RBAC 权限管理策略
梓沐666的博客
05-06 1683
今天我们来聊聊几乎所有企业系统都离不开的 权限管理，大家平时在做项目开发的时候，有没有留意过权限这块的设计呢？都是怎样实现的呢？如果现在脑子里对于这块儿不够清晰，那么，请跟我一起，来了解下企业系统常用的权限管理策略 - `RBAC` 模型。
一篇文章带你了解Rancher的世界
qq_36972930的博客
08-02 1049
Rancher 是一个 Kubernetes 管理工具，让你能在任何地方和任何提供商上部署和运行集群。Rancher 可以创建来自 Kubernetes 托管服务提供商的集群，创建节点并安装 Kubernetes，或者导入在任何地方运行的现有 Kubernetes 集群。Rancher 基于 Kubernetes 添加了新的功能，包括统一所有集群的身份验证和 RBAC，让系统管理员从一个位置控制全部集群的访问。
RBAC权限系统分析、设计与实现
lvshuocool的博客
06-28 2万+
最近，因为项目上需要设计实现一个权限管理模块，所以专门整理总结了RBAC的一些知识。 目前，使用最普遍的权限管理模型正是RBAC（Role-Based Access Control）模型，这篇文章也主要是介绍基于RBAC的权限管理系统，我会从RBAC是什么、如何设计RBAC两部分来介绍。 一、RBAC是什么 1、RBAC模型概述 RBAC模型（Role-Based Access Contr...
权限控制模型--RBAC
m0_60386582的博客
04-14 9922
1. RBAC模型概述： RBAC模型（Role-Based Access Control：基于角色的访问控制）是20世纪90年代研究出来的一种新模型，但在20世纪70年代的多用户计算时期，这种思想就被提出来了，直到20世纪90年代中后期，RBAC才在研究团队中得到一些重视，并先后提出了很多类型的RBAC模型。其中以美国George Mason大学信息安全实验室（LIST）提出的RBAC96模型最具有代表，并得到普遍的公认。 RBAC认为权限授权的过程可以抽象的概括为：Who是否可以对What进行How
【设计模式】RBAC 模型详解
船到桥头自然直
12-24 2577
随着软件系统的复杂性和规模的不断增长，权限管理成为了一个至关重要的问题。在大型多人协作的系统中，如何有效地管理不同用户的访问权限，确保系统的安全性和稳定性，是每一个开发者都需要面对的挑战。为了解决这一问题，业界提出了一种被广泛应用的权限管理模型——基于角色的访问控制（Role-Based Access Control，简称RBAC）。希望通过本篇博客的学习，您能够深入了解RBAC模型的核心思想和实现原理，掌握如何在实际项目中应用RBAC模型来提高系统的安全性和可维护性。
权限设计，设计模型分析(DAC,MAC,RBAC,ABAC) 之 RBAC
qq_40861800的博客
07-09 4156
权限设计，设计模型分析(DAC,MAC,RBAC,ABAC) 之 RBAC:角色的权限控制
K8s RBAC认证授权深度解析
博客虽小，世界尽在其中
04-20 3047
随着Kubernetes在云原生领域的广泛应用，如何有效地管理和控制用户对集群资源的访问权限成为了一个重要的问题。基于角色的访问控制（RBAC）作为一种灵活的权限管理机制，在Kubernetes中发挥着至关重要的作用。本文深入探讨了Kubernetes RBAC认证授权的核心概念、实现方式以及实践应用，旨在帮助读者更好地理解和管理Kubernetes集群中的权限问题。
RBAC详解
天青色 等烟雨的博客
07-19 3247
RPAC模型是一种基于角色的访问控制模型，它将用户分配到不同的角色中，每个角色都有一组权限。用户通过被分配到的角色来获得访问系统资源的权限。在本文中，我们详细讨论了RPAC模型的工作原理，并使用一个数据库示例来说明如何实现RPAC模型。我们还提供了相关的代码示例，帮助读者更好地理解RPAC模型的实现。
Spring Security 实战干货： RBAC权限控制概念的理解
码农小胖哥
11-11 4384
1. 前言 欢迎阅读 Spring Security 实战干货系列文章 。截止到上一篇我们已经能够简单做到用户主体认证到接口的访问控制了，但是依然满足不了实际生产的需要。 如果我们需要一个完整的权限管理系统就必须了解一下 RBAC (Role-Based Access Control 基于角色的访问控制) 的权限控制模型。 2. 为什么需要 RBAC？ 在正式讨论 RBAC 模型之前，我们要思考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值