脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - go语言使用Casbin实现角色的权限控制

go语言使用Casbin实现角色的权限控制

2021-08-11 01:11王大阳_ Golang

Casbin是用于Golang项目的功能强大且高效的开源访问控制库。本文主要介绍了go语言使用Casbin实现角色的权限控制，感兴趣的可以了解下

本文主要介绍了go语言使用casbin实现角色的权限控制，分享给大家，具体如下：

go语言使用Casbin实现角色的权限控制

介绍 casbin 是什么？

官方解释：casbin是一个强大的、高效的开源访问控制框架，其权限管理机制支持多种访问控制模型。

casbin只负责访问控制。身份认证 authentication（即验证用户的用户名、密码），需要其他专门的身份认证组件负责。例如（jwt-go）

两个核心概念：

访问控制模型model和策略policy。

工作原理：

casbin把 访问控制模型 被抽象为基于

perm元模型 (policy, effect, request, matchers) [策略，效果，请求，匹配器]， 反映了权限的本质 – 访问控制

  • policy: 定义权限的规则
  • effect: 定义组合了多个 policy 之后的结果, allow/deny
  • request: 访问请求, 也就是谁想操作什么
  • matcher: 判断 request 是否满足 policy

匹配来源：定义的 request 和 存储的 police 比对判断。

所有 model file 中主要就是定义 perm 4 个部分的一个文件（ model.conf , 这个文件一般是固定的）。

因此，切换或升级项目的授权机制与修改配置一样简单。 您可以通过组合可用的模型来定制您自己的访问控制模型（acl， rbac, abac）。

例如，您可以在一个model中获得rbac角色和abac属性，并共享一组policy规则。

g, g2, g3 表示不同的 rbac 体系, _, _ 表示用户和角色 _, _, _ 表示用户, 角色, 域(也就是租户)

rbac_models.conf

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# request definition
[request_definition]
r = sub, obj, act
 
# policy definition
[policy_definition]
p = sub, obj, act
 
# policy effect
[policy_effect]
e = some(where (p.eft == allow))
 
# matchers
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

实战

一般运用到项目后台的管理权限中

初始化数据库

初始化环境后，系统会在你选择的数据库自动生成一个casbin_rule的数据库表

go语言使用Casbin实现角色的权限控制

用户权限的增删改查

tips：这些接口，需要放在截器中间件前面， 不然空表无法添加数据

?
1
2
//使用自定义拦截器中间件
r.use(authorize())
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//增加policy
    r.post("/api/v1/add", func(c *gin.context) {
        fmt.println("增加policy")
        if ok, _ := enforcer.addpolicy("admin", "/api/v1/world", "get"); !ok {
            fmt.println("policy已经存在")
        } else {
            fmt.println("增加成功")
        }
    })
    //删除policy
    r.delete("/api/v1/delete", func(c *gin.context) {
        fmt.println("删除policy")
        if ok, _ := enforcer.removepolicy("admin", "/api/v1/world", "get"); !ok {
            fmt.println("policy不存在")
        } else {
            fmt.println("删除成功")
        }
    })
    //获取policy
    r.get("/api/v1/get", func(c *gin.context) {
        fmt.println("查看policy")
        list := enforcer.getpolicy()
        for _, vlist := range list {
            for _, v := range vlist {
                fmt.printf("value: %s, ", v)
            }
        }
    })

添加权限，访问其添加接口

go语言使用Casbin实现角色的权限控制

单个用户保存权限的路由是多条记录

go语言使用Casbin实现角色的权限控制

在使用casbin中间件时，会访问表中的数据库表 ,得到相应的权限信息，增加访问信息后，访问接口成功

go语言使用Casbin实现角色的权限控制

代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package main
 
import (
    "fmt"
    "github.com/casbin/casbin"
    xormadapter "github.com/casbin/xorm-adapter"
    "github.com/gin-gonic/gin"
    _ "github.com/go-sql-driver/mysql"
    "log"
    "net/http"
)
 
var enforcer *casbin.enforcer
 
func init() {
    casbinsetup()
}
 
