什么是CEL？

CEL 是一種非圖靈完備的表達式語言 ，旨在快速、可移植且執(zhí)行安全。CEL 可以單獨使用，也可以嵌入到其他的產(chǎn)品中。

CEL被設(shè)計成一種可以安全地執(zhí)行用戶代碼的語言。雖然盲目調(diào)用用戶的python代碼是危險的，但您可以安全地執(zhí)行用戶的CEL代碼。由于CEL防止了會降低其性能的行為，因此它的評估安全性在納秒到微秒之間；它非常適合性能關(guān)鍵型應(yīng)用程序。eval()

CEL 計算表達式，類似于單行函數(shù)或 lambda 表達式。雖然 CEL 通常用于布爾決策，但它也可用于構(gòu)造更復(fù)雜的對象，如 JSON 或 protobuf 消息。

關(guān)鍵概念

應(yīng)用

CEL是通用的，已用于各種應(yīng)用程序，從路由RPC到定義安全策略。CEL是可擴展的，與應(yīng)用程序無關(guān)，并針對一次編譯、多次評估的工作流進行了優(yōu)化。 許多服務(wù)和應(yīng)用程序評估聲明性配置。例如，基于角色的訪問控制（RBAC）是一種聲明性配置，它在給定角色和一組用戶的情況下生成訪問決策。如果聲明性配置是80%的用例，那么當(dāng)用戶需要更強的表達能力時，CEL是一個有用的工具，可以將剩余的20%取整。

編譯

表達式是針對環(huán)境編譯的。編譯步驟生成protobuf 形式的抽象語法樹（AST）。編譯后的表達式通常會存儲起來以備將來使用，從而使求值盡可能快。單個編譯表達式可以使用許多不同的輸入進行求值。

抽象語法樹：

在計算機科學(xué)中，抽象語法樹（Abstract Syntax Tree，AST），或簡稱語法樹（Syntax tree），是源代碼語法結(jié)構(gòu)的一種抽象表示。它以樹狀的形式表現(xiàn)編程語言的語法結(jié)構(gòu)，樹上的每個節(jié)點都表示源代碼中的一種結(jié)構(gòu)。之所以說語法是“抽象”的，是因為這里的語法并不會表示出真實語法中出現(xiàn)的每個細節(jié)。比如，嵌套括號被隱含在樹的結(jié)構(gòu)中，并沒有以節(jié)點的形式呈現(xiàn)；而類似于 if-condition-then 這樣的條件跳轉(zhuǎn)語句，可以使用帶有三個分支的節(jié)點來表示。

和抽象語法樹相對的是具體語法樹（通常稱作分析樹）。一般的，在源代碼的翻譯和編譯過程中，語法分析器創(chuàng)建出分析樹，然后從分析樹生成AST。一旦AST被創(chuàng)建出來，在后續(xù)的處理過程中，比如語義分析階段，會添加一些信息。

表達式

用戶定義表達式；服務(wù)和應(yīng)用程序定義了它運行的環(huán)境。函數(shù)簽名聲明輸入，并在CEL表達式之外編寫。CEL 可用的函數(shù)庫是自動導(dǎo)入的。 在下面的示例中，表達式采用一個請求對象，該請求包括一個聲明令牌。該表達式返回一個布爾值，指示聲明令牌是否仍然有效。

// 通過檢查“exp”聲明來檢查JSON Web令牌是否已過期。
//
// Args:
//   claims - authentication claims.
//   now    - timestamp indicating the current system time.
// 如果令牌已過期，則返回：true
//
timestamp(claims["exp"]) < now

環(huán)境

環(huán)境是由服務(wù)定義的。嵌入CEL的服務(wù)和應(yīng)用程序聲明表達式環(huán)境。環(huán)境是可以在表達式中使用的變量和函數(shù)的集合。 CEL 類型檢查器使用基于原型的聲明來確保表達式中的所有標(biāo)識符和函數(shù)引用都得到了正確的聲明和使用。

解析表達式的三個階段

處理表達式有三個階段：解析 、檢查 和求值 。CEL最常見的模式是控制平面在配置時解析和檢查表達式，并存儲AST。

在運行時，數(shù)據(jù)平面會重復(fù)檢索和評估AST。CEL 針對運行時效率進行了優(yōu)化，但不應(yīng)在延遲關(guān)鍵的代碼路徑中進行解析和檢查。

CEL使用ANTLR lexer/parser語法從人類可讀的表達式解析為抽象語法樹。解析階段發(fā)出一個基于原型的抽象語法樹，其中AST中的每個Expr節(jié)點都包含一個整數(shù)id，用于索引解析和檢查期間生成的元數(shù)據(jù)。解析過程中生成的syntax.proto忠實地表示了以字符串形式鍵入的內(nèi)容的抽象表示。

一旦解析了表達式，就可以根據(jù)環(huán)境對其進行檢查，以確保表達式中的所有變量和函數(shù)標(biāo)識符都已聲明并正確使用。類型檢查器生成一個checked.proto，其中包括類型、變量和函數(shù)解析元數(shù)據(jù)，可以顯著提高評估效率。

