这是本节的多页打印视图。
点击此处打印 .
返回本页常规视图 .
工作负载 理解 Pods，Kubernetes 中可部署的最小计算对象，以及辅助它运行它们的高层抽象对象。
工作负载是在 Kubernetes 上运行的应用程序。
无论你的负载是单一组件还是由多个一同工作的组件构成，在 Kubernetes 中你
可以在一组 Pods 中运行它。
在 Kubernetes 中，Pod 代表的是集群上处于运行状态的一组
容器 。
Kubernetes Pods 有确定的生命周期 。
例如，当某 Pod 在你的集群中运行时，Pod 运行所在的
节点 出现致命错误时，
所有该节点上的 Pods 都会失败。Kubernetes 将这类失败视为最终状态：
即使该节点后来恢复正常运行，你也需要创建新的 Pod 来恢复应用。
不过，为了让用户的日子略微好过一些，你并不需要直接管理每个 Pod。
相反，你可以使用 负载资源 来替你管理一组 Pods。
这些资源配置 控制器
来确保合适类型的、处于运行状态的 Pod 个数是正确的，与你所指定的状态相一致。
Kubernetes 提供若干种内置的工作负载资源：
DaemonSet
定义提供节点本地支撑设施的 Pods。这些 Pods 可能对于你的集群的运维是
非常重要的，例如作为网络链接的辅助工具或者作为网络
插件
的一部分等等。每次你向集群中添加一个新节点时，如果该节点与某 DaemonSet
的规约匹配，则控制面会为该 DaemonSet 调度一个 Pod 到该新节点上运行。Job 和
CronJob 。
定义一些一直运行到结束并停止的任务。Job 用来表达的是一次性的任务，而
CronJob 会根据其时间规划反复运行。在庞大的 Kubernetes 生态系统中，你还可以找到一些提供额外操作的第三方
工作负载资源。通过使用
定制资源定义（CRD） ，
你可以添加第三方工作负载资源，以完成原本不是 Kubernetes 核心功能的工作。
例如，如果你希望运行一组 Pods，但要求所有 Pods 都可用时才执行操作
（比如针对某种高吞吐量的分布式任务），你可以实现一个能够满足这一需求
的扩展，并将其安装到集群中运行。
接下来 除了阅读了解每类资源外，你还可以了解与这些资源相关的任务：
要了解 Kubernetes 将代码与配置分离的实现机制，可参阅
配置部分 。
关于 Kubernetes 如何为应用管理 Pods，还有两个支撑概念能够提供相关背景信息：
一旦你的应用处于运行状态，你就可能想要以
ServiceIngress
1 - Pods Pod 是可以在 Kubernetes 中创建和管理的、最小的可部署的计算单元。
Pod （就像在鲸鱼荚或者豌豆荚中）是一组（一个或多个）
容器 ；
这些容器共享存储、网络、以及怎样运行这些容器的声明。
Pod 中的内容总是并置（colocated）的并且一同调度，在共享的上下文中运行。
Pod 所建模的是特定于应用的“逻辑主机”，其中包含一个或多个应用容器，
这些容器是相对紧密的耦合在一起的。
在非云环境中，在相同的物理机或虚拟机上运行的应用类似于
在同一逻辑主机上运行的云应用。
除了应用容器，Pod 还可以包含在 Pod 启动期间运行的
Init 容器 。
你也可以在集群中支持临时性容器
的情况下，为调试的目的注入临时性容器。
什么是 Pod？ 说明： 除了 Docker 之外，Kubernetes 支持
很多其他
容器运行时 ，
Docker 是最有名的运行时，
使用 Docker 的术语来描述 Pod 会很有帮助。
Pod 的共享上下文包括一组 Linux 名字空间、控制组（cgroup）和可能一些其他的隔离
方面，即用来隔离 Docker 容器的技术。
在 Pod 的上下文中，每个独立的应用可能会进一步实施隔离。
就 Docker 概念的术语而言，Pod 类似于共享名字空间和文件系统卷的一组 Docker
容器。
使用 Pod 通常你不需要直接创建 Pod，甚至单实例 Pod。
相反，你会使用诸如
Deployment 或
Job 这类工作负载资源
来创建 Pod。如果 Pod 需要跟踪状态，
可以考虑 StatefulSet
资源。
Kubernetes 集群中的 Pod 主要有两种用法：
运行单个容器的 Pod 。"每个 Pod 一个容器"模型是最常见的 Kubernetes 用例；
在这种情况下，可以将 Pod 看作单个容器的包装器，并且 Kubernetes 直接管理 Pod，而不是容器。
运行多个协同工作的容器的 Pod 。
Pod 可能封装由多个紧密耦合且需要共享资源的共处容器组成的应用程序。
这些位于同一位置的容器可能形成单个内聚的服务单元 —— 一个容器将文件从共享卷提供给公众，
而另一个单独的“挂斗”（sidecar）容器则刷新或更新这些文件。
Pod 将这些容器和存储资源打包为一个可管理的实体。
说明： 将多个并置、同管的容器组织到一个 Pod 中是一种相对高级的使用场景。
只有在一些场景中，容器之间紧密关联时你才应该使用这种模式。
每个 Pod 都旨在运行给定应用程序的单个实例。如果希望横向扩展应用程序（例如，运行多个实例
以提供更多的资源），则应该使用多个 Pod，每个实例使用一个 Pod。
在 Kubernetes 中，这通常被称为 副本（Replication） 。
通常使用一种工作负载资源及其控制器
来创建和管理一组 Pod 副本。
参见 Pod 和控制器 以了解 Kubernetes
如何使用工作负载资源及其控制器以实现应用的扩缩和自动修复。
Pod 怎样管理多个容器 Pod 被设计成支持形成内聚服务单元的多个协作过程（形式为容器）。
Pod 中的容器被自动安排到集群中的同一物理机或虚拟机上，并可以一起进行调度。
容器之间可以共享资源和依赖、彼此通信、协调何时以及何种方式终止自身。
例如，你可能有一个容器，为共享卷中的文件提供 Web 服务器支持，以及一个单独的
“sidecar（挂斗）”容器负责从远端更新这些文件，如下图所示：
有些 Pod 具有 Init 容器 和
应用容器 。
Init 容器会在启动应用容器之前运行并完成。
Pod 天生地为其成员容器提供了两种共享资源：网络 和
存储 。
使用 Pod 你很少在 Kubernetes 中直接创建一个个的 Pod，甚至是单实例（Singleton）的 Pod。
这是因为 Pod 被设计成了相对临时性的、用后即抛的一次性实体。
当 Pod 由你或者间接地由 控制器
创建时，它被调度在集群中的节点 上运行。
Pod 会保持在该节点上运行，直到 Pod 结束执行、Pod 对象被删除、Pod 因资源不足而被
驱逐 或者节点失效为止。
说明： 重启 Pod 中的容器不应与重启 Pod 混淆。
Pod 不是进程，而是容器运行的环境。
在被删除之前，Pod 会一直存在。
当你为 Pod 对象创建清单时，要确保所指定的 Pod 名称是合法的
DNS 子域名 。
Pod 和控制器 你可以使用工作负载资源来创建和管理多个 Pod。
资源的控制器能够处理副本的管理、上线，并在 Pod 失效时提供自愈能力。
例如，如果一个节点失败，控制器注意到该节点上的 Pod 已经停止工作，
就可以创建替换性的 Pod。调度器会将替身 Pod 调度到一个健康的节点执行。
下面是一些管理一个或者多个 Pod 的工作负载资源的示例：
Pod 模版 负载 资源的控制器通常使用
Pod 模板（Pod Template） 来替你创建 Pod 并管理它们。
Pod 模板是包含在工作负载对象中的规范，用来创建 Pod。这类负载资源包括
Deployment 、
Job 和
DaemonSets 等。
工作负载的控制器会使用负载对象中的 PodTemplate 来生成实际的 Pod。
PodTemplate 是你用来运行应用时指定的负载资源的目标状态的一部分。
下面的示例是一个简单的 Job 的清单，其中的 template 指示启动一个容器。
该 Pod 中的容器会打印一条消息之后暂停。
apiVersion : batch/v1
kind : Job
metadata :
name : hello
spec :
template :
# 这里是 Pod 模版
spec :
containers :
- name : hello
image : busybox
command : ['sh' , '-c' , 'echo "Hello, Kubernetes!" && sleep 3600' ]
restartPolicy : OnFailure
# 以上为 Pod 模版
修改 Pod 模版或者切换到新的 Pod 模版都不会对已经存在的 Pod 起作用。
Pod 不会直接收到模版的更新。相反，
新的 Pod 会被创建出来，与更改后的 Pod 模版匹配。
例如，Deployment 控制器针对每个 Deployment 对象确保运行中的 Pod 与当前的 Pod
模版匹配。如果模版被更新，则 Deployment 必须删除现有的 Pod，基于更新后的模版
创建新的 Pod。每个工作负载资源都实现了自己的规则，用来处理对 Pod 模版的更新。
在节点上，kubelet 并不直接监测
或管理与 Pod 模版相关的细节或模版的更新，这些细节都被抽象出来。
这种抽象和关注点分离简化了整个系统的语义，并且使得用户可以在不改变现有代码的
前提下就能扩展集群的行为。
Pod 更新与替换 正如前面章节所述，当某工作负载的 Pod 模板被改变时，控制器会基于更新的模板
创建新的 Pod 对象而不是对现有 Pod 执行更新或者修补操作。
Kubernetes 并不禁止你直接管理 Pod。对运行中的 Pod 的某些字段执行就地更新操作
还是可能的。不过，类似
patchreplace
Pod 的绝大多数元数据都是不可变的。例如，你不可以改变其 namespace、name、
uid 或者 creationTimestamp 字段；generation 字段是比较特别的，如果更新
该字段，只能增加字段取值而不能减少。
如果 metadata.deletionTimestamp 已经被设置，则不可以向 metadata.finalizers
列表中添加新的条目。
Pod 更新不可以改变除 spec.containers[*].image、spec.initContainers[*].image、
spec.activeDeadlineSeconds 或 spec.tolerations 之外的字段。
对于 spec.tolerations，你只被允许添加新的条目到其中。
在更新spec.activeDeadlineSeconds 字段时，以下两种更新操作是被允许的：
如果该字段尚未设置，可以将其设置为一个正数； 如果该字段已经设置为一个正数，可以将其设置为一个更小的、非负的整数。 资源共享和通信 Pod 使它的成员容器间能够进行数据共享和通信。
Pod 中的存储 一个 Pod 可以设置一组共享的存储卷 。
Pod 中的所有容器都可以访问该共享卷，从而允许这些容器共享数据。
卷还允许 Pod 中的持久数据保留下来，即使其中的容器需要重新启动。
有关 Kubernetes 如何在 Pod 中实现共享存储并将其提供给 Pod 的更多信息，
请参考卷 。
Pod 联网 每个 Pod 都在每个地址族中获得一个唯一的 IP 地址。
Pod 中的每个容器共享网络名字空间，包括 IP 地址和网络端口。
Pod 内 的容器可以使用 localhost 互相通信。
当 Pod 中的容器与 Pod 之外 的实体通信时，它们必须协调如何使用共享的网络资源
（例如端口）。
在同一个 Pod 内，所有容器共享一个 IP 地址和端口空间，并且可以通过 localhost 发现对方。
他们也能通过如 SystemV 信号量或 POSIX 共享内存这类标准的进程间通信方式互相通信。
不同 Pod 中的容器的 IP 地址互不相同，没有
特殊配置 就不能使用 IPC 进行通信。
如果某容器希望与运行于其他 Pod 中的容器通信，可以通过 IP 联网的方式实现。
Pod 中的容器所看到的系统主机名与为 Pod 配置的 name 属性值相同。
网络 部分提供了更多有关此内容的信息。
容器的特权模式 Pod 中的任何容器都可以使用容器规约中的
安全性上下文 中的
privileged 参数启用特权模式。
这对于想要使用操作系统管理权能（Capabilities，如操纵网络堆栈和访问设备）
的容器很有用。
容器内的进程几乎可以获得与容器外的进程相同的特权。
说明： 你的
容器运行时 必须支持
特权容器的概念才能使用这一配置。
静态 Pod 静态 Pod（Static Pod） 直接由特定节点上的 kubelet 守护进程管理，
不需要API 服务器 看到它们。
尽管大多数 Pod 都是通过控制面（例如，Deployment ）
来管理的，对于静态 Pod 而言，kubelet 直接监控每个 Pod，并在其失效时重启之。
静态 Pod 通常绑定到某个节点上的 kubelet 。
其主要用途是运行自托管的控制面。
在自托管场景中，使用 kubelet 来管理各个独立的
控制面组件 。
kubelet 自动尝试为每个静态 Pod 在 Kubernetes API 服务器上创建一个
镜像 Pod 。
这意味着在节点上运行的 Pod 在 API 服务器上是可见的，但不可以通过 API
服务器来控制。
接下来 要了解为什么 Kubernetes 会在其他资源
（如 StatefulSet
或 Deployment ）
封装通用的 Pod API，相关的背景信息可以在前人的研究中找到。具体包括：
1.1 - Pod 的生命周期 本页面讲述 Pod 的生命周期。
Pod 遵循一个预定义的生命周期，起始于 Pending 阶段 ，如果至少
其中有一个主要容器正常启动，则进入 Running，之后取决于 Pod 中是否有容器以
失败状态结束而进入 Succeeded 或者 Failed 阶段。
在 Pod 运行期间，kubelet 能够重启容器以处理一些失效场景。
在 Pod 内部，Kubernetes 跟踪不同容器的状态
并确定使 Pod 重新变得健康所需要采取的动作。
在 Kubernetes API 中，Pod 包含规约部分和实际状态部分。
Pod 对象的状态包含了一组 Pod 状况（Conditions） 。
如果应用需要的话，你也可以向其中注入自定义的就绪性信息 。
Pod 在其生命周期中只会被调度 一次。
一旦 Pod 被调度（分派）到某个节点，Pod 会一直在该节点运行，直到 Pod 停止或者
被终止 。
Pod 生命期 和一个个独立的应用容器一样，Pod 也被认为是相对临时性（而不是长期存在）的实体。
Pod 会被创建、赋予一个唯一的
ID（UID ），
并被调度到节点，并在终止（根据重启策略）或删除之前一直运行在该节点。
如果一个节点 死掉了，调度到该节点
的 Pod 也被计划在给定超时期限结束后删除 。
Pod 自身不具有自愈能力。如果 Pod 被调度到某节点
而该节点之后失效，或者调度操作本身失效，Pod 会被删除；与此类似，Pod 无法在节点资源
耗尽或者节点维护期间继续存活。Kubernetes 使用一种高级抽象，称作
控制器 ，来管理这些相对而言
可随时丢弃的 Pod 实例。
任何给定的 Pod （由 UID 定义）从不会被“重新调度（rescheduled）”到不同的节点；
相反，这一 Pod 可以被一个新的、几乎完全相同的 Pod 替换掉。
如果需要，新 Pod 的名字可以不变，但是其 UID 会不同。
如果某物声称其生命期与某 Pod 相同，例如存储卷 ，
这就意味着该对象在此 Pod （UID 亦相同）存在期间也一直存在。
如果 Pod 因为任何原因被删除，甚至某完全相同的替代 Pod 被创建时，
这个相关的对象（例如这里的卷）也会被删除并重建。
Pod 结构图例 一个包含多个容器的 Pod 中包含一个用来拉取文件的程序和一个 Web 服务器，
均使用持久卷作为容器间共享的存储。
Pod 阶段 Pod 的 status 字段是一个
PodStatus
对象，其中包含一个 phase 字段。
Pod 的阶段（Phase）是 Pod 在其生命周期中所处位置的简单宏观概述。
该阶段并不是对容器或 Pod 状态的综合汇总，也不是为了成为完整的状态机。
Pod 阶段的数量和含义是严格定义的。
除了本文档中列举的内容外，不应该再假定 Pod 有其他的 phase 值。
下面是 phase 可能的值：
取值 描述 Pending（悬决）Pod 已被 Kubernetes 系统接受，但有一个或者多个容器尚未创建亦未运行。此阶段包括等待 Pod 被调度的时间和通过网络下载镜像的时间， Running（运行中）Pod 已经绑定到了某个节点，Pod 中所有的容器都已被创建。至少有一个容器仍在运行，或者正处于启动或重启状态。 Succeeded（成功）Pod 中的所有容器都已成功终止，并且不会再重启。 Failed（失败）Pod 中的所有容器都已终止，并且至少有一个容器是因为失败终止。也就是说，容器以非 0 状态退出或者被系统终止。 Unknown（未知）因为某些原因无法取得 Pod 的状态。这种情况通常是因为与 Pod 所在主机通信失败。
如果某节点死掉或者与集群中其他节点失联，Kubernetes
会实施一种策略，将失去的节点上运行的所有 Pod 的 phase 设置为 Failed。
容器状态 Kubernetes 会跟踪 Pod 中每个容器的状态，就像它跟踪 Pod 总体上的阶段 一样。
你可以使用容器生命周期回调
来在容器生命周期中的特定时间点触发事件。
一旦调度器 将 Pod
分派给某个节点，kubelet 就通过
容器运行时
开始为 Pod 创建容器。
容器的状态有三种：Waiting（等待）、Running（运行中）和
Terminated（已终止）。
要检查 Pod 中容器的状态，你可以使用 kubectl describe pod <pod 名称>。
其输出中包含 Pod 中每个容器的状态。
每种状态都有特定的含义：
Waiting （等待）如果容器并不处在 Running 或 Terminated 状态之一，它就处在 Waiting 状态。
处于 Waiting 状态的容器仍在运行它完成启动所需要的操作：例如，从某个容器镜像
仓库拉取容器镜像，或者向容器应用 Secret
数据等等。
当你使用 kubectl 来查询包含 Waiting 状态的容器的 Pod 时，你也会看到一个
Reason 字段，其中给出了容器处于等待状态的原因。
Running（运行中）Running 状态表明容器正在执行状态并且没有问题发生。
如果配置了 postStart 回调，那么该回调已经执行且已完成。
如果你使用 kubectl 来查询包含 Running 状态的容器的 Pod 时，你也会看到
关于容器进入 Running 状态的信息。
Terminated（已终止）处于 Terminated 状态的容器已经开始执行并且或者正常结束或者因为某些原因失败。
如果你使用 kubectl 来查询包含 Terminated 状态的容器的 Pod 时，你会看到
容器进入此状态的原因、退出代码以及容器执行期间的起止时间。
如果容器配置了 preStop 回调，则该回调会在容器进入 Terminated
状态之前执行。
容器重启策略 Pod 的 spec 中包含一个 restartPolicy 字段，其可能取值包括
Always、OnFailure 和 Never。默认值是 Always。
restartPolicy 适用于 Pod 中的所有容器。restartPolicy 仅针对同一节点上
kubelet 的容器重启动作。当 Pod 中的容器退出时，kubelet 会按指数回退
方式计算重启的延迟（10s、20s、40s、...），其最长延迟为 5 分钟。
一旦某容器执行了 10 分钟并且没有出现问题，kubelet 对该容器的重启回退计时器执行
重置操作。
Pod 状况 Pod 有一个 PodStatus 对象，其中包含一个
PodConditions
数组。Pod 可能通过也可能未通过其中的一些状况测试。
PodScheduled：Pod 已经被调度到某节点；ContainersReady：Pod 中所有容器都已就绪；Initialized：所有的 Init 容器
都已成功启动；Ready：Pod 可以为请求提供服务，并且应该被添加到对应服务的负载均衡池中。字段名称 描述 typePod 状况的名称 status表明该状况是否适用，可能的取值有 "True", "False" 或 "Unknown" lastProbeTime上次探测 Pod 状况时的时间戳 lastTransitionTimePod 上次从一种状态转换到另一种状态时的时间戳 reason机器可读的、驼峰编码（UpperCamelCase）的文字，表述上次状况变化的原因 message人类可读的消息，给出上次状态转换的详细信息
Pod 就绪态 FEATURE STATE: Kubernetes v1.14 [stable]
你的应用可以向 PodStatus 中注入额外的反馈或者信号：Pod Readiness（Pod 就绪态） 。
要使用这一特性，可以设置 Pod 规约中的 readinessGates 列表，为 kubelet
提供一组额外的状况供其评估 Pod 就绪态时使用。
就绪态门控基于 Pod 的 status.conditions 字段的当前值来做决定。
如果 Kubernetes 无法在 status.conditions 字段中找到某状况，则该状况的
状态值默认为 "False"。
这里是一个例子：
kind : Pod
...
spec :
readinessGates :
- conditionType : "www.example.com/feature-1"
status :
conditions :
- type : Ready # 内置的 Pod 状况
status : "False"
lastProbeTime : null
lastTransitionTime : 2018-01-01T00:00:00Z
- type : "www.example.com/feature-1" # 额外的 Pod 状况
status : "False"
lastProbeTime : null
lastTransitionTime : 2018-01-01T00:00:00Z
containerStatuses :
- containerID : docker://abcd...
ready : true
...
你所添加的 Pod 状况名称必须满足 Kubernetes
标签键名格式 。
Pod 就绪态的状态 命令 kubectl patch 不支持修改对象的状态。
如果需要设置 Pod 的 status.conditions，应用或者
Operators
需要使用 PATCH 操作。
你可以使用 Kubernetes 客户端库
之一来编写代码，针对 Pod 就绪态设置定制的 Pod 状况。
对于使用定制状况的 Pod 而言，只有当下面的陈述都适用时，该 Pod 才会被评估为就绪：
Pod 中所有容器都已就绪； readinessGates 中的所有状况都为 True 值。当 Pod 的容器都已就绪，但至少一个定制状况没有取值或者取值为 False，
kubelet 将 Pod 的状况 设置为 ContainersReady。
容器探针 Probe
是由 kubelet 对容器执行的定期诊断。
要执行诊断，kubelet 调用由容器实现的
Handler
（处理程序）。有三种类型的处理程序：
ExecAction ：
在容器内执行指定命令。如果命令退出时返回码为 0 则认为诊断成功。
TCPSocketAction ：
对容器的 IP 地址上的指定端口执行 TCP 检查。如果端口打开，则诊断被认为是成功的。
HTTPGetAction ：
对容器的 IP 地址上指定端口和路径执行 HTTP Get 请求。如果响应的状态码大于等于 200
且小于 400，则诊断被认为是成功的。
每次探测都将获得以下三种结果之一：
Success（成功）：容器通过了诊断。Failure（失败）：容器未通过诊断。Unknown（未知）：诊断失败，因此不会采取任何行动。针对运行中的容器，kubelet 可以选择是否执行以下三种探针，以及如何针对探测结果作出反应：
livenessProbe：指示容器是否正在运行。如果存活态探测失败，则 kubelet 会杀死容器，
并且容器将根据其重启策略 决定未来。如果容器不提供存活探针，
则默认状态为 Success。
readinessProbe：指示容器是否准备好为请求提供服务。如果就绪态探测失败，
端点控制器将从与 Pod 匹配的所有服务的端点列表中删除该 Pod 的 IP 地址。
初始延迟之前的就绪态的状态值默认为 Failure。
如果容器不提供就绪态探针，则默认状态为 Success。
startupProbe: 指示容器中的应用是否已经启动。如果提供了启动探针，则所有其他探针都会被
禁用，直到此探针成功为止。如果启动探测失败，kubelet 将杀死容器，而容器依其
重启策略 进行重启。
如果容器没有提供启动探测，则默认状态为 Success。
如欲了解如何设置存活态、就绪态和启动探针的进一步细节，可以参阅
配置存活态、就绪态和启动探针 。
何时该使用存活态探针? FEATURE STATE: Kubernetes v1.0 [stable]
如果容器中的进程能够在遇到问题或不健康的情况下自行崩溃，则不一定需要存活态探针;
kubelet 将根据 Pod 的restartPolicy 自动执行修复操作。
如果你希望容器在探测失败时被杀死并重新启动，那么请指定一个存活态探针，
并指定restartPolicy 为 "Always" 或 "OnFailure"。
何时该使用就绪态探针? FEATURE STATE: Kubernetes v1.0 [stable]
如果要仅在探测成功时才开始向 Pod 发送请求流量，请指定就绪态探针。
在这种情况下，就绪态探针可能与存活态探针相同，但是规约中的就绪态探针的存在意味着
Pod 将在启动阶段不接收任何数据，并且只有在探针探测成功后才开始接收数据。
如果你的容器需要加载大规模的数据、配置文件或者在启动期间执行迁移操作，可以添加一个
就绪态探针。
如果你希望容器能够自行进入维护状态，也可以指定一个就绪态探针，检查某个特定于
就绪态的因此不同于存活态探测的端点。
说明： 请注意，如果你只是想在 Pod 被删除时能够排空请求，则不一定需要使用就绪态探针；
在删除 Pod 时，Pod 会自动将自身置于未就绪状态，无论就绪态探针是否存在。
等待 Pod 中的容器停止期间，Pod 会一直处于未就绪状态。
何时该使用启动探针？ FEATURE STATE: Kubernetes v1.18 [beta]
对于所包含的容器需要较长时间才能启动就绪的 Pod 而言，启动探针是有用的。
你不再需要配置一个较长的存活态探测时间间隔，只需要设置另一个独立的配置选定，
对启动期间的容器执行探测，从而允许使用远远超出存活态时间间隔所允许的时长。
如果你的容器启动时间通常超出 initialDelaySeconds + failureThreshold × periodSeconds
总值，你应该设置一个启动探测，对存活态探针所使用的同一端点执行检查。
periodSeconds 的默认值是 10 秒。你应该将其 failureThreshold 设置得足够高，
以便容器有充足的时间完成启动，并且避免更改存活态探针所使用的默认值。
这一设置有助于减少死锁状况的发生。
Pod 的终止 由于 Pod 所代表的是在集群中节点上运行的进程，当不再需要这些进程时允许其体面地
终止是很重要的。一般不应武断地使用 KILL 信号终止它们，导致这些进程没有机会
完成清理操作。
设计的目标是令你能够请求删除进程，并且知道进程何时被终止，同时也能够确保删除
操作终将完成。当你请求删除某个 Pod 时，集群会记录并跟踪 Pod 的体面终止周期，
而不是直接强制地杀死 Pod。在存在强制关闭设施的前提下，
kubelet 会尝试体面地终止
Pod。
通常情况下，容器运行时会发送一个 TERM 信号到每个容器中的主进程。
很多容器运行时都能够注意到容器镜像中 STOPSIGNAL 的值，并发送该信号而不是 TERM。
一旦超出了体面终止限期，容器运行时会向所有剩余进程发送 KILL 信号，之后
Pod 就会被从 API 服务器
上移除。如果 kubelet 或者容器运行时的管理服务在等待进程终止期间被重启，
集群会从头开始重试，赋予 Pod 完整的体面终止限期。
下面是一个例子：
你使用 kubectl 工具手动删除某个特定的 Pod，而该 Pod 的体面终止限期是默认值（30 秒）。
API 服务器中的 Pod 对象被更新，记录涵盖体面终止限期在内 Pod
的最终死期，超出所计算时间点则认为 Pod 已死（dead）。
如果你使用 kubectl describe 来查验你正在删除的 Pod，该 Pod 会显示为
"Terminating" （正在终止）。
在 Pod 运行所在的节点上：kubelet 一旦看到 Pod
被标记为正在终止（已经设置了体面终止限期），kubelet 即开始本地的 Pod 关闭过程。
如果 Pod 中的容器之一定义了 preStop
回调 ，
kubelet 开始在容器内运行该回调逻辑。如果超出体面终止限期时，preStop 回调逻辑
仍在运行，kubelet 会请求给予该 Pod 的宽限期一次性增加 2 秒钟。
说明： 如果 preStop 回调所需要的时间长于默认的体面终止限期，你必须修改
terminationGracePeriodSeconds 属性值来使其正常工作。
kubelet 接下来触发容器运行时发送 TERM 信号给每个容器中的进程 1。
说明： Pod 中的容器会在不同时刻收到 TERM 信号，接收顺序也是不确定的。
如果关闭的顺序很重要，可以考虑使用 preStop 回调逻辑来协调。
与此同时，kubelet 启动体面关闭逻辑，控制面会将 Pod 从对应的端点列表（以及端点切片列表，
如果启用了的话）中移除，过滤条件是 Pod 被对应的
服务 以某
选择算符 选定。
ReplicaSets 和其他工作负载资源
不再将关闭进程中的 Pod 视为合法的、能够提供服务的副本。关闭动作很慢的 Pod
也无法继续处理请求数据，因为负载均衡器（例如服务代理）已经在终止宽限期开始的时候
将其从端点列表中移除。 超出终止宽限期限时，kubelet 会触发强制关闭过程。容器运行时会向 Pod 中所有容器内
仍在运行的进程发送 SIGKILL 信号。
kubelet 也会清理隐藏的 pause 容器，如果容器运行时使用了这种容器的话。
kubelet 触发强制从 API 服务器上删除 Pod 对象的逻辑，并将体面终止限期设置为 0
（这意味着马上删除）。
API 服务器删除 Pod 的 API 对象，从任何客户端都无法再看到该对象。
强制终止 Pod 注意： 对于某些工作负载及其 Pod 而言，强制删除很可能会带来某种破坏。
默认情况下，所有的删除操作都会附有 30 秒钟的宽限期限。
kubectl delete 命令支持 --grace-period=<seconds> 选项，允许你重载默认值，
设定自己希望的期限值。
将宽限期限强制设置为 0 意味着立即从 API 服务器删除 Pod。
如果 Pod 仍然运行于某节点上，强制删除操作会触发 kubelet 立即执行清理操作。
说明： 你必须在设置 --grace-period=0 的同时额外设置 --force
参数才能发起强制删除请求。
执行强制删除操作时，API 服务器不再等待来自 kubelet 的、关于 Pod
已经在原来运行的节点上终止执行的确认消息。
API 服务器直接删除 Pod 对象，这样新的与之同名的 Pod 即可以被创建。
在节点侧，被设置为立即终止的 Pod 仍然会在被强行杀死之前获得一点点的宽限时间。
如果你需要强制删除 StatefulSet 的 Pod，请参阅
从 StatefulSet 中删除 Pod
的任务文档。
失效 Pod 的垃圾收集 对于已失败的 Pod 而言，对应的 API 对象仍然会保留在集群的 API 服务器上，直到
用户或者控制器 进程显式地
将其删除。
控制面组件会在 Pod 个数超出所配置的阈值
（根据 kube-controller-manager 的 terminated-pod-gc-threshold 设置）时
删除已终止的 Pod（阶段值为 Succeeded 或 Failed）。
这一行为会避免随着时间演进不断创建和终止 Pod 而引起的资源泄露问题。
接下来 1.2 - Init 容器 本页提供了 Init 容器的概览。Init 容器是一种特殊容器，在 Pod
内的应用容器启动之前运行。Init 容器可以包括一些应用镜像中不存在的实用工具和安装脚本。
你可以在 Pod 的规约中与用来描述应用容器的 containers 数组平行的位置指定
Init 容器。
理解 Init 容器 每个 Pod 中可以包含多个容器，
应用运行在这些容器里面，同时 Pod 也可以有一个或多个先于应用容器启动的 Init 容器。
Init 容器与普通的容器非常像，除了如下两点：
它们总是运行到完成。 每个都必须在下一个启动之前成功完成。 如果 Pod 的 Init 容器失败，kubelet 会不断地重启该 Init 容器直到该容器成功为止。
然而，如果 Pod 对应的 restartPolicy 值为 "Never"，Kubernetes 不会重新启动 Pod。
为 Pod 设置 Init 容器需要在 Pod 的 spec 中添加 initContainers 字段，
该字段以 Container
类型对象数组的形式组织，和应用的 containers 数组同级相邻。
Init 容器的状态在 status.initContainerStatuses 字段中以容器状态数组的格式返回
（类似 status.containerStatuses 字段）。
与普通容器的不同之处 Init 容器支持应用容器的全部字段和特性，包括资源限制、数据卷和安全设置。
然而，Init 容器对资源请求和限制的处理稍有不同，在下面资源 节有说明。
同时 Init 容器不支持 lifecycle、livenessProbe、readinessProbe 和 startupProbe，
因为它们必须在 Pod 就绪之前运行完成。
如果为一个 Pod 指定了多个 Init 容器，这些容器会按顺序逐个运行。
每个 Init 容器必须运行成功，下一个才能够运行。当所有的 Init 容器运行完成时，
Kubernetes 才会为 Pod 初始化应用容器并像平常一样运行。
使用 Init 容器 因为 Init 容器具有与应用容器分离的单独镜像，其启动相关代码具有如下优势：
Init 容器可以包含一些安装过程中应用容器中不存在的实用工具或个性化代码。
例如，没有必要仅为了在安装过程中使用类似 sed、awk、python 或 dig
这样的工具而去 FROM 一个镜像来生成一个新的镜像。
Init 容器可以安全地运行这些工具，避免这些工具导致应用镜像的安全性降低。
应用镜像的创建者和部署者可以各自独立工作，而没有必要联合构建一个单独的应用镜像。
Init 容器能以不同于 Pod 内应用容器的文件系统视图运行。因此，Init 容器可以访问
应用容器不能访问的 Secret 的权限。
由于 Init 容器必须在应用容器启动之前运行完成，因此 Init 容器
提供了一种机制来阻塞或延迟应用容器的启动，直到满足了一组先决条件。
一旦前置条件满足，Pod 内的所有的应用容器会并行启动。
示例 下面是一些如何使用 Init 容器的想法：
等待一个 Service 完成创建，通过类似如下 shell 命令：
for i in { 1..100} ; do sleep 1; if dig myservice; then exit 0; fi ; exit 1
注册这个 Pod 到远程服务器，通过在命令中调用 API，类似如下：
curl -X POST http://$MANAGEMENT_SERVICE_HOST :$MANAGEMENT_SERVICE_PORT /register \
'instance=$(<POD_NAME>)&ip=$(<POD_IP>)'
在启动应用容器之前等一段时间，使用类似命令：
克隆 Git 仓库到卷 中。
将配置值放到配置文件中，运行模板工具为主应用容器动态地生成配置文件。
例如，在配置文件中存放 POD_IP 值，并使用 Jinja 生成主应用配置文件。
使用 Init 容器的情况 下面的例子定义了一个具有 2 个 Init 容器的简单 Pod。 第一个等待 myservice 启动，
第二个等待 mydb 启动。 一旦这两个 Init容器 都启动完成，Pod 将启动 spec 节中的应用容器。
apiVersion : v1
kind : Pod
metadata :
name : myapp-pod
labels :
app : myapp
spec :
containers :
- name : myapp-container
image : busybox:1.28
command : ['sh' , '-c' , 'echo The app is running! && sleep 3600' ]
initContainers :
- name : init-myservice
image : busybox:1.28
command : ['sh' , '-c' , "until nslookup myservice.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for myservice; sleep 2; done" ]
- name : init-mydb
image : busybox:1.28
command : ['sh' , '-c' , "until nslookup mydb.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for mydb; sleep 2; done" ]
你通过运行下面的命令启动 Pod：
kubectl apply -f myapp.yaml
输出类似于：
pod/myapp-pod created
使用下面的命令检查其状态：
kubectl get -f myapp.yaml
输出类似于：
NAME READY STATUS RESTARTS AGE
myapp-pod 0/1 Init:0/2 0 6m
或者查看更多详细信息：
kubectl describe -f myapp.yaml
输出类似于：
Name: myapp-pod
Namespace: default
[...]
Labels: app=myapp
Status: Pending
[...]
Init Containers:
init-myservice:
[...]
State: Running
[...]
init-mydb:
[...]
State: Waiting
Reason: PodInitializing
Ready: False
[...]
Containers:
myapp-container:
[...]
State: Waiting
Reason: PodInitializing
Ready: False
[...]
Events:
FirstSeen LastSeen Count From SubObjectPath Type Reason Message
--------- -------- ----- ---- ------------- -------- ------ -------
16s 16s 1 {default-scheduler } Normal Scheduled Successfully assigned myapp-pod to 172.17.4.201
16s 16s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Pulling pulling image "busybox"
13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Pulled Successfully pulled image "busybox"
13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Created Created container with docker id 5ced34a04634; Security:[seccomp=unconfined]
13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Started Started container with docker id 5ced34a04634
如需查看 Pod 内 Init 容器的日志，请执行：
kubectl logs myapp-pod -c init-myservice # 查看第一个 Init 容器
kubectl logs myapp-pod -c init-mydb # 查看第二个 Init 容器
在这一刻，Init 容器将会等待至发现名称为 mydb 和 myservice 的 Service。
如下为创建这些 Service 的配置文件：
---
apiVersion : v1
kind : Service
metadata :
name : myservice
spec :
ports :
- protocol : TCP
port : 80
targetPort : 9376
---
apiVersion : v1
kind : Service
metadata :
name : mydb
spec :
ports :
- protocol : TCP
port : 80
targetPort : 9377
创建 mydb 和 myservice 服务的命令：
kubectl create -f services.yaml
输出类似于：
service "myservice" created
service "mydb" created
这样你将能看到这些 Init 容器执行完毕，随后 my-app 的 Pod 进入 Running 状态：
kubectl get -f myapp.yaml
输出类似于：
NAME READY STATUS RESTARTS AGE
myapp-pod 1/1 Running 0 9m
这个简单例子应该能为你创建自己的 Init 容器提供一些启发。
接下来 节提供了更详细例子的链接。
具体行为 在 Pod 启动过程中，每个 Init 容器会在网络和数据卷初始化之后按顺序启动。
kubelet 运行依据 Init 容器在 Pod 规约中的出现顺序依次运行之。
每个 Init 容器成功退出后才会启动下一个 Init 容器。
如果某容器因为容器运行时的原因无法启动，或以错误状态退出，kubelet 会根据
Pod 的 restartPolicy 策略进行重试。
然而，如果 Pod 的 restartPolicy 设置为 "Always"，Init 容器失败时会使用
restartPolicy 的 "OnFailure" 策略。
在所有的 Init 容器没有成功之前，Pod 将不会变成 Ready 状态。
Init 容器的端口将不会在 Service 中进行聚集。正在初始化中的 Pod 处于 Pending 状态，
但会将状况 Initializing 设置为 false。
如果 Pod 重启 ，所有 Init 容器必须重新执行。
对 Init 容器规约的修改仅限于容器的 image 字段。
更改 Init 容器的 image 字段，等同于重启该 Pod。
因为 Init 容器可能会被重启、重试或者重新执行，所以 Init 容器的代码应该是幂等的。
特别地，基于 emptyDirs 写文件的代码，应该对输出文件可能已经存在做好准备。
Init 容器具有应用容器的所有字段。然而 Kubernetes 禁止使用 readinessProbe，
因为 Init 容器不能定义不同于完成态（Completion）的就绪态（Readiness）。
Kubernetes 会在校验时强制执行此检查。
在 Pod 上使用 activeDeadlineSeconds 和在容器上使用 livenessProbe 可以避免
Init 容器一直重复失败。activeDeadlineSeconds 时间包含了 Init 容器启动的时间。
在 Pod 中的每个应用容器和 Init 容器的名称必须唯一；
与任何其它容器共享同一个名称，会在校验时抛出错误。
资源 在给定的 Init 容器执行顺序下，资源使用适用于如下规则：
所有 Init 容器上定义的任何特定资源的 limit 或 request 的最大值，作为 Pod 有效初始 request/limit Pod 对资源的 有效 limit/request 是如下两者的较大者：所有应用容器对某个资源的 limit/request 之和 对某个资源的有效初始 limit/request 基于有效 limit/request 完成调度，这意味着 Init 容器能够为初始化过程预留资源，
这些资源在 Pod 生命周期过程中并没有被使用。 Pod 的 有效 QoS 层 ，与 Init 容器和应用容器的一样。 配额和限制适用于有效 Pod 的请求和限制值。
Pod 级别的 cgroups 是基于有效 Pod 的请求和限制值，和调度器相同。
Pod 重启的原因 Pod 重启会导致 Init 容器重新执行，主要有如下几个原因：
用户更新 Pod 的规约导致 Init 容器镜像发生改变。Init 容器镜像的变更会引起 Pod 重启。
应用容器镜像的变更仅会重启应用容器。
Pod 的基础设施容器 (译者注：如 pause 容器) 被重启。这种情况不多见，
必须由具备 root 权限访问节点的人员来完成。
当 restartPolicy 设置为 "Always"，Pod 中所有容器会终止而强制重启。
由于垃圾收集机制的原因，Init 容器的完成记录将会丢失。
接下来 1.3 - Pod 拓扑分布约束 FEATURE STATE: Kubernetes v1.19 [stable]
你可以使用 拓扑分布约束（Topology Spread Constraints） 来控制
Pods 在集群内故障域
之间的分布，例如区域（Region）、可用区（Zone）、节点和其他用户自定义拓扑域。
这样做有助于实现高可用并提升资源利用率。
说明： 在 v1.19 之前的 Kubernetes 版本中，如果要使用 Pod 拓扑扩展约束，你必须在
API 服务器
和
调度器
中启用
EvenPodsSpread 特性门控 。
先决条件 节点标签 拓扑分布约束依赖于节点标签来标识每个节点所在的拓扑域。
例如，某节点可能具有标签：node=node1,zone=us-east-1a,region=us-east-1
假设你拥有具有以下标签的一个 4 节点集群：
NAME STATUS ROLES AGE VERSION LABELS
node1 Ready <none> 4m26s v1.16.0 node=node1,zone=zoneA
node2 Ready <none> 3m58s v1.16.0 node=node2,zone=zoneA
node3 Ready <none> 3m17s v1.16.0 node=node3,zone=zoneB
node4 Ready <none> 2m43s v1.16.0 node=node4,zone=zoneB
然后从逻辑上看集群如下：
graph TB
subgraph "zoneB"
n3(Node3)
n4(Node4)
end
subgraph "zoneA"
n1(Node1)
n2(Node2)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n1,n2,n3,n4 k8s;
class zoneA,zoneB cluster;
[JavaScript must be enabled to view content] 你可以复用在大多数集群上自动创建和填充的
常用标签 ，
而不是手动添加标签。
Pod 的分布约束 API pod.spec.topologySpreadConstraints 字段定义如下所示：
apiVersion : v1
kind : Pod
metadata :
name : mypod
spec :
topologySpreadConstraints :
- maxSkew : <integer>
topologyKey : <string>
whenUnsatisfiable : <string>
labelSelector : <object>
你可以定义一个或多个 topologySpreadConstraint 来指示 kube-scheduler
如何根据与现有的 Pod 的关联关系将每个传入的 Pod 部署到集群中。字段包括：
maxSkew 描述 Pod 分布不均的程度。这是给定拓扑类型中任意两个拓扑域中
匹配的 pod 之间的最大允许差值。它必须大于零。取决于 whenUnsatisfiable 的
取值，其语义会有不同。当 whenUnsatisfiable 等于 "DoNotSchedule" 时，maxSkew 是目标拓扑域
中匹配的 Pod 数与全局最小值之间可存在的差异。 当 whenUnsatisfiable 等于 "ScheduleAnyway" 时，调度器会更为偏向能够降低
偏差值的拓扑域。 topologyKey 是节点标签的键。如果两个节点使用此键标记并且具有相同的标签值，
则调度器会将这两个节点视为处于同一拓扑域中。调度器试图在每个拓扑域中放置数量
均衡的 Pod。whenUnsatisfiable 指示如果 Pod 不满足分布约束时如何处理：DoNotSchedule（默认）告诉调度器不要调度。ScheduleAnyway 告诉调度器仍然继续调度，只是根据如何能将偏差最小化来对
节点进行排序。labelSelector 用于查找匹配的 pod。匹配此标签的 Pod 将被统计，以确定相应
拓扑域中 Pod 的数量。
有关详细信息，请参考标签选择算符 。你可以执行 kubectl explain Pod.spec.topologySpreadConstraints 命令以
了解关于 topologySpreadConstraints 的更多信息。
例子：单个 TopologySpreadConstraint 假设你拥有一个 4 节点集群，其中标记为 foo:bar 的 3 个 Pod 分别位于
node1、node2 和 node3 中：
graph BT
subgraph "zoneB"
p3(Pod) --> n3(Node3)
n4(Node4)
end
subgraph "zoneA"
p1(Pod) --> n1(Node1)
p2(Pod) --> n2(Node2)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n1,n2,n3,n4,p1,p2,p3 k8s;
class zoneA,zoneB cluster;
[JavaScript must be enabled to view content] 如果希望新来的 Pod 均匀分布在现有的可用区域，则可以按如下设置其规约：
kind : Pod
apiVersion : v1
metadata :
name : mypod
labels :
foo : bar
spec :
topologySpreadConstraints :
- maxSkew : 1
topologyKey : zone
whenUnsatisfiable : DoNotSchedule
labelSelector :
matchLabels :
foo : bar
containers :
- name : pause
image : k8s.gcr.io/pause:3.1topologyKey: zone 意味着均匀分布将只应用于存在标签键值对为
"zone:<any value>" 的节点。
whenUnsatisfiable: DoNotSchedule 告诉调度器如果新的 Pod 不满足约束，
则让它保持悬决状态。
如果调度器将新的 Pod 放入 "zoneA"，Pods 分布将变为 [3, 1]，因此实际的偏差
为 2（3 - 1）。这违反了 maxSkew: 1 的约定。此示例中，新 Pod 只能放置在
"zoneB" 上：
graph BT
subgraph "zoneB"
p3(Pod) --> n3(Node3)
p4(mypod) --> n4(Node4)
end
subgraph "zoneA"
p1(Pod) --> n1(Node1)
p2(Pod) --> n2(Node2)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n1,n2,n3,n4,p1,p2,p3 k8s;
class p4 plain;
class zoneA,zoneB cluster;
[JavaScript must be enabled to view content] 或者
graph BT
subgraph "zoneB"
p3(Pod) --> n3(Node3)
p4(mypod) --> n3
n4(Node4)
end
subgraph "zoneA"
p1(Pod) --> n1(Node1)
p2(Pod) --> n2(Node2)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n1,n2,n3,n4,p1,p2,p3 k8s;
class p4 plain;
class zoneA,zoneB cluster;
[JavaScript must be enabled to view content] 你可以调整 Pod 规约以满足各种要求：
将 maxSkew 更改为更大的值，比如 "2"，这样新的 Pod 也可以放在 "zoneA" 上。 将 topologyKey 更改为 "node"，以便将 Pod 均匀分布在节点上而不是区域中。
在上面的例子中，如果 maxSkew 保持为 "1"，那么传入的 Pod 只能放在 "node4" 上。 将 whenUnsatisfiable: DoNotSchedule 更改为 whenUnsatisfiable: ScheduleAnyway，
以确保新的 Pod 始终可以被调度（假设满足其他的调度 API）。
但是，最好将其放置在匹配 Pod 数量较少的拓扑域中。
（请注意，这一优先判定会与其他内部调度优先级（如资源使用率等）排序准则一起进行标准化。） 例子：多个 TopologySpreadConstraints 下面的例子建立在前面例子的基础上。假设你拥有一个 4 节点集群，其中 3 个标记为 foo:bar 的
Pod 分别位于 node1、node2 和 node3 上：
graph BT
subgraph "zoneB"
p3(Pod) --> n3(Node3)
n4(Node4)
end
subgraph "zoneA"
p1(Pod) --> n1(Node1)
p2(Pod) --> n2(Node2)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n1,n2,n3,n4,p1,p2,p3 k8s;
class p4 plain;
class zoneA,zoneB cluster;
[JavaScript must be enabled to view content] 可以使用 2 个 TopologySpreadConstraint 来控制 Pod 在 区域和节点两个维度上的分布：
kind : Pod
apiVersion : v1
metadata :
name : mypod
labels :
foo : bar
spec :
topologySpreadConstraints :
- maxSkew : 1
topologyKey : zone
whenUnsatisfiable : DoNotSchedule
labelSelector :
matchLabels :
foo : bar
- maxSkew : 1
topologyKey : node
whenUnsatisfiable : DoNotSchedule
labelSelector :
matchLabels :
foo : bar
containers :
- name : pause
image : k8s.gcr.io/pause:3.1在这种情况下，为了匹配第一个约束，新的 Pod 只能放置在 "zoneB" 中；而在第二个约束中，
新的 Pod 只能放置在 "node4" 上。最后两个约束的结果加在一起，唯一可行的选择是放置
在 "node4" 上。
多个约束之间可能存在冲突。假设有一个跨越 2 个区域的 3 节点集群：
graph BT
subgraph "zoneB"
p4(Pod) --> n3(Node3)
p5(Pod) --> n3
end
subgraph "zoneA"
p1(Pod) --> n1(Node1)
p2(Pod) --> n1
p3(Pod) --> n2(Node2)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n1,n2,n3,n4,p1,p2,p3,p4,p5 k8s;
class zoneA,zoneB cluster;
[JavaScript must be enabled to view content] 如果对集群应用 "two-constraints.yaml"，会发现 "mypod" 处于 Pending 状态。
这是因为：为了满足第一个约束，"mypod" 只能放在 "zoneB" 中，而第二个约束要求
"mypod" 只能放在 "node2" 上。Pod 调度无法满足两种约束。
为了克服这种情况，你可以增加 maxSkew 或修改其中一个约束，让其使用
whenUnsatisfiable: ScheduleAnyway。
约定 这里有一些值得注意的隐式约定：
只有与新的 Pod 具有相同命名空间的 Pod 才能作为匹配候选者。 没有 topologySpreadConstraints[*].topologyKey 的节点将被忽略。这意味着：位于这些节点上的 Pod 不影响 maxSkew 的计算。
在上面的例子中，假设 "node1" 没有标签 "zone"，那么 2 个 Pod 将被忽略，
因此传入的 Pod 将被调度到 "zoneA" 中。
新的 Pod 没有机会被调度到这类节点上。
在上面的例子中，假设一个带有标签 {zone-typo: zoneC} 的 "node5" 加入到集群，
它将由于没有标签键 "zone" 而被忽略。
注意，如果新 Pod 的 topologySpreadConstraints[*].labelSelector 与自身的
标签不匹配，将会发生什么。
在上面的例子中，如果移除新 Pod 上的标签，Pod 仍然可以调度到 "zoneB"，因为约束仍然满足。
然而，在调度之后，集群的不平衡程度保持不变。zoneA 仍然有 2 个带有 {foo:bar} 标签的 Pod，
zoneB 有 1 个带有 {foo:bar} 标签的 Pod。
因此，如果这不是你所期望的，建议工作负载的 topologySpreadConstraints[*].labelSelector
与其自身的标签匹配。 如果新 Pod 定义了 spec.nodeSelector 或 spec.affinity.nodeAffinity，则
不匹配的节点会被忽略。
假设你有一个跨越 zoneA 到 zoneC 的 5 节点集群：
graph BT
subgraph "zoneB"
p3(Pod) --> n3(Node3)
n4(Node4)
end
subgraph "zoneA"
p1(Pod) --> n1(Node1)
p2(Pod) --> n2(Node2)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n1,n2,n3,n4,p1,p2,p3 k8s;
class p4 plain;
class zoneA,zoneB cluster;
[JavaScript must be enabled to view content] graph BT
subgraph "zoneC"
n5(Node5)
end
classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000;
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff;
classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5;
class n5 k8s;
class zoneC cluster;
[JavaScript must be enabled to view content] 而且你知道 "zoneC" 必须被排除在外。在这种情况下，可以按如下方式编写 yaml，
以便将 "mypod" 放置在 "zoneB" 上，而不是 "zoneC" 上。同样，spec.nodeSelector
也要一样处理。
kind : Pod
apiVersion : v1
metadata :
name : mypod
labels :
foo : bar
spec :
topologySpreadConstraints :
- maxSkew : 1
topologyKey : zone
whenUnsatisfiable : DoNotSchedule
labelSelector :
matchLabels :
foo : bar
affinity :
nodeAffinity :
requiredDuringSchedulingIgnoredDuringExecution :
nodeSelectorTerms :
- matchExpressions :
- key : zone
operator : NotIn
values :
- zoneC
containers :
- name : pause
image : k8s.gcr.io/pause:3.1集群级别的默认约束 为集群设置默认的拓扑分布约束也是可能的。默认拓扑分布约束在且仅在以下条件满足
时才会应用到 Pod 上：
Pod 没有在其 .spec.topologySpreadConstraints 设置任何约束； Pod 隶属于某个服务、副本控制器、ReplicaSet 或 StatefulSet。 你可以在 调度方案（Schedulingg Profile）
中将默认约束作为 PodTopologySpread 插件参数的一部分来设置。
约束的设置采用如前所述的 API ，只是 labelSelector 必须为空。
选择算符是根据 Pod 所属的服务、副本控制器、ReplicaSet 或 StatefulSet 来设置的。
配置的示例可能看起来像下面这个样子：
apiVersion : kubescheduler.config.k8s.io/v1beta1
kind : KubeSchedulerConfiguration
profiles :
- pluginConfig :
- name : PodTopologySpread
args :
defaultConstraints :
- maxSkew : 1
topologyKey : topology.kubernetes.io/zone
whenUnsatisfiable : ScheduleAnyway
defaultingType : List
说明： 默认调度约束所生成的评分可能与
SelectorSpread 插件PodTopologySpread 设置默认约束是禁用调度方案中的该插件。
内部默认约束 FEATURE STATE: Kubernetes v1.20 [beta]
当你使用了默认启用的 DefaultPodTopologySpread 特性门控时，原来的
SelectorSpread 插件会被禁用。
kube-scheduler 会使用下面的默认拓扑约束作为 PodTopologySpread 插件的
配置：
defaultConstraints :
- maxSkew : 3
topologyKey : "kubernetes.io/hostname"
whenUnsatisfiable : ScheduleAnyway
- maxSkew : 5
topologyKey : "topology.kubernetes.io/zone"
whenUnsatisfiable : ScheduleAnyway
此外，原来用于提供等同行为的 SelectorSpread 插件也会被禁用。
说明： 如果你的节点不会 同时 设置 kubernetes.io/hostname 和
topology.kubernetes.io/zone 标签，你应该定义自己的约束而不是使用
Kubernetes 的默认约束。
插件 PodTopologySpread 不会为未设置分布约束中所给拓扑键的节点评分。
如果你不想为集群使用默认的 Pod 分布约束，你可以通过设置 defaultingType 参数为 List 和
将 PodTopologySpread 插件配置中的 defaultConstraints 参数置空来禁用默认 Pod 分布约束。
apiVersion : kubescheduler.config.k8s.io/v1beta1
kind : KubeSchedulerConfiguration
profiles :
- pluginConfig :
- name : PodTopologySpread
args :
defaultConstraints : []
defaultingType : List
与 PodAffinity/PodAntiAffinity 相比较 在 Kubernetes 中，与“亲和性”相关的指令控制 Pod 的调度方式（更密集或更分散）。
对于 PodAffinity，你可以尝试将任意数量的 Pod 集中到符合条件的拓扑域中。 对于 PodAntiAffinity，只能将一个 Pod 调度到某个拓扑域中。 要实现更细粒度的控制，你可以设置拓扑分布约束来将 Pod 分布到不同的拓扑域下，
从而实现高可用性或节省成本。这也有助于工作负载的滚动更新和平稳地扩展副本规模。
有关详细信息，请参考
动机 文档。
已知局限性 Deployment 缩容操作可能导致 Pod 分布不平衡。 具有污点的节点上的 Pods 也会被统计。
参考 Issue 80921 。 接下来 1.4 - 干扰（Disruptions） 本指南针对的是希望构建高可用性应用程序的应用所有者，他们有必要了解可能发生在 Pod 上的干扰类型。
文档同样适用于想要执行自动化集群操作（例如升级和自动扩展集群）的集群管理员。
自愿干扰和非自愿干扰 Pod 不会消失，除非有人（用户或控制器）将其销毁，或者出现了不可避免的硬件或软件系统错误。
我们把这些不可避免的情况称为应用的非自愿干扰（Involuntary Disruptions） 。例如：
节点下层物理机的硬件故障 集群管理员错误地删除虚拟机（实例） 云提供商或虚拟机管理程序中的故障导致的虚拟机消失 内核错误 节点由于集群网络隔离从集群中消失 由于节点资源不足 导致 pod 被驱逐。 除了资源不足的情况，大多数用户应该都熟悉这些情况；它们不是特定于 Kubernetes 的。
我们称其他情况为自愿干扰（Voluntary Disruptions） 。
包括由应用程序所有者发起的操作和由集群管理员发起的操作。典型的应用程序所有者的操
作包括：
删除 Deployment 或其他管理 Pod 的控制器 更新了 Deployment 的 Pod 模板导致 Pod 重启 直接删除 Pod（例如，因为误操作） 集群管理员操作包括：
这些操作可能由集群管理员直接执行，也可能由集群管理员所使用的自动化工具执行，或者由集群托管提供商自动执行。
咨询集群管理员或联系云提供商，或者查询发布文档，以确定是否为集群启用了任何资源干扰源。
如果没有启用，可以不用创建 Pod Disruption Budgets（Pod 干扰预算）
注意： 并非所有的自愿干扰都会受到 Pod 干扰预算的限制。
例如，删除 Deployment 或 Pod 的删除操作就会跳过 Pod 干扰预算检查。
处理干扰 以下是减轻非自愿干扰的一些方法：
确保 Pod 在请求中给出所需资源 。 如果需要更高的可用性，请复制应用程序。
（了解有关运行多副本的无状态
和有状态 应用程序的信息。） 为了在运行复制应用程序时获得更高的可用性，请跨机架（使用
反亲和性 ）或跨区域
（如果使用多区域集群 ）扩展应用程序。 自愿干扰的频率各不相同。在一个基本的 Kubernetes 集群中，根本没有自愿干扰。然而，集群管理
或托管提供商可能运行一些可能导致自愿干扰的额外服务。例如，节点软
更新可能导致自愿干扰。另外，集群（节点）自动缩放的某些
实现可能导致碎片整理和紧缩节点的自愿干扰。集群
管理员或托管提供商应该已经记录了各级别的自愿干扰（如果有的话）。
Kubernetes 提供特性来满足在出现频繁自愿干扰的同时运行高可用的应用程序。我们称这些特性为
干扰预算（Disruption Budget） 。
干扰预算 FEATURE STATE: Kubernetes v1.5 [beta]
即使你会经常引入自愿性干扰，Kubernetes 也能够支持你运行高度可用的应用。
应用程序所有者可以为每个应用程序创建 PodDisruptionBudget 对象（PDB）。
PDB 将限制在同一时间因自愿干扰导致的复制应用程序中宕机的 pod 数量。
例如，基于票选机制的应用程序希望确保运行的副本数永远不会低于仲裁所需的数量。
Web 前端可能希望确保提供负载的副本数量永远不会低于总数的某个百分比。
集群管理员和托管提供商应该使用遵循 Pod Disruption Budgets 的接口
（通过调用Eviction API ），
而不是直接删除 Pod 或 Deployment。
例如，kubectl drain 命令可以用来标记某个节点即将停止服务。
运行 kubectl drain 命令时，工具会尝试驱逐机器上的所有 Pod。
kubectl 所提交的驱逐请求可能会暂时被拒绝，所以该工具会定时重试失败的请求，
直到所有的 Pod 都被终止，或者达到配置的超时时间。
PDB 指定应用程序可以容忍的副本数量（相当于应该有多少副本）。
例如，具有 .spec.replicas: 5 的 Deployment 在任何时间都应该有 5 个 Pod。
如果 PDB 允许其在某一时刻有 4 个副本，那么驱逐 API 将允许同一时刻仅有一个而不是两个 Pod 自愿干扰。
使用标签选择器来指定构成应用程序的一组 Pod，这与应用程序的控制器（Deployment，StatefulSet 等）
选择 Pod 的逻辑一样。
Pod 控制器的 .spec.replicas 计算“预期的” Pod 数量。
根据 Pod 对象的 .metadata.ownerReferences 字段来发现控制器。
PDB 不能阻止非自愿干扰 的发生，但是确实会计入
预算。
由于应用程序的滚动升级而被删除或不可用的 Pod 确实会计入干扰预算，
但是控制器（如 Deployment 和 StatefulSet）在进行滚动升级时不受 PDB
的限制。应用程序更新期间的故障处理方式是在对应的工作负载资源的 spec 中配置的。
当使用驱逐 API 驱逐 Pod 时，Pod 会被体面地
终止 ，期间会
参考 PodSpec
中的 terminationGracePeriodSeconds 配置值。
PDB 例子 假设集群有 3 个节点，node-1 到 node-3。集群上运行了一些应用。
其中一个应用有 3 个副本，分别是 pod-a，pod-b 和 pod-c。
另外，还有一个不带 PDB 的无关 pod pod-x 也同样显示出来。
最初，所有的 Pod 分布如下：
node-1 node-2 node-3 pod-a available pod-b available pod-c available pod-x available
3 个 Pod 都是 deployment 的一部分，并且共同拥有同一个 PDB，要求 3 个 Pod 中至少有 2 个 Pod 始终处于可用状态。
例如，假设集群管理员想要重启系统，升级内核版本来修复内核中的权限。
集群管理员首先使用 kubectl drain 命令尝试排空 node-1 节点。
命令尝试驱逐 pod-a 和 pod-x。操作立即就成功了。
两个 Pod 同时进入 terminating 状态。这时的集群处于下面的状态：
node-1 draining node-2 node-3 pod-a terminating pod-b available pod-c available pod-x terminating
Deployment 控制器观察到其中一个 Pod 正在终止，因此它创建了一个替代 Pod pod-d。
由于 node-1 被封锁（cordon），pod-d 落在另一个节点上。
同样其他控制器也创建了 pod-y 作为 pod-x 的替代品。
（注意：对于 StatefulSet 来说，pod-a（也称为 pod-0）需要在替换 Pod 创建之前完全终止，
替代它的也称为 pod-0，但是具有不同的 UID。除此之外，此示例也适用于 StatefulSet。）
当前集群的状态如下：
node-1 draining node-2 node-3 pod-a terminating pod-b available pod-c available pod-x terminating pod-d starting pod-y
在某一时刻，Pod 被终止，集群如下所示：
node-1 drained node-2 node-3 pod-b available pod-c available pod-d starting pod-y
此时，如果一个急躁的集群管理员试图排空（drain）node-2 或 node-3，drain 命令将被阻塞，
因为对于 Deployment 来说只有 2 个可用的 Pod，并且它的 PDB 至少需要 2 个。
经过一段时间，pod-d 变得可用。
集群状态如下所示：
node-1 drained node-2 node-3 pod-b available pod-c available pod-d available pod-y
现在，集群管理员试图排空（drain）node-2。
drain 命令将尝试按照某种顺序驱逐两个 Pod，假设先是 pod-b，然后是 pod-d。
命令成功驱逐 pod-b，但是当它尝试驱逐 pod-d时将被拒绝，因为对于
Deployment 来说只剩一个可用的 Pod 了。
Deployment 创建 pod-b 的替代 Pod pod-e。
因为集群中没有足够的资源来调度 pod-e，drain 命令再次阻塞。集群最终将是下面这种状态：
node-1 drained node-2 node-3 no node pod-b available pod-c available pod-e pending pod-d available pod-y
此时，集群管理员需要增加一个节点到集群中以继续升级操作。
可以看到 Kubernetes 如何改变干扰发生的速率，根据：
应用程序需要多少个副本 优雅关闭应用实例需要多长时间 启动应用新实例需要多长时间 控制器的类型 集群的资源能力 分离集群所有者和应用所有者角色 通常，将集群管理者和应用所有者视为彼此了解有限的独立角色是很有用的。这种责任分离在下面这些场景下是有意义的：
当有许多应用程序团队共用一个 Kubernetes 集群，并且有自然的专业角色 当第三方工具或服务用于集群自动化管理 Pod 干扰预算通过在角色之间提供接口来支持这种分离。
如果你的组织中没有这样的责任分离，则可能不需要使用 Pod 干扰预算。
如何在集群上执行干扰性操作 如果你是集群管理员，并且需要对集群中的所有节点执行干扰操作，例如节点或系统软件升级，则可以使用以下选项
接受升级期间的停机时间。 故障转移到另一个完整的副本集群。没有停机时间，但是对于重复的节点和人工协调成本可能是昂贵的。 编写可容忍干扰的应用程序和使用 PDB。不停机。 最小的资源重复。 允许更多的集群管理自动化。 编写可容忍干扰的应用程序是棘手的，但对于支持容忍自愿干扰所做的工作，和支持自动扩缩和容忍非
自愿干扰所做工作相比，有大量的重叠 接下来 1.5 - 临时容器 FEATURE STATE: Kubernetes v1.16 [alpha]
本页面概述了临时容器：一种特殊的容器，该容器在现有 Pod
中临时运行，以便完成用户发起的操作，例如故障排查。
你会使用临时容器来检查服务，而不是用它来构建应用程序。
警告： 临时容器处于早期的 alpha 阶段，不适用于生产环境集群。
应该预料到临时容器在某些情况下不起作用，例如在定位容器的命名空间时。
根据
Kubernetes 弃用政策 ，
此 alpha 功能将来可能发生重大变化或被完全删除。
了解临时容器 Pod 是 Kubernetes 应用程序的基本构建块。
由于 Pod 是一次性且可替换的，因此一旦 Pod 创建，就无法将容器加入到 Pod 中。
取而代之的是，通常使用 Deployment
以受控的方式来删除并替换 Pod。
有时有必要检查现有 Pod 的状态。例如，对于难以复现的故障进行排查。
在这些场景中，可以在现有 Pod 中运行临时容器来检查其状态并运行任意命令。
什么是临时容器？ 临时容器与其他容器的不同之处在于，它们缺少对资源或执行的保证，并且永远不会自动重启，
因此不适用于构建应用程序。
临时容器使用与常规容器相同的 ContainerSpec 节来描述，但许多字段是不兼容和不允许的。
临时容器没有端口配置，因此像 ports，livenessProbe，readinessProbe
这样的字段是不允许的。
Pod 资源分配是不可变的，因此 resources 配置是不允许的。
有关允许字段的完整列表，请参见
EphemeralContainer 参考文档 。
临时容器是使用 API 中的一种特殊的 ephemeralcontainers 处理器进行创建的，
而不是直接添加到 pod.spec 段，因此无法使用 kubectl edit 来添加一个临时容器。
与常规容器一样，将临时容器添加到 Pod 后，将不能更改或删除临时容器。
临时容器的用途 当由于容器崩溃或容器镜像不包含调试工具而导致 kubectl exec 无用时，
临时容器对于交互式故障排查很有用。
尤其是，distroless 镜像
允许用户部署最小的容器镜像，从而减少攻击面并减少故障和漏洞的暴露。
由于 distroless 镜像不包含 Shell 或任何的调试工具，因此很难单独使用
kubectl exec 命令进行故障排查。
使用临时容器时，启用进程名字空间共享
很有帮助，可以查看其他容器中的进程。
示例 说明： 本节中的示例要求启用
EphemeralContainers
特性门控 ，
并且 kubernetes 客户端和服务端版本要求为 v1.16 或更高版本。
本节中的示例演示了临时容器如何出现在 API 中。
通常，你会使用 kubectl debug 或别的 kubectl
插件 自动执行这些步骤，而不是直接调用API。
临时容器是使用 Pod 的 ephemeralcontainers 子资源创建的，可以使用
kubectl --raw 命令进行显示。
首先描述临时容器被添加为一个 EphemeralContainers 列表：
{
"apiVersion" : "v1" ,
"kind" : "EphemeralContainers" ,
"metadata" : {
"name" : "example-pod"
},
"ephemeralContainers" : [{
"command" : [
"sh"
],
"image" : "busybox" ,
"imagePullPolicy" : "IfNotPresent" ,
"name" : "debugger" ,
"stdin" : true ,
"tty" : true ,
"terminationMessagePolicy" : "File"
}]
}
使用如下命令更新已运行的临时容器 example-pod：
kubectl replace --raw /api/v1/namespaces/default/pods/example-pod/ephemeralcontainers -f ec.json
这将返回临时容器的新列表：
{
"kind" :"EphemeralContainers" ,
"apiVersion" :"v1" ,
"metadata" :{
"name" :"example-pod" ,
"namespace" :"default" ,
"selfLink" :"/api/v1/namespaces/default/pods/example-pod/ephemeralcontainers" ,
"uid" :"a14a6d9b-62f2-4119-9d8e-e2ed6bc3a47c" ,
"resourceVersion" :"15886" ,
"creationTimestamp" :"2019-08-29T06:41:42Z"
},
"ephemeralContainers" :[
{
"name" :"debugger" ,
"image" :"busybox" ,
"command" :[
"sh"
],
"resources" :{
},
"terminationMessagePolicy" :"File" ,
"imagePullPolicy" :"IfNotPresent" ,
"stdin" :true ,
"tty" :true
}
]
}
可以使用以下命令查看新创建的临时容器的状态：
kubectl describe pod example-pod
输出为：
...
Ephemeral Containers:
debugger:
Container ID: docker://cf81908f149e7e9213d3c3644eda55c72efaff67652a2685c1146f0ce151e80f
Image: busybox
Image ID: docker-pullable://busybox@sha256:9f1003c480699be56815db0f8146ad2e22efea85129b5b5983d0e0fb52d9ab70
Port: <none>
Host Port: <none>
Command:
sh
State: Running
Started: Thu, 29 Aug 2019 06:42:21 +0000
Ready: False
Restart Count: 0
Environment: <none>
Mounts: <none>
...
可以使用以下命令连接到新的临时容器：
kubectl attach -it example-pod -c debugger
如果启用了进程命名空间共享，则可以查看该 Pod 所有容器中的进程。
例如，运行上述 attach 操作后，在调试器容器中运行 ps 操作：
# 在 "debugger" 临时容器内中运行此 shell 命令
ps auxww
运行命令后，输出类似于：
PID USER TIME COMMAND
1 root 0:00 /pause
6 root 0:00 nginx: master process nginx -g daemon off;
11 101 0:00 nginx: worker process
12 101 0:00 nginx: worker process
13 101 0:00 nginx: worker process
14 101 0:00 nginx: worker process
15 101 0:00 nginx: worker process
16 101 0:00 nginx: worker process
17 101 0:00 nginx: worker process
18 101 0:00 nginx: worker process
19 root 0:00 /pause
24 root 0:00 sh
29 root 0:00 ps auxww
2 - 工作负载资源 2.1 - Deployments 一个 Deployment 为 Pods
和 ReplicaSets
提供声明式的更新能力。
你负责描述 Deployment 中的 目标状态 ，而 Deployment 控制器（Controller）
以受控速率更改实际状态，
使其变为期望状态。你可以定义 Deployment 以创建新的 ReplicaSet，或删除现有 Deployment，
并通过新的 Deployment 收养其资源。
说明： 不要管理 Deployment 所拥有的 ReplicaSet 。
如果存在下面未覆盖的使用场景，请考虑在 Kubernetes 仓库中提出 Issue。
用例 以下是 Deployments 的典型用例：
创建 Deployment 下面是 Deployment 示例。其中创建了一个 ReplicaSet，负责启动三个 nginx Pods：
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
ports :
- containerPort : 80
在该例中：
创建名为 nginx-deployment（由 .metadata.name 字段标明）的 Deployment。 该 Deployment 创建三个（由 replicas 字段标明）Pod 副本。 template 字段包含以下子字段：Pod 被使用 labels 字段打上 app: nginx 标签。 Pod 模板规约（即 .template.spec 字段）指示 Pods 运行一个 nginx 容器，
该容器运行版本为 1.14.2 的 nginx Docker Hub 镜像。 创建一个容器并使用 name 字段将其命名为 nginx。 开始之前，请确保的 Kubernetes 集群已启动并运行。
按照以下步骤创建上述 Deployment ：
通过运行以下命令创建 Deployment ：
kubectl apply -f https://k8s.io/examples/controllers/nginx-deployment.yaml
说明： 你可以设置 --record 标志将所执行的命令写入资源注解 kubernetes.io/change-cause 中。
这对于以后的检查是有用的。例如，要查看针对每个 Deployment 修订版本所执行过的命令。
运行 kubectl get deployments 检查 Deployment 是否已创建。如果仍在创建 Deployment，
则输出类似于：
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
nginx-deployment 3 0 0 0 1s
在检查集群中的 Deployment 时，所显示的字段有：
NAME 列出了集群中 Deployment 的名称。READY 显示应用程序的可用的 副本 数。显示的模式是“就绪个数/期望个数”。UP-TO-DATE 显示为了达到期望状态已经更新的副本数。AVAILABLE 显示应用可供用户使用的副本数。AGE 显示应用程序运行的时间。请注意期望副本数是根据 .spec.replicas 字段设置 3。
要查看 Deployment 上线状态，运行 kubectl rollout status deployment/nginx-deployment。
输出类似于：
Waiting for rollout to finish: 2 out of 3 new replicas have been updated...
deployment "nginx-deployment" successfully rolled out
几秒钟后再次运行 kubectl get deployments。输出类似于：
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
nginx-deployment 3 3 3 3 18s
注意 Deployment 已创建全部三个副本，并且所有副本都是最新的（它们包含最新的 Pod 模板）
并且可用。
要查看 Deployment 创建的 ReplicaSet（rs），运行 kubectl get rs。
输出类似于：
NAME DESIRED CURRENT READY AGE
nginx-deployment-75675f5897 3 3 3 18s
ReplicaSet 输出中包含以下字段：
NAME 列出名字空间中 ReplicaSet 的名称；DESIRED 显示应用的期望副本个数，即在创建 Deployment 时所定义的值。
此为期望状态；CURRENT 显示当前运行状态中的副本个数；READY 显示应用中有多少副本可以为用户提供服务；AGE 显示应用已经运行的时间长度。注意 ReplicaSet 的名称始终被格式化为[Deployment名称]-[随机字符串]。
其中的随机字符串是使用 pod-template-hash 作为种子随机生成的。
要查看每个 Pod 自动生成的标签，运行 kubectl get pods --show-labels。返回以下输出：
NAME READY STATUS RESTARTS AGE LABELS
nginx-deployment-75675f5897-7ci7o 1/1 Running 0 18s app=nginx,pod-template-hash=3123191453
nginx-deployment-75675f5897-kzszj 1/1 Running 0 18s app=nginx,pod-template-hash=3123191453
nginx-deployment-75675f5897-qqcnn 1/1 Running 0 18s app=nginx,pod-template-hash=3123191453
所创建的 ReplicaSet 确保总是存在三个 nginx Pod。
说明： 你必须在 Deployment 中指定适当的选择算符和 Pod 模板标签（在本例中为 app: nginx）。
标签或者选择算符不要与其他控制器（包括其他 Deployment 和 StatefulSet）重叠。
Kubernetes 不会阻止你这样做，但是如果多个控制器具有重叠的选择算符，它们可能会发生冲突
执行难以预料的操作。
Pod-template-hash 标签 说明： 不要更改此标签。
Deployment 控制器将 pod-template-hash 标签添加到 Deployment 所创建或收留的
每个 ReplicaSet 。
此标签可确保 Deployment 的子 ReplicaSets 不重叠。
标签是通过对 ReplicaSet 的 PodTemplate 进行哈希处理。
所生成的哈希值被添加到 ReplicaSet 选择算符、Pod 模板标签，并存在于在 ReplicaSet
可能拥有的任何现有 Pod 中。
更新 Deployment 说明： 仅当 Deployment Pod 模板（即 .spec.template）发生改变时，例如模板的标签或容器镜像被更新，
才会触发 Deployment 上线。
其他更新（如对 Deployment 执行扩缩容的操作）不会触发上线动作。
按照以下步骤更新 Deployment：
先来更新 nginx Pod 以使用 nginx:1.16.1 镜像，而不是 nginx:1.14.2 镜像。
kubectl --record deployment.apps/nginx-deployment set image \
nginx = nginx:1.16.1
或者使用下面的命令：
kubectl set image deployment/nginx-deployment nginx = nginx:1.16.1 --record
输出类似于：
deployment.apps/nginx-deployment image updated
或者，可以 edit Deployment 并将 .spec.template.spec.containers[0].image 从
nginx:1.14.2 更改至 nginx:1.16.1。
kubectl edit deployment.v1.apps/nginx-deployment
输出类似于：
deployment.apps/nginx-deployment edited
要查看上线状态，运行：
kubectl rollout status deployment/nginx-deployment
输出类似于：
Waiting for rollout to finish: 2 out of 3 new replicas have been updated...
或者
deployment "nginx-deployment" successfully rolled out
获取关于已更新的 Deployment 的更多信息：
运行 kubectl get rs 以查看 Deployment 通过创建新的 ReplicaSet 并将其扩容到
3 个副本并将旧 ReplicaSet 缩容到 0 个副本完成了 Pod 的更新操作：
输出类似于：
NAME DESIRED CURRENT READY AGE
nginx-deployment-1564180365 3 3 3 6s
nginx-deployment-2035384211 0 0 0 36s
现在运行 get pods 应仅显示新的 Pods:
输出类似于：
NAME READY STATUS RESTARTS AGE
nginx-deployment-1564180365-khku8 1/1 Running 0 14s
nginx-deployment-1564180365-nacti 1/1 Running 0 14s
nginx-deployment-1564180365-z9gth 1/1 Running 0 14s
下次要更新这些 Pods 时，只需再次更新 Deployment Pod 模板即可。
Deployment 可确保在更新时仅关闭一定数量的 Pod。默认情况下，它确保至少所需 Pods
75% 处于运行状态（最大不可用比例为 25%）。
Deployment 还确保仅所创建 Pod 数量只可能比期望 Pods 数高一点点。
默认情况下，它可确保启动的 Pod 个数比期望个数最多多出 25%（最大峰值 25%）。
例如，如果仔细查看上述 Deployment ，将看到它首先创建了一个新的 Pod，然后删除了一些旧的 Pods，
并创建了新的 Pods。它不会杀死老 Pods，直到有足够的数量新的 Pods 已经出现。
在足够数量的旧 Pods 被杀死前并没有创建新 Pods。它确保至少 2 个 Pod 可用，同时
最多总共 4 个 Pod 可用。
获取 Deployment 的更多信息
kubectl describe deployments
输出类似于：
Name: nginx-deployment
Namespace: default
CreationTimestamp: Thu, 30 Nov 2017 10:56:25 +0000
Labels: app=nginx
Annotations: deployment.kubernetes.io/revision=2
Selector: app=nginx
Replicas: 3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType: RollingUpdate
MinReadySeconds: 0
RollingUpdateStrategy: 25% max unavailable, 25% max surge
Pod Template:
Labels: app=nginx
Containers:
nginx:
Image: nginx:1.16.1
Port: 80/TCP
Environment: <none>
Mounts: <none>
Volumes: <none>
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
OldReplicaSets: <none>
NewReplicaSet: nginx-deployment-1564180365 (3/3 replicas created)
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal ScalingReplicaSet 2m deployment-controller Scaled up replica set nginx-deployment-2035384211 to 3
Normal ScalingReplicaSet 24s deployment-controller Scaled up replica set nginx-deployment-1564180365 to 1
Normal ScalingReplicaSet 22s deployment-controller Scaled down replica set nginx-deployment-2035384211 to 2
Normal ScalingReplicaSet 22s deployment-controller Scaled up replica set nginx-deployment-1564180365 to 2
Normal ScalingReplicaSet 19s deployment-controller Scaled down replica set nginx-deployment-2035384211 to 1
Normal ScalingReplicaSet 19s deployment-controller Scaled up replica set nginx-deployment-1564180365 to 3
Normal ScalingReplicaSet 14s deployment-controller Scaled down replica set nginx-deployment-2035384211 to 0
可以看到，当第一次创建 Deployment 时，它创建了一个 ReplicaSet（nginx-deployment-2035384211）
并将其直接扩容至 3 个副本。更新 Deployment 时，它创建了一个新的 ReplicaSet
（nginx-deployment-1564180365），并将其扩容为 1，然后将旧 ReplicaSet 缩容到 2，
以便至少有 2 个 Pod 可用且最多创建 4 个 Pod。
然后，它使用相同的滚动更新策略继续对新的 ReplicaSet 扩容并对旧的 ReplicaSet 缩容。
最后，你将有 3 个可用的副本在新的 ReplicaSet 中，旧 ReplicaSet 将缩容到 0。
翻转（多 Deployment 动态更新） Deployment 控制器每次注意到新的 Deployment 时，都会创建一个 ReplicaSet 以启动所需的 Pods。
如果更新了 Deployment，则控制标签匹配 .spec.selector 但模板不匹配 .spec.template 的
Pods 的现有 ReplicaSet 被缩容。最终，新的 ReplicaSet 缩放为 .spec.replicas 个副本，
所有旧 ReplicaSets 缩放为 0 个副本。
当 Deployment 正在上线时被更新，Deployment 会针对更新创建一个新的 ReplicaSet
并开始对其扩容，之前正在被扩容的 ReplicaSet 会被翻转，添加到旧 ReplicaSets 列表
并开始缩容。
例如，假定你在创建一个 Deployment 以生成 nginx:1.14.2 的 5 个副本，但接下来
更新 Deployment 以创建 5 个 nginx:1.16.1 的副本，而此时只有 3 个nginx:1.14.2
副本已创建。在这种情况下，Deployment 会立即开始杀死 3 个 nginx:1.14.2 Pods，
并开始创建 nginx:1.16.1 Pods。它不会等待 nginx:1.14.2 的 5 个副本都创建完成
后才开始执行变更动作。
更改标签选择算符 通常不鼓励更新标签选择算符。建议你提前规划选择算符。
在任何情况下，如果需要更新标签选择算符，请格外小心，并确保自己了解
这背后可能发生的所有事情。
说明： 在 API 版本 apps/v1 中，Deployment 标签选择算符在创建后是不可变的。
添加选择算符时要求使用新标签更新 Deployment 规约中的 Pod 模板标签，否则将返回验证错误。
此更改是非重叠的，也就是说新的选择算符不会选择使用旧选择算符所创建的 ReplicaSet 和 Pod，
这会导致创建新的 ReplicaSet 时所有旧 ReplicaSet 都会被孤立。 选择算符的更新如果更改了某个算符的键名，这会导致与添加算符时相同的行为。 删除选择算符的操作会删除从 Deployment 选择算符中删除现有算符。
此操作不需要更改 Pod 模板标签。现有 ReplicaSet 不会被孤立，也不会因此创建新的 ReplicaSet，
但请注意已删除的标签仍然存在于现有的 Pod 和 ReplicaSet 中。 回滚 Deployment 有时，你可能想要回滚 Deployment；例如，当 Deployment 不稳定时（例如进入反复崩溃状态）。
默认情况下，Deployment 的所有上线记录都保留在系统中，以便可以随时回滚
（你可以通过修改修订历史记录限制来更改这一约束）。
说明： Deployment 被触发上线时，系统就会创建 Deployment 的新的修订版本。
这意味着仅当 Deployment 的 Pod 模板（.spec.template）发生更改时，才会创建新修订版本
-- 例如，模板的标签或容器镜像发生变化。
其他更新，如 Deployment 的扩缩容操作不会创建 Deployment 修订版本。
这是为了方便同时执行手动缩放或自动缩放。
换言之，当你回滚到较早的修订版本时，只有 Deployment 的 Pod 模板部分会被回滚。
按 Ctrl-C 停止上述上线状态观测。有关上线停滞的详细信息，参考这里 。 检查 Deployment 上线历史 按照如下步骤检查回滚历史：
首先，检查 Deployment 修订历史：
kubectl rollout history deployment.v1.apps/nginx-deployment
输出类似于：
deployments "nginx-deployment"
REVISION CHANGE-CAUSE
1 kubectl apply --filename= https://k8s.io/examples/controllers/nginx-deployment.yaml --record= true
2 kubectl set image deployment.v1.apps/nginx-deployment nginx = nginx:1.9.1 --record= true
3 kubectl set image deployment.v1.apps/nginx-deployment nginx = nginx:1.91 --record= true
CHANGE-CAUSE 的内容是从 Deployment 的 kubernetes.io/change-cause 注解复制过来的。
复制动作发生在修订版本创建时。你可以通过以下方式设置 CHANGE-CAUSE 消息：
使用 kubectl annotate deployment.v1.apps/nginx-deployment kubernetes.io/change-cause="image updated to 1.9.1" 为 Deployment 添加注解。 追加 --record 命令行标志以保存正在更改资源的 kubectl 命令。 手动编辑资源的清单。 要查看修订历史的详细信息，运行：
kubectl rollout history deployment.v1.apps/nginx-deployment --revision= 2
输出类似于：
deployments "nginx-deployment" revision 2
Labels: app = nginx
pod-template-hash= 1159050644
Annotations: kubernetes.io/change-cause= kubectl set image deployment.v1.apps/nginx-deployment nginx = nginx:1.16.1 --record= true
Containers:
nginx:
Image: nginx:1.16.1
Port: 80/TCP
QoS Tier:
cpu: BestEffort
memory: BestEffort
Environment Variables: <none>
No volumes.
回滚到之前的修订版本 按照下面给出的步骤将 Deployment 从当前版本回滚到以前的版本（即版本 2）。
假定现在你已决定撤消当前上线并回滚到以前的修订版本：
kubectl rollout undo deployment.v1.apps/nginx-deployment
输出类似于：
deployment.apps/nginx-deployment
或者，你也可以通过使用 --to-revision 来回滚到特定修订版本：
kubectl rollout undo deployment.v1.apps/nginx-deployment --to-revision= 2
输出类似于：
deployment.apps/nginx-deployment
与回滚相关的指令的更详细信息，请参考 kubectl rollout
现在，Deployment 正在回滚到以前的稳定版本。正如你所看到的，Deployment 控制器生成了
回滚到修订版本 2 的 DeploymentRollback 事件。
检查回滚是否成功以及 Deployment 是否正在运行，运行：
kubectl get deployment nginx-deployment
输出类似于：
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
nginx-deployment 3 3 3 3 30m
获取 Deployment 描述信息：
kubectl describe deployment nginx-deployment
输出类似于：
Name: nginx-deployment
Namespace: default
CreationTimestamp: Sun, 02 Sep 2018 18:17:55 -0500
Labels: app=nginx
Annotations: deployment.kubernetes.io/revision=4
kubernetes.io/change-cause=kubectl set image deployment.v1.apps/nginx-deployment nginx=nginx:1.16.1 --record=true
Selector: app=nginx
Replicas: 3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType: RollingUpdate
MinReadySeconds: 0
RollingUpdateStrategy: 25% max unavailable, 25% max surge
Pod Template:
Labels: app=nginx
Containers:
nginx:
Image: nginx:1.16.1
Port: 80/TCP
Host Port: 0/TCP
Environment: <none>
Mounts: <none>
Volumes: <none>
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
OldReplicaSets: <none>
NewReplicaSet: nginx-deployment-c4747d96c (3/3 replicas created)
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal ScalingReplicaSet 12m deployment-controller Scaled up replica set nginx-deployment-75675f5897 to 3
Normal ScalingReplicaSet 11m deployment-controller Scaled up replica set nginx-deployment-c4747d96c to 1
Normal ScalingReplicaSet 11m deployment-controller Scaled down replica set nginx-deployment-75675f5897 to 2
Normal ScalingReplicaSet 11m deployment-controller Scaled up replica set nginx-deployment-c4747d96c to 2
Normal ScalingReplicaSet 11m deployment-controller Scaled down replica set nginx-deployment-75675f5897 to 1
Normal ScalingReplicaSet 11m deployment-controller Scaled up replica set nginx-deployment-c4747d96c to 3
Normal ScalingReplicaSet 11m deployment-controller Scaled down replica set nginx-deployment-75675f5897 to 0
Normal ScalingReplicaSet 11m deployment-controller Scaled up replica set nginx-deployment-595696685f to 1
Normal DeploymentRollback 15s deployment-controller Rolled back deployment "nginx-deployment" to revision 2
Normal ScalingReplicaSet 15s deployment-controller Scaled down replica set nginx-deployment-595696685f to 0
缩放 Deployment 你可以使用如下指令缩放 Deployment：
kubectl scale deployment.v1.apps/nginx-deployment --replicas= 10
输出类似于：
deployment.apps/nginx-deployment scaled
假设集群启用了Pod 的水平自动缩放 ，
你可以为 Deployment 设置自动缩放器，并基于现有 Pods 的 CPU 利用率选择
要运行的 Pods 个数下限和上限。
kubectl autoscale deployment.v1.apps/nginx-deployment --min= 10 --max= 15 --cpu-percent= 80
输出类似于：
deployment.apps/nginx-deployment scaled
比例缩放 RollingUpdate 的 Deployment 支持同时运行应用程序的多个版本。
当自动缩放器缩放处于上线进程（仍在进行中或暂停）中的 RollingUpdate Deployment 时，
Deployment 控制器会平衡现有的活跃状态的 ReplicaSets（含 Pods 的 ReplicaSets）中的额外副本，
以降低风险。这称为 比例缩放（Proportional Scaling） 。
例如，你正在运行一个 10 个副本的 Deployment，其 maxSurge =3，maxUnavailable =2。
镜像更新使用 ReplicaSet nginx-deployment-1989198191 启动新的上线过程，
但由于上面提到的 maxUnavailable 要求，该进程被阻塞了。检查上线状态：
输出类似于：
NAME DESIRED CURRENT READY AGE
nginx-deployment-1989198191 5 5 0 9s
nginx-deployment-618515232 8 8 8 1m
然后，出现了新的 Deployment 扩缩请求。自动缩放器将 Deployment 副本增加到 15。
Deployment 控制器需要决定在何处添加 5 个新副本。如果未使用比例缩放，所有 5 个副本
都将添加到新的 ReplicaSet 中。使用比例缩放时，可以将额外的副本分布到所有 ReplicaSet。
较大比例的副本会被添加到拥有最多副本的 ReplicaSet，而较低比例的副本会进入到
副本较少的 ReplicaSet。所有剩下的副本都会添加到副本最多的 ReplicaSet。
具有零副本的 ReplicaSets 不会被扩容。 在上面的示例中，3 个副本被添加到旧 ReplicaSet 中，2 个副本被添加到新 ReplicaSet。
假定新的副本都很健康，上线过程最终应将所有副本迁移到新的 ReplicaSet 中。
要确认这一点，请运行：
输出类似于：
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
nginx-deployment 15 18 7 8 7m
上线状态确认了副本是如何被添加到每个 ReplicaSet 的。
输出类似于：
NAME DESIRED CURRENT READY AGE
nginx-deployment-1989198191 7 7 0 7m
nginx-deployment-618515232 11 11 11 7m
暂停、恢复 Deployment 你可以在触发一个或多个更新之前暂停 Deployment，然后再恢复其执行。
这样做使得你能够在暂停和恢复执行之间应用多个修补程序，而不会触发不必要的上线操作。
使用如下指令暂停运行：
kubectl rollout pause deployment.v1.apps/nginx-deployment
输出类似于：
deployment.apps/nginx-deployment paused
注意没有新的上线被触发：
kubectl rollout history deployment.v1.apps/nginx-deployment
输出类似于：
deployments "nginx"
REVISION CHANGE-CAUSE
1 <none>
你可以根据需要执行很多更新操作，例如，可以要使用的资源：
kubectl set resources deployment.v1.apps/nginx-deployment -c= nginx --limits= cpu = 200m,memory= 512Mi
输出类似于：
deployment.apps/nginx-deployment resource requirements updated
暂停 Deployment 之前的初始状态将继续发挥作用，但新的更新在 Deployment 被
暂停期间不会产生任何效果。
说明： 你不可以回滚处于暂停状态的 Deployment，除非先恢复其执行状态。
Deployment 状态 Deployment 的生命周期中会有许多状态。上线新的 ReplicaSet 期间可能处于
Progressing（进行中） ，可能是
Complete（已完成） ，也可能是
Failed（失败） 以至于无法继续进行。
进行中的 Deployment 执行下面的任务期间，Kubernetes 标记 Deployment 为 进行中（Progressing） ：
Deployment 创建新的 ReplicaSet Deployment 正在为其最新的 ReplicaSet 扩容 Deployment 正在为其旧有的 ReplicaSet(s) 缩容 新的 Pods 已经就绪或者可用（就绪至少持续了 MinReadySeconds 秒）。 你可以使用 kubectl rollout status 监视 Deployment 的进度。
完成的 Deployment 当 Deployment 具有以下特征时，Kubernetes 将其标记为 完成（Complete） ：
与 Deployment 关联的所有副本都已更新到指定的最新版本，这意味着之前请求的所有更新都已完成。 与 Deployment 关联的所有副本都可用。 未运行 Deployment 的旧副本。 你可以使用 kubectl rollout status 检查 Deployment 是否已完成。
如果上线成功完成，kubectl rollout status 返回退出代码 0。
kubectl rollout status deployment/nginx-deployment
输出类似于：
Waiting for rollout to finish: 2 of 3 updated replicas are available...
deployment "nginx-deployment" successfully rolled out
$ echo $?
0
失败的 Deployment 你的 Deployment 可能会在尝试部署其最新的 ReplicaSet 受挫，一直处于未完成状态。
造成此情况一些可能因素如下：
配额（Quota）不足 就绪探测（Readiness Probe）失败 镜像拉取错误 权限不足 限制范围（Limit Ranges）问题 应用程序运行时的配置错误 检测此状况的一种方法是在 Deployment 规约中指定截止时间参数：
（[.spec.progressDeadlineSeconds]（#progress-deadline-seconds））。
.spec.progressDeadlineSeconds 给出的是一个秒数值，Deployment 控制器在（通过 Deployment 状态）
标示 Deployment 进展停滞之前，需要等待所给的时长。
以下 kubectl 命令设置规约中的 progressDeadlineSeconds，从而告知控制器
在 10 分钟后报告 Deployment 没有进展：
kubectl patch deployment.v1.apps/nginx-deployment -p '{"spec":{"progressDeadlineSeconds":600}}'
输出类似于：
deployment.apps/nginx-deployment patched
超过截止时间后，Deployment 控制器将添加具有以下属性的 DeploymentCondition 到
Deployment 的 .status.conditions 中：
Type=Progressing Status=False Reason=ProgressDeadlineExceeded 参考
Kubernetes API 约定
获取更多状态状况相关的信息。
说明： 除了报告 Reason=ProgressDeadlineExceeded 状态之外，Kubernetes 对已停止的
Deployment 不执行任何操作。更高级别的编排器可以利用这一设计并相应地采取行动。
例如，将 Deployment 回滚到其以前的版本。
如果你暂停了某个 Deployment，Kubernetes 不再根据指定的截止时间检查 Deployment 进展。
你可以在上线过程中间安全地暂停 Deployment 再恢复其执行，这样做不会导致超出最后时限的问题。
Deployment 可能会出现瞬时性的错误，可能因为设置的超时时间过短，
也可能因为其他可认为是临时性的问题。例如，假定所遇到的问题是配额不足。
如果描述 Deployment，你将会注意到以下部分：
kubectl describe deployment nginx-deployment
输出类似于：
<...>
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True ReplicaSetUpdated
ReplicaFailure True FailedCreate
<...>
如果运行 kubectl get deployment nginx-deployment -o yaml，Deployment 状态输出
将类似于这样：
status:
availableReplicas: 2
conditions:
- lastTransitionTime: 2016-10-04T12:25:39Z
lastUpdateTime: 2016-10-04T12:25:39Z
message: Replica set "nginx-deployment-4262182780" is progressing.
reason: ReplicaSetUpdated
status: "True"
type: Progressing
- lastTransitionTime: 2016-10-04T12:25:42Z
lastUpdateTime: 2016-10-04T12:25:42Z
message: Deployment has minimum availability.
reason: MinimumReplicasAvailable
status: "True"
type: Available
- lastTransitionTime: 2016-10-04T12:25:39Z
lastUpdateTime: 2016-10-04T12:25:39Z
message: 'Error creating: pods "nginx-deployment-4262182780-" is forbidden: exceeded quota:
object-counts, requested: pods=1, used: pods=3, limited: pods=2'
reason: FailedCreate
status: "True"
type: ReplicaFailure
observedGeneration: 3
replicas: 2
unavailableReplicas: 2
最终，一旦超过 Deployment 进度限期，Kubernetes 将更新状态和进度状况的原因：
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing False ProgressDeadlineExceeded
ReplicaFailure True FailedCreate
可以通过缩容 Deployment 或者缩容其他运行状态的控制器，或者直接在命名空间中增加配额
来解决配额不足的问题。如果配额条件满足，Deployment 控制器完成了 Deployment 上线操作，
Deployment 状态会更新为成功状况（Status=True and Reason=NewReplicaSetAvailable）。
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
Type=Available 加上 Status=True 意味着 Deployment 具有最低可用性。
最低可用性由 Deployment 策略中的参数指定。
Type=Progressing 加上 Status=True 表示 Deployment 处于上线过程中，并且正在运行，
或者已成功完成进度，最小所需新副本处于可用。
请参阅对应状况的 Reason 了解相关细节。
在我们的案例中 Reason=NewReplicaSetAvailable 表示 Deployment 已完成。
你可以使用 kubectl rollout status 检查 Deployment 是否未能取得进展。
如果 Deployment 已超过进度限期，kubectl rollout status 返回非零退出代码。
kubectl rollout status deployment/nginx-deployment
输出类似于：
Waiting for rollout to finish: 2 out of 3 new replicas have been updated...
error: deployment "nginx" exceeded its progress deadline
kubectl rollout 命令的退出状态为 1（表明发生了错误）：
1
对失败 Deployment 的操作 可应用于已完成的 Deployment 的所有操作也适用于失败的 Deployment。
你可以对其执行扩缩容、回滚到以前的修订版本等操作，或者在需要对 Deployment 的
Pod 模板应用多项调整时，将 Deployment 暂停。
清理策略 你可以在 Deployment 中设置 .spec.revisionHistoryLimit 字段以指定保留此
Deployment 的多少个旧有 ReplicaSet。其余的 ReplicaSet 将在后台被垃圾回收。
默认情况下，此值为 10。
说明： 显式将此字段设置为 0 将导致 Deployment 的所有历史记录被清空，因此 Deployment 将无法回滚。
金丝雀部署 如果要使用 Deployment 向用户子集或服务器子集上线版本，则可以遵循
资源管理
所描述的金丝雀模式，创建多个 Deployment，每个版本一个。
编写 Deployment 规约 同其他 Kubernetes 配置一样， Deployment 需要 apiVersion，kind 和 metadata 字段。
有关配置文件的其他信息，请参考
部署 Deployment 、配置容器和
使用 kubectl 管理资源 等相关文档。
Deployment 对象的名称必须是合法的
DNS 子域名 。
Deployment 还需要 .spec 部分
Pod 模板 .spec 中只有 .spec.template 和 .spec.selector 是必需的字段。
.spec.template 是一个 Pod 模板 。
它和 Pod 的语法规则完全相同。
只是这里它是嵌套的，因此不需要 apiVersion 或 kind。
除了 Pod 的必填字段外，Deployment 中的 Pod 模板必须指定适当的标签和适当的重新启动策略。
对于标签，请确保不要与其他控制器重叠。请参考选择算符 。
只有 .spec.template.spec.restartPolicyAlways 才是被允许的，这也是在没有指定时的默认设置。
副本 .spec.replicas 是指定所需 Pod 的可选字段。它的默认值是1。
选择算符 .spec.selector 是指定本 Deployment 的 Pod
标签选择算符 的必需字段。
.spec.selector 必须匹配 .spec.template.metadata.labels，否则请求会被 API 拒绝。
在 API apps/v1版本中，.spec.selector 和 .metadata.labels 如果没有设置的话，
不会被默认设置为 .spec.template.metadata.labels，所以需要明确进行设置。
同时在 apps/v1版本中，Deployment 创建后 .spec.selector 是不可变的。
当 Pod 的标签和选择算符匹配，但其模板和 .spec.template 不同时，或者此类 Pod
的总数超过 .spec.replicas 的设置时，Deployment 会终结之。
如果 Pods 总数未达到期望值，Deployment 会基于 .spec.template 创建新的 Pod。
说明： 你不应直接创建、或者通过创建另一个 Deployment，或者创建类似 ReplicaSet
或 ReplicationController 这类控制器来创建标签与此选择算符匹配的 Pod。
如果这样做，第一个 Deployment 会认为它创建了这些 Pod。
Kubernetes 不会阻止你这么做。
如果有多个控制器的选择算符发生重叠，则控制器之间会因冲突而无法正常工作。
策略 .spec.strategy 策略指定用于用新 Pods 替换旧 Pods 的策略。
.spec.strategy.type 可以是 “Recreate” 或 “RollingUpdate”。“RollingUpdate” 是默认值。
重新创建 Deployment 如果 .spec.strategy.type==Recreate，在创建新 Pods 之前，所有现有的 Pods 会被杀死。
滚动更新 Deployment Deployment 会在 .spec.strategy.type==RollingUpdate时，采取
滚动更新的方式更新 Pods。你可以指定 maxUnavailable 和 maxSurge 来控制滚动更新
过程。
最大不可用 .spec.strategy.rollingUpdate.maxUnavailable 是一个可选字段，用来指定
更新过程中不可用的 Pod 的个数上限。该值可以是绝对数字（例如，5），也可以是
所需 Pods 的百分比（例如，10%）。百分比值会转换成绝对数并去除小数部分。
如果 .spec.strategy.rollingUpdate.maxSurge 为 0，则此值不能为 0。
默认值为 25%。
例如，当此值设置为 30% 时，滚动更新开始时会立即将旧 ReplicaSet 缩容到期望 Pod 个数的70%。
新 Pod 准备就绪后，可以继续缩容旧有的 ReplicaSet，然后对新的 ReplicaSet 扩容，确保在更新期间
可用的 Pods 总数在任何时候都至少为所需的 Pod 个数的 70%。
最大峰值 .spec.strategy.rollingUpdate.maxSurge 是一个可选字段，用来指定可以创建的超出
期望 Pod 个数的 Pod 数量。此值可以是绝对数（例如，5）或所需 Pods 的百分比（例如，10%）。
如果 MaxUnavailable 为 0，则此值不能为 0。百分比值会通过向上取整转换为绝对数。
此字段的默认值为 25%。
例如，当此值为 30% 时，启动滚动更新后，会立即对新的 ReplicaSet 扩容，同时保证新旧 Pod
的总数不超过所需 Pod 总数的 130%。一旦旧 Pods 被杀死，新的 ReplicaSet 可以进一步扩容，
同时确保更新期间的任何时候运行中的 Pods 总数最多为所需 Pods 总数的 130%。
进度期限秒数 .spec.progressDeadlineSeconds 是一个可选字段，用于指定系统在报告 Deployment
进展失败 之前等待 Deployment 取得进展的秒数。
这类报告会在资源状态中体现为 Type=Progressing、Status=False、
Reason=ProgressDeadlineExceeded。Deployment 控制器将持续重试 Deployment。
将来，一旦实现了自动回滚，Deployment 控制器将在探测到这样的条件时立即回滚 Deployment。
如果指定，则此字段值需要大于 .spec.minReadySeconds 取值。
最短就绪时间 .spec.minReadySeconds 是一个可选字段，用于指定新创建的 Pod 在没有任意容器崩溃情况下的最小就绪时间，
只有超出这个时间 Pod 才被视为可用。默认值为 0（Pod 在准备就绪后立即将被视为可用）。
要了解何时 Pod 被视为就绪，可参考容器探针 。
修订历史限制 Deployment 的修订历史记录存储在它所控制的 ReplicaSets 中。
.spec.revisionHistoryLimit 是一个可选字段，用来设定出于会滚目的所要保留的旧 ReplicaSet 数量。
这些旧 ReplicaSet 会消耗 etcd 中的资源，并占用 kubectl get rs 的输出。
每个 Deployment 修订版本的配置都存储在其 ReplicaSets 中；因此，一旦删除了旧的 ReplicaSet，
将失去回滚到 Deployment 的对应修订版本的能力。
默认情况下，系统保留 10 个旧 ReplicaSet，但其理想值取决于新 Deployment 的频率和稳定性。
更具体地说，将此字段设置为 0 意味着将清理所有具有 0 个副本的旧 ReplicaSet。
在这种情况下，无法撤消新的 Deployment 上线，因为它的修订历史被清除了。
paused（暂停的） .spec.paused 是用于暂停和恢复 Deployment 的可选布尔字段。
暂停的 Deployment 和未暂停的 Deployment 的唯一区别是，Deployment 处于暂停状态时，
PodTemplateSpec 的任何修改都不会触发新的上线。
Deployment 在创建时是默认不会处于暂停状态。
2.2 - ReplicaSet ReplicaSet 的目的是维护一组在任何时候都处于运行状态的 Pod 副本的稳定集合。
因此，它通常用来保证给定数量的、完全相同的 Pod 的可用性。
ReplicaSet 的工作原理 RepicaSet 是通过一组字段来定义的，包括一个用来识别可获得的 Pod
的集合的选择算符、一个用来标明应该维护的副本个数的数值、一个用来指定应该创建新 Pod
以满足副本个数条件时要使用的 Pod 模板等等。
每个 ReplicaSet 都通过根据需要创建和 删除 Pod 以使得副本个数达到期望值，
进而实现其存在价值。当 ReplicaSet 需要创建新的 Pod 时，会使用所提供的 Pod 模板。
ReplicaSet 通过 Pod 上的
metadata.ownerReferences
字段连接到附属 Pod，该字段给出当前对象的属主资源。
ReplicaSet 所获得的 Pod 都在其 ownerReferences 字段中包含了属主 ReplicaSet
的标识信息。正是通过这一连接，ReplicaSet 知道它所维护的 Pod 集合的状态，
并据此计划其操作行为。
ReplicaSet 使用其选择算符来辨识要获得的 Pod 集合。如果某个 Pod 没有
OwnerReference 或者其 OwnerReference 不是一个
控制器 ，且其匹配到
某 ReplicaSet 的选择算符，则该 Pod 立即被此 ReplicaSet 获得。
何时使用 ReplicaSet ReplicaSet 确保任何时间都有指定数量的 Pod 副本在运行。
然而，Deployment 是一个更高级的概念，它管理 ReplicaSet，并向 Pod
提供声明式的更新以及许多其他有用的功能。
因此，我们建议使用 Deployment 而不是直接使用 ReplicaSet，除非
你需要自定义更新业务流程或根本不需要更新。
这实际上意味着，你可能永远不需要操作 ReplicaSet 对象：而是使用
Deployment，并在 spec 部分定义你的应用。
示例 apiVersion : apps/v1
kind : ReplicaSet
metadata :
name : frontend
labels :
app : guestbook
tier : frontend
spec :
# modify replicas according to your case
replicas : 3
selector :
matchLabels :
tier : frontend
template :
metadata :
labels :
tier : frontend
spec :
containers :
- name : php-redis
image : gcr.io/google_samples/gb-frontend:v3
将此清单保存到 frontend.yaml 中，并将其提交到 Kubernetes 集群，
应该就能创建 yaml 文件所定义的 ReplicaSet 及其管理的 Pod。
kubectl apply -f https://kubernetes.io/examples/controllers/frontend.yaml
你可以看到当前被部署的 ReplicaSet：
并看到你所创建的前端：
NAME DESIRED CURRENT READY AGE
frontend 3 3 3 6s
你也可以查看 ReplicaSet 的状态：
kubectl describe rs/frontend
你会看到类似如下的输出：
Name: frontend
Namespace: default
Selector: tier=frontend
Labels: app=guestbook
tier=frontend
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"apps/v1","kind":"ReplicaSet","metadata":{"annotations":{},"labels":{"app":"guestbook","tier":"frontend"},"name":"frontend",...
Replicas: 3 current / 3 desired
Pods Status: 3 Running / 0 Waiting / 0 Succeeded / 0 Failed
Pod Template:
Labels: tier=frontend
Containers:
php-redis:
Image: gcr.io/google_samples/gb-frontend:v3
Port: <none>
Host Port: <none>
Environment: <none>
Mounts: <none>
Volumes: <none>
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal SuccessfulCreate 117s replicaset-controller Created pod: frontend-wtsmm
Normal SuccessfulCreate 116s replicaset-controller Created pod: frontend-b2zdv
Normal SuccessfulCreate 116s replicaset-controller Created pod: frontend-vcmts
最后可以查看启动了的 Pods：
你会看到类似如下的 Pod 信息：
NAME READY STATUS RESTARTS AGE
frontend-b2zdv 1/1 Running 0 6m36s
frontend-vcmts 1/1 Running 0 6m36s
frontend-wtsmm 1/1 Running 0 6m36s
你也可以查看 Pods 的属主引用被设置为前端的 ReplicaSet。
要实现这点，可取回运行中的 Pods 之一的 YAML：
kubectl get pods frontend-b2zdv -o yaml
输出将类似这样，frontend ReplicaSet 的信息被设置在 metadata 的
ownerReferences 字段中：
apiVersion : v1
kind : Pod
metadata :
creationTimestamp : "2020-02-12T07:06:16Z"
generateName : frontend-
labels :
tier : frontend
name : frontend-b2zdv
namespace : default
ownerReferences :
- apiVersion : apps/v1
blockOwnerDeletion : true
controller : true
kind : ReplicaSet
name : frontend
uid : f391f6db-bb9b-4c09-ae74-6a1f77f3d5cf
...
非模板 Pod 的获得 尽管你完全可以直接创建裸的 Pods，强烈建议你确保这些裸的 Pods 并不包含可能与你
的某个 ReplicaSet 的选择算符相匹配的标签。原因在于 ReplicaSet 并不仅限于拥有
在其模板中设置的 Pods，它还可以像前面小节中所描述的那样获得其他 Pods。
apiVersion : v1
kind : Pod
metadata :
name : pod1
labels :
tier : frontend
spec :
containers :
- name : hello1
image : gcr.io/google-samples/hello-app:2.0
---
apiVersion : v1
kind : Pod
metadata :
name : pod2
labels :
tier : frontend
spec :
containers :
- name : hello2
image : gcr.io/google-samples/hello-app:1.0
由于这些 Pod 没有控制器（Controller，或其他对象）作为其属主引用，并且
其标签与 frontend ReplicaSet 的选择算符匹配，它们会立即被该 ReplicaSet
获取。
假定你在 frontend ReplicaSet 已经被部署之后创建 Pods，并且你已经在 ReplicaSet
中设置了其初始的 Pod 副本数以满足其副本计数需要：
kubectl apply -f https://kubernetes.io/examples/pods/pod-rs.yaml
新的 Pods 会被该 ReplicaSet 获取，并立即被 ReplicaSet 终止，因为
它们的存在会使得 ReplicaSet 中 Pod 个数超出其期望值。
取回 Pods：
输出显示新的 Pods 或者已经被终止，或者处于终止过程中：
NAME READY STATUS RESTARTS AGE
frontend-b2zdv 1/1 Running 0 10m
frontend-vcmts 1/1 Running 0 10m
frontend-wtsmm 1/1 Running 0 10m
pod1 0/1 Terminating 0 1s
pod2 0/1 Terminating 0 1s
如果你先行创建 Pods：
kubectl apply -f https://kubernetes.io/examples/pods/pod-rs.yaml
之后再创建 ReplicaSet：
kubectl apply -f https://kubernetes.io/examples/controllers/frontend.yaml
你会看到 ReplicaSet 已经获得了该 Pods，并仅根据其规约创建新的 Pods，直到
新的 Pods 和原来的 Pods 的总数达到其预期个数。
这时取回 Pods：
将会生成下面的输出：
NAME READY STATUS RESTARTS AGE
frontend-hmmj2 1/1 Running 0 9s
pod1 1/1 Running 0 36s
pod2 1/1 Running 0 36s
采用这种方式，一个 ReplicaSet 中可以包含异质的 Pods 集合。
编写 ReplicaSet 的 spec 与所有其他 Kubernetes API 对象一样，ReplicaSet 也需要 apiVersion、kind、和 metadata 字段。
对于 ReplicaSets 而言，其 kind 始终是 ReplicaSet。
在 Kubernetes 1.9 中，ReplicaSet 上的 API 版本 apps/v1 是其当前版本，且被
默认启用。API 版本 apps/v1beta2 已被废弃。
参考 frontend.yaml 示例的第一行。
ReplicaSet 对象的名称必须是合法的
DNS 子域名 。
ReplicaSet 也需要 .spec
Pod 模版 .spec.template 是一个Pod 模版 ，
要求设置标签。在 frontend.yaml 示例中，我们指定了标签 tier: frontend。
注意不要将标签与其他控制器的选择算符重叠，否则那些控制器会尝试收养此 Pod。
对于模板的重启策略
字段，.spec.template.spec.restartPolicy，唯一允许的取值是 Always，这也是默认值.
Pod 选择算符 .spec.selector 字段是一个标签选择算符 。
如前文中所讨论的 ，这些是用来标识要被获取的 Pods
的标签。在签名的 frontend.yaml 示例中，选择算符为：
matchLabels :
tier : frontend
在 ReplicaSet 中，.spec.template.metadata.labels 的值必须与 spec.selector 值
相匹配，否则该配置会被 API 拒绝。
说明： 对于设置了相同的 .spec.selector，但
.spec.template.metadata.labels 和 .spec.template.spec 字段不同的
两个 ReplicaSet 而言，每个 ReplicaSet 都会忽略被另一个 ReplicaSet 所
创建的 Pods。
Replicas 你可以通过设置 .spec.replicas 来指定要同时运行的 Pod 个数。
ReplicaSet 创建、删除 Pods 以与此值匹配。
如果你没有指定 .spec.replicas, 那么默认值为 1。
使用 ReplicaSets 删除 ReplicaSet 和它的 Pod 要删除 ReplicaSet 和它的所有 Pod，使用
kubectl delete垃圾收集器
自动删除所有依赖的 Pod。
当使用 REST API 或 client-go 库时，你必须在删除选项中将 propagationPolicy
设置为 Background 或 Foreground。例如：
kubectl proxy --port= 8080
curl -X DELETE 'localhost:8080/apis/apps/v1/namespaces/default/replicasets/frontend' \
'{"kind":"DeleteOptions","apiVersion":"v1","propagationPolicy":"Foreground"}' \
"Content-Type: application/json"
只删除 ReplicaSet 你可以只删除 ReplicaSet 而不影响它的 Pods，方法是使用
kubectl delete--cascade=orphan 选项。
当使用 REST API 或 client-go 库时，你必须将 propagationPolicy 设置为 Orphan。
例如：
kubectl proxy --port= 8080
curl -X DELETE 'localhost:8080/apis/apps/v1/namespaces/default/replicasets/frontend' \
'{"kind":"DeleteOptions","apiVersion":"v1","propagationPolicy":"Orphan"}' \
"Content-Type: application/json"
一旦删除了原来的 ReplicaSet，就可以创建一个新的来替换它。
由于新旧 ReplicaSet 的 .spec.selector 是相同的，新的 ReplicaSet 将接管老的 Pod。
但是，它不会努力使现有的 Pod 与新的、不同的 Pod 模板匹配。
若想要以可控的方式更新 Pod 的规约，可以使用
Deployment
资源，因为 ReplicaSet 并不直接支持滚动更新。
将 Pod 从 ReplicaSet 中隔离 可以通过改变标签来从 ReplicaSet 的目标集中移除 Pod。
这种技术可以用来从服务中去除 Pod，以便进行排错、数据恢复等。
以这种方式移除的 Pod 将被自动替换（假设副本的数量没有改变）。
缩放 RepliaSet 通过更新 .spec.replicas 字段，ReplicaSet 可以被轻松的进行缩放。ReplicaSet
控制器能确保匹配标签选择器的数量的 Pod 是可用的和可操作的。
ReplicaSet 作为水平的 Pod 自动缩放器目标 ReplicaSet 也可以作为
水平的 Pod 缩放器 (HPA)
的目标。也就是说，ReplicaSet 可以被 HPA 自动缩放。
以下是 HPA 以我们在前一个示例中创建的副本集为目标的示例。
apiVersion : autoscaling/v1
kind : HorizontalPodAutoscaler
metadata :
name : frontend-scaler
spec :
scaleTargetRef :
kind : ReplicaSet
name : frontend
minReplicas : 3
maxReplicas : 10
targetCPUUtilizationPercentage : 50
将这个列表保存到 hpa-rs.yaml 并提交到 Kubernetes 集群，就能创建它所定义的
HPA，进而就能根据复制的 Pod 的 CPU 利用率对目标 ReplicaSet进行自动缩放。
kubectl apply -f https://k8s.io/examples/controllers/hpa-rs.yaml
或者，可以使用 kubectl autoscale 命令完成相同的操作。 (而且它更简单！)
kubectl autoscale rs frontend --max= 10 --min= 3 --cpu-percent= 50
ReplicaSet 的替代方案 Deployment （推荐） Deployment
裸 Pod 与用户直接创建 Pod 的情况不同，ReplicaSet 会替换那些由于某些原因被删除或被终止的
Pod，例如在节点故障或破坏性的节点维护（如内核升级）的情况下。
因为这个原因，我们建议你使用 ReplicaSet，即使应用程序只需要一个 Pod。
想像一下，ReplicaSet 类似于进程监视器，只不过它在多个节点上监视多个 Pod，
而不是在单个节点上监视单个进程。
ReplicaSet 将本地容器重启的任务委托给了节点上的某个代理（例如，Kubelet 或 Docker）去完成。
Job 使用Job
DaemonSet 对于管理那些提供主机级别功能（如主机监控和主机日志）的容器，
就要用 DaemonSet
ReplicationController ReplicaSet 是 ReplicationController
的后继者。二者目的相同且行为类似，只是 ReplicationController 不支持
标签用户指南
中讨论的基于集合的选择算符需求。
因此，相比于 ReplicationController，应优先考虑 ReplicaSet。
2.3 - StatefulSets StatefulSet 是用来管理有状态应用的工作负载 API 对象。
StatefulSet 用来管理某 Pod 集合的部署和扩缩，
并为这些 Pod 提供持久存储和持久标识符。
和 Deployment 类似，
StatefulSet 管理基于相同容器规约的一组 Pod。但和 Deployment 不同的是，
StatefulSet 为它们的每个 Pod 维护了一个有粘性的 ID。这些 Pod 是基于相同的规约来创建的，
但是不能相互替换：无论怎么调度，每个 Pod 都有一个永久不变的 ID。
如果希望使用存储卷为工作负载提供持久存储，可以使用 StatefulSet 作为解决方案的一部分。
尽管 StatefulSet 中的单个 Pod 仍可能出现故障，
但持久的 Pod 标识符使得将现有卷与替换已失败 Pod 的新 Pod 相匹配变得更加容易。
使用 StatefulSets StatefulSets 对于需要满足以下一个或多个需求的应用程序很有价值：
稳定的、唯一的网络标识符。 稳定的、持久的存储。 有序的、优雅的部署和缩放。 有序的、自动的滚动更新。 在上面描述中，“稳定的”意味着 Pod 调度或重调度的整个过程是有持久性的。
如果应用程序不需要任何稳定的标识符或有序的部署、删除或伸缩，则应该使用
由一组无状态的副本控制器提供的工作负载来部署应用程序，比如
Deployment 或者
ReplicaSet
可能更适用于你的无状态应用部署需要。
限制 给定 Pod 的存储必须由
PersistentVolume 驱动
基于所请求的 storage class 来提供，或者由管理员预先提供。 删除或者收缩 StatefulSet 并不会 删除它关联的存储卷。
这样做是为了保证数据安全，它通常比自动清除 StatefulSet 所有相关的资源更有价值。 StatefulSet 当前需要无头服务
来负责 Pod 的网络标识。你需要负责创建此服务。 当删除 StatefulSets 时，StatefulSet 不提供任何终止 Pod 的保证。
为了实现 StatefulSet 中的 Pod 可以有序地且体面地终止，可以在删除之前将 StatefulSet
缩放为 0。 在默认 Pod 管理策略 (OrderedReady) 时使用
滚动更新 ，可能进入需要人工干预
才能修复的损坏状态。 组件 下面的示例演示了 StatefulSet 的组件。
apiVersion : v1
kind : Service
metadata :
name : nginx
labels :
app : nginx
spec :
ports :
- port : 80
name : web
clusterIP : None
selector :
app : nginx
---
apiVersion : apps/v1
kind : StatefulSet
metadata :
name : web
spec :
selector :
matchLabels :
app : nginx # has to match .spec.template.metadata.labels
serviceName : "nginx"
replicas : 3 # by default is 1
template :
metadata :
labels :
app : nginx # has to match .spec.selector.matchLabels
spec :
terminationGracePeriodSeconds : 10
containers :
- name : nginx
image : k8s.gcr.io/nginx-slim:0.8
ports :
- containerPort : 80
name : web
volumeMounts :
- name : www
mountPath : /usr/share/nginx/html
volumeClaimTemplates :
- metadata :
name : www
spec :
accessModes : [ "ReadWriteOnce" ]
storageClassName : "my-storage-class"
resources :
requests :
storage : 1Gi
上述例子中：
名为 nginx 的 Headless Service 用来控制网络域名。 名为 web 的 StatefulSet 有一个 Spec，它表明将在独立的 3 个 Pod 副本中启动 nginx 容器。 volumeClaimTemplates 将通过 PersistentVolumes 驱动提供的
PersistentVolumes 来提供稳定的存储。StatefulSet 的命名需要遵循DNS 子域名 规范。
Pod 选择算符 你必须设置 StatefulSet 的 .spec.selector 字段，使之匹配其在
.spec.template.metadata.labels 中设置的标签。在 Kubernetes 1.8 版本之前，
被忽略 .spec.selector 字段会获得默认设置值。
在 1.8 和以后的版本中，未指定匹配的 Pod 选择器将在创建 StatefulSet 期间导致验证错误。
Pod 标识 StatefulSet Pod 具有唯一的标识，该标识包括顺序标识、稳定的网络标识和稳定的存储。
该标识和 Pod 是绑定的，不管它被调度在哪个节点上。
有序索引 对于具有 N 个副本的 StatefulSet，StatefulSet 中的每个 Pod 将被分配一个整数序号，
从 0 到 N-1，该序号在 StatefulSet 上是唯一的。
稳定的网络 ID StatefulSet 中的每个 Pod 根据 StatefulSet 的名称和 Pod 的序号派生出它的主机名。
组合主机名的格式为$(StatefulSet 名称)-$(序号)。
上例将会创建三个名称分别为 web-0、web-1、web-2 的 Pod。
StatefulSet 可以使用 无头服务
控制它的 Pod 的网络域。管理域的这个服务的格式为：
$(服务名称).$(命名空间).svc.cluster.local，其中 cluster.local 是集群域。
一旦每个 Pod 创建成功，就会得到一个匹配的 DNS 子域，格式为：
$(pod 名称).$(所属服务的 DNS 域名)，其中所属服务由 StatefulSet 的 serviceName 域来设定。
取决于集群域内部 DNS 的配置，有可能无法查询一个刚刚启动的 Pod 的 DNS 命名。
当集群内其他客户端在 Pod 创建完成前发出 Pod 主机名查询时，就会发生这种情况。
负缓存 (在 DNS 中较为常见) 意味着之前失败的查询结果会被记录和重用至少若干秒钟，
即使 Pod 已经正常运行了也是如此。
如果需要在 Pod 被创建之后及时发现它们，有以下选项：
直接查询 Kubernetes API（比如，利用 watch 机制）而不是依赖于 DNS 查询 缩短 Kubernetes DNS 驱动的缓存时长（通常这意味着修改 CoreDNS 的 ConfigMap，目前缓存时长为 30 秒） 正如限制 中所述，你需要负责创建无头服务
以便为 Pod 提供网络标识。
下面给出一些选择集群域、服务名、StatefulSet 名、及其怎样影响 StatefulSet 的 Pod 上的 DNS 名称的示例：
集群域名 服务（名字空间/名字） StatefulSet（名字空间/名字） StatefulSet 域名 Pod DNS Pod 主机名 cluster.local default/nginx default/web nginx.default.svc.cluster.local web-{0..N-1}.nginx.default.svc.cluster.local web-{0..N-1} cluster.local foo/nginx foo/web nginx.foo.svc.cluster.local web-{0..N-1}.nginx.foo.svc.cluster.local web-{0..N-1} kube.local foo/nginx foo/web nginx.foo.svc.kube.local web-{0..N-1}.nginx.foo.svc.kube.local web-{0..N-1}
说明： 集群域会被设置为
cluster.local，除非有
其他配置 。
稳定的存储 Kubernetes 为每个 VolumeClaimTemplate 创建一个 PersistentVolume 。
在上面的 nginx 示例中，每个 Pod 将会得到基于 StorageClass my-storage-class 提供的
1 Gib 的 PersistentVolume。如果没有声明 StorageClass，就会使用默认的 StorageClass。
当一个 Pod 被调度（重新调度）到节点上时，它的 volumeMounts 会挂载与其
PersistentVolumeClaims 相关联的 PersistentVolume。
请注意，当 Pod 或者 StatefulSet 被删除时，与 PersistentVolumeClaims 相关联的
PersistentVolume 并不会被删除。要删除它必须通过手动方式来完成。
Pod 名称标签 当 StatefulSet 控制器（Controller） 创建 Pod 时，
它会添加一个标签 statefulset.kubernetes.io/pod-name，该标签值设置为 Pod 名称。
这个标签允许你给 StatefulSet 中的特定 Pod 绑定一个 Service。
部署和扩缩保证 对于包含 N 个 副本的 StatefulSet，当部署 Pod 时，它们是依次创建的，顺序为 0..N-1。 当删除 Pod 时，它们是逆序终止的，顺序为 N-1..0。 在将缩放操作应用到 Pod 之前，它前面的所有 Pod 必须是 Running 和 Ready 状态。 在 Pod 终止之前，所有的继任者必须完全关闭。 StatefulSet 不应将 pod.Spec.TerminationGracePeriodSeconds 设置为 0。
这种做法是不安全的，要强烈阻止。更多的解释请参考
强制删除 StatefulSet Pod 。
在上面的 nginx 示例被创建后，会按照 web-0、web-1、web-2 的顺序部署三个 Pod。
在 web-0 进入 Running 和 Ready
状态前不会部署 web-1。在 web-1 进入 Running 和 Ready 状态前不会部署 web-2。
如果 web-1 已经处于 Running 和 Ready 状态，而 web-2 尚未部署，在此期间发生了
web-0 运行失败，那么 web-2 将不会被部署，要等到 web-0 部署完成并进入 Running 和
Ready 状态后，才会部署 web-2。
如果用户想将示例中的 StatefulSet 收缩为 replicas=1，首先被终止的是 web-2。
在 web-2 没有被完全停止和删除前，web-1 不会被终止。
当 web-2 已被终止和删除、web-1 尚未被终止，如果在此期间发生 web-0 运行失败，
那么就不会终止 web-1，必须等到 web-0 进入 Running 和 Ready 状态后才会终止 web-1。
Pod 管理策略 在 Kubernetes 1.7 及以后的版本中，StatefulSet 允许你放宽其排序保证，
同时通过它的 .spec.podManagementPolicy 域保持其唯一性和身份保证。
OrderedReady Pod 管理 OrderedReady Pod 管理是 StatefulSet 的默认设置。它实现了
上面 描述的功能。
并行 Pod 管理 Parallel Pod 管理让 StatefulSet 控制器并行的启动或终止所有的 Pod，
启动或者终止其他 Pod 前，无需等待 Pod 进入 Running 和 ready 或者完全停止状态。
这个选项只会影响伸缩操作的行为，更新则不会被影响。
更新策略 在 Kubernetes 1.7 及以后的版本中，StatefulSet 的 .spec.updateStrategy 字段让
你可以配置和禁用掉自动滚动更新 Pod 的容器、标签、资源请求或限制、以及注解。
关于删除策略 OnDelete 更新策略实现了 1.6 及以前版本的历史遗留行为。当 StatefulSet 的
.spec.updateStrategy.type 设置为 OnDelete 时，它的控制器将不会自动更新
StatefulSet 中的 Pod。
用户必须手动删除 Pod 以便让控制器创建新的 Pod，以此来对 StatefulSet 的
.spec.template 的变动作出反应。
滚动更新 RollingUpdate 更新策略对 StatefulSet 中的 Pod 执行自动的滚动更新。
在没有声明 .spec.updateStrategy 时，RollingUpdate 是默认配置。
当 StatefulSet 的 .spec.updateStrategy.type 被设置为 RollingUpdate 时，
StatefulSet 控制器会删除和重建 StatefulSet 中的每个 Pod。
它将按照与 Pod 终止相同的顺序（从最大序号到最小序号）进行，每次更新一个 Pod。
它会等到被更新的 Pod 进入 Running 和 Ready 状态，然后再更新其前身。
分区 通过声明 .spec.updateStrategy.rollingUpdate.partition 的方式，RollingUpdate
更新策略可以实现分区。
如果声明了一个分区，当 StatefulSet 的 .spec.template 被更新时，
所有序号大于等于该分区序号的 Pod 都会被更新。
所有序号小于该分区序号的 Pod 都不会被更新，并且，即使他们被删除也会依据之前的版本进行重建。
如果 StatefulSet 的 .spec.updateStrategy.rollingUpdate.partition 大于它的
.spec.replicas，对它的 .spec.template 的更新将不会传递到它的 Pod。
在大多数情况下，你不需要使用分区，但如果你希望进行阶段更新、执行金丝雀或执行
分阶段上线，则这些分区会非常有用。
强制回滚 在默认 Pod 管理策略 (OrderedReady) 下使用
滚动更新 ，可能进入需要人工干预才能修复的损坏状态。
如果更新后 Pod 模板配置进入无法运行或就绪的状态（例如，由于错误的二进制文件
或应用程序级配置错误），StatefulSet 将停止回滚并等待。
在这种状态下，仅将 Pod 模板还原为正确的配置是不够的。由于
已知问题 ，StatefulSet
将继续等待损坏状态的 Pod 准备就绪（永远不会发生），然后再尝试将其恢复为正常工作配置。
恢复模板后，还必须删除 StatefulSet 尝试使用错误的配置来运行的 Pod。这样，
StatefulSet 才会开始使用被还原的模板来重新创建 Pod。
接下来 2.4 - DaemonSet DaemonSet 确保全部（或者某些）节点上运行一个 Pod 的副本。
当有节点加入集群时， 也会为他们新增一个 Pod 。
当有节点从集群移除时，这些 Pod 也会被回收。删除 DaemonSet 将会删除它创建的所有 Pod。
DaemonSet 的一些典型用法：
在每个节点上运行集群守护进程 在每个节点上运行日志收集守护进程 在每个节点上运行监控守护进程 一种简单的用法是为每种类型的守护进程在所有的节点上都启动一个 DaemonSet。
一个稍微复杂的用法是为同一种守护进程部署多个 DaemonSet；每个具有不同的标志，
并且对不同硬件类型具有不同的内存、CPU 要求。
编写 DaemonSet Spec 创建 DaemonSet 你可以在 YAML 文件中描述 DaemonSet。
例如，下面的 daemonset.yaml 文件描述了一个运行 fluentd-elasticsearch Docker 镜像的 DaemonSet：
apiVersion : apps/v1
kind : DaemonSet
metadata :
name : fluentd-elasticsearch
namespace : kube-system
labels :
k8s-app : fluentd-logging
spec :
selector :
matchLabels :
name : fluentd-elasticsearch
template :
metadata :
labels :
name : fluentd-elasticsearch
spec :
tolerations :
# this toleration is to have the daemonset runnable on master nodes
# remove it if your masters can't run pods
- key : node-role.kubernetes.io/master
effect : NoSchedule
containers :
- name : fluentd-elasticsearch
image : quay.io/fluentd_elasticsearch/fluentd:v2.5.2
resources :
limits :
memory : 200Mi
requests :
cpu : 100m
memory : 200Mi
volumeMounts :
- name : varlog
mountPath : /var/log
- name : varlibdockercontainers
mountPath : /var/lib/docker/containers
readOnly : true
terminationGracePeriodSeconds : 30
volumes :
- name : varlog
hostPath :
path : /var/log
- name : varlibdockercontainers
hostPath :
path : /var/lib/docker/containers
基于 YAML 文件创建 DaemonSet：
kubectl apply -f https://k8s.io/examples/controllers/daemonset.yaml
必需字段 和所有其他 Kubernetes 配置一样，DaemonSet 需要 apiVersion、kind 和 metadata 字段。
有关配置文件的基本信息，参见
部署应用 、
配置容器 和
使用 kubectl 进行对象管理
文档。
DaemonSet 对象的名称必须是一个合法的
DNS 子域名 。
DaemonSet 也需要一个 .spec
Pod 模板 .spec 中唯一必需的字段是 .spec.template。
.spec.template 是一个 Pod 模板 。
除了它是嵌套的，因而不具有 apiVersion 或 kind 字段之外，它与
Pod 具有相同的 schema。
除了 Pod 必需字段外，在 DaemonSet 中的 Pod 模板必须指定合理的标签（查看 Pod 选择算符 ）。
在 DaemonSet 中的 Pod 模板必须具有一个值为 Always 的
RestartPolicyAlways。
Pod 选择算符 .spec.selector 字段表示 Pod 选择算符，它与
Job 的 .spec.selector 的作用是相同的。
从 Kubernetes 1.8 开始，您必须指定与 .spec.template 的标签匹配的 Pod 选择算符。
用户不指定 Pod 选择算符时，该字段不再有默认值。
选择算符的默认值生成结果与 kubectl apply 不兼容。
此外，一旦创建了 DaemonSet，它的 .spec.selector 就不能修改。
修改 Pod 选择算符可能导致 Pod 意外悬浮，并且这对用户来说是费解的。
spec.selector 是一个对象，如下两个字段组成：
matchLabels - 与 ReplicationController
的 .spec.selector 的作用相同。matchExpressions - 允许构建更加复杂的选择器，可以通过指定 key、value
列表以及将 key 和 value 列表关联起来的 operator。当上述两个字段都指定时，结果会按逻辑与（AND）操作处理。
如果指定了 .spec.selector，必须与 .spec.template.metadata.labels 相匹配。
如果与后者不匹配，则 DeamonSet 会被 API 拒绝。
仅在某些节点上运行 Pod 如果指定了 .spec.template.spec.nodeSelector，DaemonSet 控制器将在能够与
Node 选择算符 匹配的节点上创建 Pod。
类似这种情况，可以指定 .spec.template.spec.affinity，之后 DaemonSet 控制器
将在能够与节点亲和性
匹配的节点上创建 Pod。
如果根本就没有指定，则 DaemonSet Controller 将在所有节点上创建 Pod。
Daemon Pods 是如何被调度的 通过默认调度器调度 FEATURE STATE: Kubernetes v1.20 [stable]
DaemonSet 确保所有符合条件的节点都运行该 Pod 的一个副本。
通常，运行 Pod 的节点由 Kubernetes 调度器选择。
不过，DaemonSet Pods 由 DaemonSet 控制器创建和调度。这就带来了以下问题：
Pod 行为的不一致性：正常 Pod 在被创建后等待调度时处于 Pending 状态，
DaemonSet Pods 创建后不会处于 Pending 状态下。这使用户感到困惑。 Pod 抢占
由默认调度器处理。启用抢占后，DaemonSet 控制器将在不考虑 Pod 优先级和抢占
的情况下制定调度决策。ScheduleDaemonSetPods 允许您使用默认调度器而不是 DaemonSet 控制器来调度 DaemonSets，
方法是将 NodeAffinity 条件而不是 .spec.nodeName 条件添加到 DaemonSet Pods。
默认调度器接下来将 Pod 绑定到目标主机。
如果 DaemonSet Pod 的节点亲和性配置已存在，则被替换。
DaemonSet 控制器仅在创建或修改 DaemonSet Pod 时执行这些操作，
并且不会更改 DaemonSet 的 spec.template。
nodeAffinity :
requiredDuringSchedulingIgnoredDuringExecution :
nodeSelectorTerms :
- matchFields :
- key : metadata.name
operator : In
values :
- target-host-name
此外，系统会自动添加 node.kubernetes.io/unschedulable：NoSchedule 容忍度到
DaemonSet Pods。在调度 DaemonSet Pod 时，默认调度器会忽略 unschedulable 节点。
污点和容忍度 尽管 Daemon Pods 遵循污点和容忍度
规则，根据相关特性，控制器会自动将以下容忍度添加到 DaemonSet Pod：
容忍度键名 效果 版本 描述 node.kubernetes.io/not-readyNoExecute 1.13+ 当出现类似网络断开的情况导致节点问题时，DaemonSet Pod 不会被逐出。 node.kubernetes.io/unreachableNoExecute 1.13+ 当出现类似于网络断开的情况导致节点问题时，DaemonSet Pod 不会被逐出。 node.kubernetes.io/disk-pressureNoSchedule 1.8+ DaemonSet Pod 被默认调度器调度时能够容忍磁盘压力属性。 node.kubernetes.io/memory-pressureNoSchedule 1.8+ DaemonSet Pod 被默认调度器调度时能够容忍内存压力属性。 node.kubernetes.io/unschedulableNoSchedule 1.12+ DaemonSet Pod 能够容忍默认调度器所设置的 unschedulable 属性. node.kubernetes.io/network-unavailableNoSchedule 1.12+ DaemonSet 在使用宿主网络时，能够容忍默认调度器所设置的 network-unavailable 属性。
与 Daemon Pods 通信 与 DaemonSet 中的 Pod 进行通信的几种可能模式如下：
推送（Push） ：配置 DaemonSet 中的 Pod，将更新发送到另一个服务，例如统计数据库。
这些服务没有客户端。
NodeIP 和已知端口 ：DaemonSet 中的 Pod 可以使用 hostPort，从而可以通过节点 IP
访问到 Pod。客户端能通过某种方法获取节点 IP 列表，并且基于此也可以获取到相应的端口。
DNS ：创建具有相同 Pod 选择算符的
无头服务 ，
通过使用 endpoints 资源或从 DNS 中检索到多个 A 记录来发现 DaemonSet。
Service ：创建具有相同 Pod 选择算符的服务，并使用该服务随机访问到某个节点上的
守护进程（没有办法访问到特定节点）。
更新 DaemonSet 如果节点的标签被修改，DaemonSet 将立刻向新匹配上的节点添加 Pod，
同时删除不匹配的节点上的 Pod。
你可以修改 DaemonSet 创建的 Pod。不过并非 Pod 的所有字段都可更新。
下次当某节点（即使具有相同的名称）被创建时，DaemonSet 控制器还会使用最初的模板。
您可以删除一个 DaemonSet。如果使用 kubectl 并指定 --cascade=false 选项，
则 Pod 将被保留在节点上。接下来如果创建使用相同选择算符的新 DaemonSet，
新的 DaemonSet 会收养已有的 Pod。
如果有 Pod 需要被替换，DaemonSet 会根据其 updateStrategy 来替换。
你可以对 DaemonSet 执行滚动更新 操作。
DaemonSet 的替代方案 init 脚本 直接在节点上启动守护进程（例如使用 init、upstartd 或 systemd）的做法当然是可行的。
不过，基于 DaemonSet 来运行这些进程有如下一些好处：
像所运行的其他应用一样，DaemonSet 具备为守护进程提供监控和日志管理的能力。
为守护进程和应用所使用的配置语言和工具（如 Pod 模板、kubectl）是相同的。
在资源受限的容器中运行守护进程能够增加守护进程和应用容器的隔离性。
然而，这一点也可以通过在容器中运行守护进程但却不在 Pod 中运行之来实现。
例如，直接基于 Docker 启动。
裸 Pod 直接创建 Pod并指定其运行在特定的节点上也是可以的。
然而，DaemonSet 能够替换由于任何原因（例如节点失败、例行节点维护、内核升级）
而被删除或终止的 Pod。
由于这个原因，你应该使用 DaemonSet 而不是单独创建 Pod。
静态 Pod 通过在一个指定的、受 kubelet 监视的目录下编写文件来创建 Pod 也是可行的。
这类 Pod 被称为静态 Pod 。
不像 DaemonSet，静态 Pod 不受 kubectl 和其它 Kubernetes API 客户端管理。
静态 Pod 不依赖于 API 服务器，这使得它们在启动引导新集群的情况下非常有用。
此外，静态 Pod 在将来可能会被废弃。
Deployments DaemonSet 与 Deployments 非常类似，
它们都能创建 Pod，并且 Pod 中的进程都不希望被终止（例如，Web 服务器、存储服务器）。
建议为无状态的服务使用 Deployments，比如前端服务。
对这些服务而言，对副本的数量进行扩缩容、平滑升级，比精确控制 Pod 运行在某个主机上要重要得多。
当需要 Pod 副本总是运行在全部或特定主机上，并需要它们先于其他 Pod 启动时，
应该使用 DaemonSet。
2.5 - Jobs Job 会创建一个或者多个 Pods，并将继续重试 Pods 的执行，直到指定数量的 Pods 成功终止。
随着 Pods 成功结束，Job 跟踪记录成功完成的 Pods 个数。
当数量达到指定的成功个数阈值时，任务（即 Job）结束。
删除 Job 的操作会清除所创建的全部 Pods。
一种简单的使用场景下，你会创建一个 Job 对象以便以一种可靠的方式运行某 Pod 直到完成。
当第一个 Pod 失败或者被删除（比如因为节点硬件失效或者重启）时，Job
对象会启动一个新的 Pod。
你也可以使用 Job 以并行的方式运行多个 Pod。
运行示例 Job 下面是一个 Job 配置示例。它负责计算 π 到小数点后 2000 位，并将结果打印出来。
此计算大约需要 10 秒钟完成。
apiVersion : batch/v1
kind : Job
metadata :
name : pi
spec :
template :
spec :
containers :
- name : pi
image : perl
command : ["perl" , "-Mbignum=bpi" , "-wle" , "print bpi(2000)" ]
restartPolicy : Never
backoffLimit : 4
你可以使用下面的命令来运行此示例：
kubectl apply -f https://kubernetes.io/examples/controllers/job.yaml
输出类似于：
job.batch/pi created
使用 kubectl 来检查 Job 的状态：
输出类似于：
Name: pi
Namespace: default
Selector: controller-uid=c9948307-e56d-4b5d-8302-ae2d7b7da67c
Labels: controller-uid=c9948307-e56d-4b5d-8302-ae2d7b7da67c
job-name=pi
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"batch/v1","kind":"Job","metadata":{"annotations":{},"name":"pi","namespace":"default"},"spec":{"backoffLimit":4,"template":...
Parallelism: 1
Completions: 1
Start Time: Mon, 02 Dec 2019 15:20:11 +0200
Completed At: Mon, 02 Dec 2019 15:21:16 +0200
Duration: 65s
Pods Statuses: 0 Running / 1 Succeeded / 0 Failed
Pod Template:
Labels: controller-uid=c9948307-e56d-4b5d-8302-ae2d7b7da67c
job-name=pi
Containers:
pi:
Image: perl
Port: <none>
Host Port: <none>
Command:
perl
-Mbignum=bpi
-wle
print bpi(2000)
Environment: <none>
Mounts: <none>
Volumes: <none>
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal SuccessfulCreate 14m job-controller Created pod: pi-5rwd7
要查看 Job 对应的已完成的 Pods，可以执行 kubectl get pods。
要以机器可读的方式列举隶属于某 Job 的全部 Pods，你可以使用类似下面这条命令：
pods = $( kubectl get pods --selector= job-name= pi --output= jsonpath = '{.items[*].metadata.name}' )
echo $pods
输出类似于：
pi-5rwd7
这里，选择算符与 Job 的选择算符相同。--output=jsonpath 选项给出了一个表达式，
用来从返回的列表中提取每个 Pod 的 name 字段。
查看其中一个 Pod 的标准输出：
输出类似于：
3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632788659361533818279682303019520353018529689957736225994138912497217752834791315155748572424541506959508295331168617278558890750983817546374649393192550604009277016711390098488240128583616035637076601047101819429555961989467678374494482553797747268471040475346462080466842590694912933136770289891521047521620569660240580381501935112533824300355876402474964732639141992726042699227967823547816360093417216412199245863150302861829745557067498385054945885869269956909272107975093029553211653449872027559602364806654991198818347977535663698074265425278625518184175746728909777727938000816470600161452491921732172147723501414419735685481613611573525521334757418494684385233239073941433345477624168625189835694855620992192221842725502542568876717904946016534668049886272327917860857843838279679766814541009538837863609506800642251252051173929848960841284886269456042419652850222106611863067442786220391949450471237137869609563643719172874677646575739624138908658326459958133904780275901
编写 Job 规约 与 Kubernetes 中其他资源的配置类似，Job 也需要 apiVersion、kind 和 metadata 字段。
Job 的名字必须是合法的 DNS 子域名 。
Job 配置还需要一个.spec 节
Pod 模版 Job 的 .spec 中只有 .spec.template 是必需的字段。
字段 .spec.template 的值是一个 Pod 模版 。
其定义规范与 Pod
完全相同，只是其中不再需要 apiVersion 或 kind 字段。
除了作为 Pod 所必需的字段之外，Job 中的 Pod 模版必需设置合适的标签
（参见Pod 选择算符 ）和合适的重启策略。
Job 中 Pod 的 RestartPolicyNever 或 OnFailure 之一。
Pod 选择算符 字段 .spec.selector 是可选的。在绝大多数场合，你都不需要为其赋值。
参阅设置自己的 Pod 选择算符 .
Job 的并行执行 适合以 Job 形式来运行的任务主要有三种：
非并行 Job通常只启动一个 Pod，除非该 Pod 失败 当 Pod 成功终止时，立即视 Job 为完成状态 具有 确定完成计数 的并行 Job.spec.completions 字段设置为非 0 的正数值Job 用来代表整个任务，当对应于 1 和 .spec.completions 之间的每个整数都存在
一个成功的 Pod 时，Job 被视为完成 尚未实现 ：每个 Pod 收到一个介于 1 和 spec.completions 之间的不同索引值 带 工作队列 的并行 Job不设置 spec.completions，默认值为 .spec.parallelism 多个 Pod 之间必须相互协调，或者借助外部服务确定每个 Pod 要处理哪个工作条目。
例如，任一 Pod 都可以从工作队列中取走最多 N 个工作条目。 每个 Pod 都可以独立确定是否其它 Pod 都已完成，进而确定 Job 是否完成 当 Job 中 任何 Pod 成功终止，不再创建新 Pod 一旦至少 1 个 Pod 成功完成，并且所有 Pod 都已终止，即可宣告 Job 成功完成 一旦任何 Pod 成功退出，任何其它 Pod 都不应再对此任务执行任何操作或生成任何输出。
所有 Pod 都应启动退出过程。 对于 非并行 的 Job，你可以不设置 spec.completions 和 spec.parallelism。
这两个属性都不设置时，均取默认值 1。
对于 确定完成计数 类型的 Job，你应该设置 .spec.completions 为所需要的完成个数。
你可以设置 .spec.parallelism，也可以不设置。其默认值为 1。
对于一个 工作队列 Job，你不可以设置 .spec.completions，但要将.spec.parallelism
设置为一个非负整数。
关于如何利用不同类型的 Job 的更多信息，请参见 Job 模式 一节。
控制并行性 并行性请求（.spec.parallelism）可以设置为任何非负整数。
如果未设置，则默认为 1。
如果设置为 0，则 Job 相当于启动之后便被暂停，直到此值被增加。
实际并行性（在任意时刻运行状态的 Pods 个数）可能比并行性请求略大或略小，
原因如下：
对于 确定完成计数 Job，实际上并行执行的 Pods 个数不会超出剩余的完成数。
如果 .spec.parallelism 值较高，会被忽略。 对于 工作队列 Job，有任何 Job 成功结束之后，不会有新的 Pod 启动。
不过，剩下的 Pods 允许执行完毕。 如果 Job 控制器 没有来得及作出响应，或者 如果 Job 控制器因为任何原因（例如，缺少 ResourceQuota 或者没有权限）无法创建 Pods。
Pods 个数可能比请求的数目小。 Job 控制器可能会因为之前同一 Job 中 Pod 失效次数过多而压制新 Pod 的创建。 当 Pod 处于体面终止进程中，需要一定时间才能停止。 处理 Pod 和容器失效 Pod 中的容器可能因为多种不同原因失效，例如因为其中的进程退出时返回值非零，
或者容器因为超出内存约束而被杀死等等。
如果发生这类事件，并且 .spec.template.spec.restartPolicy = "OnFailure"，
Pod 则继续留在当前节点，但容器会被重新运行。
因此，你的程序需要能够处理在本地被重启的情况，或者要设置
.spec.template.spec.restartPolicy = "Never"。
关于 restartPolicy 的更多信息，可参阅
Pod 生命周期 。
整个 Pod 也可能会失败，且原因各不相同。
例如，当 Pod 启动时，节点失效（被升级、被重启、被删除等）或者其中的容器失败而
.spec.template.spec.restartPolicy = "Never"。
当 Pod 失败时，Job 控制器会启动一个新的 Pod。
这意味着，你的应用需要处理在一个新 Pod 中被重启的情况。
尤其是应用需要处理之前运行所产生的临时文件、锁、不完整的输出等问题。
注意，即使你将 .spec.parallelism 设置为 1，且将 .spec.completions 设置为
1，并且 .spec.template.spec.restartPolicy 设置为 "Never"，同一程序仍然有可能被启动两次。
如果你确实将 .spec.parallelism 和 .spec.completions 都设置为比 1 大的值，
那就有可能同时出现多个 Pod 运行的情况。
为此，你的 Pod 也必须能够处理并发性问题。
Pod 回退失效策略 在有些情形下，你可能希望 Job 在经历若干次重试之后直接进入失败状态，因为这很
可能意味着遇到了配置错误。
为了实现这点，可以将 .spec.backoffLimit 设置为视 Job 为失败之前的重试次数。
失效回退的限制值默认为 6。
与 Job 相关的失效的 Pod 会被 Job 控制器重建，回退重试时间将会按指数增长
（从 10 秒、20 秒到 40 秒）最多至 6 分钟。
当 Job 的 Pod 被删除时，或者 Pod 成功时没有其它 Pod 处于失败状态，失效回退的次数也会被重置（为 0）。
说明： 如果你的 Job 的 restartPolicy 被设置为 "OnFailure"，就要注意运行该 Job 的容器
会在 Job 到达失效回退次数上限时自动被终止。
这会使得调试 Job 中可执行文件的工作变得非常棘手。
我们建议在调试 Job 时将 restartPolicy 设置为 "Never"，
或者使用日志系统来确保失效 Jobs 的输出不会意外遗失。
Job 终止与清理 Job 完成时不会再创建新的 Pod，不过已有的 Pod 也不会被删除。
保留这些 Pod 使得你可以查看已完成的 Pod 的日志输出，以便检查错误、警告
或者其它诊断性输出。
Job 完成时 Job 对象也一样被保留下来，这样你就可以查看它的状态。
在查看了 Job 状态之后删除老的 Job 的操作留给了用户自己。
你可以使用 kubectl 来删除 Job（例如，kubectl delete jobs/pi
或者 kubectl delete -f ./job.yaml）。
当使用 kubectl 来删除 Job 时，该 Job 所创建的 Pods 也会被删除。
默认情况下，Job 会持续运行，除非某个 Pod 失败（restartPolicy=Never）
或者某个容器出错退出（restartPolicy=OnFailure）。
这时，Job 基于前述的 spec.backoffLimit 来决定是否以及如何重试。
一旦重试次数到达 .spec.backoffLimit 所设的上限，Job 会被标记为失败，
其中运行的 Pods 都会被终止。
终止 Job 的另一种方式是设置一个活跃期限。
你可以为 Job 的 .spec.activeDeadlineSeconds 设置一个秒数值。
该值适用于 Job 的整个生命期，无论 Job 创建了多少个 Pod。
一旦 Job 运行时间达到 activeDeadlineSeconds 秒，其所有运行中的 Pod
都会被终止，并且 Job 的状态更新为 type: Failed
及 reason: DeadlineExceeded。
注意 Job 的 .spec.activeDeadlineSeconds 优先级高于其 .spec.backoffLimit 设置。
因此，如果一个 Job 正在重试一个或多个失效的 Pod，该 Job 一旦到达
activeDeadlineSeconds 所设的时限即不再部署额外的 Pod，即使其重试次数还未
达到 backoffLimit 所设的限制。
例如：
apiVersion : batch/v1
kind : Job
metadata :
name : pi-with-timeout
spec :
backoffLimit : 5
activeDeadlineSeconds : 100
template :
spec :
containers :
- name : pi
image : perl
command : ["perl" , "-Mbignum=bpi" , "-wle" , "print bpi(2000)" ]
restartPolicy : Never
注意 Job 规约和 Job 中的
Pod 模版规约
都有 activeDeadlineSeconds 字段。
请确保你在合适的层次设置正确的字段。
还要注意的是，restartPolicy 对应的是 Pod，而不是 Job 本身：
一旦 Job 状态变为 type: Failed，就不会再发生 Job 重启的动作。
换言之，由 .spec.activeDeadlineSeconds 和 .spec.backoffLimit 所触发的 Job 终结机制
都会导致 Job 永久性的失败，而这类状态都需要手工干预才能解决。
自动清理完成的 Job 完成的 Job 通常不需要留存在系统中。在系统中一直保留它们会给 API
服务器带来额外的压力。
如果 Job 由某种更高级别的控制器来管理，例如
CronJobs ，
则 Job 可以被 CronJob 基于特定的根据容量裁定的清理策略清理掉。
已完成 Job 的 TTL 机制 FEATURE STATE: Kubernetes v1.12 [alpha]
自动清理已完成 Job （状态为 Complete 或 Failed）的另一种方式是使用由
TTL 控制器 所提供
的 TTL 机制。
通过设置 Job 的 .spec.ttlSecondsAfterFinished 字段，可以让该控制器清理掉
已结束的资源。
TTL 控制器清理 Job 时，会级联式地删除 Job 对象。
换言之，它会删除所有依赖的对象，包括 Pod 及 Job 本身。
注意，当 Job 被删除时，系统会考虑其生命周期保障，例如其 Finalizers。
例如：
apiVersion : batch/v1
kind : Job
metadata :
name : pi-with-ttl
spec :
ttlSecondsAfterFinished : 100
template :
spec :
containers :
- name : pi
image : perl
command : ["perl" , "-Mbignum=bpi" , "-wle" , "print bpi(2000)" ]
restartPolicy : Never
Job pi-with-ttl 在结束 100 秒之后，可以成为被自动删除的对象。
如果该字段设置为 0，Job 在结束之后立即成为可被自动删除的对象。
如果该字段没有设置，Job 不会在结束之后被 TTL 控制器自动清除。
注意这种 TTL 机制仍然是一种 Alpha 状态的功能特性，需要配合 TTLAfterFinished
特性门控使用。有关详细信息，可参考
TTL 控制器 的文档。
Job 模式 Job 对象可以用来支持多个 Pod 的可靠的并发执行。
Job 对象不是设计用来支持相互通信的并行进程的，后者一般在科学计算中应用较多。
Job 的确能够支持对一组相互独立而又有所关联的 工作条目 的并行处理。
这类工作条目可能是要发送的电子邮件、要渲染的视频帧、要编解码的文件、NoSQL
数据库中要扫描的主键范围等等。
在一个复杂系统中，可能存在多个不同的工作条目集合。这里我们仅考虑用户希望一起管理的
工作条目集合之一 — 批处理作业 。
并行计算的模式有好多种，每种都有自己的强项和弱点。这里要权衡的因素有：
每个工作条目对应一个 Job 或者所有工作条目对应同一 Job 对象。
后者更适合处理大量工作条目的场景；
前者会给用户带来一些额外的负担，而且需要系统管理大量的 Job 对象。 创建与工作条目相等的 Pod 或者令每个 Pod 可以处理多个工作条目。
前者通常不需要对现有代码和容器做较大改动；
后者则更适合工作条目数量较大的场合，原因同上。 有几种技术都会用到工作队列。这意味着需要运行一个队列服务，并修改现有程序或容器
使之能够利用该工作队列。
与之比较，其他方案在修改现有容器化应用以适应需求方面可能更容易一些。 下面是对这些权衡的汇总，列 2 到 4 对应上面的权衡比较。
模式的名称对应了相关示例和更详细描述的链接。
当你使用 .spec.completions 来设置完成数时，Job 控制器所创建的每个 Pod
使用完全相同的 spec
下表显示的是每种模式下 .spec.parallelism 和 .spec.completions 所需要的设置。
其中，W 表示的是工作条目的个数。
高级用法 指定你自己的 Pod 选择算符 通常，当你创建一个 Job 对象时，你不会设置 .spec.selector。
系统的默认值填充逻辑会在创建 Job 时添加此字段。
它会选择一个不会与任何其他 Job 重叠的选择算符设置。
不过，有些场合下，你可能需要重载这个自动设置的选择算符。
为了实现这点，你可以手动设置 Job 的 spec.selector 字段。
做这个操作时请务必小心。
如果你所设定的标签选择算符并不唯一针对 Job 对应的 Pod 集合，甚或该算符还能匹配
其他无关的 Pod，这些无关的 Job 的 Pod 可能会被删除。
或者当前 Job 会将另外一些 Pod 当作是完成自身工作的 Pods，
又或者两个 Job 之一或者二者同时都拒绝创建 Pod，无法运行至完成状态。
如果所设置的算符不具有唯一性，其他控制器（如 RC 副本控制器）及其所管理的 Pod
集合可能会变得行为不可预测。
Kubernetes 不会在你设置 .spec.selector 时尝试阻止你犯这类错误。
下面是一个示例场景，在这种场景下你可能会使用刚刚讲述的特性。
假定名为 old 的 Job 已经处于运行状态。
你希望已有的 Pod 继续运行，但你希望 Job 接下来要创建的其他 Pod
使用一个不同的 Pod 模版，甚至希望 Job 的名字也发生变化。
你无法更新现有的 Job，因为这些字段都是不可更新的。
因此，你会删除 old Job，但 允许该 Job 的 Pod 集合继续运行 。
这是通过 kubectl delete jobs/old --cascade=false 实现的。
在删除之前，我们先记下该 Job 所使用的选择算符。
kubectl get job old -o yaml
输出类似于：
kind : Job
metadata :
name : old
...
spec :
selector :
matchLabels :
controller-uid : a8f3d00d-c6d2-11e5-9f87-42010af00002
...
接下来你会创建名为 new 的新 Job，并显式地为其设置相同的选择算符。
由于现有 Pod 都具有标签 controller-uid=a8f3d00d-c6d2-11e5-9f87-42010af00002，
它们也会被名为 new 的 Job 所控制。
你需要在新 Job 中设置 manualSelector: true，因为你并未使用系统通常自动为你
生成的选择算符。
kind : Job
metadata :
name : new
...
spec :
manualSelector : true
selector :
matchLabels :
controller-uid : a8f3d00d-c6d2-11e5-9f87-42010af00002
...
新的 Job 自身会有一个不同于 a8f3d00d-c6d2-11e5-9f87-42010af00002 的唯一 ID。
设置 manualSelector: true 是在告诉系统你知道自己在干什么并要求系统允许这种不匹配
的存在。
替代方案 裸 Pod 当 Pod 运行所在的节点重启或者失败，Pod 会被终止并且不会被重启。
Job 会重新创建新的 Pod 来替代已终止的 Pod。
因为这个原因，我们建议你使用 Job 而不是独立的裸 Pod，
即使你的应用仅需要一个 Pod。
副本控制器 Job 与副本控制器 是彼此互补的。
副本控制器管理的是那些不希望被终止的 Pod （例如，Web 服务器），
Job 管理的是那些希望被终止的 Pod（例如，批处理作业）。
正如在 Pod 生命期 中讨论的，
Job 仅适合于 restartPolicy 设置为 OnFailure 或 Never 的 Pod。
注意：如果 restartPolicy 未设置，其默认值是 Always。
单个 Job 启动控制器 Pod 另一种模式是用唯一的 Job 来创建 Pod，而该 Pod 负责启动其他 Pod，因此扮演了一种
后启动 Pod 的控制器的角色。
这种模式的灵活性更高，但是有时候可能会把事情搞得很复杂，很难入门，
并且与 Kubernetes 的集成度很低。
这种模式的实例之一是用 Job 来启动一个运行脚本的 Pod，脚本负责启动 Spark
主控制器（参见 Spark 示例 ），
运行 Spark 驱动，之后完成清理工作。
这种方法的优点之一是整个过程得到了 Job 对象的完成保障，
同时维持了对创建哪些 Pod、如何向其分派工作的完全控制能力，
Cron Jobs 你可以使用 CronJobcron 工具。
2.6 - 垃圾收集 Kubernetes 垃圾收集器的作用是删除某些曾经拥有属主（Owner）但现在不再拥有属主的对象。
属主和附属 某些 Kubernetes 对象是其它一些对象的属主。
例如，一个 ReplicaSet 是一组 Pod 的属主。
具有属主的对象被称为是属主的 附属 。
每个附属对象具有一个指向其所属对象的 metadata.ownerReferences 字段。
有时，Kubernetes 会自动设置 ownerReference 的值。
例如，当创建一个 ReplicaSet 时，Kubernetes 自动设置 ReplicaSet 中每个 Pod 的 ownerReference 字段值。
在 Kubernetes 1.8 版本，Kubernetes 会自动为某些对象设置 ownerReference 的值。
这些对象是由 ReplicationController、ReplicaSet、StatefulSet、DaemonSet、Deployment、
Job 和 CronJob 所创建或管理的。
你也可以通过手动设置 ownerReference 的值，来指定属主和附属之间的关系。
下面的配置文件中包含一个具有 3 个 Pod 的 ReplicaSet：
apiVersion : apps/v1
kind : ReplicaSet
metadata :
name : my-repset
spec :
replicas : 3
selector :
matchLabels :
pod-is-for : garbage-collection-example
template :
metadata :
labels :
pod-is-for : garbage-collection-example
spec :
containers :
- name : nginx
image : nginx
如果你创建该 ReplicaSet，然后查看 Pod 的 metadata 字段，能够看到 OwnerReferences 字段：
kubectl apply -f https://k8s.io/examples/controllers/replicaset.yaml
kubectl get pods --output= yaml
输出显示了 Pod 的属主是名为 my-repset 的 ReplicaSet：
apiVersion : v1
kind : Pod
metadata :
...
ownerReferences :
- apiVersion : apps/v1
controller : true
blockOwnerDeletion : true
kind : ReplicaSet
name : my-repset
uid : d9607e19-f88f-11e6-a518-42010a800195
...
说明： 根据设计，kubernetes 不允许跨名字空间指定属主。
名字空间范围的附属可以指定集群范围的或者名字空间范围的属主。
名字空间范围的属主必须 和该附属处于相同的名字空间。
如果名字空间范围的属主和附属不在相同的名字空间，那么该属主引用就会被认为是缺失的，
并且当附属的所有属主引用都被确认不再存在之后，该附属就会被删除。
集群范围的附属只能指定集群范围的属主。
在 v1.20+ 版本，如果一个集群范围的附属指定了一个名字空间范围类型的属主，
那么该附属就会被认为是拥有一个不可解析的属主引用，并且它不能够被垃圾回收。
在 v1.20+ 版本，如果垃圾收集器检测到无效的跨名字空间的属主引用，
或者一个集群范围的附属指定了一个名字空间范围类型的属主，
那么它就会报告一个警告事件。该事件的原因是 OwnerRefInvalidNamespace，
involvedObject 属性中包含无效的附属。你可以通过以下命令来获取该类型的事件：
kubectl get events -A --field-selector= reason = OwnerRefInvalidNamespace
控制垃圾收集器删除附属 当你删除对象时，可以指定该对象的附属是否也自动删除。
自动删除附属的行为也称为 级联删除（Cascading Deletion） 。
Kubernetes 中有两种 级联删除 模式：后台（Background） 模式和 前台（Foreground） 模式。
如果删除对象时，不自动删除它的附属，这些附属被称作 孤立对象（Orphaned） 。
前台级联删除 在 前台级联删除 模式下，根对象首先进入 deletion in progress 状态。
在 deletion in progress 状态，会有如下的情况：
对象仍然可以通过 REST API 可见。 对象的 deletionTimestamp 字段被设置。 对象的 metadata.finalizers 字段包含值 foregroundDeletion。 一旦对象被设置为 deletion in progress 状态，垃圾收集器会删除对象的所有附属。
垃圾收集器在删除了所有有阻塞能力的附属（对象的 ownerReference.blockOwnerDeletion=true）
之后，删除属主对象。
注意，在 foregroundDeletion 模式下，只有设置了 ownerReference.blockOwnerDeletion
值的附属才能阻止删除属主对象。
在 Kubernetes 1.7 版本增加了
准入控制器 ，
基于属主对象上的删除权限来控制用户设置 blockOwnerDeletion 的值为 True，
这样未经授权的附属不能够阻止属主对象的删除。
如果一个对象的 ownerReferences 字段被一个控制器（例如 Deployment 或 ReplicaSet）设置，
blockOwnerDeletion 也会被自动设置，你不需要手动修改这个字段。
后台级联删除 在 后台级联删除 模式下，Kubernetes 会立即删除属主对象，之后垃圾收集器
会在后台删除其附属对象。
设置级联删除策略 通过为属主对象设置 deleteOptions.propagationPolicy 字段，可以控制级联删除策略。
可能的取值包括：Orphan、Foreground 或者 Background。
下面是一个在后台删除附属对象的示例：
kubectl proxy --port= 8080
curl -X DELETE localhost:8080/apis/apps/v1/namespaces/default/replicasets/my-repset \
'{"kind":"DeleteOptions","apiVersion":"v1","propagationPolicy":"Background"}' \
"Content-Type: application/json"
下面是一个在前台中删除附属对象的示例：
kubectl proxy --port= 8080
curl -X DELETE localhost:8080/apis/apps/v1/namespaces/default/replicasets/my-repset \
'{"kind":"DeleteOptions","apiVersion":"v1","propagationPolicy":"Foreground"}' \
"Content-Type: application/json"
下面是一个令附属成为孤立对象的示例：
kubectl proxy --port= 8080
curl -X DELETE localhost:8080/apis/apps/v1/namespaces/default/replicasets/my-repset \
'{"kind":"DeleteOptions","apiVersion":"v1","propagationPolicy":"Orphan"}' \
"Content-Type: application/json"
kubectl 命令也支持级联删除。
通过设置 --cascade=foreground，可以使用 kubectl 在前台删除附属对象。
设置 --cascade=orphan，会使附属对象成为孤立附属对象。
当不指定 --cascade 或者明确地指定它的值为 background 的时候，
默认的行为是在后台删除附属对象。
下面是一个例子，使一个 ReplicaSet 的附属对象成为孤立附属：
kubectl delete replicaset my-repset --cascade= orphan
Deployment 的附加说明 在 1.7 之前的版本中，当在 Deployment 中使用级联删除时，你 必须 使用
propagationPolicy:Foreground 模式以便在删除所创建的 ReplicaSet 的同时，还删除其 Pod。
如果不使用这种类型的 propagationPolicy，将只删除 ReplicaSet，而 Pod 被孤立。
有关信息请参考 kubeadm/#149 。
已知的问题 跟踪 #26120
接下来 2.7 - 已完成资源的 TTL 控制器 FEATURE STATE: Kubernetes v1.12 [alpha]
TTL 控制器提供了一种 TTL 机制来限制已完成执行的资源对象的生命周期。
TTL 控制器目前只处理 Job ，
可能以后会扩展以处理将完成执行的其他资源，例如 Pod 和自定义资源。
Alpha 免责声明：此功能目前是 alpha 版，并且可以通过 kube-apiserver 和
kube-controller-manager 上的
特性门控
TTLAfterFinished 启用。
TTL 控制器 TTL 控制器现在只支持 Job。集群操作员可以通过指定 Job 的 .spec.ttlSecondsAfterFinished
字段来自动清理已结束的作业（Complete 或 Failed），如
示例
所示。
TTL 控制器假设资源能在执行完成后的 TTL 秒内被清理，也就是当 TTL 过期后。
当 TTL 控制器清理资源时，它将做级联删除操作，即删除资源对象的同时也删除其依赖对象。
注意，当资源被删除时，由该资源的生命周期保证其终结器（Finalizers）等被执行。
可以随时设置 TTL 秒。以下是设置 Job 的 .spec.ttlSecondsAfterFinished 字段的一些示例：
警告 更新 TTL 秒 请注意，在创建资源或已经执行结束后，仍可以修改其 TTL 周期，例如 Job 的
.spec.ttlSecondsAfterFinished 字段。
但是一旦 Job 变为可被删除状态（当其 TTL 已过期时），即使您通过 API 增加其 TTL
时长得到了成功的响应，系统也不保证 Job 将被保留。
时间偏差 由于 TTL 控制器使用存储在 Kubernetes 资源中的时间戳来确定 TTL 是否已过期，
因此该功能对集群中的时间偏差很敏感，这可能导致 TTL 控制器在错误的时间清理资源对象。
在 Kubernetes 中，需要在所有节点上运行 NTP（参见
#6159 ）
以避免时间偏差。时钟并不总是如此正确，但差异应该很小。
设置非零 TTL 时请注意避免这种风险。
接下来 2.8 - CronJob FEATURE STATE: Kubernetes v1.8 [beta]
Cron Job 创建基于时间调度的 Jobs 。
一个 CronJob 对象就像 crontab (cron table) 文件中的一行。
它用 Cron 格式进行编写，
并周期性地在给定的调度时间执行 Job。
注意： 所有 CronJob 的 schedule: 时间都是基于
kube-controller-manager .
的时区。
如果你的控制平面在 Pod 或是裸容器中运行了 kube-controller-manager，
那么为该容器所设置的时区将会决定 Cron Job 的控制器所使用的时区。
为 CronJob 资源创建清单时，请确保所提供的名称是一个合法的
DNS 子域名 .
名称不能超过 52 个字符。
这是因为 CronJob 控制器将自动在提供的 Job 名称后附加 11 个字符，并且存在一个限制，
即 Job 名称的最大长度不能超过 63 个字符。
CronJob CronJobs 对于创建周期性的、反复重复的任务很有用，例如执行数据备份或者发送邮件。
CronJobs 也可以用来计划在指定时间来执行的独立任务，例如计划当集群看起来很空闲时
执行某个 Job。
示例 下面的 CronJob 示例清单会在每分钟打印出当前时间和问候消息：
apiVersion : batch/v1beta1
kind : CronJob
metadata :
name : hello
spec :
schedule : "*/1 * * * *"
jobTemplate :
spec :
template :
spec :
containers :
- name : hello
image : busybox
imagePullPolicy : IfNotPresent
command :
- /bin/sh
- -c
- date; echo Hello from the Kubernetes cluster
restartPolicy : OnFailure
使用 CronJob 运行自动化任务
一文会为你详细讲解此例。
Cron 时间表语法 # ┌───────────── 分钟 (0 - 59)
# │ ┌───────────── 小时 (0 - 23)
# │ │ ┌───────────── 月的某天 (1 - 31)
# │ │ │ ┌───────────── 月份 (1 - 12)
# │ │ │ │ ┌───────────── 周的某天 (0 - 6) （周日到周一；在某些系统上，7 也是星期日）
# │ │ │ │ │
# │ │ │ │ │
# │ │ │ │ │
# * * * * *
输入 描述 相当于 @yearly (or @annually) 每年 1 月 1 日的午夜运行一次 0 0 1 1 * @monthly 每月第一天的午夜运行一次 0 0 1 * * @weekly 每周的周日午夜运行一次 0 0 * * 0 @daily (or @midnight) 每天午夜运行一次 0 0 * * * @hourly 每小时的开始一次 0 * * * *
例如，下面这行指出必须在每个星期五的午夜以及每个月 13 号的午夜开始任务：
0 0 13 * 5
要生成 CronJob 时间表表达式，你还可以使用 crontab.guru 之类的 Web 工具。
CronJob 限制 CronJob 根据其计划编排，在每次该执行任务的时候大约会创建一个 Job。
我们之所以说 "大约"，是因为在某些情况下，可能会创建两个 Job，或者不会创建任何 Job。
我们试图使这些情况尽量少发生，但不能完全杜绝。因此，Job 应该是 幂等的 。
如果 startingDeadlineSeconds 设置为很大的数值或未设置（默认），并且
concurrencyPolicy 设置为 Allow，则作业将始终至少运行一次。
注意： 如果 startingDeadlineSeconds 的设置值低于 10 秒钟，CronJob 可能无法被调度。
这是因为 CronJob 控制器每 10 秒钟执行一次检查。
对于每个 CronJob，CronJob 控制器（Controller）
检查从上一次调度的时间点到现在所错过了调度次数。如果错过的调度次数超过 100 次，
那么它就不会启动这个任务，并记录这个错误:
Cannot determine if job needs to be started. Too many missed start time (> 100). Set or decrease .spec.startingDeadlineSeconds or check clock skew.
需要注意的是，如果 startingDeadlineSeconds 字段非空，则控制器会统计从
startingDeadlineSeconds 设置的值到现在而不是从上一个计划时间到现在错过了多少次 Job。
例如，如果 startingDeadlineSeconds 是 200，则控制器会统计在过去 200 秒中错过了多少次 Job。
如果未能在调度时间内创建 CronJob，则计为错过。
例如，如果 concurrencyPolicy 被设置为 Forbid，并且当前有一个调度仍在运行的情况下，
试图调度的 CronJob 将被计算为错过。
例如，假设一个 CronJob 被设置为从 08:30:00 开始每隔一分钟创建一个新的 Job，并且它的 startingDeadlineSeconds 字段
未被设置。如果 CronJob 控制器从 08:29:00 到 10:21:00 终止运行，则该 Job 将不会启动，因为其错过的调度次数超过了100。
为了进一步阐述这个概念，假设将 CronJob 设置为从 08:30:00 开始每隔一分钟创建一个新的 Job，
并将其 startingDeadlineSeconds 字段设置为 200 秒。
如果 CronJob 控制器恰好在与上一个示例相同的时间段（08:29:00 到 10:21:00）终止运行，
则 Job 仍将从 10:22:00 开始。
造成这种情况的原因是控制器现在检查在最近 200 秒（即 3 个错过的调度）中发生了多少次错过的
Job 调度，而不是从现在为止的最后一个调度时间开始。
CronJob 仅负责创建与其调度时间相匹配的 Job，而 Job 又负责管理其代表的 Pod。
新控制器 CronJob 控制器有一个替代的实现，自 Kubernetes 1.20 开始以 alpha 特性引入。
如果选择 CronJob 控制器的 v2 版本，请在 kube-controller-manager
中设置以下特性门控 标志。
--feature-gates="CronJobControllerV2=true"
接下来 2.9 - ReplicationController ReplicationController 确保在任何时候都有特定数量的 Pod 副本处于运行状态。
换句话说，ReplicationController 确保一个 Pod 或一组同类的 Pod 总是可用的。
ReplicationController 如何工作 当 Pod 数量过多时，ReplicationController 会终止多余的 Pod。当 Pod 数量太少时，ReplicationController 将会启动新的 Pod。
与手动创建的 Pod 不同，由 ReplicationController 创建的 Pod 在失败、被删除或被终止时会被自动替换。
例如，在中断性维护（如内核升级）之后，你的 Pod 会在节点上重新创建。
因此，即使你的应用程序只需要一个 Pod，你也应该使用 ReplicationController 创建 Pod。
ReplicationController 类似于进程管理器，但是 ReplicationController 不是监控单个节点上的单个进程，而是监控跨多个节点的多个 Pod。
在讨论中，ReplicationController 通常缩写为 "rc"，并作为 kubectl 命令的快捷方式。
一个简单的示例是创建一个 ReplicationController 对象来可靠地无限期地运行 Pod 的一个实例。
更复杂的用例是运行一个多副本服务（如 web 服务器）的若干相同副本。
运行一个示例 ReplicationController 这个示例 ReplicationController 配置运行 nginx Web 服务器的三个副本。
apiVersion : v1
kind : ReplicationController
metadata :
name : nginx
spec :
replicas : 3
selector :
app : nginx
template :
metadata :
name : nginx
labels :
app : nginx
spec :
containers :
- name : nginx
image : nginx
ports :
- containerPort : 80
通过下载示例文件并运行以下命令来运行示例任务:
kubectl apply -f https://k8s.io/examples/controllers/replication.yaml
输出类似于：
replicationcontroller/nginx created
使用以下命令检查 ReplicationController 的状态:
kubectl describe replicationcontrollers/nginx
输出类似于：
Name: nginx
Namespace: default
Selector: app=nginx
Labels: app=nginx
Annotations: <none>
Replicas: 3 current / 3 desired
Pods Status: 0 Running / 3 Waiting / 0 Succeeded / 0 Failed
Pod Template:
Labels: app=nginx
Containers:
nginx:
Image: nginx
Port: 80/TCP
Environment: <none>
Mounts: <none>
Volumes: <none>
Events:
FirstSeen LastSeen Count From SubobjectPath Type Reason Message
--------- -------- ----- ---- ------------- ---- ------ -------
20s 20s 1 {replication-controller } Normal SuccessfulCreate Created pod: nginx-qrm3m
20s 20s 1 {replication-controller } Normal SuccessfulCreate Created pod: nginx-3ntk0
20s 20s 1 {replication-controller } Normal SuccessfulCreate Created pod: nginx-4ok8v
在这里，创建了三个 Pod，但没有一个 Pod 正在运行，这可能是因为正在拉取镜像。
稍后，相同的命令可能会显示：
Pods Status: 3 Running / 0 Waiting / 0 Succeeded / 0 Failed
要以机器可读的形式列出属于 ReplicationController 的所有 Pod，可以使用如下命令：
pods = $( kubectl get pods --selector= app = nginx --output= jsonpath ={ .items..metadata.name} )
echo $pods
输出类似于：
nginx-3ntk0 nginx-4ok8v nginx-qrm3m
这里，选择算符与 ReplicationController 的选择算符相同（参见 kubectl describe 输出），并以不同的形式出现在 replication.yaml 中。
--output=jsonpath 选项指定了一个表达式，仅从返回列表中的每个 Pod 中获取名称。
编写一个 ReplicationController Spec 与所有其它 Kubernetes 配置一样，ReplicationController 需要 apiVersion、kind 和 metadata 字段。
有关使用配置文件的常规信息，参考对象管理 。
ReplicationController 也需要一个 .spec 部分
Pod 模板 .spec.template 是 .spec 的唯一必需字段。
.spec.template 是一个 Pod 模板 。
它的模式与 Pod 完全相同，只是它是嵌套的，没有 apiVersion 或 kind 属性。
除了 Pod 所需的字段外，ReplicationController 中的 Pod 模板必须指定适当的标签和适当的重新启动策略。
对于标签，请确保不与其他控制器重叠。参考 Pod 选择算符 。
只允许 .spec.template.spec.restartPolicyAlways，如果没有指定，这是默认值。
对于本地容器重启，ReplicationController 委托给节点上的代理，
例如 Kubelet 或 Docker。
ReplicationController 上的标签 ReplicationController 本身可以有标签 （.metadata.labels）。
通常，你可以将这些设置为 .spec.template.metadata.labels；
如果没有指定 .metadata.labels 那么它默认为 .spec.template.metadata.labels。.metadata.labels 不会影响 ReplicationController 的行为。
Pod 选择算符 .spec.selector 字段是一个标签选择算符 。
ReplicationController 管理标签与选择算符匹配的所有 Pod。
它不区分它创建或删除的 Pod 和其他人或进程创建或删除的 Pod。
这允许在不影响正在运行的 Pod 的情况下替换 ReplicationController。
如果指定了 .spec.template.metadata.labels，它必须和 .spec.selector 相同，否则它将被 API 拒绝。
如果没有指定 .spec.selector，它将默认为 .spec.template.metadata.labels。
另外，通常不应直接使用另一个 ReplicationController 或另一个控制器（例如 Job）
来创建其标签与该选择算符匹配的任何 Pod。如果这样做，ReplicationController 会认为它创建了这些 Pod。
Kubernetes 并没有阻止你这样做。
如果你的确创建了多个控制器并且其选择算符之间存在重叠，那么你将不得不自己管理删除操作（参考后文 ）。
多个副本 你可以通过设置 .spec.replicas 来指定应该同时运行多少个 Pod。
在任何时候，处于运行状态的 Pod 个数都可能高于或者低于设定值。例如，副本个数刚刚被增加或减少时，或者一个 Pod 处于优雅终止过程中而其替代副本已经提前开始创建时。
如果你没有指定 .spec.replicas ，那么它默认是 1。
使用 ReplicationController 删除一个 ReplicationController 以及它的 Pod 要删除一个 ReplicationController 以及它的 Pod，使用
kubectl delete
当使用 REST API 或 Go 客户端库时，你需要明确地执行这些步骤（缩放副本为 0、
等待 Pod 删除，之后删除 ReplicationController 资源）。
只删除 ReplicationController 你可以删除一个 ReplicationController 而不影响它的任何 Pod。
使用 kubectl，为 kubectl delete--cascade=false 选项。
当使用 REST API 或 Go 客户端库时，只需删除 ReplicationController 对象。
一旦原始对象被删除，你可以创建一个新的 ReplicationController 来替换它。
只要新的和旧的 .spec.selector 相同，那么新的控制器将领养旧的 Pod。
但是，它不会做出任何努力使现有的 Pod 匹配新的、不同的 Pod 模板。
如果希望以受控方式更新 Pod 以使用新的 spec，请执行滚动更新 操作。
从 ReplicationController 中隔离 Pod 通过更改 Pod 的标签，可以从 ReplicationController 的目标中删除 Pod。
此技术可用于从服务中删除 Pod 以进行调试、数据恢复等。以这种方式删除的 Pod 将自动替换（假设复制副本的数量也没有更改）。
常见的使用模式 重新调度 如上所述，无论你想要继续运行 1 个 Pod 还是 1000 个 Pod，一个 ReplicationController 都将确保存在指定数量的 Pod，即使在节点故障或 Pod 终止(例如，由于另一个控制代理的操作)的情况下也是如此。
扩缩容 通过设置 replicas 字段，ReplicationController 可以方便地横向扩容或缩容副本的数量。
你可以手动或通过自动缩放控制代理来控制 ReplicationController 执行此操作。
滚动更新 ReplicationController 的设计目的是通过逐个替换 Pod 以方便滚动更新服务。
如 #1353 PR 中所述，建议的方法是使用 1 个副本创建一个新的 ReplicationController，
逐个扩容新的（+1）和缩容旧的（-1）控制器，然后在旧的控制器达到 0 个副本后将其删除。
这一方法能够实现可控的 Pod 集合更新，即使存在意外失效的状况。
理想情况下，滚动更新控制器将考虑应用程序的就绪情况，并确保在任何给定时间都有足够数量的 Pod 有效地提供服务。
这两个 ReplicationController 将需要创建至少具有一个不同标签的 Pod，比如 Pod 主要容器的镜像标签，因为通常是镜像更新触发滚动更新。
滚动更新是在客户端工具 kubectl rolling-updatekubectl rolling-update 任务
多个版本跟踪 除了在滚动更新过程中运行应用程序的多个版本之外，通常还会使用多个版本跟踪来长时间，甚至持续运行多个版本。这些跟踪将根据标签加以区分。
例如，一个服务可能把具有 tier in (frontend), environment in (prod) 的所有 Pod 作为目标。
现在假设你有 10 个副本的 Pod 组成了这个层。但是你希望能够 canary （金丝雀）发布这个组件的新版本。
你可以为大部分副本设置一个 ReplicationController，其中 replicas 设置为 9，
标签为 tier=frontend, environment=prod, track=stable 而为 canary
设置另一个 ReplicationController，其中 replicas 设置为 1，
标签为 tier=frontend, environment=prod, track=canary。
现在这个服务覆盖了 canary 和非 canary Pod。但你可以单独处理 ReplicationController，以测试、监控结果等。
和服务一起使用 ReplicationController 多个 ReplicationController 可以位于一个服务的后面，例如，一部分流量流向旧版本，一部分流量流向新版本。
一个 ReplicationController 永远不会自行终止，但它不会像服务那样长时间存活。
服务可以由多个 ReplicationController 控制的 Pod 组成，并且在服务的生命周期内
（例如，为了执行 Pod 更新而运行服务），可以创建和销毁许多 ReplicationController。
服务本身和它们的客户端都应该忽略负责维护服务 Pod 的 ReplicationController 的存在。
编写多副本的应用 由 ReplicationController 创建的 Pod 是可替换的，语义上是相同的，尽管随着时间的推移，它们的配置可能会变得异构。
这显然适合于多副本的无状态服务器，但是 ReplicationController 也可以用于维护主选、分片和工作池应用程序的可用性。
这样的应用程序应该使用动态的工作分配机制，例如
RabbitMQ 工作队列 ，
而不是静态的或者一次性定制每个 Pod 的配置，这被认为是一种反模式。
执行的任何 Pod 定制，例如资源的垂直自动调整大小（例如，CPU 或内存），
都应该由另一个在线控制器进程执行，这与 ReplicationController 本身没什么不同。
ReplicationController 的职责 ReplicationController 仅确保所需的 Pod 数量与其标签选择算符匹配，并且是可操作的。
目前，它的计数中只排除终止的 Pod。
未来，可能会考虑系统提供的就绪状态 和其他信息，
我们可能会对替换策略添加更多控制，
我们计划发出事件，这些事件可以被外部客户端用来实现任意复杂的替换和/或缩减策略。
ReplicationController 永远被限制在这个狭隘的职责范围内。
它本身既不执行就绪态探测，也不执行活跃性探测。
它不负责执行自动缩放，而是由外部自动缩放器控制（如 #492 中所述），后者负责更改其 replicas 字段值。
我们不会向 ReplicationController 添加调度策略(例如，spreading )。
它也不应该验证所控制的 Pod 是否与当前指定的模板匹配，因为这会阻碍自动调整大小和其他自动化过程。
类似地，完成期限、整理依赖关系、配置扩展和其他特性也属于其他地方。
我们甚至计划考虑批量创建 Pod 的机制（查阅 #170 ）。
ReplicationController 旨在成为可组合的构建基元。
我们希望在它和其他补充原语的基础上构建更高级别的 API 或者工具，以便于将来的用户使用。
kubectl 目前支持的 "macro" 操作（运行、缩放、滚动更新）就是这方面的概念示例。
例如，我们可以想象类似于 Asgard
的东西管理 ReplicationController、自动定标器、服务、调度策略、金丝雀发布等。
API 对象 在 Kubernetes REST API 中 Replication controller 是顶级资源。
更多关于 API 对象的详细信息可以在
ReplicationController API 对象 找到。
ReplicationController 的替代方案 ReplicaSet ReplicaSet基于集合的标签选择算符 。
它主要被 Deployment
Deployment （推荐） Deploymentkubectl rolling-update 的方式更新其底层 ReplicaSet 及其 Pod。
如果你想要这种滚动更新功能，那么推荐使用 Deployment，因为与 kubectl rolling-update 不同，
它们是声明式的、服务端的，并且具有其它特性。
裸 Pod 与用户直接创建 Pod 的情况不同，ReplicationController 能够替换因某些原因被删除或被终止的 Pod ，例如在节点故障或中断节点维护的情况下，例如内核升级。
因此，我们建议你使用 ReplicationController，即使你的应用程序只需要一个 Pod。
可以将其看作类似于进程管理器，它只管理跨多个节点的多个 Pod ，而不是单个节点上的单个进程。
ReplicationController 将本地容器重启委托给节点上的某个代理(例如，Kubelet 或 Docker)。
Job 对于预期会自行终止的 Pod (即批处理任务)，使用
Job
DaemonSet 对于提供机器级功能（例如机器监控或机器日志记录）的 Pod，
使用 DaemonSet
更多信息 请阅读运行无状态的 ReplicationController 。
