OPSaid – 策略治理

Docs: Rego 语言

Tue, 21 Nov 2023 16:18:29 +0800

简要概述

这里做 Rego 的简要语法说明。

基础类型

Scalar Values

标量值是 Rego 中最简单的类型，可以是字符串、数字、布尔值或 null，如：

greeting := "Hello"
max_height := 42
pi := 3.14159
allowed := true
location := null

docs := [greeting, max_height, pi, allowed, location]

Strings

字符串支持两种声明方式，第一种通过双引号包含，如果有特殊字符需通过反斜杠转译，如：

"[a-zA-Z_]\\w*"

第二种声明方式是通过反引号(`)，对特殊字符既所见即所得，如：

`[a-zA-Z_]\w*`

这其实和 Go 语言字符串有相同申明方式。

Composite Values

组合值包含两种类型：Objects（对象）、Sets（集合），在简单情况下，组合值可以像标量值一样被视为常量：

cube := {"width": 3, "height": 4, "depth": 5}
docs := [greeting, max_height, pi, allowed, location]

Objects（对象，也包含数组）键值可以是任意值：

ips_by_port := {
 80: ["1.1.1.1", "1.1.1.2"],
 443: ["2.2.2.1"],
 "80": ["1.1.1.3"],
}

这里 ips_by_port[80] 与 ips_by_port["80"] 获取是不一样的结果，当需要把 ips_by_port 输出 JSON 结构时，原先以 80 为键名的内容会被 "80" 所覆盖，因为 JSON 本身不支持以数字为属性，所以我们在定义 rego 变量是要避免使用数字类型键值，如 ips_by_port 输出 JSON 结果集为：

{
 "443": [
 "2.2.2.1"
 ],
 "80": [
 "1.1.1.3"
 ]
}

Sets（集合）是无序的唯一值的集合，如：

{1,2,3} == {3,1,2}

定义变量

变量在 Rego 中与大部分编程语言不同，可同时是输入和输出。如果为变量提供了一个值，那么该变量是一个输入型，如果没有为变量提供值，那么该变量是一个输出型。

作为输入

m := [10,6,9,8,15,3,12]

sites := [
 {"name": "prod"},
 {"name": "smoke1"},
 {"name": "dev"}
]

以上变量 m 与 sites 均作为输入型变量，这同其他语言定义。

作为输出

> m := [10,6,9,8,15,3,12]
Rule 'm' defined in package repl. Type 'show' to see rules.
> m
[
 10,
 6,
 9,
 8,
 15,
 3,
 12
]
>
> n
1 error occurred: 1:1: rego_unsafe_var_error: var n is unsafe
>
> m[n] == 3
+---+
| n |
+---+
| 5 |
+---+
>

定义一个数组 m，此时变量 n 未定义，通过查询语句 m[n] == 3 查找数组 m 中值为 “3” 的结果并写入到变量 n 中，此时变量 n 作为输出型，在看另外一个示例：

import future.keywords.if
import future.keywords.in
import future.keywords.contains

sites := [
 {"name": "prod"},
 {"name": "smoke1"},
 {"name": "dev"}
]

q contains name if {
 some site in sites
 name := site.name
}

此时变量 q 的结果为：

[
 "dev",
 "prod",
 "smoke1"
]

在使用一个未定义过的变量 x 来评估 q，此时 x 为输出，如 q[x] 结果为：

+----------+----------+
| x | q[x] |
+----------+----------+
| "dev" | "dev" |
| "prod" | "prod" |
| "smoke1" | "smoke1" |
+----------+----------+

这里由于 q 是一个集合，所以它们结果相同。

再比如 sites[i].name，这样在遍历数组时会自动把变量 i 赋值输出：

+---+---------------+
| i | sites[i].name |
+---+---------------+
| 0 | "prod" |
| 1 | "smoke1" |
| 2 | "dev" |
+---+---------------+

如果以上变量 i 在下文中不会使用，我们可以用下划线代替 sites[_].name，下划线在 Rego 中为特殊含义表示永不重复变量。

推导式

推导式，提供了一种从子查询构建复合值的简洁方式，主要有三种形式，这里通过以下示例说明：

apps := [
 {
 "id": "001",
 "name": "web",
 "servers": [
 "web-0",
 "web-1",
 "web-1000",
 "web-1001",
 "web-dev"
 ]
 },
 {
 "id": "002",
 "name": "mysql",
 "servers": [
 "db-0",
 "db-1000"
 ]
 },
 {
 "id": "003",
 "name": "web",
 "servers": [
 "web-3",
 "web-prod"
 ]
 },
 {
 "id": "004",
 "name": "mongodb",
 "servers": [
 "db-dev"
 ]
 }
]

数组推导式

Array Comprehensions

[ <term> | <body> ]

> comp := [ server | apps[i].name == "web"; server := apps[i].servers[0] ]
> comp
[
 "web-0",
 "web-3"
]
>

对象推导式

Object Comprehensions

{ <key>: <term> | <body> }

> comp := { key: server | key := apps[i].id; server := apps[i].servers[0] }
> comp
{
 "001": "web-0",
 "002": "db-0",
 "003": "web-3",
 "004": "db-dev"
}
>

集合推导式

Set Comprehensions

{ <term> | <body> }

> comp := { name | name = apps[x].name }
> comp
[
 "mongodb",
 "mysql",
 "web"
]
>

根据已有数据生成变量

在编写规则时，使用到的一些关键字需要自己引入下，如 if contains 等：

import future.keywords.if
import futere.keywords.contains

通过规则生成数组

comp[name] {
 name := apps[_].servers[0]
}

> comp
[
 "db-0",
 "db-dev",
 "web-0",
 "web-3"
]
>

通过规则生成对象

comp[id] := server {
 some i
 id := apps[i].id
 server := apps[i].servers
}

> comp
{
 "001": [
 "web-0",
 "web-1",
 "web-1000",
 "web-1001",
 "web-dev"
 ],
 "002": [
 "db-0",
 "db-1000"
 ],
 "003": [
 "web-3",
 "web-prod"
 ],
 "004": [
 "db-dev"
 ]
}
>

这里使用示例数据 apps 生成一组对象 comp 以 “id” 为键，以 “server” 为值，这个值来自后面的 {} 判断。

对已有数组的累加

使用相同的变量 comp 在通过多次规则时，它们的结果集是做增量，如下面两次叠加：

> comp[name] { name := apps[_].servers[0] }
>
> comp
[
 "db-0",
 "db-dev",
 "web-0",
 "web-3"
]
>
>
> comp[name] { name := apps[_].name }
> comp
[
 "db-0",
 "db-dev",
 "mongodb",
 "mysql",
 "web",
 "web-0",
 "web-3"
]
>

对变量的完整定义

除了部分定义集合和对象的规则外，还支持任何类型文档的完整定义，通常用于常量：

pi := 3.14159

由具有完整定义的规则生成的文档一次只能具有一个值，如果评估为同一文档生成多个值，将返回错误。

package repl

import future.keywords.if

# 定义一个用户 "bob"
user := "bob"

# 定义两个用户组，分布表示管理员与受限用户组
power_users := {"alice", "bob", "fred"}
restricted_users := {"bob", "kim"}

# 管理员可拥有 32GB 内存
max_memory := 32 if power_users[user]

# 受限用户仅可有 4GB 内存
max_memory := 4 if restricted_users[user]

TODO;

这里注意下，官方文档是说无法更改，但实际测试中可以被变更：

Rule 'max_memory' re-defined in package repl. Type 'show' to see rules.

需具体检查下原因。

用户自定义函数

支持用户自定定义函数，可以与内置函数相同的语义进行调用，它们可以访问数据文档和输入文档。

trim_and_split(s) := x {
 t := trim(s, " ")
 x := split(t, ".")
}

> trim_and_split(" foo.bar ")
[
 "foo",
 "bar"
]
>

foo([x, {"bar": y}]) := z {
 z := {x: y}
}

> foo([10, {"bar": 30}])
{
 "10": 30
}
>

模块、包与内置函数

模块组成

一个 Rego 的模块，由以下三部分组成：

固定使用一个 package 关键字申明包名称；
零个或多个 import 关键字语句导入外部模块；
零个或多个规则定义。

包名称

包名称仅能使用字符串，如需分割多个层级，则通过点号 “."，如：

package foo.bar.baz

pi := 3.14159

以上规则定义好后，会自动导出到 opa，可通过以下 api 查询：

GET /v1/data/foo/bar/baz/pi

属于相同的包名称下的模块，可以分布在不同的目录。

导入模块

如需复用第三方模块，使用关键字 import 导入，这样即可在当前模块中引用该文档导出的标识符，如需使用关键字 if 与 contains 则：

package foo.bar.baz

import future.keywords.if
import future.keywords.contains

http_servers contains server if {
 some server in servers
 "http" in server.protocols
}

TODO; 关键字 data 与 input

备注注解

同其他语言一样，通过 “#” 实现注解。

内置函数

OPA 本身提供了很多常用的函数，可直接调用，如：

> m := [6,9,8]
Rule 'm' defined in package repl. Type 'show' to see rules.
> max(m)
9
> min(m)
6
>

具体列表查看官方文档。

内置关键字

some

用于遍历数据或对象，显式声明键索引与键值局部变量，这些变量的作用范围仅限于该规则内，类似 go 语言的 for 循环，如：

> import future.keywords.in
>
> m := [10,6,9,8,15,3,12]
Rule 'm' defined in package repl. Type 'show' to see rules.
>
> some k, v in m
+---+----+
| k | v |
+---+----+
| 0 | 10 |
| 1 | 6 |
| 2 | 9 |
| 3 | 8 |
| 4 | 15 |
| 5 | 3 |
| 6 | 12 |
+---+----+
>

with

<expr> with <target-1> as <value-1> [with <target-2> as <value-2> [...]]

TODO;

default

default <name> := <term>

为变量定义默认值，因为在判断规则不成立时，变量会被设置为 undefined，这样在使用过程中不友好，如：

> import future.keywords.if
>
> m if 3 > 10
Rule 'm' defined in package repl. Type 'show' to see rules.
> m
undefined
>
> default m := false
Rule 'm' re-defined in package repl. Type 'show' to see rules.
>
> m
false
>
> m if 3 > 10
Rule 'm' defined in package repl. Type 'show' to see rules.
>
> m
false
>

else

基本的控制流构造，对一组规则按照顺序进行评估，一旦找到匹配项，就不会继续对后续规则评估，如：

import future.keywords.if

x := 10
y := 10

name := "user1" if {
 x > y
} else := "user2" {
 x == y
} else := "user3" {
 x < y
}

future

包含 in every if contains 在使用过程中可一次性导入 import futer.keyworks 不过建议按需，如：

import future.keywords.in
import future.keywords.every
import future.keywords.if
import future.keywords.contains

future.keywords.in

对查找的内容是否在给定的对象或数组中，如：

> import future.keywords.in
>
> m := [10,6,9,8,15,3,12]
Rule 'm' defined in package repl. Type 'show' to see rules.
> m
[
 10,
 6,
 9,
 8,
 15,
 3,
 12
]
>
> n := 3
Rule 'n' defined in package repl. Type 'show' to see rules.
>
> n
3
>
> n in m
true
>

future.keywords.every

对遍历的对象或数组，在规则内必须每个都成立，此时结果才为真，如：

> import future.keywords.in
> import future.keywords.every
>
> m := [10,6,9,8,15,3,12]
Rule 'm' defined in package repl. Type 'show' to see rules.
>
> n := 3
Rule 'n' defined in package repl. Type 'show' to see rules.
>
> n in m
true
>
> every x in m {
| x >= n
| }
|
true
>

future.keywords.if

如果规则判断为真，对前变量赋值，如：

> import future.keywords.if
>
> m := [10,6,9,8,15,3,12]
Rule 'm' defined in package repl. Type 'show' to see rules.
>
> n := 3
Rule 'n' defined in package repl. Type 'show' to see rules.
>
> deny if n > m[0]
Rule 'deny' defined in package repl. Type 'show' to see rules.
>
> deny
undefined
>
> deny if n < m[0]
Rule 'deny' defined in package repl. Type 'show' to see rules.
>
> deny
true
>

future.keywords.contains

TODO;

运算符

等号运算符

等号存在三种运算：赋值（:=）、相等（==）和对比赋值（=）。建议尽量使用赋值（:=）和比较（==），以便编写和阅读更容易理解的策略。

赋值运算 “:=” 是将值分配给变量

在规则内分配变量的作用域仅限于该规则内，并且会覆盖全局变量

import future.keywords.if

x := 100

p if {
 # 这里变量 "x" 仅在该规则内有效，并忽略上面的变量 "x"
 x := 1
 x != 100
}

以下均是错误的，变量赋值过不可重复

import future.keywords.if

x := 100

p if {
 # 这里变量 "x" 为以上定义的全局变量，不能在重复赋值，所以出错
 x != 100
 x := 1
}

p if {
 x := 1
 x := 2
}

从数组中提取值并将其赋值给变量

import future.keywords.if

address := ["3 Abbey Road", "NW8 9AY", "London", "England"]

in_london if {
 [_, _, city, country] := address
 city == "London"
 country == "England"
}

相等运算 “==” 比较在规则内检查两个值是否相等

比较两个变量值是否相等

import future.keywords.if

p if {
 x := 100
 x == 100
}

两边对比的变量必须已经定义否则出错

import future.keywords.if

p if {
 x == 100
}

对比赋值 “=” 用于比较两边规则如果为真则分别对其赋值

[x, "world"] = ["hello", y]

与单独赋值（:=）区别在他们规则内无需按照顺序

import future.keywords.if

s if {
 # 这个正常执行
 x > y
 y = 41
 x = 42
}

import future.keywords.if

s if {
 # 这个会出错
 x > y
 y := 41
 x := 42
}

对比运算符

也就平常的大于、小于、等于等，如：

a == b # `a` is equal to `b`.
a != b # `a` is not equal to `b`.
a < b # `a` is less than `b`.
a <= b # `a` is less than or equal to `b`.
a > b # `a` is greater than `b`.
a >= b # `a` is greater than or equal to `b`.

Docs: Gatekeeper

Tue, 02 Jan 2024 17:38:16 +0800

简要概述

各公司针对各自 K8S 集群都有一些合规政策，为了满足运维、安全、合规等要求。如果试图通过手动确保合规性就有可能会出现错误，所以需通过自动化方式执行确保一致性，即时反馈、并允许开发人员独立运作而无需牺牲合规性来提高灵活性。

Kubernetes 是允许通过 Admission Controller Webhooks 准入控制器将策略决策与 API Server 的内部工作解耦，这些 Webhooks 在每次创建、更新或删除资源时执行。如果各个规则均需要编写一个对应的准入控制器，难免有些复杂不够灵活，所以产生了通用的策略服务组件，也就是 Gatekeeper。

Gatekeeper

它支持验证性质的准入 Webhook ValidatingAdmissionWebhook 与变更性质的准入 Webhook MutatingAdmissionWebhook，通过由 Open Policy Agent（OPA）执行预先编写的 rego 策略规则，基于 CRD 的方式数据持久存储在 etcd 中。而 OPA 是一个在云原生环境中执行的策略引擎，由 CNCF 作为一个已毕业项目进行托管。

它的基础是基于 OPA Constraint Framework 框架实现，主要包含以下概念：

ConstraintTemplate：是 Gatekeeper 中的一个自定义资源，用于定义一组策略规则，每个模版包含了用于验证和强制执行策略的 Rego 代码和相应的参数模式。
Constraint：是 ConstraintTemplate 的实例，用于具体应用策略，每个对象定义了将被验证的 Kubernetes 对象类型、相应的参数和用于验证的 Rego 代码，当然必须遵循 ConstraintTemplate 中定义的 crd 属性与规则。

其中 Constraint 也是以 crd 在 k8s 集群中体现，它是由 ConstraintTemplate 模版自动创建的。待 Gatekeeper 安装后默认存在 crd 列表如下：

assign.mutations.gatekeeper.sh
assignimage.mutations.gatekeeper.sh
assignmetadata.mutations.gatekeeper.sh
configs.config.gatekeeper.sh
constraintpodstatuses.status.gatekeeper.sh
constrainttemplatepodstatuses.status.gatekeeper.sh
constrainttemplates.templates.gatekeeper.sh
expansiontemplate.expansion.gatekeeper.sh
expansiontemplatepodstatuses.status.gatekeeper.sh
modifyset.mutations.gatekeeper.sh
mutatorpodstatuses.status.gatekeeper.sh
providers.externaldata.gatekeeper.sh

其中来自于 OPA Constraint Framework 框架有 “expansiontemplate.expansion.gatekeeper.sh” 以及使用 “constraints.gatekeeper.sh” 后缀的 crd，如：

k8srequiredlabels.constraints.gatekeeper.sh

配置示例

ConstraintTemplate

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
 name: foosystemrequiredlabels
spec:
 # 自动创建 foosystemrequiredlabels.constraints.gatekeeper.sh 类型
 crd:
 spec:
 names:
 kind: FooSystemRequiredLabels
 validation:
 # 这里的属性会添加到自动创建 crd 的 parameters 参数下
 openAPIV3Schema:
 type: object
 properties:
 labels:
 type: array
 items:
 type: string

 targets:
 - target: admission.k8s.gatekeeper.sh
 libs:
 - |
 package lib.helpers

 make_message(missing) = msg {
 msg := sprintf("you must provide labels: %v", [missing])
 }

 rego: |
 package foosystemrequiredlabels

 import data.lib.helpers

 violation[{"msg": msg, "details": {"missing_labels": missing}}] {
 provided := {label | input.request.object.metadata.labels[label]}
 required := {label | label := input.parameters.labels[_]}
 missing := required - provided
 count(missing) > 0
 msg := helpers.make_message(missing)
 }

Constraint

apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
 name: ns-must-have-gk
spec:
 match:
 kinds:
 - apiGroups: [""]
 kinds: ["Namespace"]
 parameters:
 labels: ["gatekeeper"]
 enforcementAction: "deny"

Rego 引用变量

请求评估的对象

input.review

对象存储正在评估的 Admission 请求，数据结构可参考 AdmissionRequest。

用户自定义属性

input.parameters

对象存储了用户在 “ConstraintTemplate” 中定义的属性，既 “crd.spec.validation.openAPIV3Schema.properties” 这配置的值。

数据结构

ConstraintTemplate

在代码仓库 github.com/open-policy-agent/frameworks 中定义：

https://github.com/open-policy-agent/frameworks/blob/master/constraint/pkg/apis/templates/v1/constrainttemplate_types.go

// ConstraintTemplate is the Schema for the constrainttemplates API
// +k8s:openapi-gen=true
// +k8s:conversion-gen-external-types=github.com/open-policy-agent/frameworks/constraint/pkg/apis/templates
type ConstraintTemplate struct {
 metav1.TypeMeta `json:",inline"`
 metav1.ObjectMeta `json:"metadata,omitempty"`

 Spec ConstraintTemplateSpec `json:"spec,omitempty"`
 Status ConstraintTemplateStatus `json:"status,omitempty"`
}

// ConstraintTemplateSpec defines the desired state of ConstraintTemplate.
type ConstraintTemplateSpec struct {
 CRD CRD `json:"crd,omitempty"`
 Targets []Target `json:"targets,omitempty"`
}

type CRD struct {
 Spec CRDSpec `json:"spec,omitempty"`
}

type CRDSpec struct {
 Names Names `json:"names,omitempty"`
 // +kubebuilder:default={legacySchema: false}
 Validation *Validation `json:"validation,omitempty"`
}

type Names struct {
 Kind string `json:"kind,omitempty"`
 ShortNames []string `json:"shortNames,omitempty"`
}

type Validation struct {
 // +kubebuilder:validation:Schemaless
 // +kubebuilder:validation:Type=object
 // +kubebuilder:pruning:PreserveUnknownFields
 // +k8s:conversion-gen=false
 OpenAPIV3Schema *apiextensionsv1.JSONSchemaProps `json:"openAPIV3Schema,omitempty"`
 // +kubebuilder:default=false
 LegacySchema *bool `json:"legacySchema,omitempty"` // *bool allows for "unset" state which we need to apply appropriate defaults
}

type Target struct {
 Target string `json:"target,omitempty"`
 Rego string `json:"rego,omitempty"`
 Libs []string `json:"libs,omitempty"`
 // The source code options for the constraint template. "Rego" can only
 // be specified in one place (either here or in the "rego" field)
 // +listType=map
 // +listMapKey=engine
 // +kubebuilder:validation:Required
 Code []Code `json:"code,omitempty"`
}

type Code struct {
 // The engine used to evaluate the code. Example: "Rego". Required.
 // +kubebuilder:validation:Required
 Engine string `json:"engine"`

 // +kubebuilder:validation:Required
 // +kubebuilder:validation:Schemaless
 // +kubebuilder:pruning:PreserveUnknownFields
 // The source code for the template. Required.
 Source *templates.Anything `json:"source"`
}

Constraint

是定义在 “ConstraintTemplate” 中自动生成的 CRD，查看该集群存在多少可通过以下指令：

kubectl get constraints

创建该资源 crd 的逻辑在 github.com/open-policy-agent/frameworks/constraint/pkg/client/crds/crds.go 中 “CreateCRD“ 根据 “ConstraintTemplate” 中的 “openAPIV3Schema” 定义并把参数添加到 “parameters” 里面，然后在集群在把对应的 “Constraint” CRD 创建出来，大致设计以下代码片段：

github.com/open-policy-agent/frameworks/constraint/pkg/client/crds/schema.go -> CreateSchema -> apiextensions.JSONSchemaProps
github.com/open-policy-agent/frameworks/constraint/pkg/client/crds/crds.go -> CreateCRD -> apiextensions.CustomResourceDefinition

apiextensions.JSONSchemaProps -> apiextensions.CustomResourceDefinition

每个 “Constraint” CRD 都存在以下三个参数，在 CreateSchema 方法中定义：

参数	类型
match	target.MatchSchema()
enforcementAction	string
parameters	ConstraintTemplate.Spec.CRD.Spec.Validation.OpenAPIV3Schema

“match” 字段定义了约束将被应用于哪些资源，它支持以下类型的匹配器：

“kinds” 接受一个包含 apiGroups 和 kinds 字段的对象列表，列出了约束将应用于的对象的组或种类。如果指定了多个组或种类，则只需要一个匹配项，资源就会处于范围内。
“scope” 确定是否匹配集群范围或命名空间范围的资源。接受 *, Cluster 或 Namespaced。（默认为 *）
“namespaces” 是一个命名空间名称的列表。如果定义了，约束仅适用于列出的命名空间中的资源。Namespaces 还支持基于前缀的通配符。例如，namespaces: [kube-*] 匹配 kube-system 和 kube-public。
“excludedNamespaces” 是一个命名空间名称的列表。如果定义了，约束仅适用于不在列出的命名空间中的资源。excludedNamespaces 也支持基于前缀的通配符。例如，excludedNamespaces: [kube-*] 匹配不在 kube-system 和 kube-public 中的资源。
“labelSelector” 是两个可选字段的组合：matchLabels 和 matchExpressions。这两个字段提供了基于对象元数据中包含的标签键和值选择或排除 Kubernetes 对象的不同方法。所有选择表达式都会进行 AND 运算，以确定对象是否符合选择器的累积要求。
“namespaceSelector” 是针对对象所在的命名空间或对象本身（如果对象是一个命名空间）的标签选择器。
“name” 是 Kubernetes 对象的名称。如果定义了，它将与具有指定名称的对象匹配。Name 也支持基于前缀的通配符。例如，name: pod-* 匹配 pod-a 和 pod-b。

“enforcementAction” 字段定义了处理约束违规的操作，支持 [deny, dryrun, warn] 三个取值，默认情况下被设置为 deny，因为默认行为是拒绝任何违规的 Admission 请求。

“parameters” 字段描述了约束的意图，它可以被 “ConstraintTemplate” 的 Rego 源代码中 input.parameters 引用。

CreateSchema

github.com/open-policy-agent/frameworks/constraint/pkg/client/crds/schema.go

// CreateSchema combines the schema of the match target and the ConstraintTemplate parameters
// to form the schema of the actual constraint resource.
func CreateSchema(templ *templates.ConstraintTemplate, target MatchSchemaProvider) *apiextensions.JSONSchemaProps {
 props := map[string]apiextensions.JSONSchemaProps{
 "match": target.MatchSchema(),
 "enforcementAction": {Type: "string"},
 }

 if templ.Spec.CRD.Spec.Validation != nil && templ.Spec.CRD.Spec.Validation.OpenAPIV3Schema != nil {
 internalSchema := *templ.Spec.CRD.Spec.Validation.OpenAPIV3Schema.DeepCopy()
 props["parameters"] = internalSchema
 }

 schema := &apiextensions.JSONSchemaProps{
 Type: "object",
 Properties: map[string]apiextensions.JSONSchemaProps{
 "metadata": {
 Type: "object",
 Properties: map[string]apiextensions.JSONSchemaProps{
 "name": {
 Type: "string",
 MaxLength: pointer.Int64(63),
 },
 },
 },
 "spec": {
 Type: "object",
 Properties: props,
 },
 "status": {
 XPreserveUnknownFields: pointer.Bool(true),
 },
 },
 }

 return schema
}

target.MatchSchema

github.com/open-policy-agent/gatekeeper/pkg/mutation/match/match_types.go github.com/open-policy-agent/gatekeeper/pkg/target/matchcrd_constant.go

// Match selects which objects are in scope.
// +kubebuilder:object:generate=true
type Match struct {
 // Source determines whether generated or original resources are matched.
 // Accepts `Generated`|`Original`|`All` (defaults to `All`). A value of
 // `Generated` will only match generated resources, while `Original` will only
 // match regular resources.
 // +kubebuilder:validation:Enum=All;Generated;Original
 Source string `json:"source,omitempty"`
 Kinds []Kinds `json:"kinds,omitempty"`
 // Scope determines if cluster-scoped and/or namespaced-scoped resources
 // are matched. Accepts `*`, `Cluster`, or `Namespaced`. (defaults to `*`)
 Scope apiextensionsv1.ResourceScope `json:"scope,omitempty"`
 // Namespaces is a list of namespace names. If defined, a constraint only
 // applies to resources in a listed namespace. Namespaces also supports a
 // prefix or suffix based glob. For example, `namespaces: [kube-*]` matches both
 // `kube-system` and `kube-public`, and `namespaces: [*-system]` matches both
 // `kube-system` and `gatekeeper-system`.
 Namespaces []wildcard.Wildcard `json:"namespaces,omitempty"`
 // ExcludedNamespaces is a list of namespace names. If defined, a
 // constraint only applies to resources not in a listed namespace.
 // ExcludedNamespaces also supports a prefix or suffix based glob. For example,
 // `excludedNamespaces: [kube-*]` matches both `kube-system` and
 // `kube-public`, and `excludedNamespaces: [*-system]` matches both `kube-system` and
 // `gatekeeper-system`.
 ExcludedNamespaces []wildcard.Wildcard `json:"excludedNamespaces,omitempty"`
 // LabelSelector is the combination of two optional fields: `matchLabels`
 // and `matchExpressions`. These two fields provide different methods of
 // selecting or excluding k8s objects based on the label keys and values
 // included in object metadata. All selection expressions from both
 // sections are ANDed to determine if an object meets the cumulative
 // requirements of the selector.
 LabelSelector *metav1.LabelSelector `json:"labelSelector,omitempty"`
 // NamespaceSelector is a label selector against an object's containing
 // namespace or the object itself, if the object is a namespace.
 NamespaceSelector *metav1.LabelSelector `json:"namespaceSelector,omitempty"`
 // Name is the name of an object. If defined, it will match against objects with the specified
 // name. Name also supports a prefix or suffix glob. For example, `name: pod-*` would match
 // both `pod-a` and `pod-b`, and `name: *-pod` would match both `a-pod` and `b-pod`.
 Name wildcard.Wildcard `json:"name,omitempty"`
}

// Kinds accepts a list of objects with apiGroups and kinds fields
// that list the groups/kinds of objects to which the mutation will apply.
// If multiple groups/kinds objects are specified,
// only one match is needed for the resource to be in scope.
// +kubebuilder:object:generate=true
type Kinds struct {
 // APIGroups is the API groups the resources belong to. '*' is all groups.
 // If '*' is present, the length of the slice must be one.
 // Required.
 APIGroups []string `json:"apiGroups,omitempty" protobuf:"bytes,1,rep,name=apiGroups"`
 Kinds []string `json:"kinds,omitempty"`
}

apiextensionsv1.JSONSchemaProps

TODO;

templates.Anything

TODO;