python的基于属性的访问控制（abac）sdk
vakt的Python项目详细描述
[！[vakt logo]（logo.png）]（logo.png）
python的基于属性的访问控制（abac）sdk。
[！[构建状态]（https://travis-ci.org/kolotaev/vakt.svg？branch=master）（https://travis ci.org/kolotaev/vakt）
[！[codecov.io]（https://codecov.io/github/kolotaev/vakt/coverage.svg？branch=master）（https://codecov.io/github/kolotaev/vakt？分支=主）
[！[PYPI版本]（https://badge.fury.io/py/vakt.svg）（https://badge.fury.io/py/vakt）
[！[许可的apache 2.0]（https://img.shields.io/badge/license apache%202.0-yellow.svg）]（https://raw.githubusercontent.com/kolotaev/vakt/master/license）
----
-[文档
-[描述]
-[概念]（[概念]
-[安装]（[安装]
-[用法]"（#用法）
-[组件]（组件）
-[策略]（策略）
-[查询]（查询）
-[规则]（规则）
-[比较相关]（比较相关）
-[逻辑相关]（逻辑相关）
-[列表相关]（列表相关）
-[网络相关]（网络相关）
-[string-related]（3535; string-related）
-[inquiry-related]（inquiry-related）
-[checker]（checker）
-[guard]（guard）
-[stor储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储
-[日志[例]（/例）
-[例]（/例）
-[确认]（[确认]）
-[基准]（[基准]）
-[开发]（[开发]
-[许可]（[许可]（[许可]）
abac不考虑rbac和acl模型，为您提供对限制资源访问的规则定义的细粒度控制，通常被认为是下一代在"授权模型"中，
其形式与[iam policies]类似（https://github.com/awsdocs/iam user guide/blob/master/doc-source/access-policies.md），但是
有一种更好的属性管理方式。
有关详细信息，请参阅[概念]部分。
*[返回顶部]（《文档》）n）*
\*正在请求哪些资源（资源）？*BR/> 1。*谁在请求资源？*BR/> 1。*请求对请求的资源执行哪些操作（操作）？*BR/> 1。*在请求本身的上下文中应该满足哪些规则？*BR/> 1。*答案对上述问题有何影响？*
"vakt"工作流的总体图是：
[！[vakt图]（diagram.svg）-（diagram.svg）
vakt允许您获得：
*基于策略的访问控制（vakt基于描述访问规则、资源策略的策略）
*细粒度授权（vakt策略允许您对资源进行细粒度控制）'s、subject's、action's和context's attributes）
*动态授权管理（您可以添加策略并更改其属性）
*外部授权管理（您可以使用vakt构建自己的外部authz服务器，请参阅示例）
*[返回顶部]（文档）*
pypypy实现也受支持。
对于内存存储：
``bash
pip install vakt
````
对于mongodb存储：
```bash
``pip install vakt[mongo]
```
<>快速切入：
``` python
import uuid
import vakt
from vakt.rules导入eq，any，startswith，and，greater，less
actions=[eq（'fork'），eq（'clone'）]，
resources=[startswith（'repos/google'，ci=true]，
subjects=[{'name'：any（），'stars'：and（greater（50），less（999））}，
effect=vakt.允许访问，
context={'referer'：'https://github.com'}，
description="
允许使用fork或为那些拥有50颗和999颗星星并且来自github的用户克隆任何google存储库
"
"）
storage=vakt.memoryStorage（）
storage.add（policy）
guard=vakt.guard（storage，vakt.ruleschecker（））
inq=vakt.inquiry（action='fork'，
resource='repos/google/tensorflow'，
subject={'name'：'larry'，'stars'：80}，
context={'referer'：'https://github.com'}）
assert guard.is懔allowed（inq）
````
ion）*
回答：问什么？
*主题-主题列表。答：谁要求获得资源？
*操作-操作列表。答：要求对资源执行哪些操作？
*上下文-给定查询上下文应满足的规则。
*效果-如果策略匹配上述所有条件，它意味着什么效果？
可以是"vakt.allow_access"或"vakt.deny_access"
所有"resources"、"subjects"和"actions"都用
一个包含字符串、正则表达式、[规则]（rules）或字符串（属性）字典到[规则]（rules）的列表来描述。
列表中的每个元素都充当逻辑或。规则字典中的每个键都充当逻辑和。
"上下文"只能用[规则]（规则）字典来描述。
根据描述"资源"、"主题"、"操作"的方式，策略可以具有基于字符串或基于规则的类型。可由"policy.type"检查。
这强制使用具体的checker实现。有关详细信息，请参见[检查器]（检查器）。
``python
from vakt import policy，allow懔access
from vakt.rules import cidr，any，eq，noteq，in
管理接口子类别："panel"、"switch"（如果用户不是开发人员，并且来自本地IP地址）。
"，
操作=[any（）]，
资源=[{'category'：eq（'a dministration'），'sub'：in（['panel'，'switch']），
主题=[{'name'：any（），'role'：noteq（'developer'）}]，
effect=allow廑access，
context={'ip'：cidr（'127.0.0.1/32'）}
）
书籍或杂志，
但仅当它们从本地图书馆的计算机连接时，
效果=允许访问，
主题=['<；[\w]+m[\w]+>；']，
资源=（'library:book s:<；+>；'，'office:magages:<；+>；'），
操作=['<；读取'get>；']，
context={'ip'：cidr（'192.168.2.0/24'）}
）
````
基本上，您希望创建一些包含域访问规则的策略集，并将它们存储起来，以便由[guard]（guard）组件做出未来的决策。
``python
st=memoryStorage（）
st.add（p）
```
*[返回顶部]（文档）*
查询
查询是vakt和外部世界资源访问请求之间的中介对象。您只需要
接受任何类型的传入请求（rest请求、soap等）并根据其顺序构建一个"查询"把它喂给vakt。没有任何具体的构建器可以从不同的请求类型进行查询，因为这是一个非常细致的
过程，而且您可以亲自控制自己进行查询。让我们看一个例子：
``python
from vakt import inquiry
from flask import request，session
…
le"：请求。如果定义了策略，则form['user_role']}，
action=request.form['action']，
resource={'book'：session.get（'book'），'chapter'：请求。form['chapter']}，
context={'ip'：请求。remote_addr}）
使用字符串或正则表达式：
inquiry=inquiry（subject=request.form['username'，
action=request.form['action'，
resource=request.form['page'，
context={'ip'：request.remote_addr}）
````
烧瓶请求和附加请求信息中的参数。然后我们将它们转换为查询。就这样。
inquiry有几个构造函数参数：
*resource-any dictionary of str->；any。请求访问哪些资源？
*操作-任意字典str->；任意。要求对资源做什么？
*主题-任意字典str->；任意。谁要的？
*上下文-字典str->；任意。请求的上下文是什么？
如果您足够细心，您可能已经注意到查询类似于策略，策略描述了所有者端资源访问的多个
变体，查询描述了消费者端的具体访问场景。
*[返回顶部]（文档）*
规则
规则允许您直接描述"操作"、"主题"、"资源"和"上下文"或其属性上的条件。
如果规则集中至少有一个规则不满足要求，则给定策略将拒绝查询。
将规则集附加到策略很简单。以下是一些示例：
``python
from vakt import policy，rules
policy（
…，
subjects=[{name'：rules.eq（'.kimzihhh0gsrc'）}，
policy（
…，
actions=[rules.eq（'get'），rules.eq（'list'），rules.eq（'read'），
，
policy（
…，
context={
"secret"：rules.string.equal（'.kimzihhh0gsrc'），
"ip"：rules.net.cidr（'192.168.0.15/24'）
}，
）
`````
自己的[自己的]（./examples/extending.py）。
规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则；
noteq `年龄：noteq（40）` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `>lessorequal `'stars'：lessorequal（300）` `'stars'：300`||
逻辑相关
规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则查询规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则
法尔西``阿美n'：falsy（）` `'admin'：lambda x:x.is_admin（）` `对查询创建的求值
`'age'：not（大于（90））` ` `'age'：40`；
` ` ` ` ` ` ` `格雷水（50），小于（120），Eq（8888）` ` `星'：78`还有，一个列表中的规则，比如说，` actions`充当或逻辑
任何` actions=[any（）]` ` action='get'`，` action='foo'`适合任何值的占位符
两个` subjects=[none（）]` ` subject='max'`，` subject='joe'`都不是很有用，只剩下了作为任何<
攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀br/>notin `'方法：notin（'get'"，"post'````方法'：'get'``` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `.5，4.9）``高度'：[7.55]``高度'：AnyNotIn（5.9，7.5，4.9）` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `'IP'：CIDR（'192.168.2.0/24'）` `'IP'：192.168.2.4`
如果您希望字符串类型检查和大小写不区分敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串名称：pairsequal（）`` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `：开始（"'logs-'''```文件'：'logs-data-101967.log'`````支持不区分大小写的不区分大小写
endswith `'file'：endswith（'.log'）````文件'：'logs-data-101967.log'`````支持不区分大小写的不区分大小写；
`包含``文件''：contains（'sun'）````'sun'''file''：'obisonsinsinsun晴天.csv'`````````````````文件''confensensensis支持不区分大小写不区分大小写的不区分大小写；
|注：subjectequal数据：subjectequal（）``查询（subject='max'）``只对字符串有效；查询（actionequal（）``查询（action='get'）``只对字符串有效"：resourcein（）` `查询（resource='/books/'）`仅适用于字符串
*[返回顶部]（文档）*
检查器
检查器允许您按具体字段（`subject`，`action`）检查策略是否与查询匹配。[guard]（guard）在内部使用
，但您应该知道检查程序类型：
*rule s checker-通用类型，用于检查用规则或规则字典定义的策略的匹配性
（基于规则的策略类型）。它提供了最高的灵活性。
大多数时候，您将使用这种类型的策略，从而使用这种类型的检查程序。
此外，它的性能比regexchecker高得多。请参见[Benchmark]（benchmark）了解更多详细信息。
``python
from vakt import ruleschecker
可以用regex语法定义（但如果policy中未定义regex，则返回到简单字符串相等性测试）-它比简单字符串具有更好的灵活性，但性能相对较慢。
可以配置lru缓存大小来调整性能。满足您的需要：
``来自vakt import regexcheck的python
ch=regexchecker（2048）
>ch2=regexchecker（512）
ch2=regexchecker（512）
等
````
详见[基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准br/>"foo"
```
，其中`<；gt；`是正则表达式bou的分隔符一部分。自定义策略可以重写
"开始标记"和"结束标记"属性来重新定义它们。通常，您总是希望使用第一个变量：`<；foo.*>；`.
*string exact checker-最快速的检查器：
``
checker，它使用精确的字符串相等。区分大小写。
例如"sunny"中的"sun"-false
"sun"中的"sun"-true
``````
*StringFuzzyChecker-具有一定灵活性的快速检查程序：
````
使用模糊子字符串相等的检查程序。区分大小写。
例如"sunny"中的"sun"-true
"sun"中的"sun"-true
`````
请注意，某些[存储]（存储）处理程序已经可以通过执行特定于该存储查询的操作来检查策略是否适合于
"find_for_inquiry（）"方法中的查询-存储可以（通常应该）
根据checker类被传递给[guard]（guard）构造函数
（或直接"find_for_inquiry（）"）。
不管存储返回的结果如何，checker始终是vakt做出决定之前的最后一行控件
*[返回顶部]（文档）*
做决定。它有一个方法'is allowed'，它传递了一个
[查询]（查询）给您一个布尔值答案：这个查询是否允许？
guard由[storage]（storage）和[checker]（checker）组成。如果使用ruleschecker，则具有基于字符串类型的策略将不匹配，反之亦然。
``python
st=memoryStorage（）
/>guard=guard（st，ruleschecker（））
，401
```
*[返回顶部]（文档）*
存储是一个组件，它提供一个接口，用于在各个位置操作[策略]（策略）持久性。
e策略按其ID
获取全部（限制，偏移量）检索所有存储的策略（带分页）
更新（策略）存储更新的策略
删除（uid）从存储中删除策略按其ID
查找用于查询（查询）的策略检索与给定查询匹配的策略
`````
ios后端实现（rdbms、nosql数据库等）。vakt提供了一些现成的存储实现。请参见下面的内容。
memory
在内存中存储策略的实现。它没有任何文件或其他东西的支持，因此每次重新启动
应用程序时，都会刷掉存储的所有内容。对测试有用。
mongodb
mongodb被选为最流行和最广泛的无SQL数据库。
``python
from pymongo import mongo client
from vakt.storage.mongo import mongostorage
client=mongoclient（'localhost'，27017）
storage=mongostorage（client，'database name'，collection=-optional-ccollection name'）
```
>默认集合名称为'vakt_policies'。
操作与符合'vakt.storage.abc.storage'基类接口的任何存储相同。
请注意，当前MongoStorage仅支持为stringExact和stringFuzzy检查程序编制索引的'find_for_inquiry（）'。
regexchecker（请参阅[此发布]（https://jira.mongodb.org/browse/server-11947）和ruleschecker只需返回数据库中的所有策略即可。
*[返回顶部]（文档）*
\因为它知道vakt对策略数据的要求。但无论如何，这并不是强制性的。
但是它取决于特定的存储来决定是否需要迁移。
它由3个组件组成：
*`migration`
*`migrationset`
*`migrator`
`migration`允许您描述版本之间的数据修改。
each存储可以有许多"migration"类来处理不同的版本，它们的迁移顺序
在"order"属性中指定。
应该位于特定的存储模块中并实现"vakt.storage.migration.migration"。
迁移有两种主要方法（如您可能猜测）和1个属性：
-`up`-向上运行db"schema"
-`down`-向下运行db"schema"（回滚'up`）的操作
-`order`-告诉行中当前迁移的数目
`migrationset`是表示存储迁移集合的组件.
您应该定义自己的迁移集。它应该位于特定的存储模块中，并实现
"vakt.storage.migration.migrationset"。它有3个方法，以防未实现：
-`migrations`-应返回所有初始化的迁移对象
-`save-applied`-在存储中保存一个应用了上一次迁移的lst，以供以后参考
-`last-applied`-返回一个从存储
`migrator`是迁移的执行者。它可以向上或向下执行所有迁移，或者在提供"number"参数的情况下执行特定的迁移。
示例用法：
``python
from pymongo import mongoclient
from vakt.storage.mongo import mongostorage，mongomigrationset
from vakt.storage.migration importmigrator
client=mongoclient（'localhost'，27017）
storage=mongostorage（client，'database name'，collection='optional-collection-name'）
migrator=migrator（mongomigrationset（storage））
migrator.up（）
…
migrator.down（）
…
migrator.up（number=2）
…
migrator.down（number=2）
```
*[返回顶部]（文档）*
\json
policy=policy（'1'）
json-policy=policy.to_json（）
print（json-policy）
{"actions"：[]，"description"：null，"effect"："deny"，"uid"："1"，
"resources"：[]，"context"：{，"subjects"：[]}
policy=policy.from_json（json-policy）
print（policy）
位于0x1023ca198>；
```
的策略对象同样适用于规则、查询。
从它们派生的所有自定义类也支持此功能。
如果不是从vakt的类派生，但需要此选项，则可以混入"vakt.util.jsonserializer"类。
``python
from vakt.util import jsonserializer
````
*[back to top]（documentation）*
pen但默认情况下日志消息由"nullhandler"处理。
由外部代码/应用程序提供所需的日志处理程序、筛选器、级别等。
例如：
``python
import logging
root=logging.getlogger（）
root.setlevel（logging.info）
root.addhandler（logging.streamhandler（））
…#这里是所有的vakt调用。
```
vakt日志可以e分为两个基本层次：
1。*错误/异常*-通知VAKT工作期间的异常和错误。
2.*信息*-提供有关传入查询及其解决方案的信息。
*[返回顶部]（文档）*
3535
>VAKT的初始代码思想基于
[亚马逊IAM政策]（https://github.com/awsdocs/iam-user-guide/blob/master/doc/docu-source/access-source/access-policicicicicicicics.md）和
[br/>[la是的cies sdk作为它的参考实现。
*[返回顶部]（文档）*
\
对于[memoryStorage]（memory），当[guard's]（guard）代码迭代整个策略列表以决定是否允许
查询时，它测量所有策略的决策过程的运行时间。如果是其他存储，则里程
可能会有所不同，因为它们可能返回符合给定查询的较小策略子集。
不要忘记，大多数外部存储都会为执行I/O操作增加一些时间限制。
运行时还取决于所使用的策略类型（因此是检查程序）：ruleschecker的性能比regex checker好得多。
示例：
``bash
python3 benchmark.py--checker regex--storage memory-n 1000
`````
输出是：
>；使用策略填充内存存储<；br/>；
>；………..<；br/>；
>；开始基准测试！<；br/>>；
>；数据库中的唯一策略数：1000个<；br/>>；
>；其中，具有相同regexp模式的策略：0<；br/>>；
>；使用的检查程序：regexchecker<；br/>>；
>；一次查询的决策：0.4451秒<；br/>>；
>；查询通过了检查？false<；br/>；
脚本用法：
```
用法：benchmark.py[-h][-n[policies_number][-d{mongo，memory}]
[-c{regex，rules，exact，fuzzy}[--regexp][--same same]
[--cache cache]
可选参数：
-h，-帮助显示此帮助消息。退出
-n[策略数]，--数[策略数]
db中要创建的策略数（默认值：100000）
-d{mongo，memory}，-storage{mongo，memory}
storage类型（默认值：memory）
-c{regex，rules，exact，fuzzy}，-checker{regex，rules，exact，fuzzy}
检查程序类型（默认值：regex）
regex策略相关：
--regexp是否应在不使用regex语法的情况下定义策略？
（默认值：true）
--策略中相同数量的相似regexp
--regexchecker的lru缓存数（默认值：
regexchecker的默认缓存大小）
````
*[返回顶部]（文档）*
本地运行：
``` bash
$…#使用首选方法（可选）激活虚拟环境
$pip install-e.[dev，mongo]以安装所有依赖项
$pytest-m"not integration"以运行覆盖率报告为
$pytest--cov=vakt tests的非集成测试/以获取覆盖率报告
$pylint vakt以检查代码质量使用pylint
`````
>只运行集成测试（对于存储适配器而不是‘memoryststorage```````bash
```bash
$docker run--rm-d-p 27017:27017:27017 mongo
$pytest-m integration
````
35;许可证
源代码是在apache许可证版本2.0下授权的
*[返回顶部]（文档）*
python的基于属性的访问控制（abac）sdk。
[！[构建状态]（https://travis-ci.org/kolotaev/vakt.svg？branch=master）（https://travis ci.org/kolotaev/vakt）
[！[codecov.io]（https://codecov.io/github/kolotaev/vakt/coverage.svg？branch=master）（https://codecov.io/github/kolotaev/vakt？分支=主）
[！[PYPI版本]（https://badge.fury.io/py/vakt.svg）（https://badge.fury.io/py/vakt）
[！[许可的apache 2.0]（https://img.shields.io/badge/license apache%202.0-yellow.svg）]（https://raw.githubusercontent.com/kolotaev/vakt/master/license）
----
-[文档
-[描述]
-[概念]（[概念]
-[安装]（[安装]
-[用法]"（#用法）
-[组件]（组件）
-[策略]（策略）
-[查询]（查询）
-[规则]（规则）
-[比较相关]（比较相关）
-[逻辑相关]（逻辑相关）
-[列表相关]（列表相关）
-[网络相关]（网络相关）
-[string-related]（3535; string-related）
-[inquiry-related]（inquiry-related）
-[checker]（checker）
-[guard]（guard）
-[stor储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储储
-[日志[例]（/例）
-[例]（/例）
-[确认]（[确认]）
-[基准]（[基准]）
-[开发]（[开发]
-[许可]（[许可]（[许可]）
abac不考虑rbac和acl模型，为您提供对限制资源访问的规则定义的细粒度控制，通常被认为是下一代在"授权模型"中，
其形式与[iam policies]类似（https://github.com/awsdocs/iam user guide/blob/master/doc-source/access-policies.md），但是
有一种更好的属性管理方式。
有关详细信息，请参阅[概念]部分。
*[返回顶部]（《文档》）n）*
\*正在请求哪些资源（资源）？*BR/> 1。*谁在请求资源？*BR/> 1。*请求对请求的资源执行哪些操作（操作）？*BR/> 1。*在请求本身的上下文中应该满足哪些规则？*BR/> 1。*答案对上述问题有何影响？*
"vakt"工作流的总体图是：
[！[vakt图]（diagram.svg）-（diagram.svg）
vakt允许您获得：
*基于策略的访问控制（vakt基于描述访问规则、资源策略的策略）
*细粒度授权（vakt策略允许您对资源进行细粒度控制）'s、subject's、action's和context's attributes）
*动态授权管理（您可以添加策略并更改其属性）
*外部授权管理（您可以使用vakt构建自己的外部authz服务器，请参阅示例）
*[返回顶部]（文档）*
pypypy实现也受支持。
对于内存存储：
``bash
pip install vakt
````
对于mongodb存储：
```bash
``pip install vakt[mongo]
```
<>快速切入：
``` python
import uuid
import vakt
from vakt.rules导入eq，any，startswith，and，greater，less
actions=[eq（'fork'），eq（'clone'）]，
resources=[startswith（'repos/google'，ci=true]，
subjects=[{'name'：any（），'stars'：and（greater（50），less（999））}，
effect=vakt.允许访问，
context={'referer'：'https://github.com'}，
description="
允许使用fork或为那些拥有50颗和999颗星星并且来自github的用户克隆任何google存储库
"
"）
storage=vakt.memoryStorage（）
storage.add（policy）
guard=vakt.guard（storage，vakt.ruleschecker（））
inq=vakt.inquiry（action='fork'，
resource='repos/google/tensorflow'，
subject={'name'：'larry'，'stars'：80}，
context={'referer'：'https://github.com'}）
assert guard.is懔allowed（inq）
````
ion）*
回答：问什么？
*主题-主题列表。答：谁要求获得资源？
*操作-操作列表。答：要求对资源执行哪些操作？
*上下文-给定查询上下文应满足的规则。
*效果-如果策略匹配上述所有条件，它意味着什么效果？
可以是"vakt.allow_access"或"vakt.deny_access"
所有"resources"、"subjects"和"actions"都用
一个包含字符串、正则表达式、[规则]（rules）或字符串（属性）字典到[规则]（rules）的列表来描述。
列表中的每个元素都充当逻辑或。规则字典中的每个键都充当逻辑和。
"上下文"只能用[规则]（规则）字典来描述。
根据描述"资源"、"主题"、"操作"的方式，策略可以具有基于字符串或基于规则的类型。可由"policy.type"检查。
这强制使用具体的checker实现。有关详细信息，请参见[检查器]（检查器）。
``python
from vakt import policy，allow懔access
from vakt.rules import cidr，any，eq，noteq，in
管理接口子类别："panel"、"switch"（如果用户不是开发人员，并且来自本地IP地址）。
"，
操作=[any（）]，
资源=[{'category'：eq（'a dministration'），'sub'：in（['panel'，'switch']），
主题=[{'name'：any（），'role'：noteq（'developer'）}]，
effect=allow廑access，
context={'ip'：cidr（'127.0.0.1/32'）}
）
书籍或杂志，
但仅当它们从本地图书馆的计算机连接时，
效果=允许访问，
主题=['<；[\w]+m[\w]+>；']，
资源=（'library:book s:<；+>；'，'office:magages:<；+>；'），
操作=['<；读取'get>；']，
context={'ip'：cidr（'192.168.2.0/24'）}
）
````
基本上，您希望创建一些包含域访问规则的策略集，并将它们存储起来，以便由[guard]（guard）组件做出未来的决策。
``python
st=memoryStorage（）
st.add（p）
```
*[返回顶部]（文档）*
查询
查询是vakt和外部世界资源访问请求之间的中介对象。您只需要
接受任何类型的传入请求（rest请求、soap等）并根据其顺序构建一个"查询"把它喂给vakt。没有任何具体的构建器可以从不同的请求类型进行查询，因为这是一个非常细致的
过程，而且您可以亲自控制自己进行查询。让我们看一个例子：
``python
from vakt import inquiry
from flask import request，session
…
le"：请求。如果定义了策略，则form['user_role']}，
action=request.form['action']，
resource={'book'：session.get（'book'），'chapter'：请求。form['chapter']}，
context={'ip'：请求。remote_addr}）
使用字符串或正则表达式：
inquiry=inquiry（subject=request.form['username'，
action=request.form['action'，
resource=request.form['page'，
context={'ip'：request.remote_addr}）
````
烧瓶请求和附加请求信息中的参数。然后我们将它们转换为查询。就这样。
inquiry有几个构造函数参数：
*resource-any dictionary of str->；any。请求访问哪些资源？
*操作-任意字典str->；任意。要求对资源做什么？
*主题-任意字典str->；任意。谁要的？
*上下文-字典str->；任意。请求的上下文是什么？
如果您足够细心，您可能已经注意到查询类似于策略，策略描述了所有者端资源访问的多个
变体，查询描述了消费者端的具体访问场景。
*[返回顶部]（文档）*
规则
规则允许您直接描述"操作"、"主题"、"资源"和"上下文"或其属性上的条件。
如果规则集中至少有一个规则不满足要求，则给定策略将拒绝查询。
将规则集附加到策略很简单。以下是一些示例：
``python
from vakt import policy，rules
policy（
…，
subjects=[{name'：rules.eq（'.kimzihhh0gsrc'）}，
policy（
…，
actions=[rules.eq（'get'），rules.eq（'list'），rules.eq（'read'），
，
policy（
…，
context={
"secret"：rules.string.equal（'.kimzihhh0gsrc'），
"ip"：rules.net.cidr（'192.168.0.15/24'）
}，
）
`````
自己的[自己的]（./examples/extending.py）。
规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则；
noteq `年龄：noteq（40）` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `>lessorequal `'stars'：lessorequal（300）` `'stars'：300`||
逻辑相关
规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则查询规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则规则
法尔西``阿美n'：falsy（）` `'admin'：lambda x:x.is_admin（）` `对查询创建的求值
`'age'：not（大于（90））` ` `'age'：40`；
` ` ` ` ` ` ` `格雷水（50），小于（120），Eq（8888）` ` `星'：78`还有，一个列表中的规则，比如说，` actions`充当或逻辑
任何` actions=[any（）]` ` action='get'`，` action='foo'`适合任何值的占位符
两个` subjects=[none（）]` ` subject='max'`，` subject='joe'`都不是很有用，只剩下了作为任何<
攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀攀br/>notin `'方法：notin（'get'"，"post'````方法'：'get'``` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `.5，4.9）``高度'：[7.55]``高度'：AnyNotIn（5.9，7.5，4.9）` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `'IP'：CIDR（'192.168.2.0/24'）` `'IP'：192.168.2.4`
如果您希望字符串类型检查和大小写不区分敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串类型检查和大小写不敏感度的字符串名称：pairsequal（）`` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `：开始（"'logs-'''```文件'：'logs-data-101967.log'`````支持不区分大小写的不区分大小写
endswith `'file'：endswith（'.log'）````文件'：'logs-data-101967.log'`````支持不区分大小写的不区分大小写；
`包含``文件''：contains（'sun'）````'sun'''file''：'obisonsinsinsun晴天.csv'`````````````````文件''confensensensis支持不区分大小写不区分大小写的不区分大小写；
|注：subjectequal数据：subjectequal（）``查询（subject='max'）``只对字符串有效；查询（actionequal（）``查询（action='get'）``只对字符串有效"：resourcein（）` `查询（resource='/books/'）`仅适用于字符串
*[返回顶部]（文档）*
检查器
检查器允许您按具体字段（`subject`，`action`）检查策略是否与查询匹配。[guard]（guard）在内部使用
，但您应该知道检查程序类型：
*rule s checker-通用类型，用于检查用规则或规则字典定义的策略的匹配性
（基于规则的策略类型）。它提供了最高的灵活性。
大多数时候，您将使用这种类型的策略，从而使用这种类型的检查程序。
此外，它的性能比regexchecker高得多。请参见[Benchmark]（benchmark）了解更多详细信息。
``python
from vakt import ruleschecker
可以用regex语法定义（但如果policy中未定义regex，则返回到简单字符串相等性测试）-它比简单字符串具有更好的灵活性，但性能相对较慢。
可以配置lru缓存大小来调整性能。满足您的需要：
``来自vakt import regexcheck的python
ch=regexchecker（2048）
>ch2=regexchecker（512）
ch2=regexchecker（512）
等
````
详见[基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准基准br/>"foo"
```
，其中`<；gt；`是正则表达式bou的分隔符一部分。自定义策略可以重写
"开始标记"和"结束标记"属性来重新定义它们。通常，您总是希望使用第一个变量：`<；foo.*>；`.
*string exact checker-最快速的检查器：
``
checker，它使用精确的字符串相等。区分大小写。
例如"sunny"中的"sun"-false
"sun"中的"sun"-true
``````
*StringFuzzyChecker-具有一定灵活性的快速检查程序：
````
使用模糊子字符串相等的检查程序。区分大小写。
例如"sunny"中的"sun"-true
"sun"中的"sun"-true
`````
请注意，某些[存储]（存储）处理程序已经可以通过执行特定于该存储查询的操作来检查策略是否适合于
"find_for_inquiry（）"方法中的查询-存储可以（通常应该）
根据checker类被传递给[guard]（guard）构造函数
（或直接"find_for_inquiry（）"）。
不管存储返回的结果如何，checker始终是vakt做出决定之前的最后一行控件
*[返回顶部]（文档）*
做决定。它有一个方法'is allowed'，它传递了一个
[查询]（查询）给您一个布尔值答案：这个查询是否允许？
guard由[storage]（storage）和[checker]（checker）组成。如果使用ruleschecker，则具有基于字符串类型的策略将不匹配，反之亦然。
``python
st=memoryStorage（）
/>guard=guard（st，ruleschecker（））
，401
```
*[返回顶部]（文档）*
存储是一个组件，它提供一个接口，用于在各个位置操作[策略]（策略）持久性。
e策略按其ID
获取全部（限制，偏移量）检索所有存储的策略（带分页）
更新（策略）存储更新的策略
删除（uid）从存储中删除策略按其ID
查找用于查询（查询）的策略检索与给定查询匹配的策略
`````
ios后端实现（rdbms、nosql数据库等）。vakt提供了一些现成的存储实现。请参见下面的内容。
memory
在内存中存储策略的实现。它没有任何文件或其他东西的支持，因此每次重新启动
应用程序时，都会刷掉存储的所有内容。对测试有用。
mongodb
mongodb被选为最流行和最广泛的无SQL数据库。
``python
from pymongo import mongo client
from vakt.storage.mongo import mongostorage
client=mongoclient（'localhost'，27017）
storage=mongostorage（client，'database name'，collection=-optional-ccollection name'）
```
>默认集合名称为'vakt_policies'。
操作与符合'vakt.storage.abc.storage'基类接口的任何存储相同。
请注意，当前MongoStorage仅支持为stringExact和stringFuzzy检查程序编制索引的'find_for_inquiry（）'。
regexchecker（请参阅[此发布]（https://jira.mongodb.org/browse/server-11947）和ruleschecker只需返回数据库中的所有策略即可。
*[返回顶部]（文档）*
\因为它知道vakt对策略数据的要求。但无论如何，这并不是强制性的。
但是它取决于特定的存储来决定是否需要迁移。
它由3个组件组成：
*`migration`
*`migrationset`
*`migrator`
`migration`允许您描述版本之间的数据修改。
each存储可以有许多"migration"类来处理不同的版本，它们的迁移顺序
在"order"属性中指定。
应该位于特定的存储模块中并实现"vakt.storage.migration.migration"。
迁移有两种主要方法（如您可能猜测）和1个属性：
-`up`-向上运行db"schema"
-`down`-向下运行db"schema"（回滚'up`）的操作
-`order`-告诉行中当前迁移的数目
`migrationset`是表示存储迁移集合的组件.
您应该定义自己的迁移集。它应该位于特定的存储模块中，并实现
"vakt.storage.migration.migrationset"。它有3个方法，以防未实现：
-`migrations`-应返回所有初始化的迁移对象
-`save-applied`-在存储中保存一个应用了上一次迁移的lst，以供以后参考
-`last-applied`-返回一个从存储
`migrator`是迁移的执行者。它可以向上或向下执行所有迁移，或者在提供"number"参数的情况下执行特定的迁移。
示例用法：
``python
from pymongo import mongoclient
from vakt.storage.mongo import mongostorage，mongomigrationset
from vakt.storage.migration importmigrator
client=mongoclient（'localhost'，27017）
storage=mongostorage（client，'database name'，collection='optional-collection-name'）
migrator=migrator（mongomigrationset（storage））
migrator.up（）
…
migrator.down（）
…
migrator.up（number=2）
…
migrator.down（number=2）
```
*[返回顶部]（文档）*
\json
policy=policy（'1'）
json-policy=policy.to_json（）
print（json-policy）
{"actions"：[]，"description"：null，"effect"："deny"，"uid"："1"，
"resources"：[]，"context"：{，"subjects"：[]}
policy=policy.from_json（json-policy）
print（policy）
位于0x1023ca198>；
```
的策略对象同样适用于规则、查询。
从它们派生的所有自定义类也支持此功能。
如果不是从vakt的类派生，但需要此选项，则可以混入"vakt.util.jsonserializer"类。
``python
from vakt.util import jsonserializer
````
*[back to top]（documentation）*
pen但默认情况下日志消息由"nullhandler"处理。
由外部代码/应用程序提供所需的日志处理程序、筛选器、级别等。
例如：
``python
import logging
root=logging.getlogger（）
root.setlevel（logging.info）
root.addhandler（logging.streamhandler（））
…#这里是所有的vakt调用。
```
vakt日志可以e分为两个基本层次：
1。*错误/异常*-通知VAKT工作期间的异常和错误。
2.*信息*-提供有关传入查询及其解决方案的信息。
*[返回顶部]（文档）*
3535
>VAKT的初始代码思想基于
[亚马逊IAM政策]（https://github.com/awsdocs/iam-user-guide/blob/master/doc/docu-source/access-source/access-policicicicicicicics.md）和
[br/>[la是的cies sdk作为它的参考实现。
*[返回顶部]（文档）*
\
对于[memoryStorage]（memory），当[guard's]（guard）代码迭代整个策略列表以决定是否允许
查询时，它测量所有策略的决策过程的运行时间。如果是其他存储，则里程
可能会有所不同，因为它们可能返回符合给定查询的较小策略子集。
不要忘记，大多数外部存储都会为执行I/O操作增加一些时间限制。
运行时还取决于所使用的策略类型（因此是检查程序）：ruleschecker的性能比regex checker好得多。
示例：
``bash
python3 benchmark.py--checker regex--storage memory-n 1000
`````
输出是：
>；使用策略填充内存存储<；br/>；
>；………..<；br/>；
>；开始基准测试！<；br/>>；
>；数据库中的唯一策略数：1000个<；br/>>；
>；其中，具有相同regexp模式的策略：0<；br/>>；
>；使用的检查程序：regexchecker<；br/>>；
>；一次查询的决策：0.4451秒<；br/>>；
>；查询通过了检查？false<；br/>；
脚本用法：
```
用法：benchmark.py[-h][-n[policies_number][-d{mongo，memory}]
[-c{regex，rules，exact，fuzzy}[--regexp][--same same]
[--cache cache]
可选参数：
-h，-帮助显示此帮助消息。退出
-n[策略数]，--数[策略数]
db中要创建的策略数（默认值：100000）
-d{mongo，memory}，-storage{mongo，memory}
storage类型（默认值：memory）
-c{regex，rules，exact，fuzzy}，-checker{regex，rules，exact，fuzzy}
检查程序类型（默认值：regex）
regex策略相关：
--regexp是否应在不使用regex语法的情况下定义策略？
（默认值：true）
--策略中相同数量的相似regexp
--regexchecker的lru缓存数（默认值：
regexchecker的默认缓存大小）
````
*[返回顶部]（文档）*
本地运行：
``` bash
$…#使用首选方法（可选）激活虚拟环境
$pip install-e.[dev，mongo]以安装所有依赖项
$pytest-m"not integration"以运行覆盖率报告为
$pytest--cov=vakt tests的非集成测试/以获取覆盖率报告
$pylint vakt以检查代码质量使用pylint
`````
>只运行集成测试（对于存储适配器而不是‘memoryststorage```````bash
```bash
$docker run--rm-d-p 27017:27017:27017 mongo
$pytest-m integration
````
35;许可证
源代码是在apache许可证版本2.0下授权的
*[返回顶部]（文档）*
欢迎加入QQ群-->： 979659372
