k8s中资源配额 ResourceQuota

文章转载自：https://www.kuboard.cn/learning/k8s-advanced/policy/lr.html

当多个用户（团队）共享一个节点数量有限的集群时，如何在多个用户（团队）之间分配集群的资源就会变得非常重要。Resource quota 的用途便在于此。

资源配额

资源配额（Resource quota）通过 ResourceQuota 对象定义，可以限定单个名称空间中可使用的计算资源的总量。限定的方式有：

按对象类型限定名称空间中可创建的对象的总数
按对象类型限定名称空间中可消耗的计算资源

资源配额（Resource quota）的工作方式描述如下：

不同的用户（团队）使用不同的名称空间。如果通过 ACL（权限控制），可以强制用户只能访问特定的名称空间
集群管理员为每个名称空间创建一个 ResourceQuota 对象
用户在名称空间中创建对象（Pod、Service等），ResourceQuota 系统跟踪对象的资源使用情况，并确保不会超过 ResourceQuota 对象中定义的配额
如果创建或更新对象时与 ResourceQuota 冲突，则 apiserver 会返回 HTTP 状态码 403，以及对应的错误提示信息
如果在名称空间中为计算资源 CPU 和内存激活 ResourceQuota，用户在创建对象（Pod、Service等）时，必须指定 requests 和 limits。

使用 LimitRange 可以为没有定义 requests、limits 的对象强制添加默认值

下面是一些使用 ResourceQuota 的场景描述：

在一个总容量为 32GiB 内存、16核CPU 的集群里，允许 teamA 使用 20GiB内存、10核CPU，允许 teamB 使用 10GiB 内存、4核CPU，保留 2GiB 内存和 2核CPU 待将来分配
限定 “Testing” 名称空间使用 1核CPU、1GiB内存，允许 “Production” 名称空间使用任意数量的计算资源

当集群中总的容量小于名称空间资源配额的总和时，可能会发生资源争夺。此时 Kubernetes 集群将按照先到先得的方式分配资源。

无论是资源争夺还是修改名称空间的资源配额（ResourceQuota），都不会影响到已经创建的对象。

启用ResourceQuota

Kubernetes集群中默认启用 ResourceQuota。如果没有，可在启动 apiserver 时为参数 --enable-admission-plugins 添加 ResourceQuota 配置项。

在名称空间中定义一个 ResourceQuota 对象，就可以激活该名称空间的资源配额检查。

资源类型

当多个用户（团队）共享一个节点数量有限的集群时，如何在多个用户（团队）之间分配集群的资源就会变得非常重要。Resource quota 的用途便在于此。本文主要探索通过 ResourceQuota 限定名称空间的计算资源配额、存储资源配额、对象数量配额。

计算资源配额

通过 ResourceQuota 可以限定名称空间中可以使用的计算资源的总量。支持的计算资源定义类型如下：

资源名称	描述
limits.cpu	名称空间中，所有非终止状态（non-terminal）的 Pod 的 CPU限制 resources.limits.cpu 之和不能超过此值
limits.memory	名称空间中，所有非终止状态（non-terminal）的 Pod 的内存限制 resources.limits.memory 之和不能超过此值
requests.cpu	名称空间中，所有非终止状态（non-terminal）的 Pod 的 CPU请求 resources.requrest.cpu 之和不能超过此值
requests.memory	名称空间中，所有非终止状态（non-terminal）的 Pod 的 CPU请求 resources.requests.memory 之和不能超过此值

存储资源配额

通过 ResourceQuota 可以：

限定名称空间中可以使用的存储资源的总量
限定名称空间中可以使用的某个存储类存储资源的总量

资源名称	描述
requests.storage	名称空间中，所有存储卷声明（PersistentVolumeClaim）请求的存储总量不能超过此值
persistentvolumeclaims	名称空间中，可以创建的存储卷声明（PersistentVolumeClaim）的总数不能超过此值
.storageclass
.storage.k8s.io/requests.storage	名称空间中，所有与指定存储类（StorageClass）关联的存储卷声明（PersistentVolumeClaim）请求的存储总量不能超过此值
.storageclass
.storage.k8s.io/persistentvolumeclaims	名称空间中，所有与指定存储类（StorageClass）关联的存储卷声明（PersistentVolumeClaim）的总数不能超过此值

例如，假设管理员想要对存储类 gold 和存储类 bronze 做不同的配额限定，那么，可以按如下方式定义 ResourceQuota：

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

在 Kubernetes v1.8 中，引入了本地短时存储（local ephemeral storage）的资源配额设置 (Alpha)

