k8s资源限制——资源的配额管理(Resource Quotas)

布满荆棘的人生 2022-12-04 01:17 610阅读 0赞

## 简介 ##

在k8s集群中为了能够使系统正常稳定运行，通常会限制Pod的资源使用情况，在k8s集群中如果有一个程序出现异常，并占用大量的系统资源。如果未对该Pod进行资源限制的话，可能会影响其他的Pod。

k8s常见的资源管理方式：计算资源管理(Compute Resources)、资源的配置范围管理(LimitRange)和资源的配额管理(Resource Quotas)

计算资源管理(Compute Resources): 为Pod中的容器指定使用的计算资源(CPU和内存)。

资源的配置范围管理(LimitRange)：可以对集群内Request和Limits的配置做一个全局的统一的限制，相当于批量设置了某一个范围内(某个命名空间)的Pod的资源使用限制。

资源的配额管理(Resource Quotas)：可以为每一个命名空间(namespace)提供一个总体的资源使用限制，通过它可以限制命名空间中某个类型的对象的总数目上限，也可以设置命名空间中Pod可以使用到的计算资源的总上限。资源的配额管理有效解决了多用户或多个团队公用一个k8s集群时资源有效分配的问题。

本篇主要总结 **资源的配额管理(Resource Quotas)**的使用

资源配额，通过 `ResourceQuota` 对象来定义，对每个命名空间的资源消耗总量提供限制。 它可以限制命名空间中某种类型的对象的总数目上限，也可以限制命令空间中的 Pod 可以使用的计算资源的总上限。

资源配额的工作方式如下：

*  不同的团队可以在不同的命名空间下工作，目前这是非约束性的，在未来的版本中可能会通过 ACL (Access Control List 访问控制列表) 来实现强制性约束。
 *  集群管理员可以为每个命名空间创建一个或多个资源配额对象。
 *  当用户在命名空间下创建资源（如 Pod、Service 等）时，Kubernetes 的配额系统会 跟踪集群的资源使用情况，以确保使用的资源用量不超过资源配额中定义的硬性资源限额。
 *  如果资源创建或者更新请求违反了配额约束，那么该请求会报错（HTTP 403 FORBIDDEN）， 并在消息中给出有可能违反的约束。
 *  如果命名空间下的计算资源 （如 `cpu` 和 `memory`）的配额被启用，则用户必须为 这些资源设定请求值（request）和约束值（limit），否则配额系统将拒绝 Pod 的创建。 提示: 可使用 `LimitRanger` 准入控制器来为没有设置计算资源需求的 Pod 设置默认值。

ResourceQuota 对象的名称必须时合法的 [DNS 子域名][DNS]。

下面是使用命名空间和配额构建策略的示例：

*  在具有 32 GiB 内存和 16 核 CPU 资源的集群中，允许 A 团队使用 20 GiB 内存 和 10 核的 CPU 资源， 允许 B 团队使用 10 GiB 内存和 4 核的 CPU 资源，并且预留 2 GiB 内存和 2 核的 CPU 资源供将来分配。
 *  限制 "testing" 命名空间使用 1 核 CPU 资源和 1GiB 内存。允许 "production" 命名空间使用任意数量。

在集群容量小于各命名空间配额总和的情况下，可能存在资源竞争。资源竞争时，Kubernetes 系统会遵循先到先得的原则。

不管是资源竞争还是配额的修改，都不会影响已经创建的资源使用对象。

## 启用资源配额 ##

资源配额的支持在很多 Kubernetes 版本中是默认开启的。当 apiserver `--enable-admission-plugins=` 参数中包含 `ResourceQuota` 时，资源配额会被启用。

当命名空间中存在一个 `ResourceQuota` 对象时，对于该命名空间而言，资源配额就是开启的。

## 计算资源配额 ##

用户可以对给定命名空间下的可被请求的 [计算资源][Link 1] 总量进行限制。

