この記事の内容
実際に
Practical Regoの 始め方
この
通常の
この
この
Regoの概要
Open Policy Agent(
Regoは、
宣言型プログラミング
宣
命令型
def is_even(x):
remainder = x % 2
if remainder == 0:
return True
return False宣
is_even {
remainder == 0
remainder = input % 2
}
[プレイグラウンド]
Regoでは、
論理プログラミング
Datalogは、
次に
Regoでは、
前述の
存在量化
プログラミングに
Regoは存在 量化(FOR ANYと
命令型FOR ALLと
どちらの
存在量化の
抽象的に
存在量化は
エントリーポイント
Regoには、data.mypolicies.denyです。mypolicies内のdeny Regoルールを
エントリーポイントをinput ドキュメントが
最適化
この
この
この
ルール
package earlyexit.iteration
p {
some p
data.projects[p] == "project-a"
}
変数のdata.earlyexit.iteration.pの
つまり、data.projectsをproject-aと
等価性
Regoには、
等価演算子 | 意味 |
|---|---|
| 比較演算子。 |
| 代入演算子。 |
| 単 |
=演算子は、
# input
[1, 2, 5]
# code
default allow := false
allow {
input[_] = 5 # assignment fails, comparison evaluates to `true`
# (`input[_] := 5` creates error "cannot assign to ref")
}
# output
{
"allow": true
}
[プレイグラウンド]
`=`演算子を使う理由がない限り、使用は避けることをお勧めします[13]。代入には`:=`演算子を、比較には`==`演算子を使用してください。
ポリシー、ルール、関数
この
ポリシー
ポリシーとは、allowとdenyの
package mypolicy
allow {
input.name == "bar"
}
deny {
input.name == "foo"
}
ルール
ルールは、
# input
[
"world-a",
"universe-a",
"world-b",
"universe-b"
]
# code
worlds[world] {
item := input[_] # loop over `input`
startswith(item, "world")
world := item # var `world` is return value
}
universes[universe] {
item := input[_]
startswith(item, "universe")
universe := item
}
# output
{
"universes": [
"universe-a",
"universe-b"
],
"worlds": [
"world-a",
"world-b"
]
}
[プレイグラウンド]
戻り値がtrueを
したがって、
deny := true if { # rule header
true # rule body
}
deny { # optimized rule header
true
}前述の
allow := true {
false
}set型またはobject型の
# input
[
"a",
"b",
"c",
"c"
]
# code
return_set[item] {
item := input[_]
}
return_object[key] := value {
value := input[key]
}
# output
{
"return_object": {
"0": "a",
"1": "b",
"2": "c",
"3": "c"
},
"return_set": [
"a",
"b",
"c"
]
}
[プレイグラウンド]
Regoルールはreturn_set(param1は
存在量化
OPAの
命令型言語では
for n in numbers: # think "FOR ALL" items `n` in numbers
if n % 2 == 0:
print(n)このnumbersから
even_numbers[n] {
n := input[_]
n % 2 == 0 # think "FOR ANY" item `n` in inputs
}上のsomeをnをinputから、nをnの
一致する
必須ではありませんが、someを
文字列1で
# input
{
"a": "1a",
"b": "2b",
"c": "1c"
}
# code
prefixed[item] {
item := input[_]
startswith(item, "1")
}
# output
{
"prefixed": [
"1a",
"1c"
]
}[プレイグラウンド]
item := input[_]とbはstartswith(l, "1")をcに
この
関数
Regoの
greet(name) := msg {
msg := sprintf("Hello %s!", [name])
}
greeting := greet("Bob") # returns "Hello Bob!"パラメーターの
greet() := msg {
msg := "Hello"
}
greet() # creates error "rego_parse_error:
# rule argument list must take at least one argument"ルールは
# input
[
[1, 1],
[2, 2],
[3, 3]
]
# code
add_function(inp) := result { # define function
result := [ sum | # create array comprehension
arr := inp[_]
sum := arr[0] + arr[1]
]
}
output := add_function(input) # store result of function
dummy_rule_iterate_function_output[item] {
item := output[index] # work with function result
}
add_rule = result { # define rule
result := [ sum | # create array comprehension
arr := input[_]
sum := arr[0] + arr[1]
]
}
dummy_rule_iterate_rule[item] {
item := add_rule[index] # work with rule result
}
# output
"add_rule": [
2,
4,
6
],
"output": [
2,
4,
6
]
[プレイグラウンド]
ルールと
制御フロー
基本
複数の
# input
{
"name": "foo"
}
# code
my_rule {
startswith(input.name, "f") # first condition (AND..)
endswith(input.name, "o") # second condition
}
# output
{
"my_rule": true
}
[プレイグラウンド]
ルールがtrueとtrueとtrueに
次のmy_ruleルールは
# input
{
"name": "foo"
}
# code
my_rule {
count(input.name) == 3
}
my_rule {
input.name == "foobar" # not true; aborts execution
}
# output
{
"my_rule": true
}[プレイグラウンド]
elseキーワードを
# input
{
"name": "foo"
}
# code
my_rule := msg {
input.name == "foo"
msg := "Hello foo!"
} else := msg {
msg := "Hello anonymous"
}
# output
{
"my_rule": "Hello foo!"
}[プレイグラウンド]
否定ロジックはnotキーワードを
# input
{
"a": "1a",
"b": "2b",
"c": "1c"
}
# code
prefixed[item] {
item := input[_]
not startswith(item, "1")
}
# output
{
"prefixed": [
"2b"
]
}[プレイグラウンド]
not演算子は!=演算子は
ループ
Regoでは
構文の曖昧さ
Regoでは、
# input
{
"array": [0, 3, 5],
"object": {"foo": "bar"}
}
# code
iterate_array[msg] { # returns array of strings
value := input.array[index] # loop over array
msg := sprintf("%d: %d", [index, value])
}
access_key_in_object := v { # returns string
v := input.object["foo"] # get value by key "foo"
}
create_set := s {
s := { v |
v := input.array[_]
}
}
iterate_set[v] { # returns array of integers
create_set[v] # iterate over set
}
check_key_in_object { # returns `true`
input.object["foo"] # check if key "foo" exists
}[プレイグラウンド]
文脈なしに
例1:
var3 := var1[var2]
var1の
| その |
| その |
例2:
var1[var2]
var1の
| その |
| その |
| その |
落とし穴
あらゆる
これを
OPAには、
コンパイルエラーや コードの 問題点の 特定に 役立つ checkという組み込みコマンドが 用意されています。
OPAを
開発するStyraは、 コードスタイルから バグまで、 さまざまな 問題を ソースコードから 分析する Rego用リンター、 regalをリリースしました。
早期終了の最適化
「最適化」
ユーザーから
# input
[
"on-prem",
"remote",
"on-prem",
"on-prem"
]
# code
default allow := false
allow {
input[_] == "on-prem"
}
# output
{
"allow": true
}[プレイグラウンド]
このtrueに
たとえば、
origins = ['on-prem', 'remote', 'on-prem', 'on-prem']
def allow():
for origin in origins:
if origin != 'on-prem':
return 1
return 0
if __name__ == '__main__':
raise SystemExit(allow())このallowのtrueとon-premにoriginsの
このFOR ALL)を
修正方法のcomprehensionを
default allow := false
allow {
all_allows := [ allowed |
origin := input[_]
origin == "on-prem"
allowed := true
]
count(all_allows) == count(input)
}[プレイグラウンド]
もうeveryキーワードを
import future.keywords.every
default allow := false
allow {
every origin in input {
origin == "on-prem"
}
}[プレイグラウンド]
3つ目の
# input
[
"remote",
"on-prem",
"on-prem"
]
# code
default deny := false
deny {
input[_] != "on-prem"
}
# output
{
"deny": true
}[プレイグラウンド]
このdenyルールは、trueを
ただし、everyキーワードを
反復処理を
未定義の値
上記のtrueとfalseをundefinedの
たとえば、undefinedと
意図しない
# input
{
"message": "world"
}
# code
deny {
input.mesage == "world"
}
# output
{}[プレイグラウンド]
属性input.mesageにはundefinedかを
このprint()ステートメントを
問題の
JSONの「true」
OPAへのinputドキュメントはtrue」)
# input
{
"privileged": "true"
}
# code
deny {
input.privileged == true
}
# output
{}[プレイグラウンド]
修正方法と
1# input
2{
3 "privileged": "true"
4}
5
6# code
7is_true(b) := ret {
8 is_boolean(b)
9 b
10 ret := b
11} else := ret {
12 b == "true"
13 ret := true
14} else = false {
15 true
16}
17
18deny {
19 is_true(input.privileged)
20}
21
22# output
23{
24 "deny": true
25}[プレイグラウンド]
テスト
ポリシーがtestコマンドが
次のpolicy.rego)が
package mypolicy
deny {
input.privileged == true
}テストpolicy_tests.rego)は
package mypolicy
test_deny_privileged {
deny with input as {"privileged": true}
}
test_deny_unprivileged {
not deny with input as {"privileged": false}
}コマンド./opa test policy.rego policy_tests.regoをPASS: 2/2が
デバッグ
デバッグは、evalコマンドがgdbのような
このtrue」で
test_deny_string {
deny with input as {"privileged": "true"}
}予想どおり、
$ ./opa test policy.rego policy_test.rego
policy_test.rego:
data.mypolicy.test_deny_string: FAIL (85.375µs) --------------------------------------------------------------------------------
PASS: 2/3
FAIL: 1/3
問題をprint()をinput.privilegedの
deny {
print(sprintf("value of `privileged`: %v", [input]))
input.privileged == true
}テストケースを
$ ./opa test policy.rego policy_test.rego
policy_test.rego:
data.mypolicy.test_deny_string: FAIL (88.875µs)
value of `privileged`: {"privileged": "true"} --------------------------------------------------------------------------------
PASS: 2/3
FAIL: 1/3
出力からinput.privilegedの
OPAでは、print()関数をprint()はundefinedのundefined>と
コードの
よくあるエラー
Complete rules must not produce multiple outputs
同じ
# input
-
# code
a_rule := res {
res := "b"
}
a_rule := res {
res := "c"
}
# outputpolicy.rego:7: eval_conflict_error: complete rules must not produce multiple outputs
[プレイグラウンド]
a_ruleのb」をc」を
多くの
# input
-
# code
a_rule[res] {
res := "b"
}
a_rule[res] {
res := "c"
}
# output
{
"a_rule": [
"b",
"c"
]
}[プレイグラウンド]
もう
重要な処理でのOPAの活用
Regoと
ただし、
その
たとえば、