評估CEL需要3件事：

• 任何自定義擴展的函數(shù)綁定

• 變量綁定

• AST評估

函數(shù)和變量綁定應(yīng)該與用于編譯AST的綁定相匹配。這些輸入中的任何一個都可以在多個評估中重復(fù)使用，例如在多組變量綁定中評估AST，或者在多個AST中使用相同的變量，或者在進程的整個生命周期中使用函數(shù)綁定（常見情況）。

CEL 適合您的項目嗎？

由于 CEL 以納秒到微秒為單位評估 AST 的表達式，因此 CEL 的理想用例是具有性能關(guān)鍵路徑的應(yīng)用程序。不應(yīng)在關(guān)鍵路徑中將 CEL 代碼編譯到 AST 中;理想的應(yīng)用程序是經(jīng)常執(zhí)行配置且修改頻率相對較低的應(yīng)用程序。

例如，對服務(wù)的每個 HTTP 請求執(zhí)行安全策略是 CEL 的理想用例，因為安全策略很少更改，并且 CEL 對響應(yīng)時間的影響可以忽略不計。在這種情況下，CEL 將返回一個布爾值（無論是否允許該請求），但它可能會返回更復(fù)雜的消息。

在 golang 中如何使用 CEL

一下代碼我們使用 golang 的 cel 包 github.com/google/cel-go/cel

使用 cel 進行字符串拼接：

字符串 str = "Hello world! I'm " + name + "."中存在變量 name ,在我們的程序中，這個 name 是一個變量，需要在程序中替換為具體的值，比如：張三

步驟如下：

1、先初始化 env，也就是我們上面說的需要配置執(zhí)行的環(huán)境

2、在環(huán)境中綁定變量 name 以及類型

3、env.Compile(str) 就是做了我們上面所說的編譯并解析表達式,返回 str 所對應(yīng)的ast

4、程序求值。我們將 name 需要的具體值傳到 program 中執(zhí)行 values := map[string]interface{}{"name": "CEL"}

5、獲取到最后的結(jié)果

func Test_exprReplacement(t *testing.T) {
    var str = `"Hello world! I'm " + name + "."`
    env, err := cel.NewEnv(
        cel.Variable("name", cel.StringType), // 參數(shù)類型綁定
    )
    if err != nil {
        t.Fatal(err)
    }
    ast, iss := env.Compile(str) // 編譯，校驗，執(zhí)行 str
    if iss.Err() != nil {
        t.Fatal(iss.Err())
    }
    program, err := env.Program(ast)
    if err != nil {
        t.Fatal(err)
    }
  // 初始化 name 變量的值
    values := map[string]interface{}{"name": "CEL"}
  // 傳給內(nèi)部程序并返回執(zhí)行的結(jié)果
    out, detail, err := program.Eval(values)
    if err != nil {
        t.Fatal(err)
    }
    fmt.Println(detail)
    fmt.Println(out)
}

測試結(jié)果：

Running tool: /usr/local/go/bin/go test -timeout 10s -run ^Test_exprReplacement$ github.com/demo007x/goexpr -v

=== RUN   Test_exprReplacement
Hello world! I'm CEL.
<nil>
--- PASS: Test_exprReplacement (0.00s)
PASS
ok      github.com/demo007x/goexpr    0.010s

計算一個表達式的邏輯結(jié)果：

返回表達式 var str = 100 + 200 >= 300 的執(zhí)行結(jié)果：

執(zhí)行步驟跟上面的一樣，這里就省略了。

func Test_LogicExpr1(t *testing.T) {
    var str = `100 + 200 >= 300`
    env, err := cel.NewEnv()
    if err != nil {
        t.Fatal(err)
    }
    ast, iss := env.Compile(str)
    if iss.Err() != nil {
        t.Fatal(iss.Err())
    }
    prog, err := env.Program(ast)
    if err != nil {
        t.Fatal(err)
    }
    out, detail, err := prog.Eval(map[string]interface{}{})
    if err != nil {
        t.Fatal(err)
    }
    fmt.Println(out)
    fmt.Println(detail)
}

輸出結(jié)果：

Running tool: /usr/local/go/bin/go test -timeout 10s -run ^Test_LogicExpr1$ github.com/demo007x/goexpr -v

=== RUN   Test_LogicExpr1
true
<nil>
--- PASS: Test_LogicExpr1 (0.00s)
PASS
ok      github.com/demo007x/goexpr    0.010s

執(zhí)行一個有函數(shù)的表達式會是咋樣的呢？

先定一一個函數(shù)：

type Integer interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

// 求所有傳入?yún)?shù)的和
func Add[T Integer](param1, param2 T, ints ...T) T {
    sum := param1 + param2
    for _, v := range ints {
        sum += v
    }
    return sum
}