配额机制所支持的资源类型：

<table> 
 <thead> 
  <tr> 
   <th>资源名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>limits.cpu</code></td> 
   <td>所有非终止状态的 Pod，其 CPU 限额总量不能超过该值。</td> 
  </tr> 
  <tr> 
   <td><code>limits.memory</code></td> 
   <td>所有非终止状态的 Pod，其内存限额总量不能超过该值。</td> 
  </tr> 
  <tr> 
   <td><code>requests.cpu</code></td> 
   <td>所有非终止状态的 Pod，其 CPU 需求总量不能超过该值。</td> 
  </tr> 
  <tr> 
   <td><code>requests.memory</code></td> 
   <td>所有非终止状态的 Pod，其内存需求总量不能超过该值。</td> 
  </tr> 
 </tbody> 
</table>

### 扩展资源的资源配额[ ][Link 2] ###

除上述资源外，在 Kubernetes 1.10 版本中，还添加了对 [扩展资源][Link 3] 的支持。

由于扩展资源不可超量分配，因此没有必要在配额中为同一扩展资源同时指定 `requests` 和 `limits`。 对于扩展资源而言，目前仅允许使用前缀为 `requests.` 的配额项。

以 GPU 拓展资源为例，如果资源名称为 `nvidia.com/gpu`，并且要将命名空间中请求的 GPU 资源总数限制为 4，则可以如下定义配额：

*  `requests.nvidia.com/gpu: 4`

有关更多详细信息，请参阅[查看和设置配额][Link 4]。

## 存储资源配额 ##

用户可以对给定命名空间下的[存储资源][Link 5]总量进行限制。

此外，还可以根据相关的存储类（Storage Class）来限制存储资源的消耗。

<table> 
 <thead> 
  <tr> 
   <th>资源名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>requests.storage</code></td> 
   <td>所有 PVC，存储资源的需求总量不能超过该值。</td> 
  </tr> 
  <tr> 
   <td><code>persistentvolumeclaims</code></td> 
   <td>在该命名空间中所允许的 <a href="https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims" rel="nofollow">PVC</a> 总量。</td> 
  </tr> 
  <tr> 
   <td><code>&lt;storage-class-name&gt;.storageclass.storage.k8s.io/requests.storage</code></td> 
   <td>在所有与 storage-class-name 相关的持久卷声明中，存储请求的总和不能超过该值。</td> 
  </tr> 
  <tr> 
   <td><code>&lt;storage-class-name&gt;.storageclass.storage.k8s.io/persistentvolumeclaims</code></td> 
   <td>在与 storage-class-name 相关的所有持久卷声明中，命名空间中可以存在的<a href="https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims" rel="nofollow">持久卷申领</a>总数。</td> 
  </tr> 
 </tbody> 
</table>

例如，如果一个操作人员针对 `gold` 存储类型与 `bronze` 存储类型设置配额，操作人员可以定义如下配额：

*  `gold.storageclass.storage.k8s.io/requests.storage: 500Gi`
 *  `bronze.storageclass.storage.k8s.io/requests.storage: 100Gi`

在 Kubernetes 1.8 版本中，本地临时存储的配额支持已经是 Alpha 功能：

<table> 
 <thead> 
  <tr> 
   <th>资源名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>requests.ephemeral-storage</code></td> 
   <td>在命名空间的所有 Pod 中，本地临时存储请求的总和不能超过此值。</td> 
  </tr> 
  <tr> 
   <td><code>limits.ephemeral-storage</code></td> 
   <td>在命名空间的所有 Pod 中，本地临时存储限制值的总和不能超过此值。</td> 
  </tr> 
 </tbody> 
</table>

## 对象数量配额 ##

Kubernetes 1.9 版本增加了使用以下语法对所有标准的、命名空间域的资源类型进行配额设置的支持。

*  `count/<resource>.<group>`

这是用户可能希望利用对象计数配额来管理的一组资源示例。

