1 - 词汇表 2 - API 概述 本文提供了 Kubernetes API 的参考信息。
REST API 是 Kubernetes 的基本结构。
所有操作和组件之间的通信及外部用户命令都是调用 API 服务器处理的 REST API。
因此,Kubernetes 平台视一切皆为 API 对象,
且它们在 API 中有相应的定义。
Kubernetes API 参考
列出了 Kubernetes v1.27 版本的 API。
如需了解一般背景信息,请查阅 Kubernetes API 。
Kubernetes API 控制访问 描述了客户端如何向
Kubernetes API 服务器进行身份认证以及他们的请求如何被鉴权。
API 版本控制 JSON 和 Protobuf 序列化模式遵循相同的模式更改原则。
以下描述涵盖了这两种格式。
API 版本控制和软件版本控制是间接相关的。
API 和发布版本控制提案 描述了
API 版本控制和软件版本控制间的关系。
不同的 API 版本代表着不同的稳定性和支持级别。
你可以在 API 变更文档
中查看到更多的不同级别的判定标准。
下面是每个级别的摘要:
Alpha:版本名称包含 alpha
(例如:v1alpha1
)。 内置的 Alpha API 版本默认被禁用且必须在 kube-apiserver
配置中显式启用才能使用。 软件可能会有 Bug。启用某个特性可能会暴露出 Bug。 对某个 Alpha API 特性的支持可能会随时被删除,恕不另行通知。 API 可能在以后的软件版本中以不兼容的方式更改,恕不另行通知。 由于缺陷风险增加和缺乏长期支持,建议该软件仅用于短期测试集群。 Beta:
版本名称包含 beta
(例如:v2beta3
)。 内置的 Beta API 版本默认被禁用且必须在 kube-apiserver
配置中显式启用才能使用
(例外情况是 Kubernetes 1.22 之前引入的 Beta 版本的 API,这些 API 默认被启用)。 内置 Beta API 版本从引入到弃用的最长生命周期为 9 个月或 3 个次要版本(以较长者为准),
从弃用到移除的最长生命周期为 9 个月或 3 个次要版本(以较长者为准)。 软件被很好的测试过。启用某个特性被认为是安全的。 尽管一些特性会发生细节上的变化,但它们将会被长期支持。 在随后的 Beta 版或 Stable 版中,对象的模式和(或)语义可能以不兼容的方式改变。
当这种情况发生时,将提供迁移说明。
适配后续的 Beta 或 Stable API 版本可能需要编辑或重新创建 API 对象,这可能并不简单。
对于依赖此功能的应用程序,可能需要停机迁移。 该版本的软件不建议生产使用。
后续发布版本可能会有不兼容的变动。
一旦 Beta API 版本被弃用且不再提供服务,
则使用 Beta API 版本的用户需要转为使用后续的 Beta 或 Stable API 版本。 说明: 请尝试 Beta 版时特性时并提供反馈。
特性完成 Beta 阶段测试后,就可能不会有太多的变更了。
Stable:版本名称如 vX
,其中 X
为整数。 特性的 Stable 版本会出现在后续很多版本的发布软件中。
Stable API 版本仍然适用于 Kubernetes 主要版本范围内的所有后续发布,
并且 Kubernetes 的主要版本当前没有移除 Stable API 的修订计划。 API 组 API 组 能够简化对
Kubernetes API 的扩展。API 组信息出现在 REST 路径中,也出现在序列化对象的 apiVersion
字段中。
以下是 Kubernetes 中的几个组:
核心(core) (也被称为 legacy )组的 REST 路径为 /api/v1
。
核心组并不作为 apiVersion
字段的一部分,例如, apiVersion: v1
。指定的组位于 REST 路径 /apis/$GROUP_NAME/$VERSION
,
并且使用 apiVersion: $GROUP_NAME/$VERSION
(例如,apiVersion: batch/v1
)。
你可以在 Kubernetes API 参考文档
中查看全部的 API 组。 启用或禁用 API 组 资源和 API 组是在默认情况下被启用的。
你可以通过在 API 服务器上设置 --runtime-config
参数来启用或禁用它们。
--runtime-config
参数接受逗号分隔的 <key>[=<value>]
对,
来描述 API 服务器的运行时配置。如果省略了 =<value>
部分,那么视其指定为 =true
。
例如:
禁用 batch/v1
,对应参数设置 --runtime-config=batch/v1=false
启用 batch/v2alpha1
,对应参数设置 --runtime-config=batch/v2alpha1
要启用特定版本的 API,如 storage.k8s.io/v1beta1/csistoragecapacities
,可以设置
--runtime-config=storage.k8s.io/v1beta1/csistoragecapacities
说明: 启用或禁用组或资源时,
你需要重启 API 服务器和控制器管理器来使 --runtime-config
生效。
持久化 Kubernetes 通过 API 资源来将序列化的状态写到 etcd 中存储。
接下来 2.1 - Kubernetes API 概念 Kubernetes API 是通过 HTTP 提供的基于资源 (RESTful) 的编程接口。
它支持通过标准 HTTP 动词(POST、PUT、PATCH、DELETE、GET)检索、创建、更新和删除主要资源。
对于某些资源,API 包括额外的子资源,允许细粒度授权(例如:将 Pod 的详细信息与检索日志分开),
为了方便或者提高效率,可以以不同的表示形式接受和服务这些资源。
Kubernetes 支持通过 watch 实现高效的资源变更通知。
Kubernetes 还提供了一致的列表操作,以便 API 客户端可以有效地缓存、跟踪和同步资源的状态。
你可以在线查看 API 参考 ,
或继续阅读以了解 API 的一般信息。
Kubernetes API 术语 Kubernetes 通常使用常见的 RESTful 术语来描述 API 概念:
资源类型(Resource Type) 是 URL 中使用的名称(pods
、namespaces
、services
)所有资源类型都有一个具体的表示(它们的对象模式),称为 类别(Kind) 资源实例的列表称为 集合(Collection) 资源类型的单个实例称为 资源(Resource) ,通常也表示一个 对象(Object) 对于某些资源类型,API 包含一个或多个 子资源(sub-resources) ,这些子资源表示为资源下的 URI 路径 大多数 Kubernetes API
资源类型都是对象 :
它们代表集群上某个概念的具体实例,例如 Pod 或名字空间。
少数 API 资源类型是 “虚拟的”,它们通常代表的是操作而非对象本身,
例如权限检查(使用带有 JSON 编码的 SubjectAccessReview
主体的 POST 到 subjectaccessreviews
资源),
或 Pod 的子资源 eviction
(用于触发 API-发起的驱逐 )。
对象名字 你可以通过 API 创建的所有对象都有一个唯一的名字 ,
以允许幂等创建和检索,
但如果虚拟资源类型不可检索或不依赖幂等性,则它们可能没有唯一名称。
在名字空间 内,
同一时刻只能有一个给定类别的对象具有给定名称。
但是,如果你删除该对象,你可以创建一个具有相同名称的新对象。
有些对象没有名字空间(例如:节点),因此它们的名称在整个集群中必须是唯一的。
API 动词 几乎所有对象资源类型都支持标准 HTTP 动词 - GET、POST、PUT、PATCH 和 DELETE。
Kubernetes 也使用自己的动词,这些动词通常写成小写,以区别于 HTTP 动词。
Kubernetes 使用术语 list 来描述返回资源集合 ,
以区别于通常称为 get 的单个资源检索。
如果你发送带有 ?watch
查询参数的 HTTP GET 请求,
Kubernetes 将其称为 watch 而不是 get (有关详细信息,请参阅快速检测更改 )。
对于 PUT 请求,Kubernetes 在内部根据现有对象的状态将它们分类为 create 或 update 。
update 不同于 patch ;patch 的 HTTP 动词是 PATCH。
资源 URI 所有资源类型要么是集群作用域的(/apis/GROUP/VERSION/*
),
要么是名字空间作用域的(/apis/GROUP/VERSION/namespaces/NAMESPACE/*
)。
名字空间作用域的资源类型会在其名字空间被删除时也被删除,
并且对该资源类型的访问是由定义在名字空间域中的授权检查来控制的。
注意: 核心资源使用 /api
而不是 /apis
,并且不包含 GROUP 路径段。
例如:
/api/v1/namespaces
/api/v1/pods
/api/v1/namespaces/my-namespace/pods
/apis/apps/v1/deployments
/apis/apps/v1/namespaces/my-namespace/deployments
/apis/apps/v1/namespaces/my-namespace/deployments/my-deployment
你还可以访问资源集合(例如:列出所有 Node)。以下路径用于检索集合和资源:
集群作用域的资源:GET /apis/GROUP/VERSION/RESOURCETYPE
- 返回指定资源类型的资源的集合GET /apis/GROUP/VERSION/RESOURCETYPE/NAME
- 返回指定资源类型下名称为 NAME 的资源 名字空间作用域的资源:GET /apis/GROUP/VERSION/RESOURCETYPE
- 返回所有名字空间中指定资源类型的全部实例的集合GET /apis/GROUP/VERSION/namespaces/NAMESPACE/RESOURCETYPE
- 返回名字空间 NAMESPACE 内给定资源类型的全部实例的集合GET /apis/GROUP/VERSION/namespaces/NAMESPACE/RESOURCETYPE/NAME
- 返回名字空间 NAMESPACE 中给定资源类型的名称为 NAME 的实例 由于名字空间本身是一个集群作用域的资源类型,你可以通过 GET /api/v1/namespaces/
检视所有名字空间的列表(“集合”),使用 GET /api/v1/namespaces/NAME
查看特定名字空间的详细信息。
集群作用域的子资源:GET /apis/GROUP/VERSION/RESOURCETYPE/NAME/SUBRESOURCE
名字空间作用域的子资源:GET /apis/GROUP/VERSION/namespaces/NAMESPACE/RESOURCETYPE/NAME/SUBRESOURCE
取决于对象是什么,每个子资源所支持的动词有所不同 - 参见 API 文档 以了解更多信息。
跨多个资源来访问其子资源是不可能的 - 如果需要这一能力,则通常意味着需要一种新的虚拟资源类型了。
高效检测变更 Kubernetes API 允许客户端对对象或集合发出初始请求,然后跟踪自该初始请求以来的更改:watch 。
客户端可以发送 list 或者 get 请求,然后发出后续 watch 请求。
为了使这种更改跟踪成为可能,每个 Kubernetes 对象都有一个 resourceVersion
字段,
表示存储在底层持久层中的该资源的版本。在检索资源集合(名字空间或集群范围)时,
来自 API 服务器的响应包含一个 resourceVersion
值。
客户端可以使用该 resourceVersion
来启动对 API 服务器的 watch 。
当你发送 watch 请求时,API 服务器会响应更改流。
这些更改逐项列出了在你指定为 watch 请求参数的 resourceVersion
之后发生的操作
(例如 create 、delete 和 update )的结果。
整个 watch 机制允许客户端获取当前状态,然后订阅后续更改,而不会丢失任何事件。
如果客户端 watch 连接断开,则该客户端可以从最后返回的 resourceVersion
开始新的 watch 请求;
客户端还可以执行新的 get /list 请求并重新开始。有关更多详细信息,请参阅资源版本语义 。
例如:
列举给定名字空间中的所有 Pod:
GET /api/v1/namespaces/test/pods
---
200 OK
Content-Type: application/json
{
"kind": "PodList",
"apiVersion": "v1",
"metadata": {"resourceVersion":"10245"},
"items": [...]
}
从资源版本 10245 开始,接收影响 test 名字空间中 Pod 的所有 API 操作
(例如 create 、delete 、apply 或 update )的通知。
每个更改通知都是一个 JSON 文档。
HTTP 响应正文(用作 application/json
)由一系列 JSON 文档组成。
GET /api/v1/namespaces/test/pods?watch=1&resourceVersion=10245
---
200 OK
Transfer-Encoding: chunked
Content-Type: application/json
{
"type": "ADDED",
"object": {"kind": "Pod", "apiVersion": "v1", "metadata": {"resourceVersion": "10596", ...}, ...}
}
{
"type": "MODIFIED",
"object": {"kind": "Pod", "apiVersion": "v1", "metadata": {"resourceVersion": "11020", ...}, ...}
}
...
给定的 Kubernetes 服务器只会保留一定的时间内发生的历史变更列表。
使用 etcd3 的集群默认保存过去 5 分钟内发生的变更。
当所请求的 watch 操作因为资源的历史版本不存在而失败,
客户端必须能够处理因此而返回的状态代码 410 Gone
,清空其本地的缓存,
重新执行 get 或者 list 操作,
并基于新返回的 resourceVersion
来开始新的 watch 操作。
对于订阅集合,Kubernetes 客户端库通常会为 list -然后- watch 的逻辑提供某种形式的标准工具。
(在 Go 客户端库中,这称为 反射器(Reflector)
,位于 k8s.io/client-go/tools/cache
包中。)
监视书签 为了减轻短历史窗口的影响,Kubernetes API 提供了一个名为 BOOKMARK
的监视事件。
这是一种特殊的事件,用于标记客户端请求的给定 resourceVersion
的所有更改都已发送。
代表 BOOKMARK
事件的文档属于请求所请求的类型,但仅包含一个 .metadata.resourceVersion
字段。例如:
GET /api/v1/namespaces/test/pods?watch=1&resourceVersion=10245&allowWatchBookmarks=true
---
200 OK
Transfer-Encoding: chunked
Content-Type: application/json
{
"type": "ADDED",
"object": {"kind": "Pod", "apiVersion": "v1", "metadata": {"resourceVersion": "10596", ...}, ...}
}
...
{
"type": "BOOKMARK",
"object": {"kind": "Pod", "apiVersion": "v1", "metadata": {"resourceVersion": "12746"} }
}
作为客户端,你可以在 watch 请求中设置 allowWatchBookmarks=true
查询参数来请求 BOOKMARK
事件,
但你不应假设书签会在任何特定时间间隔返回,即使要求时,客户端也不能假设 API 服务器会发送任何 BOOKMARK
事件。
流式列表 特性状态: Kubernetes v1.27 [alpha]
在大型集群检索某些资源类型的集合可能会导致控制平面的资源使用量(主要是 RAM)显著增加。
为了减轻其影响并简化 list + watch 模式的用户体验,
Kubernetes 1.27 版本引入了一个 alpha 功能,支持在 watch 请求中请求初始状态
(之前在 list 请求中请求)。
如果启用了 WatchList
特性门控 ,
可以通过在 watch 请求中指定 sendInitialEvents=true
作为查询字符串参数来实现这一功能。
如果指定了这个参数,API 服务器将使用合成的初始事件(类型为 ADDED
)来启动监视流,
以构建所有现有对象的完整状态;如果请求还带有 allowWatchBookmarks=true
选项,
则继续发送 BOOKMARK
事件 。
BOOKMARK 事件包括已被同步的资源版本。
发送 BOOKMARK 事件后,API 服务器会像处理所有其他 watch 请求一样继续执行。
当你在查询字符串中设置 sendInitialEvents=true
时,
Kubernetes 还要求你将 resourceVersionMatch
的值设置为 NotOlderThan
。
如果你在查询字符串中提供 resourceVersion
而没有提供值或者根本没有提供这个参数,
这一请求将被视为 一致性读(Consistent Read) 请求;
当状态至少被同步到开始处理一致性读操作时,才会发送 BOOKMARK 事件。
如果你(在查询字符串中)指定了 resourceVersion
,则只要需要等状态同步到所给资源版本时,
BOOKMARK 事件才会被发送。
示例 举个例子:你想监视一组 Pod。对于该集合,当前资源版本为 10245,并且有两个 Pod:foo
和 bar
。
接下来你发送了以下请求(通过使用 resourceVersion=
设置空的资源版本来明确请求 一致性读 ),
这样做的结果是可能收到如下事件序列:
GET /api/v1/namespaces/test/pods?watch=1&sendInitialEvents=true&allowWatchBookmarks=true&resourceVersion=&resourceVersionMatch=NotOlderThan
---
200 OK
Transfer-Encoding: chunked
Content-Type: application/json
{
"type": "ADDED",
"object": {"kind": "Pod", "apiVersion": "v1", "metadata": {"resourceVersion": "8467", "name": "foo"}, ...}
}
{
"type": "ADDED",
"object": {"kind": "Pod", "apiVersion": "v1", "metadata": {"resourceVersion": "5726", "name": "bar"}, ...}
}
{
"type": "BOOKMARK",
"object": {"kind": "Pod", "apiVersion": "v1", "metadata": {"resourceVersion": "10245"} }
}
...
<followed by regular watch stream starting from resourceVersion="10245">
响应压缩 特性状态: Kubernetes v1.16 [beta]
APIResponseCompression
是一个选项,允许 API 服务器压缩 get 和 list 请求的响应,
减少占用的网络带宽并提高大规模集群的性能。此选项自 Kubernetes 1.16 以来默认启用,
可以通过在 API 服务器上的 --feature-gates
标志中包含 APIResponseCompression=false
来禁用。
特别是对于大型资源或集合 ,
API 响应压缩可以显著减小其响应的大小。例如,针对 Pod 的 list 请求可能会返回数百 KB 甚至几 MB 的数据,
具体大小取决于 Pod 数量及其属性。通过压缩响应,可以节省网络带宽并降低延迟。
要验证 APIResponseCompression
是否正常工作,你可以使用一个 Accept-Encoding
头向 API 服务器发送一个 get 或 list 请求,并检查响应大小和头信息。例如:
GET /api/v1/pods
Accept-Encoding: gzip
---
200 OK
Content-Type: application/json
content-encoding: gzip
...
content-encoding
头表示响应使用 gzip
进行了压缩。
分块检视大体量结果 特性状态: Kubernetes v1.9 [beta]
在较大规模集群中,检索某些资源类型的集合可能会导致非常大的响应,从而影响服务器和客户端。
例如,一个集群可能有数万个 Pod,每个 Pod 大约相当于 2 KiB 的编码 JSON。
跨所有名字空间检索所有 Pod 可能会导致非常大的响应 (10-20MB) 并消耗大量服务器资源。
如果你没有明确禁用 APIListChunking
特性门控 ,
Kubernetes API 服务器支持将单个大型集合请求分解为许多较小块的能力,同时保持总请求的一致性。
你可以请求 API 服务器通过使用页(Kubernetes 将其称为“块(Chunk)”)的方式来处理 list ,
完成单个集合的响应。
要以块的形式检索单个集合,针对集合的请求支持两个查询参数 limit
和 continue
,
并且从集合元 metadata
字段中的所有 list 操作返回响应字段 continue
。
客户端应该指定他们希望在每个带有 limit
的块中接收的条目数上限,如果集合中有更多资源,
服务器将在结果中返回 limit
资源并包含一个 continue
值。
作为 API 客户端,你可以在下一次请求时将 continue
值传递给 API 服务器,
以指示服务器返回下一页(块 )结果。继续下去直到服务器返回一个空的 continue
值,
你可以检索整个集合。
与 watch 操作类似,continue
令牌也会在很短的时间(默认为 5 分钟)内过期,
并在无法返回更多结果时返回 410 Gone
代码。
这时,客户端需要从头开始执行上述检视操作或者忽略 limit
参数。
例如,如果集群上有 1253 个 Pod,客户端希望每次收到包含至多 500 个 Pod
的数据块,它应按下面的步骤来请求数据块:
列举集群中所有 Pod,每次接收至多 500 个 Pod:
GET /api/v1/pods?limit=500
---
200 OK
Content-Type: application/json
{
"kind": "PodList",
"apiVersion": "v1",
"metadata": {
"resourceVersion":"10245",
"continue": "ENCODED_CONTINUE_TOKEN",
"remainingItemCount": 753,
...
},
"items": [...] // returns pods 1-500
}
继续前面的调用,返回下一组 500 个 Pod:
GET /api/v1/pods?limit=500&continue=ENCODED_CONTINUE_TOKEN
---
200 OK
Content-Type: application/json
{
"kind": "PodList",
"apiVersion": "v1",
"metadata": {
"resourceVersion":"10245",
"continue": "ENCODED_CONTINUE_TOKEN_2",
"remainingItemCount": 253,
...
},
"items": [...] // returns pods 501-1000
}
继续前面的调用,返回最后 253 个 Pod:
GET /api/v1/pods?limit=500&continue=ENCODED_CONTINUE_TOKEN_2
---
200 OK
Content-Type: application/json
{
"kind": "PodList",
"apiVersion": "v1",
"metadata": {
"resourceVersion":"10245",
"continue": "", // continue token is empty because we have reached the end of the list
...
},
"items": [...] // returns pods 1001-1253
}
请注意,集合的 resourceVersion
在每个请求中保持不变,
这表明服务器正在向你显示 Pod 的一致快照。
在版本 10245
之后创建、更新或删除的 Pod 将不会显示,
除非你在没有继续令牌的情况下发出单独的 list 请求。
这使你可以将大请求分成更小的块,然后对整个集合执行 watch 操作,而不会丢失任何更新。
remainingItemCount
是集合中未包含在此响应中的后续项目的数量。
如果 list 请求包含标签或字段选择器 ,
则剩余项目的数量是未知的,并且 API 服务器在其响应中不包含 remainingItemCount
字段。
如果 list 是完整的(因为它没有分块,或者因为这是最后一个块),没有更多的剩余项目,
API 服务器在其响应中不包含 remainingItemCount
字段。
remainingItemCount
的用途是估计集合的大小。
集合 在 Kubernetes 术语中,你从 list 中获得的响应是一个“集合(Collections)”。
然而,Kubernetes 为不同类型资源的集合定义了具体类型。
集合的类别名是针对资源类别的,并附加了 List
。
当你查询特定类型的 API 时,该查询返回的所有项目都属于该类型。
例如,当你 list Service 对象时,集合响应的 kind
设置为
ServiceList
;
该集合中的每个项目都代表一个 Service。例如:
GET /api/v1/services
{
"kind": "ServiceList" ,
"apiVersion": "v1" ,
"metadata": {
"resourceVersion": "2947301"
},
"items": [
{
"metadata": {
"name": "kubernetes" ,
"namespace": "default" ,
...
"metadata": {
"name": "kube-dns" ,
"namespace": "kube-system" ,
...
Kubernetes API 中定义了数十种集合类型(如 PodList
、ServiceList
和 NodeList
)。
你可以从 Kubernetes API 文档中获取有关每种集合类型的更多信息。
一些工具,例如 kubectl
,对于 Kubernetes 集合的表现机制与 Kubernetes API 本身略有不同。
因为 kubectl
的输出可能包含来自 API 级别的多个 list 操作的响应,
所以 kubectl
使用 kind: List
表示项目列表。例如:
kubectl get services -A -o yaml
apiVersion : v1
kind : List
metadata :
resourceVersion : ""
selfLink : ""
items :
- apiVersion : v1
kind : Service
metadata :
creationTimestamp : "2021-06-03T14:54:12Z"
labels :
component : apiserver
provider : kubernetes
name : kubernetes
namespace : default
...
- apiVersion : v1
kind : Service
metadata :
annotations :
prometheus.io/port : "9153"
prometheus.io/scrape : "true"
creationTimestamp : "2021-06-03T14:54:14Z"
labels :
k8s-app : kube-dns
kubernetes.io/cluster-service : "true"
kubernetes.io/name : CoreDNS
name : kube-dns
namespace : kube-system
说明: 请记住,Kubernetes API 没有名为 List
的 kind
。
kind: List
是一个客户端内部实现细节,用于处理可能属于不同类别的对象的集合。
在自动化或其他代码中避免依赖 kind: List
。
以表格形式接收资源 当你执行 kubectl get
时,默认的输出格式是特定资源类型的一个或多个实例的简单表格形式。
过去,客户端需要重复 kubectl
中所实现的表格输出和描述输出逻辑,以执行简单的对象列表操作。
该方法的一些限制包括处理某些对象时的不可忽视逻辑。
此外,API 聚合或第三方资源提供的类型在编译时是未知的。
这意味着必须为客户端无法识别的类型提供通用实现。
为了避免上述各种潜在的局限性,客户端可以请求服务器端返回对象的表格(Table)
表现形式,从而将打印输出的特定细节委托给服务器。
Kubernetes API 实现标准的 HTTP 内容类型(Content Type)协商:为 GET
调用传入一个值为 application/json;as=Table;g=meta.k8s.io;v=v1
的 Accept
头部即可请求服务器以 Table 的内容类型返回对象。
例如,以 Table 格式列举集群中所有 Pod:
GET /api/v1/pods
Accept: application/json;as=Table;g=meta.k8s.io;v=v1
---
200 OK
Content-Type: application/json
{
"kind": "Table",
"apiVersion": "meta.k8s.io/v1",
...
"columnDefinitions": [
...
]
}
对于在控制平面上不存在定制的 Table 定义的 API 资源类型而言,服务器会返回一个默认的
Table 响应,其中包含资源的 name
和 creationTimestamp
字段。
GET /apis/crd.example.com/v1alpha1/namespaces/default/resources
---
200 OK
Content-Type: application/json
...
{
"kind": "Table",
"apiVersion": "meta.k8s.io/v1",
...
"columnDefinitions": [
{
"name": "Name",
"type": "string",
...
},
{
"name": "Created At",
"type": "date",
...
}
]
}
并非所有 API 资源类型都支持 Table 响应;
例如,CustomResourceDefinitions 可能没有定义字段到表的映射,
扩展核心 Kubernetes API
的 APIService 可能根本不提供 Table 响应。
如果你正在实现使用 Table 信息并且必须针对所有资源类型(包括扩展)工作的客户端,
你应该在 Accept
请求头中指定多种内容类型的请求。例如:
Accept: application/json;as=Table;g=meta.k8s.io;v=v1, application/json
资源的其他表示形式 默认情况下,Kubernetes 返回序列化为 JSON 的对象,内容类型为 application/json
。
这是 API 的默认序列化格式。
但是,客户端可能会使用更有效的 Protobuf 表示 请求这些对象,
以获得更好的大规模性能。Kubernetes API 实现标准的 HTTP 内容类型协商:
带有 Accept
请求头部的 GET
调用会请求服务器尝试以你的首选媒体类型返回响应,
而将 Protobuf 中的对象发送到服务器以进行 PUT
或 POST
调用意味着你必须适当地设置
Content-Type
请求头。
如果支持请求的格式,服务器将返回带有 Content-Type
标头的响应,
如果不支持你请求的媒体类型,则返回 406 Not Acceptable
错误。
所有内置资源类型都支持 application/json
媒体类型。
有关每个 API 支持的内容类型列表,请参阅 Kubernetes API 参考 。
例如:
以 Protobuf 格式列举集群上的所有 Pod:
GET /api/v1/pods
Accept: application/vnd.kubernetes.protobuf
---
200 OK
Content-Type: application/vnd.kubernetes.protobuf
... binary encoded PodList object
通过向服务器发送 Protobuf 编码的数据创建 Pod,但请求以 JSON 形式接收响应:
POST /api/v1/namespaces/test/pods
Content-Type: application/vnd.kubernetes.protobuf
Accept: application/json
... binary encoded Pod object
---
200 OK
Content-Type: application/json
{
"kind": "Pod",
"apiVersion": "v1",
...
}
并非所有 API 资源类型都支持 Protobuf;具体来说,
Protobuf 不适用于定义为 CustomResourceDefinitions
或通过聚合层 提供服务的资源。
作为客户端,如果你可能需要使用扩展类型,则应在请求 Accept
请求头中指定多种内容类型以支持回退到 JSON。
例如:
Accept: application/vnd.kubernetes.protobuf, application/json
Kubernetes Protobuf 编码 Kubernetes 使用封套形式来对 Protobuf 响应进行编码。
封套外层由 4 个字节的特殊数字开头,便于从磁盘文件或 etcd 中辩识 Protobuf
格式的(而不是 JSON)数据。
接下来存放的是 Protobuf 编码的封套消息,其中描述下层对象的编码和类型,最后
才是对象本身。
封套格式如下:
四个字节的特殊数字前缀:
字节 0-3: "k8s\x00" [0x6b, 0x38, 0x73, 0x00]
使用下面 IDL 来编码的 Protobuf 消息:
message Unknown {
// typeMeta 应该包含 "kind" 和 "apiVersion" 的字符串值,就像
// 对应的 JSON 对象中所设置的那样
optional TypeMeta typeMeta = 1;
// raw 中将保存用 protobuf 序列化的完整对象。
// 参阅客户端库中为指定 kind 所作的 protobuf 定义
optional bytes raw = 2;
// contentEncoding 用于 raw 数据的编码格式。未设置此值意味着没有特殊编码。
optional string contentEncoding = 3;
// contentType 包含 raw 数据所采用的序列化方法。
// 未设置此值意味着 application/vnd.kubernetes.protobuf,且通常被忽略
optional string contentType = 4;
}
message TypeMeta {
// apiVersion 是 type 对应的组名/版本
optional string apiVersion = 1;
// kind 是对象模式定义的名称。此对象应该存在一个 protobuf 定义。
optional string kind = 2;
}
说明: 收到 application/vnd.kubernetes.protobuf
格式响应的客户端在响应与预期的前缀不匹配时应该拒绝响应,
因为将来的版本可能需要以某种不兼容的方式更改序列化格式,
并且这种更改是通过变更前缀完成的。
资源删除 当你 delete 资源时,操作将分两个阶段进行。
终结(finalization) 移除 {
"kind": "ConfigMap" ,
"apiVersion": "v1" ,
"metadata": {
"finalizers": {"url.io/neat-finalization" , "other-url.io/my-finalizer" },
"deletionTimestamp": nil,
}
}
当客户端第一次发送 delete 请求删除资源时,.metadata.deletionTimestamp
设置为当前时间。
一旦设置了 .metadata.deletionTimestamp
,
作用于终结器的外部控制器可以在任何时间以任何顺序开始执行它们的清理工作。
终结器之间 不存在 强制的执行顺序,因为这会带来卡住 .metadata.finalizers
的重大风险。
.metadata.finalizers
字段是共享的:任何有权限的参与者都可以重新排序。
如果终结器列表是按顺序处理的,那么这可能会导致这样一种情况:
在列表中负责第一个终结器的组件正在等待列表中稍后负责终结器的组件产生的某些信号
(字段值、外部系统或其他),从而导致死锁。
如果没有强制排序,终结者可以在它们之间自由排序,并且不易受到列表中排序变化的影响。
当最后一个终结器也被移除时,资源才真正从 etcd 中移除。
单个资源 API Kubernetes API 动词 get 、create 、apply 、update 、patch 、delete 和 proxy 仅支持单一资源。
这些具有单一资源支持的动词不支持在有序或无序列表或事务中一起提交多个资源。
当客户端(包括 kubectl)对一组资源进行操作时,客户端会发出一系列单资源 API 请求,
然后在需要时聚合响应。
相比之下,Kubernetes API 动词 list 和 watch 允许获取多个资源,
而 deletecollection 允许删除多个资源。
字段校验 Kubernetes 总是校验字段的类型。例如,如果 API 中的某个字段被定义为数值,
你就不能将该字段设置为文本类型的值。如果某个字段被定义为字符串数组,你只能提供数组。
有些字段可以忽略,有些字段必须填写。忽略 API 请求中的必填字段会报错。
如果请求中带有集群控制面无法识别的额外字段,API 服务器的行为会更加复杂。
默认情况下,如果接收到的输入信息中含有 API 服务器无法识别的字段,API 服务器会丢弃该字段
(例如: PUT
请求中的 JSON 主体)。
API 服务器会在两种情况下丢弃 HTTP 请求中提供的字段。
这些情况是:
相关资源的 OpenAPI 模式定义中没有该字段,因此无法识别该字段(有种例外情形是,
CRD
通过 x-kubernetes-preserve-unknown-fields
显式选择不删除未知字段)。 字段在对象中重复出现。 检查无法识别或重复的字段 特性状态: Kubernetes v1.27 [stable]
从 1.25 开始,当使用可以提交数据的 HTTP 动词(POST
、PUT
和 PATCH
)时,
将通过服务器上的校验检测到对象中无法识别或重复的字段。
校验的级别可以是 Ignore
、Warn
(默认值) 和 Strict
之一。
Ignore
使 API 服务器像没有遇到错误字段一样成功处理请求,丢弃所有的未知字段和重复字段,并且不发送丢弃字段的通知。 Warn
:(默认值)使 API 服务器成功处理请求,并向客户端发送告警信息。告警信息通过 Warning:
响应头发送,
并为每个未知字段或重复字段添加一条告警信息。有关告警和相关的 Kubernetes API 的信息,
可参阅博文告警:增加实用告警功能 。
Strict
API 服务器检测到任何未知字段或重复字段时,拒绝处理请求并返回 400 Bad Request 错误。
来自 API 服务器的响应消息列出了 API 检测到的所有未知字段或重复字段。 字段校验级别可通过查询参数 fieldValidation
来设置。
说明: 如果你提交的请求中设置了一个无法被识别的字段,并且该请求存在因其他原因引起的不合法
(例如,请求为某已知字段提供了一个字符串值,而 API 期望该字段为整数),
那么 API 服务器会以 400 Bad Request 错误作出响应,但不会提供有关未知或重复字段的任何信息
(仅提供它首先遇到的致命错误)。
在这种情况下,不管你设置哪种字段校验级别,你总会收到出错响应。
向服务器提交请求的工具(例如 kubectl
)可能会设置自己的默认值,与 API 服务器默认使用的 Warn
校验层级不同。
kubectl
工具使用 --validate
标志设置字段校验层级。
该字段可取的值包括 ignore
、warn
和 strict
,同时还接受值 true
(相当于 strict
)和
false
(相当于 ignore
)。
kubectl 默认的校验设置是 --validate=true
,这意味着执行严格的服务端字段校验。
当 kubectl 无法连接到启用字段校验的 API 服务器(Kubernetes 1.27 之前的 API 服务器)时,
将回退到使用客户端的字段校验。
客户端校验将在 kubectl 未来版本中被完全删除。
说明: 在 Kubernetes 1.25 之前,kubectl --validate
是用来开启或关闭客户端校验的布尔标志的命令。
试运行 特性状态: Kubernetes v1.18 [stable]
当你使用可以修改资源的 HTTP 动词(POST
、PUT
、PATCH
和 DELETE
)时,
你可以在 试运行(dry run) 模式下提交你的请求。
试运行模式有助于通过典型的请求阶段(准入链、验证、合并冲突)评估请求,直到将对象持久化到存储中。
请求的响应正文尽可能接近非试运行响应。Kubernetes 保证试运行请求不会被持久化存储或产生任何其他副作用。
发起试运行请求 通过设置 dryRun
查询参数触发试运行。此参数是一个字符串,用作枚举,唯一可接受的值是:
[未设置值] 允许副作用。你可以使用 ?dryRun
或 ?dryRun&pretty=true
之类的查询字符串请求此操作。
响应是最终会被持久化的对象,或者如果请求不能被满足则会出现一个错误。 All
每个阶段都正常运行,除了防止副作用的最终存储阶段。 当你设置 ?dryRun=All
时,将运行任何相关的准入控制器 ,
验证准入控制器检查经过变更的请求,针对 PATCH
请求执行合并、设置字段默认值等操作,并进行模式验证。
更改不会持久化到底层存储,但本应持久化的最终对象仍会与正常状态代码一起返回给用户。
如果请求的非试运行版本会触发具有副作用的准入控制器,则该请求将失败,而不是冒不希望的副作用的风险。
所有内置准入控制插件都支持试运行。
此外,准入 Webhook 还可以设置配置对象
的 sideEffects
字段为 None
,借此声明它们没有副作用。
说明: 如果 webhook 确实有副作用,则应该将 sideEffects
字段设置为 “NoneOnDryRun”。
如果还修改了 webhook 以理解 AdmissionReview 中的 DryRun 字段,
并防止对标记为试运行的任何请求产生副作用,则该更改是适当的。
这是一个使用 ?dryRun=All
的试运行请求的示例:
POST /api/v1/namespaces/test/pods?dryRun=All
Content-Type: application/json
Accept: application/json
响应会与非试运行模式请求的响应看起来相同,只是某些生成字段的值可能会不同。
生成值 对象的某些值通常是在对象被写入数据库之前生成的。很重要的一点是不要依赖试运行请求为这些字段所设置的值,
因为试运行模式下所得到的这些值与真实请求所获得的值很可能不同。这类字段有:
name
:如果设置了 generateName
字段,则 name
会获得一个唯一的随机名称creationTimestamp
/ deletionTimestamp
:记录对象的创建/删除时间UID
:唯一标识 对象,
取值随机生成(非确定性)resourceVersion
:跟踪对象的持久化(存储)版本变更性准入控制器所设置的字段 对于 Service
资源:kube-apiserver
为 Service
对象分配的端口和 IP 地址 试运行的授权 试运行和非试运行请求的鉴权是完全相同的。因此,要发起一个试运行请求,
你必须被授权执行非试运行请求。
例如,要在 Deployment 对象上试运行 patch 操作,你必须具有对 Deployment 执行 patch 操作的访问权限,
如下面的 RBAC 规则所示:
rules :
- apiGroups : ["apps" ]
resources : ["deployments" ]
verbs : ["patch" ]
参阅鉴权概述 以了解鉴权细节。
服务器端应用 Kubernetes 的服务器端应用 功能允许控制平面跟踪新创建对象的托管字段。
服务端应用为管理字段冲突提供了清晰的模式,提供了服务器端 Apply
和 Update
操作,
并替换了 kubectl apply
的客户端功能。
服务端应用的 API 动词是 apply 。有关详细信息,
请参阅服务器端应用 。
资源版本 资源版本是标识服务器内部对象版本的字符串。
客户端可以使用资源版本来确定对象何时更改,
或者在获取、列出和监视资源时表达数据一致性要求。
资源版本必须被客户端视为不透明的,并且未经修改地传回服务器。
你不能假设资源版本是数字的或可排序的。
API 客户端只能比较两个资源版本的相等性(这意味着你不能比较资源版本的大于或小于关系)。
客户端在资源中查找资源版本,这些资源包括来自用于 watch 的响应流资源,或者使用 list 枚举的资源。
v1.meta/ObjectMeta -
资源的 metadata.resourceVersion
值标明该实例上次被更改时的资源版本。
v1.meta/ListMeta - 资源集合即
list 操作的响应)的 metadata.resourceVersion
所标明的是 list 响应被构造时的资源版本。
查询字符串中的 resourceVersion
参数 get 、list 和 watch 操作支持 resourceVersion
参数。
从 v1.19 版本开始,Kubernetes API 服务器支持 list 请求的 resourceVersionMatch
参数。
API 服务器根据你请求的操作和 resourceVersion
的值对 resourceVersion
参数进行不同的解释。
如果你设置 resourceVersionMatch
那么这也会影响匹配发生的方式。
get 和 list 语义对于 get 和 list 而言,resourceVersion
的语义为:
get:
resourceVersion 未设置 resourceVersion="0" resourceVersion="<非零值>" 最新版本 任何版本 不老于给定版本
list:
从 v1.19 版本开始,Kubernetes API 服务器支持 list 请求的 resourceVersionMatch
参数。
如果同时设置 resourceVersion
和 resourceVersionMatch
,
则 resourceVersionMatch
参数确定 API 服务器如何解释 resourceVersion
。
在 list 请求上设置 resourceVersion
时,你应该始终设置 resourceVersionMatch
参数。
但是,请准备好处理响应的 API 服务器不知道 resourceVersionMatch
并忽略它的情况。
除非你对一致性有着非常强烈的需求,使用 resourceVersionMatch=NotOlderThan
同时为 resourceVersion
设定一个已知值是优选的交互方式,因为与不设置
resourceVersion
和 resourceVersionMatch
相比,这种配置可以取得更好的集群性能和可扩缩性。
后者需要提供带票选能力的读操作。
设置 resourceVersionMatch
参数而不设置 resourceVersion
参数是不合法的。
下表解释了具有各种 resourceVersion
和 resourceVersionMatch
组合的 list 请求的行为:
list 操作的 resourceVersionMatch 与分页参数 resourceVersionMatch 参数 分页参数 resourceVersion 未设置 resourceVersion="0" resourceVersion="<非零值>" 未设置 limit 未设置 最新版本 任意版本 不老于指定版本 未设置 limit=<n>, continue 未设置 最新版本 任意版本 精确匹配 未设置 limit=<n>, continue=<token> 从 token 开始、精确匹配 非法请求,视为从 token 开始、精确匹配 非法请求,返回 HTTP 400 Bad Request
resourceVersionMatch=Exact
[1]limit 未设置 非法请求 非法请求 精确匹配 resourceVersionMatch=Exact
[1]limit=<n>, continue 未设置 非法请求 非法请求 精确匹配 resourceVersionMatch=NotOlderThan
[1]limit 未设置 非法请求 任意版本 不老于指定版本 resourceVersionMatch=NotOlderThan
[1]limit=<n>, continue 未设置 非法请求 任意版本 不老于指定版本
说明: 如果你的集群的 API 服务器不支持 resourceVersionMatch
参数,
则行为与你未设置它时相同。
get 和 list 的语义是:
任意版本 返回任何资源版本的数据。最新可用资源版本优先,但不需要强一致性;
可以提供任何资源版本的数据。由于分区或过时的缓存,
请求可能返回客户端先前观察到的更旧资源版本的数据,特别是在高可用性配置中。
不能容忍这种情况的客户不应该使用这种语义。 最新版本 返回最新资源版本的数据。
返回的数据必须一致(详细说明:通过仲裁读取从 etcd 提供)。 不老于指定版本 返回数据至少与提供的 resourceVersion
一样新。
最新的可用数据是首选,但可以提供不早于提供的 resourceVersion
的任何数据。
对于对遵守 resourceVersionMatch
参数的服务器的 list 请求,
这保证了集合的 .metadata.resourceVersion
不早于请求的 resourceVersion
,
但不保证该集合中任何项目的 .metadata.resourceVersion
。 精确匹配 以提供的确切资源版本返回数据。如果提供的 resourceVersion
不可用,
则服务器以 HTTP 410 “Gone”响应。对于对支持 resourceVersionMatch
参数的服务器的 list 请求,
这可以保证集合的 .metadata.resourceVersion
与你在查询字符串中请求的 resourceVersion
相同。
该保证不适用于该集合中任何项目的 .metadata.resourceVersion
。 从 token 开始、精确匹配 返回初始分页 list 调用的资源版本的数据。
返回的 Continue 令牌 负责跟踪最初提供的资源版本,最初提供的资源版本用于在初始分页 list 之后的所有分页 list 中。 说明: 当你 list 资源并收到集合响应时,
响应包括集合的元数据
以及该集合中每个项目的对象元数据 。
对于在集合响应中找到的单个对象,.metadata.resourceVersion
跟踪该对象的最后更新时间,
而不是对象在服务时的最新程度。
当使用 resourceVersionMatch=NotOlderThan
并设置了限制时,
客户端必须处理 HTTP 410 “Gone” 响应。
例如,客户端可能会使用更新的 resourceVersion
重试或回退到 resourceVersion=""
。
当使用 resourceVersionMatch=Exact
并且未设置限制时,
客户端必须验证集合的 .metadata.resourceVersion
是否与请求的 resourceVersion
匹配,
并处理不匹配的情况。例如,客户端可能会退回到设置了限制的请求。
watch 语义对于 watch 操作而言,资源版本的语义如下:
watch:
watch 操作的 resourceVersion 设置 resourceVersion 未设置 resourceVersion="0" resourceVersion="<非零值>" 读取状态并从最新版本开始 读取状态并从任意版本开始 从指定版本开始
watch 操作语义的含义如下:
读取状态并从任意版本开始 注意: 以这种方式初始化的监视可能会返回任意陈旧的数据。
请在使用之前查看此语义,并尽可能支持其他语义。
在任何资源版本开始 watch ;首选可用的最新资源版本,但不是必需的。允许任何起始资源版本。
由于分区或过时的缓存,watch 可能从客户端之前观察到的更旧的资源版本开始,
特别是在高可用性配置中。不能容忍这种明显倒带的客户不应该用这种语义启动 watch 。
为了建立初始状态,watch 从起始资源版本中存在的所有资源实例的合成 “添加” 事件开始。
以下所有监视事件都针对在 watch 开始的资源版本之后发生的所有更改。读取状态并从最新版本开始 从最近的资源版本开始 watch ,
它必须是一致的(详细说明:通过仲裁读取从 etcd 提供服务)。
为了建立初始状态,watch 从起始资源版本中存在的所有资源实例的合成 “添加” 事件开始。
以下所有监视事件都针对在 watch 开始的资源版本之后发生的所有更改。 从指定版本开始 以确切的资源版本开始 watch 。监视事件适用于提供的资源版本之后的所有更改。
与 “Get State and Start at Most Recent” 和 “Get State and Start at Any” 不同,
watch 不会以所提供资源版本的合成 “添加” 事件启动。
由于客户端提供了资源版本,因此假定客户端已经具有起始资源版本的初始状态。 "410 Gone" 响应 服务器不需要提供所有老的资源版本,在客户端请求的是早于服务器端所保留版本的
resourceVersion
时,可以返回 HTTP 410 (Gone)
状态码。
客户端必须能够容忍 410 (Gone)
响应。
参阅高效检测变更 以了解如何在监测资源时处理
410 (Gone)
响应。
如果所请求的 resourceVersion
超出了可应用的 limit
,
那么取决于请求是否是通过高速缓存来满足的,API 服务器可能会返回一个 410 Gone
HTTP 响应。
不可用的资源版本 服务器不需要提供无法识别的资源版本。
如果你请求了 list 或 get API 服务器无法识别的资源版本,则 API 服务器可能会:
短暂等待资源版本可用,如果提供的资源版本在合理的时间内仍不可用,
则应超时并返回 504 (Gateway Timeout)
; 使用 Retry-After
响应标头进行响应,指示客户端在重试请求之前应等待多少秒。 如果你请求 API 服务器无法识别的资源版本,
kube-apiserver 还会使用 “Too large resource version” 消息额外标识其错误响应。
如果你对无法识别的资源版本发出 watch 请求,
API 服务器可能会无限期地等待(直到请求超时)资源版本变为可用。
2.2 - 服务器端应用(Server-Side Apply) 特性状态: Kubernetes v1.22 [stable]
简介 服务器端应用协助用户、控制器通过声明式配置的方式管理他们的资源。
客户端可以发送完整描述的目标(A fully specified intent),
声明式地创建和修改对象 。
一个完整描述的目标并不是一个完整的对象,仅包括能体现用户意图的字段和值。
该目标(intent)可以用来创建一个新对象,
也可以通过服务器来实现与现有对象的合并 。
系统支持多个应用者(appliers)在同一个对象上开展协作。
“字段管理(field management) ”机制追踪对象字段的变化。
当一个字段值改变时,其所有权从当前管理器(manager)转移到施加变更的管理器。
当尝试将新配置应用到一个对象时,如果字段有不同的值,且由其他管理器管理,
将会引发冲突 。
冲突引发警告信号:此操作可能抹掉其他协作者的修改。
冲突可以被刻意忽略,这种情况下,值将会被改写,所有权也会发生转移。
当你从配置文件中删除一个字段,然后应用这个配置文件,
将触发服务器端应用检查此字段是否还被其他字段管理器拥有。
如果没有,那就从活动对象中删除该字段;如果有,那就重置为默认值。
该规则同样适用于 list 或 map 项目。
服务器端应用既是原有 kubectl apply
的替代品,
也是控制器发布自身变化的一个简化机制。
如果你启用了服务器端应用,控制平面就会跟踪被所有新创建对象管理的字段。
字段管理 相对于通过 kubectl
管理的注解 last-applied
,
服务器端应用使用了一种更具声明式特点的方法:
它持续的跟踪用户的字段管理,而不仅仅是最后一次的执行状态。
这就意味着,作为服务器端应用的一个副作用,
关于用哪一个字段管理器负责管理对象中的哪个字段的这类信息,都要对外界开放了。
用户管理字段这件事,在服务器端应用的场景中,意味着用户依赖并期望字段的值不要改变。
最后一次对字段值做出断言的用户将被记录到当前字段管理器。
这可以通过发送 POST
、 PUT
、
或非应用(non-apply)方式的 PATCH
等命令来修改字段值的方式实现,
或通过把字段放在配置文件中,然后发送到服务器端应用的服务端点的方式实现。
当使用服务器端应用,尝试着去改变一个被其他人管理的字段,
会导致请求被拒绝(在没有设置强制执行时,参见冲突 )。
如果两个或以上的应用者均把同一个字段设置为相同值,他们将共享此字段的所有权。
后续任何改变共享字段值的尝试,不管由那个应用者发起,都会导致冲突。
共享字段的所有者可以放弃字段的所有权,这只需从配置文件中删除该字段即可。
字段管理的信息存储在 managedFields
字段中,该字段是对象的
metadata
中的一部分。
服务器端应用创建对象的简单示例如下:
apiVersion : v1
kind : ConfigMap
metadata :
name : test-cm
namespace : default
labels :
test-label : test
managedFields :
- manager : kubectl
operation : Apply
apiVersion : v1
time : "2010-10-10T0:00:00Z"
fieldsType : FieldsV1
fieldsV1 :
f:metadata :
f:labels :
f:test-label : {}
f:data :
f:key : {}
data :
key : some value
上述对象在 metadata.managedFields
中包含了唯一的管理器。
管理器由管理实体自身的基本信息组成,比如操作类型、API 版本、以及它管理的字段。
说明: 该字段由 API 服务器管理,用户不应该改动它。
不过,执行 Update
操作修改 metadata.managedFields
也是可实现的。
强烈不鼓励这么做,但当发生如下情况时,
比如 managedFields
进入不一致的状态(显然不应该发生这种情况),
这么做也是一个合理的尝试。
managedFields
的格式在
API
文档中描述。
冲突 冲突是一种特定的错误状态,
发生在执行 Apply
改变一个字段,而恰巧该字段被其他用户声明过主权时。
这可以防止一个应用者不小心覆盖掉其他用户设置的值。
冲突发生时,应用者有三种办法来解决它:
覆盖前值,成为唯一的管理器: 如果打算覆盖该值(或应用者是一个自动化部件,比如控制器),
应用者应该设置查询参数 force
为 true(在 kubectl 中,可以通过在
apply 命令中使用 --force-conflicts
标志来完成),然后再发送一次请求。
这将强制操作成功,改变字段的值,从所有其他管理器的 managedFields 条目中删除指定字段。
不覆盖前值,放弃管理权: 如果应用者不再关注该字段的值,
可以从配置文件中删掉它,再重新发送请求。
这就保持了原值不变,并从 managedFields 的应用者条目中删除该字段。
不覆盖前值,成为共享的管理器: 如果应用者仍然关注字段值,并不想覆盖它,
他们可以在配置文件中把字段的值改为和服务器对象一样,再重新发送请求。
这样在不改变字段值的前提下,
就实现了字段管理被应用者和所有声明了管理权的其他的字段管理器共享。
管理器 管理器识别出正在修改对象的工作流程(在冲突时尤其有用),
管理器可以通过修改请求的参数 fieldManager
指定。
虽然 kubectl 默认发往 kubectl
服务端点,但它则请求到应用的服务端点(apply endpoint)。
对于其他的更新,它默认的是从用户代理计算得来。
应用和更新 此特性涉及两类操作,分别是 Apply
(内容类型为 application/apply-patch+yaml
的 PATCH
请求)
和 Update
(所有修改对象的其他操作)。
这两类操作都会更新字段 managedFields
,但行为表现有一点不同。
说明: 不管你提交的是 JSON 数据还是 YAML 数据,
都要使用 application/apply-patch+yaml
作为 Content-Type
的值。
所有的 JSON 文档 都是合法的 YAML。
例如,在冲突发生的时候,只有 apply
操作失败,而 update
则不会。
此外,apply
操作必须通过提供一个 fieldManager
查询参数来标识自身,
而此查询参数对于 update
操作则是可选的。
最后,当使用 apply
命令时,你不能在应用中的对象中持有 managedFields
。
一个包含多个管理器的对象,示例如下:
apiVersion : v1
kind : ConfigMap
metadata :
name : test-cm
namespace : default
labels :
test-label : test
managedFields :
- manager : kubectl
operation : Apply
apiVersion : v1
fields :
f:metadata :
f:labels :
f:test-label : {}
- manager : kube-controller-manager
operation : Update
apiVersion : v1
time : '2019-03-30T16:00:00.000Z'
fields :
f:data :
f:key : {}
data :
key : new value
在这个例子中,
第二个操作被管理器 kube-controller-manager
以 Update
的方式运行。
此 update
更改 data 字段的值,
并使得字段管理器被改为 kube-controller-manager
。
如果把 update
操作改为 Apply
,那就会因为所有权冲突的原因,导致操作失败。
合并策略 由服务器端应用实现的合并策略,提供了一个总体更稳定的对象生命周期。
服务器端应用试图依据负责管理它们的主体来合并字段,而不是根据值来否决。
这么做是为了多个主体可以更新同一个对象,且不会引起意外的相互干扰。
当用户发送一个“完整描述的目标”对象到服务器端应用的服务端点,
服务器会将它和活动对象做一次合并,如果两者中有重复定义的值,那就以配置文件的为准。
如果配置文件中的项目集合不是此用户上一次操作项目的超集,
所有缺少的、没有其他应用者管理的项目会被删除。
关于合并时用来做决策的对象规格的更多信息,参见
sigs.k8s.io/structured-merge-diff .
Kubernetes 1.16 和 1.17 中添加了一些标记,
允许 API 开发人员描述由 list、map、和 structs 支持的合并策略。
这些标记可应用到相应类型的对象,在 Go 文件或在
CRD
的 OpenAPI 的模式中定义:
Golang 标记 OpenAPI extension 可接受的值 描述 引入版本 //+listType
x-kubernetes-list-type
atomic
/set
/map
适用于 list。set
适用于仅包含标量元素的列表。这些元素必须是不重复的。map
仅适用于包含嵌套类型的列表。列表中的键(参见 listMapKey
)不可以重复。atomic
适用于任何类型的列表。如果配置为 atomic
,则合并时整个列表会被替换掉。任何时候,只有一个管理器负责管理指定列表。如果配置为 set
或 map
,不同的管理器也可以分开管理条目。 1.16 //+listMapKey
x-kubernetes-list-map-keys
字段名称的列表,例如,["port", "protocol"]
仅当 +listType=map
时适用。取值为字段名称的列表,这些字段值的组合能够唯一标识列表中的条目。尽管可以存在多个键,listMapKey
是单数的,这是因为键名需要在 Go 类型中各自独立指定。键字段必须是标量。 1.16 //+mapType
x-kubernetes-map-type
atomic
/granular
适用于 map。 atomic
指 map 只能被单个的管理器整个的替换。 granular
指 map 支持多个管理器各自更新自己的字段。 1.17 //+structType
x-kubernetes-map-type
atomic
/granular
适用于 structs;否则就像 //+mapType
有相同的用法和 openapi 注释. 1.17
若未指定 listType
,API 服务器将 patchMergeStrategy=merge
标记解释为
listType=map
并且视对应的 patchMergeKey
标记为 listMapKey
取值。
atomic
列表类型是递归的。
这些标记都是用源代码注释的方式给出的,不必作为字段标签(tag)再重复。
拓扑变化时的兼容性 在极少的情况下,CRD 或者内置类型的作者可能希望更改其资源中的某个字段的
拓扑配置,同时又不提升版本号。
通过升级集群或者更新 CRD 来更改类型的拓扑信息与更新现有对象的结果不同。
变更的类型有两种:一种是将字段从 map
/set
/granular
更改为 atomic
,
另一种是做逆向改变。
当 listType
、mapType
或 structType
从 map
/set
/granular
改为
atomic
时,现有对象的整个列表、映射或结构的属主都会变为这些类型的
元素之一的属主。这意味着,对这些对象的进一步变更会引发冲突。
当一个列表、映射或结构从 atomic
改为 map
/set
/granular
之一
时,API 服务器无法推导这些字段的新的属主。因此,当对象的这些字段
再次被更新时不会引发冲突。出于这一原因,不建议将某类型从 atomic
改为
map
/set
/granular
。
以下面的自定义资源为例:
apiVersion : example.com/v1
kind : Foo
metadata :
name : foo-sample
managedFields :
- manager : manager-one
operation : Apply
apiVersion : example.com/v1
fields :
f:spec :
f:data : {}
spec :
data :
key1 : val1
key2 : val2
在 spec.data
从 atomic
改为 granular
之前,manager-one
是
spec.data
字段及其所包含字段(key1
和 key2
)的属主。
当对应的 CRD 被更改,使得 spec.data
变为 granular
拓扑时,
manager-one
继续拥有顶层字段 spec.data
(这意味着其他管理者想删除名为
data
的映射而不引起冲突是不可能的),但不再拥有
key1
和 key2
。因此,其他管理者可以在不引起冲突的情况下更改
或删除这些字段。
自定义资源 默认情况下,服务器端应用把自定义资源看做非结构化数据。
所有的键值(keys)就像 struct 的字段一样被处理,
所有的 list 被认为是原子性的。
如果自定义资源定义(Custom Resource Definition,CRD)定义了一个
模式 ,
它包含类似以前“合并策略”章节中定义过的注解,
这些注解将在合并此类型的对象时使用。
在控制器中使用服务器端应用 控制器的开发人员可以把服务器端应用作为简化控制器的更新逻辑的方式。
读-改-写 和/或 patch 的主要区别如下所示:
应用的对象必须包含控制器关注的所有字段。 对于在控制器没有执行过应用操作之前就已经存在的字段,不能删除。
(控制器在这种用例环境下,依然可以发送一个 PATCH/UPDATE) 对象不必事先读取,resourceVersion
不必指定。 强烈推荐:设置控制器在冲突时强制执行,这是因为冲突发生时,它们没有其他解决方案或措施。
转移所有权 除了通过冲突解决方案 提供的并发控制,
服务器端应用提供了一些协作方式来将字段所有权从用户转移到控制器。
最好通过例子来说明这一点。
让我们来看看,在使用 HorizontalPodAutoscaler 资源和与之配套的控制器,
且开启了 Deployment 的自动水平扩展功能之后,
怎么安全的将 replicas
字段的所有权从用户转移到控制器。
假设用户定义了 Deployment,且 replicas
字段已经设置为期望的值:
apiVersion : apps/v1
kind : Deployment
metadata :
name : nginx-deployment
labels :
app : nginx
spec :
replicas : 3
selector :
matchLabels :
app : nginx
template :
metadata :
labels :
app : nginx
spec :
containers :
- name : nginx
image : nginx:1.14.2
并且,用户使用服务器端应用,像这样创建 Deployment:
kubectl apply -f https://k8s.io/examples/application/ssa/nginx-deployment.yaml --server-side
然后,为 Deployment 启用 HPA,例如:
kubectl autoscale deployment nginx-deployment --cpu-percent= 50 --min= 1 --max= 10
现在,用户希望从他们的配置中删除 replicas
,所以他们总是和 HPA 控制器冲突。
然而,这里存在一个竟态:
在 HPA 需要调整 replicas
之前会有一个时间窗口,
如果在 HPA 写入字段成为所有者之前,用户删除了replicas
,
那 API 服务器就会把 replicas
的值设为 1, 也就是默认值。
这不是用户希望发生的事情,即使是暂时的。
这里有两个解决方案:
(基本操作)把 replicas
留在配置文件中;当 HPA 最终写入那个字段,
系统基于此事件告诉用户:冲突发生了。在这个时间点,可以安全的删除配置文件。 (高级操作)然而,如果用户不想等待,比如他们想为合作伙伴保持集群清晰,
那他们就可以执行以下步骤,安全的从配置文件中删除 replicas
。 首先,用户新定义一个只包含 replicas
字段的配置文件:
# 将此文件另存为 'nginx-deployment-replicas-only.yaml'
apiVersion : apps/v1
kind : Deployment
metadata :
name : nginx-deployment
spec :
replicas : 3
说明: 此场景中针对 SSA 的 YAML 文件仅包含你要更改的字段。
如果只想使用 SSA 来修改 spec.replicas
字段,你无需提供完全兼容的 Deployment 清单。
用户使用名为 handover-to-hpa
的字段管理器,应用此配置文件。
kubectl apply -f nginx-deployment-replicas-only.yaml \
--server-side --field-manager= handover-to-hpa \
--validate= false
如果应用操作和 HPA 控制器产生冲突,那什么都不做。
冲突表明控制器在更早的流程中已经对字段声明过所有权。
在此时间点,用户可以从配置文件中删除 replicas
。
apiVersion : apps/v1
kind : Deployment
metadata :
name : nginx-deployment
labels :
app : nginx
spec :
selector :
matchLabels :
app : nginx
template :
metadata :
labels :
app : nginx
spec :
containers :
- name : nginx
image : nginx:1.14.2
注意,只要 HPA 控制器为 replicas
设置了一个新值,
该临时字段管理器将不再拥有任何字段,会被自动删除。
这里不需要执行清理工作。
在用户之间转移所有权 通过在配置文件中把一个字段设置为相同的值,用户可以在他们之间转移字段的所有权,
从而共享了字段的所有权。
当用户共享了字段的所有权,任何一个用户可以从他的配置文件中删除该字段,
并应用该变更,从而放弃所有权,并实现了所有权向其他用户的转移。
与客户端应用的对比 由服务器端应用实现的冲突检测和解决方案的一个结果就是,
应用者总是可以在本地状态中得到最新的字段值。
如果得不到最新值,下次执行应用操作时就会发生冲突。
解决冲突三个选项的任意一个都会保证:此应用过的配置文件是服务器上对象字段的最新子集。
这和客户端应用(Client Side Apply) 不同,如果有其他用户覆盖了此值,
过期的值被留在了应用者本地的配置文件中。
除非用户更新了特定字段,此字段才会准确,
应用者没有途径去了解下一次应用操作是否会覆盖其他用户的修改。
另一个区别是使用客户端应用的应用者不能改变他们正在使用的 API 版本,但服务器端应用支持这个场景。
从客户端应用升级到服务器端应用 客户端应用方式时,用户使用 kubectl apply
管理资源,
可以通过使用下面标记切换为使用服务器端应用。
kubectl apply --server-side [ --dry-run= server]
默认情况下,对象的字段管理从客户端应用方式迁移到 kubectl 触发的服务器端应用时,不会发生冲突。
注意: 保持注解 last-applied-configuration
是最新的。
从注解能推断出字段是由客户端应用管理的。
任何没有被客户端应用管理的字段将引发冲突。
举例说明,比如你在客户端应用之后,
使用 kubectl scale
去更新 replicas
字段,
可是该字段并没有被客户端应用所拥有,
在执行 kubectl apply --server-side
时就会产生冲突。
此操作以 kubectl
作为字段管理器来应用到服务器端应用。
作为例外,可以指定一个不同的、非默认字段管理器停止的这种行为,如下面的例子所示。
对于 kubectl 触发的服务器端应用,默认的字段管理器是 kubectl
。
kubectl apply --server-side --field-manager= my-manager [ --dry-run= server]
从服务器端应用降级到客户端应用 如果你用 kubectl apply --server-side
管理一个资源,
可以直接用 kubectl apply
命令将其降级为客户端应用。
降级之所以可行,这是因为 kubectl server-side apply
会保存最新的 last-applied-configuration
注解。
此操作以 kubectl
作为字段管理器应用到服务器端应用。
作为例外,可以指定一个不同的、非默认字段管理器停止这种行为,如下面的例子所示。
对于 kubectl 触发的服务器端应用,默认的字段管理器是 kubectl
。
kubectl apply --server-side --field-manager= my-manager [ --dry-run= server]
API 端点 启用了服务器端应用特性之后,
PATCH
服务端点接受额外的内容类型 application/apply-patch+yaml
。
服务器端应用的用户就可以把 YAMl
格式的部分定义对象(partially specified objects)发送到此端点。
当一个配置文件被应用时,它应该包含所有体现你意图的字段。
RBAC 和权限 因为服务器端应用是一种 PATCH
操作,所以一个角色编辑资源需要 PATCH
权限,
但要用服务器端应用创建资源还需要 CREATE
动作权限。
清除 ManagedFields 可以从对象中剥离所有 managedField,
实现方法是通过使用 MergePatch
、 StrategicMergePatch
、
JSONPatch
、 Update
、以及所有的非应用方式的操作来覆盖它。
这可以通过用空条目覆盖 managedFields 字段的方式实现。以下是两个示例:
PATCH /api/v1/namespaces/default/configmaps/example-cm
Content-Type: application/merge-patch+json
Accept: application/json
Data: {"metadata":{"managedFields": [{}]}}
PATCH /api/v1/namespaces/default/configmaps/example-cm
Content-Type: application/json-patch+json
Accept: application/json
Data: [{"op": "replace", "path": "/metadata/managedFields", "value": [{}]}]
这一操作将用只包含一个空条目的列表覆写 managedFields,
来实现从对象中整个的去除 managedFields。
注意,只把 managedFields 设置为空列表并不会重置字段。
这么做是有目的的,所以 managedFields 将永远不会被与该字段无关的客户删除。
在重置操作结合 managedFields 以外其他字段更改的场景中,
将导致 managedFields 首先被重置,其他改变被押后处理。
其结果是,应用者取得了同一个请求中所有字段的所有权。
2.3 - 客户端库 本页面概要介绍了基于各种编程语言使用 Kubernetes API 的客户端库。
在使用 Kubernetes REST API 编写应用程序时,
你并不需要自己实现 API 调用和 “请求/响应” 类型。
你可以根据自己的编程语言需要选择使用合适的客户端库。
客户端库通常为你处理诸如身份验证之类的常见任务。
如果 API 客户端在 Kubernetes 集群中运行,大多数客户端库可以发现并使用 Kubernetes 服务账号进行身份验证,
或者能够理解 kubeconfig 文件
格式来读取凭据和 API 服务器地址。
官方支持的 Kubernetes 客户端库 以下客户端库由 Kubernetes SIG API Machinery
正式维护。
社区维护的客户端库 说明:
本部分链接到提供 Kubernetes 所需功能的第三方项目。Kubernetes 项目作者不负责这些项目。此页面遵循
CNCF 网站指南 ,按字母顺序列出项目。要将项目添加到此列表中,请在提交更改之前阅读
内容指南 。
以下 Kubernetes API 客户端库是由社区,而非 Kubernetes 团队支持、维护的。
2.4 - Kubernetes 中的通用表达式语言 通用表达式语言 (Common Expression Language, CEL)
用于声明 Kubernetes API 的验证规则、策略规则和其他限制或条件。
CEL 表达式在API 服务器 中直接进行评估,
这使得 CEL 成为许多可扩展性用例的便捷替代方案,而无需使用类似 Webhook 这种进程外机制。
只要控制平面的 API 服务器组件保持可用状态,你的 CEL 表达式就会继续执行。
语言概述 CEL 语言 的语法直观简单,
类似于 C、C++、Java、JavaScript 和 Go 中的表达式。
CEL 的设计目的是嵌入应用程序中。每个 CEL "程序" 都是一个单独的表达式,其评估结果为单个值。
CEL 表达式通常是短小的 "一行式",可以轻松嵌入到 Kubernetes API 资源的字符串字段中。
对 CEL 程序的输入是各种 “变量”。包含 CEL 的每个 Kubernetes API 字段都在 API
文档中声明了字段可使用哪些变量。例如,在 CustomResourceDefinitions 的
x-kubernetes-validations[i].rules
字段中,self
和 oldSelf
变量可用,
并且分别指代要由 CEL 表达式验证的自定义资源数据的前一个状态和当前状态。
其他 Kubernetes API 字段可能声明不同的变量。请查阅 API 字段的 API 文档以了解该字段可使用哪些变量。
CEL 表达式示例:
CEL 表达式例子和每个表达式的用途 规则 用途 self.minReplicas <= self.replicas && self.replicas <= self.maxReplicas
验证定义副本的三个字段被正确排序 'Available' in self.stateCounts
验证映射中存在主键为 'Available' 的条目 (self.list1.size() == 0) != (self.list2.size() == 0)
验证两个列表中有一个非空,但不是两个都非空 self.envars.filter(e, e.name = 'MY_ENV').all(e, e.value.matches('^[a-zA-Z]*$')
验证 listMap 条目的 'value' 字段,其主键字段 'name' 是 'MY_ENV' has(self.expired) && self.created + self.ttl < self.expired
验证 'expired' 日期在 'create' 日期加上 'ttl' 持续时间之后 self.health.startsWith('ok')
验证 'health' 字符串字段具有前缀 'ok' self.widgets.exists(w, w.key == 'x' && w.foo < 10)
验证具有键 'x' 的 listMap 项的 'foo' 属性小于 10 type(self) == string ? self == '99%' : self == 42
验证 int-or-string 字段是否同时具备 int 和 string 的属性 self.metadata.name == 'singleton'
验证某对象的名称与特定的值匹配(使其成为一个特例) self.set1.all(e, !(e in self.set2))
验证两个 listSet 不相交 self.names.size() == self.details.size() && self.names.all(n, n in self.details)
验证 'details' 映射是由 'names' listSet 中的各项键入的
Kubernetes CEL 表达式能够访问以下 CEL 社区库:
Kubernetes CEL 库 除了 CEL 社区库之外,Kubernetes 还包括在 Kubernetes 中使用 CEL 时所有可用的 CEL 库。
Kubernetes 列表库 列表库包括 indexOf
和 lastIndexOf
,这两个函数的功能类似于同名的字符串函数。
这些函数返回提供的元素在列表中的第一个或最后一个位置索引。
列表库还包括 min
、max
和 sum
。
sum
可以用于所有数字类型以及持续时间类型。
min
和 max
可用于所有可比较的类型。
isSorted
也作为一个便捷的函数提供,并且支持所有可比较的类型。
例如:
使用列表库函数的 CEL 表达式例子 CEL 表达式 用途 names.isSorted()
验证名称列表是否按字母顺序排列 items.map(x, x.weight).sum() == 1.0
验证对象列表的 “weight” 总和为 1.0 lowPriorities.map(x, x.priority).max() < highPriorities.map(x, x.priority).min()
验证两组优先级不重叠 names.indexOf('should-be-first') == 1
如果是特定值,则使用列表中的第一个名称
更多信息请查阅 Go 文档:
Kubernetes 列表库 。
Kubernetes 正则表达式库 除了 CEL 标准库提供的 matches
函数外,正则表达式库还提供了 find
和 findAll
,
使得更多种类的正则表达式运算成为可能。
例如:
使用正则表达式库函数的 CEL 表达式例子 CEL 表达式 用途 "abc 123".find('[0-9]*')
找到字符串中的第一个数字 "1, 2, 3, 4".findAll('[0-9]*').map(x, int(x)).sum() < 100
验证字符串中的数字之和小于 100
更多信息请查阅 Go 文档:
Kubernetes 正则表达式库 。
Kubernetes URL 库 为了更轻松、更安全地处理 URL,添加了以下函数:
isURL(string)
按照
Go 的 net/url
检查字符串是否是一个有效的 URL。该字符串必须是一个绝对 URL。url(string) URL
将字符串转换为 URL,如果字符串不是一个有效的 URL,则返回错误。一旦通过 url
函数解析,所得到的 URL 对象就具有
getScheme
、getHost
、getHostname
、getPort
、getEscapedPath
和 getQuery
访问器。
例如:
使用 URL 库函数的 CEL 表达式例子 CEL 表达式 用途 url('https://example.com:80/').getHost()
获取 URL 的 'example.com:80' 主机部分 url('https://example.com/path with spaces/').getEscapedPath()
返回 '/path%20with%20spaces/'
更多信息请查阅 Go 文档:
Kubernetes URL 库 。
Kubernetes 鉴权组件库 在 API 中使用 CEL 表达式,可以使用类型为 Authorizer
的变量,
这个鉴权组件可用于对请求的主体(已认证用户)执行鉴权检查。
API 资源检查的过程如下:
指定要检查的组和资源:Authorizer.group(string).resource(string) ResourceCheck
可以调用以下任意组合的构建器函数(Builder Function),以进一步缩小鉴权检查范围。
注意这些函数将返回接收者的类型,并且可以串接起来:ResourceCheck.subresource(string) ResourceCheck
ResourceCheck.namespace(string) ResourceCheck
ResourceCheck.name(string) ResourceCheck
调用 ResourceCheck.check(verb string) Decision
来执行鉴权检查。 调用 allowed() bool
或 reason() string
来查验鉴权检查的结果。 对非资源访问的鉴权过程如下:
仅指定路径:Authorizer.path(string) PathCheck
调用 PathCheck.check(httpVerb string) Decision
来执行鉴权检查。 调用 allowed() bool
或 reason() string
来查验鉴权检查的结果。 对于服务账号执行鉴权检查的方式:
Authorizer.serviceAccount(namespace string, name string) Authorizer
使用 URL 库函数的 CEL 表达式示例 CEL 表达式 用途 authorizer.group('').resource('pods').namespace('default').check('create').allowed()
如果主体(用户或服务账号)被允许在 default
名字空间中创建 Pod,返回 true。 authorizer.path('/healthz').check('get').allowed()
检查主体(用户或服务账号)是否有权限向 /healthz API 路径发出 HTTP GET 请求。 authorizer.serviceAccount('default', 'myserviceaccount').resource('deployments').check('delete').allowed()
检查服务账号是否有权限删除 Deployment。
更多信息请参阅 Go 文档:
Kubernetes Authz library 。
类型检查 CEL 是一种逐渐类型化的语言 。
一些 Kubernetes API 字段包含完全经过类型检查的 CEL 表达式。
例如,CustomResourceDefinitions 验证规则 就是完全经过类型检查的。
一些 Kubernetes API 字段包含部分经过类型检查的 CEL 表达式。
部分经过类型检查的表达式是指一些变量是静态类型,而另一些变量是动态类型的表达式。
例如在 ValidatingAdmissionPolicies
的 CEL 表达式中,request
变量是有类型的,但 object
变量是动态类型的。
因此,包含 request.namex
的表达式将无法通过类型检查,因为 namex
字段未定义。
然而,即使对于 object
所引用的资源种类没有定义 namex
字段,
object.namex
也会通过类型检查,因为 object
是动态类型。
在 CEL 中,has()
宏可用于检查动态类型变量的字段是否可访问,然后再尝试访问该字段的值。
例如:
has(object.namex) ? object.namex == 'special' : request.name == 'special'
类型系统集成 表格显示了 OpenAPIv3 类型和 CEL 类型之间的关系 OpenAPIv3 类型 CEL 类型 设置了 properties 的 'object' object / "message type" (type(<object>)
评估为 selfType<uniqueNumber>.path.to.object.from.self
设置了 AdditionalProperties 的 'object' map 设置了 x-kubernetes-embedded-type 的 'object' object / "message type",'apiVersion'、'kind'、'metadata.name' 和 'metadata.generateName' 被隐式包含在模式中 设置了 x-kubernetes-preserve-unknown-fields 的 'object' object / "message type",CEL 表达式中不可访问的未知字段 x-kubernetes-int-or-string int 或 string 的并集,self.intOrString < 100 || self.intOrString == '50%'
对于 50
和 "50%"
都评估为 true 'array' list 设置了 x-kubernetes-list-type=map 的 'array' list,具有基于 Equality 和唯一键保证的 map 设置了 x-kubernetes-list-type=set 的 'array' list,具有基于 Equality 和唯一条目保证的 set 'boolean' boolean 'number' (所有格式) double 'integer' (所有格式) int (64) **非等价 ** uint (64) 'null' null_type 'string' string 设置了 format=byte 的 'string'(以 base64 编码) bytes 设置了 format=date 的 'string' timestamp (google.protobuf.Timestamp) 设置了 format=datetime 的 'string' timestamp (google.protobuf.Timestamp) 设置了 format=duration 的 'string' duration (google.protobuf.Duration)
另见:CEL 类型 、
OpenAPI 类型 、
Kubernetes 结构化模式 。
x-kubernetes-list-type
为 set
或 map
的数组进行相等比较时会忽略元素顺序。
例如,如果这些数组代表 Kubernetes 的 set
值,则 [1, 2] == [2, 1]
。
使用 x-kubernetes-list-type
的数组进行串接时,使用 list 类型的语义:
set
:X + Y
执行并集操作,保留 X
中所有元素的数组位置,
将 Y
中非交集元素追加到 X
中,保留它们的部分顺序。map
:X + Y
执行合并操作,保留 X
中所有键的数组位置,
但是当 X
和 Y
的键集相交时,将 Y
中的值覆盖 X
中的值。
将 Y
中非交集键的元素附加到 X
中,保留它们的部分顺序。转义 仅形如 [a-zA-Z_.-/][a-zA-Z0-9_.-/]*
的 Kubernetes 资源属性名可以从 CEL 中访问。
当在表达式中访问可访问的属性名时,会根据以下规则进行转义:
CEL 标识符转义规则表 转义序列 等价的属性名 __underscores__
__
__dot__
.
__dash__
-
__slash__
/
__{keyword}__
CEL 保留的 关键字
当你需要转义 CEL 的任一 保留的 关键字时,你需要使用下划线转义来完全匹配属性名
(例如,sprint
这个单词中的 int
不会被转义,也不需要被转义)。
转义示例:
转义的 CEL 标识符例子 属性名称 带有转义的属性名称的规则 namespace
self.__namespace__ > 0
x-prop
self.x__dash__prop > 0
redact__d
self.redact__underscores__d > 0
string
self.startsWith('kube')
资源约束 CEL 不是图灵完备的,提供了多种生产安全控制手段来限制执行时间。
CEL 的资源约束 特性提供了关于表达式复杂性的反馈,并帮助保护 API 服务器免受过度的资源消耗。
CEL 的资源约束特性用于防止 CEL 评估消耗过多的 API 服务器资源。
资源约束特性的一个关键要素是 CEL 定义的成本单位 ,它是一种跟踪 CPU 利用率的方式。
成本单位独立于系统负载和硬件。成本单位也是确定性的;对于任何给定的 CEL 表达式和输入数据,
由 CEL 解释器评估表达式将始终产生相同的成本。
CEL 的许多核心运算具有固定成本。例如比较(例如 <
)这类最简单的运算成本为 1。
有些运算具有更高的固定成本,例如列表字面声明具有 40 个成本单位的固定基础成本。
调用本地代码实现的函数时,基于运算的时间复杂度估算其成本。
举例而言:match
和 find
这类使用正则表达式的运算使用
length(regexString)*length(inputString)
的近似成本进行估算。
这个近似的成本反映了 Go 的 RE2 实现的最坏情况的时间复杂度。
运行时成本预算 所有由 Kubernetes 评估的 CEL 表达式都受到运行时成本预算的限制。
运行时成本预算是通过在解释 CEL 表达式时增加成本单元计数器来计算实际 CPU 利用率的估算值。
如果 CEL 解释器执行的指令太多,将超出运行时成本预算,表达式的执行将停止,并将出现错误。
一些 Kubernetes 资源定义了额外的运行时成本预算,用于限制多个表达式的执行。
如果所有表达式的成本总和超过预算,表达式的执行将停止,并将出现错误。
例如,自定义资源的验证具有针对验证自定义资源所评估的所有
验证规则 的
每个验证 运行时成本预算。
估算的成本限制 对于某些 Kubernetes 资源,API 服务器还可能检查 CEL 表达式的最坏情况估计运行时间是否过于昂贵而无法执行。
如果是,则 API 服务器会拒绝包含 CEL 表达式的创建或更新操作,以防止 CEL 表达式被写入 API 资源。
此特性提供了更强的保证,即写入 API 资源的 CEL 表达式将在运行时进行评估,而不会超过运行时成本预算。
2.5 - Kubernetes 弃用策略 本文档详细解释系统中各个层面的弃用策略(Deprecation Policy)。
Kubernetes 是一个组件众多、贡献者人数众多的大系统。
就像很多类似的软件,所提供的功能特性集合会随着时间推移而自然发生变化,
而且有时候某个功能特性可能需要被去除。被去除的可能是一个 API、
一个参数标志或者甚至某整个功能特性。为了避免影响到现有用户,
Kubernetes 对于其中渐次移除的各个方面规定了一种弃用策略并遵从此策略。
弃用 API 的一部分 由于 Kubernetes 是一个 API 驱动的系统,API 会随着时间推移而演化,
以反映人们对问题空间的认识的变化。Kubernetes API 实际上是一个 API 集合,
其中每个成员称作“API 组(API Group)”,并且每个 API 组都是独立管理版本的。
API 版本 会有三类,
每类有不同的废弃策略:
示例 分类 v1 正式发布(Generally available,GA,稳定版本) v1beta1 Beta (预发布) v1alpha1 Alpha (试验性)
给定的 Kubernetes 发布版本中可以支持任意数量的 API 组,且每组可以包含任意个数的版本。
下面的规则负责指导 API 元素的弃用,具体元素包括:
REST 资源(也即 API 对象) REST 资源的字段 REST 资源的注解,包含“beta”类注解但不包含“alpha”类注解 枚举值或者常数值 组件配置结构 以下是跨正式发布版本时要实施的规则,不适用于对 master 或发布分支上不同提交之间的变化。
规则 #1:只能在增加 API 组版本号时删除 API 元素。
一旦在某个特定 API 组版本中添加了 API 元素,则该元素不可从该版本中删除,
且其行为也不能大幅度地变化,无论属于哪一类(GA、Alpha 或 Beta)。
说明: 由于历史原因,Kubernetes 中存在两个“单体式(Monolithic)”API 组 -
“core”(无组名)和“extensions”。这两个遗留 API 组中的资源会被逐渐迁移到更为特定领域的 API 组中。
规则 #2:在给定的发布版本中,API 对象必须能够在不同的 API
版本之间来回转换且不造成信息丢失,除非整个 REST 资源在某些版本中完全不存在。
例如,一个对象可被用 v1 来写入之后用 v2 来读出并转换为 v1,所得到的 v1 必须与原来的
v1 对象完全相同。v2 中的表现形式可能与 v1 不同,但系统知道如何在两个版本之间执行双向转换。
此外,v2 中添加的所有新字段都必须能够转换为 v1 再转换回来。这意味着 v1
必须添加一个新的等效字段或者将其表现为一个注解。
规则 #3:给定类别的 API 版本不可被弃用以支持稳定性更差的 API 版本。
一个正式发布的(GA)API 版本可替换 Beta 或 Alpha API 版本。 Beta API 版本可以替换早期的 Beta 和 Alpha API 版本,但 不可以 替换正式的 API 版本。 Alpha API 版本可以替换早期的 Alpha API 版本,但 不可以 替换 Beta 或正式的 API 版本。 规则 #4a:API 生命周期由 API 稳定性级别决定
GA API 版本可以被标记为已弃用,但不得在 Kubernetes 的主要版本中删除 Beta API 版本在引入后不超过 9 个月或 3 个次要版本(以较长者为准)将被弃用,
并且在弃用后 9 个月或 3 个次要版本(以较长者为准)不再提供服务 Alpha API 版本可能会在任何版本中被删除,不另行通知 这确保了 Beta API 支持涵盖了最多 2 个版本的支持版本偏差 ,
并且这些 API 不会在不稳定的 Beta 版本上停滞不前,积累的生产使用数据将在对 Beta API 的支持结束时中断。
说明: 目前没有删除正式版本 API 的 Kubernetes 主要版本修订计划。
说明: 在
#52185 被解决之前,
已经被保存到持久性存储中的 API 版本都不可以被去除。
你可以禁止这些版本所对应的 REST 末端(在符合本文中弃用时间线的前提下),
但是 API 服务器必须仍能解析和转换存储中以前写入的数据。
规则 #4b:标记为“preferred(优选的)” API 版本和给定 API 组的
“storage version(存储版本)”在既支持老版本也支持新版本的 Kubernetes
发布版本出来以前不可以提升其版本号。
用户必须能够升级到 Kubernetes 新的发行版本,之后再回滚到前一个发行版本,
且整个过程中无需针对新的 API 版本做任何转换,也不允许出现功能损坏的情况,
除非用户显式地使用了仅在较新版本中才存在的功能特性。
就对象的存储表示而言,这一点尤其是不言自明的。
以上所有规则最好通过例子来说明。假定现有 Kubernetes 发行版本为 X,其中引入了新的 API 组。
大约每隔 4 个月会有一个新的 Kubernetes 版本被发布(每年 3 个版本)。
下面的表格描述了在一系列后续的发布版本中哪些 API 版本是受支持的。
发布版本 API 版本 优选/存储版本 注释 X v1alpha1 v1alpha1 X+1 v1alpha2 v1alpha2 v1alpha1 被去除,发布说明中会包含 "action required(采取行动)" 说明 X+2 v1beta1 v1beta1 v1alpha2 被去除,发布说明中包含对应的 "action required(采取行动)" 说明 X+3 v1beta2、v1beta1(已弃用) v1beta1 v1beta1 被弃用,发布说明中包含对应的 "action required(采取行动)" 说明 X+4 v1beta2、v1beta1(已弃用) v1beta2 X+5 v1、v1beta1(已弃用)、v1beta2(已弃用) v1beta2 v1beta2 被弃用,发布说明中包含对应的 "action required(采取行动)" 说明 X+6 v1、v1beta2(已弃用) v1 v1beta1 被去除,发布说明中包含对应的 "action required(采取行动)" 说明 X+7 v1、v1beta2(已弃用) v1 X+8 v2alpha1、v1 v1 v1beta2 被去除,发布说明中包含对应的 "action required(采取行动)" 说明 X+9 v2alpha2、v1 v1 v2alpha1 被删除,发布说明中包含对应的 "action required(采取行动)" 说明 X+10 v2beta1、v1 v1 v2alpha2 被删除,发布说明中包含对应的 "action required(采取行动)" 说明 X+11 v2beta2、v2beta1(已弃用)、v1 v1 v2beta1 被弃用,发布说明中包含对应的 "action required(采取行动)" 说明 X+12 v2、v2beta2(已弃用)、v2beta1(已弃用)、v1(已弃用) v1 v2beta2 已被弃用,发布说明中包含对应的 "action required(采取行动)" 说明 v1 已被弃用,取而代之的是 v2,但不会被删除 X+13 v2、v2beta1(已弃用)、v2beta2(已弃用)、v1(已弃用) v2 X+14 v2、v2beta2(已弃用)、v1(已弃用) v2 v2beta1 被删除,发布说明中包含对应的 "action required(采取行动)" 说明 X+15 v2、v1(已弃用) v2 v2beta2 被删除,发布说明中包含对应的 "action required(采取行动)" 说明
REST 资源(也即 API 对象) 考虑一个假想的名为 Widget 的 REST 资源,在上述时间线中位于 API v1,而现在打算将其弃用。
我们会在文档和公告 中与
X+1 版本的发布同步记述此弃用决定。
Widget 资源仍会在 API 版本 v1(已弃用)中存在,但不会出现在 v2alpha1 中。
Widget 资源会 X+8 发布版本之前(含 X+8)一直存在并可用。
只有在发布版本 X+9 中,API v1 寿终正寝时,Widget
才彻底消失,相应的资源行为也被移除。
从 Kubernetes v1.19 开始,当 API 请求被发送到一个已弃用的 REST API 末端时:
API 响应中会包含一个 Warning
头部字段(如 RFC7234 5.5 节 所定义);
该请求会导致对应的审计事件 中会增加一个注解
"k8s.io/deprecated":"true"
。
kube-apiserver
进程的 apiserver_requested_deprecated_apis
度量值会被设置为 1
。
该度量值还附带 group
、version
、resource
和 subresource
标签
(可供添加到度量值 apiserver_request_total
上),
和一个 removed_release
标签,标明该 API 将消失的 Kubernetes 发布版本。
下面的 Prometheus 查询会返回对 v1.22 中将移除的、已弃用的 API 的请求的信息:
apiserver_requested_deprecated_apis {removed_release = "1.22 "} * on ( group ,version ,resource ,subresource ) group_right () apiserver_request_total
REST 资源的字段 就像整个 REST 资源一样,在 API v1 中曾经存在的各个字段在 API v1 被移除之前必须一直存在且起作用。
与整个资源上的规定不同,v2 API 可以选择为字段提供不同的表示方式,
只要对应的资源对象可在不同版本之间来回转换即可。
例如,v1 版本中一个名为 "magnitude" 的已弃用字段可能在 API v2 中被命名为 "deprecatedMagnitude"。
当 v1 最终被移除时,废弃的字段也可以从 v2 中移除。
枚举值或常数值 就像前文讲述的 REST 资源及其中的单个字段一样,API v1 中所支持的常数值必须在
API v1 被移除之前一直存在且起作用。
组件配置结构 组件的配置也是有版本的,并且按 REST 资源的方式来管理。
将来的工作 随着时间推移,Kubernetes 会引入粒度更细的 API 版本。
到那时,这里的规则会根据需要进行调整。
弃用一个标志或 CLI 命令 Kubernetes 系统中包含若干不同的、相互协作的程序。
有时,Kubernetes 可能会删除这些程序的某些标志或 CLI 命令(统称“命令行元素”)。
这些程序可以天然地划分到两个大组中:面向用户的和面向管理员的程序。
二者之间的弃用策略略有不同。
除非某个标志显示地通过前缀或文档来标明其为“alpha”或“beta”,
该标志要被视作正式发布的(GA)。
命令行元素相当于系统的 API 的一部分,不过因为它们并没有采用 REST API
一样的方式来管理版本,其弃用规则规定如下:
规则 #5a:面向用户的命令行元素(例如,kubectl)必须在其宣布被弃用其在以下时长内仍能使用:
GA:12 个月或者 2 个发布版本(取其较长者) Beta:3 个月或者 1 个发布版本(取其较长者) Alpha:0 发布版本 规则 #5b:面向管理员的命令行元素(例如,kubelet)必须在其被宣布弃用之后以下时长内保持可用:
GA:6 个月或 1 个发行版本(取其较长者) Beta: 3 个月或 1 个发行版本(取其较长者) Alpha: 0 个发布版本 规则 #6:被弃用的 CLI 元素在被用到时必须能够产生警告,而警告的产生是可以被禁止的。
弃用某功能特性或行为 在一些较偶然的情形下,某 Kubernetes 发行版本需要弃用系统的某项功能特性或者行为,
而对应的功能特性或行为并不受 API 或 CLI 控制。在这种情况下,其弃用规则如下:
规则 #7:被弃用的行为必须在被宣布弃用之后至少 1 年时间内必须保持能用。
这并不意味着对系统的所有更改都受此策略约束。
此规则仅适用于重大的、用户可见的行为;这些行为会影响到在 Kubernetes
中运行的应用的正确性,或者影响到 Kubernetes 集群的管理。
此规则也适用于那些被整个移除的功能特性或行为。
上述规则的一个例外是 特性门控(Feature Gate) 。特性门控是一些键值偶对,
允许用户启用或禁用一些试验性的功能特性。
特性门控意在覆盖功能特性的整个开发周期,它们无意成为长期的 API。
因此,它们会在某功能特性正式发布或被抛弃之后被弃用和删除。
随着一个功能特性经过不同的成熟阶段,相关的特性门控也会演化。
与功能特性生命周期对应的特性门控状态为:
Alpha:特性门控默认被禁用,只能由用户显式启用。 Beta:特性门控默认被弃用,可被用户显式禁用。 GA: 特性门控被弃用(参见弃用 ),并且不再起作用。 GA,弃用窗口期结束:特性门控被删除,不再接受调用。 弃用 功能特性在正式发布之前的生命周期内任何时间点都可被移除。
当未正式发布的功能特性被移除时,它们对应的特性门控也被弃用。
当尝试禁用一个不再起作用的特性门控时,该调用会失败,这样可以避免毫无迹象地执行一些不受支持的场景。
在某些场合,移除一个即将正式发布的功能特性需要很长时间。
特性门控可以保持其功能,直到对应的功能特性被彻底去除,直到那时特性门控自身才可被弃用。
由于移除一个已经正式发布的功能特性对应的特性门控也需要一定时间,对特性门控的调用可能一直被允许,
前提是特性门控对功能本身无影响且特性门控不会引发任何错误。
意在允许用户禁用的功能特性应该包含一个在相关联的特性门控中禁用该功能的机制。
特性门控的版本管理与之前讨论的组件版本管理不同,因此其对应的弃用策略如下:
规则 #8:特性门控所对应的功能特性经历下面所列的成熟性阶段转换时,特性门控必须被弃用。
特性门控弃用时必须在以下时长内保持其功能可用:
Beta 特性转为 GA:6 个月或者 2 个发布版本(取其较长者) Beta 特性转为丢弃:3 个月或者 1 个发布版本(取其较长者) Alpha 特性转为丢弃:0 个发布版本 规则 #9:已弃用的特色门控再被使用时必须给出警告回应。当特性门控被弃用时,
必须在发布说明和对应的 CLI 帮助信息中通过文档宣布。
警告信息和文档都要标明是否某特性门控不再起作用。
弃用度量值 Kubernetes 控制平面的每个组件都公开度量值(通常是 /metrics
端点),它们通常由集群管理员使用。
并不是所有的度量值都是同样重要的:一些度量值通常用作 SLIs 或被使用来确定 SLOs,这些往往比较重要。
其他度量值在本质上带有实验性,或者主要用于 Kubernetes 开发过程。
因此,度量值分为三个稳定性类别(ALPHA
、BETA
、STABLE
);
此分类会影响在 Kubernetes 发布版本中移除某度量值。
所对应的分类取决于对该度量值重要性的预期。
弃用和移除度量值的规则如下:
规则 #9a: 对于相应的稳定性类别,度量值起作用的周期必须不小于:
STABLE: 4 个发布版本或者 12 个月 (取其较长者) BETA: 2 个发布版本或者 8 个月 (取其较长者) ALPHA: 0 个发布版本 规则 #9b: 在度量值被宣布启用之后,它起作用的周期必须不小于:
STABLE: 3 个发布版本或者 9 个月 (取其较长者) BETA: 1 个发布版本或者 4 个月 (取其较长者) ALPHA: 0 个发布版本 已弃用的度量值将在其描述文本前加上一个已弃用通知字符串 '(Deprecated from x.y)',
并将在度量值被记录期间发出警告日志。就像稳定的、未被弃用的度量指标一样,
被弃用的度量值将自动注册到 metrics 端点,因此被弃用的度量值也是可见的。
在随后的版本中(当度量值 deprecatedVersion
等于 当前 Kubernetes 版本 - 3 ),
被弃用的度量值将变成 隐藏(Hidden) metric 度量值。
与被弃用的度量值不同,隐藏的度量值将不再被自动注册到 metrics 端点(因此被隐藏)。
但是,它们可以通过可执行文件的命令行标志显式启用
(--show-hidden-metrics-for-version=
)。
如果集群管理员不能对早期的弃用警告作出反应,这一设计就为他们提供了抓紧迁移弃用度量值的途径。
隐藏的度量值应该在再过一个发行版本后被删除。
例外 没有策略可以覆盖所有情况。此策略文档是一个随时被更新的文档,会随着时间推移演化。
在实践中,会有一些情况无法很好地匹配到这里的弃用策略,
或者这里的策略变成了很严重的羁绊。这类情形要与 SIG 和项目领导讨论,
寻求对应场景的最佳解决方案。请一直铭记,Kubernetes 承诺要成为一个稳定的系统,
至少会尽力做到不会影响到其用户。此弃用策略的任何例外情况都会在所有相关的发布说明中公布。
2.6 - 已弃用 API 的迁移指南 随着 Kubernetes API 的演化,API 会周期性地被重组或升级。
当 API 演化时,老的 API 会被弃用并被最终删除。
本页面包含你在将已弃用 API 版本迁移到新的更稳定的 API 版本时需要了解的知识。
各发行版本中移除的 API v1.29 v1.29 发行版本将停止提供以下已弃用的 API 版本:
流控制资源 flowcontrol.apiserver.k8s.io/v1beta2 API 版本的 FlowSchema
和 PriorityLevelConfiguration 将不会在 v1.29 中提供。
迁移清单和 API 客户端使用 flowcontrol.apiserver.k8s.io/v1beta3 API 版本,
此 API 从 v1.26 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; flowcontrol.apiserver.k8s.io/v1beta3 中需要额外注意的变更:PriorityLevelConfiguration 的 spec.limited.assuredConcurrencyShares
字段已被更名为 spec.limited.nominalConcurrencyShares
v1.27 v1.27 发行版本中将去除以下已弃用的 API 版本:
CSIStorageCapacity storage.k8s.io/v1beta1 API 版本的 CSIStorageCapacity 将不会在 v1.27 提供。
自 v1.24 版本起,迁移清单和 API 客户端使用 storage.k8s.io/v1 API 版本 所有现有的持久化对象都可以通过新的 API 访问 没有需要额外注意的变更 v1.26 v1.26 发行版本中将去除以下已弃用的 API 版本:
流控制资源 从 v1.26 版本开始不再提供 flowcontrol.apiserver.k8s.io/v1beta1 API 版本的
FlowSchema 和 PriorityLevelConfiguration。
迁移清单和 API 客户端使用 flowcontrol.apiserver.k8s.io/v1beta3 API 版本,
此 API 从 v1.26 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更 HorizontalPodAutoscaler 从 v1.26 版本开始不再提供 autoscaling/v2beta2 API 版本的
HorizontalPodAutoscaler。
迁移清单和 API 客户端使用 autoscaling/v2 API 版本,
此 API 从 v1.23 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; v1.25 v1.25 发行版本将停止提供以下已废弃 API 版本:
CronJob 从 v1.25 版本开始不再提供 batch/v1beta1 API 版本的 CronJob。
迁移清单和 API 客户端使用 batch/v1 API 版本,此 API 从 v1.21 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 EndpointSlice 从 v1.25 版本开始不再提供 discovery.k8s.io/v1beta1 API 版本的 EndpointSlice。
迁移清单和 API 客户端使用 discovery.k8s.io/v1 API 版本,此 API 从 v1.21 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; discovery.k8s.io/v1 中值得注意的变更有:使用每个 Endpoint 的 nodeName
字段而不是已被弃用的
topology["kubernetes.io/hostname"]
字段; 使用每个 Endpoint 的 zone
字段而不是已被弃用的
topology["kubernetes.io/zone"]
字段; topology
字段被替换为 deprecatedTopology
,并且在 v1 版本中不可写入。Event 从 v1.25 版本开始不再提供 events.k8s.io/v1beta1 API 版本的 Event。
迁移清单和 API 客户端使用 events.k8s.io/v1 API 版本,此 API 从 v1.19 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; events.k8s.io/v1 中值得注意的变更有:type
字段只能设置为 Normal
和 Warning
之一;involvedObject
字段被更名为 regarding
;action
、reason
、reportingController
和 reportingInstance
字段
在创建新的 events.k8s.io/v1 版本 Event 时都是必需的字段;使用 eventTime
而不是已被弃用的 firstTimestamp
字段
(该字段已被更名为 deprecatedFirstTimestamp
,且不允许出现在新的 events.k8s.io/v1 Event 对象中); 使用 series.lastObservedTime
而不是已被弃用的 lastTimestamp
字段
(该字段已被更名为 deprecatedLastTimestamp
,且不允许出现在新的 events.k8s.io/v1 Event 对象中); 使用 series.count
而不是已被弃用的 count
字段
(该字段已被更名为 deprecatedCount
,且不允许出现在新的 events.k8s.io/v1 Event 对象中); 使用 reportingController
而不是已被弃用的 source.component
字段
(该字段已被更名为 deprecatedSource.component
,且不允许出现在新的 events.k8s.io/v1 Event 对象中); 使用 reportingInstance
而不是已被弃用的 source.host
字段
(该字段已被更名为 deprecatedSource.host
,且不允许出现在新的 events.k8s.io/v1 Event 对象中)。 HorizontalPodAutoscaler 从 v1.25 版本开始不再提供 autoscaling/v2beta1 API 版本的
HorizontalPodAutoscaler。
迁移清单和 API 客户端使用 autoscaling/v2 API 版本,此 API 从 v1.23 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问。 PodDisruptionBudget 从 v1.25 版本开始不再提供 policy/v1beta1 API 版本的 PodDisruptionBudget。
迁移清单和 API 客户端使用 policy/v1 API 版本,此 API 从 v1.21 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; policy/v1 中需要额外注意的变更有:在 policy/v1
版本的 PodDisruptionBudget 中将 spec.selector
设置为空({}
)时会选择名字空间中的所有 Pod(在 policy/v1beta1
版本中,空的 spec.selector
不会选择任何 Pod)。如果 spec.selector
未设置,则在两个 API 版本下都不会选择任何 Pod。 PodSecurityPolicy 从 v1.25 版本开始不再提供 policy/v1beta1 API 版本中的 PodSecurityPolicy,
并且 PodSecurityPolicy 准入控制器也会被删除。
迁移到 Pod 安全准入 或第三方准入 webhook 。
有关迁移指南,请参阅从 PodSecurityPolicy 迁移到内置 PodSecurity 准入控制器 。
有关弃用的更多信息,请参阅 PodSecurityPolicy 弃用:过去、现在和未来 。
RuntimeClass 从 v1.25 版本开始不再提供 node.k8s.io/v1beta1 API 版本中的 RuntimeClass。
迁移清单和 API 客户端使用 node.k8s.io/v1 API 版本,此 API 从 v1.20 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 v1.22 v1.22 发行版本停止提供以下已废弃 API 版本:
Webhook 资源 admissionregistration.k8s.io/v1beta1 API 版本的 MutatingWebhookConfiguration
和 ValidatingWebhookConfiguration 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 admissionregistration.k8s.io/v1 API 版本,
此 API 从 v1.16 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 值得注意的变更:webhooks[*].failurePolicy
在 v1 版本中默认值从 Ignore
改为 Fail
webhooks[*].matchPolicy
在 v1 版本中默认值从 Exact
改为 Equivalent
webhooks[*].timeoutSeconds
在 v1 版本中默认值从 30s
改为 10s
webhooks[*].sideEffects
的默认值被删除,并且该字段变为必须指定;
在 v1 版本中可选的值只能是 None
和 NoneOnDryRun
之一webhooks[*].admissionReviewVersions
的默认值被删除,在 v1
版本中此字段变为必须指定(AdmissionReview 的被支持版本包括 v1
和 v1beta1
)webhooks[*].name
必须在通过 admissionregistration.k8s.io/v1
创建的对象列表中唯一 CustomResourceDefinition apiextensions.k8s.io/v1beta1 API 版本的 CustomResourceDefinition
不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 apiextensions/v1 API 版本,此 API 从 v1.16 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; APIService apiregistration/v1beta1 API 版本的 APIService 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 apiregistration.k8s.io/v1 API 版本,此 API 从
v1.10 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 TokenReview authentication.k8s.io/v1beta1 API 版本的 TokenReview 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 authentication.k8s.io/v1 API 版本,此 API 从
v1.6 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 SubjectAccessReview resources authorization.k8s.io/v1beta1 API 版本的 LocalSubjectAccessReview、
SelfSubjectAccessReview、SubjectAccessReview、SelfSubjectRulesReview 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 authorization.k8s.io/v1 API 版本,此 API 从
v1.6 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 需要额外注意的变更:spec.group
在 v1 版本中被更名为 spec.groups
(补丁 #32709 ) CertificateSigningRequest certificates.k8s.io/v1beta1 API 版本的 CertificateSigningRequest 不在
v1.22 版本中继续提供。
迁移清单和 API 客户端使用 certificates.k8s.io/v1 API 版本,此 API 从
v1.19 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; certificates.k8s.io/v1
中需要额外注意的变更:对于请求证书的 API 客户端而言:spec.signerName
现在变成必需字段(参阅
已知的 Kubernetes 签署者 ),
并且通过 certificates.k8s.io/v1
API 不可以创建签署者为
kubernetes.io/legacy-unknown
的请求spec.usages
现在变成必需字段,其中不可以包含重复的字符串值,
并且只能包含已知的用法字符串 对于要批准或者签署证书的 API 客户端而言:status.conditions
中不可以包含重复的类型status.conditions[*].status
字段现在变为必需字段status.certificate
必须是 PEM 编码的,而且其中只能包含 CERTIFICATE
数据块 Lease coordination.k8s.io/v1beta1 API 版本的 Lease 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 coordination.k8s.io/v1 API 版本,此 API 从
v1.14 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 Ingress extensions/v1beta1 和 networking.k8s.io/v1beta1 API 版本的 Ingress
不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 networking.k8s.io/v1 API 版本,此 API 从
v1.19 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 值得注意的变更:spec.backend
字段被更名为 spec.defaultBackend
后端的 serviceName
字段被更名为 service.name
数值表示的后端 servicePort
字段被更名为 service.port.number
字符串表示的后端 servicePort
字段被更名为 service.port.name
对所有要指定的路径,pathType
都成为必需字段。
可选项为 Prefix
、Exact
和 ImplementationSpecific
。
要匹配 v1beta1
版本中未定义路径类型时的行为,可使用 ImplementationSpecific
IngressClass networking.k8s.io/v1beta1 API 版本的 IngressClass 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 networking.k8s.io/v1 API 版本,此 API 从
v1.19 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 RBAC 资源 rbac.authorization.k8s.io/v1beta1 API 版本的 ClusterRole、ClusterRoleBinding、
Role 和 RoleBinding 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 rbac.authorization.k8s.io/v1 API 版本,此 API 从
v1.8 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 PriorityClass scheduling.k8s.io/v1beta1 API 版本的 PriorityClass 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 scheduling.k8s.io/v1 API 版本,此 API 从
v1.14 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 存储资源 storage.k8s.io/v1beta1 API 版本的 CSIDriver、CSINode、StorageClass
和 VolumeAttachment 不在 v1.22 版本中继续提供。
迁移清单和 API 客户端使用 storage.k8s.io/v1 API 版本CSIDriver 从 v1.19 版本开始在 storage.k8s.io/v1 中提供; CSINode 从 v1.17 版本开始在 storage.k8s.io/v1 中提供; StorageClass 从 v1.6 版本开始在 storage.k8s.io/v1 中提供; VolumeAttachment 从 v1.13 版本开始在 storage.k8s.io/v1 中提供; 所有的已保存的对象都可以通过新的 API 来访问; 没有需要额外注意的变更。 v1.16 v1.16 发行版本停止提供以下已废弃 API 版本:
NetworkPolicy extensions/v1beta1 API 版本的 NetworkPolicy 不在 v1.16 版本中继续提供。
迁移清单和 API 客户端使用 networking.k8s.io/v1 API 版本,此 API 从
v1.8 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问。 DaemonSet extensions/v1beta1 和 apps/v1beta2 API 版本的 DaemonSet 在
v1.16 版本中不再继续提供。
迁移清单和 API 客户端使用 apps/v1 API 版本,此 API 从 v1.9 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 值得注意的变更:spec.templateGeneration
字段被删除spec.selector
现在变成必需字段,并且在对象创建之后不可变更;
可以将现有模板的标签作为选择算符以实现无缝迁移。spec.updateStrategy.type
的默认值变为 RollingUpdate
(extensions/v1beta1
API 版本中的默认值是 OnDelete
)。 Deployment extensions/v1beta1 、apps/v1beta1 和 apps/v1beta2 API 版本的
Deployment 在 v1.16 版本中不再继续提供。
迁移清单和 API 客户端使用 apps/v1 API 版本,此 API 从 v1.9 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 值得注意的变更:spec.rollbackTo
字段被删除spec.selector
字段现在变为必需字段,并且在 Deployment 创建之后不可变更;
可以使用现有的模板的标签作为选择算符以实现无缝迁移。spec.progressDeadlineSeconds
的默认值变为 600
秒
(extensions/v1beta1
中的默认值是没有期限)spec.revisionHistoryLimit
的默认值变为 10
(apps/v1beta1
API 版本中此字段默认值为 2
,在extensions/v1beta1
API
版本中的默认行为是保留所有历史记录)。maxSurge
和 maxUnavailable
的默认值变为 25%
(在 extensions/v1beta1
API 版本中,这些字段的默认值是 1
)。 StatefulSet apps/v1beta1 和 apps/v1beta2 API 版本的 StatefulSet 在 v1.16 版本中不再继续提供。
迁移清单和 API 客户端使用 apps/v1 API 版本,此 API 从 v1.9 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 值得注意的变更:spec.selector
字段现在变为必需字段,并且在 StatefulSet 创建之后不可变更;
可以使用现有的模板的标签作为选择算符以实现无缝迁移。spec.updateStrategy.type
的默认值变为 RollingUpdate
(apps/v1beta1
API 版本中的默认值是 OnDelete
)。 ReplicaSet extensions/v1beta1 、apps/v1beta1 和 apps/v1beta2 API 版本的
ReplicaSet 在 v1.16 版本中不再继续提供。
迁移清单和 API 客户端使用 apps/v1 API 版本,此 API 从 v1.9 版本开始可用; 所有的已保存的对象都可以通过新的 API 来访问; 值得注意的变更:spec.selector
现在变成必需字段,并且在对象创建之后不可变更;
可以将现有模板的标签作为选择算符以实现无缝迁移。 PodSecurityPolicy extensions/v1beta1 API 版本的 PodSecurityPolicy 在 v1.16 版本中不再继续提供。
迁移清单和 API 客户端使用 policy/v1beta1 API 版本,此 API 从 v1.10 版本开始可用; 注意 policy/v1beta1 API 版本的 PodSecurityPolicy 会在 v1.25 版本中移除。 需要做什么 在禁用已启用 API 的情况下执行测试 你可以通过在启动 API 服务器时禁用特定的 API 版本来模拟即将发生的
API 移除,从而完成测试。在 API 服务器启动参数中添加如下标志:
--runtime-config=<group>/<version>=false
例如:
--runtime-config=admissionregistration.k8s.io/v1beta1=false,apiextensions.k8s.io/v1beta1,...
定位何处使用了已弃用的 API 使用 client warnings, metrics, and audit information available in 1.19+
来定位在何处使用了已弃用的 API。
迁移到未被弃用的 API 更新自定义的集成组件和控制器,调用未被弃用的 API 更改 YAML 文件引用未被弃用的 API 你可以用 kubectl-convert
命令(在 v1.20 之前是 kubectl convert
)
来自动转换现有对象:
kubectl-convert -f <file> --output-version <group>/<version>
.
例如,要将较老的 Deployment 版本转换为 apps/v1
版本,你可以运行:
kubectl-convert -f ./my-deployment.yaml --output-version apps/v1
需要注意的是这种操作使用的默认值可能并不理想。
要进一步了解某个特定资源,可查阅 Kubernetes API 参考 。
2.7 - Kubernetes API 健康端点 Kubernetes API 服务器 提供 API 端点以指示 API 服务器的当前状态。
本文描述了这些 API 端点,并说明如何使用。
API 健康端点 Kubernetes API 服务器提供 3 个 API 端点(healthz
、livez
和 readyz
)来表明 API 服务器的当前状态。
healthz
端点已被弃用(自 Kubernetes v1.16 起),你应该使用更为明确的 livez
和 readyz
端点。
livez
端点可与 --livez-grace-period
标志 一起使用,来指定启动持续时间。
为了正常关机,你可以使用 /readyz
端点并指定 --shutdown-delay-duration
标志 。
检查 API 服务器的 healthz
/livez
/readyz
端点的机器应依赖于 HTTP 状态代码。
状态码 200
表示 API 服务器是 healthy
、live
还是 ready
,具体取决于所调用的端点。
以下更详细的选项供操作人员使用,用来调试其集群或了解 API 服务器的状态。
以下示例将显示如何与运行状况 API 端点进行交互。
对于所有端点,都可以使用 verbose
参数来打印检查项以及检查状态。
这对于操作人员调试 API 服务器的当前状态很有用,这些不打算给机器使用:
curl -k https://localhost:6443/livez?verbose
或从具有身份验证的远程主机:
kubectl get --raw= '/readyz?verbose'
输出将如下所示:
[+]ping ok
[+]log ok
[+]etcd ok
[+]poststarthook/start-kube-apiserver-admission-initializer ok
[+]poststarthook/generic-apiserver-start-informers ok
[+]poststarthook/start-apiextensions-informers ok
[+]poststarthook/start-apiextensions-controllers ok
[+]poststarthook/crd-informer-synced ok
[+]poststarthook/bootstrap-controller ok
[+]poststarthook/rbac/bootstrap-roles ok
[+]poststarthook/scheduling/bootstrap-system-priority-classes ok
[+]poststarthook/start-cluster-authentication-info-controller ok
[+]poststarthook/start-kube-aggregator-informers ok
[+]poststarthook/apiservice-registration-controller ok
[+]poststarthook/apiservice-status-available-controller ok
[+]poststarthook/kube-apiserver-autoregistration ok
[+]autoregister-completion ok
[+]poststarthook/apiservice-openapi-controller ok
healthz check passed
Kubernetes API 服务器也支持排除特定的检查项。
查询参数也可以像以下示例一样进行组合:
curl -k 'https://localhost:6443/readyz?verbose&exclude=etcd'
输出显示排除了 etcd
检查:
[+]ping ok
[+]log ok
[+]etcd excluded: ok
[+]poststarthook/start-kube-apiserver-admission-initializer ok
[+]poststarthook/generic-apiserver-start-informers ok
[+]poststarthook/start-apiextensions-informers ok
[+]poststarthook/start-apiextensions-controllers ok
[+]poststarthook/crd-informer-synced ok
[+]poststarthook/bootstrap-controller ok
[+]poststarthook/rbac/bootstrap-roles ok
[+]poststarthook/scheduling/bootstrap-system-priority-classes ok
[+]poststarthook/start-cluster-authentication-info-controller ok
[+]poststarthook/start-kube-aggregator-informers ok
[+]poststarthook/apiservice-registration-controller ok
[+]poststarthook/apiservice-status-available-controller ok
[+]poststarthook/kube-apiserver-autoregistration ok
[+]autoregister-completion ok
[+]poststarthook/apiservice-openapi-controller ok
[+]shutdown ok
healthz check passed
独立健康检查 特性状态: Kubernetes v1.27 [alpha]
每个单独的健康检查都会公开一个 HTTP 端点,并且可以单独检查。
单个运行状况检查的模式为 /livez/<healthcheck-name>
,其中 livez
和 readyz
表明你要检查的是 API 服务器是否存活或就绪。
<healthcheck-name>
的路径可以通过上面的 verbose
参数发现 ,并采用 [+]
和 ok
之间的路径。
这些单独的健康检查不应由机器使用,但对于操作人员调试系统而言,是有帮助的:
curl -k https://localhost:6443/livez/etcd
3 - API 访问控制 关于 Kubernetes 如何实现和控制 API 访问的介绍性材料,
可阅读控制 Kubernetes API 的访问 。
参考文档:
3.1 - 用户认证 本页提供身份认证有关的概述。
Kubernetes 中的用户 所有 Kubernetes 集群都有两类用户:由 Kubernetes 管理的服务账号和普通用户。
Kubernetes 假定普通用户是由一个与集群无关的服务通过以下方式之一进行管理的:
负责分发私钥的管理员 类似 Keystone 或者 Google Accounts 这类用户数据库 包含用户名和密码列表的文件 有鉴于此,Kubernetes 并不包含用来代表普通用户账号的对象 。
普通用户的信息无法通过 API 调用添加到集群中。
尽管无法通过 API 调用来添加普通用户,
Kubernetes 仍然认为能够提供由集群的证书机构签名的合法证书的用户是通过身份认证的用户。
基于这样的配置,Kubernetes 使用证书中的 'subject' 的通用名称(Common Name)字段
(例如,"/CN=bob")来确定用户名。
接下来,基于角色访问控制(RBAC)子系统会确定用户是否有权针对某资源执行特定的操作。
进一步的细节可参阅证书请求
下普通用户主题。
与此不同,服务账号是 Kubernetes API 所管理的用户。它们被绑定到特定的名字空间,
或者由 API 服务器自动创建,或者通过 API 调用创建。服务账号与一组以 Secret
保存的凭据相关,这些凭据会被挂载到 Pod 中,从而允许集群内的进程访问 Kubernetes API。
API 请求则或者与某普通用户相关联,或者与某服务账号相关联,
亦或者被视作匿名请求 。这意味着集群内外的每个进程在向 API
服务器发起请求时都必须通过身份认证,否则会被视作匿名用户。这里的进程可以是在某工作站上输入
kubectl
命令的操作人员,也可以是节点上的 kubelet
组件,还可以是控制面的成员。
身份认证策略 Kubernetes 通过身份认证插件利用客户端证书、持有者令牌(Bearer Token)或身份认证代理(Proxy)
来认证 API 请求的身份。HTTP 请求发给 API 服务器时,插件会将以下属性关联到请求本身:
用户名:用来辩识最终用户的字符串。常见的值可以是 kube-admin
或 jane@example.com
。 用户 ID:用来辩识最终用户的字符串,旨在比用户名有更好的一致性和唯一性。 用户组:取值为一组字符串,其中各个字符串用来标明用户是某个命名的用户逻辑集合的成员。
常见的值可能是 system:masters
或者 devops-team
等。 附加字段:一组额外的键-值映射,键是字符串,值是一组字符串;
用来保存一些鉴权组件可能觉得有用的额外信息。 所有(属性)值对于身份认证系统而言都是不透明的,
只有被鉴权组件 解释过之后才有意义。
你可以同时启用多种身份认证方法,并且你通常会至少使用两种方法:
针对服务账号使用服务账号令牌 至少另外一种方法对用户的身份进行认证 当集群中启用了多个身份认证模块时,第一个成功地对请求完成身份认证的模块会直接做出评估决定。
API 服务器并不保证身份认证模块的运行顺序。
对于所有通过身份认证的用户,system:authenticated
组都会被添加到其组列表中。
与其它身份认证协议(LDAP、SAML、Kerberos、X509 的替代模式等等)
都可以通过使用一个身份认证代理 或身份认证 Webhoook
来实现。
X509 客户证书 通过给 API 服务器传递 --client-ca-file=SOMEFILE
选项,就可以启动客户端证书身份认证。
所引用的文件必须包含一个或者多个证书机构,用来验证向 API 服务器提供的客户端证书。
如果提供了客户端证书并且证书被验证通过,则 subject 中的公共名称(Common Name)
就被作为请求的用户名。
自 Kubernetes 1.4 开始,客户端证书还可以通过证书的 organization 字段标明用户的组成员信息。
要包含用户的多个组成员信息,可以在证书中包含多个 organization 字段。
例如,使用 openssl
命令行工具生成一个证书签名请求:
openssl req -new -key jbeda.pem -out jbeda-csr.pem -subj "/CN=jbeda/O=app1/O=app2"
此命令将使用用户名 jbeda
生成一个证书签名请求(CSR),且该用户属于 "app1" 和
"app2" 两个用户组。
参阅管理证书 了解如何生成客户端证书。
静态令牌文件 当 API 服务器的命令行设置了 --token-auth-file=SOMEFILE
选项时,会从文件中读取持有者令牌。
目前,令牌会长期有效,并且在不重启 API 服务器的情况下无法更改令牌列表。
令牌文件是一个 CSV 文件,包含至少 3 个列:令牌、用户名和用户的 UID。
其余列被视为可选的组名。
说明: 如果要设置的组名不止一个,则对应的列必须用双引号括起来,例如:
token,user,uid,"group1,group2,group3"
在请求中放入持有者令牌 当使用持有者令牌来对某 HTTP 客户端执行身份认证时,API 服务器希望看到一个名为
Authorization
的 HTTP 头,其值格式为 Bearer <token>
。
持有者令牌必须是一个可以放入 HTTP 头部值字段的字符序列,至多可使用 HTTP 的编码和引用机制。
例如:如果持有者令牌为 31ada4fd-adec-460c-809a-9e56ceb75269
,则其出现在 HTTP 头部时如下所示:
Authorization: Bearer 31ada4fd-adec-460c-809a-9e56ceb75269
启动引导令牌 特性状态: Kubernetes v1.18 [stable]
为了支持平滑地启动引导新的集群,Kubernetes 包含了一种动态管理的持有者令牌类型,
称作 启动引导令牌(Bootstrap Token) 。
这些令牌以 Secret 的形式保存在 kube-system
名字空间中,可以被动态管理和创建。
控制器管理器包含的 TokenCleaner
控制器能够在启动引导令牌过期时将其删除。
这些令牌的格式为 [a-z0-9]{6}.[a-z0-9]{16}
。第一个部分是令牌的 ID;
第二个部分是令牌的 Secret。你可以用如下所示的方式来在 HTTP 头部设置令牌:
Authorization: Bearer 781292.db7bc3a58fc5f07e
你必须在 API 服务器上设置 --enable-bootstrap-token-auth
标志来启用基于启动引导令牌的身份认证组件。
你必须通过控制器管理器的 --controllers
标志来启用 TokenCleaner 控制器;
这可以通过类似 --controllers=*,tokencleaner
这种设置来做到。
如果你使用 kubeadm
来启动引导新的集群,该工具会帮你完成这些设置。
身份认证组件的认证结果为 system:bootstrap:<令牌 ID>
,该用户属于
system:bootstrappers
用户组。
这里的用户名和组设置都是有意设计成这样,其目的是阻止用户在启动引导集群之后继续使用这些令牌。
这里的用户名和组名可以用来(并且已经被 kubeadm
用来)构造合适的鉴权策略,
以完成启动引导新集群的工作。
请参阅启动引导令牌 ,
以了解关于启动引导令牌身份认证组件与控制器的更深入的信息,以及如何使用
kubeadm
来管理这些令牌。
服务账号令牌 服务账号(Service Account)是一种自动被启用的用户认证机制,使用经过签名的持有者令牌来验证请求。
该插件可接受两个可选参数:
--service-account-key-file
文件包含 PEM 编码的 x509 RSA 或 ECDSA 私钥或公钥,
用于验证 ServiceAccount 令牌。这样指定的文件可以包含多个密钥,
并且可以使用不同的文件多次指定此参数。若未指定,则使用 --tls-private-key-file 参数。--service-account-lookup
如果启用,则从 API 删除的令牌会被回收。服务账号通常由 API 服务器自动创建并通过 ServiceAccount
准入控制器 关联到集群中运行的 Pod 上。
持有者令牌会挂载到 Pod 中可预知的位置,允许集群内进程与 API 服务器通信。
服务账号也可以使用 Pod 规约的 serviceAccountName
字段显式地关联到 Pod 上。
说明: serviceAccountName
通常会被忽略,因为关联关系是自动建立的。
apiVersion : apps/v1 # 此 apiVersion 从 Kubernetes 1.9 开始可用
kind : Deployment
metadata :
name : nginx-deployment
namespace : default
spec :
replicas : 3
template :
metadata :
# ...
spec :
serviceAccountName : bob-the-bot
containers :
- name : nginx
image : nginx:1.14.2
在集群外部使用服务账号持有者令牌也是完全合法的,且可用来为长时间运行的、需要与 Kubernetes
API 服务器通信的任务创建标识。要手动创建服务账号,可以使用
kubectl create serviceaccount <名称>
命令。
此命令会在当前的名字空间中生成一个服务账号。
kubectl create serviceaccount jenkins
serviceaccount/jenkins created
创建相关联的令牌:
kubectl create token jenkins
eyJhbGciOiJSUzI1NiIsImtp...
所创建的令牌是一个已签名的 JWT 令牌。
已签名的 JWT 可以用作持有者令牌,并将被认证为所给的服务账号。
关于如何在请求中包含令牌,请参阅前文 。
通常,这些令牌数据会被挂载到 Pod 中以便集群内访问 API 服务器时使用,
不过也可以在集群外部使用。
服务账号被身份认证后,所确定的用户名为 system:serviceaccount:<名字空间>:<服务账号>
,
并被分配到用户组 system:serviceaccounts
和 system:serviceaccounts:<名字空间>
。
警告: 由于服务账号令牌也可以保存在 Secret API 对象中,任何能够写入这些 Secret
的用户都可以请求一个令牌,且任何能够读取这些 Secret 的用户都可以被认证为对应的服务账号。
在为用户授予访问服务账号的权限以及对 Secret 的读取或写入权能时,要格外小心。
OpenID Connect(OIDC)令牌 OpenID Connect 是一种 OAuth2 认证方式,
被某些 OAuth2 提供者支持,例如 Azure 活动目录、Salesforce 和 Google。
协议对 OAuth2 的主要扩充体现在有一个附加字段会和访问令牌一起返回,
这一字段称作 ID Token(ID 令牌) 。
ID 令牌是一种由服务器签名的 JWT 令牌,其中包含一些可预知的字段,
例如用户的邮箱地址,
要识别用户,身份认证组件使用 OAuth2
令牌响应 中的
id_token
(而非 access_token
)作为持有者令牌。
关于如何在请求中设置令牌,可参见前文 。
sequenceDiagram
participant user as 用户
participant idp as 身份提供者
participant kube as Kubectl
participant api as API 服务器
user ->> idp: 1. 登录到 IdP
activate idp
idp -->> user: 2. 提供 access_token, id_token, 和 refresh_token
deactivate idp
activate user
user ->> kube: 3. 调用 Kubectl 并 设置 --token 为 id_token 或者将令牌添加到 .kube/config
deactivate user
activate kube
kube ->> api: 4. Authorization: Bearer...
deactivate kube
activate api
api ->> api: 5. JWT 签名合法么?
api ->> api: 6. JWT 是否已过期?(iat+exp)
api ->> api: 7. 用户被授权了么?
api -->> kube: 8. 已授权:执行 操作并返回结果
deactivate api
activate kube
kube --x user: 9. 返回结果
deactivate kube
登录到你的身份服务(Identity Provider) 你的身份服务将为你提供 access_token
、id_token
和 refresh_token
在使用 kubectl
时,将 id_token
设置为 --token
标志值,或者将其直接添加到
kubeconfig
中 kubectl
将你的 id_token
放到一个称作 Authorization
的头部,发送给 API 服务器API 服务器将负责通过检查配置中引用的证书来确认 JWT 的签名是合法的 检查确认 id_token
尚未过期 确认用户有权限执行操作 鉴权成功之后,API 服务器向 kubectl
返回响应 kubectl
向用户提供反馈信息由于用来验证你是谁的所有数据都在 id_token
中,Kubernetes 不需要再去联系身份服务。
在一个所有请求都是无状态请求的模型中,这一工作方式可以使得身份认证的解决方案更容易处理大规模请求。
不过,此访问也有一些挑战:
Kubernetes 没有提供用来触发身份认证过程的 "Web 界面"。
因为不存在用来收集用户凭据的浏览器或用户接口,你必须自己先行完成对身份服务的认证过程。 id_token
令牌不可收回。因其属性类似于证书,其生命期一般很短(只有几分钟),
所以,每隔几分钟就要获得一个新的令牌这件事可能很让人头疼。如果需要向 Kubernetes 控制面板执行身份认证,你必须使用 kubectl proxy
命令或者一个能够注入 id_token
的反向代理。 配置 API 服务器 要启用此插件,须在 API 服务器上配置以下标志:
参数 描述 示例 必需? --oidc-issuer-url
允许 API 服务器发现公开的签名密钥的服务的 URL。只接受模式为 https://
的 URL。此值通常设置为服务的发现 URL,不含路径。例如:"https://accounts.google.com" 或 "https://login.salesforce.com"。此 URL 应指向 .well-known/openid-configuration 下一层的路径。 如果发现 URL 是 https://accounts.google.com/.well-known/openid-configuration
,则此值应为 https://accounts.google.com
是 --oidc-client-id
所有令牌都应发放给此客户 ID。 kubernetes 是 --oidc-username-claim
用作用户名的 JWT 申领(JWT Claim)。默认情况下使用 sub
值,即最终用户的一个唯一的标识符。管理员也可以选择其他申领,例如 email
或者 name
,取决于所用的身份服务。不过,除了 email
之外的申领都会被添加令牌发放者的 URL 作为前缀,以免与其他插件产生命名冲突。 sub 否 --oidc-username-prefix
要添加到用户名申领之前的前缀,用来避免与现有用户名发生冲突(例如:system:
用户)。例如,此标志值为 oidc:
时将创建形如 oidc:jane.doe
的用户名。如果此标志未设置,且 --oidc-username-claim
标志值不是 email
,则默认前缀为 <令牌发放者的 URL>#
,其中 <令牌发放者 URL >
的值取自 --oidc-issuer-url
标志的设定。此标志值为 -
时,意味着禁止添加用户名前缀。 oidc:
否 --oidc-groups-claim
用作用户组名的 JWT 申领。如果所指定的申领确实存在,则其值必须是一个字符串数组。 groups 否 --oidc-groups-prefix
添加到组申领的前缀,用来避免与现有用户组名(如:system:
组)发生冲突。例如,此标志值为 oidc:
时,所得到的用户组名形如 oidc:engineering
和 oidc:infra
。 oidc:
否 --oidc-required-claim
取值为一个 key=value 偶对,意为 ID 令牌中必须存在的申领。如果设置了此标志,则 ID 令牌会被检查以确定是否包含取值匹配的申领。此标志可多次重复,以指定多个申领。 claim=value
否 --oidc-ca-file
指向一个 CA 证书的路径,该 CA 负责对你的身份服务的 Web 证书提供签名。默认值为宿主系统的根 CA。 /etc/kubernetes/ssl/kc-ca.pem
否 --oidc-signing-algs
采纳的签名算法。默认为 "RS256"。 RS512
否
很重要的一点是,API 服务器并非一个 OAuth2 客户端,相反,它只能被配置为信任某一个令牌发放者。
这使得使用公共服务(如 Google)的用户可以不信任发放给第三方的凭据。
如果管理员希望使用多个 OAuth 客户端,他们应该研究一下那些支持 azp
(Authorized Party,被授权方)申领的服务。
azp
是一种允许某客户端代替另一客户端发放令牌的机制。
Kubernetes 并未提供 OpenID Connect 的身份服务。
你可以使用现有的公共的 OpenID Connect 身份服务
(例如 Google 或者其他服务 )。
或者,你也可以选择自己运行一个身份服务,例如 dex 、
Keycloak 、
CloudFoundry UAA 或者
Tremolo Security 的 OpenUnison 。
要在 Kubernetes 环境中使用某身份服务,该服务必须:
支持 OpenID connect 发现 ;
但事实上并非所有服务都具备此能力 运行 TLS 协议且所使用的加密组件都未过时 拥有由 CA 签名的证书(即使 CA 不是商业 CA 或者是自签名的 CA 也可以) 关于上述第三条需求,即要求具备 CA 签名的证书,有一些额外的注意事项。
如果你部署了自己的身份服务,而不是使用云厂商(如 Google 或 Microsoft)所提供的服务,
你必须对身份服务的 Web 服务器证书进行签名,签名所用证书的 CA
标志要设置为
TRUE
,即使用的是自签名证书。这是因为 GoLang 的 TLS 客户端实现对证书验证标准方面有非常严格的要求。如果你手头没有现成的 CA 证书,可以使用 CoreOS
团队所开发的这个脚本
来创建一个简单的 CA 和被签了名的证书与密钥对。
或者你也可以使用这个类似的脚本 ,
生成一个合法期更长、密钥尺寸更大的 SHA256 证书。
特定系统的安装指令:
使用 kubectl 选项一:OIDC 身份认证组件 第一种方案是使用 kubectl 的 oidc
身份认证组件,该组件将 id_token
设置为所有请求的持有者令牌,
并且在令牌过期时自动刷新。在你登录到你的身份服务之后,
可以使用 kubectl 来添加你的 id_token
、refresh_token
、client_id
和
client_secret
,以配置该插件。
如果服务在其刷新令牌响应中不包含 id_token
,则此插件无法支持该服务。
这时你应该考虑下面的选项二。
kubectl config set-credentials USER_NAME \
--auth-provider= oidc \
--auth-provider-arg= idp-issuer-url=( issuer url ) \
--auth-provider-arg= client-id=( your client id ) \
--auth-provider-arg= client-secret=( your client secret ) \
--auth-provider-arg= refresh-token=( your refresh token ) \
--auth-provider-arg= idp-certificate-authority=( path to your ca certificate ) \
--auth-provider-arg= id-token=( your id_token )
作为示例,在完成对你的身份服务的身份认证之后,运行下面的命令:
kubectl config set-credentials mmosley \
--auth-provider= oidc \
--auth-provider-arg= idp-issuer-url= https://oidcidp.tremolo.lan:8443/auth/idp/OidcIdP \
--auth-provider-arg= client-id= kubernetes \
--auth-provider-arg= client-secret= 1db158f6-177d-4d9c-8a8b-d36869918ec5 \
--auth-provider-arg= refresh-token= q1bKLFOyUiosTfawzA93TzZIDzH2TNa2SMm0zEiPKTUwME6BkEo6Sql5yUWVBSWpKUGphaWpxSVAfekBOZbBhaEW+VlFUeVRGcluyVF5JT4+haZmPsluFoFu5XkpXk5BXqHega4GAXlF+ma+vmYpFcHe5eZR+slBFpZKtQA= \
--auth-provider-arg= idp-certificate-authority= /root/ca.pem \
--auth-provider-arg= id-token= eyJraWQiOiJDTj1vaWRjaWRwLnRyZW1vbG8ubGFuLCBPVT1EZW1vLCBPPVRybWVvbG8gU2VjdXJpdHksIEw9QXJsaW5ndG9uLCBTVD1WaXJnaW5pYSwgQz1VUy1DTj1rdWJlLWNhLTEyMDIxNDc5MjEwMzYwNzMyMTUyIiwiYWxnIjoiUlMyNTYifQ.eyJpc3MiOiJodHRwczovL29pZGNpZHAudHJlbW9sby5sYW46ODQ0My9hdXRoL2lkcC9PaWRjSWRQIiwiYXVkIjoia3ViZXJuZXRlcyIsImV4cCI6MTQ4MzU0OTUxMSwianRpIjoiMm96US15TXdFcHV4WDlHZUhQdy1hZyIsImlhdCI6MTQ4MzU0OTQ1MSwibmJmIjoxNDgzNTQ5MzMxLCJzdWIiOiI0YWViMzdiYS1iNjQ1LTQ4ZmQtYWIzMC0xYTAxZWU0MWUyMTgifQ.w6p4J_6qQ1HzTG9nrEOrubxIMb9K5hzcMPxc9IxPx2K4xO9l-oFiUw93daH3m5pluP6K7eOE6txBuRVfEcpJSwlelsOsW8gb8VJcnzMS9EnZpeA0tW_p-mnkFc3VcfyXuhe5R3G7aa5d8uHv70yJ9Y3-UhjiN9EhpMdfPAoEB9fYKKkJRzF7utTTIPGrSaSU6d2pcpfYKaxIwePzEkT4DfcQthoZdy9ucNvvLoi1DIC-UocFD8HLs8LYKEqSxQvOcvnThbObJ9af71EwmuE21fO5KzMW20KtAeget1gnldOosPtz1G5EwvaQ401-RPQzPGMVBld0_zMCAwZttJ4knw
此操作会生成以下配置:
users :
- name : mmosley
user :
auth-provider :
config :
client-id : kubernetes
client-secret : 1db158f6-177d-4d9c-8a8b-d36869918ec5
id-token : eyJraWQiOiJDTj1vaWRjaWRwLnRyZW1vbG8ubGFuLCBPVT1EZW1vLCBPPVRybWVvbG8gU2VjdXJpdHksIEw9QXJsaW5ndG9uLCBTVD1WaXJnaW5pYSwgQz1VUy1DTj1rdWJlLWNhLTEyMDIxNDc5MjEwMzYwNzMyMTUyIiwiYWxnIjoiUlMyNTYifQ.eyJpc3MiOiJodHRwczovL29pZGNpZHAudHJlbW9sby5sYW46ODQ0My9hdXRoL2lkcC9PaWRjSWRQIiwiYXVkIjoia3ViZXJuZXRlcyIsImV4cCI6MTQ4MzU0OTUxMSwianRpIjoiMm96US15TXdFcHV4WDlHZUhQdy1hZyIsImlhdCI6MTQ4MzU0OTQ1MSwibmJmIjoxNDgzNTQ5MzMxLCJzdWIiOiI0YWViMzdiYS1iNjQ1LTQ4ZmQtYWIzMC0xYTAxZWU0MWUyMTgifQ.w6p4J_6qQ1HzTG9nrEOrubxIMb9K5hzcMPxc9IxPx2K4xO9l-oFiUw93daH3m5pluP6K7eOE6txBuRVfEcpJSwlelsOsW8gb8VJcnzMS9EnZpeA0tW_p-mnkFc3VcfyXuhe5R3G7aa5d8uHv70yJ9Y3-UhjiN9EhpMdfPAoEB9fYKKkJRzF7utTTIPGrSaSU6d2pcpfYKaxIwePzEkT4DfcQthoZdy9ucNvvLoi1DIC-UocFD8HLs8LYKEqSxQvOcvnThbObJ9af71EwmuE21fO5KzMW20KtAeget1gnldOosPtz1G5EwvaQ401-RPQzPGMVBld0_zMCAwZttJ4knw
idp-certificate-authority : /root/ca.pem
idp-issuer-url : https://oidcidp.tremolo.lan:8443/auth/idp/OidcIdP
refresh-token : q1bKLFOyUiosTfawzA93TzZIDzH2TNa2SMm0zEiPKTUwME6BkEo6Sql5yUWVBSWpKUGphaWpxSVAfekBOZbBhaEW+VlFUeVRGcluyVF5JT4+haZmPsluFoFu5XkpXk5BXq
name : oidc
当你的 id_token
过期时,kubectl
会尝试使用你的 refresh_token
来刷新你的
id_token
,并且在 .kube/config
文件的 client_secret
中存放 refresh_token
和 id_token
的新值。
选项二:使用 --token
选项 kubectl
命令允许你使用 --token
选项传递一个令牌。
你可以将 id_token
的内容复制粘贴过来,作为此标志的取值:
kubectl --token= eyJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJodHRwczovL21sYi50cmVtb2xvLmxhbjo4MDQzL2F1dGgvaWRwL29pZGMiLCJhdWQiOiJrdWJlcm5ldGVzIiwiZXhwIjoxNDc0NTk2NjY5LCJqdGkiOiI2RDUzNXoxUEpFNjJOR3QxaWVyYm9RIiwiaWF0IjoxNDc0NTk2MzY5LCJuYmYiOjE0NzQ1OTYyNDksInN1YiI6Im13aW5kdSIsInVzZXJfcm9sZSI6WyJ1c2VycyIsIm5ldy1uYW1lc3BhY2Utdmlld2VyIl0sImVtYWlsIjoibXdpbmR1QG5vbW9yZWplZGkuY29tIn0.f2As579n9VNoaKzoF-dOQGmXkFKf1FMyNV0-va_B63jn-_n9LGSCca_6IVMP8pO-Zb4KvRqGyTP0r3HkHxYy5c81AnIh8ijarruczl-TK_yF5akjSTHFZD-0gRzlevBDiH8Q79NAr-ky0P4iIXS8lY9Vnjch5MF74Zx0c3alKJHJUnnpjIACByfF2SCaYzbWFMUNat-K1PaUk5-ujMBG7yYnr95xD-63n8CO8teGUAAEMx6zRjzfhnhbzX-ajwZLGwGUBT4WqjMs70-6a7_8gZmLZb2az1cZynkFRj2BaCkVT3A2RrjeEwZEtGXlMqKJ1_I2ulrOVsYx01_yD35-rw get nodes
Webhook 令牌身份认证 Webhook 身份认证是一种用来验证持有者令牌的回调机制。
--authentication-token-webhook-config-file
指向一个配置文件,
其中描述如何访问远程的 Webhook 服务。--authentication-token-webhook-cache-ttl
用来设定身份认证决定的缓存时间。
默认时长为 2 分钟。--authentication-token-webhook-version
决定是使用 authentication.k8s.io/v1beta1
还是
authenticationk8s.io/v1
版本的 TokenReview
对象从 webhook 发送/接收信息。
默认为“v1beta1”。配置文件使用 kubeconfig
文件的格式。文件中,clusters
指代远程服务,users
指代远程 API 服务
Webhook。下面是一个例子:
# Kubernetes API 版本
apiVersion : v1
# API 对象类别
kind : Config
# clusters 指代远程服务
clusters :
- name : name-of-remote-authn-service
cluster :
certificate-authority : /path/to/ca.pem # 用来验证远程服务的 CA
server : https://authn.example.com/authenticate # 要查询的远程服务 URL。生产环境中建议使用 'https'。
# users 指代 API 服务的 Webhook 配置
users :
- name : name-of-api-server
user :
client-certificate : /path/to/cert.pem # Webhook 插件要使用的证书
client-key : /path/to/key.pem # 与证书匹配的密钥
# kubeconfig 文件需要一个上下文(Context),此上下文用于本 API 服务器
current-context : webhook
contexts :
- context :
cluster : name-of-remote-authn-service
user : name-of-api-server
name : webhook
当客户端尝试在 API 服务器上使用持有者令牌完成身份认证
(如前 所述)时,
身份认证 Webhook 会用 POST 请求发送一个 JSON 序列化的对象到远程服务。
该对象是 TokenReview
对象,其中包含持有者令牌。
Kubernetes 不会强制请求提供此 HTTP 头部。
要注意的是,Webhook API 对象和其他 Kubernetes API 对象一样,
也要受到同一版本兼容规则 约束。
实现者应检查请求的 apiVersion
字段以确保正确的反序列化,
并且 必须 以与请求相同版本的 TokenReview
对象进行响应。
说明: Kubernetes API 服务器默认发送 authentication.k8s.io/v1beta1
令牌以实现向后兼容性。
要选择接收 authentication.k8s.io/v1
令牌认证,API 服务器必须带着参数
--authentication-token-webhook-version=v1
启动。
{
"apiVersion": "authentication.k8s.io/v1" ,
"kind": "TokenReview" ,
"spec": {
# 发送到 API 服务器的不透明持有者令牌
"token": "014fbff9a07c..." ,
# 提供令牌的服务器的受众标识符的可选列表。
# 受众感知令牌验证器(例如,OIDC 令牌验证器)
# 应验证令牌是否针对此列表中的至少一个受众,
# 并返回此列表与响应状态中令牌的有效受众的交集。
# 这确保了令牌对于向其提供给的服务器进行身份验证是有效的。
# 如果未提供受众,则应验证令牌以向 Kubernetes API 服务器进行身份验证。
"audiences": ["https://myserver.example.com" , "https://myserver.internal.example.com" ]
}
}
{
"apiVersion": "authentication.k8s.io/v1beta1" ,
"kind": "TokenReview" ,
"spec": {
# 发送到 API 服务器的不透明匿名令牌
"token": "014fbff9a07c..." ,
# 提供令牌的服务器的受众标识符的可选列表。
# 受众感知令牌验证器(例如,OIDC 令牌验证器)
# 应验证令牌是否针对此列表中的至少一个受众,
# 并返回此列表与响应状态中令牌的有效受众的交集。
# 这确保了令牌对于向其提供给的服务器进行身份验证是有效的。
# 如果未提供受众,则应验证令牌以向 Kubernetes API 服务器进行身份验证。
"audiences": ["https://myserver.example.com" , "https://myserver.internal.example.com" ]
}
}
远程服务预计会填写请求的 status
字段以指示登录成功。
响应正文的 spec
字段被忽略并且可以省略。
远程服务必须使用它收到的相同 TokenReview
API 版本返回响应。
持有者令牌的成功验证将返回:
{
"apiVersion": "authentication.k8s.io/v1" ,
"kind": "TokenReview" ,
"status": {
"authenticated": true ,
"user": {
# 必要
"username": "janedoe@example.com" ,
# 可选
"uid": "42" ,
# 可选的组成员身份
"groups": ["developers" , "qa" ],
# 认证者提供的可选附加信息。
# 此字段不可包含机密数据,因为这类数据可能被记录在日志或 API 对象中,
# 并且可能传递给 admission webhook。
"extra": {
"extrafield1": [
"extravalue1" ,
"extravalue2"
]
}
},
# 验证器可以返回的、可选的用户感知令牌列表,
# 包含令牌对其有效的、包含于 `spec.audiences` 列表中的受众。
# 如果省略,则认为该令牌可用于对 Kubernetes API 服务器进行身份验证。
"audiences": ["https://myserver.example.com" ]
}
}
{
"apiVersion": "authentication.k8s.io/v1beta1" ,
"kind": "TokenReview" ,
"status": {
"authenticated": true ,
"user": {
# 必要
"username": "janedoe@example.com" ,
# 可选
"uid": "42" ,
# 可选的组成员身份
"groups": ["developers" , "qa" ],
# 认证者提供的可选附加信息。
# 此字段不可包含机密数据,因为这类数据可能被记录在日志或 API 对象中,
# 并且可能传递给 admission webhook。
"extra": {
"extrafield1": [
"extravalue1" ,
"extravalue2"
]
}
},
# 验证器可以返回的、可选的用户感知令牌列表,
# 包含令牌对其有效的、包含于 `spec.audiences` 列表中的受众。
# 如果省略,则认为该令牌可用于对 Kubernetes API 服务器进行身份验证。
"audiences": ["https://myserver.example.com" ]
}
}
而不成功的请求会返回:
{
"apiVersion": "authentication.k8s.io/v1" ,
"kind": "TokenReview" ,
"status": {
"authenticated": false ,
# 可选地包括有关身份验证失败原因的详细信息。
# 如果没有提供错误信息,API 将返回一个通用的 Unauthorized 消息。
# 当 authenticated=true 时,error 字段被忽略。
"error": "Credentials are expired"
}
}
{
"apiVersion": "authentication.k8s.io/v1beta1" ,
"kind": "TokenReview" ,
"status": {
"authenticated": false ,
# 可选地包括有关身份验证失败原因的详细信息。
# 如果没有提供错误信息,API 将返回一个通用的 Unauthorized 消息。
# 当 authenticated=true 时,error 字段被忽略。
"error": "Credentials are expired"
}
}
身份认证代理 API 服务器可以配置成从请求的头部字段值(如 X-Remote-User
)中辩识用户。
这一设计是用来与某身份认证代理一起使用 API 服务器,代理负责设置请求的头部字段值。
--requestheader-username-headers
必需字段,大小写不敏感。
用来设置要获得用户身份所要检查的头部字段名称列表(有序)。
第一个包含数值的字段会被用来提取用户名。--requestheader-group-headers
可选字段,在 Kubernetes 1.6 版本以后支持,大小写不敏感。
建议设置为 "X-Remote-Group"。用来指定一组头部字段名称列表,以供检查用户所属的组名称。
所找到的全部头部字段的取值都会被用作用户组名。--requestheader-extra-headers-prefix
可选字段,在 Kubernetes 1.6 版本以后支持,大小写不敏感。
建议设置为 "X-Remote-Extra-"。用来设置一个头部字段的前缀字符串,
API 服务器会基于所给前缀来查找与用户有关的一些额外信息。这些额外信息通常用于所配置的鉴权插件。
API 服务器会将与所给前缀匹配的头部字段过滤出来,去掉其前缀部分,将剩余部分转换为小写字符串,
并在必要时执行百分号解码 后,
构造新的附加信息字段键名。原来的头部字段值直接作为附加信息字段的值。例如,使用下面的配置:
--requestheader-username-headers=X-Remote-User
--requestheader-group-headers=X-Remote-Group
--requestheader-extra-headers-prefix=X-Remote-Extra-
针对所收到的如下请求:
GET / HTTP / 1.1
X-Remote-User: fido
X-Remote-Group: dogs
X-Remote-Group: dachshunds
X-Remote-Extra-Acme.com%2Fproject: some-project
X-Remote-Extra-Scopes: openid
X-Remote-Extra-Scopes: profile
会生成下面的用户信息:
name : fido
groups :
- dogs
- dachshunds
extra :
acme.com/project :
- some-project
scopes :
- openid
- profile
为了防范头部信息侦听,在请求中的头部字段被检视之前,
身份认证代理需要向 API 服务器提供一份合法的客户端证书,供后者使用所给的 CA 来执行验证。
警告:不要 在不同的上下文中复用 CA 证书,除非你清楚这样做的风险是什么以及应如何保护
CA 用法的机制。
--requestheader-client-ca-file
必需字段,给出 PEM 编码的证书包。
在检查请求的头部字段以提取用户名信息之前,必须提供一个合法的客户端证书,
且该证书要能够被所给文件中的机构所验证。--requestheader-allowed-names
可选字段,用来给出一组公共名称(CN)。
如果此标志被设置,则在检视请求中的头部以提取用户信息之前,
必须提供包含此列表中所给的 CN 名的、合法的客户端证书。匿名请求 启用匿名请求支持之后,如果请求没有被已配置的其他身份认证方法拒绝,
则被视作匿名请求(Anonymous Requests)。这类请求获得用户名 system:anonymous
和对应的用户组 system:unauthenticated
。
例如,在一个配置了令牌身份认证且启用了匿名访问的服务器上,如果请求提供了非法的持有者令牌,
则会返回 401 Unauthorized
错误。如果请求没有提供持有者令牌,则被视为匿名请求。
在 1.5.1-1.5.x 版本中,匿名访问默认情况下是被禁用的,可以通过为 API 服务器设定
--anonymous-auth=true
来启用。
在 1.6 及之后版本中,如果所使用的鉴权模式不是 AlwaysAllow
,则匿名访问默认是被启用的。
从 1.6 版本开始,ABAC 和 RBAC 鉴权模块要求对 system:anonymous
用户或者
system:unauthenticated
用户组执行显式的权限判定,所以之前的为用户 *
或用户组
*
赋予访问权限的策略规则都不再包含匿名用户。
用户伪装 一个用户可以通过伪装(Impersonation)头部字段来以另一个用户的身份执行操作。
使用这一能力,你可以手动重载请求被身份认证所识别出来的用户信息。
例如,管理员可以使用这一功能特性来临时伪装成另一个用户,查看请求是否被拒绝,
从而调试鉴权策略中的问题,
带伪装的请求首先会被身份认证识别为发出请求的用户,
之后会切换到使用被伪装的用户的用户信息。
用户发起 API 调用时 同时 提供自身的凭据和伪装头部字段信息 API 服务器对用户执行身份认证 API 服务器确认通过认证的用户具有伪装特权 请求用户的信息被替换成伪装字段的值 评估请求,鉴权组件针对所伪装的用户信息执行操作 以下 HTTP 头部字段可用来执行伪装请求:
Impersonate-User
:要伪装成的用户名Impersonate-Group
:要伪装成的用户组名。可以多次指定以设置多个用户组。
可选字段;要求 "Impersonate-User" 必须被设置。Impersonate-Extra-<附加名称>
:一个动态的头部字段,用来设置与用户相关的附加字段。
此字段可选;要求 "Impersonate-User" 被设置。为了能够以一致的形式保留,
<附加名称>
部分必须是小写字符,
如果有任何字符不是合法的 HTTP 头部标签字符 ,
则必须是 utf8 字符,且转换为百分号编码 。Impersonate-Uid
:一个唯一标识符,用来表示所伪装的用户。此头部可选。
如果设置,则要求 "Impersonate-User" 也存在。Kubernetes 对此字符串没有格式要求。说明: 在 1.11.3 版本之前(以及 1.10.7、1.9.11),<附加名称>
只能包含合法的 HTTP 标签字符。
说明: Impersonate-Uid
仅在 1.22.0 及更高版本中可用。
伪装带有用户组的用户时,所使用的伪装头部字段示例:
Impersonate-User: jane.doe@example.com
Impersonate-Group: developers
Impersonate-Group: admins
伪装带有 UID 和附加字段的用户时,所使用的伪装头部字段示例:
Impersonate-User: jane.doe@example.com
Impersonate-Extra-dn: cn=jane,ou=engineers,dc=example,dc=com
Impersonate-Extra-acme.com%2Fproject: some-project
Impersonate-Extra-scopes: view
Impersonate-Extra-scopes: development
Impersonate-Uid: 06f6ce97-e2c5-4ab8-7ba5-7654dd08d52b
在使用 kubectl
时,可以使用 --as
标志来配置 Impersonate-User
头部字段值,
使用 --as-group
标志配置 Impersonate-Group
头部字段值。
Error from server (Forbidden): User "clark" cannot get nodes at the cluster scope. (get nodes mynode)
设置 --as
和 --as-group
标志:
kubectl drain mynode --as= superman --as-group= system:masters
node/mynode cordoned
node/mynode drained
说明: kubectl
不能对附加字段或 UID 执行伪装。
若要伪装成某个用户、某个组、用户标识符(UID))或者设置附加字段,
执行伪装操作的用户必须具有对所伪装的类别(“user”、“group”、“uid” 等)执行 “impersonate”
动词操作的能力。
对于启用了 RBAC 鉴权插件的集群,下面的 ClusterRole 封装了设置用户和组伪装字段所需的规则:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : impersonator
rules :
- apiGroups : ["" ]
resources : ["users" , "groups" , "serviceaccounts" ]
verbs : ["impersonate" ]
为了执行伪装,附加字段和所伪装的 UID 都位于 "authorization.k8s.io" apiGroup
中。
附加字段会被作为 userextras
资源的子资源来执行权限评估。
如果要允许用户为附加字段 “scopes” 和 UID 设置伪装头部,该用户需要被授予以下角色:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : scopes-and-uid-impersonator
rules :
# 可以设置 "Impersonate-Extra-scopes" 和 "Impersonate-Uid" 头部
- apiGroups : ["authentication.k8s.io" ]
resources : ["userextras/scopes" , "uids" ]
verbs : ["impersonate" ]
你也可以通过约束资源可能对应的 resourceNames
限制伪装头部的取值:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : limited-impersonator
rules :
# 可以伪装成用户 "jane.doe@example.com"
- apiGroups : ["" ]
resources : ["users" ]
verbs : ["impersonate" ]
resourceNames : ["jane.doe@example.com" ]
# 可以伪装成用户组 "developers" 和 "admins"
- apiGroups : ["" ]
resources : ["groups" ]
verbs : ["impersonate" ]
resourceNames : ["developers" ,"admins" ]
# 可以将附加字段 "scopes" 伪装成 "view" 和 "development"
- apiGroups : ["authentication.k8s.io" ]
resources : ["userextras/scopes" ]
verbs : ["impersonate" ]
resourceNames : ["view" , "development" ]
# 可以伪装 UID "06f6ce97-e2c5-4ab8-7ba5-7654dd08d52b"
- apiGroups : ["authentication.k8s.io" ]
resources : ["uids" ]
verbs : ["impersonate" ]
resourceNames : ["06f6ce97-e2c5-4ab8-7ba5-7654dd08d52b" ]
说明: 基于伪装成一个用户或用户组的能力,你可以执行任何操作,好像你就是那个用户或用户组一样。
出于这一原因,伪装操作是不受名字空间约束的。
如果你希望允许使用 Kubernetes RBAC 来执行身份伪装,就需要使用 ClusterRole
和 ClusterRoleBinding
,而不是 Role
或 RoleBinding
。
client-go 凭据插件 特性状态: Kubernetes v1.22 [stable]
k8s.io/client-go
及使用它的工具(如 kubectl
和 kubelet
)
可以执行某个外部命令来获得用户的凭据信息。
这一特性的目的是便于客户端与 k8s.io/client-go
并不支持的身份认证协议
(LDAP、Kerberos、OAuth2、SAML 等)继承。
插件实现特定于协议的逻辑,之后返回不透明的凭据以供使用。
几乎所有的凭据插件使用场景中都需要在服务器端存在一个支持
Webhook 令牌身份认证组件 的模块,
负责解析客户端插件所生成的凭据格式。
示例应用场景 在一个假想的应用场景中,某组织运行这一个外部的服务,能够将特定用户的已签名的令牌转换成
LDAP 凭据。此服务还能够对
Webhook 令牌身份认证组件 的请求做出响应以验证所提供的令牌。
用户需要在自己的工作站上安装一个凭据插件。
要对 API 服务器认证身份时:
用户发出 kubectl
命令。 凭据插件提示用户输入 LDAP 凭据,并与外部服务交互,获得令牌。 凭据插件将令牌返回该 client-go,后者将其用作持有者令牌提交给 API 服务器。 API 服务器使用 Webhook 令牌身份认证组件 向外部服务发出
TokenReview
请求。 外部服务检查令牌上的签名,返回用户的用户名和用户组信息。 配置 凭据插件通过 kubectl 配置文件
来作为 user 字段的一部分设置。
apiVersion : v1
kind : Config
users :
- name : my-user
user :
exec :
# 要执行的命令。必需。
command : "example-client-go-exec-plugin"
# 解析 ExecCredentials 资源时使用的 API 版本。必需。
# 插件返回的 API 版本必需与这里列出的版本匹配。
#
# 要与支持多个版本的工具(如 client.authentication.k8s.io/v1beta1)集成,
# 可以设置一个环境变量或者向工具传递一个参数标明 exec 插件所期望的版本,
# 或者从 KUBERNETES_EXEC_INFO 环境变量的 ExecCredential 对象中读取版本信息。
apiVersion : "client.authentication.k8s.io/v1"
# 执行此插件时要设置的环境变量。可选字段。
env :
- name : "FOO"
value : "bar"
# 执行插件时要传递的参数。可选字段。
args :
- "arg1"
- "arg2"
# 当可执行文件不存在时显示给用户的文本。可选的。
installHint : |
需要 example-client-go-exec-plugin 来在当前集群上执行身份认证。可以通过以下命令安装:
MacOS: brew install example-client-go-exec-plugin
Ubuntu: apt-get install example-client-go-exec-plugin
Fedora: dnf install example-client-go-exec-plugin
...
# 是否使用 KUBERNETES_EXEC_INFO 环境变量的一部分向这个 exec 插件
# 提供集群信息(可能包含非常大的 CA 数据)
provideClusterInfo : true
# Exec 插件与标准输入 I/O 数据流之间的协议。如果协议无法满足,
# 则插件无法运行并会返回错误信息。合法的值包括 "Never" (Exec 插件从不使用标准输入),
# "IfAvailable" (Exec 插件希望在可以的情况下使用标准输入),
# 或者 "Always" (Exec 插件需要使用标准输入才能工作)。必需字段。
interactiveMode : Never
clusters :
- name : my-cluster
cluster :
server : "https://172.17.4.100:6443"
certificate-authority : "/etc/kubernetes/ca.pem"
extensions :
- name : client.authentication.k8s.io/exec # 为每个集群 exec 配置保留的扩展名
extension :
arbitrary : config
this : 在设置 provideClusterInfo 时可通过环境变量 KUBERNETES_EXEC_INFO 指定
you : ["can" , "put" , "anything" , "here" ]
contexts :
- name : my-cluster
context :
cluster : my-cluster
user : my-user
current-context : my-cluster
apiVersion : v1
kind : Config
users :
- name : my-user
user :
exec :
# 要执行的命令。必需。
command : "example-client-go-exec-plugin"
# 解析 ExecCredentials 资源时使用的 API 版本。必需。
# 插件返回的 API 版本必需与这里列出的版本匹配。
#
# 要与支持多个版本的工具(如 client.authentication.k8s.io/v1)集成,
# 可以设置一个环境变量或者向工具传递一个参数标明 exec 插件所期望的版本,
# 或者从 KUBERNETES_EXEC_INFO 环境变量的 ExecCredential 对象中读取版本信息。
apiVersion : "client.authentication.k8s.io/v1beta1"
# 执行此插件时要设置的环境变量。可选字段。
env :
- name : "FOO"
value : "bar"
# 执行插件时要传递的参数。可选字段。
args :
- "arg1"
- "arg2"
# 当可执行文件不存在时显示给用户的文本。可选的。
installHint : |
需要 example-client-go-exec-plugin 来在当前集群上执行身份认证。可以通过以下命令安装:
MacOS: brew install example-client-go-exec-plugin
Ubuntu: apt-get install example-client-go-exec-plugin
Fedora: dnf install example-client-go-exec-plugin
...
# 是否使用 KUBERNETES_EXEC_INFO 环境变量的一部分向这个 exec 插件
# 提供集群信息(可能包含非常大的 CA 数据)
provideClusterInfo : true
# Exec 插件与标准输入 I/O 数据流之间的协议。如果协议无法满足,
# 则插件无法运行并会返回错误信息。合法的值包括 "Never" (Exec 插件从不使用标准输入),
# "IfAvailable" (Exec 插件希望在可以的情况下使用标准输入),
# 或者 "Always" (Exec 插件需要使用标准输入才能工作)。可选字段。
# 默认值为 "IfAvailable"。
interactiveMode : Never
clusters :
- name : my-cluster
cluster :
server : "https://172.17.4.100:6443"
certificate-authority : "/etc/kubernetes/ca.pem"
extensions :
- name : client.authentication.k8s.io/exec # 为每个集群 exec 配置保留的扩展名
extension :
arbitrary : config
this : 在设置 provideClusterInfo 时可通过环境变量 KUBERNETES_EXEC_INFO 指定
you : ["can" , "put" , "anything" , "here" ]
contexts :
- name : my-cluster
context :
cluster : my-cluster
user : my-user
current-context : my-cluster
解析相对命令路径时,kubectl 将其视为与配置文件比较而言的相对路径。
如果 KUBECONFIG 被设置为 /home/jane/kubeconfig
,而 exec 命令为
./bin/example-client-go-exec-plugin
,则要执行的可执行文件为
/home/jane/bin/example-client-go-exec-plugin
。
- name : my-user
user :
exec :
# 对 kubeconfig 目录而言的相对路径
command : "./bin/example-client-go-exec-plugin"
apiVersion : "client.authentication.k8s.io/v1"
interactiveMode : Never
所执行的命令会在 stdout
打印 ExecCredential
对象。
k8s.io/client-go
使用 status
中返回的凭据信息向 Kubernetes API 服务器执行身份认证。
所执行的命令会通过环境变量 KUBERNETES_EXEC_INFO
收到一个 ExecCredential
对象作为其输入。
此输入中包含类似于所返回的 ExecCredential
对象的预期 API 版本,
以及是否插件可以使用 stdin
与用户交互这类信息。
在交互式会话(即,某终端)中运行时,stdin
是直接暴露给插件使用的。
插件应该使用来自 KUBERNETES_EXEC_INFO
环境变量的 ExecCredential
输入对象中的 spec.interactive
字段来确定是否提供了 stdin
。
插件的 stdin
需求(即,为了能够让插件成功运行,是否 stdin
是可选的、
必须提供的或者从不会被使用的)是通过
kubeconfig
中的 user.exec.interactiveMode
来声明的(参见下面的表格了解合法值)。
字段 user.exec.interactiveMode
在 client.authentication.k8s.io/v1beta1
中是可选的,在 client.authentication.k8s.io/v1
中是必需的。
interactiveMode 取值 interactiveMode
取值含义 Never
此 exec 插件从不需要使用标准输入,因此如论是否有标准输入提供给用户输入,该 exec 插件都能运行。 IfAvailable
此 exec 插件希望在标准输入可用的情况下使用标准输入,但在标准输入不存在时也可运行。因此,无论是否存在给用户提供输入的标准输入,此 exec 插件都会运行。如果存在供用户输入的标准输入,则该标准输入会被提供给 exec 插件。 Always
此 exec 插件需要标准输入才能正常运行,因此只有存在供用户输入的标准输入时,此 exec 插件才会运行。如果不存在供用户输入的标准输入,则 exec 插件无法运行,并且 exec 插件的执行者会因此返回错误信息。
与使用持有者令牌凭据,插件在 ExecCredential
的状态中返回一个令牌:
{
"apiVersion" : "client.authentication.k8s.io/v1" ,
"kind" : "ExecCredential" ,
"status" : {
"token" : "my-bearer-token"
}
}
{
"apiVersion" : "client.authentication.k8s.io/v1beta1" ,
"kind" : "ExecCredential" ,
"status" : {
"token" : "my-bearer-token"
}
}
另一种方案是,返回 PEM 编码的客户端证书和密钥,以便执行 TLS 客户端身份认证。
如果插件在后续调用中返回了不同的证书或密钥,k8s.io/client-go
会终止其与服务器的连接,从而强制执行新的 TLS 握手过程。
如果指定了这种方式,则 clientKeyData
和 clientCertificateData
字段都必需存在。
clientCertificateData
字段可能包含一些要发送给服务器的中间证书(Intermediate
Certificates)。
{
"apiVersion" : "client.authentication.k8s.io/v1" ,
"kind" : "ExecCredential" ,
"status" : {
"clientCertificateData" : "-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----" ,
"clientKeyData" : "-----BEGIN RSA PRIVATE KEY-----\n...\n-----END RSA PRIVATE KEY-----"
}
}
{
"apiVersion" : "client.authentication.k8s.io/v1beta1" ,
"kind" : "ExecCredential" ,
"status" : {
"clientCertificateData" : "-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----" ,
"clientKeyData" : "-----BEGIN RSA PRIVATE KEY-----\n...\n-----END RSA PRIVATE KEY-----"
}
}
作为一种可选方案,响应中还可以包含以 RFC 3339
时间戳格式给出的证书到期时间。
证书到期时间的有无会有如下影响:
如果响应中包含了到期时间,持有者令牌和 TLS 凭据会被缓存,直到期限到来、
或者服务器返回 401 HTTP 状态码,或者进程退出。 如果未指定到期时间,则持有者令牌和 TLS 凭据会被缓存,直到服务器返回 401
HTTP 状态码或者进程退出。
{
"apiVersion" : "client.authentication.k8s.io/v1" ,
"kind" : "ExecCredential" ,
"status" : {
"token" : "my-bearer-token" ,
"expirationTimestamp" : "2018-03-05T17:30:20-08:00"
}
}
{
"apiVersion" : "client.authentication.k8s.io/v1beta1" ,
"kind" : "ExecCredential" ,
"status" : {
"token" : "my-bearer-token" ,
"expirationTimestamp" : "2018-03-05T17:30:20-08:00"
}
}
为了让 exec 插件能够获得特定与集群的信息,可以在
kubeconfig
中的 user.exec
设置 provideClusterInfo
。
这一特定于集群的信息就会通过 KUBERNETES_EXEC_INFO
环境变量传递给插件。
此环境变量中的信息可以用来执行特定于集群的凭据获取逻辑。
下面的 ExecCredential
清单描述的是一个示例集群信息。
{
"apiVersion" : "client.authentication.k8s.io/v1" ,
"kind" : "ExecCredential" ,
"spec" : {
"cluster" : {
"server" : "https://172.17.4.100:6443" ,
"certificate-authority-data" : "LS0t..." ,
"config" : {
"arbitrary" : "config" ,
"this" : "可以在设置 provideClusterInfo 时通过 KUBERNETES_EXEC_INFO 环境变量提供" ,
"you" : ["can" , "put" , "anything" , "here" ]
}
},
"interactive" : true
}
}
{
"apiVersion" : "client.authentication.k8s.io/v1beta1" ,
"kind" : "ExecCredential" ,
"spec" : {
"cluster" : {
"server" : "https://172.17.4.100:6443" ,
"certificate-authority-data" : "LS0t..." ,
"config" : {
"arbitrary" : "config" ,
"this" : "可以在设置 provideClusterInfo 时通过 KUBERNETES_EXEC_INFO 环境变量提供" ,
"you" : ["can" , "put" , "anything" , "here" ]
}
},
"interactive" : true
}
}
为客户端提供的对身份验证信息的 API 访问 特性状态: Kubernetes v1.27 [beta]
如果集群启用了此 API,你可以使用 SelfSubjectReview
API 来了解 Kubernetes
集群如何映射你的身份验证信息从而将你识别为某客户端。无论你是作为用户(通常代表一个真的人)还是作为
ServiceAccount 进行身份验证,这一 API 都可以使用。
SelfSubjectReview
对象没有任何可配置的字段。
Kubernetes API 服务器收到请求后,将使用用户属性填充 status 字段并将其返回给用户。
请求示例(主体将是 SelfSubjectReview
):
POST /apis/authentication.k8s.io/v1beta1/selfsubjectreviews
{
"apiVersion" : "authentication.k8s.io/v1beta1" ,
"kind" : "SelfSubjectReview"
}
响应示例:
{
"apiVersion" : "authentication.k8s.io/v1beta1" ,
"kind" : "SelfSubjectReview" ,
"status" : {
"userInfo" : {
"name" : "jane.doe" ,
"uid" : "b6c7cfd4-f166-11ec-8ea0-0242ac120002" ,
"groups" : [
"viewers" ,
"editors" ,
"system:authenticated"
],
"extra" : {
"provider_id" : ["token.company.example" ]
}
}
}
}
为了方便,Kubernetes 提供了 kubectl auth whoami
命令。
执行此命令将产生以下输出(但将显示不同的用户属性):
通过提供 output 标志,也可以打印结果的 JSON 或 YAML 表现形式:
{
"apiVersion" : "authentication.k8s.io/v1alpha1" ,
"kind" : "SelfSubjectReview" ,
"status" : {
"userInfo" : {
"username" : "jane.doe" ,
"uid" : "b79dbf30-0c6a-11ed-861d-0242ac120002" ,
"groups" : [
"students" ,
"teachers" ,
"system:authenticated"
],
"extra" : {
"skills" : [
"reading" ,
"learning"
],
"subjects" : [
"math" ,
"sports"
]
}
}
}
}
apiVersion : authentication.k8s.io/v1alpha1
kind : SelfSubjectReview
status :
userInfo :
username : jane.doe
uid : b79dbf30-0c6a-11ed-861d-0242ac120002
groups :
- students
- teachers
- system:authenticated
extra :
skills :
- reading
- learning
subjects :
- math
- sports
在 Kubernetes 集群中使用复杂的身份验证流程时,例如如果你使用
Webhook 令牌身份验证 或身份验证代理 时,
此特性极其有用。
说明: Kubernetes API 服务器在所有身份验证机制
(包括伪装 ),
被应用后填充 userInfo
,
如果你或某个身份验证代理使用伪装进行 SelfSubjectReview,你会看到被伪装用户的用户详情和属性。
默认情况下,所有经过身份验证的用户都可以在 APISelfSubjectReview
特性被启用时创建 SelfSubjectReview
对象。
这是 system:basic-user
集群角色允许的操作。
说明: 你只能在以下情况下进行 SelfSubjectReview
请求:
集群启用了 APISelfSubjectReview
(Beta 版本默认启用)
特性门控 集群的 API 服务器已启用 authentication.k8s.io/v1alpha1
或者 authentication.k8s.io/v1beta1
API 组 。。 接下来 3.2 - 使用启动引导令牌(Bootstrap Tokens)认证 特性状态: Kubernetes v1.18 [stable]
启动引导令牌是一种简单的持有者令牌(Bearer Token),这种令牌是在新建集群
或者在现有集群中添加新节点时使用的。
它被设计成能够支持 kubeadm
,
但是也可以被用在其他的案例中以便用户在不使用 kubeadm
的情况下启动集群。
它也被设计成可以通过 RBAC 策略,结合
Kubelet TLS 启动引导
系统进行工作。
启动引导令牌被定义成一个特定类型的 Secret(bootstrap.kubernetes.io/token
),
并存在于 kube-system
名字空间中。
这些 Secret 会被 API 服务器上的启动引导认证组件(Bootstrap Authenticator)读取。
控制器管理器中的控制器 TokenCleaner 能够删除过期的令牌。
这些令牌也被用来在节点发现的过程中会使用的一个特殊的 ConfigMap 对象。
BootstrapSigner 控制器也会使用这一 ConfigMap。
令牌格式 启动引导令牌使用 abcdef.0123456789abcdef
的形式。
更加规范地说,它们必须符合正则表达式 [a-z0-9]{6}\.[a-z0-9]{16}
。
令牌的第一部分是 “Token ID”,它是一种公开信息,用于引用令牌并确保不会
泄露认证所使用的秘密信息。
第二部分是“令牌秘密(Token Secret)”,它应该被共享给受信的第三方。
启用启动引导令牌 启用启动引导令牌身份认证 启动引导令牌认证组件可以通过 API 服务器上的如下标志启用:
--enable-bootstrap-token-auth
启动引导令牌被启用后,可以作为持有者令牌的凭据,用于 API 服务器请求的身份认证。
Authorization: Bearer 07401b.f395accd246ae52d
令牌认证为用户名 system:bootstrap:<token id>
并且是组 system:bootstrappers
的成员。额外的组信息可以通过令牌的 Secret 来设置。
过期的令牌可以通过启用控制器管理器中的 tokencleaner
控制器来删除。
--controllers=*,tokencleaner
每个合法的令牌背后对应着 kube-system
名字空间中的某个 Secret 对象。
你可以从
这里
找到完整设计文档。
这是 Secret 看起来的样子。
apiVersion : v1
kind : Secret
metadata :
# name 必须是 "bootstrap-token-<token id>" 格式的
name : bootstrap-token-07401b
namespace : kube-system
# type 必须是 'bootstrap.kubernetes.io/token'
type : bootstrap.kubernetes.io/token
stringData :
# 供人阅读的描述,可选。
description : "The default bootstrap token generated by 'kubeadm init'."
# 令牌 ID 和秘密信息,必需。
token-id : 07401b
token-secret : f395accd246ae52d
# 可选的过期时间字段
expiration : 2017-03-10T03:22:11Z
# 允许的用法
usage-bootstrap-authentication : "true"
usage-bootstrap-signing : "true"
# 令牌要认证为的额外组,必须以 "system:bootstrappers:" 开头
auth-extra-groups : system:bootstrappers:worker,system:bootstrappers:ingress
Secret 的类型必须是 bootstrap.kubernetes.io/token
,而且名字必须是 bootstrap-token-<token id>
。
令牌必须存在于 kube-system
名字空间中。
usage-bootstrap-*
成员表明这个 Secret 的用途。启用时,值必须设置为 true
。
usage-bootstrap-authentication
表示令牌可以作为持有者令牌用于 API 服务器的身份认证。usage-bootstrap-signing
表示令牌可被用于 cluster-info
ConfigMap 的签名,
就像下面描述的那样。expiration
字段控制令牌的失效期。过期的令牌在用于身份认证时会被拒绝,在用于
ConfigMap 签名时会被忽略。
过期时间值是遵循 RFC3339 进行编码的 UTC 时间。
启用 TokenCleaner 控制器会自动删除过期的令牌。
使用 kubeadm
管理令牌 你可以使用 kubeadm
工具管理运行中集群上的令牌。
参见 kubeadm token 文档
以了解详细信息。
ConfigMap 签名 除了身份认证,令牌还可以用于签名 ConfigMap。
这一用法发生在集群启动过程的早期,在客户端信任 API 服务器之前。
被签名的 ConfigMap 可以被共享令牌完成身份认证。
通过在控制器管理器上启用 bootstrapsigner
控制器可以启用 ConfigMap 签名特性。
--controllers=*,bootstrapsigner
被签名的 ConfigMap 是 kube-public
名字空间中的 cluster-info
。
典型的工作流中,客户端在未经认证和忽略 TLS 报错的状态下读取这个 ConfigMap。
通过检查 ConfigMap 中嵌入的签名校验 ConfigMap 的载荷。
ConfigMap 会是这个样子的:
apiVersion : v1
kind : ConfigMap
metadata :
name : cluster-info
namespace : kube-public
data :
jws-kubeconfig-07401b : eyJhbGciOiJIUzI1NiIsImtpZCI6IjA3NDAxYiJ9..tYEfbo6zDNo40MQE07aZcQX2m3EB2rO3NuXtxVMYm9U
kubeconfig : |
apiVersion: v1
clusters:
- cluster:
certificate-authority-data: <非常长的证书数据>
server: https://10.138.0.2:6443
name: ""
contexts: []
current-context: ""
kind: Config
preferences: {}
users: []
ConfigMap 的 kubeconfig
成员是一个填好了集群信息的配置文件。
这里主要交换的信息是 certificate-authority-data
。在将来可能会有扩展。
签名是一个使用 “detached” 模式生成的 JWS 签名。
为了检验签名,用户应该按照 JWS 规则(base64 编码且丢掉结尾的 =
)对
kubeconfig
的载荷进行编码。完成编码的载荷会被插入到两个句点中间,形成完整的
JWS。你可以使用完整的令牌(比如 07401b.f395accd246ae52d
)作为共享密钥,
通过 HS256
方式 (HMAC-SHA256) 对 JWS 进行校验。
用户必须 确保使用了 HS256。
警告: 任何拥有了启动引导令牌的主体都可以为该令牌生成一个合法的签名。
当使用 ConfigMap 签名时,非常不建议针对很多客户使用相同的令牌,因为某个被攻击的
客户可能对另一个一来签名来开启 TLS 信任的客户发起中间人攻击。
参考 kubeadm 实现细节
了解更多信息。
3.3 - 证书签名请求 特性状态: Kubernetes v1.19 [stable]
证书 API 支持
X.509
的自动化配置,
它为 Kubernetes API 的客户端提供一个编程接口,
用于从证书颁发机构(CA)请求并获取 X.509
证书 。
CertificateSigningRequest(CSR)资源用来向指定的签名者申请证书签名,
在最终签名之前,申请可能被批准,也可能被拒绝。
请求签名流程 CertificateSigningRequest 资源类型允许客户使用它申请发放 X.509 证书。
CertificateSigningRequest 对象 在 spec.request
中包含一个 PEM 编码的 PKCS#10 签名请求。
CertificateSigningRequest 使用 spec.signerName
字段标示签名者(请求的接收方)。
注意,spec.signerName
在 certificates.k8s.io/v1
之后的 API 版本是必填项。
在 Kubernetes v1.22 和以后的版本,客户可以可选地设置 spec.expirationSeconds
字段来为颁发的证书设定一个特定的有效期。该字段的最小有效值是 600
,也就是 10 分钟。
创建完成的 CertificateSigningRequest,要先通过批准,然后才能签名。
根据所选的签名者,CertificateSigningRequest 可能会被
控制器 自动批准。
否则,就必须人工批准,
人工批准可以使用 REST API(或 go 客户端),也可以执行 kubectl certificate approve
命令。
同样,CertificateSigningRequest 也可能被驳回,
这就相当于通知了指定的签名者,这个证书不能签名。
对于已批准的证书,下一步是签名。
对应的签名控制器首先验证签名条件是否满足,然后才创建证书。
签名控制器然后更新 CertificateSigningRequest,
将新证书保存到现有 CertificateSigningRequest 对象的 status.certificate
字段中。
此时,字段 status.certificate
要么为空,要么包含一个用 PEM 编码的 X.509 证书。
直到签名完成前,CertificateSigningRequest 的字段 status.certificate
都为空。
一旦 status.certificate
字段完成填充,请求既算完成,
客户端现在可以从 CertificateSigningRequest 资源中获取已签名的证书的 PEM 数据。
当然如果不满足签名条件,签名者可以拒签。
为了减少集群中遗留的过时的 CertificateSigningRequest 资源的数量,
一个垃圾收集控制器将会周期性地运行。
此垃圾收集器会清除在一段时间内没有改变过状态的 CertificateSigningRequests:
已批准的请求:1 小时后自动删除 已拒绝的请求:1 小时后自动删除 已失败的请求:1 小时后自动删除 挂起的请求:24 小时后自动删除 所有请求:在颁发的证书过期后自动删除 签名者 也可以指定自定义 signerName。
所有签名者都应该提供自己工作方式的信息,
以便客户端可以预期到他们的 CSR 将发生什么。
此类信息包括:
信任分发 :信任(CA 证书包)是如何分发的。许可的主体 :当一个受限制的主体(subject)发送请求时,相应的限制和应对手段。许可的 x509 扩展 :包括 IP subjectAltNames、DNS subjectAltNames、
Email subjectAltNames、URI subjectAltNames 等,请求一个受限制的扩展项时的应对手段。许可的密钥用途/扩展的密钥用途 :当用途和签名者在 CSR 中指定的用途不同时,
相应的限制和应对手段。过期时间/证书有效期 :过期时间由签名者确定、由管理员配置、还是由 CSR spec.expirationSeconds
字段指定等,
以及签名者决定的过期时间与 CSR spec.expirationSeconds
字段不同时的应对手段。允许/不允许 CA 位 :当 CSR 包含一个签名者并不允许的 CA 证书的请求时,相应的应对手段。一般来说,当 CSR 被批准通过,且证书被签名后,status.certificate
字段
将包含一个 PEM 编码的 X.509 证书。
有些签名者在 status.certificate
字段中存储多个证书。
在这种情况下,签名者的说明文档应当指明附加证书的含义。
例如,这是要在 TLS 握手时提供的证书和中继证书。
PKCS#10 签名请求格式并没有一种标准的方法去设置证书的过期时间或者生命期。
因此,证书的过期时间或者生命期必须通过 CSR 对象的 spec.expirationSeconds
字段来设置。
当 spec.expirationSeconds
没有被指定时,内置的签名者默认使用 ClusterSigningDuration
配置选项
(kube-controller-manager 的命令行选项 --cluster-signing-duration
),该选项的默认值设为 1 年。
当 spec.expirationSeconds
被指定时,spec.expirationSeconds
和 ClusterSigningDuration
中的最小值会被使用。
说明: spec.expirationSeconds
字段是在 Kubernetes v1.22 中加入的。早期的 Kubernetes 版本并不认识该字段。
v1.22 版本之前的 Kubernetes API 服务器会在创建对象的时候忽略该字段。
Kubernetes 签名者 Kubernetes 提供了内置的签名者,每个签名者都有一个众所周知的 signerName
:
kubernetes.io/kube-apiserver-client
:签名的证书将被 API 服务器视为客户证书。
kube-controller-manager 不会自动批准它。信任分发:签名的证书将被 API 服务器视为客户端证书。CA 证书包不通过任何其他方式分发。 许可的主体:没有主体限制,但审核人和签名者可以选择不批准或不签署。
某些主体,比如集群管理员级别的用户或组因部署和安装方式不同而不同,
所以批准和签署之前需要进行额外仔细审查。
用来限制 system:masters
的 CertificateSubjectRestriction 准入插件默认处于启用状态,
但它通常不是集群中唯一的集群管理员主体。 许可的 x509 扩展:允许 subjectAltName 和 key usage 扩展,弃用其他扩展。 许可的密钥用途:必须包含 ["client auth"]
,但不能包含
["digital signature", "key encipherment", "client auth"]
之外的键。 过期时间/证书有效期:对于 kube-controller-manager 实现的签名者,
设置为 --cluster-signing-duration
选项和 CSR 对象的 spec.expirationSeconds
字段(如有设置该字段)中的最小值。 允许/不允许 CA 位:不允许。 kubernetes.io/kube-apiserver-client-kubelet
: 签名的证书将被 kube-apiserver 视为客户证书。
kube-controller-manager 可以自动批准它。
信任分发:签名的证书将被 API 服务器视为客户端证书。CA 证书包不通过任何其他方式分发。 许可的主体:组织名必须是 ["system:nodes"]
,用户名以 "system:node:
" 开头 许可的 x509 扩展:允许 key usage 扩展,禁用 subjectAltName 扩展,并删除其他扩展。 许可的密钥用途:必须是 ["key encipherment", "digital signature", "client auth"]
过期时间/证书有效期:对于 kube-controller-manager 实现的签名者,
设置为 --cluster-signing-duration
选项和 CSR 对象的 spec.expirationSeconds
字段(如有设置该字段)中的最小值。 允许/不允许 CA 位:不允许。 kubernetes.io/kubelet-serving
: 签名服务证书,该服务证书被 API 服务器视为有效的 kubelet 服务证书,
但没有其他保证。kube-controller-manager 不会自动批准它。信任分发:签名的证书必须被 kube-apiserver 认可,可有效的中止 kubelet 连接。CA 证书包不通过任何其他方式分发。 许可的主体:组织名必须是 ["system:nodes"]
,用户名以 "system:node:
" 开头 许可的 x509 扩展:允许 key usage、DNSName/IPAddress subjectAltName 等扩展,
禁止 EmailAddress、URI subjectAltName 等扩展,并丢弃其他扩展。
至少有一个 DNS 或 IP 的 SubjectAltName 存在。 许可的密钥用途:必须是 ["key encipherment", "digital signature", "server auth"]
过期时间/证书有效期:对于 kube-controller-manager 实现的签名者,
设置为 --cluster-signing-duration
选项和 CSR 对象的 spec.expirationSeconds
字段(如有设置该字段)中的最小值。 允许/不允许 CA 位:不允许。 kubernetes.io/legacy-unknown
: 不保证信任。Kubernetes 的一些第三方发行版可能会使用它签署的客户端证书。
稳定版的 CertificateSigningRequest API(certificates.k8s.io/v1
以及之后的版本)不允许将
signerName
设置为 kubernetes.io/legacy-unknown
。
kube-controller-manager 不会自动批准这类请求。信任分发:没有。这个签名者在 Kubernetes 集群中没有标准的信任或分发。 许可的主体:全部。 许可的 x509 扩展:允许 subjectAltName 和 key usage 等扩展,并弃用其他扩展。 许可的密钥用途:全部。 过期时间/证书有效期:对于 kube-controller-manager 实现的签名者,
设置为 --cluster-signing-duration
选项和 CSR 对象的 spec.expirationSeconds
字段(如有设置该字段)中的最小值。 允许/不允许 CA 位 - 不允许。 说明: 注意:所有这些故障仅在 kube-controller-manager 日志中报告。
说明: spec.expirationSeconds
字段是在 Kubernetes v1.22 中加入的。早期的 Kubernetes 版本并不认识该字段。
v1.22 版本之前的 Kubernetes API 服务器会在创建对象的时候忽略该字段。
对于这些签名者,信任的分发发生在带外(out of band)。上述信任之外的任何信任都是完全巧合的。
例如,一些发行版可能会将 kubernetes.io/legacy-unknown
作为 kube-apiserver 的客户端证书,
但这个做法并不标准。
这些用途都没有以任何方式涉及到 ServiceAccount 中的 Secrets .data[ca.crt]
。
此 CA 证书包只保证使用默认的服务(kubernetes.default.svc
)来验证到 API 服务器的连接。
鉴权 授权创建 CertificateSigningRequest 和检索 CertificateSigningRequest:
verbs(动词): create
、get
、list
、watch
,
group(组):certificates.k8s.io
,
resources:certificatesigningrequests
例如:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : csr-creator
rules :
- apiGroups :
- certificates.k8s.io
resources :
- certificatesigningrequests
verbs :
- create
- get
- list
- watch
授权批准 CertificateSigningRequest:
verbs(动词): get
、list
、watch
,
group(组):certificates.k8s.io
,
resources(资源):certificatesigningrequests
verbs(动词): update
,
group(组):certificates.k8s.io
,
resources(资源):certificatesigningrequests/approval
verbs(动词):approve
,
group(组):certificates.k8s.io
,
resources(资源):signers
,
resourceName:<signerNameDomain>/<signerNamePath>
或 <signerNameDomain>/*
例如:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : csr-approver
rules :
- apiGroups :
- certificates.k8s.io
resources :
- certificatesigningrequests
verbs :
- get
- list
- watch
- apiGroups :
- certificates.k8s.io
resources :
- certificatesigningrequests/approval
verbs :
- update
- apiGroups :
- certificates.k8s.io
resources :
- signers
resourceNames :
- example.com/my-signer-name # example.com/* 可用于为 “example.com” 域中的所有签名者授权
verbs :
- approve
授权签名 CertificateSigningRequest:
verbs(动词):get
、list
、watch
,
group(组):certificates.k8s.io
,
resources(资源):certificatesigningrequests
verbs(动词):update
,
group(组):certificates.k8s.io
,
resources(资源):certificatesigningrequests/status
verbs(动词):sign
,
group(组):certificates.k8s.io
,
resources(资源):signers
,
resourceName:<signerNameDomain>/<signerNamePath>
或 <signerNameDomain>/*
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : csr-signer
rules :
- apiGroups :
- certificates.k8s.io
resources :
- certificatesigningrequests
verbs :
- get
- list
- watch
- apiGroups :
- certificates.k8s.io
resources :
- certificatesigningrequests/status
verbs :
- update
- apiGroups :
- certificates.k8s.io
resources :
- signers
resourceNames :
- example.com/my-signer-name # example.com/* 可用于为 “example.com” 域中的所有签名者授权
verbs :
- sign
普通用户 为了让普通用户能够通过认证并调用 API,需要执行几个步骤。
首先,该用户必须拥有 Kubernetes 集群签发的证书,
然后将该证书提供给 Kubernetes API。
创建私钥 下面的脚本展示了如何生成 PKI 私钥和 CSR。
设置 CSR 的 CN 和 O 属性很重要。CN 是用户名,O 是该用户归属的组。
你可以参考 RBAC 了解标准组的信息。
openssl genrsa -out myuser.key 2048
openssl req -new -key myuser.key -out myuser.csr
创建 CertificateSigningRequest 创建一个 CertificateSigningRequest,并通过 kubectl 将其提交到 Kubernetes 集群。
下面是生成 CertificateSigningRequest 的脚本。
cat <<EOF | kubectl apply -f -
apiVersion: certificates.k8s.io/v1
kind: CertificateSigningRequest
metadata:
name: myuser
spec:
request: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0KTUlJQ1ZqQ0NBVDRDQVFBd0VURVBNQTBHQTFVRUF3d0dZVzVuWld4aE1JSUJJakFOQmdrcWhraUc5dzBCQVFFRgpBQU9DQVE4QU1JSUJDZ0tDQVFFQTByczhJTHRHdTYxakx2dHhWTTJSVlRWMDNHWlJTWWw0dWluVWo4RElaWjBOCnR2MUZtRVFSd3VoaUZsOFEzcWl0Qm0wMUFSMkNJVXBGd2ZzSjZ4MXF3ckJzVkhZbGlBNVhwRVpZM3ExcGswSDQKM3Z3aGJlK1o2MVNrVHF5SVBYUUwrTWM5T1Nsbm0xb0R2N0NtSkZNMUlMRVI3QTVGZnZKOEdFRjJ6dHBoaUlFMwpub1dtdHNZb3JuT2wzc2lHQ2ZGZzR4Zmd4eW8ybmlneFNVekl1bXNnVm9PM2ttT0x1RVF6cXpkakJ3TFJXbWlECklmMXBMWnoyalVnald4UkhCM1gyWnVVV1d1T09PZnpXM01LaE8ybHEvZi9DdS8wYk83c0x0MCt3U2ZMSU91TFcKcW90blZtRmxMMytqTy82WDNDKzBERHk5aUtwbXJjVDBnWGZLemE1dHJRSURBUUFCb0FBd0RRWUpLb1pJaHZjTgpBUUVMQlFBRGdnRUJBR05WdmVIOGR4ZzNvK21VeVRkbmFjVmQ1N24zSkExdnZEU1JWREkyQTZ1eXN3ZFp1L1BVCkkwZXpZWFV0RVNnSk1IRmQycVVNMjNuNVJsSXJ3R0xuUXFISUh5VStWWHhsdnZsRnpNOVpEWllSTmU3QlJvYXgKQVlEdUI5STZXT3FYbkFvczFqRmxNUG5NbFpqdU5kSGxpT1BjTU1oNndLaTZzZFhpVStHYTJ2RUVLY01jSVUyRgpvU2djUWdMYTk0aEpacGk3ZnNMdm1OQUxoT045UHdNMGM1dVJVejV4T0dGMUtCbWRSeEgvbUNOS2JKYjFRQm1HCkkwYitEUEdaTktXTU0xMzhIQXdoV0tkNjVoVHdYOWl4V3ZHMkh4TG1WQzg0L1BHT0tWQW9FNkpsYWFHdTlQVmkKdjlOSjVaZlZrcXdCd0hKbzZXdk9xVlA3SVFjZmg3d0drWm89Ci0tLS0tRU5EIENFUlRJRklDQVRFIFJFUVVFU1QtLS0tLQo=
signerName: kubernetes.io/kube-apiserver-client
expirationSeconds: 86400 # one day
usages:
- client auth
EOF
需要注意的几点:
usage
字段必须是 'client auth
'
expirationSeconds
可以设置为更长(例如 864000
是十天)或者更短(例如 3600
是一个小时)
request
字段是 CSR 文件内容的 base64 编码值。
要得到该值,可以执行命令
cat myuser.csr | base64 | tr -d "\n"
批准证书签名请求 使用 kubectl 创建 CSR 并批准。
获取 CSR 列表:
批准 CSR:
kubectl certificate approve myuser
取得证书 从 CSR 取得证书:
kubectl get csr/myuser -o yaml
证书的内容使用 base64 编码,存放在字段 status.certificate
。
从 CertificateSigningRequest 导出颁发的证书。
kubectl get csr myuser -o jsonpath = '{.status.certificate}' | base64 -d > myuser.crt
创建角色和角色绑定 创建了证书之后,为了让这个用户能访问 Kubernetes 集群资源,现在就要创建
Role 和 RoleBinding 了。
下面是为这个新用户创建 Role 的示例命令:
kubectl create role developer --verb= create --verb= get --verb= list --verb= update --verb= delete --resource= pods
下面是为这个新用户创建 RoleBinding 的示例命令:
kubectl create rolebinding developer-binding-myuser --role= developer --user= myuser
添加到 kubeconfig 最后一步是将这个用户添加到 kubeconfig 文件。
首先,你需要添加新的凭据:
kubectl config set-credentials myuser --client-key= myuser.key --client-certificate= myuser.crt --embed-certs= true
然后,你需要添加上下文:
kubectl config set-context myuser --cluster= kubernetes --user= myuser
来测试一下,把上下文切换为 myuser
:
kubectl config use-context myuser
批准和驳回 控制平面的自动化批准 kube-controller-manager 内建了一个证书批准者,其 signerName 为
kubernetes.io/kube-apiserver-client-kubelet
,
该批准者将 CSR 上用于节点凭据的各种权限委托给权威认证机构。
kube-controller-manager 将 SubjectAccessReview 资源发送(POST)到 API 服务器,
以便检验批准证书的授权。
使用 kubectl
批准或驳回 Kubernetes 管理员(拥有足够的权限)可以手工批准(或驳回)CertificateSigningRequests,
此操作使用 kubectl certificate approve
和 kubectl certificate deny
命令实现。
使用 kubectl 批准一个 CSR:
kubectl certificate approve <certificate-signing-request-name>
同样地,驳回一个 CSR:
kubectl certificate deny <certificate-signing-request-name>
使用 Kubernetes API 批准或驳回 REST API 的用户可以通过向待批准的 CSR 的 approval
子资源提交更新请求来批准 CSR。
例如,你可以编写一个
operator
来监视特定类型的 CSR,然后发送一个更新来批准它。
当你发出批准或驳回的指令时,根据你期望的状态来选择设置 Approved
或 Denied
。
批准(Approved
) 的 CSR:
apiVersion : certificates.k8s.io/v1
kind : CertificateSigningRequest
...
status :
conditions :
- lastUpdateTime : "2020-02-08T11:37:35Z"
lastTransitionTime : "2020-02-08T11:37:35Z"
message : Approved by my custom approver controller
reason : ApprovedByMyPolicy # You can set this to any string
type : Approved
驳回(Denied
)的 CSR:
apiVersion : certificates.k8s.io/v1
kind : CertificateSigningRequest
...
status :
conditions :
- lastUpdateTime : "2020-02-08T11:37:35Z"
lastTransitionTime : "2020-02-08T11:37:35Z"
message : Denied by my custom approver controller
reason : DeniedByMyPolicy # You can set this to any string
type : Denied
status.conditions.reason
字段通常设置为一个首字母大写的对机器友好的原因码;
这是一个命名约定,但你也可以随你的个人喜好设置。
如果你想添加一个供人类使用的注释,那就用 status.conditions.message
字段。
签名 控制平面签名者 Kubernetes 控制平面实现了每一个
Kubernetes 签名者 ,
每个签名者的实现都是 kube-controller-manager 的一部分。
说明: 在 Kubernetes v1.18 之前,
kube-controller-manager 签名所有标记为 approved 的 CSR。
说明: spec.expirationSeconds
字段是在 Kubernetes v1.22 中加入的。早期的 Kubernetes 版本并不认识该字段。
v1.22 版本之前的 Kubernetes API 服务器会在创建对象的时候忽略该字段。
基于 API 的签名者 REST API 的用户可以通过向待签名的 CSR 的 status
子资源提交更新请求来对 CSR 进行签名。
作为这个请求的一部分,status.certificate
字段应设置为已签名的证书。
此字段可包含一个或多个 PEM 编码的证书。
所有的 PEM 块必须具备 "CERTIFICATE" 标签,且不包含文件头,且编码的数据必须是
RFC5280 第 4 节
中描述的 BER 编码的 ASN.1 证书结构。
-----BEGIN CERTIFICATE-----
MIIDgjCCAmqgAwIBAgIUC1N1EJ4Qnsd322BhDPRwmg3b/oAwDQYJKoZIhvcNAQEL
BQAwXDELMAkGA1UEBhMCeHgxCjAIBgNVBAgMAXgxCjAIBgNVBAcMAXgxCjAIBgNV
BAoMAXgxCjAIBgNVBAsMAXgxCzAJBgNVBAMMAmNhMRAwDgYJKoZIhvcNAQkBFgF4
MB4XDTIwMDcwNjIyMDcwMFoXDTI1MDcwNTIyMDcwMFowNzEVMBMGA1UEChMMc3lz
dGVtOm5vZGVzMR4wHAYDVQQDExVzeXN0ZW06bm9kZToxMjcuMC4wLjEwggEiMA0G
CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDne5X2eQ1JcLZkKvhzCR4Hxl9+ZmU3
+e1zfOywLdoQxrPi+o4hVsUH3q0y52BMa7u1yehHDRSaq9u62cmi5ekgXhXHzGmm
kmW5n0itRECv3SFsSm2DSghRKf0mm6iTYHWDHzUXKdm9lPPWoSOxoR5oqOsm3JEh
Q7Et13wrvTJqBMJo1GTwQuF+HYOku0NF/DLqbZIcpI08yQKyrBgYz2uO51/oNp8a
sTCsV4OUfyHhx2BBLUo4g4SptHFySTBwlpRWBnSjZPOhmN74JcpTLB4J5f4iEeA7
2QytZfADckG4wVkhH3C2EJUmRtFIBVirwDn39GXkSGlnvnMgF3uLZ6zNAgMBAAGj
YTBfMA4GA1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDAjAMBgNVHRMB
Af8EAjAAMB0GA1UdDgQWBBTREl2hW54lkQBDeVCcd2f2VSlB1DALBgNVHREEBDAC
ggAwDQYJKoZIhvcNAQELBQADggEBABpZjuIKTq8pCaX8dMEGPWtAykgLsTcD2jYr
L0/TCrqmuaaliUa42jQTt2OVsVP/L8ofFunj/KjpQU0bvKJPLMRKtmxbhXuQCQi1
qCRkp8o93mHvEz3mTUN+D1cfQ2fpsBENLnpS0F4G/JyY2Vrh19/X8+mImMEK5eOy
o0BMby7byUj98WmcUvNCiXbC6F45QTmkwEhMqWns0JZQY+/XeDhEcg+lJvz9Eyo2
aGgPsye1o3DpyXnyfJWAWMhOz7cikS5X2adesbgI86PhEHBXPIJ1v13ZdfCExmdd
M1fLPhLyR54fGaY+7/X8P9AZzPefAkwizeXwe9ii6/a08vWoiE4=
-----END CERTIFICATE-----
非 PEM 内容可能会出现在证书 PEM 块前后的位置,且未经验证,
以允许使用 RFC7468 第 5.2 节 中描述的解释性文本。
当使用 JSON 或 YAML 格式时,此字段是 base-64 编码。
包含上述示例证书的 CertificateSigningRequest 如下所示:
apiVersion : certificates.k8s.io/v1
kind : CertificateSigningRequest
...
status :
certificate : "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JS..."
接下来 3.4 - 准入控制器参考 此页面提供准入控制器(Admission Controllers)的概述。
什么是准入控制插件? 准入控制器 是一段代码,它会在请求通过认证和鉴权之后、对象被持久化之前拦截到达 API
服务器的请求。
准入控制器可以执行验证(Validating) 和/或变更(Mutating) 操作。
变更(mutating)控制器可以根据被其接受的请求更改相关对象;验证(validating)控制器则不行。
准入控制器限制创建、删除、修改对象的请求。
准入控制器也可以阻止自定义动作,例如通过 API 服务器代理连接到 Pod 的请求。
准入控制器不会 (也不能)阻止读取(get 、watch 或 list )对象的请求。
Kubernetes 1.27
中的准入控制器由下面的列表 组成,
并编译进 kube-apiserver
可执行文件,并且只能由集群管理员配置。
在该列表中,有两个特殊的控制器:MutatingAdmissionWebhook 和 ValidatingAdmissionWebhook。
它们根据 API 中的配置,
分别执行变更和验证准入控制 webhook 。
准入控制阶段 准入控制过程分为两个阶段。第一阶段,运行变更准入控制器。第二阶段,运行验证准入控制器。
再次提醒,某些控制器既是变更准入控制器又是验证准入控制器。
如果两个阶段之一的任何一个控制器拒绝了某请求,则整个请求将立即被拒绝,并向最终用户返回错误。
最后,除了对对象进行变更外,准入控制器还可能有其它副作用:将相关资源作为请求处理的一部分进行变更。
增加配额用量就是一个典型的示例,说明了这样做的必要性。
此类用法都需要相应的回收或回调过程,因为任一准入控制器都无法确定某个请求能否通过所有其它准入控制器。
为什么需要准入控制器? Kubernetes 的若干重要功能都要求启用一个准入控制器,以便正确地支持该特性。
因此,没有正确配置准入控制器的 Kubernetes API 服务器是不完整的,它无法支持你所期望的所有特性。
如何启用一个准入控制器? Kubernetes API 服务器的 enable-admission-plugins
标志接受一个(以逗号分隔的)准入控制插件列表,
这些插件会在集群修改对象之前被调用。
例如,下面的命令启用 NamespaceLifecycle
和 LimitRanger
准入控制插件:
kube-apiserver --enable-admission-plugins= NamespaceLifecycle,LimitRanger ...
说明: 根据你 Kubernetes 集群的部署方式以及 API 服务器的启动方式,你可能需要以不同的方式应用设置。
例如,如果将 API 服务器部署为 systemd 服务,你可能需要修改 systemd 单元文件;
如果以自托管方式部署 Kubernetes,你可能需要修改 API 服务器的清单文件。
怎么关闭准入控制器? Kubernetes API 服务器的 disable-admission-plugins
标志,会将传入的(以逗号分隔的)
准入控制插件列表禁用,即使是默认启用的插件也会被禁用。
kube-apiserver --disable-admission-plugins= PodNodeSelector,AlwaysDeny ...
哪些插件是默认启用的? 要查看哪些插件是被启用的:
kube-apiserver -h | grep enable-admission-plugins
在 Kubernetes 1.27 中,默认启用的插件有:
CertificateApproval, CertificateSigning, CertificateSubjectRestriction, DefaultIngressClass, DefaultStorageClass, DefaultTolerationSeconds, LimitRanger, MutatingAdmissionWebhook, NamespaceLifecycle, PersistentVolumeClaimResize, PodSecurity, Priority, ResourceQuota, RuntimeClass, ServiceAccount, StorageObjectInUseProtection, TaintNodesByCondition, ValidatingAdmissionPolicy, ValidatingAdmissionWebhook
每个准入控制器的作用是什么? AlwaysAdmit 特性状态: Kubernetes v1.13 [deprecated]
该准入控制器允许所有的 Pod 进入集群。此插件已被弃用 ,因其行为与没有准入控制器一样。
AlwaysDeny 特性状态: Kubernetes v1.13 [deprecated]
拒绝所有的请求。由于它没有实际意义,已被弃用 。
AlwaysPullImages 该准入控制器会修改每个新创建的 Pod,将其镜像拉取策略设置为 Always
。
这在多租户集群中是有用的,这样用户就可以放心,他们的私有镜像只能被那些有凭证的人使用。
如果没有这个准入控制器,一旦镜像被拉取到节点上,任何用户的 Pod 都可以通过已了解到的镜像的名称
(假设 Pod 被调度到正确的节点上)来使用它,而不需要对镜像进行任何鉴权检查。
启用这个准入控制器之后,启动容器之前必须拉取镜像,这意味着需要有效的凭证。
CertificateApproval 此准入控制器获取审批 CertificateSigningRequest 资源的请求并执行额外的鉴权检查,
以确保针对设置了 spec.signerName
的 CertificateSigningRequest 资源而言,
审批请求的用户有权限对证书请求执行 审批 操作。
有关对 CertificateSigningRequest 资源执行不同操作所需权限的详细信息,
请参阅证书签名请求 。
CertificateSigning 此准入控制器监视对 CertificateSigningRequest 资源的 status.certificate
字段的更新请求,
并执行额外的鉴权检查,以确保针对设置了 spec.signerName
的 CertificateSigningRequest 资源而言,
签发证书的用户有权限对证书请求执行 签发 操作。
有关对 CertificateSigningRequest 资源执行不同操作所需权限的详细信息,
请参阅证书签名请求 。
CertificateSubjectRestriction 此准入控制器监视 spec.signerName
被设置为 kubernetes.io/kube-apiserver-client
的
CertificateSigningRequest 资源创建请求,并拒绝所有将 “group”(或 “organization attribute”)
设置为 system:masters
的请求。
DefaultIngressClass 该准入控制器监测没有请求任何特定 Ingress 类的 Ingress
对象创建请求,并自动向其添加默认 Ingress 类。
这样,没有任何特殊 Ingress 类需求的用户根本不需要关心它们,他们将被设置为默认 Ingress 类。
当未配置默认 Ingress 类时,此准入控制器不执行任何操作。如果有多个 Ingress 类被标记为默认 Ingress 类,
此控制器将拒绝所有创建 Ingress
的操作,并返回错误信息。
要修复此错误,管理员必须重新检查其 IngressClass
对象,并仅将其中一个标记为默认
(通过注解 "ingressclass.kubernetes.io/is-default-class")。
此准入控制器会忽略所有 Ingress
更新操作,仅处理创建操作。
关于 Ingress 类以及如何将 Ingress 类标记为默认的更多信息,请参见
Ingress 页面。
DefaultStorageClass 此准入控制器监测没有请求任何特定存储类的 PersistentVolumeClaim
对象的创建请求,
并自动向其添加默认存储类。
这样,没有任何特殊存储类需求的用户根本不需要关心它们,它们将被设置为使用默认存储类。
当未配置默认存储类时,此准入控制器不执行任何操作。如果将多个存储类标记为默认存储类,
此控制器将拒绝所有创建 PersistentVolumeClaim
的请求,并返回错误信息。
要修复此错误,管理员必须重新检查其 StorageClass
对象,并仅将其中一个标记为默认。
此准入控制器会忽略所有 PersistentVolumeClaim
更新操作,仅处理创建操作。
关于持久卷申领和存储类,以及如何将存储类标记为默认,请参见持久卷 页面。
DefaultTolerationSeconds 此准入控制器基于 k8s-apiserver 的输入参数 default-not-ready-toleration-seconds
和
default-unreachable-toleration-seconds
为 Pod 设置默认的容忍度,以容忍 notready:NoExecute
和
unreachable:NoExecute
污点
(如果 Pod 尚未容忍 node.kubernetes.io/not-ready:NoExecute
和
node.kubernetes.io/unreachable:NoExecute
污点的话)。
default-not-ready-toleration-seconds
和 default-unreachable-toleration-seconds
的默认值是 5 分钟。
DenyServiceExternalIPs 此准入控制器拒绝新的 Service
中使用字段 externalIPs
。
此功能非常强大(允许网络流量拦截),并且无法很好地受策略控制。
启用后,集群用户将无法创建使用 externalIPs
的新 Service
,也无法在现有
Service
对象上为 externalIPs
添加新值。
externalIPs
的现有使用不受影响,用户可以在现有 Service
对象上从
externalIPs
中删除值。
大多数用户根本不需要此特性,集群管理员应考虑将其禁用。
确实需要使用此特性的集群应考虑使用一些自定义策略来管理 externalIPs
的使用。
此准入控制器默认被禁用。
EventRateLimit 特性状态: Kubernetes v1.13 [alpha]
此准入控制器缓解了请求存储新事件时淹没 API 服务器的问题。集群管理员可以通过以下方式指定事件速率限制:
启用 EventRateLimit
准入控制器; 在通过 API 服务器的命令行标志 --admission-control-config-file
设置的文件中,
引用 EventRateLimit
配置文件: apiVersion : apiserver.config.k8s.io/v1
kind : AdmissionConfiguration
plugins :
- name : EventRateLimit
path : eventconfig.yaml
...
可以在配置中指定的限制有四种类型:
Server
:API 服务器收到的所有(创建或修改)Event 请求共享一个桶。Namespace
:每个名字空间都对应一个专用的桶。User
:为每个用户分配一个桶。SourceAndObject
:根据事件的来源和涉及对象的各种组合分配桶。下面是一个针对此配置的 eventconfig.yaml
示例:
apiVersion : eventratelimit.admission.k8s.io/v1alpha1
kind : Configuration
limits :
- type : Namespace
qps : 50
burst : 100
cacheSize : 2000
- type : User
qps : 10
burst : 50
详情请参见
EventRateLimit 配置 API 文档(v1alpha1) 。
此准入控制器默认被禁用。
ExtendedResourceToleration 此插件有助于创建带有扩展资源的专用节点。
如果运维人员想要创建带有扩展资源(如 GPU、FPGA 等)的专用节点,他们应该以扩展资源名称作为键名,
为节点设置污点 。
如果启用了此准入控制器,会将此类污点的容忍度自动添加到请求扩展资源的 Pod 中,
用户不必再手动添加这些容忍度。
此准入控制器默认被禁用。
ImagePolicyWebhook ImagePolicyWebhook 准入控制器允许使用后端 Webhook 做出准入决策。
此准入控制器默认被禁用。
ImagePolicyWebhook 使用配置文件来为后端行为设置选项。该文件可以是 JSON 或 YAML,
并具有以下格式:
imagePolicy :
kubeConfigFile : /path/to/kubeconfig/for/backend
# 以秒计的时长,控制批准请求的缓存时间
allowTTL : 50
# 以秒计的时长,控制拒绝请求的缓存时间
denyTTL : 50
# 以毫秒计的时长,控制重试间隔
retryBackoff : 500
# 确定 Webhook 后端失效时的行为
defaultAllow : true
在通过命令行标志 --admission-control-config-file
为 API 服务器提供的文件中,
引用 ImagePolicyWebhook 配置文件:
apiVersion : apiserver.config.k8s.io/v1
kind : AdmissionConfiguration
plugins :
- name : ImagePolicyWebhook
path : imagepolicyconfig.yaml
...
或者,你也可以直接将配置嵌入到该文件中:
apiVersion : apiserver.config.k8s.io/v1
kind : AdmissionConfiguration
plugins :
- name : ImagePolicyWebhook
configuration :
imagePolicy :
kubeConfigFile : <kubeconfig 文件路径>
allowTTL : 50
denyTTL : 50
retryBackoff : 500
defaultAllow : true
ImagePolicyWebhook 的配置文件必须引用
kubeconfig
格式的文件;该文件用来设置与后端的连接。要求后端使用 TLS 进行通信。
kubeconfig 文件的 clusters
字段需要指向远端服务,users
字段需要包含已返回的授权者。
# clusters 指的是远程服务。
clusters :
- name : name-of-remote-imagepolicy-service
cluster :
certificate-authority : /path/to/ca.pem # CA 用于验证远程服务
server : https://images.example.com/policy # 要查询的远程服务的 URL,必须是 'https'。
# users 指的是 API 服务器的 Webhook 配置。
users :
- name : name-of-api-server
user :
client-certificate : /path/to/cert.pem # Webhook 准入控制器使用的证书
client-key : /path/to/key.pem # 证书匹配的密钥
关于 HTTP 配置的更多信息,请参阅
kubeconfig
文档。
请求载荷 当面对一个准入决策时,API 服务器发送一个描述操作的 JSON 序列化的
imagepolicy.k8s.io/v1alpha1
ImageReview
对象。
该对象包含描述被准入容器的字段,以及与 *.image-policy.k8s.io/*
匹配的所有 Pod 注解。
说明: 注意,Webhook API 对象与其他 Kubernetes API 对象一样受制于相同的版本控制兼容性规则。
实现者应该知道对 alpha 对象兼容性是相对宽松的,并检查请求的 "apiVersion" 字段,
以确保正确的反序列化。
此外,API 服务器必须启用 imagepolicy.k8s.io/v1alpha1
API 扩展组
(--runtime-config=imagepolicy.k8s.io/v1alpha1=true
)。
请求载荷示例:
{
"apiVersion" : "imagepolicy.k8s.io/v1alpha1" ,
"kind" : "ImageReview" ,
"spec" : {
"containers" : [
{
"image" : "myrepo/myimage:v1"
},
{
"image" : "myrepo/myimage@sha256:beb6bd6a68f114c1dc2ea4b28db81bdf91de202a9014972bec5e4d9171d90ed"
}
],
"annotations" : {
"mycluster.image-policy.k8s.io/ticket-1234" : "break-glass"
},
"namespace" : "mynamespace"
}
}
远程服务将填充请求的 status
字段,并返回允许或不允许访问的响应。
响应体的 spec
字段会被忽略,并且可以被省略。一个允许访问应答会返回:
{
"apiVersion" : "imagepolicy.k8s.io/v1alpha1" ,
"kind" : "ImageReview" ,
"status" : {
"allowed" : true
}
}
若不允许访问,服务将返回:
{
"apiVersion" : "imagepolicy.k8s.io/v1alpha1" ,
"kind" : "ImageReview" ,
"status" : {
"allowed" : false ,
"reason" : "image currently blacklisted"
}
}
更多的文档,请参阅 imagepolicy.v1alpha1
API 。
使用注解进行扩展 一个 Pod 中匹配 *.image-policy.k8s.io/*
的注解都会被发送给 Webhook。
这样做使得了解后端镜像策略的用户可以向它发送额外的信息,
并让不同的后端实现接收不同的信息。
你可以在这里输入的信息有:
在紧急情况下,请求破例覆盖某个策略。 从一个记录了破例的请求的工单(Ticket)系统得到的一个工单号码。 向策略服务器提供提示信息,用于提供镜像的 imageID,以方便它进行查找。 在任何情况下,注解都是由用户提供的,并不会被 Kubernetes 以任何方式进行验证。
LimitPodHardAntiAffinityTopology 此准入控制器拒绝定义了 AntiAffinity
拓扑键的任何 Pod
(requiredDuringSchedulingRequiredDuringExecution
中的 kubernetes.io/hostname
除外)。
此准入控制器默认被禁用。
LimitRanger 此准入控制器会监测传入的请求,并确保请求不会违反 Namespace
中 LimitRange
对象所设置的任何约束。
如果你在 Kubernetes 部署中使用了 LimitRange
对象,则必须使用此准入控制器来执行这些约束。
LimitRanger 还可以用于将默认资源请求应用到没有设定资源约束的 Pod;
当前,默认的 LimitRanger 对 default
名字空间中的所有 Pod 都设置 0.1 CPU 的需求。
请查看
limitRange API 文档 和
LimitRange 例子 以了解更多细节。
MutatingAdmissionWebhook 此准入控制器调用任何与请求匹配的变更(Mutating) Webhook。匹配的 Webhook 将被顺序调用。
每一个 Webhook 都可以自由修改对象。
MutatingAdmissionWebhook
,顾名思义,仅在变更阶段运行。
如果由此准入控制器调用的 Webhook 有副作用(如:减少配额),
则它 必须 具有协调系统,因为不能保证后续的 Webhook 和验证准入控制器都会允许完成请求。
如果你禁用了 MutatingAdmissionWebhook,那么还必须使用 --runtime-config
标志禁止
admissionregistration.k8s.io/v1
组/版本中的 MutatingWebhookConfiguration
,
二者都是默认启用的。
谨慎编写和安装变更 webhook 当用户尝试创建的对象与返回的对象不同时,用户可能会感到困惑。 当他们读回的对象与尝试创建的对象不同,内建的控制回路可能会出问题。与覆盖原始请求中设置的字段相比,使用原始请求未设置的字段会引起问题的可能性较小。
应尽量避免覆盖原始请求中的字段设置。 内建资源和第三方资源的控制回路未来可能会出现破坏性的变更,使现在运行良好的 Webhook
无法再正常运行。即使完成了 Webhook API 安装,也不代表该 Webhook 会被提供无限期的支持。 NamespaceAutoProvision 此准入控制器会检查针对名字空间域资源的所有传入请求,并检查所引用的名字空间是否确实存在。
如果找不到所引用的名字空间,控制器将创建一个名字空间。
此准入控制器对于不想要求名字空间必须先创建后使用的集群部署很有用。
NamespaceExists 此准入控制器检查针对名字空间作用域的资源(除 Namespace
自身)的所有请求。
如果请求引用的名字空间不存在,则拒绝该请求。
NamespaceLifecycle 该准入控制器禁止在一个正在被终止的 Namespace
中创建新对象,并确保针对不存在的
Namespace
的请求被拒绝。
该准入控制器还会禁止删除三个系统保留的名字空间,即 default
、
kube-system
和 kube-public
。
Namespace
的删除操作会触发一系列删除该名字空间中所有对象(Pod、Service 等)的操作。
为了确保这个过程的完整性,我们强烈建议启用这个准入控制器。
NodeRestriction 该准入控制器限制了某 kubelet 可以修改的 Node
和 Pod
对象。
为了受到这个准入控制器的限制,kubelet 必须使用在 system:nodes
组中的凭证,
并使用 system:node:<nodeName>
形式的用户名。
这样,kubelet 只可修改自己的 Node
API 对象,只能修改绑定到自身节点的 Pod 对象。
不允许 kubelet 更新或删除 Node
API 对象的污点。
NodeRestriction
准入插件可防止 kubelet 删除其 Node
API 对象,
并对前缀为 kubernetes.io/
或 k8s.io/
的标签的修改对 kubelet 作如下限制:
禁止 kubelet 添加、删除或更新前缀为 node-restriction.kubernetes.io/
的标签。
这类前缀的标签时保留给管理员的,用以为 Node
对象设置标签以隔离工作负载,而不允许 kubelet
修改带有该前缀的标签。允许 kubelet 添加、删除、更新以下标签:kubernetes.io/hostname
kubernetes.io/arch
kubernetes.io/os
beta.kubernetes.io/instance-type
node.kubernetes.io/instance-type
failure-domain.beta.kubernetes.io/region
(已弃用)failure-domain.beta.kubernetes.io/zone
(已弃用)topology.kubernetes.io/region
topology.kubernetes.io/zone
kubelet.kubernetes.io/
为前缀的标签node.kubernetes.io/
为前缀的标签以 kubernetes.io
或 k8s.io
为前缀的所有其他标签都限制 kubelet 使用,并且将来可能会被
NodeRestriction
准入插件允许或禁止。
将来的版本可能会增加其他限制,以确保 kubelet 具有正常运行所需的最小权限集。
OwnerReferencesPermissionEnforcement 此准入控制器保护对对象的 metadata.ownerReferences
的访问,以便只有对该对象具有
delete 权限的用户才能对其进行更改。
该准入控制器还保护对 metadata.ownerReferences[x].blockOwnerDeletion
对象的访问,
以便只有对所引用的 属主(owner) 的 finalizers
子资源具有 update
权限的用户才能对其进行更改。
PersistentVolumeClaimResize 特性状态: Kubernetes v1.24 [stable]
此准入控制器检查传入的 PersistentVolumeClaim
调整大小请求,对其执行额外的验证检查操作。
建议启用 PersistentVolumeClaimResize
准入控制器。除非 PVC 的 StorageClass
明确地将
allowVolumeExpansion
设置为 true
来显式启用调整大小。
否则,默认情况下该准入控制器会阻止所有对 PVC 大小的调整。
例如:由以下 StorageClass
创建的所有 PersistentVolumeClaim
都支持卷容量扩充:
apiVersion : storage.k8s.io/v1
kind : StorageClass
metadata :
name : gluster-vol-default
provisioner : kubernetes.io/glusterfs
parameters :
resturl : "http://192.168.10.100:8080"
restuser : ""
secretNamespace : ""
secretName : ""
allowVolumeExpansion : true
关于持久化卷申领的更多信息,请参见
PersistentVolumeClaim 。
PersistentVolumeLabel 特性状态: Kubernetes v1.13 [deprecated]
此准入控制器会自动将由云提供商(如 Azure 或 GCP)定义的区(region)或区域(zone)
标签附加到 PersistentVolume 上。这有助于确保 Pod 和 PersistentVolume 位于相同的区或区域。
如果准入控制器不支持为 PersistentVolumes 自动添加标签,那你可能需要手动添加标签,
以防止 Pod 挂载其他区域的卷。
PersistentVolumeLabel 已被弃用 ,
为持久卷添加标签的操作已由云管理控制器 接管。
此准入控制器默认被禁用。
PodNodeSelector 特性状态: Kubernetes v1.5 [alpha]
此准入控制器通过读取名字空间注解和全局配置,来为名字空间中可以使用的节点选择器设置默认值并实施限制。
此准入控制器默认被禁用。
PodNodeSelector
使用配置文件来设置后端行为的选项。
请注意,配置文件格式将在将来某个版本中改为版本化文件。
该文件可以是 JSON 或 YAML,格式如下:
podNodeSelectorPluginConfig :
clusterDefaultNodeSelector : name-of-node-selector
namespace1 : name-of-node-selector
namespace2 : name-of-node-selector
通过 API 服务器命令行标志 --admission-control-config-file
为 API 服务器提供的文件中,
需要引用 PodNodeSelector
配置文件:
apiVersion : apiserver.config.k8s.io/v1
kind : AdmissionConfiguration
plugins :
- name : PodNodeSelector
path : podnodeselector.yaml
...
PodNodeSelector
使用键为 scheduler.alpha.kubernetes.io/node-selector
的注解为名字空间设置节点选择算符。
apiVersion : v1
kind : Namespace
metadata :
annotations :
scheduler.alpha.kubernetes.io/node-selector : name-of-node-selector
name : namespace3
内部行为 此准入控制器行为如下:
如果 Namespace
的注解带有键 scheduler.alpha.kubernetes.io/node-selector
,
则将其值用作节点选择算符。 如果名字空间缺少此类注解,则使用 PodNodeSelector
插件配置文件中定义的
clusterDefaultNodeSelector
作为节点选择算符。 评估 Pod 节点选择算符和名字空间节点选择算符是否存在冲突。存在冲突将拒绝 Pod。 评估 Pod 节点选择算符和特定于名字空间的被允许的选择算符所定义的插件配置文件是否存在冲突。
存在冲突将导致拒绝 Pod。 说明: PodNodeSelector 允许 Pod 强制在特定标签的节点上运行。
另请参阅 PodTolerationRestriction 准入插件,该插件可防止 Pod 在特定污点的节点上运行。
PodSecurity 特性状态: Kubernetes v1.25 [stable]
PodSecurity 准入控制器在新 Pod 被准入之前对其进行检查,
根据请求的安全上下文和 Pod 所在命名空间允许的
Pod 安全性标准 的限制来确定新 Pod
是否应该被准入。
更多信息请参阅 Pod 安全性准入 。
PodSecurity 取代了一个名为 PodSecurityPolicy 的旧准入控制器。
PodTolerationRestriction 特性状态: Kubernetes v1.7 [alpha]
准入控制器 PodTolerationRestriction 检查 Pod 的容忍度与其名字空间的容忍度之间是否存在冲突。
如果存在冲突,则拒绝 Pod 请求。
控制器接下来会将名字空间的容忍度合并到 Pod 的容忍度中,
根据名字空间的容忍度白名单检查所得到的容忍度结果。
如果检查成功,则将接受 Pod 请求,否则拒绝该请求。
如果 Pod 的名字空间没有任何关联的默认容忍度或容忍度白名单,
则使用集群级别的默认容忍度或容忍度白名单(如果有的话)。
名字空间的容忍度通过注解键 scheduler.alpha.kubernetes.io/defaultTolerations
来设置。可接受的容忍度可以通过 scheduler.alpha.kubernetes.io/tolerationsWhitelist
注解键来添加。
名字空间注解的示例:
apiVersion : v1
kind : Namespace
metadata :
name : apps-that-need-nodes-exclusively
annotations :
scheduler.alpha.kubernetes.io/defaultTolerations : '[{"operator": "Exists", "effect": "NoSchedule", "key": "dedicated-node"}]'
scheduler.alpha.kubernetes.io/tolerationsWhitelist : '[{"operator": "Exists", "effect": "NoSchedule", "key": "dedicated-node"}]'
此准入控制器默认被禁用。
优先级 优先级准入控制器使用 priorityClassName
字段并用整型值填充优先级。
如果找不到优先级,则拒绝 Pod。
ResourceQuota 此准入控制器会监测传入的请求,并确保它不违反任何一个 Namespace
中的 ResourceQuota
对象中列举的约束。如果你在 Kubernetes 部署中使用了 ResourceQuota
,
则必须使用这个准入控制器来强制执行配额限制。
请参阅
resourceQuota API 参考
和 Resource Quota 例子 了解更多细节。
RuntimeClass 如果你所定义的 RuntimeClass 包含 Pod 开销 ,
这个准入控制器会检查新的 Pod。
被启用后,此准入控制器会拒绝所有已经设置了 overhead 字段的 Pod 创建请求。
对于配置了 RuntimeClass 并在其 .spec
中选定 RuntimeClass 的 Pod,
此准入控制器会根据相应 RuntimeClass 中定义的值为 Pod 设置 .spec.overhead
。
详情请参见 Pod 开销 。
SecurityContextDeny 特性状态: Kubernetes v1.0 [alpha]
注意: 这个准入控制器插件是过时的 且不完整的 ,它可能无法使用或无法达到你的预期。
它最初旨在防止使用某些(但不是全部)安全敏感字段。
事实上,像 privileged
这样的字段在创建时并没有被过滤,
而且该插件没有根据最新的字段和新的 API(例如 Pod 的 ephemeralContainers
字段)来更新。
采用 Pod 安全性标准 中的 Restricted
方案的 Pod 安全性准入 插件,
能以更好和最新的方式来表述此插件所要实现的目标。
此准入控制器将拒绝任何尝试设置以下
SecurityContext
字段的 Pod:
.spec.securityContext.supplementalGroups
.spec.securityContext.seLinuxOptions
.spec.securityContext.runAsUser
.spec.securityContext.fsGroup
.spec.(init)Containers[*].securityContext.seLinuxOptions
.spec.(init)Containers[*].securityContext.runAsUser
有关此插件的更多历史背景,请参阅 Kubernetes 博客中这篇有关 PodSecurityPolicy 及其移除的文章:
The birth of PodSecurityPolicy 。
这篇文章详细地介绍了 PodSecurityPolicy 的历史背景以及 Pod 的 securityContext
字段的诞生。
ServiceAccount 此准入控制器实现了
ServiceAccount
的自动化。强烈推荐为 Kubernetes 项目启用此准入控制器。
如果你打算使用 Kubernetes 的 ServiceAccount
对象,你应启用这个准入控制器。
StorageObjectInUseProtection StorageObjectInUseProtection
插件将 kubernetes.io/pvc-protection
或
kubernetes.io/pv-protection
finalizers 添加到新创建的持久卷申领(PVC)
或持久卷(PV)中。如果用户尝试删除 PVC/PV,除非 PVC/PV 的保护控制器移除终结器(finalizers),
否则 PVC/PV 不会被删除。有关更多详细信息,
请参考保护使用中的存储对象 。
TaintNodesByCondition 该准入控制器为新创建的节点添加 NotReady
和 NoSchedule
污点 。
这些污点能够避免一些竞态条件的发生,而这类竞态条件可能导致 Pod
在更新节点污点以准确反映其所报告状况之前,就被调度到新节点上。
ValidatingAdmissionPolicy 此准入控制器 针对传入的匹配请求实现
CEL 校验。当 validatingadmissionpolicy
和 admissionregistration.k8s.io/v1alpha1
特性门控组/版本被启用时,
此特性被启用。如果任意 ValidatingAdmissionPolicy 失败,则请求失败。
ValidatingAdmissionWebhook 此准入控制器调用与请求匹配的所有验证性 Webhook。
匹配的 Webhook 将被并行调用。如果其中任何一个拒绝请求,则整个请求将失败。
该准入控制器仅在验证(Validating)阶段运行;与 MutatingAdmissionWebhook
准入控制器所调用的 Webhook 相反,它调用的 Webhook 不可以变更对象。
如果以此方式调用的 Webhook 有其它副作用(如:减少配额),则它 必须 具有协调机制。
这是因为无法保证后续的 Webhook 或其他验证性准入控制器都允许请求完成。
如果你禁用了 ValidatingAdmissionWebhook,还必须通过 --runtime-config
标志来禁用
admissionregistration.k8s.io/v1
组/版本中的 ValidatingWebhookConfiguration
对象。
有推荐的准入控制器吗? 有。推荐使用的准入控制器默认情况下都处于启用状态
(请查看这里 )。
因此,你无需显式指定它们。
你可以使用 --enable-admission-plugins
标志( 顺序不重要 )来启用默认设置以外的其他准入控制器。
3.5 - 动态准入控制 除了内置的 admission 插件 ,
准入插件可以作为扩展独立开发,并以运行时所配置的 Webhook 的形式运行。
此页面描述了如何构建、配置、使用和监视准入 Webhook。
什么是准入 Webhook? 准入 Webhook 是一种用于接收准入请求并对其进行处理的 HTTP 回调机制。
可以定义两种类型的准入 webhook,即
验证性质的准入 Webhook 和
修改性质的准入 Webhook 。
修改性质的准入 Webhook 会先被调用。它们可以更改发送到 API
服务器的对象以执行自定义的设置默认值操作。
在完成了所有对象修改并且 API 服务器也验证了所传入的对象之后,
验证性质的 Webhook 会被调用,并通过拒绝请求的方式来强制实施自定义的策略。
说明: 如果准入 Webhook 需要保证它们所看到的是对象的最终状态以实施某种策略。
则应使用验证性质的准入 Webhook,因为对象被修改性质 Webhook 看到之后仍然可能被修改。
尝试准入 Webhook 准入 Webhook 本质上是集群控制平面的一部分。你应该非常谨慎地编写和部署它们。
如果你打算编写或者部署生产级准入 webhook,请阅读用户指南 以获取相关说明。
在下文中,我们将介绍如何快速试验准入 Webhook。
先决条件 编写一个准入 Webhook 服务器 请参阅 Kubernetes e2e 测试中的
Admission Webhook 服务器
的实现。webhook 处理由 API 服务器发送的 AdmissionReview
请求,并且将其决定
作为 AdmissionReview
对象以相同版本发送回去。
有关发送到 Webhook 的数据的详细信息,请参阅 Webhook 请求 。
要获取来自 Webhook 的预期数据,请参阅 Webhook 响应 。
示例准入 Webhook 服务器置 ClientAuth
字段为
空 ,
默认为 NoClientCert
。这意味着 Webhook 服务器不会验证客户端的身份,认为其是 apiservers。
如果你需要双向 TLS 或其他方式来验证客户端,请参阅
如何对 apiservers 进行身份认证 。
部署准入 Webhook 服务 e2e 测试中的 Webhook 服务器通过
deployment API
部署在 Kubernetes 集群中。该测试还将创建一个
service
作为 Webhook 服务器的前端。参见
相关代码 。
你也可以在集群外部署 Webhook。这样做需要相应地更新你的 Webhook 配置。
你可以通过
ValidatingWebhookConfiguration
或者
MutatingWebhookConfiguration 动态配置哪些资源要被哪些准入 Webhook 处理。
以下是一个 ValidatingWebhookConfiguration
示例,Mutating Webhook 配置与此类似。有关每个配置字段的详细信息,请参阅 Webhook 配置 部分。
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
metadata :
name : "pod-policy.example.com"
webhooks :
- name : "pod-policy.example.com"
rules :
- apiGroups : ["" ]
apiVersions : ["v1" ]
operations : ["CREATE" ]
resources : ["pods" ]
scope : "Namespaced"
clientConfig :
service :
namespace : "example-namespace"
name : "example-service"
caBundle : <CA_BUNDLE>
admissionReviewVersions : ["v1" ]
sideEffects : None
timeoutSeconds : 5
说明: 你必须在以上示例中将 <CA_BUNDLE>
替换为一个有效的 CA 证书包,
这是一个用 PEM 编码的(字段值是 Base64 编码) CA 证书包,用于校验 Webhook 的服务器证书。
scope
字段指定是仅集群范围的资源(Cluster)还是名字空间范围的资源资源(Namespaced)将与此规则匹配。
*
表示没有范围限制。
说明: 当使用 clientConfig.service
时,服务器证书必须对 <svc_name>.<svc_namespace>.svc
有效。
说明: Webhook 调用的默认超时是 10 秒,你可以设置 timeout
并建议对 Webhook 设置较短的超时时间。
如果 Webhook 调用超时,则根据 Webhook 的失败策略处理请求。
当一个 API 服务器收到与 rules
相匹配的请求时,
该 API 服务器将按照 clientConfig
中指定的方式向 Webhook 发送一个 admissionReview
请求。
创建 Webhook 配置后,系统将花费几秒钟使新配置生效。
对 API 服务器进行身份认证 如果你的 Webhook 需要身份验证,则可以将 API 服务器配置为使用基本身份验证、持有者令牌或证书来向
Webhook 提供身份证明。完成此配置需要三个步骤。
启动 API 服务器时,通过 --admission-control-config-file
参数指定准入控制配置文件的位置。
在准入控制配置文件中,指定 MutatingAdmissionWebhook 控制器和 ValidatingAdmissionWebhook 控制器应该读取凭据的位置。
凭证存储在 kubeConfig 文件中(是的,与 kubectl 使用的模式相同),因此字段名称为 kubeConfigFile
。
以下是一个准入控制配置文件示例:
apiVersion : apiserver.config.k8s.io/v1
kind : AdmissionConfiguration
plugins :
- name : ValidatingAdmissionWebhook
configuration :
apiVersion : apiserver.config.k8s.io/v1
kind : WebhookAdmissionConfiguration
kubeConfigFile : "<path-to-kubeconfig-file>"
- name : MutatingAdmissionWebhook
configuration :
apiVersion : apiserver.config.k8s.io/v1
kind : WebhookAdmissionConfiguration
kubeConfigFile : "<path-to-kubeconfig-file>"
# 1.17 中被淘汰,推荐使用 apiserver.config.k8s.io/v1
apiVersion : apiserver.k8s.io/v1alpha1
kind : AdmissionConfiguration
plugins :
- name : ValidatingAdmissionWebhook
configuration :
# 1.17 中被淘汰,推荐使用 apiserver.config.k8s.io/v1,kind = WebhookAdmissionConfiguration
apiVersion : apiserver.config.k8s.io/v1alpha1
kind : WebhookAdmission
kubeConfigFile : "<path-to-kubeconfig-file>"
- name : MutatingAdmissionWebhook
configuration :
# 1.17 中被淘汰,推荐使用 apiserver.config.k8s.io/v1,kind = WebhookAdmissionConfiguration
apiVersion : apiserver.config.k8s.io/v1alpha1
kind : WebhookAdmission
kubeConfigFile : "<path-to-kubeconfig-file>"
有关 AdmissionConfiguration
的更多信息,请参见
AdmissionConfiguration (v1) reference 。
有关每个配置字段的详细信息,请参见 Webhook 配置 部分。
在 kubeConfig 文件中,提供证书凭据:
apiVersion : v1
kind : Config
users :
# 名称应设置为服务的 DNS 名称或配置了 Webhook 的 URL 的主机名(包括端口)。
# 如果将非 443 端口用于服务,则在配置 1.16+ API 服务器时,该端口必须包含在名称中。
#
# 对于配置在默认端口(443)上与服务对话的 Webhook,请指定服务的 DNS 名称:
# - name: webhook1.ns1.svc
# user: ...
#
# 对于配置在非默认端口(例如 8443)上与服务对话的 Webhook,请在 1.16+ 中指定服务的 DNS 名称和端口:
# - name: webhook1.ns1.svc:8443
# user: ...
# 并可以选择仅使用服务的 DNS 名称来创建第二节,以与 1.15 API 服务器版本兼容:
# - name: webhook1.ns1.svc
# user: ...
#
# 对于配置为使用 URL 的 webhook,请匹配在 webhook 的 URL 中指定的主机(和端口)。
# 带有 `url: https://www.example.com` 的 webhook:
# - name: www.example.com
# user: ...
#
# 带有 `url: https://www.example.com:443` 的 webhook:
# - name: www.example.com:443
# user: ...
#
# 带有 `url: https://www.example.com:8443` 的 webhook:
# - name: www.example.com:8443
# user: ...
#
- name : 'webhook1.ns1.svc'
user :
client-certificate-data : "<pem encoded certificate>"
client-key-data : "<pem encoded key>"
# `name` 支持使用 * 通配符匹配前缀段。
- name : '*.webhook-company.org'
user :
password : "<password>"
username : "<name>"
# '*' 是默认匹配项。
- name : '*'
user :
token : "<token>"
当然,你需要设置 Webhook 服务器来处理这些身份验证请求。
Webhook 请求与响应 请求 Webhook 发送 POST 请求时,请设置 Content-Type: application/json
并对 admission.k8s.io
API
组中的 AdmissionReview
对象进行序列化,将所得到的 JSON 作为请求的主体。
Webhook 可以在配置中的 admissionReviewVersions
字段指定可接受的 AdmissionReview
对象版本:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
admissionReviewVersions : ["v1" , "v1beta1" ]
创建 Webhook 配置时,admissionReviewVersions
是必填字段。
Webhook 必须支持至少一个当前和以前的 API 服务器都可以解析的 AdmissionReview
版本。
API 服务器将发送的是 admissionReviewVersions
列表中所支持的第一个 AdmissionReview
版本。如果 API 服务器不支持列表中的任何版本,则不允许创建配置。
如果 API 服务器遇到以前创建的 Webhook 配置,并且不支持该 API 服务器知道如何发送的任何 AdmissionReview
版本,则调用 Webhook 的尝试将失败,并依据失败策略 进行处理。
此示例显示了 AdmissionReview
对象中包含的数据,该数据用于请求更新 apps/v1
Deployment
的 scale
子资源:
apiVersion : admission.k8s.io/v1
kind : AdmissionReview
request :
# 唯一标识此准入回调的随机 uid
uid : 705ab4f5-6393-11e8-b7cc-42010a800002
# 传入完全正确的 group/version/kind 对象
kind :
group : autoscaling
version : v1
kind : Scale
# 修改 resource 的完全正确的的 group/version/kind
resource :
group : apps
version : v1
resource : deployments
# subResource(如果请求是针对 subResource 的)
subResource : scale
# 在对 API 服务器的原始请求中,传入对象的标准 group/version/kind
# 仅当 Webhook 指定 `matchPolicy: Equivalent` 且将对 API 服务器的原始请求
# 转换为 Webhook 注册的版本时,这才与 `kind` 不同。
requestKind :
group : autoscaling
version : v1
kind : Scale
# 在对 API 服务器的原始请求中正在修改的资源的标准 group/version/kind
# 仅当 Webhook 指定了 `matchPolicy:Equivalent` 并且将对 API 服务器的原始请求转换为
# Webhook 注册的版本时,这才与 `resource` 不同。
requestResource :
group : apps
version : v1
resource : deployments
# subResource(如果请求是针对 subResource 的)
# 仅当 Webhook 指定了 `matchPolicy:Equivalent` 并且将对
# API 服务器的原始请求转换为该 Webhook 注册的版本时,这才与 `subResource` 不同。
requestSubResource : scale
# 被修改资源的名称
name : my-deployment
# 如果资源是属于名字空间(或者是名字空间对象),则这是被修改的资源的名字空间
namespace : my-namespace
# 操作可以是 CREATE、UPDATE、DELETE 或 CONNECT
operation : UPDATE
userInfo :
# 向 API 服务器发出请求的经过身份验证的用户的用户名
username : admin
# 向 API 服务器发出请求的经过身份验证的用户的 UID
uid : 014fbff9a07c
# 向 API 服务器发出请求的经过身份验证的用户的组成员身份
groups :
- system:authenticated
- my-admin-group
# 向 API 服务器发出请求的用户相关的任意附加信息
# 该字段由 API 服务器身份验证层填充,并且如果 webhook 执行了任何
# SubjectAccessReview 检查,则应将其包括在内。
extra :
some-key :
- some-value1
- some-value2
# object 是被接纳的新对象。
# 对于 DELETE 操作,它为 null。
object :
apiVersion : autoscaling/v1
kind : Scale
# oldObject 是现有对象。
# 对于 CREATE 和 CONNECT 操作,它为 null。
oldObject :
apiVersion : autoscaling/v1
kind : Scale
# options 包含要接受的操作的选项,例如 meta.k8s.io/v CreateOptions、UpdateOptions 或 DeleteOptions。
# 对于 CONNECT 操作,它为 null。
options :
apiVersion : meta.k8s.io/v1
kind : UpdateOptions
# dryRun 表示 API 请求正在以 `dryrun` 模式运行,并且将不会保留。
# 带有副作用的 Webhook 应该避免在 dryRun 为 true 时激活这些副作用。
# 有关更多详细信息,请参见 http://k8s.io/docs/reference/using-api/api-concepts/#make-a-dry-run-request
dryRun : False
响应 Webhook 使用 HTTP 200 状态码、Content-Type: application/json
和一个包含 AdmissionReview
对象的 JSON 序列化格式来发送响应。该 AdmissionReview
对象与发送的版本相同,且其中包含的 response
字段已被有效填充。
response
至少必须包含以下字段:
uid
,从发送到 Webhook 的 request.uid
中复制而来allowed
,设置为 true
或 false
Webhook 允许请求的最简单响应示例:
{
"apiVersion" : "admission.k8s.io/v1" ,
"kind" : "AdmissionReview" ,
"response" : {
"uid" : "<value from request.uid>" ,
"allowed" : true
}
}
Webhook 禁止请求的最简单响应示例:
{
"apiVersion" : "admission.k8s.io/v1" ,
"kind" : "AdmissionReview" ,
"response" : {
"uid" : "<value from request.uid>" ,
"allowed" : false
}
}
当拒绝请求时,Webhook 可以使用 status
字段自定义 http 响应码和返回给用户的消息。
有关状态类型的详细信息,请参见
API 文档 。
禁止请求的响应示例,它定制了向用户显示的 HTTP 状态码和消息:
{
"apiVersion" : "admission.k8s.io/v1" ,
"kind" : "AdmissionReview" ,
"response" : {
"uid" : "<value from request.uid>" ,
"allowed" : false ,
"status" : {
"code" : 403 ,
"message" : "You cannot do this because it is Tuesday and your name starts with A"
}
}
}
当允许请求时,mutating准入 Webhook 也可以选择修改传入的对象。
这是通过在响应中使用 patch
和 patchType
字段来完成的。
当前唯一支持的 patchType
是 JSONPatch
。
有关更多详细信息,请参见 JSON patch 。
对于 patchType: JSONPatch
,patch
字段包含一个以 base64 编码的 JSON patch 操作数组。
例如,设置 spec.replicas
的单个补丁操作将是
[{"op": "add", "path": "/spec/replicas", "value": 3}]
。
如果以 Base64 形式编码,结果将是
W3sib3AiOiAiYWRkIiwgInBhdGgiOiAiL3NwZWMvcmVwbGljYXMiLCAidmFsdWUiOiAzfV0=
因此,添加该标签的 Webhook 响应为:
{
"apiVersion" : "admission.k8s.io/v1" ,
"kind" : "AdmissionReview" ,
"response" : {
"uid" : "<value from request.uid>" ,
"allowed" : true ,
"patchType" : "JSONPatch" ,
"patch" : "W3sib3AiOiAiYWRkIiwgInBhdGgiOiAiL3NwZWMvcmVwbGljYXMiLCAidmFsdWUiOiAzfV0="
}
}
准入 Webhook 可以选择性地返回在 HTTP Warning
头中返回给请求客户端的警告消息,警告代码为 299。
警告可以与允许或拒绝的准入响应一起发送。
如果你正在实现返回一条警告的 webhook,则:
不要在消息中包括 "Warning:" 前缀 使用警告消息描述该客户端进行 API 请求时会遇到或应意识到的问题 如果可能,将警告限制为 120 个字符 注意: 超过 256 个字符的单条警告消息在返回给客户之前可能会被 API 服务器截断。
如果超过 4096 个字符的警告消息(来自所有来源),则额外的警告消息会被忽略。
{
"apiVersion" : "admission.k8s.io/v1" ,
"kind" : "AdmissionReview" ,
"response" : {
"uid" : "<value from request.uid>" ,
"allowed" : true ,
"warnings" : [
"duplicate envvar entries specified with name MY_ENV" ,
"memory request less than 4MB specified for container mycontainer, which will not start successfully"
]
}
}
Webhook 配置 要注册准入 Webhook,请创建 MutatingWebhookConfiguration
或 ValidatingWebhookConfiguration
API 对象。
MutatingWebhookConfiguration
或ValidatingWebhookConfiguration
对象的名称必须是有效的
DNS 子域名 。
每种配置可以包含一个或多个 Webhook。如果在单个配置中指定了多个
Webhook,则应为每个 Webhook 赋予一个唯一的名称。
这是必需的,以使生成的审计日志和指标更易于与激活的配置相匹配。
每个 Webhook 定义以下内容。
匹配请求-规则 每个 Webhook 必须指定用于确定是否应将对 apiserver 的请求发送到 webhook 的规则列表。
每个规则都指定一个或多个 operations、apiGroups、apiVersions 和 resources 以及资源的 scope:
operations
列出一个或多个要匹配的操作。
可以是 CREATE
、UPDATE
、DELETE
、CONNECT
或 *
以匹配所有内容。
apiGroups
列出了一个或多个要匹配的 API 组。""
是核心 API 组。"*"
匹配所有 API 组。
apiVersions
列出了一个或多个要匹配的 API 版本。"*"
匹配所有 API 版本。
resources
列出了一个或多个要匹配的资源。
"*"
匹配所有资源,但不包括子资源。"*/*"
匹配所有资源,包括子资源。"pods/*"
匹配 pod 的所有子资源。"*/status"
匹配所有 status 子资源。scope
指定要匹配的范围。有效值为 "Cluster"
、"Namespaced"
和 "*"
。
子资源匹配其父资源的范围。默认值为 "*"
。
"Cluster"
表示只有集群作用域的资源才能匹配此规则(API 对象 Namespace 是集群作用域的)。"Namespaced"
意味着仅具有名字空间的资源才符合此规则。"*"
表示没有作用域限制。如果传入请求与任何 Webhook rules
的指定 operations
、groups
、versions
、
resources
和 scope
匹配,则该请求将发送到 Webhook。
以下是可用于指定应拦截哪些资源的规则的其他示例。
匹配针对 apps/v1
和 apps/v1beta1
组中 deployments
和 replicasets
资源的 CREATE
或 UPDATE
请求:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
...
webhooks :
- name : my-webhook.example.com
rules :
- operations : ["CREATE" , "UPDATE" ]
apiGroups : ["apps" ]
apiVersions : ["v1" , "v1beta1" ]
resources : ["deployments" , "replicasets" ]
scope : "Namespaced"
...
匹配所有 API 组和版本中的所有资源(但不包括子资源)的创建请求:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
rules :
- operations : ["CREATE" ]
apiGroups : ["*" ]
apiVersions : ["*" ]
resources : ["*" ]
scope : "*"
匹配所有 API 组和版本中所有 status
子资源的更新请求:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
rules :
- operations : ["UPDATE" ]
apiGroups : ["*" ]
apiVersions : ["*" ]
resources : ["*/status" ]
scope : "*"
匹配请求:objectSelector 通过指定 objectSelector
,Webhook 能够根据可能发送的对象的标签来限制哪些请求被拦截。
如果指定,则将对 objectSelector
和可能发送到 Webhook 的 object 和 oldObject
进行评估。如果两个对象之一与选择器匹配,则认为该请求已匹配。
空对象(对于创建操作而言为 oldObject
,对于删除操作而言为 newObject
),
或不能带标签的对象(例如 DeploymentRollback
或 PodProxyOptions
对象)
被认为不匹配。
仅当选择使用 Webhook 时才使用对象选择器,因为最终用户可以通过设置标签来
跳过准入 Webhook。
这个例子展示了一个变更性质的 Webhook,它将匹配带有标签 foo:bar
的所有资源(但不包括子资源)的
CREATE
操作:
apiVersion : admissionregistration.k8s.io/v1
kind : MutatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
objectSelector :
matchLabels :
foo : bar
rules :
- operations : ["CREATE" ]
apiGroups : ["*" ]
apiVersions : ["*" ]
resources : ["*" ]
scope : "*"
有关标签选择器的更多示例,请参见标签 。
匹配请求:namespaceSelector 通过指定 namespaceSelector
,
Webhook 可以根据具有名字空间的资源所处的名字空间的标签来选择拦截哪些资源的操作。
namespaceSelector
根据名字空间的标签是否匹配选择器,决定是否针对具名字空间的资源
(或 Namespace 对象)的请求运行 webhook。
如果对象是除 Namespace 以外的集群范围的资源,则 namespaceSelector
标签无效。
本例给出的修改性质的 Webhook 将匹配到对名字空间中具名字空间的资源的 CREATE
请求,
前提是这些资源不含值为 "0" 或 "1" 的 "runlevel" 标签:
apiVersion : admissionregistration.k8s.io/v1
kind : MutatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
namespaceSelector :
matchExpressions :
- key : runlevel
operator : NotIn
values : ["0" , "1" ]
rules :
- operations : ["CREATE" ]
apiGroups : ["*" ]
apiVersions : ["*" ]
resources : ["*" ]
scope : "Namespaced"
此示例显示了一个验证性质的 Webhook,它将匹配到对某名字空间中的任何具名字空间的资源的
CREATE
请求,前提是该名字空间具有值为 "prod" 或 "staging" 的 "environment" 标签:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
namespaceSelector :
matchExpressions :
- key : environment
operator : In
values : ["prod" , "staging" ]
rules :
- operations : ["CREATE" ]
apiGroups : ["*" ]
apiVersions : ["*" ]
resources : ["*" ]
scope : "Namespaced"
有关标签选择器的更多示例,请参见
标签 。
匹配请求:matchPolicy API 服务器可以通过多个 API 组或版本来提供对象。
例如,如果一个 Webhook 仅为某些 API 组/版本指定了规则(例如
apiGroups:["apps"], apiVersions:["v1","v1beta1"]
),而修改资源的请求是通过另一个
API 组/版本(例如 extensions/v1beta1
)发出的,该请求将不会被发送到 Webhook。
matchPolicy
允许 Webhook 定义如何使用其 rules
匹配传入的请求。
允许的值为 Exact
或 Equivalent
。
Exact
表示仅当请求与指定规则完全匹配时才应拦截该请求。Equivalent
表示如果某个请求意在修改 rules
中列出的资源,
即使该请求是通过其他 API 组或版本发起,也应拦截该请求。在上面给出的示例中,仅为 apps/v1
注册的 Webhook 可以使用 matchPolicy
:
matchPolicy: Exact
表示不会将 extensions/v1beta1
请求发送到 WebhookmatchPolicy:Equivalent
表示将 extensions/v1beta1
请求发送到 Webhook
(将对象转换为 Webhook 指定的版本:apps/v1
)建议指定 Equivalent
,确保升级后启用 API 服务器中资源的新版本时,
Webhook 继续拦截他们期望的资源。
当 API 服务器停止提供某资源时,该资源不再被视为等同于该资源的其他仍在提供服务的版本。
例如,extensions/v1beta1
中的 Deployment 已被废弃,计划在 v1.16 中移除。
移除后,带有 apiGroups:["extensions"], apiVersions:["v1beta1"], resources: ["deployments"]
规则的 Webhook 将不再拦截通过 apps/v1
API 来创建的 Deployment。
因此,Webhook 应该优先注册稳定版本的资源。
此示例显示了一个验证性质的 Webhook,该 Webhook 拦截对 Deployment 的修改(无论 API 组或版本是什么),
始终会发送一个 apps/v1
版本的 Deployment 对象:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
matchPolicy : Equivalent
rules :
- operations : ["CREATE" ,"UPDATE" ,"DELETE" ]
apiGroups : ["apps" ]
apiVersions : ["v1" ]
resources : ["deployments" ]
scope : "Namespaced"
准入 Webhook 所用的 matchPolicy
默认为 Equivalent
。
匹配请求:matchConditions
特性状态: Kubernetes v1.27 [alpha]
说明: 使用 matchConditions
需要先在 kube-apiserver
上明确启用功能门控
AdmissionWebhookMatchConditions
,然后才能使用此功能。
如果你需要细粒度地过滤请求,你可以为 Webhook 定义匹配条件 。
如果你发现匹配规则、objectSelectors
和 namespaceSelectors
仍然不能提供你想要的何时进行 HTTP
调用的过滤条件,那么添加这些条件会很有用。
匹配条件是 CEL 表达式 。
所有匹配条件都必须为 true 才能调用 Webhook。
以下是一个例子,说明了匹配条件的几种不同用法:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
matchPolicy : Equivalent
rules :
- operations : ['CREATE' ,'UPDATE' ]
apiGroups : ['*' ]
apiVersions : ['*' ]
resources : ['*' ]
failurePolicy : 'Ignore' # 失败时继续处理请求但跳过 Webhook (可选值)
sideEffects : None
clientConfig :
service :
namespace : my-namespace
name : my-webhook
caBundle : '<omitted>'
matchConditions :
- name : 'exclude-leases' # 每个匹配条件必须有唯一的名称
expression : '!(request.resource.group == "coordination.k8s.io" && request.resource.resource == "leases")' # 匹配非租约资源
- name : 'exclude-kubelet-requests'
expression : '!("system:nodes" in request.userInfo.groups)' # 匹配非节点用户发出的请求
- name : 'rbac' # 跳过 RBAC 请求,该请求将由第二个 Webhook 处理
expression : 'request.resource.group != "rbac.authorization.k8s.io"'
# 这个示例演示了如何使用 “authorizer”。
# 授权检查比简单的表达式更复杂,因此在这个示例中,使用第二个 Webhook 来针对 RBAC 请求进行处理。
# 两个 Webhook 都可以由同一个端点提供服务。
- name : rbac.my-webhook.example.com
matchPolicy : Equivalent
rules :
- operations : ['CREATE' ,'UPDATE' ]
apiGroups : ['rbac.authorization.k8s.io' ]
apiVersions : ['*' ]
resources : ['*' ]
failurePolicy : 'Fail' # 失败时拒绝请求 (默认值)
sideEffects : None
clientConfig :
service :
namespace : my-namespace
name : my-webhook
caBundle : '<omitted>'
matchConditions :
- name : 'breakglass'
# 跳过由授权给 “breakglass” 的用户在这个 Webhook 上发起的请求。
# “breakglass” API 不需要在这个检查之外存在。
expression : '!authorizer.group("admissionregistration.k8s.io").resource("validatingwebhookconfigurations").name("my-webhook.example.com").check("breakglass").allowed()'
匹配条件可以访问以下 CEL 变量:
object
- 来自传入请求的对象。对于 DELETE 请求,该值为 null。
该对象版本可能根据 matchPolicy 进行转换。oldObject
- 现有对象。对于 CREATE 请求,该值为 null。authorizer
- 一个 CEL 鉴权组件。可用于对请求的主体(经过身份认证的用户)执行鉴权检查。
更多详细信息,请参阅 Kubernetes CEL 库文档中的
Authz 。authorizer.requestResource
- 对配置的请求资源(组、资源、(子资源)、名字空间、名称)进行授权检查的快捷方式。了解有关 CEL 表达式的更多信息,请参阅
Kubernetes 参考文档中的通用表达式语言 。
如果在对匹配条件求值时出现错误,则不会调用 Webhook。根据以下方式确定是否拒绝请求:
如果任何一个 匹配条件求值结果为 false
(不管其他错误),API 服务器将跳过 Webhook。 否则: API 服务器确定请求应发送到 Webhook 后,它需要知道如何调用 webhook。
此信息在 Webhook 配置的 clientConfig
节中指定。
Webhook 可以通过 URL 或服务引用来调用,并且可以选择包含自定义 CA 包,以用于验证 TLS 连接。
URL url
以标准 URL 形式给出 Webhook 的位置(scheme://host:port/path
)。
host
不应引用集群中运行的服务;通过指定 service
字段来使用服务引用。
主机可以通过某些 API 服务器中的外部 DNS 进行解析。
(例如,kube-apiserver
无法解析集群内 DNS,因为这将违反分层规则)。host
也可以是 IP 地址。
请注意,将 localhost
或 127.0.0.1
用作 host
是有风险的,
除非你非常小心地在所有运行 apiserver 的、可能需要对此 Webhook
进行调用的主机上运行。这样的安装方式可能不具有可移植性,即很难在新集群中启用。
scheme 必须为 "https";URL 必须以 "https://" 开头。
使用用户或基本身份验证(例如:"user:password@")是不允许的。
使用片段("#...")和查询参数("?...")也是不允许的。
这是配置为调用 URL 的修改性质的 Webhook 的示例
(并且期望使用系统信任根证书来验证 TLS 证书,因此不指定 caBundle):
apiVersion : admissionregistration.k8s.io/v1
kind : MutatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
clientConfig :
url : "https://my-webhook.example.com:9443/my-webhook-path"
服务引用 clientConfig
内部的 Service 是对该 Webhook 服务的引用。
如果 Webhook 在集群中运行,则应使用 service
而不是 url
。
服务的 namespace
和 name
是必需的。
port
是可选的,默认值为 443。path
是可选的,默认为 "/"。
这是一个 mutating Webhook 的示例,该 mutating Webhook 配置为在子路径 "/my-path" 端口
"1234" 上调用服务,并使用自定义 CA 包针对 ServerName
my-service-name.my-service-namespace.svc
验证 TLS 连接:
apiVersion : admissionregistration.k8s.io/v1
kind : MutatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
clientConfig :
caBundle : <CA_BUNDLE>
service :
namespace : my-service-namespace
name : my-service-name
path : /my-path
port : 1234
说明: 你必须在以上示例中将 <CA_BUNDLE>
替换为一个有效的 VA 证书包,
这是一个用 PEM 编码的 CA 证书包,用于校验 Webhook 的服务器证书。
副作用 Webhook 通常仅对发送给他们的 AdmissionReview
内容进行操作。
但是,某些 Webhook 在处理 admission 请求时会进行带外更改。
进行带外更改的(产生“副作用”的) Webhook 必须具有协调机制(如控制器),
该机制定期确定事物的实际状态,并调整由准入 Webhook 修改的带外数据以反映现实情况。
这是因为对准入 Webhook 的调用不能保证所准入的对象将原样保留,或根本不保留。
以后,webhook 可以修改对象的内容,在写入存储时可能会发生冲突,或者
服务器可以在持久保存对象之前关闭电源。
此外,处理 dryRun: true
admission 请求时,具有副作用的 Webhook 必须避免产生副作用。
一个 Webhook 必须明确指出在使用 dryRun
运行时不会有副作用,
否则 dry-run
请求将不会发送到该 Webhook,而 API 请求将会失败。
Webhook 使用 Webhook 配置中的 sideEffects
字段显示它们是否有副作用:
None
:调用 Webhook 没有副作用。NoneOnDryRun
:调用 Webhook 可能会有副作用,但是如果将带有 dryRun: true
属性的请求发送到 webhook,则 Webhook 将抑制副作用(该 Webhook 可识别 dryRun
)。这是一个 validating Webhook 的示例,表明它对 dryRun: true
请求没有副作用:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
sideEffects : NoneOnDryRun
超时 由于 Webhook 会增加 API 请求的延迟,因此应尽快完成自身的操作。
timeoutSeconds
用来配置在将调用视为失败之前,允许 API 服务器等待 Webhook 响应的时间长度。
如果超时在 Webhook 响应之前被触发,则基于失败策略 ,将忽略
Webhook 调用或拒绝 API 调用。
超时值必须设置在 1 到 30 秒之间。
这是一个自定义超时设置为 2 秒的 validating Webhook 的示例:
apiVersion : admissionregistration.k8s.io/v1
kind : ValidatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
timeoutSeconds : 2
准入 Webhook 所用的超时时间默认为 10 秒。
再调用策略 修改性质的准入插件(包括 Webhook)的任何一种排序方式都不会适用于所有情况。
(参见 https://issue.k8s.io/64333 示例)。
修改性质的 Webhook 可以向对象中添加新的子结构(例如向 pod
中添加 container
),
已经运行的其他修改插件可能会对这些新结构有影响
(就像在所有容器上设置 imagePullPolicy
一样)。
要允许修改性质的准入插件感应到其他插件所做的更改,
如果修改性质的 Webhook 修改了一个对象,则会重新运行内置的修改性质的准入插件,
并且修改性质的 Webhook 可以指定 reinvocationPolicy
来控制是否也重新调用它们。
可以将 reinvocationPolicy
设置为 Never
或 IfNeeded
。 默认为 Never
。
Never
: 在一次准入测试中,不得多次调用 Webhook。IfNeeded
: 如果在最初的 Webhook 调用之后被其他对象的插件修改了被接纳的对象,
则可以作为准入测试的一部分再次调用该 webhook。要注意的重要因素有:
不能保证附加调用的次数恰好是一。 如果其他调用导致对该对象的进一步修改,则不能保证再次调用 Webhook。 使用此选项的 Webhook 可能会重新排序,以最大程度地减少额外调用的次数。 要在确保所有修改都完成后验证对象,请改用验证性质的 Webhook
(推荐用于有副作用的 Webhook)。 这是一个修改性质的 Webhook 的示例,该 Webhook 在以后的准入插件修改对象时被重新调用:
apiVersion : admissionregistration.k8s.io/v1
kind : MutatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
reinvocationPolicy : IfNeeded
修改性质的 Webhook 必须具有幂等 性,并且能够成功处理
已被接纳并可能被修改的对象的修改性质的 Webhook。
对于所有修改性质的准入 Webhook 都是如此,因为它们可以在对象中进行的
任何更改可能已经存在于用户提供的对象中,但是对于选择重新调用的 Webhook
来说是必不可少的。
失败策略 failurePolicy
定义了如何处理准入 Webhook 中无法识别的错误和超时错误。允许的值为 Ignore
或 Fail
。
Ignore
表示调用 Webhook 的错误将被忽略并且允许 API 请求继续。Fail
表示调用 Webhook 的错误导致准入失败并且 API 请求被拒绝。这是一个修改性质的 webhook,配置为在调用准入 Webhook 遇到错误时拒绝 API 请求:
apiVersion : admissionregistration.k8s.io/v1
kind : MutatingWebhookConfiguration
webhooks :
- name : my-webhook.example.com
failurePolicy : Fail
准入 Webhook 所用的默认 failurePolicy
是 Fail
。
监控 Admission Webhook API 服务器提供了监视准入 Webhook 行为的方法。这些监视机制可帮助集群管理员回答以下问题:
哪个修改性质的 Webhook 改变了 API 请求中的对象? 修改性质的 Webhook 对对象做了哪些更改? 哪些 Webhook 经常拒绝 API 请求?是什么原因拒绝? Mutating Webhook 审计注解 有时,了解 API 请求中的哪个修改性质的 Webhook 使对象改变以及该 Webhook 应用了哪些更改很有用。
Kubernetes API 服务器针对每个修改性质的 Webhook 调用执行审计 操作。
每个调用都会生成一个审计注解,记述请求对象是否发生改变,
可选地还可以根据 Webhook 的准入响应生成一个注解,记述所应用的修补。
针对给定请求的给定执行阶段,注解被添加到审计事件中,
然后根据特定策略进行预处理并写入后端。
事件的审计级别决定了要记录哪些注解:
在 Metadata
或更高审计级别上,将使用 JSON 负载记录带有键名
mutation.webhook.admission.k8s.io/round_{round idx}_index_{order idx}
的注解,
该注解表示针对给定请求调用了 Webhook,以及该 Webhook 是否更改了对象。
例如,对于正在被重新调用的某 Webhook,所记录的注解如下。
Webhook 在 mutating Webhook 链中排在第三个位置,并且在调用期间未改变请求对象。
# 审计事件相关记录
{
"kind": "Event" ,
"apiVersion": "audit.k8s.io/v1" ,
"annotations": {
"mutation.webhook.admission.k8s.io/round_1_index_2": "{\"configuration\":\"my-mutating-webhook-configuration.example.com\",\"webhook\":\"my-webhook.example.com\",\"mutated\": false }"
# 其他注解
...
}
# 其他字段
...
}
# 反序列化的注解值
{
"configuration": "my-mutating-webhook-configuration.example.com" ,
"webhook": "my-webhook.example.com" ,
"mutated": false
}
对于在第一轮中调用的 Webhook,所记录的注解如下。
Webhook 在 mutating Webhook 链中排在第一位,并在调用期间改变了请求对象。
# 审计事件相关记录
{
"kind": "Event" ,
"apiVersion": "audit.k8s.io/v1" ,
"annotations": {
"mutation.webhook.admission.k8s.io/round_0_index_0": "{\"configuration\":\"my-mutating-webhook-configuration.example.com\",\"webhook\":\"my-webhook-always-mutate.example.com\",\"mutated\": true }"
# 其他注解
...
}
# 其他字段
...
}
# 反序列化的注解值
{
"configuration": "my-mutating-webhook-configuration.example.com" ,
"webhook": "my-webhook-always-mutate.example.com" ,
"mutated": true
}
在 Request
或更高审计级别上,将使用 JSON 负载记录带有键名为
patch.webhook.admission.k8s.io/round_{round idx}_index_{order idx}
的注解,
该注解表明针对给定请求调用了 Webhook 以及应用于请求对象之上的修改。
例如,以下是针对正在被重新调用的某 Webhook 所记录的注解。
Webhook 在修改性质的 Webhook 链中排在第四,并在其响应中包含一个 JSON 补丁,
该补丁已被应用于请求对象。
# 审计事件相关记录
{
"kind": "Event" ,
"apiVersion": "audit.k8s.io/v1" ,
"annotations": {
"patch.webhook.admission.k8s.io/round_1_index_3": "{\"configuration\":\"my-other-mutating-webhook-configuration.example.com\",\"webhook\":\"my-webhook-always-mutate.example.com\",\"patch\":[{\"op\":\"add\",\"path\":\"/data/mutation-stage\",\"value\":\"yes\"}],\"patchType\":\"JSONPatch\"}"
# 其他注解
...
}
# 其他字段
...
}
# 反序列化的注解值
{
"configuration": "my-other-mutating-webhook-configuration.example.com" ,
"webhook": "my-webhook-always-mutate.example.com" ,
"patchType": "JSONPatch" ,
"patch": [
{
"op": "add" ,
"path": "/data/mutation-stage" ,
"value": "yes"
}
]
}
准入 Webhook 度量值 API 服务器从 /metrics
端点公开 Prometheus 指标,这些指标可用于监控和诊断 API 服务器状态。
以下指标记录了与准入 Webhook 相关的状态。
apiserver 准入 Webhook 拒绝次数 有时,了解哪些准入 Webhook 经常拒绝 API 请求以及拒绝的原因是很有用的。
在 v1.16+ 中,kube-apiserver 提供了 Prometheus 计数器度量值,记录
准入 Webhook 的拒绝次数。
度量值的标签给出了 Webhook 拒绝该请求的原因:
name
:拒绝请求 Webhook 的名称。operation
:请求的操作类型可以是 CREATE
、UPDATE
、DELETE
和 CONNECT
其中之一。type
:Admission Webhook 类型,可以是 admit
和 validating
其中之一。error_type
:标识在 Webhook 调用期间是否发生了错误并且导致了拒绝。其值可以是以下之一:calling_webhook_error
:发生了来自准入 Webhook 的无法识别的错误或超时错误,
并且 Webhook 的 失败策略 设置为 Fail
。no_error
:未发生错误。Webhook 在准入响应中以 allowed: false
值拒绝了请求。
度量标签 rejection_code
记录了在准入响应中设置的 .status.code
。apiserver_internal_error
:apiserver 发生内部错误。rejection_code
:当 Webhook 拒绝请求时,在准入响应中设置的 HTTP 状态码。拒绝计数指标示例:
# HELP apiserver_admission_webhook_rejection_count [ALPHA] Admission webhook rejection count, identified by name and broken out for each admission type (validating or admit) and operation. Additional labels specify an error type (calling_webhook_error or apiserver_internal_error if an error occurred; no_error otherwise) and optionally a non-zero rejection code if the webhook rejects the request with an HTTP status code (honored by the apiserver when the code is greater or equal to 400). Codes greater than 600 are truncated to 600, to keep the metrics cardinality bounded.
# TYPE apiserver_admission_webhook_rejection_count counter
apiserver_admission_webhook_rejection_count{error_type="calling_webhook_error",name="always-timeout-webhook.example.com",operation="CREATE",rejection_code="0",type="validating"} 1
apiserver_admission_webhook_rejection_count{error_type="calling_webhook_error",name="invalid-admission-response-webhook.example.com",operation="CREATE",rejection_code="0",type="validating"} 1
apiserver_admission_webhook_rejection_count{error_type="no_error",name="deny-unwanted-configmap-data.example.com",operation="CREATE",rejection_code="400",type="validating"} 13
最佳实践和警告 幂等性 幂等的修改性质的准入 Webhook 能够成功处理已经被它接纳甚或修改的对象。
即使多次执行该准入测试,也不会产生与初次执行结果相异的结果。
幂等 mutating admission Webhook 的示例: 对于 CREATE
Pod 请求,将 Pod 的字段 .spec.securityContext.runAsNonRoot
设置为 true,以实施安全最佳实践。 对于 CREATE
Pod 请求,如果未设置容器的字段
.spec.containers[].resources.limits
,设置默认资源限制值。 对于 CREATE
pod 请求,如果 Pod 中不存在名为 foo-sidecar
的边车容器,
向 Pod 注入一个 foo-sidecar
容器。 在上述情况下,可以安全地重新调用 Webhook,或接受已经设置了字段的对象。
非幂等 mutating admission Webhook 的示例: 对于 CREATE
pod 请求,注入名称为 foo-sidecar
并带有当前时间戳的
边车容器(例如 foo-sidecar-19700101-000000
)。 对于 CREATE/UPDATE
pod 请求,如果容器已设置标签 "env"
则拒绝,
否则将 "env": "prod"
标签添加到容器。 对于 CREATE
pod 请求,盲目地添加一个名为 foo-sidecar
的边车容器,
而未查看 Pod 中是否已经有 foo-sidecar
容器。 在上述第一种情况下,重新调用该 Webhook 可能导致同一个 Sidecar 容器
多次注入到 Pod 中,而且每次使用不同的容器名称。
类似地,如果 Sidecar 已存在于用户提供的 Pod 中,则 Webhook 可能注入重复的容器。
在上述第二种情况下,重新调用 Webhook 将导致 Webhook 自身输出失败。
在上述第三种情况下,重新调用 Webhook 将导致 Pod 规范中的容器重复,
从而使请求无效并被 API 服务器拒绝。
拦截对象的所有版本 建议通过将 .webhooks[].matchPolicy
设置为 Equivalent
,
以确保准入 Webhooks 始终拦截对象的所有版本。
建议准入 Webhooks 应该更偏向注册资源的稳定版本。
如果无法拦截对象的所有版本,可能会导致准入策略未再某些版本的请求上执行。
有关示例,请参见匹配请求:matchPolicy 。
可用性 建议准入 Webhook 尽快完成执行(时长通常是毫秒级),因为它们会增加 API 请求的延迟。
建议对 Webhook 使用较小的超时值。有关更多详细信息,请参见超时 。
建议 Admission Webhook 应该采用某种形式的负载均衡机制,以提供高可用性和高性能。
如果集群中正在运行 Webhook,则可以在服务后面运行多个 Webhook 后端,以利用该服务支持的负载均衡。
确保看到对象的最终状态 如果某准入 Webhook 需要保证自己能够看到对象的最终状态以实施策略,
则应该使用一个验证性质的 webhook,
因为可以通过 mutating Webhook 看到对象后对其进行修改。
例如,一个修改性质的准入 Webhook 被配置为在每个 CREATE
Pod 请求中
注入一个名称为 "foo-sidecar" 的 sidecar 容器。
如果必须 存在边车容器,则还应配置一个验证性质的准入 Webhook 以拦截
CREATE
Pod 请求,并验证要创建的对象中是否存在具有预期配置的名称为
"foo-sidecar" 的容器。
避免自托管的 Webhooks 中出现死锁 如果集群内的 Webhook 配置能够拦截启动其自己的 Pod 所需的资源,
则该 Webhook 可能导致其自身部署时发生死锁。
例如,某修改性质的准入 Webhook 配置为仅当 Pod 中设置了某个标签
(例如 "env": "prod"
)时,才接受 CREATE
Pod 请求。
Webhook 服务器在未设置 "env"
标签的 Deployment 中运行。当运行 Webhook 服务器的
容器的节点运行不正常时,Webhook 部署尝试将容器重新调度到另一个节点。
但是,由于未设置 "env"
标签,因此请求将被现有的 Webhook 服务器拒绝,并且调度迁移不会发生。
建议使用 namespaceSelector 排除
Webhook 所在的名字空间。
副作用 建议准入 Webhook 应尽可能避免副作用,这意味着该准入 Webhook 仅对发送给他们的
AdmissionReview
的内容起作用,并且不要进行额外更改。
如果 Webhook 没有任何副作用,则 .webhooks[].sideEffects
字段应设置为
None
。
如果在准入执行期间存在副作用,则应在处理 dryRun
为 true
的 AdmissionReview
对象时避免产生副作用,并且其 .webhooks[].sideEffects
字段应设置为
NoneOnDryRun
。更多详细信息,请参见副作用 。
避免对 kube-system 名字空间进行操作 kube-system
名字空间包含由 Kubernetes 系统创建的对象,
例如用于控制平面组件的服务账号,诸如 kube-dns
之类的 Pod 等。
意外更改或拒绝 kube-system
名字空间中的请求可能会导致控制平面组件停止运行或者导致未知行为发生。
如果你的准入 Webhook 不想修改 Kubernetes 控制平面的行为,请使用
namespaceSelector
避免拦截 kube-system
名字空间。
3.6 - 管理服务账号 ServiceAccount 为 Pod 中运行的进程提供了一个身份。
Pod 内的进程可以使用其关联服务账号的身份,向集群的 API 服务器进行身份认证。
有关服务账号的介绍,
请参阅配置服务账号 。
本任务指南阐述有关 ServiceAccount 的几个概念。
本指南还讲解如何获取或撤销代表 ServiceAccount 的令牌。
准备开始 你必须拥有一个 Kubernetes 的集群,同时你的 Kubernetes 集群必须带有 kubectl 命令行工具。
建议在至少有两个节点的集群上运行本教程,且这些节点不作为控制平面主机。
如果你还没有集群,你可以通过 Minikube
构建一个你自己的集群,或者你可以使用下面任意一个 Kubernetes 工具构建:
为了能够准确地跟随这些步骤,确保你有一个名为 examplens
的名字空间。
如果你没有,运行以下命令创建一个名字空间:
kubectl create namespace examplens
用户账号与服务账号 Kubernetes 区分用户账号和服务账号的概念,主要基于以下原因:
用户账号是针对人而言的。而服务账号是针对运行在 Pod 中的应用进程而言的,
在 Kubernetes 中这些进程运行在容器中,而容器是 Pod 的一部分。 用户账号是全局性的。其名称在某集群中的所有名字空间中必须是唯一的。
无论你查看哪个名字空间,代表用户的特定用户名都代表着同一个用户。
在 Kubernetes 中,服务账号是名字空间作用域的。
两个不同的名字空间可以包含具有相同名称的 ServiceAccount。 通常情况下,集群的用户账号可能会从企业数据库进行同步,
创建新用户需要特殊权限,并且涉及到复杂的业务流程。
服务账号创建有意做得更轻量,允许集群用户为了具体的任务按需创建服务账号。
将 ServiceAccount 的创建与新用户注册的步骤分离开来,
使工作负载更易于遵从权限最小化原则。 对人员和服务账号审计所考虑的因素可能不同;这种分离更容易区分不同之处。 针对复杂系统的配置包可能包含系统组件相关的各种服务账号的定义。
因为服务账号的创建约束不多并且有名字空间域的名称,所以这种配置通常是轻量的。 绑定的服务账号令牌卷机制 特性状态: Kubernetes v1.22 [stable]
默认情况下,Kubernetes 控制平面(特别是 ServiceAccount 准入控制器 )
添加一个投射卷 到 Pod,
此卷包括了访问 Kubernetes API 的令牌。
以下示例演示如何查找已启动的 Pod:
...
- name : kube-api-access-<随机后缀>
projected :
sources :
- serviceAccountToken :
path : token # 必须与应用所预期的路径匹配
- configMap :
items :
- key : ca.crt
path : ca.crt
name : kube-root-ca.crt
- downwardAPI :
items :
- fieldRef :
apiVersion : v1
fieldPath : metadata.namespace
path : namespace
该清单片段定义了由三个数据源组成的投射卷。在当前场景中,每个数据源也代表该卷内的一条独立路径。这三个数据源是:
serviceAccountToken
数据源,包含 kubelet 从 kube-apiserver 获取的令牌。
kubelet 使用 TokenRequest API 获取有时间限制的令牌。为 TokenRequest 服务的这个令牌会在
Pod 被删除或定义的生命周期(默认为 1 小时)结束之后过期。该令牌绑定到特定的 Pod,
并将其 audience(受众)设置为与 kube-apiserver
的 audience 相匹配。
这种机制取代了之前基于 Secret 添加卷的机制,之前 Secret 代表了针对 Pod 的 ServiceAccount 但不会过期。configMap
数据源。ConfigMap 包含一组证书颁发机构数据。
Pod 可以使用这些证书来确保自己连接到集群的 kube-apiserver(而不是连接到中间件或意外配置错误的对等点上)。downwardAPI
数据源,用于查找包含 Pod 的名字空间的名称,
并使该名称信息可用于在 Pod 内运行的应用程序代码。Pod 内挂载这个特定卷的所有容器都可以访问上述信息。
说明: 没有特定的机制可以使通过 TokenRequest 签发的令牌无效。
如果你不再信任为某个 Pod 绑定的服务账号令牌,
你可以删除该 Pod。删除 Pod 将使其绑定的服务账号令牌过期。
手动管理 ServiceAccount 的 Secret v1.22 之前的 Kubernetes 版本会自动创建凭据访问 Kubernetes API。
这种更老的机制基于先创建令牌 Secret,然后将其挂载到正运行的 Pod 中。
在包括 Kubernetes v1.27 在内最近的几个版本中,使用
TokenRequest
API 直接获得 API 凭据,
并使用投射卷挂载到 Pod 中。使用这种方法获得的令牌具有绑定的生命周期,
当挂载的 Pod 被删除时这些令牌将自动失效。
你仍然可以手动创建
Secret 来保存服务账号令牌;例如在你需要一个永不过期的令牌的时候。
一旦你手动创建一个 Secret 并将其关联到 ServiceAccount,
Kubernetes 控制平面就会自动将令牌填充到该 Secret 中。
说明: 尽管存在手动创建长久 ServiceAccount 令牌的机制,但还是推荐使用
TokenRequest
获得短期的 API 访问令牌。
控制平面细节 ServiceAccount 控制器管理名字空间内的 ServiceAccount,
并确保每个活跃的名字空间中都存在名为 default
的 ServiceAccount。
令牌控制器 服务账号令牌控制器作为 kube-controller-manager
的一部分运行,以异步的形式工作。
其职责包括:
监测 ServiceAccount 的删除并删除所有相应的服务账号令牌 Secret。 监测服务账号令牌 Secret 的添加,保证相应的 ServiceAccount 存在,
如有需要,向 Secret 中添加令牌。 监测服务账号令牌 Secret 的删除,如有需要,从相应的 ServiceAccount 中移除引用。 你必须通过 --service-account-private-key-file
标志为
kube-controller-manager
的令牌控制器传入一个服务账号私钥文件。
该私钥用于为所生成的服务账号令牌签名。同样地,你需要通过
--service-account-key-file
标志将对应的公钥通知给
kube-apiserver。公钥用于在身份认证过程中校验令牌。
ServiceAccount 准入控制器 对 Pod 的改动通过一个被称为准入控制器 的插件来实现。
它是 API 服务器的一部分。当 Pod 被创建时,该准入控制器会同步地修改 Pod。
如果该插件处于激活状态(在大多数发行版中都是默认激活的),当 Pod 被创建时它会进行以下操作:
如果该 Pod 没有设置 .spec.serviceAccountName
,
准入控制器为新来的 Pod 将 ServiceAccount 的名称设为 default
。 准入控制器保证新来的 Pod 所引用的 ServiceAccount 确实存在。
如果没有 ServiceAccount 具有匹配的名称,则准入控制器拒绝新来的 Pod。
这个检查甚至适用于 default
ServiceAccount。 如果服务账号的 automountServiceAccountToken
字段或 Pod 的
automountServiceAccountToken
字段都未显式设置为 false
:准入控制器变更新来的 Pod,添加一个包含 API
访问令牌的额外卷 。 准入控制器将 volumeMount
添加到 Pod 中的每个容器,
忽略已为 /var/run/secrets/kubernetes.io/serviceaccount
路径定义的卷挂载的所有容器。
对于 Linux 容器,此卷挂载在 /var/run/secrets/kubernetes.io/serviceaccount
;
在 Windows 节点上,此卷挂载在等价的路径上。 如果新来 Pod 的规约不包含任何 imagePullSecrets
,则准入控制器添加 imagePullSecrets
,
并从 ServiceAccount
进行复制。 TokenRequest API 特性状态: Kubernetes v1.22 [stable]
你使用 ServiceAccount 的
TokenRequest
子资源为该 ServiceAccount 获取有时间限制的令牌。
你不需要调用它来获取在容器中使用的 API 令牌,
因为 kubelet 使用投射卷 对此进行了设置。
如果你想要从 kubectl
使用 TokenRequest API,
请参阅为 ServiceAccount 手动创建 API 令牌 。
Kubernetes 控制平面(特别是 ServiceAccount 准入控制器)向 Pod 添加了一个投射卷,
kubelet 确保该卷包含允许容器作为正确 ServiceAccount 进行身份认证的令牌。
(这种机制取代了之前基于 Secret 添加卷的机制,之前 Secret 代表了 Pod 所用的 ServiceAccount 但不会过期。)
以下示例演示如何查找已启动的 Pod:
...
- name : kube-api-access-<random-suffix>
projected :
defaultMode : 420 # 这个十进制数等同于八进制 0644
sources :
- serviceAccountToken :
expirationSeconds : 3607
path : token
- configMap :
items :
- key : ca.crt
path : ca.crt
name : kube-root-ca.crt
- downwardAPI :
items :
- fieldRef :
apiVersion : v1
fieldPath : metadata.namespace
path : namespace
该清单片段定义了由三个数据源信息组成的投射卷。
serviceAccountToken
数据源,包含 kubelet 从 kube-apiserver 获取的令牌。
kubelet 使用 TokenRequest API 获取有时间限制的令牌。为 TokenRequest 服务的这个令牌会在
Pod 被删除或定义的生命周期(默认为 1 小时)结束之后过期。该令牌绑定到特定的 Pod,
并将其 audience(受众)设置为与 kube-apiserver
的 audience 相匹配。configMap
数据源。ConfigMap 包含一组证书颁发机构数据。
Pod 可以使用这些证书来确保自己连接到集群的 kube-apiserver(而不是连接到中间件或意外配置错误的对等点上)。downwardAPI
数据源。这个 downwardAPI
卷获得包含 Pod 的名字空间的名称,
并使该名称信息可用于在 Pod 内运行的应用程序代码。挂载此卷的 Pod 内的所有容器均可以访问上述信息。
创建额外的 API 令牌 注意: 只有令牌请求 机制不合适,才需要创建长久的 API 令牌。
令牌请求机制提供有时间限制的令牌;因为随着这些令牌过期,它们对信息安全方面的风险也会降低。
要为 ServiceAccount 创建一个不过期、持久化的 API 令牌,
请创建一个类型为 kubernetes.io/service-account-token
的 Secret,
附带引用 ServiceAccount 的注解。控制平面随后生成一个长久的令牌,
并使用生成的令牌数据更新该 Secret。
以下是此类 Secret 的示例清单:
apiVersion : v1
kind : Secret
type : kubernetes.io/service-account-token
metadata :
name : mysecretname
annotations :
kubernetes.io/service-account.name : myserviceaccount
若要基于此示例创建 Secret,运行以下命令:
kubectl -n examplens create -f https://k8s.io/examples/secret/serviceaccount/mysecretname.yaml
若要查看该 Secret 的详细信息,运行以下命令:
kubectl -n examplens describe secret mysecretname
输出类似于:
Name: mysecretname
Namespace: examplens
Labels: <none>
Annotations: kubernetes.io/service-account.name=myserviceaccount
kubernetes.io/service-account.uid=8a85c4c4-8483-11e9-bc42-526af7764f64
Type: kubernetes.io/service-account-token
Data
====
ca.crt: 1362 bytes
namespace: 9 bytes
token: ...
如果你在 examplens
名字空间中启动一个新的 Pod,它可以使用你刚刚创建的
myserviceaccount
service-account-token Secret。
删除/废止 ServiceAccount 令牌 如果你知道 Secret 的名称且该 Secret 包含要移除的令牌:
kubectl delete secret name-of-secret
否则,先找到 ServiceAccount 所用的 Secret。
# 此处假设你已有一个名为 'examplens' 的名字空间
kubectl -n examplens get serviceaccount/example-automated-thing -o yaml
输出类似于:
apiVersion : v1
kind : ServiceAccount
metadata :
annotations :
kubectl.kubernetes.io/last-applied-configuration : |
{"apiVersion":"v1","kind":"ServiceAccount","metadata":{"annotations":{},"name":"example-automated-thing","namespace":"examplens"}}
creationTimestamp : "2019-07-21T07:07:07Z"
name : example-automated-thing
namespace : examplens
resourceVersion : "777"
selfLink : /api/v1/namespaces/examplens/serviceaccounts/example-automated-thing
uid : f23fd170-66f2-4697-b049-e1e266b7f835
secrets :
- name : example-automated-thing-token-zyxwv
随后删除你现在知道名称的 Secret:
kubectl -n examplens delete secret/example-automated-thing-token-zyxwv
控制平面发现 ServiceAccount 缺少其 Secret,并创建一个替代项:
kubectl -n examplens get serviceaccount/example-automated-thing -o yaml
apiVersion : v1
kind : ServiceAccount
metadata :
annotations :
kubectl.kubernetes.io/last-applied-configuration : |
{"apiVersion":"v1","kind":"ServiceAccount","metadata":{"annotations":{},"name":"example-automated-thing","namespace":"examplens"}}
creationTimestamp : "2019-07-21T07:07:07Z"
name : example-automated-thing
namespace : examplens
resourceVersion : "1026"
selfLink : /api/v1/namespaces/examplens/serviceaccounts/example-automated-thing
uid : f23fd170-66f2-4697-b049-e1e266b7f835
secrets :
- name : example-automated-thing-token-4rdrh
清理 如果创建了一个 examplens
名字空间进行试验,你可以移除它:
kubectl delete namespace examplens
接下来 3.7 - 鉴权概述 了解有关 Kubernetes 鉴权的更多信息,包括使用支持的鉴权模块创建策略的详细信息。
在 Kubernetes 中,你必须在鉴权(授予访问权限)之前进行身份验证(登录),有关身份验证的信息,
请参阅访问控制概述 .
Kubernetes 期望请求中存在 REST API 常见的属性。
这意味着 Kubernetes 鉴权适用于现有的组织范围或云提供商范围的访问控制系统,
除了 Kubernetes API 之外,它还可以处理其他 API。
确定是允许还是拒绝请求 Kubernetes 使用 API 服务器对 API 请求进行鉴权。
它根据所有策略评估所有请求属性来决定允许或拒绝请求。
一个 API 请求的所有部分都必须被某些策略允许才能继续。
这意味着默认情况下拒绝权限。
(尽管 Kubernetes 使用 API 服务器,但是依赖于特定对象种类的特定字段的访问控制
和策略由准入控制器处理。)
当系统配置了多个鉴权模块时,Kubernetes 将按顺序使用每个模块。
如果任何鉴权模块批准或拒绝请求,则立即返回该决定,并且不会与其他鉴权模块协商。
如果所有模块对请求没有意见,则拒绝该请求。
被拒绝响应返回 HTTP 状态代码 403。
审查你的请求属性 Kubernetes 仅审查以下 API 请求属性:
用户 —— 身份验证期间提供的 user
字符串。组 —— 经过身份验证的用户所属的组名列表。额外信息 —— 由身份验证层提供的任意字符串键到字符串值的映射。API —— 指示请求是否针对 API 资源。请求路径 —— 各种非资源端点的路径,如 /api
或 /healthz
。API 请求动词 —— API 动词 get
、list
、create
、update
、patch
、watch
、
proxy
、redirect
、delete
和 deletecollection
用于资源请求。
要确定资源 API 端点的请求动词,请参阅确定请求动词 。HTTP 请求动词 —— HTTP 动词 get
、post
、put
和 delete
用于非资源请求。资源 —— 正在访问的资源的 ID 或名称(仅限资源请求)-
对于使用 get
、update
、patch
和 delete
动词的资源请求,你必须提供资源名称。子资源 —— 正在访问的子资源(仅限资源请求)。名字空间 —— 正在访问的对象的名称空间(仅适用于名字空间资源请求)。API 组 —— 正在访问的 API 组
(仅限资源请求)。空字符串表示核心 API 组 。确定请求动词 非资源请求
对于 /api/v1/...
或 /apis/<group>/<version>/...
之外的端点的请求被视为 “非资源请求(Non-Resource Requests)”,
并使用该请求的 HTTP 方法的小写形式作为其请求动词。
例如,对 /api
或 /healthz
这类端点的 GET
请求将使用 get
作为其动词。
资源请求
要确定对资源 API 端点的请求动词,需要查看所使用的 HTTP 动词以及该请求是针对单个资源还是一组资源:
HTTP 动词 请求动词 POST create GET, HEAD get (针对单个资源)、list(针对集合) PUT update PATCH patch DELETE delete(针对单个资源)、deletecollection(针对集合)
注意: get
、list
和 watch
动作都可以返回一个资源的完整详细信息。就返回的数据而言,它们是等价的。
例如,对 secrets
使用 list
仍然会显示所有已返回资源的 data
属性。
Kubernetes 有时使用专门的动词以对额外的权限进行鉴权。例如:
RBAC 对 rbac.authorization.k8s.io
API 组中 roles
和 clusterroles
资源的 bind
和 escalate
动词 身份认证 对核心 API 组中 users
、groups
和 serviceaccounts
以及 authentication.k8s.io
API 组中的 userextras
所使用的 impersonate
动词。 鉴权模块 Node —— 一个专用鉴权模式,根据调度到 kubelet 上运行的 Pod 为 kubelet 授予权限。
要了解有关使用节点鉴权模式的更多信息,请参阅节点鉴权 。ABAC —— 基于属性的访问控制(ABAC)定义了一种访问控制范型,通过使用将属性组合在一起的策略,
将访问权限授予用户。策略可以使用任何类型的属性(用户属性、资源属性、对象,环境属性等)。
要了解有关使用 ABAC 模式的更多信息,请参阅
ABAC 模式 。RBAC —— 基于角色的访问控制(RBAC)
是一种基于企业内个人用户的角色来管理对计算机或网络资源的访问的方法。
在此上下文中,权限是单个用户执行特定任务的能力,
例如查看、创建或修改文件。要了解有关使用 RBAC 模式的更多信息,请参阅
RBAC 模式 。被启用之后,RBAC(基于角色的访问控制)使用 rbac.authorization.k8s.io
API
组来驱动鉴权决策,从而允许管理员通过 Kubernetes API 动态配置权限策略。 要启用 RBAC,请使用 --authorization-mode = RBAC
启动 API 服务器。 Webhook —— WebHook 是一个 HTTP 回调:发生某些事情时调用的 HTTP POST;
通过 HTTP POST 进行简单的事件通知。
实现 WebHook 的 Web 应用程序会在发生某些事情时将消息发布到 URL。
要了解有关使用 Webhook 模式的更多信息,请参阅
Webhook 模式 。检查 API 访问 kubectl
提供 auth can-i
子命令,用于快速查询 API 鉴权。
该命令使用 SelfSubjectAccessReview
API 来确定当前用户是否可以执行给定操作,
无论使用何种鉴权模式该命令都可以工作。
kubectl auth can-i create deployments --namespace dev
输出类似于:
yes
kubectl auth can-i create deployments --namespace prod
输出类似于:
no
管理员可以将此与用户扮演(User Impersonation)
结合使用,以确定其他用户可以执行的操作。
kubectl auth can-i list secrets --namespace dev --as dave
输出类似于:
no
类似地,检查名字空间 dev
里的 dev-sa
服务账户是否可以列举名字空间 target
里的 Pod:
kubectl auth can-i list pods \
--namespace target \
--as system:serviceaccount:dev:dev-sa
输出类似于:
yes
SelfSubjectAccessReview
是 authorization.k8s.io
API 组的一部分,它将 API
服务器鉴权公开给外部服务。该组中的其他资源包括:
SubjectAccessReview
- 对任意用户的访问进行评估,而不仅仅是当前用户。
当鉴权决策被委派给 API 服务器时很有用。例如,kubelet 和扩展 API
服务器使用它来确定用户对自己的 API 的访问权限。LocalSubjectAccessReview
- 与 SubjectAccessReview
类似,但仅限于特定的名字空间。SelfSubjectRulesReview
- 返回用户可在名字空间内执行的操作集的审阅。
用户可以快速汇总自己的访问权限,或者用于 UI 中的隐藏/显示动作。可以通过创建普通的 Kubernetes 资源来查询这些 API,其中返回对象的响应 "status"
字段是查询的结果。
kubectl create -f - -o yaml << EOF
apiVersion: authorization.k8s.io/v1
kind: SelfSubjectAccessReview
spec:
resourceAttributes:
group: apps
name: deployments
verb: create
namespace: dev
EOF
生成的 SelfSubjectAccessReview
为:
apiVersion : authorization.k8s.io/v1
kind : SelfSubjectAccessReview
metadata :
creationTimestamp : null
spec :
resourceAttributes :
group : apps
name : deployments
namespace : dev
verb : create
status :
allowed : true
denied : false
为你的鉴权模块设置参数 你必须在策略中包含一个参数标志,以指明你的策略包含哪个鉴权模块:
可以使用的参数有:
--authorization-mode=ABAC
基于属性的访问控制(ABAC)模式允许你使用本地文件配置策略。--authorization-mode=RBAC
基于角色的访问控制(RBAC)模式允许你使用
Kubernetes API 创建和存储策略。--authorization-mode=Webhook
WebHook 是一种 HTTP 回调模式,允许你使用远程
REST 端点管理鉴权。--authorization-mode=Node
节点鉴权是一种特殊用途的鉴权模式,专门对
kubelet 发出的 API 请求执行鉴权。--authorization-mode=AlwaysDeny
该标志阻止所有请求。仅将此标志用于测试。--authorization-mode=AlwaysAllow
此标志允许所有请求。仅在你不需要 API 请求的鉴权时才使用此标志。你可以选择多个鉴权模块。模块按顺序检查,以便较靠前的模块具有更高的优先级来允许或拒绝请求。
通过创建或编辑工作负载提升权限 能够在名字空间中创建或者编辑 Pod 的用户,
无论是直接操作还是通过控制器
(例如,一个 Operator)来操作,都可以提升他们在该名字空间内的权限。
注意: 系统管理员在授予对工作负载的创建或编辑的权限时要小心。
关于这些权限如何被误用的详细信息请参阅
提升途径
特权提升途径 挂载该名字空间内的任意 Secret可以用来访问其他工作负载专用的 Secret 可以用来获取权限更高的服务账号的令牌 使用该名字空间内的任意服务账号可以用另一个工作负载的身份来访问 Kubernetes API(伪装) 可以执行该服务账号的任意特权操作 挂载该名字空间里其他工作负载专用的 ConfigMap可以用来获取其他工作负载专用的信息,例如数据库主机名。 挂载该名字空间里其他工作负载的卷 注意: 系统管理员在部署改变以上部分的 CRD 的时候要小心。
它们可能会打开权限提升的途径。
在决定你的 RBAC 控制时应该考虑这方面的问题。
接下来 3.8 - 使用 RBAC 鉴权 基于角色(Role)的访问控制(RBAC)是一种基于组织中用户的角色来调节控制对计算机或网络资源的访问的方法。
RBAC 鉴权机制使用 rbac.authorization.k8s.io
API 组 来驱动鉴权决定,
允许你通过 Kubernetes API 动态配置策略。
要启用 RBAC,在启动 API 服务器 时将
--authorization-mode
参数设置为一个逗号分隔的列表并确保其中包含 RBAC
。
kube-apiserver --authorization-mode= Example,RBAC --<其他选项> --<其他选项>
API 对象 RBAC API 声明了四种 Kubernetes 对象:Role 、ClusterRole 、RoleBinding 和
ClusterRoleBinding 。你可以像使用其他 Kubernetes 对象一样,通过类似 kubectl
这类工具描述对象 ,
或修补对象。
注意: 这些对象在设计时即实施了一些访问限制。如果你在学习过程中对集群做了更改,
请参考避免特权提升和引导 一节,
以了解这些限制会以怎样的方式阻止你做出修改。
Role 和 ClusterRole RBAC 的 Role 或 ClusterRole 中包含一组代表相关权限的规则。
这些权限是纯粹累加的(不存在拒绝某操作的规则)。
Role 总是用来在某个名字空间 内设置访问权限;
在你创建 Role 时,你必须指定该 Role 所属的名字空间。
与之相对,ClusterRole 则是一个集群作用域的资源。这两种资源的名字不同(Role 和 ClusterRole)
是因为 Kubernetes 对象要么是名字空间作用域的,要么是集群作用域的,不可两者兼具。
ClusterRole 有若干用法。你可以用它来:
定义对某名字空间域对象的访问权限,并将在个别名字空间内被授予访问权限; 为名字空间作用域的对象设置访问权限,并被授予跨所有名字空间的访问权限; 为集群作用域的资源定义访问权限。 如果你希望在名字空间内定义角色,应该使用 Role;
如果你希望定义集群范围的角色,应该使用 ClusterRole。
Role 示例 下面是一个位于 "default" 名字空间的 Role 的示例,可用来授予对
Pod 的读访问权限:
apiVersion : rbac.authorization.k8s.io/v1
kind : Role
metadata :
namespace : default
name : pod-reader
rules :
- apiGroups : ["" ] # "" 标明 core API 组
resources : ["pods" ]
verbs : ["get" , "watch" , "list" ]
ClusterRole 示例 ClusterRole 同样可以用于授予 Role 能够授予的权限。
因为 ClusterRole 属于集群范围,所以它也可以为以下资源授予访问权限:
下面是一个 ClusterRole 的示例,可用来为任一特定名字空间中的
Secret 授予读访问权限,
或者跨名字空间的访问权限(取决于该角色是如何绑定 的):
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
# "namespace" 被忽略,因为 ClusterRoles 不受名字空间限制
name : secret-reader
rules :
- apiGroups : ["" ]
# 在 HTTP 层面,用来访问 Secret 资源的名称为 "secrets"
resources : ["secrets" ]
verbs : ["get" , "watch" , "list" ]
Role 或 ClusterRole 对象的名称必须是合法的路径分段名称 。
RoleBinding 和 ClusterRoleBinding 角色绑定(Role Binding)是将角色中定义的权限赋予一个或者一组用户。
它包含若干 主体 (用户、组或服务账户)的列表和对这些主体所获得的角色的引用。
RoleBinding 在指定的名字空间中执行授权,而 ClusterRoleBinding 在集群范围执行授权。
一个 RoleBinding 可以引用同一的名字空间中的任何 Role。
或者,一个 RoleBinding 可以引用某 ClusterRole 并将该 ClusterRole 绑定到
RoleBinding 所在的名字空间。
如果你希望将某 ClusterRole 绑定到集群中所有名字空间,你要使用 ClusterRoleBinding。
RoleBinding 或 ClusterRoleBinding 对象的名称必须是合法的
路径分段名称 。
RoleBinding 示例 下面的例子中的 RoleBinding 将 "pod-reader" Role 授予在 "default" 名字空间中的用户 "jane"。
这样,用户 "jane" 就具有了读取 "default" 名字空间中所有 Pod 的权限。
apiVersion : rbac.authorization.k8s.io/v1
# 此角色绑定允许 "jane" 读取 "default" 名字空间中的 Pod
# 你需要在该命名空间中有一个名为 “pod-reader” 的 Role
kind : RoleBinding
metadata :
name : read-pods
namespace : default
subjects :
# 你可以指定不止一个“subject(主体)”
- kind : User
name : jane # "name" 是区分大小写的
apiGroup : rbac.authorization.k8s.io
roleRef :
# "roleRef" 指定与某 Role 或 ClusterRole 的绑定关系
kind : Role # 此字段必须是 Role 或 ClusterRole
name : pod-reader # 此字段必须与你要绑定的 Role 或 ClusterRole 的名称匹配
apiGroup : rbac.authorization.k8s.io
RoleBinding 也可以引用 ClusterRole,以将对应 ClusterRole 中定义的访问权限授予
RoleBinding 所在名字空间的资源。这种引用使得你可以跨整个集群定义一组通用的角色,
之后在多个名字空间中复用。
例如,尽管下面的 RoleBinding 引用的是一个 ClusterRole,"dave"(这里的主体,
区分大小写)只能访问 "development" 名字空间中的 Secrets 对象,因为 RoleBinding
所在的名字空间(由其 metadata 决定)是 "development"。
apiVersion : rbac.authorization.k8s.io/v1
# 此角色绑定使得用户 "dave" 能够读取 "development" 名字空间中的 Secrets
# 你需要一个名为 "secret-reader" 的 ClusterRole
kind : RoleBinding
metadata :
name : read-secrets
# RoleBinding 的名字空间决定了访问权限的授予范围。
# 这里隐含授权仅在 "development" 名字空间内的访问权限。
namespace : development
subjects :
- kind : User
name : dave # 'name' 是区分大小写的
apiGroup : rbac.authorization.k8s.io
roleRef :
kind : ClusterRole
name : secret-reader
apiGroup : rbac.authorization.k8s.io
ClusterRoleBinding 示例 要跨整个集群完成访问权限的授予,你可以使用一个 ClusterRoleBinding。
下面的 ClusterRoleBinding 允许 "manager" 组内的所有用户访问任何名字空间中的 Secret。
apiVersion : rbac.authorization.k8s.io/v1
# 此集群角色绑定允许 “manager” 组中的任何人访问任何名字空间中的 Secret 资源
kind : ClusterRoleBinding
metadata :
name : read-secrets-global
subjects :
- kind : Group
name : manager # 'name' 是区分大小写的
apiGroup : rbac.authorization.k8s.io
roleRef :
kind : ClusterRole
name : secret-reader
apiGroup : rbac.authorization.k8s.io
创建了绑定之后,你不能再修改绑定对象所引用的 Role 或 ClusterRole。
试图改变绑定对象的 roleRef
将导致合法性检查错误。
如果你想要改变现有绑定对象中 roleRef
字段的内容,必须删除重新创建绑定对象。
这种限制有两个主要原因:
将 roleRef
设置为不可以改变,这使得可以为用户授予对现有绑定对象的 update
权限,
这样可以让他们管理主体列表,同时不能更改被授予这些主体的角色。 针对不同角色的绑定是完全不一样的绑定。要求通过删除/重建绑定来更改 roleRef
,
这样可以确保要赋予绑定的所有主体会被授予新的角色(而不是在允许或者不小心修改了
roleRef
的情况下导致所有现有主体未经验证即被授予新角色对应的权限)。 命令 kubectl auth reconcile
可以创建或者更新包含 RBAC 对象的清单文件,
并且在必要的情况下删除和重新创建绑定对象,以改变所引用的角色。
更多相关信息请参照命令用法和示例 。
对资源的引用 在 Kubernetes API 中,大多数资源都是使用对象名称的字符串表示来呈现与访问的。
例如,对于 Pod 应使用 "pods"。
RBAC 使用对应 API 端点的 URL 中呈现的名字来引用资源。
有一些 Kubernetes API 涉及 子资源(subresource) ,例如 Pod 的日志。
对 Pod 日志的请求看起来像这样:
GET /api/v1/namespaces/{namespace}/pods/{name}/log
在这里,pods
对应名字空间作用域的 Pod 资源,而 log
是 pods
的子资源。
在 RBAC 角色表达子资源时,使用斜线(/
)来分隔资源和子资源。
要允许某主体读取 pods
同时访问这些 Pod 的 log
子资源,你可以这样写:
apiVersion : rbac.authorization.k8s.io/v1
kind : Role
metadata :
namespace : default
name : pod-and-pod-logs-reader
rules :
- apiGroups : ["" ]
resources : ["pods" , "pods/log" ]
verbs : ["get" , "list" ]
对于某些请求,也可以通过 resourceNames
列表按名称引用资源。
在指定时,可以将请求限定为资源的单个实例。
下面的例子中限制可以 get
和 update
一个名为 my-configmap
的
ConfigMap :
apiVersion : rbac.authorization.k8s.io/v1
kind : Role
metadata :
namespace : default
name : configmap-updater
rules :
- apiGroups : ["" ]
# 在 HTTP 层面,用来访问 ConfigMap 资源的名称为 "configmaps"
resources : ["configmaps" ]
resourceNames : ["my-configmap" ]
verbs : ["update" , "get" ]
说明: 你不能使用资源名字来限制 create
或者 deletecollection
请求。
对于 create
请求而言,这是因为在鉴权时可能还不知道新对象的名字。
如果你使用 resourceName
来限制 list
或者 watch
请求,
客户端必须在它们的 list
或者 watch
请求里包含一个与指定的 resourceName
匹配的 metadata.name
字段选择器。
例如,kubectl get configmaps --field-selector=metadata.name=my-configmap
你可愈使用通配符 *
可以批量引用所有的 resources
、apiGroups
和 verbs
对象, 无需逐一引用。
对于 nonResourceURLs
,你可以将通配符 *
作为后缀实现全局通配,
对于 resourceNames
,空集表示没有任何限制。
下面的示例对 example.com
API 组中所有当前和未来资源执行所有动作。
这类似于内置的 cluster-admin
。
apiVersion : rbac.authorization.k8s.io/v1
kind : Role
metadata :
namespace : default
name : example.com-superuser # 此角色仅作示范,请勿使用
rules :
- apiGroups : ["example.com" ]
resources : ["*" ]
verbs : ["*" ]
注意: 在 resources 和 verbs 条目中使用通配符会为敏感资源授予过多的访问权限。
例如,如果添加了新的资源类型、新的子资源或新的自定义动词,
通配符条目会自动授予访问权限,用户可能不希望出现这种情况。
应该执行最小特权原则 ,
使用具体的 resources 和 verbs 确保仅赋予工作负载正常运行所需的权限。
聚合的 ClusterRole 你可以将若干 ClusterRole 聚合(Aggregate) 起来,形成一个复合的 ClusterRole。
作为集群控制面的一部分,控制器会监视带有 aggregationRule
的 ClusterRole 对象集合。aggregationRule
为控制器定义一个标签选择算符 供后者匹配应该组合到当前
ClusterRole 的 roles
字段中的 ClusterRole 对象。
注意: 控制平面会覆盖你在聚合 ClusterRole 的 rules
字段中手动指定的所有值。
如果你想更改或添加规则,请在被 aggregationRule
所选中的 ClusterRole
对象上执行变更。
下面是一个聚合 ClusterRole 的示例:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : monitoring
aggregationRule :
clusterRoleSelectors :
- matchLabels :
rbac.example.com/aggregate-to-monitoring : "true"
rules : [] # 控制面自动填充这里的规则
如果你创建一个与某个已存在的聚合 ClusterRole 的标签选择算符匹配的 ClusterRole,
这一变化会触发新的规则被添加到聚合 ClusterRole 的操作。
下面的例子中,通过创建一个标签同样为 rbac.example.com/aggregate-to-monitoring: true
的 ClusterRole,新的规则可被添加到 "monitoring" ClusterRole 中。
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : monitoring-endpoints
labels :
rbac.example.com/aggregate-to-monitoring : "true"
# 当你创建 "monitoring-endpoints" ClusterRole 时,
# 下面的规则会被添加到 "monitoring" ClusterRole 中
rules :
- apiGroups : ["" ]
resources : ["services" , "endpointslices" , "pods" ]
verbs : ["get" , "list" , "watch" ]
默认的面向用户的角色 使用 ClusterRole 聚合。
这使得作为集群管理员的你可以为扩展默认规则,包括为定制资源设置规则,
比如通过 CustomResourceDefinitions 或聚合 API 服务器提供的定制资源。
例如,下面的 ClusterRoles 让默认角色 "admin" 和 "edit" 拥有管理自定义资源 "CronTabs" 的权限,
"view" 角色对 CronTab 资源拥有读操作权限。
你可以假定 CronTab 对象在 API 服务器所看到的 URL 中被命名为 "crontabs"
。
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : aggregate-cron-tabs-edit
labels :
# 添加以下权限到默认角色 "admin" 和 "edit" 中
rbac.authorization.k8s.io/aggregate-to-admin : "true"
rbac.authorization.k8s.io/aggregate-to-edit : "true"
rules :
- apiGroups : ["stable.example.com" ]
resources : ["crontabs" ]
verbs : ["get" , "list" , "watch" , "create" , "update" , "patch" , "delete" ]
---
kind : ClusterRole
apiVersion : rbac.authorization.k8s.io/v1
metadata :
name : aggregate-cron-tabs-view
labels :
# 添加以下权限到 "view" 默认角色中
rbac.authorization.k8s.io/aggregate-to-view : "true"
rules :
- apiGroups : ["stable.example.com" ]
resources : ["crontabs" ]
verbs : ["get" , "list" , "watch" ]
Role 示例 以下示例均为从 Role 或 ClusterRole 对象中截取出来,我们仅展示其 rules
部分。
允许读取在核心 API 组 下的 "pods"
:
rules :
- apiGroups : ["" ]
# 在 HTTP 层面,用来访问 Pod 资源的名称为 "pods"
resources : ["pods" ]
verbs : ["get" , "list" , "watch" ]
允许在 "apps"
API 组中读/写 Deployment(在 HTTP 层面,对应 URL
中资源部分为 "deployments"
):
rules :
- apiGroups : ["apps" ]
#
# 在 HTTP 层面,用来访问 Deployment 资源的名称为 "deployments"
resources : ["deployments" ]
verbs : ["get" , "list" , "watch" , "create" , "update" , "patch" , "delete" ]
允许读取核心 API 组中的 Pod 和读/写 "batch"
API 组中的 Job 资源:
rules :
- apiGroups : ["" ]
# 在 HTTP 层面,用来访问 Pod 资源的名称为 "pods"
resources : ["pods" ]
verbs : ["get" , "list" , "watch" ]
- apiGroups : ["batch" ]
# 在 HTTP 层面,用来访问 Job 资源的名称为 "jobs"
resources : ["jobs" ]
verbs : ["get" , "list" , "watch" , "create" , "update" , "patch" , "delete" ]
允许读取名称为 "my-config" 的 ConfigMap(需要通过 RoleBinding
绑定以限制为某名字空间中特定的 ConfigMap):
rules :
- apiGroups : ["" ]
# 在 HTTP 层面,用来访问 ConfigMap 资源的名称为 "configmaps"
resources : ["configmaps" ]
resourceNames : ["my-config" ]
verbs : ["get" ]
允许读取在核心组中的 "nodes"
资源(因为 Node
是集群作用域的,所以需要
ClusterRole 绑定到 ClusterRoleBinding 才生效):
rules :
- apiGroups : ["" ]
# 在 HTTP 层面,用来访问 Node 资源的名称为 "nodes"
resources : ["nodes" ]
verbs : ["get" , "list" , "watch" ]
允许针对非资源端点 /healthz
和其子路径上发起 GET 和 POST 请求
(必须在 ClusterRole 绑定 ClusterRoleBinding 才生效):
rules :
- nonResourceURLs : ["/healthz" , "/healthz/*" ] # nonResourceURL 中的 '*' 是一个全局通配符
verbs : ["get" , "post" ]
对主体的引用 RoleBinding 或者 ClusterRoleBinding 可绑定角色到某 主体(Subject) 上。
主体可以是组,用户或者服务账户 。
Kubernetes 用字符串来表示用户名。
用户名可以是普通的用户名,像 "alice";或者是邮件风格的名称,如 "bob@example.com",
或者是以字符串形式表达的数字 ID。你作为 Kubernetes
管理员负责配置身份认证模块 ,
以便后者能够生成你所期望的格式的用户名。
注意: 前缀 system:
是 Kubernetes 系统保留的,所以你要确保所配置的用户名或者组名不能出现上述
system:
前缀。除了对前缀的限制之外,RBAC 鉴权系统不对用户名格式作任何要求。
在 Kubernetes 中,身份认证(Authenticator)模块提供用户组信息。
与用户名一样,用户组名也用字符串来表示,而且对该字符串没有格式要求,
只是不能使用保留的前缀 system:
。
服务账户(ServiceAccount)
的用户名前缀为 system:serviceaccount:
,属于前缀为 system:serviceaccounts:
的用户组。
说明: system:serviceaccount:
(单数)是用于服务账户用户名的前缀;system:serviceaccounts:
(复数)是用于服务账户组名的前缀。RoleBinding 示例 下面示例是 RoleBinding
中的片段,仅展示其 subjects
的部分。
对于名称为 alice@example.com
的用户:
subjects :
- kind : User
name : "alice@example.com"
apiGroup : rbac.authorization.k8s.io
对于名称为 frontend-admins
的用户组:
subjects :
- kind : Group
name : "frontend-admins"
apiGroup : rbac.authorization.k8s.io
对于 kube-system
名字空间中的默认服务账户:
subjects :
- kind : ServiceAccount
name : default
namespace : kube-system
对于 "qa" 名称空间中的所有服务账户:
subjects :
- kind : Group
name : system:serviceaccounts:qa
apiGroup : rbac.authorization.k8s.io
对于在任何名字空间中的服务账户:
subjects :
- kind : Group
name : system:serviceaccounts
apiGroup : rbac.authorization.k8s.io
对于所有已经过身份认证的用户:
subjects :
- kind : Group
name : system:authenticated
apiGroup : rbac.authorization.k8s.io
对于所有未通过身份认证的用户:
subjects :
- kind : Group
name : system:unauthenticated
apiGroup : rbac.authorization.k8s.io
对于所有用户:
subjects :
- kind : Group
name : system:authenticated
apiGroup : rbac.authorization.k8s.io
- kind : Group
name : system:unauthenticated
apiGroup : rbac.authorization.k8s.io
默认 Roles 和 Role Bindings API 服务器创建一组默认的 ClusterRole 和 ClusterRoleBinding 对象。
这其中许多是以 system:
为前缀的,用以标识对应资源是直接由集群控制面管理的。
所有的默认 ClusterRole 和 ClusterRoleBinding 都有
kubernetes.io/bootstrapping=rbac-defaults
标签。
注意: 在修改名称包含 system:
前缀的 ClusterRole 和 ClusterRoleBinding
时要格外小心。
对这些资源的更改可能导致集群无法正常运作。
自动协商 在每次启动时,API 服务器都会更新默认 ClusterRole 以添加缺失的各种权限,
并更新默认的 ClusterRoleBinding 以增加缺失的各类主体。
这种自动协商机制允许集群去修复一些不小心发生的修改,
并且有助于保证角色和角色绑定在新的发行版本中有权限或主体变更时仍然保持最新。
如果要禁止此功能,请将默认 ClusterRole 以及 ClusterRoleBinding 的
rbac.authorization.kubernetes.io/autoupdate
注解设置成 false
。
注意,缺少默认权限和角色绑定主体可能会导致集群无法正常工作。
如果基于 RBAC 的鉴权机制被启用,则自动协商功能默认是被启用的。
API 发现角色 无论是经过身份验证的还是未经过身份验证的用户,
默认的角色绑定都授权他们读取被认为是可安全地公开访问的 API(包括 CustomResourceDefinitions)。
如果要禁用匿名的未经过身份验证的用户访问,请在 API 服务器配置中中添加
--anonymous-auth=false
的配置选项。
通过运行命令 kubectl
可以查看这些角色的配置信息:
kubectl get clusterroles system:discovery -o yaml
说明: 如果你编辑该 ClusterRole,你所作的变更会被 API 服务器在重启时自动覆盖,
这是通过自动协商 机制完成的。要避免这类覆盖操作,
要么不要手动编辑这些角色,要么禁止自动协商机制。
Kubernetes RBAC API 发现角色 默认 ClusterRole 默认 ClusterRoleBinding 描述 system:basic-user system:authenticated 组允许用户以只读的方式去访问他们自己的基本信息。在 v1.14 版本之前,这个角色在默认情况下也绑定在 system:unauthenticated 上。 system:discovery system:authenticated 组允许以只读方式访问 API 发现端点,这些端点用来发现和协商 API 级别。
在 v1.14 版本之前,这个角色在默认情况下绑定在 system:unauthenticated 上。 system:public-info-viewer system:authenticated 和 system:unauthenticated 组允许对集群的非敏感信息进行只读访问,此角色是在 v1.14 版本中引入的。
面向用户的角色 一些默认的 ClusterRole 不是以前缀 system:
开头的。这些是面向用户的角色。
它们包括超级用户(Super-User)角色(cluster-admin
)、
使用 ClusterRoleBinding 在集群范围内完成授权的角色(cluster-status
)、
以及使用 RoleBinding 在特定名字空间中授予的角色(admin
、edit
、view
)。
面向用户的 ClusterRole 使用 ClusterRole 聚合 以允许管理员在这些
ClusterRole 上添加用于定制资源的规则。如果想要添加规则到 admin
、edit
或者 view
,
可以创建带有以下一个或多个标签的 ClusterRole:
metadata :
labels :
rbac.authorization.k8s.io/aggregate-to-admin : "true"
rbac.authorization.k8s.io/aggregate-to-edit : "true"
rbac.authorization.k8s.io/aggregate-to-view : "true"
默认 ClusterRole 默认 ClusterRoleBinding 描述 cluster-admin system:masters 组允许超级用户在平台上的任何资源上执行所有操作。
当在 ClusterRoleBinding 中使用时,可以授权对集群中以及所有名字空间中的全部资源进行完全控制。
当在 RoleBinding 中使用时,可以授权控制角色绑定所在名字空间中的所有资源,包括名字空间本身。 admin 无 允许管理员访问权限,旨在使用 RoleBinding 在名字空间内执行授权。如果在 RoleBinding 中使用,则可授予对名字空间中的大多数资源的读/写权限,
包括创建角色和角色绑定的能力。
此角色不允许对资源配额或者名字空间本身进行写操作。
此角色也不允许对 Kubernetes v1.22+ 创建的 EndpointSlices(或 Endpoints)进行写操作。
更多信息参阅 “EndpointSlices 和 Endpoints 写权限”小节 。
edit 无 允许对名字空间的大多数对象进行读/写操作。此角色不允许查看或者修改角色或者角色绑定。
不过,此角色可以访问 Secret,以名字空间中任何 ServiceAccount 的身份运行 Pod,
所以可以用来了解名字空间内所有服务账户的 API 访问级别。
此角色也不允许对 Kubernetes v1.22+ 创建的 EndpointSlices(或 Endpoints)进行写操作。
更多信息参阅 “EndpointSlices 和 Endpoints 写操作”小节 。
view 无 允许对名字空间的大多数对象有只读权限。
它不允许查看角色或角色绑定。此角色不允许查看 Secrets,因为读取 Secret 的内容意味着可以访问名字空间中
ServiceAccount 的凭据信息,进而允许利用名字空间中任何 ServiceAccount
的身份访问 API(这是一种特权提升)。
核心组件角色 默认 ClusterRole 默认 ClusterRoleBinding 描述 system:kube-scheduler system:kube-scheduler 用户允许访问 scheduler
组件所需要的资源。 system:volume-scheduler system:kube-scheduler 用户允许访问 kube-scheduler 组件所需要的卷资源。 system:kube-controller-manager system:kube-controller-manager 用户允许访问控制器管理器 组件所需要的资源。
各个控制回路所需要的权限在控制器角色 详述。 system:node 无 允许访问 kubelet 所需要的资源,包括对所有 Secret 的读操作和对所有 Pod 状态对象的写操作。 你应该使用 Node 鉴权组件 和
NodeRestriction 准入插件 而不是
system:node 角色。同时基于 kubelet 上调度执行的 Pod 来授权
kubelet 对 API 的访问。
system:node 角色的意义仅是为了与从 v1.8 之前版本升级而来的集群兼容。
system:node-proxier system:kube-proxy 用户允许访问 kube-proxy
组件所需要的资源。
其他组件角色 默认 ClusterRole 默认 ClusterRoleBinding 描述 system:auth-delegator 无 允许将身份认证和鉴权检查操作外包出去。
这种角色通常用在插件式 API 服务器上,以实现统一的身份认证和鉴权。 system:heapster 无 为 Heapster 组件(已弃用)定义的角色。 system:kube-aggregator 无 为 kube-aggregator 组件定义的角色。 system:kube-dns 在 kube-system 名字空间中的 kube-dns 服务账户 为 kube-dns 组件定义的角色。 system:kubelet-api-admin 无 允许 kubelet API 的完全访问权限。 system:node-bootstrapper 无 允许访问执行
kubelet TLS 启动引导
所需要的资源。 system:node-problem-detector 无 为 node-problem-detector 组件定义的角色。 system:persistent-volume-provisioner 无 允许访问大部分动态卷驱动 所需要的资源。 system:monitoring system:monitoring 组允许对控制平面监控端点的读取访问(例如:kube-apiserver
存活和就绪端点(/healthz 、/livez 、/readyz ),
各个健康检查端点(/healthz/* 、/livez/* 、/readyz/* )和 /metrics )。
请注意,各个运行状况检查端点和度量标准端点可能会公开敏感信息。
内置控制器的角色 Kubernetes 控制器管理器 运行内建于
Kubernetes 控制面的控制器 。
当使用 --use-service-account-credentials
参数启动时,kube-controller-manager
使用单独的服务账户来启动每个控制器。
每个内置控制器都有相应的、前缀为 system:controller:
的角色。
如果控制管理器启动时未设置 --use-service-account-credentials
,
它使用自己的身份凭据来运行所有的控制器,该身份必须被授予所有相关的角色。
这些角色包括:
system:controller:attachdetach-controller
system:controller:certificate-controller
system:controller:clusterrole-aggregation-controller
system:controller:cronjob-controller
system:controller:daemon-set-controller
system:controller:deployment-controller
system:controller:disruption-controller
system:controller:endpoint-controller
system:controller:expand-controller
system:controller:generic-garbage-collector
system:controller:horizontal-pod-autoscaler
system:controller:job-controller
system:controller:namespace-controller
system:controller:node-controller
system:controller:persistent-volume-binder
system:controller:pod-garbage-collector
system:controller:pv-protection-controller
system:controller:pvc-protection-controller
system:controller:replicaset-controller
system:controller:replication-controller
system:controller:resourcequota-controller
system:controller:root-ca-cert-publisher
system:controller:route-controller
system:controller:service-account-controller
system:controller:service-controller
system:controller:statefulset-controller
system:controller:ttl-controller
初始化与预防权限提升 RBAC API 会阻止用户通过编辑角色或者角色绑定来提升权限。
由于这一点是在 API 级别实现的,所以在 RBAC 鉴权组件未启用的状态下依然可以正常工作。
对角色创建或更新的限制 只有在符合下列条件之一的情况下,你才能创建/更新角色:
你已经拥有角色中包含的所有权限,且其作用域与正被修改的对象作用域相同。
(对 ClusterRole 而言意味着集群范围,对 Role 而言意味着相同名字空间或者集群范围)。 你被显式授权在 rbac.authorization.k8s.io
API 组中的 roles
或 clusterroles
资源使用 escalate
动词。 例如,如果 user-1
没有列举集群范围所有 Secret 的权限,他将不能创建包含该权限的 ClusterRole。
若要允许用户创建/更新角色:
根据需要赋予他们一个角色,允许他们根据需要创建/更新 Role 或者 ClusterRole 对象。 授予他们在所创建/更新角色中包含特殊权限的权限:隐式地为他们授权(如果它们试图创建或者更改 Role 或 ClusterRole 的权限,
但自身没有被授予相应权限,API 请求将被禁止)。 通过允许他们在 Role 或 ClusterRole 资源上执行 escalate
动作显式完成授权。
这里的 roles
和 clusterroles
资源包含在 rbac.authorization.k8s.io
API 组中。 对角色绑定创建或更新的限制 只有你已经具有了所引用的角色中包含的全部权限时,或者 你被授权在所引用的角色上执行 bind
动词时,你才可以创建或更新角色绑定。这里的权限与角色绑定的作用域相同。
例如,如果用户 user-1
没有列举集群范围所有 Secret 的能力,则他不可以创建
ClusterRoleBinding 引用授予该许可权限的角色。
如要允许用户创建或更新角色绑定:
赋予他们一个角色,使得他们能够根据需要创建或更新 RoleBinding 或 ClusterRoleBinding 对象。 授予他们绑定某特定角色所需要的许可权限:隐式授权下,可以将角色中包含的许可权限授予他们; 显式授权下,可以授权他们在特定 Role (或 ClusterRole)上执行 bind
动词的权限。 例如,下面的 ClusterRole 和 RoleBinding 将允许用户 user-1
把名字空间 user-1-namespace
中的 admin
、edit
和 view
角色赋予其他用户:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
name : role-grantor
rules :
- apiGroups : ["rbac.authorization.k8s.io" ]
resources : ["rolebindings" ]
verbs : ["create" ]
- apiGroups : ["rbac.authorization.k8s.io" ]
resources : ["clusterroles" ]
verbs : ["bind" ]
# 忽略 resourceNames 意味着允许绑定任何 ClusterRole
resourceNames : ["admin" ,"edit" ,"view" ]
---
apiVersion : rbac.authorization.k8s.io/v1
kind : RoleBinding
metadata :
name : role-grantor-binding
namespace : user-1-namespace
roleRef :
apiGroup : rbac.authorization.k8s.io
kind : ClusterRole
name : role-grantor
subjects :
- apiGroup : rbac.authorization.k8s.io
kind : User
name : user-1
当启动引导第一个角色和角色绑定时,需要为初始用户授予他们尚未拥有的权限。
对初始角色和角色绑定进行初始化时需要:
使用用户组为 system:masters
的凭据,该用户组由默认绑定关联到 cluster-admin
这个超级用户角色。 一些命令行工具 kubectl create role
创建 Role 对象,定义在某一名字空间中的权限。例如:
kubectl create clusterrole
创建 ClusterRole 对象。例如:
kubectl create rolebinding
在特定的名字空间中对 Role
或 ClusterRole
授权。例如:
kubectl create clusterrolebinding
在整个集群(所有名字空间)中用 ClusterRole 授权。例如:
kubectl auth reconcile
使用清单文件来创建或者更新 rbac.authorization.k8s.io/v1
API 对象。
尚不存在的对象会被创建,如果对应的名字空间也不存在,必要的话也会被创建。
已经存在的角色会被更新,使之包含输入对象中所给的权限。如果指定了
--remove-extra-permissions
,可以删除额外的权限。
已经存在的绑定也会被更新,使之包含输入对象中所给的主体。如果指定了
--remove-extra-permissions
,则可以删除多余的主体。
例如:
服务账户权限 默认的 RBAC 策略为控制面组件、节点和控制器授予权限。
但是不会对 kube-system
名字空间之外的服务账户授予权限。
(除了授予所有已认证用户的发现权限)
这使得你可以根据需要向特定 ServiceAccount 授予特定权限。
细粒度的角色绑定可带来更好的安全性,但需要更多精力管理。
粗粒度的授权可能导致 ServiceAccount 被授予不必要的 API 访问权限(甚至导致潜在的权限提升),
但更易于管理。
按从最安全到最不安全的顺序,存在以下方法:
为特定应用的服务账户授予角色(最佳实践)
这要求应用在其 Pod 规约中指定 serviceAccountName
,
并额外创建服务账户(包括通过 API、应用程序清单、kubectl create serviceaccount
等)。
例如,在名字空间 “my-namespace” 中授予服务账户 “my-sa” 只读权限:
kubectl create rolebinding my-sa-view \
--clusterrole= view \
--serviceaccount= my-namespace:my-sa \
--namespace= my-namespace
将角色授予某名字空间中的 “default” 服务账户
如果某应用没有指定 serviceAccountName
,那么它将使用 “default” 服务账户。
说明: "default" 服务账户所具有的权限会被授予给名字空间中所有未指定 serviceAccountName
的 Pod。
例如,在名字空间 "my-namespace" 中授予服务账户 "default" 只读权限:
kubectl create rolebinding default-view \
--clusterrole= view \
--serviceaccount= my-namespace:default \
--namespace= my-namespace
许多插件组件 在 kube-system
名字空间以 “default” 服务账户运行。
要允许这些插件组件以超级用户权限运行,需要将集群的 cluster-admin
权限授予
kube-system
名字空间中的 “default” 服务账户。
注意: 启用这一配置意味着在 kube-system
名字空间中包含以超级用户账号来访问集群 API 的 Secret。
kubectl create clusterrolebinding add-on-cluster-admin \
--clusterrole= cluster-admin \
--serviceaccount= kube-system:default
将角色授予名字空间中所有服务账户
如果你想要名字空间中所有应用都具有某角色,无论它们使用的什么服务账户,
可以将角色授予该名字空间的服务账户组。
例如,在名字空间 “my-namespace” 中的只读权限授予该名字空间中的所有服务账户:
kubectl create rolebinding serviceaccounts-view \
--clusterrole= view \
--group= system:serviceaccounts:my-namespace \
--namespace= my-namespace
在集群范围内为所有服务账户授予一个受限角色(不鼓励)
如果你不想管理每一个名字空间的权限,你可以向所有的服务账户授予集群范围的角色。
例如,为集群范围的所有服务账户授予跨所有名字空间的只读权限:
kubectl create clusterrolebinding serviceaccounts-view \
--clusterrole= view \
--group= system:serviceaccounts
授予超级用户访问权限给集群范围内的所有服务帐户(强烈不鼓励)
如果你不在乎如何区分权限,你可以将超级用户访问权限授予所有服务账户。
警告: 这样做会允许所有应用都对你的集群拥有完全的访问权限,并将允许所有能够读取
Secret(或创建 Pod)的用户对你的集群有完全的访问权限。
kubectl create clusterrolebinding serviceaccounts-cluster-admin \
--clusterrole= cluster-admin \
--group= system:serviceaccounts
EndpointSlices 和 Endpoints 写权限 在 Kubernetes v1.22 之前版本创建的集群里,
“edit” 和 “admin” 聚合角色包含对 EndpointSlices(和 Endpoints)的写权限。
作为 CVE-2021-25740 的缓解措施,
此访问权限不包含在 Kubernetes 1.22 以及更高版本集群的聚合角色里。
升级到 Kubernetes v1.22 版本的现有集群不会包括此变化。
CVE 公告 包含了在现有集群里限制此访问权限的指引。
如果你希望在新集群的聚合角色里保留此访问权限,你可以创建下面的 ClusterRole:
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRole
metadata :
annotations :
kubernetes.io/description : |-
将端点写入权限添加到 edit 和 admin 角色。此特性因 CVE-2021-25740 在 1.22
中默认被移除。请参阅 https://issue.k8s.io/103675
这一设置将允许写者要求 LoadBalancer 或 Ingress 的实现向外暴露后端 IP 地址,
所暴露的 IP 地址无法通过其他方式访问,
并且可以规避对这些后端访问进行预防/隔离的网络策略或安全控制机制。
EndpointSlice 从未包含在 edit 和 admin 角色中,
因此 EndpointSlice API 没有什么可恢复的。
labels :
rbac.authorization.k8s.io/aggregate-to-edit : "true"
name : custom:aggregate-to-edit:endpoints # 你可以随意愿更改这个 name
rules :
- apiGroups : ["" ]
resources : ["endpoints" ]
verbs : ["create" , "delete" , "deletecollection" , "patch" , "update" ]
从 ABAC 升级 原来运行较老版本 Kubernetes 的集群通常会使用限制宽松的 ABAC 策略,
包括授予所有服务帐户全权访问 API 的能力。
默认的 RBAC 策略为控制面组件、节点和控制器等授予有限的权限,但不会为
kube-system
名字空间外的服务账户授权(除了授予所有认证用户的发现权限之外)。
这样做虽然安全得多,但可能会干扰期望自动获得 API 权限的现有工作负载。
这里有两种方法来完成这种转换:
并行鉴权 同时运行 RBAC 和 ABAC 鉴权模式,
并指定包含现有的 ABAC 策略 的策略文件:
--authorization-mode= ...,RBAC,ABAC --authorization-policy-file= mypolicy.json
关于命令行中的第一个选项:如果早期的鉴权组件,例如 Node,拒绝了某个请求,则
RBAC 鉴权组件尝试对该 API 请求鉴权。如果 RBAC 也拒绝了该 API 请求,则运行 ABAC
鉴权组件。这意味着被 RBAC 或 ABAC 策略所允许的任何请求都是被允许的请求。
如果 kube-apiserver 启动时,RBAC 组件的日志级别为 5 或更高(--vmodule=rbac*=5
或 --v=5
),
你可以在 API 服务器的日志中看到 RBAC 拒绝的细节(前缀 RBAC
)
你可以使用这些信息来确定需要将哪些角色授予哪些用户、组或服务帐户。
一旦你将角色授予服务账户 且工作负载运行时,
服务器日志中没有出现 RBAC 拒绝消息,就可以删除 ABAC 鉴权器。
宽松的 RBAC 权限 你可以使用 RBAC 角色绑定复制宽松的 ABAC 策略。
警告: 下面的策略允许 所有 服务帐户充当集群管理员。
容器中运行的所有应用程序都会自动收到服务帐户的凭据,可以对 API 执行任何操作,
包括查看 Secret 和修改权限。这一策略是不被推荐的。
kubectl create clusterrolebinding permissive-binding \
--clusterrole= cluster-admin \
--user= admin \
--user= kubelet \
--group= system:serviceaccounts
在你完成到 RBAC 的迁移后,应该调整集群的访问控制,确保相关的策略满足你的信息安全需求。
3.9 - 使用 ABAC 鉴权 基于属性的访问控制(Attribute-based access control - ABAC)定义了访问控制范例,
其中通过使用将属性组合在一起的策略来向用户授予访问权限。
基于 ABAC
模式,可以这样指定策略文件 --authorization-policy-file=SOME_FILENAME
。
此文件格式是 JSON Lines ,不应存在外层的列表或映射,每行应只有一个映射。
每一行都是一个策略对象,策略对象是具有以下属性的映射:
版本控制属性:apiVersion
,字符串类型:有效值为 abac.authorization.kubernetes.io/v1beta1
,允许对策略格式进行版本控制和转换。kind
,字符串类型:有效值为 Policy
,允许对策略格式进行版本控制和转换。 spec
配置为具有以下映射的属性:主体匹配属性:user
,字符串类型;来自 --token-auth-file
的用户字符串,如果你指定 user
,它必须与验证用户的用户名匹配。group
,字符串类型;如果指定 group
,它必须与经过身份验证的用户的一个组匹配,system:authenticated
匹配所有经过身份验证的请求。
system:unauthenticated
匹配所有未经过身份验证的请求。 资源匹配属性:apiGroup
,字符串类型;一个 API 组。例如:apps
,networking.k8s.io
通配符:*
匹配所有 API 组。 namespace
,字符串类型;一个命名空间。例如:kube-system
通配符:*
匹配所有资源请求。 resource
,字符串类型;资源类型。例如:pods
,deployments
通配符:*
匹配所有资源请求。 非资源匹配属性:nonResourcePath
,字符串类型;非资源请求路径。例如:/version
或 /apis
通配符:*
匹配所有非资源请求。/foo/*
匹配 /foo/
的所有子路径。 readonly
,键入布尔值,如果为 true,则表示该策略仅适用于 get、list 和 watch 操作。说明: 属性未设置等效于属性被设置为对应类型的零值( 例如空字符串、0、false),然而,出于可读性考虑,应尽量选择不设置这类属性。
在将来,策略可能以 JSON 格式表示,并通过 REST 界面进行管理。
鉴权算法 请求具有与策略对象的属性对应的属性。
当接收到请求时,确定属性。未知属性设置为其类型的零值(例如:空字符串,0,false)。
设置为 "*"
的属性将匹配相应属性的任何值。
检查属性的元组,以匹配策略文件中的每个策略。如果至少有一行匹配请求属性,则请求被鉴权(但仍可能无法通过稍后的合法性检查)。
要允许任何经过身份验证的用户执行某些操作,请将策略组属性设置为 "system:authenticated"
。
要允许任何未经身份验证的用户执行某些操作,请将策略组属性设置为 "system:unauthenticated"
。
要允许用户执行任何操作,请使用设置为 "*"
的 apiGroup,namespace,resource 和 nonResourcePath 属性编写策略。
kubectl kubectl 使用 apiserver 的 /api
和 /apis
端点来发现服务资源类型,
并使用位于 /openapi/v2
的模式信息来验证通过创建/更新操作发送到 API 的对象。
当使用 ABAC 鉴权时,这些特殊资源必须显式地通过策略中的 nonResourcePath
属性暴露出来(参见下面的 示例 ):
/api
,/api/*
,/apis
和 /apis/*
用于 API 版本协商。/version
通过 kubectl version
检索服务器版本。/swaggerapi/*
用于创建 / 更新操作。要检查涉及到特定 kubectl 操作的 HTTP 调用,你可以调整详细程度:
kubectl --v=8 version
例子 Alice 可以对所有资源做任何事情:
{"apiVersion" : "abac.authorization.kubernetes.io/v1beta1" , "kind" : "Policy" , "spec" : {"user" : "alice" , "namespace" : "*" , "resource" : "*" , "apiGroup" : "*" }}
kubelet 可以读取任何 pod:
{"apiVersion" : "abac.authorization.kubernetes.io/v1beta1" , "kind" : "Policy" , "spec" : {"user" : "kubelet" , "namespace" : "*" , "resource" : "pods" , "readonly" : true }}
kubelet 可以读写事件:
{"apiVersion" : "abac.authorization.kubernetes.io/v1beta1" , "kind" : "Policy" , "spec" : {"user" : "kubelet" , "namespace" : "*" , "resource" : "events" }}
Bob 可以在命名空间 projectCaribou
中读取 pod:
{"apiVersion" : "abac.authorization.kubernetes.io/v1beta1" , "kind" : "Policy" , "spec" : {"user" : "bob" , "namespace" : "projectCaribou" , "resource" : "pods" , "readonly" : true }}
任何人都可以对所有非资源路径进行只读请求:
{"apiVersion" : "abac.authorization.kubernetes.io/v1beta1" , "kind" : "Policy" , "spec" : {"group" : "system:authenticated" , "readonly" : true , "nonResourcePath" : "*" }}
{"apiVersion" : "abac.authorization.kubernetes.io/v1beta1" , "kind" : "Policy" , "spec" : {"group" : "system:unauthenticated" , "readonly" : true , "nonResourcePath" : "*" }}
完整文件示例
服务帐户的快速说明 服务帐户自动生成用户。用户名是根据命名约定生成的:
system:serviceaccount:<namespace>:<serviceaccountname>
创建新的命名空间也会导致创建一个新的服务帐户:
system:serviceaccount:<namespace>:default
例如,如果要将 API 的 kube-system 完整权限中的默认服务帐户授予,则可以将此行添加到策略文件中:
{"apiVersion" :"abac.authorization.kubernetes.io/v1beta1" ,"kind" :"Policy" ,"spec" :{"user" :"system:serviceaccount:kube-system:default" ,"namespace" :"*" ,"resource" :"*" ,"apiGroup" :"*" }}
需要重新启动 apiserver 以获取新的策略行。
3.10 - 使用 Node 鉴权 节点鉴权是一种特殊用途的鉴权模式,专门对 kubelet 发出的 API 请求进行授权。
概述 节点鉴权器允许 kubelet 执行 API 操作。包括:
读取操作:
services endpoints nodes pods 与绑定到 kubelet 节点的 Pod 相关的 Secret、ConfigMap、PersistentVolumeClaim 和持久卷 写入操作:
节点和节点状态(启用 NodeRestriction
准入插件以限制 kubelet 只能修改自己的节点) Pod 和 Pod 状态 (启用 NodeRestriction
准入插件以限制 kubelet 只能修改绑定到自身的 Pod) 事件 身份认证与鉴权相关的操作:
在将来的版本中,节点鉴权器可能会添加或删除权限,以确保 kubelet 具有正确操作所需的最小权限集。
为了获得节点鉴权器的授权,kubelet 必须使用一个凭证以表示它在 system:nodes
组中,用户名为 system:node:<nodeName>
。上述的组名和用户名格式要与
kubelet TLS 启动引导
过程中为每个 kubelet 创建的标识相匹配。
<nodeName>
的值必须 与 kubelet 注册的节点名称精确匹配。默认情况下,节点名称是由
hostname
提供的主机名,或者通过 kubelet --hostname-override
选项 覆盖。
但是,当使用 --cloud-provider
kubelet 选项时,具体的主机名可能由云提供商确定,
忽略本地的 hostname
和 --hostname-override
选项。有关
kubelet 如何确定主机名的详细信息,请参阅
kubelet 选项参考 。
要启用节点鉴权器,请使用 --authorization-mode=Node
启动 API 服务器。
要限制 kubelet 可以写入的 API 对象,请使用
--enable-admission-plugins=...,NodeRestriction,...
启动 API 服务器,从而启用
NodeRestriction
准入插件。
迁移考虑因素 在 system:nodes
组之外的 kubelet system:nodes
组之外的 kubelet 不会被 Node
鉴权模式授权,并且需要继续通过当前授权它们的机制来授权。
节点准入插件不会限制来自这些 kubelet 的请求。
具有无差别用户名的 kubelet 在一些部署中,kubelet 具有 system:nodes
组的凭证,
但是无法给出它们所关联的节点的标识,因为它们没有 system:node:...
格式的用户名。
这些 kubelet 不会被 Node
鉴权模式授权,并且需要继续通过当前授权它们的任何机制来授权。
因为默认的节点标识符实现不会把它当作节点身份标识,NodeRestriction
准入插件会忽略来自这些 kubelet 的请求。
相对于以前使用 RBAC 的版本的更新 升级的 1.7 之前的使用 RBAC
的集群将继续按原样运行,因为 system:nodes
组绑定已经存在。
如果集群管理员希望开始使用 Node
鉴权器和 NodeRestriction
准入插件来限制节点对
API 的访问,这一需求可以通过下列操作来完成且不会影响已部署的应用:
启用 Node
鉴权模式 (--authorization-mode=Node,RBAC
) 和 NodeRestriction
准入插件 确保所有 kubelet 的凭据符合组/用户名要求 审核 API 服务器日志以确保 Node
鉴权器不会拒绝来自 kubelet 的请求(日志中没有持续的 NODE DENY
消息) 删除 system:node
集群角色绑定 RBAC 节点权限 在 1.6 版本中,当使用 RBAC 鉴权模式
时,system:nodes
集群角色会被自动绑定到 system:node
组。
在 1.7 版本中,不再推荐将 system:nodes
组自动绑定到 system:node
角色,因为节点鉴权器通过对 Secret 和 ConfigMap 访问的额外限制完成了相同的任务。
如果同时启用了 Node
和 RBAC
鉴权模式,1.7 版本则不会创建 system:nodes
组到 system:node
角色的自动绑定。
在 1.8 版本中,绑定将根本不会被创建。
使用 RBAC 时,将继续创建 system:node
集群角色,以便与将其他用户或组绑定到该角色的部署方法兼容。
3.11 - 从 PodSecurityPolicy 映射到 Pod 安全性标准 下面的表格列举了 PodSecurityPolicy
对象上的配置参数,这些字段是否会变更或检查 Pod 配置,以及这些配置值如何映射到
Pod 安全性标准(Pod Security Standards)
之上。
对于每个可应用的参数,表格中给出了
Baseline 和
Restricted
配置下可接受的取值。
对这两种配置而言不可接受的取值均归入
Privileged
配置下。“无意见”意味着对所有 Pod 安全性标准而言所有取值都可接受。
如果想要了解如何一步步完成迁移,可参阅从 PodSecurityPolicy 迁移到内置的 PodSecurity 准入控制器 。
PodSecurityPolicy 规约 下面表格中所列举的字段是 PodSecurityPolicySpec
的一部分,是通过 .spec
字段路径来设置的。
从 PodSecurityPolicySpec 字段映射到 Pod Security 标准 PodSecurityPolicySpec
类型 Pod 安全性标准中对应设置 privileged
检查性质 Baseline & Restricted : false
/ 未定义 / nildefaultAddCapabilities
更改性质 & 检查性质 需求满足下面的 allallowedCapabilities
allowedCapabilities
检查性质 Baseline :下面各项的子集
AUDIT_WRITE
CHOWN
DAC_OVERRIDE
FOWNER
FSETID
KILL
MKNOD
NET_BIND_SERVICE
SETFCAP
SETGID
SETPCAP
SETUID
SYS_CHROOT
Restricted :空 / 未定义 / nil 或仅 包含 NET_BIND_SERVICE
的列表
requiredDropCapabilities
更改性质 & 检查性质 Baseline :无意见
Restricted :必须包含 ALL
volumes
检查性质 Baseline 除下列取值之外的任何值
Restricted :下列取值的子集
configMap
csi
downwardAPI
emptyDir
ephemeral
persistentVolumeClaim
projected
secret
hostNetwork
检查性质 Baseline & Restricted :false
/ 未定义 / nilhostPorts
检查性质 Baseline & Restricted :未定义 / nil / 空hostPID
检查性质 Baseline & Restricted :false
/ 未定义 / nilhostIPC
检查性质 Baseline & Restricted :false
/ 未定义 / nilseLinux
更改性质 & 检查性质 Baseline & Restricted :
seLinux.rule
为 MustRunAs
,且 options
如下:
user
未设置(""
/ 未定义 / nil)role
未设置(""
/ 未定义 / nil)type
未设置或者取值为 container_t
、container_init_t
或 container_kvm_t
之一level
是任何取值runAsUser
变更性质 & 检查性质 Baseline :任何取值
Restricted :rule
是 MustRunAsNonRoot
runAsGroup
变更性质(MustRunAs)& 检查性质 无意见 supplementalGroups
变更性质 & 检查性质 无意见 fsGroup
变更性质 & 验证性质 无意见 readOnlyRootFilesystem
变更性质 & 检查性质 无意见 defaultAllowPrivilegeEscalation
变更性质 无意见(非变更性质) allowPrivilegeEscalation
变更性质 & 检查性质 只有设置为 false
时才执行变更动作
Baseline :无意见
Restricted :false
allowedHostPaths
检查性质 无意见(volumes 优先) allowedFlexVolumes
检查性质 无意见(volumes 优先) allowedCSIDrivers
检查性质 无意见(volumes 优先) allowedUnsafeSysctls
检查性质 Baseline & Restricted :未定义 / nil / 空forbiddenSysctls
检查性质 无意见 allowedProcMountTypes
(alpha feature) 检查性质 Baseline & Restricted :["Default"]
或者未定义 / nil / 空runtimeClass
.defaultRuntimeClassName
变更性质 无意见 runtimeClass
.allowedRuntimeClassNames
检查性质 无意见
PodSecurityPolicy 注解 下面表格中所列举的注解 可以通过
.metadata.annotations
设置到 PodSecurityPolicy 对象之上。
将 PodSecurityPolicy 注解映射到 Pod 安全性标准 PSP 注解
类型 Pod 安全性标准中对应设置 seccomp.security.alpha.kubernetes.io
/defaultProfileName
变更性质 无意见 seccomp.security.alpha.kubernetes.io
/allowedProfileNames
检查性质 Baseline :"runtime/default,"
(其中尾部的逗号允许取消设置)
Restricted :"runtime/default"
(没有尾部逗号)
localhost/*
取值对于 Baseline 和 Restricted 都是可接受的
apparmor.security.beta.kubernetes.io
/defaultProfileName
变更性质 无意见 apparmor.security.beta.kubernetes.io
/allowedProfileNames
检查性质 Baseline :"runtime/default,"
(其中尾部的逗号允许取消设置)
Restricted :"runtime/default"
(没有尾部逗号)
localhost/*
取值对于 Baseline 和 Restricted 都是可接受的
3.12 - Webhook 模式 WebHook 是一种 HTTP 回调:某些条件下触发的 HTTP POST 请求;通过 HTTP POST
发送的简单事件通知。一个基于 web 应用实现的 WebHook 会在特定事件发生时把消息发送给特定的 URL。
具体来说,当在判断用户权限时,Webhook
模式会使 Kubernetes 查询外部的 REST 服务。
Webhook
模式需要一个 HTTP 配置文件,通过
--authorization-webhook-config-file=SOME_FILENAME
的参数声明。
配置文件的格式使用
kubeconfig 。
在该文件中,“users” 代表着 API 服务器的 webhook,而 “cluster” 代表着远程服务。
使用 HTTPS 客户端认证的配置例子:
# Kubernetes API 版本
apiVersion : v1
# API 对象种类
kind : Config
# clusters 代表远程服务。
clusters :
- name : name-of-remote-authz-service
cluster :
# 对远程服务进行身份认证的 CA。
certificate-authority : /path/to/ca.pem
# 远程服务的查询 URL。必须使用 'https'。
server : https://authz.example.com/authorize
# users 代表 API 服务器的 webhook 配置
users :
- name : name-of-api-server
user :
client-certificate : /path/to/cert.pem # webhook plugin 使用 cert
client-key : /path/to/key.pem # cert 所对应的 key
# kubeconfig 文件必须有 context。需要提供一个给 API 服务器。
current-context : webhook
contexts :
- context :
cluster : name-of-remote-authz-service
user : name-of-api-server
name : webhook
请求载荷 在做认证决策时,API 服务器会 POST 一个 JSON 序列化的 authorization.k8s.io/v1beta1
SubjectAccessReview
对象来描述这个动作。这个对象包含了描述用户请求的字段,同时也包含了需要被访问资源或请求特征的具体信息。
需要注意的是 webhook API 对象与其他 Kubernetes API
对象一样都同样都遵从版本兼容规则 。
实施人员应该了解 beta 对象的更宽松的兼容性承诺,同时确认请求的 "apiVersion" 字段能被正确地反序列化。
此外,API 服务器还必须启用 authorization.k8s.io/v1beta1
API 扩展组 (--runtime-config=authorization.k8s.io/v1beta1=true
)。
一个请求内容的例子:
{
"apiVersion" : "authorization.k8s.io/v1beta1" ,
"kind" : "SubjectAccessReview" ,
"spec" : {
"resourceAttributes" : {
"namespace" : "kittensandponies" ,
"verb" : "get" ,
"group" : "unicorn.example.org" ,
"resource" : "pods"
},
"user" : "jane" ,
"group" : [
"group1" ,
"group2"
]
}
}
期待远程服务填充请求的 status
字段并响应允许或禁止访问。响应主体的 spec
字段被忽略,可以省略。允许的响应将返回:
{
"apiVersion" : "authorization.k8s.io/v1beta1" ,
"kind" : "SubjectAccessReview" ,
"status" : {
"allowed" : true
}
}
为了禁止访问,有两种方法。
在大多数情况下,第一种方法是首选方法,它指示授权 webhook 不允许或对请求 “无意见”。
但是,如果配置了其他授权者,则可以给他们机会允许请求。如果没有其他授权者,或者没有一个授权者,则该请求被禁止。webhook 将返回:
{
"apiVersion" : "authorization.k8s.io/v1beta1" ,
"kind" : "SubjectAccessReview" ,
"status" : {
"allowed" : false ,
"reason" : "user does not have read access to the namespace"
}
}
第二种方法立即拒绝其他配置的授权者进行短路评估。仅应由对集群的完整授权者配置有详细了解的 webhook 使用。webhook 将返回:
{
"apiVersion" : "authorization.k8s.io/v1beta1" ,
"kind" : "SubjectAccessReview" ,
"status" : {
"allowed" : false ,
"denied" : true ,
"reason" : "user does not have read access to the namespace"
}
}
对于非资源的路径访问是这么发送的:
{
"apiVersion" : "authorization.k8s.io/v1beta1" ,
"kind" : "SubjectAccessReview" ,
"spec" : {
"nonResourceAttributes" : {
"path" : "/debug" ,
"verb" : "get"
},
"user" : "jane" ,
"group" : [
"group1" ,
"group2"
]
}
}
非资源类的路径包括:/api
、/apis
、/metrics
、/logs
、/debug
、
/healthz
、/livez
、/openapi/v2
、/readyz
、和 /version
。
客户端需要访问 /api
、/api/*
、/apis
、/apis/*
和 /version
以便
能发现服务器上有什么资源和版本。对于其他非资源类的路径访问在没有 REST API 访问限制的情况下拒绝。
更多信息可以参考 authorization.v1beta1 API 对象和
webhook.go 。
3.13 - Kubelet 认证/鉴权 概述 kubelet 的 HTTPS 端点公开了 API,
这些 API 可以访问敏感度不同的数据,
并允许你在节点上和容器内以不同级别的权限执行操作。
本文档介绍了如何对 kubelet 的 HTTPS 端点的访问进行认证和鉴权。
Kubelet 身份认证 默认情况下,未被已配置的其他身份认证方法拒绝的对 kubelet 的 HTTPS 端点的请求会被视为匿名请求,
并被赋予 system:anonymous
用户名和 system:unauthenticated
组。
要禁用匿名访问并向未经身份认证的请求发送 401 Unauthorized
响应,请执行以下操作:
带 --anonymous-auth=false
标志启动 kubelet 要对 kubelet 的 HTTPS 端点启用 X509 客户端证书认证:
带 --client-ca-file
标志启动 kubelet,提供一个 CA 证书包以供验证客户端证书 带 --kubelet-client-certificate
和 --kubelet-client-key
标志启动 API 服务器 有关更多详细信息,请参见
API 服务器身份验证文档 要启用 API 持有者令牌(包括服务帐户令牌)以对 kubelet 的 HTTPS 端点进行身份验证,请执行以下操作:
确保在 API 服务器中启用了 authentication.k8s.io/v1beta1
API 组 带 --authentication-token-webhook
和 --kubeconfig
标志启动 kubelet kubelet 调用已配置的 API 服务器上的 TokenReview
API,以根据持有者令牌确定用户信息 Kubelet 鉴权 任何成功通过身份验证的请求(包括匿名请求)之后都会被鉴权。
默认的鉴权模式为 AlwaysAllow
,它允许所有请求。
细分对 kubelet API 的访问权限可能有多种原因:
启用了匿名身份验证,但是应限制匿名用户调用 kubelet API 的能力 启用了持有者令牌认证,但应限制任意 API 用户(如服务帐户)调用 kubelet API 的能力 启用了客户端证书身份验证,但仅应允许已配置的 CA 签名的某些客户端证书使用 kubelet API 要细分对 kubelet API 的访问权限,请将鉴权委派给 API 服务器:
确保在 API 服务器中启用了 authorization.k8s.io/v1beta1
API 组 带 --authorization-mode=Webhook
和 --kubeconfig
标志启动 kubelet kubelet 调用已配置的 API 服务器上的 SubjectAccessReview
API,
以确定每个请求是否得到鉴权 kubelet 使用与 API 服务器相同的
请求属性
方法对 API 请求执行鉴权。
请求的动词根据传入请求的 HTTP 动词确定:
HTTP 动词 请求动词 POST create GET, HEAD get PUT update PATCH patch DELETE delete
资源和子资源是根据传入请求的路径确定的:
Kubelet API 资源 子资源 /stats/* nodes stats /metrics/* nodes metrics /logs/* nodes log /spec/* nodes spec 其它所有 nodes proxy
名字空间和 API 组属性始终是空字符串,
资源名称始终是 kubelet 的 Node
API 对象的名称。
在此模式下运行时,请确保传递给 API 服务器的由 --kubelet-client-certificate
和
--kubelet-client-key
标志标识的用户具有以下属性的鉴权:
verb=*, resource=nodes, subresource=proxy verb=*, resource=nodes, subresource=stats verb=*, resource=nodes, subresource=log verb=*, resource=nodes, subresource=spec verb=*, resource=nodes, subresource=metrics 3.14 - TLS 启动引导 在一个 Kubernetes 集群中,工作节点上的组件(kubelet 和 kube-proxy)需要与
Kubernetes 控制平面组件通信,尤其是 kube-apiserver。
为了确保通信本身是私密的、不被干扰,并且确保集群的每个组件都在与另一个可信的组件通信,
我们强烈建议使用节点上的客户端 TLS 证书。
启动引导这些组件的正常过程,尤其是需要证书来与 kube-apiserver 安全通信的工作节点,
可能会是一个具有挑战性的过程,因为这一过程通常不受 Kubernetes 控制,需要不少额外工作。
这也使得初始化或者扩缩一个集群的操作变得具有挑战性。
为了简化这一过程,从 1.4 版本开始,Kubernetes 引入了一个证书请求和签名 API。
该提案可在这里 看到。
本文档描述节点初始化的过程,如何为 kubelet 配置 TLS 客户端证书启动引导,
以及其背后的工作原理。
初始化过程 当工作节点启动时,kubelet 执行以下操作:
寻找自己的 kubeconfig
文件 检索 API 服务器的 URL 和凭据,通常是来自 kubeconfig
文件中的
TLS 密钥和已签名证书 尝试使用这些凭据来与 API 服务器通信 假定 kube-apiserver 成功地认证了 kubelet 的凭据数据,它会将 kubelet
视为一个合法的节点并开始将 Pod 分派给该节点。
注意,签名的过程依赖于:
kubeconfig
中包含密钥和本地主机的证书证书被 kube-apiserver 所信任的一个证书机构(CA)所签名 负责部署和管理集群的人有以下责任:
创建 CA 密钥和证书 将 CA 证书发布到 kube-apiserver 运行所在的控制平面节点上 为每个 kubelet 创建密钥和证书;强烈建议为每个 kubelet 使用独一无二的、
CN 取值与众不同的密钥和证书 使用 CA 密钥对 kubelet 证书签名 将 kubelet 密钥和签名的证书发布到 kubelet 运行所在的特定节点上 本文中描述的 TLS 启动引导过程有意简化甚至完全自动化上述过程,
尤其是第三步之后的操作,因为这些步骤是初始化或者扩缩集群时最常见的操作。
启动引导初始化 在启动引导初始化过程中,会发生以下事情:
kubelet 启动 kubelet 看到自己没有 对应的 kubeconfig
文件 kubelet 搜索并发现 bootstrap-kubeconfig
文件 kubelet 读取该启动引导文件,从中获得 API 服务器的 URL 和用途有限的一个“令牌(Token)” kubelet 建立与 API 服务器的连接,使用上述令牌执行身份认证 kubelet 现在拥有受限制的凭据来创建和取回证书签名请求(CSR) kubelet 为自己创建一个 CSR,并将其 signerName 设置为 kubernetes.io/kube-apiserver-client-kubelet
CSR 被以如下两种方式之一批复:如果配置了,kube-controller-manager 会自动批复该 CSR 如果配置了,一个外部进程,或者是人,使用 Kubernetes API 或者使用 kubectl
来批复该 CSR kubelet 所需要的证书被创建 证书被发放给 kubelet kubelet 取回该证书 kubelet 创建一个合适的 kubeconfig
,其中包含密钥和已签名的证书 kubelet 开始正常操作 可选地,如果配置了,kubelet 在证书接近于过期时自动请求更新证书 更新的证书被批复并发放;取决于配置,这一过程可能是自动的或者手动完成 本文的其余部分描述配置 TLS 启动引导的必要步骤及其局限性。
配置 要配置 TLS 启动引导及可选的自动批复,你必须配置以下组件的选项:
kube-apiserver kube-controller-manager kubelet 集群内的资源:ClusterRoleBinding
以及可能需要的 ClusterRole
此外,你需要有 Kubernetes 证书机构(Certificate Authority,CA)。
证书机构 就像在没有 TLS 启动引导支持的情况下,你会需要证书机构(CA)密钥和证书。
这些数据会被用来对 kubelet 证书进行签名。
如前所述,将证书机构密钥和证书发布到控制平面节点是你的责任。
就本文而言,我们假定这些数据被发布到控制平面节点上的 /var/lib/kubernetes/ca.pem
(证书)和
/var/lib/kubernetes/ca-key.pem
(密钥)文件中。
我们将这两个文件称作“Kubernetes CA 证书和密钥”。
所有 Kubernetes 组件(kubelet、kube-apiserver、kube-controller-manager)
都使用这些凭据,并假定这里的密钥和证书都是 PEM 编码的。
kube-apiserver 配置 启用 TLS 启动引导对 kube-apiserver 有若干要求:
能够识别对客户端证书进行签名的 CA 能够对启动引导的 kubelet 执行身份认证,并将其置入 system:bootstrappers
组 能够对启动引导的 kubelet 执行鉴权操作,允许其创建证书签名请求(CSR) 识别客户证书 对于所有客户端证书的认证操作而言,这是很常见的。
如果还没有设置,要为 kube-apiserver 命令添加 --client-ca-file=FILENAME
标志来启用客户端证书认证,在标志中引用一个包含用来签名的证书的证书机构包,
例如:--client-ca-file=/var/lib/kubernetes/ca.pem
。
初始启动引导认证 为了让启动引导的 kubelet 能够连接到 kube-apiserver 并请求证书,
它必须首先在服务器上认证自身身份。你可以使用任何一种能够对 kubelet
执行身份认证的身份认证组件 。
尽管所有身份认证策略都可以用来对 kubelet 的初始启动凭据来执行认证,
出于容易准备的因素,建议使用如下两个身份认证组件:
启动引导令牌(Bootstrap Token) 令牌认证文件 启动引导令牌是一种对 kubelet 进行身份认证的方法,相对简单且容易管理,
且不需要在启动 kube-apiserver 时设置额外的标志。
无论选择哪种方法,这里的需求是 kubelet 能够被身份认证为某个具有如下权限的用户:
创建和读取 CSR 在启用了自动批复时,能够在请求节点客户端证书时得到自动批复 使用启动引导令牌执行身份认证的 kubelet 会被认证为 system:bootstrappers
组中的用户。这是使用启动引导令牌的一种标准方法。
随着这个功能特性的逐渐成熟,你需要确保令牌绑定到某基于角色的访问控制(RBAC)
策略上,从而严格限制请求(使用启动引导令牌 )
仅限于客户端申请提供证书。当 RBAC 被配置启用时,可以将令牌限制到某个组,
从而提高灵活性。例如,你可以在准备节点期间禁止某特定启动引导组的访问。
启动引导令牌 启动引导令牌的细节在这里
详述。启动引导令牌在 Kubernetes 集群中存储为 Secret 对象,被发放给各个 kubelet。
你可以在整个集群中使用同一个令牌,也可以为每个节点发放单独的令牌。
这一过程有两个方面:
基于令牌 ID、机密数据和范畴信息创建 Kubernetes Secret 将令牌发放给 kubelet 从 kubelet 的角度,所有令牌看起来都很像,没有特别的含义。
从 kube-apiserver 服务器的角度,启动引导令牌是很特殊的。
根据其 type
、namespace
和 name
,kube-apiserver 能够将其认作特殊的令牌,
并授予携带该令牌的任何人特殊的启动引导权限,换言之,将其视为
system:bootstrappers
组的成员。这就满足了 TLS 启动引导的基本需求。
关于创建 Secret 的进一步细节可访问这里 。
如果你希望使用启动引导令牌,你必须在 kube-apiserver 上使用下面的标志启用之:
--enable-bootstrap-token-auth=true
令牌认证文件 kube-apiserver 能够将令牌视作身份认证依据。
这些令牌可以是任意数据,但必须表示为基于某安全的随机数生成器而得到的至少
128 位混沌数据。这里的随机数生成器可以是现代 Linux 系统上的
/dev/urandom
。生成令牌的方式有很多种。例如:
head -c 16 /dev/urandom | od -An -t x | tr -d ' '
上面的命令会生成类似于 02b50b05283e98dd0fd71db496ef01e8
这样的令牌。
令牌文件看起来是下面的例子这样,其中前面三个值可以是任何值,
用引号括起来的组名称则只能用例子中给的值。
02b50b05283e98dd0fd71db496ef01e8,kubelet-bootstrap,10001,"system:bootstrappers"
向 kube-apiserver 添加 --token-auth-file=FILENAME
标志(或许这要对 systemd
的单元文件作修改)以启用令牌文件。有关进一步细节的文档,
可参见这里 。
授权 kubelet 创建 CSR 现在启动引导节点被 身份认证 为 system:bootstrapping
组的成员,
它需要被 授权 创建证书签名请求(CSR)并在证书被签名之后将其取回。
幸运的是,Kubernetes 提供了一个 ClusterRole
,其中精确地封装了这些许可,
system:node-bootstrapper
。
为了实现这一点,你只需要创建 ClusterRoleBinding
,将 system:bootstrappers
组绑定到集群角色 system:node-bootstrapper
。
# 允许启动引导节点创建 CSR
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRoleBinding
metadata :
name : create-csrs-for-bootstrapping
subjects :
- kind : Group
name : system:bootstrappers
apiGroup : rbac.authorization.k8s.io
roleRef :
kind : ClusterRole
name : system:node-bootstrapper
apiGroup : rbac.authorization.k8s.io
kube-controller-manager 配置 API 服务器从 kubelet 收到证书请求并对这些请求执行身份认证,
但真正负责发放签名证书的是控制器管理器(controller-manager)。
控制器管理器通过一个证书发放的控制回路来执行此操作。该操作的执行方式是使用磁盘上的文件用
cfssl 本地签名组件来完成。
目前,所发放的所有证书都有一年的有效期,并设定了默认的一组密钥用法。
为了让控制器管理器对证书签名,它需要:
能够访问你之前所创建并分发的 “Kubernetes CA 密钥和证书” 启用 CSR 签名 访问密钥和证书 如前所述,你需要创建一个 Kubernetes CA 密钥和证书,并将其发布到控制平面节点。
这些数据会被控制器管理器来对 kubelet 证书进行签名。
由于这些被签名的证书反过来会被 kubelet 用来在 kube-apiserver 执行普通的
kubelet 身份认证,很重要的一点是为控制器管理器所提供的 CA 也被 kube-apiserver
信任用来执行身份认证。CA 密钥和证书是通过 kube-apiserver 的标志
--client-ca-file=FILENAME
(例如,--client-ca-file=/var/lib/kubernetes/ca.pem
),
来设定的,正如 kube-apiserver 配置节所述。
要将 Kubernetes CA 密钥和证书提供给 kube-controller-manager,可使用以下标志:
--cluster-signing-cert-file= "/etc/path/to/kubernetes/ca/ca.crt" --cluster-signing-key-file= "/etc/path/to/kubernetes/ca/ca.key"
例如:
--cluster-signing-cert-file= "/var/lib/kubernetes/ca.pem" --cluster-signing-key-file= "/var/lib/kubernetes/ca-key.pem"
所签名的证书的合法期限可以通过下面的标志来配置:
--cluster-signing-duration
批复 为了对 CSR 进行批复,你需要告诉控制器管理器批复这些 CSR 是可接受的。
这是通过将 RBAC 访问权限授予正确的组来实现的。
许可权限有两组:
nodeclient
:如果节点在为节点创建新的证书,则该节点还没有证书。
该节点使用前文所列的令牌之一来执行身份认证,因此是组 system:bootstrappers
组的成员。selfnodeclient
:如果节点在对证书执行续期操作,则该节点已经拥有一个证书。
节点持续使用现有的证书将自己认证为 system:nodes
组的成员。要允许 kubelet 请求并接收新的证书,可以创建一个 ClusterRoleBinding
将启动引导节点所处的组 system:bootstrappers
绑定到为其赋予访问权限的 ClusterRole
system:certificates.k8s.io:certificatesigningrequests:nodeclient
:
# 批复 "system:bootstrappers" 组的所有 CSR
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRoleBinding
metadata :
name : auto-approve-csrs-for-group
subjects :
- kind : Group
name : system:bootstrappers
apiGroup : rbac.authorization.k8s.io
roleRef :
kind : ClusterRole
name : system:certificates.k8s.io:certificatesigningrequests:nodeclient
apiGroup : rbac.authorization.k8s.io
要允许 kubelet 对其客户端证书执行续期操作,可以创建一个 ClusterRoleBinding
将正常工作的节点所处的组 system:nodes
绑定到为其授予访问许可的 ClusterRole
system:certificates.k8s.io:certificatesigningrequests:selfnodeclient
:
# 批复 "system:nodes" 组的 CSR 续约请求
apiVersion : rbac.authorization.k8s.io/v1
kind : ClusterRoleBinding
metadata :
name : auto-approve-renewals-for-nodes
subjects :
- kind : Group
name : system:nodes
apiGroup : rbac.authorization.k8s.io
roleRef :
kind : ClusterRole
name : system:certificates.k8s.io:certificatesigningrequests:selfnodeclient
apiGroup : rbac.authorization.k8s.io
作为 kube-controller-manager
的一部分的 csrapproving
控制器是自动被启用的。
该控制器使用 SubjectAccessReview
API
来确定给定用户是否被授权请求 CSR,之后基于鉴权结果执行批复操作。
为了避免与其它批复组件发生冲突,内置的批复组件不会显式地拒绝任何 CSRs。
该组件仅是忽略未被授权的请求。
控制器也会作为垃圾收集的一部分清除已过期的证书。
kubelet 配置 最后,当控制平面节点被正确配置并且所有必要的身份认证和鉴权机制都就绪时,
我们可以配置 kubelet。
kubelet 需要以下配置来执行启动引导:
一个用来存储所生成的密钥和证书的路径(可选,可以使用默认配置) 一个用来指向尚不存在的 kubeconfig
文件的路径;kubelet 会将启动引导配置文件放到这个位置 一个指向启动引导 kubeconfig
文件的路径,用来提供 API 服务器的 URL 和启动引导凭据,
例如,启动引导令牌 可选的:轮换证书的指令 启动引导 kubeconfig
文件应该放在一个 kubelet 可访问的路径下,例如
/var/lib/kubelet/bootstrap-kubeconfig
。
其格式与普通的 kubeconfig
文件完全相同。实例文件可能看起来像这样:
apiVersion : v1
kind : Config
clusters :
- cluster :
certificate-authority : /var/lib/kubernetes/ca.pem
server : https://my.server.example.com:6443
name : bootstrap
contexts :
- context :
cluster : bootstrap
user : kubelet-bootstrap
name : bootstrap
current-context : bootstrap
preferences : {}
users :
- name : kubelet-bootstrap
user :
token : 07401b.f395accd246ae52d
需要额外注意的一些因素有:
certificate-authority
:指向 CA 文件的路径,用来对 kube-apiserver 所出示的服务器证书进行验证server
:用来访问 kube-apiserver 的 URLtoken
:要使用的令牌令牌的格式并不重要,只要它与 kube-apiserver 的期望匹配即可。
在上面的例子中,我们使用的是启动引导令牌。
如前所述,任何合法的身份认证方法都可以使用,不限于令牌。
因为启动引导 kubeconfig
文件是一个标准的 kubeconfig
文件,你可以使用
kubectl
来生成该文件。要生成上面的示例文件:
kubectl config --kubeconfig=/var/lib/kubelet/bootstrap-kubeconfig set-cluster bootstrap --server='https://my.server.example.com:6443' --certificate-authority=/var/lib/kubernetes/ca.pem
kubectl config --kubeconfig=/var/lib/kubelet/bootstrap-kubeconfig set-credentials kubelet-bootstrap --token=07401b.f395accd246ae52d
kubectl config --kubeconfig=/var/lib/kubelet/bootstrap-kubeconfig set-context bootstrap --user=kubelet-bootstrap --cluster=bootstrap
kubectl config --kubeconfig=/var/lib/kubelet/bootstrap-kubeconfig use-context bootstrap
要指示 kubelet 使用启动引导 kubeconfig
文件,可以使用下面的 kubelet 标志:
--bootstrap-kubeconfig="/var/lib/kubelet/bootstrap-kubeconfig" --kubeconfig="/var/lib/kubelet/kubeconfig"
在启动 kubelet 时,如果 --kubeconfig
标志所指定的文件并不存在,会使用通过标志
--bootstrap-kubeconfig
所指定的启动引导 kubeconfig 配置来向 API 服务器请求客户端证书。
在证书请求被批复并被 kubelet 收回时,一个引用所生成的密钥和所获得证书的 kubeconfig
文件会被写入到通过 --kubeconfig
所指定的文件路径下。
证书和密钥文件会被放到 --cert-dir
所指定的目录中。
客户和服务证书 前文所述的内容都与 kubelet 客户端 证书相关,尤其是 kubelet 用来向
kube-apiserver 认证自身身份的证书。
kubelet 也可以使用 服务(Serving) 证书。kubelet 自身向外提供一个 HTTPS 末端,
包含若干功能特性。要保证这些末端的安全性,kubelet 可以执行以下操作之一:
使用通过 --tls-private-key-file
和 --tls-cert-file
所设置的密钥和证书 如果没有提供密钥和证书,则创建自签名的密钥和证书 通过 CSR API 从集群服务器请求服务证书 TLS 启动引导所提供的客户端证书默认被签名为仅用于 client auth
(客户端认证),
因此不能作为提供服务的证书,或者 server auth
。
不过,你可以启用服务器证书,至少可以部分地通过证书轮换来实现这点。
证书轮换 Kubernetes v1.8 和更高版本的 kubelet 实现了对客户端证书与/或服务证书进行轮换这一特性。
请注意,服务证书轮换是一项 Beta 特性,需要 kubelet 上 RotateKubeletServerCertificate
特性的支持(默认启用)
你可以配置 kubelet 使其在现有凭据过期时通过创建新的 CSR 来轮换其客户端证书。
要启用此功能,请使用 kubelet 配置文件 的
rotateCertificates
字段或将以下命令行参数传递给 kubelet(已弃用):
--rotate-certificates
启用 RotateKubeletServerCertificate
会让 kubelet
在启动引导其客户端凭据之后请求一个服务证书且 对该服务证书执行轮换操作。
要启用此特性,请使用 kubelet 配置文件 的
serverTLSBootstrap
字段将以下命令行参数传递给 kubelet(已弃用):
--rotate-server-certificates
说明: 出于安全原因 ,Kubernetes 核心中所实现的
CSR 批复控制器并不会自动批复节点的服务 证书。
要使用 RotateKubeletServerCertificate
功能特性,
集群运维人员需要运行一个定制的控制器或者手动批复服务证书的请求。
对 kubelet 服务证书的批复过程因集群部署而异,通常应该仅批复如下 CSR:
由节点发出的请求(确保 spec.username
字段形式为 system:node:<nodeName>
且 spec.groups
包含 system:nodes
) 请求中包含服务证书用法(确保 spec.usages
中包含 server auth
,可选地也可包含
digital signature
和 key encipherment
,且不包含其它用法) 仅包含隶属于请求节点的 IP 和 DNS 的 subjectAltNames
,没有 URI 和 Email
形式的 subjectAltNames
(解析 spec.request
中的 x509 证书签名请求可以检查
subjectAltNames
) 其它身份认证组件 本文所描述的所有 TLS 启动引导内容都与 kubelet 相关。不过,其它组件也可能需要直接与
kube-apiserver 直接通信。容易想到的是 kube-proxy,同样隶属于
Kubernetes 的节点组件并且运行在所有节点之上,不过也可能包含一些其它负责监控或者联网的组件。
与 kubelet 类似,这些其它组件也需要一种向 kube-apiserver 认证身份的方法。
你可以用几种方法来生成这类凭据:
较老的方式:和 kubelet 在 TLS 启动引导之前所做的一样,用类似的方式创建和分发证书。 DaemonSet:由于 kubelet 自身被加载到所有节点之上,并且有足够能力来启动基本服务,
你可以运行将 kube-proxy 和其它特定节点的服务作为 kube-system
名字空间中的
DaemonSet 来执行,而不是独立的进程。由于 DaemonSet 位于集群内部,
你可以为其指派一个合适的服务账户,使之具有适当的访问权限来完成其使命。
这也许是配置此类服务的最简单的方法。 kubectl 批复 CSR 可以在编译进控制器内部的批复工作流之外被批复。
签名控制器并不会立即对所有证书请求执行签名操作。相反,
它会等待这些请求被某具有适当特权的用户标记为 “Approved(已批准)”状态。
这一流程有意允许由外部批复控制器来自动执行的批复,
或者由控制器管理器内置的批复控制器来自动批复。
不过,集群管理员也可以使用 kubectl
来手动批准证书请求。
管理员可以通过 kubectl get csr
来列举所有的 CSR,使用
kubectl descsribe csr <name>
来描述某个 CSR 的细节。
管理员可以使用 kubectl certificate approve <name
来批准某 CSR,或者
kubectl certificate deny <name>
来拒绝某 CSR。
3.15 - 验证准入策略(ValidatingAdmissionPolicy) 特性状态: Kubernetes v1.26 [alpha]
本页面提供验证准入策略(Validating Admission Policy)的概述。
什么是验证准入策略? 验证准入策略提供一种声明式的、进程内的替代方案来验证准入 Webhook。
验证准入策略使用通用表达语言 (Common Expression Language,CEL) 来声明策略的验证规则。
验证准入策略是高度可配置的,使配置策略的作者能够根据集群管理员的需要,
定义可以参数化并限定到资源的策略。
哪些资源构成策略 策略通常由三种资源构成:
ValidatingAdmissionPolicy
描述策略的抽象逻辑(想想看:“这个策略确保一个特定标签被设置为一个特定值”)。
一个 ValidatingAdmissionPolicyBinding
将上述资源联系在一起,并提供作用域。
如果你只想为 Pods
设置一个 owner
标签,你就需要在这个绑定中指定这个限制。
参数资源为 ValidatingAdmissionPolicy
提供信息,使其成为一个具体的声明
(想想看:“owner
标签必须被设置为以 .company.com
结尾的形式")。
参数资源的模式(Schema)使用诸如 ConfigMap 或 CRD 这类原生类型定义。
ValidatingAdmissionPolicy
对象指定它们期望参数资源所呈现的类型。
至少要定义一个 ValidatingAdmissionPolicy
和一个相对应的 ValidatingAdmissionPolicyBinding
才能使策略生效。
如果 ValidatingAdmissionPolicy
不需要参数配置,不设置 ValidatingAdmissionPolicy
中的
spec.paramKind
即可。
准备开始 确保 ValidatingAdmissionPolicy
特性门控 被启用。 确保 admissionregistration.k8s.io/v1alpha1
API 被启用。 开始使用验证准入策略 验证准入策略是集群控制平面的一部分。你应该非常谨慎地编写和部署它们。下面介绍如何快速试验验证准入策略。
创建一个 ValidatingAdmissionPolicy 以下是一个 ValidatingAdmissionPolicy 的示例:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
metadata :
name : "demo-policy.example.com"
spec :
failurePolicy : Fail
matchConstraints :
resourceRules :
- apiGroups : ["apps" ]
apiVersions : ["v1" ]
operations : ["CREATE" , "UPDATE" ]
resources : ["deployments" ]
validations :
- expression : "object.spec.replicas <= 5"
spec.validations
包含使用通用表达式语言 (CEL)
来验证请求的 CEL 表达式。
如果表达式的计算结果为 false,则根据 spec.failurePolicy
字段强制执行验证检查处理。
要配置一个在某集群中使用的验证准入策略,需要一个绑定。
以下是一个 ValidatingAdmissionPolicyBinding 的示例:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicyBinding
metadata :
name : "demo-binding-test.example.com"
spec :
policyName : "demo-policy.example.com"
validationActions : [Deny]
matchResources :
namespaceSelector :
matchLabels :
environment : test
尝试创建副本集合不满足验证表达式的 Deployment 时,将返回包含以下消息的错误:
ValidatingAdmissionPolicy 'demo-policy.example.com' with binding 'demo-binding-test.example.com' denied request: failed expression: object.spec.replicas <= 5
上面提供的是一个简单的、无配置参数的 ValidatingAdmissionPolicy。
验证操作 每个 ValidatingAdmissionPolicyBinding
必须指定一个或多个
validationActions
来声明如何执行策略的 validations
。
支持的 validationActions
包括:
Deny
: 验证失败会导致请求被拒绝。Warn
: 验证失败会作为警告 报告给请求客户端。Audit
: 验证失败会包含在 API 请求的审计事件中。例如,要同时向客户端发出验证失败的警告并记录验证失败的审计记录,请使用以下配置:
validationActions : [Warn, Audit]
Deny
和 Warn
不能一起使用,因为这种组合会不必要地将验证失败重复输出到
API 响应体和 HTTP 警告头中。
如果 validation
求值为 false,则始终根据这些操作执行。
由 failurePolicy
定义的失败仅在 failurePolicy
设置为 Fail
(或未设置)时根据这些操作执行,
否则这些失败将被忽略。
有关验证失败审计注解的详细信息,请参见
审计注解:验证失败 。
参数资源 参数资源允许策略配置与其定义分开。
一个策略可以定义 paramKind,给出参数资源的 GVK,
然后一个策略绑定可以通过名称(通过 policyName)将某策略与某特定的参数资源(通过 paramRef)联系起来。
如果需要参数配置,下面是一个带有参数配置的 ValidatingAdmissionPolicy 的例子:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
metadata :
name : "replicalimit-policy.example.com"
spec :
failurePolicy : Fail
paramKind :
apiVersion : rules.example.com/v1
kind : ReplicaLimit
matchConstraints :
resourceRules :
- apiGroups : ["apps" ]
apiVersions : ["v1" ]
operations : ["CREATE" , "UPDATE" ]
resources : ["deployments" ]
validations :
- expression : "object.spec.replicas <= params.maxReplicas"
reason : Invalid
ValidatingAdmissionPolicy 的 spec.paramKind
字段指定用于参数化此策略的资源类型。
在这个例子中,它是由自定义资源 ReplicaLimit 配置的。
在这个例子中请注意 CEL 表达式是如何通过 CEL params 变量引用参数的,如:params.maxReplicas
。
spec.matchConstraints
指定此策略要检查哪些资源。
请注意,诸如 ConfigMap
之类的原生类型也可以用作参数引用。
spec.validations
字段包含 CEL 表达式。
如果表达式的计算结果为 false,则根据 spec.failurePolicy
字段强制执行验证检查操作。
验证准入策略的作者负责提供 ReplicaLimit 参数 CRD。
要配置一个在某集群中使用的验证准入策略,需要创建绑定和参数资源。
以下是 ValidatingAdmissionPolicyBinding 的示例:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicyBinding
metadata :
name : "replicalimit-binding-test.example.com"
spec :
policyName : "replicalimit-policy.example.com"
validationActions : [Deny]
paramRef :
name : "replica-limit-test.example.com"
matchResources :
namespaceSelector :
matchLabels :
environment : test
参数资源可以如下:
apiVersion : rules.example.com/v1
kind : ReplicaLimit
metadata :
name : "replica-limit-test.example.com"
maxReplicas : 3
此策略参数资源将限制测试环境所有名字空间中的 Deployment 最多有 3 个副本。
一个准入策略可以有多个绑定。
要绑定所有的其他环境,限制 maxReplicas 为 100,请创建另一个 ValidatingAdmissionPolicyBinding:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicyBinding
metadata :
name : "replicalimit-binding-nontest"
spec :
policyName : "replicalimit-policy.example.com"
validationActions : [Deny]
paramRef :
name : "replica-limit-clusterwide.example.com"
matchResources :
namespaceSelector :
matchExpressions :
- key : environment
operator : NotIn
values :
- test
并有一个参数资源,如下:
apiVersion : rules.example.com/v1
kind : ReplicaLimit
metadata :
name : "replica-limit-clusterwide.example.com"
maxReplicas : 100
绑定可以包含相互重叠的匹配条件。策略会针对每个匹配的绑定进行计算。
在上面的例子中,nontest
策略绑定可以被定义为一个全局策略:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicyBinding
metadata :
name : "replicalimit-binding-global"
spec :
policyName : "replicalimit-policy.example.com"
validationActions : [Deny]
params : "replica-limit-clusterwide.example.com"
matchResources :
namespaceSelector :
matchExpressions :
- key : environment
operator : Exists
如果参数资源尚未被绑定,代表参数资源的 params 对象将不会被设置,
所以对于需要参数资源的策略,添加一个检查来确保参数资源被绑定,这会很有用。
对于需要参数配置的场景,我们建议在 spec.validations[0].expression
中添加一个参数检查:
- expression: "params != null"
message: "params missing but required to bind to this policy"
将可选参数作为参数资源的一部分,并且只在参数存在时执行检查操作,这样做会比较方便。
CEL 提供了 has()
方法,它检查传递给它的键是否存在。CEL 还实现了布尔短路逻辑。
如果逻辑 OR 的前半部分计算为 true,则不会计算另一半(因为无论如何整个 OR 的结果都为真)。
结合这两者,我们可以提供一种验证可选参数的方法:
!has(params.optionalNumber) || (params.optionalNumber >= 5 && params.optionalNumber <= 10)
在这里,我们首先用 !has(params.optionalNumber)
检查可选参数是否存在。
如果 optionalNumber
没有被定义,那么表达式就会短路,因为 !has(params.optionalNumber)
的计算结果为 true。 如果 optionalNumber
被定义了,那么将计算 CEL 表达式的后半部分,
并且 optionalNumber
将被检查以确保它包含一个 5 到 10 之间的值(含 5 到 10)。 鉴权检查 我们为参数资源引入了鉴权检查。
用户应该对 ValidatingAdmissionPolicy
中的 paramKind
和 ValidatingAdmissionPolicyBinding
中的 paramRef
所引用的资源有 read
权限。
请注意,如果 paramKind
中的资源没能通过 restmapper 解析,则用户需要拥有对组的所有资源的
read
访问权限。
失效策略 failurePolicy
定义了如何处理错误配置和准入策略的 CEL 表达式取值为 error 的情况。
允许的值是 Ignore
或 Fail
。
Ignore
意味着调用 ValidatingAdmissionPolicy 的错误被忽略,允许 API 请求继续。Fail
意味着调用 ValidatingAdmissionPolicy 的错误导致准入失败并拒绝 API 请求。请注意,failurePolicy
是在 ValidatingAdmissionPolicy
中定义的:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
spec :
...
failurePolicy : Ignore # 默认值是 "Fail"
validations :
- expression : "object.spec.xyz == params.x"
检查表达式 spec.validations[i].expression
代表将使用 CEL 来计算表达式。
要了解更多信息,请参阅 CEL 语言规范 。
CEL 表达式可以访问按 CEL 变量来组织的 Admission 请求/响应的内容,以及其他一些有用的变量 :
'object' - 来自传入请求的对象。对于 DELETE 请求,该值为 null。 'oldObject' - 现有对象。对于 CREATE 请求,该值为 null。 'request' - 准入请求 的属性。 'params' - 被计算的策略绑定引用的参数资源。如果未设置 paramKind
,该值为 null。 authorizer
- 一个 CEL 鉴权组件。可以用来为请求的主体(经过身份验证的用户)执行鉴权检查。
更多细节可以参考 Kubernetes CEL 库的文档中的 Authz 。authorizer.requestResource
- 针对请求资源(组、资源、(子资源)、命名空间、名称)所配置的鉴权检查的快捷方式。总是可以从对象的根访问的属性有 apiVersion
、kind
、metadata.name
和 metadata.generateName
。
其他元数据属性不能访问。
只有符合 [a-zA-Z_.-/][a-zA-Z0-9_.-/]*
形式的属性名称是可访问的。
可访问的属性名称在表达式中被访问时,根据以下规则进行转义:
转义序列 属性名称等效 __underscores__
__
__dot__
.
__dash__
-
__slash__
/
__{keyword}__
CEL 保留关键字
说明: CEL 保留 关键字仅在字符串与保留关键字完全匹配时才需要转义。
例如,单词 “sprint” 中的 int
不需要被转义。
转义示例:
属性名 具有转义属性名称的规则 namespace self.__namespace__ > 0
x-prop self.x__dash__prop > 0
redact__d self.redact__underscores__d > 0
string self.startsWith('kube')
列表类型为 "set" 或 "map" 的数组上的等价关系比较会忽略元素顺序,即 [1, 2] == [2, 1]。
使用 x-kubernetes-list-type 连接数组时使用列表类型的语义:
'set': X + Y
执行并集,其中 X
中所有元素的数组位置被保留,Y
中不相交的元素被追加,保留其元素的偏序关系。 'map':X + Y
执行合并,保留 X
中所有键的数组位置,但是当 X
和 Y
的键集相交时,其值被 Y
的值覆盖。
Y
中键值不相交的元素被追加,保留其元素之间的偏序关系。 检查表达式示例 表达式 目的 object.minReplicas <= object.replicas && object.replicas <= object.maxReplicas
检查定义副本的三个字段是否大小关系正确 'Available' in object.stateCounts
检查映射中是否存在键为 Available
的条目 (size(object.list1) == 0) != (size(object.list2) == 0)
检查两个列表是否有且只有一个非空 !('MY_KEY' in object.map1) || object['MY_KEY'].matches('^[a-zA-Z]*$')
检查映射中存在特定的键时其取值符合某规则 object.envars.filter(e, e.name == 'MY_ENV').all(e, e.value.matches('^[a-zA-Z]*$')
验证 listMap 中所有键名为 "MY_ENV" 的条目的 “value” 字段,确保其符合规则 has(object.expired) && object.created + object.ttl < object.expired
检查 expired 日期在 create 日期加上 ttl 时长之后 object.health.startsWith('ok')
检查 health 字符串字段的取值有 “ok” 前缀 object.widgets.exists(w, w.key == 'x' && w.foo < 10)
对于 listMap 中键为 “x” 的条目,检查该条目的 "foo" 属性的值是否小于 10 type(object) == string ? object == '100%' : object == 1000
对于 int-or-string 字段,分别处理类型为 int 或 string 的情况 object.metadata.name.startsWith(object.prefix)
检查对象名称是否以另一个字段值为前缀 object.set1.all(e, !(e in object.set2))
检查两个 listSet 是否不相交 size(object.names) == size(object.details) && object.names.all(n, n in object.details)
检查映射 “details” 所有的键和 listSet “names” 中的条目是否一致 size(object.clusters.filter(c, c.name == object.primary)) == 1
检查 “primary” 字段的值在 listMap “clusters” 中只出现一次
了解关于 CEL 规则的更多信息, 请阅读
CEL 支持的求值表达式 。
spec.validation[i].reason
表示一个机器可读的描述,说明为什么这次检查失败。
如果这是列表中第一个失败的检查,其原因以及相应的 HTTP 响应代码会被用在给客户端的 HTTP 响应中。
目前支持的原因有:Unauthorized
、Forbidden
、Invalid
、RequestEntityTooLarge
。
如果未设置,将在对客户端的响应中使用 StatusReasonInvalid
。
匹配请求:matchConditions
如果需要进行精细的请求过滤,可以为 ValidatingAdmissionPolicy
定义 匹配条件(match conditions) 。
如果发现匹配规则、objectSelectors
和 namespaceSelectors
仍无法提供所需的过滤功能,则使用这些条件非常有用。
匹配条件是 CEL 表达式 。
所有匹配条件必须求值为 true 时才会对资源进行评估。
以下示例说明了匹配条件的几个不同用法:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
metadata :
name : "demo-policy.example.com"
spec :
failurePolicy : Fail
matchConstraints :
resourceRules :
- apiGroups : ["*" ]
apiVersions : ["*" ]
operations : ["CREATE" , "UPDATE" ]
resources : ["*" ]
matchConditions :
- name : 'exclude-leases' # 每个匹配条件必须有一个唯一的名称
expression : '!(request.resource.group == "coordination.k8s.io" && request.resource.resource == "leases")' # 匹配非租约资源
- name : 'exclude-kubelet-requests'
expression : '!("system:nodes" in request.userInfo.groups)' # 匹配非节点用户发出的请求
- name : 'rbac' # 跳过 RBAC 请求
expression : 'request.resource.group != "rbac.authorization.k8s.io"'
validations :
- expression : "!object.metadata.name.contains('demo') || object.metadata.namespace == 'demo'"
这些匹配条件可以访问与验证表达式相同的 CEL 变量。
在评估匹配条件时出现错误时,将不会评估策略。根据以下方式确定是否拒绝请求:
如果任何一个 匹配条件求值结果为 false
(不管其他错误),API 服务器将跳过 Webhook。
否则:
审计注解 auditAnnotations
可用于在 API 请求的审计事件中包括审计注解。
例如,以下是带有审计注解的准入策略:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
metadata :
name : "demo-policy.example.com"
spec :
failurePolicy : Fail
matchConstraints :
resourceRules :
- apiGroups : ["apps" ]
apiVersions : ["v1" ]
operations : ["CREATE" , "UPDATE" ]
resources : ["deployments" ]
validations :
- key : "high-replica-count"
expression : "object.spec.replicas > 50"
messageExpression : "'Deployment spec.replicas set to ' + string(object.spec.replicas)"
当使用此准入策略验证 API 请求时,生成的审计事件将如下所示:
# the audit event recorded
{
"kind": "Event",
"apiVersion": "audit.k8s.io/v1",
"annotations": {
"demo-policy.example.com/high-replica-count": "Deployment spec.replicas set to 128"
# other annotations
...
}
# other fields
...
}
在此示例中,只有 Deployment 的 spec.replicas
大于 50 时才会包含注解,
否则 CEL 表达式将求值为 null,并且不会包含注解。
请注意,审计注解键以 ValidatingAdmissionWebhook
的名称和 /
为前缀。
如果另一个准入控制器(例如准入 Webhook)使用完全相同的审计注解键,
则第一个包括审计注解值的准入控制器将出现在审计事件中,而所有其他值都将被忽略。
消息表达式 为了在策略拒绝请求时返回更友好的消息,我们在 spec.validations[i].messageExpression
中使用 CEL 表达式来构造消息。
与验证表达式类似,消息表达式可以访问 object
、oldObject
、request
和 params
。
但是,与验证不同,消息表达式必须求值为字符串。
例如,为了在策略引用参数时更好地告知用户拒绝原因,我们可以有以下验证:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
metadata :
name : "deploy-replica-policy.example.com"
spec :
paramKind :
apiVersion : rules.example.com/v1
kind : ReplicaLimit
matchConstraints :
resourceRules :
- apiGroups : ["apps" ]
apiVersions : ["v1" ]
operations : ["CREATE" , "UPDATE" ]
resources : ["deployments" ]
validations :
- expression : "object.spec.replicas <= params.maxReplicas"
messageExpression : "'object.spec.replicas must be no greater than ' + string(params.maxReplicas)"
reason : Invalid
在创建限制副本为 3 的 Params 对象并设置绑定之后,当我们尝试创建具有 5 个副本的 Deployment
时,我们将收到以下消息:
$ kubectl create deploy --image=nginx nginx --replicas=5
error: failed to create deployment: deployments.apps "nginx" is forbidden: ValidatingAdmissionPolicy 'deploy-replica-policy.example.com' with binding 'demo-binding-test.example.com' denied request: object.spec.replicas must be no greater than 3
这比静态消息 "too many replicas" 更具说明性。
如果既定义了消息表达式,又在 spec.validations[i].message
中定义了静态消息,
则消息表达式优先于静态消息。
但是,如果消息表达式求值失败,则将使用静态消息。
此外,如果消息表达式求值为多行字符串,则会丢弃求值结果并使用静态消息(如果存在)。
请注意,静态消息也要检查是否存在多行字符串。
类型检查 创建或更新策略定义时,验证过程将解析它包含的表达式,在发现错误时报告语法错误并拒绝该定义。
之后,引用的变量将根据 spec.matchConstraints
的匹配类型检查类型错误,包括缺少字段和类型混淆。
类型检查的结果可以从 status.typeChecking
中获得。
status.typeChecking
的存在表示类型检查已完成,而空的 status.typeChecking
表示未发现错误。
例如,给定以下策略定义:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
metadata :
name : "deploy-replica-policy.example.com"
spec :
matchConstraints :
resourceRules :
- apiGroups : ["apps" ]
apiVersions : ["v1" ]
operations : ["CREATE" , "UPDATE" ]
resources : ["deployments" ]
validations :
- expression : "object.replicas > 1" # 应该是 object.spec.replicas > 1
message : "must be replicated"
reason : Invalid
status 字段将提供以下信息:
status :
typeChecking :
expressionWarnings :
- fieldRef : spec.validations[0].expression
warning : |-
apps/v1, Kind=Deployment: ERROR: <input>:1:7: undefined field 'replicas'
| object.replicas > 1
| ......^
如果在 spec.matchConstraints
中匹配了多个资源,则所有匹配的资源都将进行检查。
例如,以下策略定义:
apiVersion : admissionregistration.k8s.io/v1alpha1
kind : ValidatingAdmissionPolicy
metadata :
name : "replica-policy.example.com"
spec :
matchConstraints :
resourceRules :
- apiGroups : ["apps" ]
apiVersions : ["v1" ]
operations : ["CREATE" , "UPDATE" ]
resources : ["deployments" ,"replicasets" ]
validations :
- expression : "object.replicas > 1" # 应该是 object.spec.replicas > 1
message : "must be replicated"
reason : Invalid
将具有多个类型,并在警告消息中提供每种类型的类型检查结果。
status :
typeChecking :
expressionWarnings :
- fieldRef : spec.validations[0].expression
warning : |-
apps/v1, Kind=Deployment: ERROR: <input>:1:7: undefined field 'replicas'
| object.replicas > 1
| ......^
apps/v1, Kind=ReplicaSet: ERROR: <input>:1:7: undefined field 'replicas'
| object.replicas > 1
| ......^
类型检查具有以下限制:
没有通配符匹配。
如果 spec.matchConstraints.resourceRules
中的任何一个 apiGroups``、apiVersions
或 resources
包含 "*",则不会检查与 "*" 匹配的类型。 匹配的类型数量最多为 10 种。这是为了防止手动指定过多类型的策略消耗过多计算资源。
按升序处理组、版本,然后是资源,忽略第 11 个及其之后的组合。 类型检查不会以任何方式影响策略行为。即使类型检查检测到错误,策略也将继续评估。
如果在评估期间出现错误,则失败策略将决定其结果。 类型检查不适用于 CRD(自定义资源定义),包括匹配的 CRD 类型和 paramKind 的引用。
对 CRD 的支持将在未来发布中推出。 4 - 众所周知的标签、注解和污点 Kubernetes 将所有标签和注解保留在 kubernetes.io 和 k8s.io 名字空间中。
本文档既可作为值的参考,也可作为分配值的协调点。
API 对象上使用的标签、注解和污点 app.kubernetes.io/component 例子:app.kubernetes.io/component: "database"
用于:所有对象(通常用于工作负载资源 )。
架构中的组件。
推荐标签 之一。
app.kubernetes.io/created-by(已弃用) 示例:app.kubernetes.io/created-by: "controller-manager"
用于:所有对象(通常用于工作负载资源 )。
创建此资源的控制器/用户。
app.kubernetes.io/instance 示例:app.kubernetes.io/instance: "mysql-abcxzy"
用于:所有对象(通常用于工作负载资源 )。
标识应用实例的唯一名称。要分配一个不唯一的名称,可使用 app.kubernetes.io/name 。
推荐标签 之一。
app.kubernetes.io/managed-by 示例:app.kubernetes.io/managed-by: "helm"
用于:所有对象(通常用于工作负载资源 )。
用于管理应用操作的工具。
推荐标签 之一。
app.kubernetes.io/name 示例:app.kubernetes.io/name: "mysql"
用于:所有对象(通常用于工作负载资源 )。
应用的名称。
推荐标签 之一。
app.kubernetes.io/part-of 示例:app.kubernetes.io/part-of: "wordpress"
用于:所有对象(通常用于工作负载资源 )。
此应用所属的更高级别应用的名称。
推荐标签 之一。
app.kubernetes.io/version 示例:app.kubernetes.io/version: "5.7.21"
用于:所有对象(通常用于工作负载资源 )。
值的常见形式包括:
推荐标签 之一。
cluster-autoscaler.kubernetes.io/safe-to-evict 例子:cluster-autoscaler.kubernetes.io/safe-to-evict: "true"
用于:Pod
当这个注解设置为 "true"
时,即使其他规则通常会阻止驱逐操作,也会允许该集群自动扩缩器驱逐一个 Pod。
集群自动扩缩器从不驱逐将此注解显式设置为 "false"
的 Pod;你可以针对要保持运行的重要 Pod 设置此注解。
如果未设置此注解,则集群自动扩缩器将遵循其 Pod 级别的行为。
config.kubernetes.io/local-config 例子:config.kubernetes.io/local-config: "true"
用于:所有对象
该注解用于清单中的对象,表示某对象是本地配置,不应提交到 Kubernetes API。
对于这个注解,当值为 "true" 时,表示该对象仅被客户端工具使用,不应提交到 API 服务器。
当值为 "false",可以用来声明该对象应提交到 API 服务器,即使它是本地对象。
该注解是 Kubernetes 资源模型 (KRM) 函数规范的一部分,被 Kustomize 和其他类似的第三方工具使用。
例如,Kustomize 会从其最终构建输出中删除带有此注解的对象。
internal.config.kubernetes.io/* (保留的前缀) 用于:所有对象
该前缀被保留,供遵从 Kubernetes 资源模型 (KRM) 函数规范的编排工具内部使用。
带有该前缀的注解仅在编排过程中使用,不会持久化到文件系统。
换句话说,编排工具应从本地文件系统读取文件时设置这些注解,并在将函数输出写回文件系统时删除它们。
除非特定注解另有说明,KRM 函数不得修改带有此前缀的注解。
这使得编排工具可以添加额外的内部注解,而不需要更改现有函数。
internal.config.kubernetes.io/path 例子:internal.config.kubernetes.io/path: "relative/file/path.yaml"
用于:所有对象
此注解记录了加载对象清单文件的(斜线分隔、与操作系统无关)相对路径。
该路径相对于文件系统上由编排工具确定的固定位置。
该注解是 Kubernetes 资源模型 (KRM) 函数规范的一部分,被 Kustomize 和其他类似的第三方工具使用。
KRM 函数不应 在输入对象上修改此注解,除非它正在修改引用的文件。
KRM 函数可以 在它所生成的对象上包含这个注解。
internal.config.kubernetes.io/index 例子:internal.config.kubernetes.io/index: "2"
用于:所有对象
该注解记录了包含对象的 YAML 文档在加载对象的清单文件中的零索引位置。
请注意,YAML 文档由三个破折号 (---) 分隔,每个文档可以包含一个对象。
如果未指定此注解,则该值为 0。
该注解是 Kubernetes 资源模型 (KRM) 函数规范的一部分,被 Kustomize 和其他类似的第三方工具使用。
KRM 函数不应 在输入对象上修改此注解,除非它正在修改引用的文件。
KRM 函数可以 在它所生成的对象上包含这个注解。
kubernetes.io/arch 例子:kubernetes.io/arch: "amd64"
用于:Node
Kubelet 使用 Go 定义的 runtime.GOARCH
填充它。如果你混合使用 ARM 和 X86 节点,这会很方便。
kubernetes.io/os 例子:kubernetes.io/os: "linux"
用于:Node,Pod
对于节点,kubelet 会根据 Go 定义的 runtime.GOOS
填充这个值。
你可以很方便地在集群中混合使用操作系统(例如:混合使用 Linux 和 Windows 节点)。
你还可以在 Pod 上设置这个标签。
Kubernetes 允许你为此标签设置任何值;如果你使用此标签,
你应该将其设置为与该 Pod 实际使用的操作系统相对应的 Go runtime.GOOS
字符串。
当 Pod 的 kubernetes.io/os 标签值与节点上的标签值不匹配时,节点上的 kubelet 不会运行该 Pod。
但是,kube-scheduler 并未考虑这一点。
另外,如果你为 Pod 指定的操作系统与运行该 kubelet 的节点操作系统不相同,那么 kubelet 会拒绝运行该 Pod。
请查看 Pod 操作系统 了解更多详情。
例子:kubernetes.io/metadata.name: "mynamespace"
用于:Namespace
Kubernetes API 服务器(控制平面 的一部分)在所有 Namespace 上设置此标签。
标签值被设置 Namespace 的名称。你无法更改此标签的值。
如果你想使用标签选择算符 定位特定 Namespace,这很有用。
kubernetes.io/limit-ranger 例子:kubernetes.io/limit-ranger: "LimitRanger plugin set: cpu, memory request for container nginx; cpu, memory limit for container nginx"
用于:Pod
Kubernetes 默认不提供任何资源限制,这意味着除非你明确定义限制,否则你的容器将可以无限消耗 CPU 和内存。
你可以为 Pod 定义默认请求或默认限制。为此,你可以在相关命名空间中创建一个 LimitRange。
在你定义 LimitRange 后部署的 Pod 将受到这些限制。
注解 kubernetes.io/limit-ranger
记录了为 Pod 指定的资源默认值,以及成功应用这些默认值。
有关更多详细信息,请阅读 LimitRanges 。
beta.kubernetes.io/arch (已弃用) 此标签已被弃用。请改用 kubernetes.io/arch
。
beta.kubernetes.io/os (已弃用) 此标签已被弃用。请改用 kubernetes.io/os
。
kube-aggregator.kubernetes.io/automanaged 例子:kube-aggregator.kubernetes.io/automanaged: "onstart"
用于:APIService
kube-apiserver
会在由 API 服务器自动创建的所有 APIService 对象上设置这个标签。
该标签标记了控制平面应如何管理该 APIService。你不应自行添加、修改或删除此标签。
说明: 当自动托管的 APIService 对象没有内置或自定义资源 API 对应于该 APIService 的 API 组/版本时,
它将被 kube-apiserver 删除。
有两个可能的值:
onstart
:API 服务器应在启动时协调 APIService,但在其他时间不会进行协调。true
:API 服务器应持续协调此 APIService。service.alpha.kubernetes.io/tolerate-unready-endpoints(已弃用) 用于:StatefulSet
Service 上的这个注解表示 Endpoints 控制器是否应该继续为未准备好的 Pod 创建 Endpoints。
这些 Service 的 Endpoints 保留其 DNS 记录,并从 kubelet 启动 Pod 中的所有容器并将其标记为
Running 的那一刻起继续接收 Service 的流量,直到 kubelet 停止所有容器并从 API 服务器删除 Pod 为止。
kubernetes.io/hostname 例子:kubernetes.io/hostname: "ip-172-20-114-199.ec2.internal"
用于:Node
Kubelet 使用主机名填充此标签。请注意,可以通过将 --hostname-override
标志传递给 kubelet
来替代“实际”主机名。
此标签也用作拓扑层次结构的一部分。有关详细信息,请参阅 topology.kubernetes.io/zone 。
kubernetes.io/change-cause 例子:kubernetes.io/change-cause: "kubectl edit --record deployment foo"
用于:所有对象
此注解是对某些事物发生变更的原因的最佳猜测。
将 --record
添加到可能会更改对象的 kubectl
命令时会填充它。
kubernetes.io/description 例子:kubernetes.io/description: "Description of K8s object."
用于:所有对象
此注解用于描述给定对象的特定行为。
kubernetes.io/enforce-mountable-secrets 例子:kubernetes.io/enforce-mountable-secrets: "true"
用于:ServiceAccount
此注解的值必须为 true 才能生效。此注解表示作为此服务帐户运行的 Pod
只能引用在服务帐户的 secrets
字段中指定的 Secret API 对象。
node.kubernetes.io/exclude-from-external-load-balancer 例子:node.kubernetes.io/exclude-from-external-load-balancer
用于:Node
Kubernetes 自动在其创建的集群上启用 ServiceNodeExclusion
特性门控。
在一个集群上启用此特性门控后,你可以添加标签到特定的 Worker 节点,将这些节点从后端服务器列表排除在外。
以下命令可用于从后端集的后端服务器列表中排除一个 Worker 节点:
kubectl label nodes <node-name> node.kubernetes.io/exclude-from-external-load-balancers=true
controller.kubernetes.io/pod-deletion-cost 例子:controller.kubernetes.io/pod-deletion-cost: "10"
用于:Pod
该注解用于设置
Pod 删除成本 允许用户影响
ReplicaSet 缩减顺序。注解解析为 int32
类型。
cluster-autoscaler.kubernetes.io/enable-ds-eviction 例子:cluster-autoscaler.kubernetes.io/enable-ds-eviction: "true"
用于:Pod
该注解控制 DaemonSet Pod 是否应由 ClusterAutoscaler 驱逐。
该注解需要在 DaemonSet 清单中的 DaemonSet Pod 上指定。
当该注解设为 "true"
时,即使其他规则通常会阻止驱逐,也将允许 ClusterAutoscaler 驱逐 DaemonSet Pod。
要取消允许 ClusterAutoscaler 驱逐 DaemonSet Pod,你可以为重要的 DaemonSet Pod 将该注解设为 "false"
。
如果未设置该注解,则 Cluster Autoscaler 将遵循其整体行为(即根据其配置驱逐 DaemonSet)。
kubernetes.io/ingress-bandwidth 说明: 入站流量控制注解是一项实验性功能。
如果要启用流量控制支持,必须将 bandwidth
插件添加到 CNI 配置文件(默认为 /etc/cni/net.d
)
并确保二进制文件包含在你的 CNI bin 目录中(默认为 /opt/cni/bin
)。
示例:kubernetes.io/ingress-bandwidth: 10M
用于:Pod
你可以对 Pod 应用服务质量流量控制并有效限制其可用带宽。
入站流量(到 Pod)通过控制排队的数据包来处理,以有效地处理数据。
要限制 Pod 的带宽,请编写对象定义 JSON 文件并使用 kubernetes.io/ingress-bandwidth
注解指定数据流量速度。用于指定入站的速率单位是每秒,
作为量纲(Quantity) 。
例如,10M
表示每秒 10 兆比特。
kubernetes.io/egress-bandwidth 说明: 出站流量控制注解是一项实验性功能。
如果要启用流量控制支持,必须将 bandwidth
插件添加到 CNI 配置文件(默认为 /etc/cni/net.d
)
并确保二进制文件包含在你的 CNI bin 目录中(默认为 /opt/cni/bin
)。
示例:kubernetes.io/egress-bandwidth: 10M
用于:Pod
出站流量(来自 pod)由策略控制,策略只是丢弃超过配置速率的数据包。
你为一个 Pod 所设置的限制不会影响其他 Pod 的带宽。
要限制 Pod 的带宽,请编写对象定义 JSON 文件并使用 kubernetes.io/egress-bandwidth
注解指定数据流量速度。
用于指定出站的速率单位是每秒比特数,
以量纲(Quantity) 的形式给出。
例如,10M
表示每秒 10 兆比特。
beta.kubernetes.io/instance-type (已弃用) node.kubernetes.io/instance-type 例子:node.kubernetes.io/instance-type: "m3.medium"
用于:Node
Kubelet 使用 cloudprovider
定义的实例类型填充它。
仅当你使用 cloudprovider
时才会设置此项。如果你希望将某些工作负载定位到某些实例类型,则此设置非常方便,
但通常你希望依靠 Kubernetes 调度程序来执行基于资源的调度。
你应该基于属性而不是实例类型来调度(例如:需要 GPU,而不是需要 g2.2xlarge
)。
failure-domain.beta.kubernetes.io/region (已弃用) 请参阅 topology.kubernetes.io/region 。
failure-domain.beta.kubernetes.io/zone (已弃用) 请参阅 topology.kubernetes.io/zone 。
pv.kubernetes.io/bind-completed 例子:pv.kubernetes.io/bind-completed: "yes"
用于:PersistentVolumeClaim
当在 PersistentVolumeClaim (PVC) 上设置此注解时,表示 PVC 的生命周期已通过初始绑定设置。
当存在此注解时,该信息会改变控制平面解释 PVC 对象状态的方式。此注解的值对 Kubernetes 无关紧要。
pv.kubernetes.io/bound-by-controller 例子:pv.kubernetes.io/bound-by-controller: "yes"
用于:PersistentVolume、PersistentVolumeClaim
如果此注解设置在 PersistentVolume 或 PersistentVolumeClaim 上,则表示存储绑定
(PersistentVolume → PersistentVolumeClaim,或 PersistentVolumeClaim → PersistentVolume)
已由控制器 配置完毕。
如果未设置此注解,且存在存储绑定,则缺少该注解意味着绑定是手动完成的。此注解的值无关紧要。
pv.kubernetes.io/provisioned-by 例子:pv.kubernetes.io/provisioned-by: "kubernetes.io/rbd"
用于:PersistentVolume
此注解被添加到已由 Kubernetes 动态制备的 PersistentVolume (PV)。
它的值是创建卷的卷插件的名称。它同时服务于用户(显示 PV 的来源)和 Kubernetes(识别其决策中动态制备的 PV)。
pv.kubernetes.io/migrated-to 例子:pv.kubernetes.io/migrated-to: pd.csi.storage.gke.io
用于:PersistentVolume、PersistentVolumeClaim
它被添加到 PersistentVolume (PV) 和 PersistentVolumeClaim (PVC),应该由其相应的 CSI
驱动程序通过 CSIMigration
特性门控动态制备/删除。设置此注解后,Kubernetes 组件将“停止”,
而 external-provisioner
将作用于对象。
statefulset.kubernetes.io/pod-name 例子:statefulset.kubernetes.io/pod-name: "mystatefulset-7"
当 StatefulSet 控制器为 StatefulSet 创建 Pod 时,控制平面会在该 Pod 上设置此标签。标签的值是正在创建的 Pod 的名称。
有关详细信息,请参阅 StatefulSet 主题中的 Pod 名称标签 。
scheduler.alpha.kubernetes.io/node-selector 例子:scheduler.alpha.kubernetes.io/node-selector: "name-of-node-selector"
用于:Namespace
PodNodeSelector
使用此注解键为名字空间中的 Pod 设置节点选择算符。
topology.kubernetes.io/region 例子:topology.kubernetes.io/region: "us-east-1"
请参阅 topology.kubernetes.io/zone 。
topology.kubernetes.io/zone 例子:topology.kubernetes.io/zone: "us-east-1c"
用于:Node、PersistentVolume
在 Node 上:kubelet
或外部 cloud-controller-manager
使用 cloudprovider
提供的信息填充它。
仅当你使用 cloudprovider
时才会设置此项。
但是,如果它在你的拓扑中有意义,你应该考虑在 Node 上设置它。
在 PersistentVolume 上:拓扑感知卷配置器将自动在 PersistentVolume
上设置 Node 亲和性约束。
一个 Zone 代表一个逻辑故障域。Kubernetes 集群通常跨越多个 Zone 以提高可用性。虽然 Zone 的确切定义留给基础设施实现,
但 Zone 的常见属性包括 Zone 内非常低的网络延迟、Zone 内的免费网络流量以及与其他 Zone 的故障独立性。
例如,一个 Zone 内的 Node 可能共享一个网络交换机,但不同 Zone 中的 Node 无法共享交换机。
一个 Region 代表一个更大的域,由一个或多个 Zone 组成。Kubernetes 集群跨多个 Region 并不常见,
虽然 Zone 或 Region 的确切定义留给基础设施实现,
但 Region 的共同属性包括它们之间的网络延迟比它们内部更高,它们之间的网络流量成本非零,
以及与其他 Zone 或 Region 的故障独立性。
例如,一个 Region 内的 Node 可能共享电力基础设施(例如 UPS 或发电机),但不同 Region 的 Node 通常不会共享电力基础设施。
Kubernetes 对 Zone 和 Region 的结构做了一些假设:
Zone 和 Region 是分层的:Zone 是 Region 的严格子集,没有 Zone 可以在两个 Region 中;
Zone 名称跨 Region 是唯一的;例如,Region “africa-east-1” 可能由 Zone “africa-east-1a”
和 “africa-east-1b” 组成。
你可以大胆假设拓扑标签不会改变。尽管严格地讲标签是可变的,
但节点的用户可以假设给定节点只能通过销毁和重新创建才能完成 Zone 间移动。
Kubernetes 可以通过多种方式使用这些信息。例如,调度程序会自动尝试将 ReplicaSet 中的 Pod
分布在单 Zone 集群中的多个节点上(以便减少节点故障的影响,请参阅 kubernetes.io/hostname )。
对于多 Zone 集群,这种分布行为也适用于 Zone(以减少 Zone 故障的影响)。
Zone 级别的 Pod 分布是通过 SelectorSpreadPriority 实现的。
SelectorSpreadPriority 是一个尽力而为的放置机制。如果集群中的 Zone 是异构的
(例如:节点数量不同、节点类型不同或 Pod 资源需求有别等),这种放置机制可能会让你的
Pod 无法实现跨 Zone 均匀分布。
如果需要,你可以使用同质 Zone(节点数量和类型均相同)来减少不均匀分布的可能性。
调度程序还将(通过 VolumeZonePredicate 条件)确保申领给定卷的 Pod 仅被放置在与该卷相同的 Zone 中。
卷不能跨 Zone 挂接。
你应该考虑手动添加标签(或添加对 PersistentVolumeLabel
的支持)。
基于 PersistentVolumeLabel
,调度程序可以防止 Pod 挂载来自其他 Zone 的卷。
如果你的基础架构没有此限制,则不需要将 Zone 标签添加到卷上。
volume.beta.kubernetes.io/storage-provisioner (已弃用) 例子:volume.beta.kubernetes.io/storage-provisioner: "k8s.io/minikube-hostpath"
用于:PersistentVolumeClaim
此注解已被弃用。
volume.beta.kubernetes.io/storage-class(已弃用) 例子:volume.beta.kubernetes.io/storage-class: "example-class"
用于:PersistentVolume、PersistentVolumeClaim
此注解可以为 PersistentVolume (PV) 或 PersistentVolumeClaim (PVC) 指定
StorageClass 。
当 storageClassName
属性和 volume.beta.kubernetes.io/storage-class
注解均被指定时,
注解 volume.beta.kubernetes.io/storage-class
将优先于 storageClassName
属性。
此注解已被弃用。作为替代方案,你应该为 PersistentVolumeClaim 或 PersistentVolume 设置
storageClassName
字段 。
volume.beta.kubernetes.io/mount-options(已弃用) 例子:volume.beta.kubernetes.io/mount-options: "ro,soft"
用于:PersistentVolume
针对 PersistentVolume 挂载到一个节点上的情形,
Kubernetes 管理员可以指定更多的挂载选项 。
该注解已弃用。
volume.kubernetes.io/storage-provisioner 用于:PersistentVolumeClaim
此注解将被添加到根据需要动态制备的 PVC 上。
volume.kubernetes.io/selected-node 用于:PersistentVolumeClaim
此注解被添加到调度程序所触发的 PVC 上,对应的 PVC 需要被动态制备。注解值是选定节点的名称。
volumes.kubernetes.io/controller-managed-attach-detach 用于:Node
如果节点已在其自身上设置了注解 volumes.kubernetes.io/controller-managed-attach-detach
,
那么它的存储挂接和解除挂接的操作是交由运行在
kube-controller-manager
中的卷挂接/解除挂接 控制器 来管理的。
注解的值并不重要;如果节点上存在该注解,则由控制器管理存储挂接和解除挂接的操作。
node.kubernetes.io/windows-build 例子:node.kubernetes.io/windows-build: "10.0.17763"
用于:Node
当 kubelet 在 Microsoft Windows 上运行时,它会自动标记其所在节点以记录所使用的 Windows Server 的版本。
标签的值采用 “MajorVersion.MinorVersion.BuildNumber” 格式。
service.kubernetes.io/headless 例子:service.kubernetes.io/headless: ""
用于:Service
当拥有的 Service 是无头类型时,控制平面将此标签添加到 Endpoints 对象。
kubernetes.io/service-name 例子:kubernetes.io/service-name: "my-website"
用于:EndpointSlice
Kubernetes 使用这个标签将
EndpointSlices
与服务 关联。
这个标签记录了 EndpointSlice 后备服务的名称 。
所有 EndpointSlice 都应将此标签设置为其关联服务的名称。
kubernetes.io/service-account.name 示例:kubernetes.io/service-account.name: "sa-name"
用于:Secret
这个注解记录了令牌(存储在 kubernetes.io/service-account-token
类型的 Secret 中)所代表的
ServiceAccount 的名称 。
kubernetes.io/service-account.uid 示例:kubernetes.io/service-account.uid: da68f9c6-9d26-11e7-b84e-002dc52800da
用于:Secret
该注解记录了令牌(存储在 kubernetes.io/service-account-token
类型的 Secret 中)所代表的
ServiceAccount 的唯一 ID 。
kubernetes.io/legacy-token-last-used 例子:kubernetes.io/legacy-token-last-used: 2022-10-24
用于:Secret
控制面仅为 kubernetes.io/service-account-token
类型的 Secret 添加此标签。
该标签的值记录着控制面最近一次接到客户端使用服务帐户令牌进行身份验证请求的日期(ISO 8601
格式,UTC 时区)
如果上一次使用老的令牌的时间在集群获得此特性(添加于 Kubernetes v1.26)之前,则不会设置此标签。
endpointslice.kubernetes.io/managed-by 例子:endpointslice.kubernetes.io/managed-by: "controller"
用于:EndpointSlice
用于标示管理 EndpointSlice 的控制器或实体。该标签旨在使不同的 EndpointSlice
对象能够由同一集群内的不同控制器或实体管理。
endpointslice.kubernetes.io/skip-mirror 例子:endpointslice.kubernetes.io/skip-mirror: "true"
用于:Endpoints
可以在 Endpoints 资源上将此标签设置为 "true"
,以指示 EndpointSliceMirroring
控制器不应使用 EndpointSlice 镜像此 Endpoints 资源。
service.kubernetes.io/service-proxy-name 例子:service.kubernetes.io/service-proxy-name: "foo-bar"
用于:Service
kube-proxy 自定义代理会使用这个标签,它将服务控制委托给自定义代理。
experimental.windows.kubernetes.io/isolation-type (已弃用) 例子:experimental.windows.kubernetes.io/isolation-type: "hyperv"
用于:Pod
注解用于运行具有 Hyper-V 隔离的 Windows 容器。要使用 Hyper-V 隔离功能并创建 Hyper-V
隔离容器,kubelet 启动时应该需要设置特性门控 HyperVContainer=true。
说明: 你只能在具有单个容器的 Pod 上设置此注解。
从 v1.20 开始,此注解已弃用。1.21 中删除了实验性 Hyper-V 支持。
ingressclass.kubernetes.io/is-default-class 例子:ingressclass.kubernetes.io/is-default-class: "true"
用于:IngressClass
当单个 IngressClass 资源将此注解设置为 "true"
时,新的未指定 Ingress 类的 Ingress
资源将被设置为此默认类。
kubernetes.io/ingress.class (已弃用) 说明: 从 v1.18 开始,不推荐使用此注解以鼓励使用 spec.ingressClassName
。