资源名称	描述
requests.ephemeral-storage	名称空间中，所有 Pod 的本地短时存储（local ephemeral storage）请求的总和不能超过此值
limits.ephemeral-storage	名称空间中，所有 Pod 的本地短时存储（local ephemeral storage）限定的总和不能超过此值

对象数量配额

从 Kubernetes v1.9 开始，支持使用如下格式的限定名称空间中标准类型对象的总数量：

count/.

下面是一些例子：

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 v1.15 开始，支持使用相同的格式限定名称空间中自定义资源（CustomResource）对象的总量。例如，为 example.com API group 中的自定义资源（CustomResource） widgets 限定对象数量总数的配额，可以使用 count/widgets.example.com。

当使用 count/* 的方式限定对象总数的配额时，只要对象存储在 apiserver 中，无论其状态如何，该对象就被计数。此类配额限定可以保护 apiserver 的存储空间不被过度消耗。例如，

您可能需要限定名称空间中 Secret 的总数，因为他们通常占用的存储空间比较大。集群中如果存在大量的 Secret 对象，可能会导致 apiserver 或者控制器（Controller）启动失败
您可能也需要限定名称空间中 Job 对象的个数，以避免某个配置错误的 cronjob 创建了太多的 Job，造成了拒绝服务（denial of service）的情况

作用域

每个 ResourceQuota 对象都可以绑定一组作用域，当 Kubernetes 对象与此 ResourceQuota 的作用域匹配（在作用域中）时，ResourceQuota 的限定才对该对象生效。

Scope（作用域）	描述
Terminating	包含所有 .spec.activeDeadlineSeconds >= 0 的 Pod
NotTerminating	包含所有 .spec.activeDeadlineSeconds is nil 的Pod
BestEffort	包含所有服务等级（quality of service）为 BestEffort 的 Pod
NotBestEffort	包含所有服务等级（quality of service）为 NotBestEffort 的 Pod

带有 BestEffort 作用域的 ResourceQuota 关注点为: Pod
带有 Terminating、NotTerminating、 NotBestEffort 的作用域关注点为：
- cpu
- limits.cpu
- limits.memory
- memory
- pods
- requests.cpu
- requests.memory

按PriorityClass设定ResourceQuota

创建 Pod 时，可以指定 priority

(opens new window)。使用 ResourceQuota 的 .spec.scopeSelector 字段将 ResourceQuota 和 Pod 的 priority 关联，进而限定 Pod 的资源消耗。

只有当 ResourceQuota 的 .spec.scopeSelector 字段与 Pod 的 priorty 字段匹配时，ResourceQuota 才生效。

下面的例子创建了一个通过 priority 限定特定 Pod 的 ResourceQuota 对象，该例子的工作方式如下：

假设集群中的 Pod 可以被指定三种 priority class： low、medium、high
集群中为每个 Priority 都创建了一个 ResourceQuota 对象

定义 ResourceQuota 对象的文件如下所示：

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"]

执行命令以创建 ResourceQuota：

kubectl create -f https://kuboard.cn/statics/learning/policy/rq-scope-quota.yaml

resourcequota/pods-high created
resourcequota/pods-medium created
resourcequota/pods-low created

执行如下命令验证 quota 的使用为 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” priority Pod，YAML 文件如下所示：

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 -f https://kuboard.cn/statics/learning/policy/rq-scope-high-priority-pod.yaml

验证 "high" priority 对应的 ResourceQuota pods-high 的 Used 统计结果，可以发现 pods-heigh 的配额已经被使用，而其他两个的配额则没有被使用。

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.matchExpressions.operator 字段中，可以使用如下几种取值：

In
NotIn
Exist
DoesNotExist

Requests vs Limits

Kubernetes 中，在为容器分配计算资源时，每一个容器都可以指定 resources.limits.cpu、resources.limits.memory、resources.requests.cpu、resources.requests.memory。
ResourceQuota可以为 limits 和 requests 各自设定资源配额。

如果 ResourceQuota 指定了 requests.cpu 或者 requests.memory，此时任何新建的容器都必须明确指定自己的 requests.cpu、requests.memory。
如果 ResourceQuota 指定了 limits.cpu 或者 limits.memory，此时任何新建的容器都必须明确指定自己的 limits.cpu、limits.memory。

查看和设定ResourceQuota

使用 kubectl 可以查看和设定 ResourceQuota：

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 run nginx --image=nginx --replicas=2 --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

ResourceQuota和Cluster Capacity

ResourceQuota 与 Cluster Capacity 相互独立，都使用绝对值来标识其大小（而不是百分比）。如果您想集群中添加节点，并不会自动使其中任何一个名称空间的可用资源配额发生变化。

某些情况下，需要更加复杂的策略配置，例如：

在多个团队之间按比例切分集群的资源
允许每一个租户按需增加资源使用，但是又有合适的限定以避免资源耗尽的情况发生
根据某个名称空间的实际需要，增加节点，并提高为其提高资源配额

要实现这些策略，可以使用 ResourceQuota 作为基础，编写自己的控制器来监听资源配额的使用情况，并根据具体的情况动态调整名称空间的 ResourceQuota。

尽管 ResourceQuota 可以将集群中的资源配额分配到名称空间，但是它并不对节点做任何限定，不同名称空间的 Pod 可以运行在同一个节点上。

限定Priority Class的默认资源消耗

某些情况下我们可能需要做如下设定：某个特定 priority 的 Pod（例如，cluster-services）当且仅当名称空间中存在匹配的 ResourceQuota 时才可以创建。

使用这样的机制，集群管理员可以限定某些特别的 priority class 只在指定的名称空间中使用。

如果要激活此特性，您需要将如下配置文件的路径通过 --admission-control-config-file 参数指定到 kube-apiserver 的启动参数中：

apiVersion: apiserver.k8s.io/v1alpha1
kind: AdmissionConfiguration
plugins:
- name: "ResourceQuota"
  configuration:
    apiVersion: resourcequota.admission.k8s.io/v1beta1
    kind: Configuration
    limitedResources:
    - resource: pods
      matchScopes:
      - scopeName: PriorityClass 
        operator: In
        values: ["cluster-services"]

完成此配置后，cluster-services priority 的 Pod 将只能在带有对应 scopeSelector 的 ResourceQuota 的名称空间中创建，例如：

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

CPU/内存资源限额

本文通过实例演示了如何通过ResourceQuota为名称空间配置CPU和内存的资源限额。

创建名称空间

执行如下命令，创建名称空间：

kubectl create namespace quota-mem-cpu-example

创建ResourceQuota

下面是 ResourceQuota 的YAML文件：

apiVersion: v1
kind: ResourceQuota
metadata:
  name: mem-cpu-demo
spec:
  hard:
    requests.cpu: "1"
    requests.memory: 1Gi
    limits.cpu: "2"
    limits.memory: 2Gi

执行命令以创建该 ResourceQuota：

kubectl apply -f https://kuboard.cn/statics/learning/policy/rq-mem-cpu-quota.yaml --namespace=quota-mem-cpu-example

执行命令查看刚创建的 ResourceQuota：

kubectl get resourcequota mem-cpu-demo --namespace=quota-mem-cpu-example --output=yaml

ResourceQuota 为 quota-mem-cpu-example 名称空间设定了如下资源配额：

每一个容器必须有内存请求（request）、内存限制（limit）、CPU请求（request)、CPU限制（limit）
所有容器的内存请求总和不超过 1 GiB
所有容器的内存限定总和不超过 2 GiB
所有容器的CPU请求总和不超过 1 cpu
所有容器的CPU限定总和不超过 2 cpu

创建Pod

下面是一个 Pod 的配置文件：

apiVersion: v1
kind: Pod
metadata:
  name: quota-mem-cpu-demo
spec:
  containers:
  - name: quota-mem-cpu-demo-ctr
    image: nginx
    resources:
      limits:
        memory: "800Mi"
        cpu: "800m" 
      requests:
        memory: "600Mi"
        cpu: "400m"

执行命令以创建该 Pod

kubectl apply -f https://kuboard.cn/statics/learning/policy/rq-mem-cpu-pod.yaml --namespace=quota-mem-cpu-example

执行命令验证 Pod 已运行：

kubectl get pod quota-mem-cpu-demo --namespace=quota-mem-cpu-example

此时执行命令再次查看名称空间的资源配额消耗情况：

kubectl get resourcequota mem-cpu-demo --namespace=quota-mem-cpu-example --output=yaml

输出结果中除了显示名称空间的资源配额之外，同时还显示了该配额的使用情况。结果如下所示：

status:
  hard:
    limits.cpu: "2"
    limits.memory: 2Gi
    requests.cpu: "1"
    requests.memory: 1Gi
  used:
    limits.cpu: 800m
    limits.memory: 800Mi
    requests.cpu: 400m
    requests.memory: 600Mi

尝试创建第二个Pod

下面是另外一个 Pod 的 YAML 文件：

apiVersion: v1
kind: Pod
metadata:
  name: quota-mem-cpu-demo-2
spec:
  containers:
  - name: quota-mem-cpu-demo-2-ctr
    image: redis
    resources:
      limits:
        memory: "1Gi"
        cpu: "800m"      
      requests:
        memory: "700Mi"
        cpu: "400m"

在此配置文件中，Pod 请求了 700MiB 的内存，如果加上第一个 Pod 所请求的内存，其结果已经超出了名称空间的资源配额中对内存请求的限制：600MiB + 600MiB > 1GiB

执行如下命令尝试创建该 Pod：

kubectl apply -f https://kuboard.cn/statics/learning/policy/rq-mem-cpu-pod-2.yaml --namespace=quota-mem-cpu-example

第二个 Pod 将不能创建成功，该命令的输出结果将提示创建 Pod 失败的原因是内存请求之和超过了内存请求的资源配额，错误信息如下所示：

Error from server (Forbidden): error when creating "examples/admin/resource/quota-mem-cpu-pod-2.yaml":
pods "quota-mem-cpu-demo-2" is forbidden: exceeded quota: mem-cpu-demo,
requested: requests.memory=700Mi,used: requests.memory=600Mi, limited: requests.memory=1Gi

总结

在本文的例子中，您可以使用 ResourceQuota 来限定名称空间中所有容器的内存请求（request）之和不超过指定的配额。同时也可以设置内存限定（limit）、CPU请求（request）、CPU限定（limit）的资源配额。

如果需要限定单个Pod、容器的资源使用情况，请参考 LimitRange

清理

删除名称空间可清理本文所创建的所有内容：

kubectl delete namespace quota-mem-cpu-example

Pod数量限额

本文通过实例演示了如何通过ResourceQuota为名称空间配置最多可以运行多少个Pod。

创建名称空间

为本次演示创建名称空间：

kubectl create namespace quota-pod-example

创建ResourceQuota

为本次演示创建 ResourceQuota 对象，yaml文件如下所示：

apiVersion: v1
kind: ResourceQuota
metadata:
  name: pod-demo
spec:
  hard:
    pods: "2"

执行命令创建该 ResourceQuota

kubectl apply -f https://kuboard.cn/statics/learning/policy/rq-pod-quota.yaml --namespace=quota-pod-example

执行如下命令查看已创建的 ResourceQuota

kubectl get resourcequota pod-demo --namespace=quota-pod-example --output=yaml

输出结果中显示了该名称空间的配额限定了只能创建两个 Pod，当前没有任何 Pod 被创建：

spec:
  hard:
    pods: "2"
status:
  hard:
    pods: "2"
  used:
    pods: "0"

创建Pod

创建如下 Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pod-quota-demo
spec:
  selector:
    matchLabels:
      purpose: quota-demo
  replicas: 3
  template:
    metadata:
      labels:
        purpose: quota-demo
    spec:
      containers:
      - name: pod-quota-demo
        image: nginx

该 Deployment 的副本数为 3 replicas: 3，执行命令以创建该 Deployment：

kubectl apply -f https://kuboard.cn/statics/learning/policy/rq-pod-deployment.yaml --namespace=quota-pod-example

执行命令以查看 Deployment 的详细信息

kubectl get deployment pod-quota-demo --namespace=quota-pod-example --output=yaml

尽管 Deployment 期望的副本数是 3，但是由于名称空间通过 ResourceQuota 限定了最大的 Pod 数量，因此，最终只有两个 Pod 被创建成功。输出结果如下所示：

spec:
  ...
  replicas: 3
...
status:
  availableReplicas: 2
...
lastUpdateTime: 2017-07-07T20:57:05Z
    message: 'unable to create pods: pods "pod-quota-demo-1650323038-" is forbidden:
      exceeded quota: pod-demo, requested: pods=1, used: pods=2, limited: pods=2'

清理

删除名称空间可清理本次演示创建的对象：

kubectl delete namespace quota-pod-example

posted @ 2022-01-19 16:35 哈喽哈喽111111 阅读(2196) 评论(0) 收藏举报

刷新页面返回顶部

哈喽

k8s中 资源配额 ResourceQuota

资源配额

启用ResourceQuota

资源类型

计算资源配额

存储资源配额

对象数量配额

作用域

按PriorityClass设定ResourceQuota

Requests vs Limits

查看和设定ResourceQuota

ResourceQuota和Cluster Capacity

限定Priority Class的默认资源消耗

CPU/内存资源限额

创建名称空间

创建ResourceQuota

创建Pod

尝试创建第二个Pod

总结

清理

Pod数量限额

创建名称空间

创建ResourceQuota

创建Pod

清理

k8s中资源配额 ResourceQuota