*  `count/persistentvolumeclaims`
 *  `count/services`
 *  `count/secrets`
 *  `count/configmaps`
 *  `count/replicationcontrollers`
 *  `count/deployments.apps`
 *  `count/replicasets.apps`
 *  `count/statefulsets.apps`
 *  `count/jobs.batch`
 *  `count/cronjobs.batch`
 *  `count/deployments.extensions`

Kubernetes 1.15 版本增加了对使用相同语法来约束自定义资源的支持。 例如，要对 `example.com` API 组中的自定义资源 `widgets` 设置配额，请使用 `count/widgets.example.com`。

当使用 `count/*` 资源配额时，如果对象存在于服务器存储中，则会根据配额管理资源。 这些类型的配额有助于防止存储资源耗尽。例如，用户可能想根据服务器的存储能力来对服务器中 Secret 的数量进行配额限制。集群中存在过多的 Secret 实际上会导致服务器和控制器无法启动！用户可以选择对 Job 进行配额管理，以防止配置不当的 CronJob 在某命名空间中创建太多作业而导致集群拒绝服务。

在 Kubernetes 1.9 版本之前，可以在有限的一组资源上实施一般性的对象数量配额。 此外，还可以进一步按资源的类型设置其配额。

支持以下类型：

<table> 
 <thead> 
  <tr> 
   <th>资源名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>configmaps</code></td> 
   <td>在该命名空间中允许存在的 ConfigMap 总数上限。</td> 
  </tr> 
  <tr> 
   <td><code>persistentvolumeclaims</code></td> 
   <td>在该命名空间中允许存在的 <a href="https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims" rel="nofollow">PVC</a> 的总数上限。</td> 
  </tr> 
  <tr> 
   <td><code>pods</code></td> 
   <td>在该命名空间中允许存在的非终止状态的 pod 总数上限。Pod 终止状态等价于 Pod 的 <code>.status.phase in (Failed, Succeeded)</code> = true</td> 
  </tr> 
  <tr> 
   <td><code>replicationcontrollers</code></td> 
   <td>在该命名空间中允许存在的 RC 总数上限。</td> 
  </tr> 
  <tr> 
   <td><code>resourcequotas</code></td> 
   <td>在该命名空间中允许存在的资源配额总数上限。</td> 
  </tr> 
  <tr> 
   <td><code>services</code></td> 
   <td>在该命名空间中允许存在的 Service 总数上限。</td> 
  </tr> 
  <tr> 
   <td><code>services.loadbalancers</code></td> 
   <td>在该命名空间中允许存在的 LoadBalancer 类型的服务总数上限。</td> 
  </tr> 
  <tr> 
   <td><code>services.nodeports</code></td> 
   <td>在该命名空间中允许存在的 NodePort 类型的服务总数上限。</td> 
  </tr> 
  <tr> 
   <td><code>secrets</code></td> 
   <td>在该命名空间中允许存在的 Secret 总数上限。</td> 
  </tr> 
 </tbody> 
</table>

例如，`pods` 配额统计某个命名空间中所创建的、非终止状态的 `Pod` 个数并确保其不超过某上限值。 用户可能希望在某命名空间中设置 `pods` 配额，以避免有用户创建很多小的 Pod，从而耗尽集群所能提供的 Pod IP 地址。

## 配额作用域 ##

每个配额都有一组相关的作用域（scope），配额只会对作用域内的资源生效。 配额机制仅统计所列举的作用域的交集中的资源用量。

当一个作用域被添加到配额中后，它会对作用域相关的资源数量作限制。 如配额中指定了允许（作用域）集合之外的资源，会导致验证错误。