// 初始化casbin
func casbinsetup(){
    a, err := xormadapter.newadapter("mysql", "root:root123@tcp(127.0.0.1:3306)/casbin?charset=utf8", true)
    if err != nil {
        log.printf("连接数据库错误: %v", err)
        return
    }
    e, err := casbin.newenforcer("./conf/rbac_models.conf", a)
    if err != nil {
        log.printf("初始化casbin错误: %v", err)
        return
    }
 
    enforcer = e
    //return e
}
 
 
func hello(c *gin.context) {
    fmt.println("hello 接收到get请求..")
    c.json(http.statusok, gin.h{
        "code": 200,
        "msg":  "success",
        "data": "hello 接收到get请求..",
    })
}
 
 
func main() {
    //获取router路由对象
    r := gin.new()
 
 
    //增加policy
    r.get("/api/v1/add", func(c *gin.context) {
        fmt.println("增加policy")
        if ok, _ := enforcer.addpolicy("admin", "/api/v1/world", "get"); !ok {
            fmt.println("policy已经存在")
        } else {
            fmt.println("增加成功")
        }
    })
    //删除policy
    r.delete("/api/v1/delete", func(c *gin.context) {
        fmt.println("删除policy")
        if ok, _ := enforcer.removepolicy("admin", "/api/v1/world", "get"); !ok {
            fmt.println("policy不存在")
        } else {
            fmt.println("删除成功")
        }
    })
    //获取policy
    r.get("/api/v1/get", func(c *gin.context) {
        fmt.println("查看policy")
        list := enforcer.getpolicy()
        for _, vlist := range list {
            for _, v := range vlist {
                fmt.printf("value: %s, ", v)
            }
        }
    })
 
    //使用自定义拦截器中间件
    r.use(authorize())
 
 
 
 
    //创建请求
    r.get("/api/v1/hello", hello)
    r.run(":9000") //参数为空 默认监听8080端口
}
 
 
 
 
//拦截器
func authorize() gin.handlerfunc {
 
    return func(c *gin.context) {
        //var e *casbin.enforcer
        e := enforcer
 
        //从db加载策略
        e.loadpolicy()
 
        //获取请求的uri
        obj := c.request.url.requesturi()
        //获取请求方法
        act := c.request.method
        //获取用户的角色 应该从db中读取
        sub := "admin"
 
        //判断策略中是否存在
        if ok, _ := e.enforce(sub, obj, act); ok {
            fmt.println("恭喜您,权限验证通过")
            c.next() // 进行下一步操作
        } else {
            fmt.println("很遗憾,权限验证没有通过")
            c.abort()
        }
    }
}

总代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package main
 
import (
    "fmt"
    "github.com/casbin/casbin"
    xormadapter "github.com/casbin/xorm-adapter"
    "github.com/gin-gonic/gin"
    _ "github.com/go-sql-driver/mysql"
    "log"
    "net/http"
)
 
var enforcer *casbin.enforcer
 
func init() {
    casbinsetup()
}
 