執(zhí)行有函數(shù)的表達式：6 == Add(age1, age2, age3

func Test_add(t *testing.T) {
    str := `6 == Add(age1, age2, age3)`
    env, _ := cel.NewEnv(
        cel.Variable("age1", cel.IntType),
        cel.Variable("age2", cel.IntType),
        cel.Variable("age3", cel.IntType),
        cel.Function("Add", cel.Overload(
            "Add",
            []*cel.Type{cel.IntType, cel.IntType, cel.IntType},
            cel.IntType,
            cel.FunctionBinding(func(vals ...ref.Val) ref.Val {
                var xx []int64
                for _, v := range vals {
                    xx = append(xx, v.Value().(int64))
                }
                return types.Int(Add[int64](xx[0], xx[1], xx[2:]...))
            }),
        )),
    )
    ast, iss := env.Compile(str)
    if iss.Err() != nil {
        t.Fatal(iss.Err())
    }
    prog, err := env.Program(ast)
    if err != nil {
        t.Fatal(err)
    }
    val, detail, err := prog.Eval(map[string]interface{}{"age1": 1, "age2": 2, "age3": 3})
    if err != nil {
        t.Fatal(err)
    }
    fmt.Print(detail)
    fmt.Println(val)
}

執(zhí)行步驟跟上面的一樣:

• 首先需要申明傳入函數(shù)參數(shù)的類型 age1, age2 age3
• 申明 Add 函數(shù),并申明函數(shù)的參數(shù)類型，以及返回結(jié)果
• env.Compile(str) 字符串的編譯、校驗、執(zhí)行，返回 ast
• prog.Eval 傳入?yún)?shù)執(zhí)行并返回結(jié)果

執(zhí)行結(jié)果：

Running tool: /usr/local/go/bin/go test -timeout 10s -run ^Test_add$ github.com/demo007x/goexpr -v

=== RUN   Test_add
<nil>true
--- PASS: Test_add (0.00s)
PASS
ok      github.com/demo007x/goexpr    0.014s

場景：

一般情況下項目中都很少會去執(zhí)行一個 CEL 的表達式，我們都會按照固定好的邏輯去編寫代碼。

目前低代碼盛行的時代，項目中的功能都可以自定義，這樣一個功能就需要足夠的靈活，將一些程序執(zhí)行的邏輯交給用戶去控制。

比如我們目前的項目中：一個復(fù)雜的流程具體要怎么執(zhí)行，需要誰去審批，需要在那一步的時候跳過等這些都是可以靈活配置每一個節(jié)點的邏輯條件，滿足條件的就去執(zhí)行節(jié)點流程，不滿足的就去跳過執(zhí)行下一個流程處理。這時候配置條件就可以使用 cel 的表達式去配置，通過表單中的多個字段的值組成一個 bool 條件。

比如請假流程：請假天數(shù) <= 3 流程需要走到部門領(lǐng)導(dǎo)審批， 請假天數(shù) > 3 流程需要部門領(lǐng)導(dǎo)審批完成后繼續(xù)流轉(zhuǎn)到部門領(lǐng)導(dǎo)的上級審批。

這樣一個條件中請假天數(shù)是一個表單中某個字段的值，這樣配置條件就很靈活。這就是 cel 在我們項目中實際使用的例子的一部分。

cel 在 k8s中的使用

CEL 的每個 Kubernetes API 字段都在 API 文檔中聲明了字段可使用哪些變量。例如，在 CustomResourceDefinitions 的 x-kubernetes-validations[i].rules 字段中，self 和 oldSelf 變量可用， 并且分別指代要由 CEL 表達式驗證的自定義資源數(shù)據(jù)的前一個狀態(tài)和當(dāng)前狀態(tài)。 其他 Kubernetes API 字段可能聲明不同的變量。請查閱 API 字段的 API 文檔以了解該字段可使用哪些變量。

K8S 中 CEL 表達式示例：

思考

cel 的執(zhí)行流程都是固定的，不管是簡單的字符串還是內(nèi)嵌函數(shù)的執(zhí)行。那是不是我們就可以基于 go-cel的功能來封裝一次，將相同的邏輯代碼抽取出來。這樣使用的時候就不需要每執(zhí)行一個 cel 的表達式就去寫一遍實現(xiàn)了呢？

我們分析下相同點和不同點：

相同點：

• cel.NewEnv 初始化 env
• env.Compile 檢測，編譯 cel 表達式
• env.Program ast 執(zhí)行
• prog.Eval 執(zhí)行并返回結(jié)果

不同的地方就是需要明確的標(biāo)明變量的類型，以及返回值（函數(shù)），而且參數(shù)個數(shù)不能多，也不能少，prog.Eval 傳入的實參只能多不能少，少了就會報錯。

如果我們將需要傳遞的參數(shù)以及類型提前解析出來并動態(tài)的傳入以上幾個步驟中，那我們的封裝是有意義的。代碼量也減少很多。哪如何抽取動態(tài)參數(shù)以及類型呢？

以上就是在golang中使用cel的用法詳解的詳細內(nèi)容，更多關(guān)于golang中使用cel的資料請關(guān)注腳本之家其它相關(guān)文章！