<table> 
 <thead> 
  <tr> 
   <th>作用域</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Terminating</code></td> 
   <td>匹配所有 <code>spec.activeDeadlineSeconds</code> 不小于 0 的 Pod。</td> 
  </tr> 
  <tr> 
   <td><code>NotTerminating</code></td> 
   <td>匹配所有 <code>spec.activeDeadlineSeconds</code> 是 nil 的 Pod。</td> 
  </tr> 
  <tr> 
   <td><code>BestEffort</code></td> 
   <td>匹配所有 Qos 是 BestEffort 的 Pod。</td> 
  </tr> 
  <tr> 
   <td><code>NotBestEffort</code></td> 
   <td>匹配所有 Qos 不是 BestEffort 的 Pod。</td> 
  </tr> 
 </tbody> 
</table>

BestEffort` 作用域限制配额跟踪以下资源：`pods

`Terminating`、`NotTerminating` 和 `NotBestEffort` 这三种作用域限制配额跟踪以下资源：

*  `cpu`
 *  `limits.cpu`
 *  `limits.memory`
 *  `memory`
 *  `pods`
 *  `requests.cpu`
 *  `requests.memory`

### 基于优先级类（PriorityClass）来设置资源配额 ###

**FEATURE STATE:** `Kubernetes 1.12 [beta]`

Pod 可以创建为特定的[优先级][Link 6]。 通过使用配额规约中的 `scopeSelector` 字段，用户可以根据 Pod 的优先级控制其系统资源消耗。

仅当配额规范中的 `scopeSelector` 字段选择到某 Pod 时，配额机制才会匹配和计量 Pod 的资源消耗。

本示例创建一个配额对象，并将其与具有特定优先级的 Pod 进行匹配。 该示例的工作方式如下：

*  集群中的 Pod 可取三个优先级类之一，即 "low"、"medium"、"high"。
 *  为每个优先级创建一个配额对象。

将以下 YAML 保存到文件 `quota.yml` 中。

apiVersion: v1
    kind: List
    items:
    - apiVersion: v1
      kind: ResourceQuota
      metadata:
        name: pods-high
      spec:
        hard:
          cpu: "1000"
          memory: 200Gi
          pods: "10"
        scopeSelector:
          matchExpressions:
          - operator : In
            scopeName: PriorityClass
            values: ["high"]
    - apiVersion: v1
      kind: ResourceQuota
      metadata:
        name: pods-medium
      spec:
        hard:
          cpu: "10"
          memory: 20Gi
          pods: "10"
        scopeSelector:
          matchExpressions:
          - operator : In
            scopeName: PriorityClass
            values: ["medium"]
    - apiVersion: v1
      kind: ResourceQuota
      metadata:
        name: pods-low
      spec:
        hard:
          cpu: "5"
          memory: 10Gi
          pods: "10"
        scopeSelector:
          matchExpressions:
          - operator : In
            scopeName: PriorityClass
            values: ["low"]

使用 `kubectl create` 命令运行以下操作。

kubectl create -f ./quota.yml
    resourcequota/pods-high created
    resourcequota/pods-medium created
    resourcequota/pods-low created

使用 `kubectl describe quota` 操作验证配额的 `Used` 值为 `0`。

kubectl describe quota
    Name:       pods-high
    Namespace:  default
    Resource    Used  Hard
    --------    ----  ----
    cpu         0     1k
    memory      0     200Gi
    pods        0     10
    
    
    Name:       pods-low
    Namespace:  default
    Resource    Used  Hard
    --------    ----  ----
    cpu         0     5
    memory      0     10Gi
    pods        0     10
    
    
    Name:       pods-medium
    Namespace:  default
    Resource    Used  Hard
    --------    ----  ----
    cpu         0     10
    memory      0     20Gi
    pods        0     10

创建优先级为 "high" 的 Pod。 将以下 YAML 保存到文件 `high-priority-pod.yml` 中。

apiVersion: v1
    kind: Pod
    metadata:
      name: high-priority
    spec:
      containers:
      - name: high-priority
        image: ubuntu
        command: ["/bin/sh"]
        args: ["-c", "while true; do echo hello; sleep 10;done"]
        resources:
          requests:
            memory: "10Gi"
            cpu: "500m"
          limits:
            memory: "10Gi"
            cpu: "500m"
      priorityClassName: high