// 初始化casbin
func casbinsetup(){
    a, err := xormadapter.newadapter("mysql", "root:root123@tcp(127.0.0.1:3306)/casbin?charset=utf8", true)
    if err != nil {
        log.printf("连接数据库错误: %v", err)
        return
    }
    e, err := casbin.newenforcer("./conf/rbac_models.conf", a)
    if err != nil {
        log.printf("初始化casbin错误: %v", err)
        return
    }
 
    enforcer = e
    //return e
}
 
 
func hello(c *gin.context) {
    fmt.println("hello 接收到get请求..")
    c.json(http.statusok, gin.h{
        "code": 200,
        "msg":  "success",
        "data": "hello 接收到get请求..",
    })
}
 
 
func main() {
    //获取router路由对象
    r := gin.new()
 
 
    //增加policy
    r.get("/api/v1/add", func(c *gin.context) {
        fmt.println("增加policy")
        if ok, _ := enforcer.addpolicy("admin", "/api/v1/world", "get"); !ok {
            fmt.println("policy已经存在")
        } else {
            fmt.println("增加成功")
        }
    })
    //删除policy
    r.delete("/api/v1/delete", func(c *gin.context) {
        fmt.println("删除policy")
        if ok, _ := enforcer.removepolicy("admin", "/api/v1/world", "get"); !ok {
            fmt.println("policy不存在")
        } else {
            fmt.println("删除成功")
        }
    })
    //获取policy
    r.get("/api/v1/get", func(c *gin.context) {
        fmt.println("查看policy")
        list := enforcer.getpolicy()
        for _, vlist := range list {
            for _, v := range vlist {
                fmt.printf("value: %s, ", v)
            }
        }
    })
 
    //使用自定义拦截器中间件
    r.use(authorize())
 
 
 
 
    //创建请求
    r.get("/api/v1/hello", hello)
    r.run(":9000") //参数为空 默认监听8080端口
}
 
 
 
 
//拦截器
func authorize() gin.handlerfunc {
 
    return func(c *gin.context) {
        //var e *casbin.enforcer
        e := enforcer
 
        //从db加载策略
        e.loadpolicy()
 
        //获取请求的uri
        obj := c.request.url.requesturi()
        //获取请求方法
        act := c.request.method
        //获取用户的角色 应该从db中读取
        sub := "admin"
 
        //判断策略中是否存在
        if ok, _ := e.enforce(sub, obj, act); ok {
            fmt.println("恭喜您,权限验证通过")
            c.next() // 进行下一步操作
        } else {
            fmt.println("很遗憾,权限验证没有通过")
            c.abort()
        }
    }
}

封装后的代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package mycasbin
 
import (
    "simple-api/mongoose"
    "github.com/casbin/mongodb-adapter"
    "github.com/casbin/casbin"
    "gopkg.in/mgo.v2/bson"
)
 
type casbinmodel struct {
    id       bson.objectid `json:"id" bson:"_id"`
    ptype    string        `json:"ptype" bson:"ptype"`
    rolename string        `json:"rolename" bson:"v0"`
    path     string        `json:"path" bson:"v1"`
    method   string        `json:"method" bson:"v2"`
}
 
//添加权限
func (c *casbinmodel) addcasbin(cm casbinmodel) bool {
    e := casbin()
    e.addpolicy(cm.rolename, cm.path, cm.method)
    return true
 
}
 
//持久化到数据库
// "github.com/casbin/mongodb-adapter"
// func casbin() *casbin.enforcer {
//  a := mongodbadapter.newadapter(mongoose.mongourl)
//  e := casbin.newenforcer("conf/auth_model.conf", a)
//  e.loadpolicy()
//  return e
// }
func casbin() *casbin.enforcer {
    a := mongodbadapter.newadapter(mongoose.mongourl)
    e, err := casbin.newenforcer("conf/auth_model.conf", a)
    if err != nil {
        panic(err)
    }
    e.loadpolicy()
    return e
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package apis
 
import (
    "net/http"
    "simple-api/utils/mycasbin"
 
    "github.com/gin-gonic/gin"
    "gopkg.in/mgo.v2/bson"
)
 
var (
    casbins = mycasbin.casbinmodel{}
)
 
func addcasbin(c *gin.context) {
    rolename := c.postform("rolename")
    path := c.postform("path")
    method := c.postform("method")
    ptype := "p"
    casbin := mycasbin.casbinmodel{
        id:       bson.newobjectid(),
        ptype:    ptype,
        rolename: rolename,
        path:     path,
        method:   method,
    }
    isok := casbins.addcasbin(casbin)
    if isok {
        c.json(http.statusok, gin.h{
            "success": true,
            "msg":     "保存成功",
        })
    } else {
        c.json(http.statusok, gin.h{
            "success": false,
            "msg":     "保存失败",
        })
    }
}

参考

https://www.jianshu.com/p/9506406e745f

到此这篇关于go语言使用casbin实现角色的权限控制的文章就介绍到这了,更多相关go语言角色权限控制内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/weixin_43746433/article/details/107889086

  • GO语言
  • 权限控制
  • casbin
  • 角色

    • 延伸 · 阅读

    精彩推荐
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图