使用 `kubectl create` 运行以下操作。

kubectl create -f ./high-priority-pod.yml

确认 "high" 优先级配额 `pods-high` 的 "Used" 统计信息已更改，并且其他两个配额未更改。

kubectl describe quota
    Name:       pods-high
    Namespace:  default
    Resource    Used  Hard
    --------    ----  ----
    cpu         500m  1k
    memory      10Gi  200Gi
    pods        1     10
    
    
    Name:       pods-low
    Namespace:  default
    Resource    Used  Hard
    --------    ----  ----
    cpu         0     5
    memory      0     10Gi
    pods        0     10
    
    
    Name:       pods-medium
    Namespace:  default
    Resource    Used  Hard
    --------    ----  ----
    cpu         0     10
    memory      0     20Gi
    pods        0     10

`scopeSelector` 在 `operator` 字段中支持以下值：

*  `In`
 *  `NotIn`
 *  `Exist`
 *  `DoesNotExist`

## 请求与限制 ##

分配计算资源时，每个容器可以为 CPU 或内存指定请求和约束。 配额可以针对二者之一进行设置。

如果配额中指定了 `requests.cpu` 或 `requests.memory` 的值，则它要求每个容器都显式给出对这些资源的请求。 同理，如果配额中指定了 `limits.cpu` 或 `limits.memory` 的值，那么它要求每个容器都显式设定对应资源的限制。

## 查看和设置配额 ##

Kubectl 支持创建、更新和查看配额：

kubectl create namespace myspace
    cat <<EOF > compute-resources.yaml
    apiVersion: v1
    kind: ResourceQuota
    metadata:
      name: compute-resources
    spec:
      hard:
        requests.cpu: "1"
        requests.memory: 1Gi
        limits.cpu: "2"
        limits.memory: 2Gi
        requests.nvidia.com/gpu: 4
    EOF
    kubectl create -f ./compute-resources.yaml --namespace=myspace
    cat <<EOF > object-counts.yaml
    apiVersion: v1
    kind: ResourceQuota
    metadata:
      name: object-counts
    spec:
      hard:
        configmaps: "10"
        persistentvolumeclaims: "4"
        pods: "4"
        replicationcontrollers: "20"
        secrets: "10"
        services: "10"
        services.loadbalancers: "2"
    EOF
    kubectl create -f ./object-counts.yaml --namespace=myspace
    kubectl get quota --namespace=myspace
    NAME                    AGE
    compute-resources       30s
    object-counts           32s
    kubectl describe quota compute-resources --namespace=myspace
    Name:                    compute-resources
    Namespace:               myspace
    Resource                 Used  Hard
    --------                 ----  ----
    limits.cpu               0     2
    limits.memory            0     2Gi
    requests.cpu             0     1
    requests.memory          0     1Gi
    requests.nvidia.com/gpu  0     4
    kubectl describe quota object-counts --namespace=myspace
    Name:                   object-counts
    Namespace:              myspace
    Resource                Used    Hard
    --------                ----    ----
    configmaps              0       10
    persistentvolumeclaims  0       4
    pods                    0       4
    replicationcontrollers  0       20
    secrets                 1       10
    services                0       10
    services.loadbalancers  0       2

kubectl 还使用语法 `count/<resource>.<group>` 支持所有标准的、命名空间域的资源的对象计数配额：

kubectl create namespace myspace
    kubectl create quota test --hard=count/deployments.extensions=2,count/replicasets.extensions=4,count/pods=3,count/secrets=4 --namespace=myspace
    kubectl create deployment nginx --image=nginx --namespace=myspace
    kubectl describe quota --namespace=myspace
    Name:                         test
    Namespace:                    myspace
    Resource                      Used  Hard
    --------                      ----  ----
    count/deployments.extensions  1     2
    count/pods                    2     3
    count/replicasets.extensions  1     4
    count/secrets                 1     4

## 配额和集群容量 ##

资源配额与集群资源总量是完全独立的。它们通过绝对的单位来配置。 所以，为集群添加节点时，资源配额*不会*自动赋予每个命名空间消耗更多资源的能力。

有时可能需要资源配额支持更复杂的策略，比如：

*  在几个团队中按比例划分总的集群资源。
 *  允许每个租户根据需要增加资源使用量，但要有足够的限制以防止资源意外耗尽。
 *  探测某个命名空间的需求，添加物理节点并扩大资源配额值。

这些策略可以通过将资源配额作为一个组成模块、手动编写一个控制器来监控资源使用情况， 并结合其他信号调整命名空间上的硬性资源配额来实现。

注意：资源配额对集群资源总体进行划分，但它对节点没有限制：来自不同命名空间的 Pod 可能在同一节点上运行。

## 默认情况下限制特定优先级的资源消耗 ##

有时候可能希望当且仅当某名字空间中存在匹配的配额对象时，才可以创建特定优先级 （例如 "cluster-services"）的 Pod。

通过这种机制，操作人员能够将限制某些高优先级类仅出现在有限数量的命名空间中， 而并非每个命名空间默认情况下都能够使用这些优先级类。

要实现此目的，应使用 kube-apiserver 标志 `--admission-control-config-file` 传递如下配置文件的路径：

*  [apiserver.config.k8s.io/v1][apiserver.config.k8s.io_v1]
 *  [apiserver.k8s.io/v1alpha1][apiserver.k8s.io_v1alpha1]

apiVersion: apiserver.config.k8s.io/v1
    kind: AdmissionConfiguration
    plugins:
    - name: "ResourceQuota"
      configuration:
        apiVersion: apiserver.config.k8s.io/v1
        kind: ResourceQuotaConfiguration
        limitedResources:
        - resource: pods
          matchScopes:
          - scopeName: PriorityClass
            operator: In
            values: ["cluster-services"]

现在，仅当命名空间中存在匹配的 `scopeSelector` 的配额对象时，才允许使用 "cluster-services" Pod。

示例：

scopeSelector:
          matchExpressions:
          - scopeName: PriorityClass
            operator: In
            values: ["cluster-services"]

以上内容主要摘自k8s官方文档：[https://kubernetes.io/zh/docs/concepts/policy/resource-quotas/][https_kubernetes.io_zh_docs_concepts_policy_resource-quotas]

[DNS]: https://kubernetes.io/zh/docs/concepts/overview/working-with-objects/names#dns-subdomain-names
[Link 1]: https://kubernetes.io/zh/docs/concepts/configuration/manage-resources-containers/
[Link 2]: https://kubernetes.io/zh/docs/concepts/policy/resource-quotas/#%E6%89%A9%E5%B1%95%E8%B5%84%E6%BA%90%E7%9A%84%E8%B5%84%E6%BA%90%E9%85%8D%E9%A2%9D
[Link 3]: https://kubernetes.io/zh/docs/concepts/configuration/manage-resources-containers/#extended-resources
[Link 4]: https://kubernetes.io/zh/docs/concepts/policy/resource-quotas/#viewing-and-setting-quotas
[Link 5]: https://kubernetes.io/docs/concepts/storage/persistent-volumes/
[Link 6]: https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/#pod-priority
[apiserver.config.k8s.io_v1]: https://kubernetes.io/zh/docs/concepts/policy/resource-quotas/#example1-0
[apiserver.k8s.io_v1alpha1]: https://kubernetes.io/zh/docs/concepts/policy/resource-quotas/#example1-1
[https_kubernetes.io_zh_docs_concepts_policy_resource-quotas]: https://kubernetes.io/zh/docs/concepts/policy/resource-quotas/