047.集群管理-资源及配额管理

一 资源管理

1.1 资源调度机制

对于kubernetes资源，有两个重要参数：cpu request与memory request。

通常在定义pod时并没有定义这两个参数，此时kubernetes会认为该pod所需的资源很少，并可以将其调度到任何可用的node上。因此，当集群中的计算资源不很充足时，如果集群中的pod负载突然增大，就会使某个node的资源严重不足。为了避免node系统挂掉，该node会选择“清理”某些pod来释放资源，此时每个pod都可能被“清理”。若其中某些pod非常重要，比如与数据存储相关的、与登录相关的、与查询余额相关的，需要在系统资源严重不足时，也得保障这些pod的存活。

kubernetes中该保障机制的核心如下：

• 通过资源限额来确保不同的pod只能占用指定的资源。
• 允许集群的资源被超额分配，以提高集群的资源利用率。
• 为pod划分等级，确保不同等级的pod有不同的服务质量（qos），资源不足时，低等级的pod会被清理，以确保高等级的pod稳定运行。

kubernetes集群里的节点提供的资源主要是计算资源，计算资源是可计量的能被申请、分配和使用的基础资源，这使之区别于api资源（api resources，例如pod和services等）。

当前kubernetes集群中的计算资源主要包括cpu、gpu及memory，通常绝大多数常规应用不需要gpu资源。cpu与memory是被pod使用的，因此在配置pod时可以通过参数cpu request及memory request为其中的每个容器指定所需使用的cpu与memory量，kubernetes会根据request的值去查找有足够资源的node来调度此pod，如果没有相应的node能满足，则调度失败。

通常，一个程序所使用的cpu与memory是一个动态的量，确切地说，是一个范围，跟它的负载密切相关：负载增加时，cpu和memory的使用量也会增加。因此最准确的说法是，某个进程的cpu使用量为0.1个cpu～1个cpu，内存占用则为500mb～1gb。对应到kubernetes的pod容器上，就是下面这4个参数：

1. spec.container[].resources.requests.cpu
2. spec.container[].resources.limits.cpu
3. spec.container[].resources.requests.memory
4. spec.container[].resources.limits.memory

其中，limits对应资源量的上限，即最多允许使用这个上限的资源量。由于cpu资源是可压缩的，进程无论如何也不可能突破上限，因此设置起来比较容易。对于memory这种不可压缩资源来说，需要进行一定的规划，若设置得小了，当进程在业务繁忙期试图请求超过limit限制的memory时，此进程就会被kubernetes杀掉。因此，memory的request与limit的值需要结合进程的实际需求谨慎设置。

1.2 批量设置

若存在成百上千个不同的pod，那么先手动设置每个pod的这4个参数，再检查并确保这些参数的设置是否合理。比如不能出现内存超过2gb或者cpu占据2个核心的pod。最后需要手工检查不同租户（namespace）下的pod的资源使用量是否超过限额。

若上设置相对繁琐复杂，为此，kubernetes提供了另外两个相关对象：limitrange及resourcequota，前者解决request与limit参数的默认值和合法取值范围等问题，后者则解决约束租户的资源配额问题。集群管理涉及计算资源管理（computeresources）、服务质量管理（qos）、资源配额管理（limitrange、resourcequota）等方面。

resourceqos解读：若不设置cpu或memory的limit值，该pod的资源使用量有一个弹性范围，假设pod a的memory request被设置为1gb，node a当时空闲的memory为1.2gb，符合pod a的需求，因此pod a被调度到node a上。运行3天后，pod a的访问请求大增，内存需要增加到1.5gb，此时node a的剩余内存只有200mb，由于pod a新增的内存已经超出系统资源，所以在这种情况下，pod a就会被kubernetes杀掉。没有设置limit的pod，或者只设置了cpulimit或者memorylimit两者之一的pod，表面看都是很有弹性的，但实际上，相对于4个参数都被设置的pod，是处于一种相对不稳定的状态的，它们与4个参数都没设置的pod相比，只是稳定一点而已。

二 计算资源管理

2.1 requests和limits

以cpu为例，下图显示了未设置limits和设置了requests、limits的cpu使用率的区别。

尽管requests和limits只能被设置到容器上，但是设置pod级别的requests和limits能大大提高管理pod的便利性和灵活性，因此在kubernetes中提供了对pod级别的requests和limits的配置。对于cpu和内存而言，pod的requests或limits是指该pod中所有容器的requests或limits的总和（对于pod中没有设置requests或limits的容器，该项的值被当作0或者按照集群配置的默认值来计算）。

2.2 cpu和memory计算

cpu的requests和limits是通过cpu数（cpus）来度量的。cpu的资源值是绝对值，而不是相对值，比如0.1cpu在单核或多核机器上是一样的，都严格等于0.1cpucore。

memory内存的requests和limits计量单位是字节数。使用整数或者定点整数加上国际单位制来表示内存值。国际单位制包括十进制的e、p、t、g、m、k、m，或二进制的ei、pi、ti、gi、mi、ki。kib与mib是以二进制表示的字节单位，常见的kb与mb则是以十进制表示的字节单位，比如：

• 1kb（kilobyte）= 1000bytes = 8000bits
• 1kib（kibibyte）= 2^10bytes = 1024bytes = 8192bits

因此，128974848、129e6、129m、123mi的内存配置是一样的。

kubernetes的计算资源单位是大小写敏感的，因为m可以表示千分之一单位（milliunit），而m可以表示十进制的1000，二者的含义不同；同理，小写的k不是一个合法的资源单位。

示例1：

[root@k8smaster01 study]# vi requests01.yaml

  1 apiversion: v1
  2 kind: pod
  3 metadata:
  4   name: frontend
  5 spec:
  6  continers:
  7  - name: db
  8    image: mysql
  9    resources:
 10      requests:
 11        memory: "64mi"
 12        cpu: "250m"
 13      limits:
 14        memory: "128mi"
 15        cpu: "500m"
 16  - name: wp
 17    image: wordpress
 18    resources:
 19      requests:
 20        memory: "64mi"
 21        cpu: "250m"
 22      limits:
 23        memory: "128mi"
 24        cpu: "500m"
 25 

解读：如上所示，该pod包含两个容器，每个容器配置的requests都是0.25cpu和64mib（226 bytes）内存，而配置的limits都是0.5cpu和

128mib（227 bytes）内存。

这个pod的requests和limits等于pod中所有容器对应配置的总和，所以pod的requests是0.5cpu和128mib（227 bytes）内存，limits是1cpu和256mib（228 bytes）内存。

2.3 requests和limits的pod调度机制

当一个pod创建成功时，kubernetes调度器（scheduler）会为该pod选择一个节点来执行。对于每种计算资源（cpu和memory）而言，每个节点都有一个能用于运行pod的最大容量值。调度器在调度时，首先要确保调度后该节点上所有pod的cpu和内存的requests总和，不超过该节点能提供给pod使用的cpu和memory的最大容量值。

例如，某个节点上的cpu资源充足，而内存为4gb，其中3gb可以运行pod，而某pod的memory requests为1gb、limits为2gb，那么在这个节点上最多可以运行3个这样的pod。假设该节点已经启动3个此pod实例，而这3个pod的实际内存使用都不足500mb，那么理论上该节点的可用内存应该大于1.5gb。但是由于该节点的pod requests总和已经达到节点的可用内存上限，因此kubernetes不会再将任何pod实例调度到该节点上。

注意：可能某节点上的实际资源使用量非常低，但是已运行pod配置的requests值的总和非常高，再加上需要调度的pod的requests值，会超过该节点提供给pod的资源容量上限，这时kubernetes仍然不会将pod调度到该节点上。如果kubernetes将pod调度到该节点上，之后该节点上运行的pod又面临服务峰值等情况，就可能导致pod资源短缺。

2.4 requests和limits机制

kubelet在启动pod的某个容器时，会将容器的requests和limits值转化为相应的容器启动参数传递给容器执行器（docker或者rkt）。如果容器的执行环境是docker，那么会传递如下4个参数给docker容器：

• spec.container[].resources.requests.cpu

这个参数会转化为core数（比如配置的100m会转化为0.1），然后乘以1024，再将这个结果作为--cpu-shares参数的值传递给docker run命令。在docker run命令中，--cpu-share参数是一个相对权重值（relativeweight），这个相对权重值会决定docker在资源竞争时分配给容器的资源比例。

举例说明--cpu-shares参数在docker中的含义：比如将两个容器的cpu requests分别设置为1和2，那么容器在docker run启动时对应的--cpu-shares参数值分别为1024和2048，在主机cpu资源产生竞争时，docker会尝试按照1∶2的配比将cpu资源分配给这两个容器使用。

注意这个参数对于kubernetes而言是绝对值，主要用于kubernetes调度和管理；同时kubernetes会将这个参数的值传递给docker run的--cpu-shares参数。--cpu-shares参数对于docker而言是相对值，主要用于资源分配比例。

• spec.container[].resources.limits.cpu

这个参数会转化为millicore数（比如配置的1被转化为1000，而配置的100m被转化为100），将此值乘以100000，再除以1000，然后将结果值作为--cpu-quota参数的值传递给docker run命令。docker run命令中另外一个参数--cpu-period默认被设置为100000，表示docker重新计量和分配cpu的使用时间间隔为100000μs（100ms）。

docker的--cpu-quota参数和--cpu-period参数一起配合完成对容器cpu的使用限制：比如kubernetes中配置容器的cpu limits为0.1，那么计算后--cpu-quota为10000，而--cpu-period为100000，这意味着docker在100ms内最多给该容器分配10ms×core的计算资源用量，10/100=0.1core的结果与kubernetes配置的意义是一致的。

注意：如果kubelet的启动参数--cpu-cfs-quota被设置为true，那么kubelet会强制要求所有pod都必须配置cpu limits（如果pod没有配置，则集群提供了默认配置也可以）。从kubernetes1.2版本开始，这个--cpu-cfs-quota启动参数的默认值就是true。

• spec.container[].resources.requests.memory

这个参数值只提供给kubernetes调度器作为调度和管理的依据，不会作为任何参数传递给docker。

• spec.container[].resources.limits.memory

这个参数值会转化为单位为bytes的整数，数值会作为--memory参数传递给docker run命令。如果一个容器在运行过程中使用了超出了其内存limits配置的内存限制值，那么它可能会被杀掉，如果这个容器是一个可重启的容器，那么之后它会被kubelet重新启动。

因此对容器的limits配置需要进行准确测试和评估。与内存limits不同的是，cpu在容器技术中属于可压缩资源，因此对cpu的limits配置一般不会因为偶然超标使用而导致容器被系统杀。

2.5 计算资源使用情况监控

pod的资源用量会作为pod的状态信息一同上报给master。如果在集群中配置了heapster来监控集群的性能数据，那么还可以从heapster中查看pod的资源用量信息。

2.6 计算资源调度常见问题

• pod状态为pending，错误信息为failedscheduling

如果kubernetes调度器在集群中找不到合适的节点来运行pod，那么这个pod会一直处于未调度状态，直到调度器找到合适的节点为止。每次调度器尝试调度失败时，kubernetes都会产生一个事件，我们可以通过下面这种方式来查看事件的信息：

kubectl describe pod <podname>| grep -a 3 events

如果一个或者多个pod调度失败且有这类错误，那么可以尝试以下几种解决方法：

1. 添加更多的节点到集群中；
2. 停止一些不必要的运行中的pod，释放资源；
3. 检查pod的配置，错误的配置可能导致该pod永远无法被调度执行。比如整个集群中所有节点都只有1cpu，而pod配置的cpurequests为2，该pod就不会被调度执行。

可以使用kubectl describe nodes命令来查看集群中节点的计算资源容量和已使用量：

[root@k8smaster01 ~]# kubectl describe nodes k8snode01

超过可用资源容量上限（capacity）和已分配资源量（allocatedresources）差额的pod无法运行在该node上。

• 容器被强行终止（terminated）

如果容器使用的资源超过了它配置的limits，那么该容器可能会被强制终止。可以通过kubectl describe pod命令来确认容器是否因为这个原因被终止：

kubectl describe pod

restart count:5说明这个名为simmemleak的容器被强制终止并重启了5次。可以在使用kubectl get pod命令时添加-o go-template=...格式参数来读取已终止容器之前的状态信息：

kubectl get pod -o go-template='{{range.status.containerstatuses}}{{"container name:"}}{{.name}}{{"\r\nlastate:"}}{{.laststate}}{{end}}'

可以看到这个容器因为reason:oom killed而被强制终止，说明这个容器的内存超过了限制（outofmemory）。

三 资源配置范围管理（limitrange）

3.1 limitrange

在默认情况下，kubernetes不会对pod加上cpu和内存限制，这意味着kubernetes系统中任何pod都可以使用其所在节点的所有可用的cpu和内存。通过配置pod的计算资源requests和limits，可以限制pod的资源使用，但对于kubernetes集群管理员而言，配置每一个pod的requests和limits是烦琐的，而且很受限制。更多时候，需要对集群内requests和limits的配置做一个全局限制。

常见的配置场景如下：

1. 集群中的每个节点都有2gb内存，集群管理员不希望任何pod申请超过2gb的内存：因为在整个集群中都没有任何节点能满足超过2gb内存的请求。如果某个pod的内存配置超过2gb，那么该pod将永远都无法被调度到任何节点上执行。为了防止这种情况的发生，集群管理员希望能在系统管理功能中设置禁止pod申请超过2gb内存。
2. 集群由同一个组织中的两个团队共享，分别运行生产环境和开发环境。生产环境最多可以使用8gb内存，而开发环境最多可以使用512mb内存。集群管理员希望通过为这两个环境创建不同的命名空间，并为每个命名空间设置不同的限制来满足这个需求。
3. 用户创建pod时使用的资源可能会刚好比整个机器资源的上限稍小，而恰好剩下的资源大小非常尴尬：不足以运行其他任务但整个集群加起来又非常浪费。因此，集群管理员希望设置每个pod都必须至少使用集群平均资源值（cpu和内存）的20%，这样集群能够提供更好的资源一致性的调度，从而减少了资源浪费。

针对这些需求，kubernetes提供了limitrange机制对pod和容器的requests和limits配置进一步做出限制。

示例1：

[root@k8smaster01 study]# kubectl create namespace limit-example #创建namespace

[root@k8smaster01 study]# vi limits.yaml #创建limitrange

  1 apiversion: v1
  2 kind: limitrange
  3 metadata:
  4   name: mylimits
  5 spec:
  6   limits:
  7   - max:
  8       cpu: "4"
  9       memory: 2gi
 10     min:
 11       cpu: 200m
 12       memory: 6mi
 13     maxlimitrequestratio:
 14       cpu: 3
 15       memory: 2
 16     type: pod
 17   - default:
 18       cpu: 300m
 19       memory: 200mi
 20     defaultrequest:
 21       cpu: 200m
 22       memory: 100mi
 23     max:
 24       cpu: "2"
 25       memory: 1gi
 26     min:
 27       cpu: 100m
 28       memory: 3mi
 29     maxlimitrequestratio:
 30       cpu: 5
 31       memory: 4
 32     type: container
 33 

[root@k8smaster01 study]# kubectl create -f limits.yaml --namespace=limit-example #为namespace“limit-example”创建limitrange

[root@k8smaster01 study]# kubectl get limitranges -n limit-example

[root@k8smaster01 study]# kubectl describe limitranges mylimits -n limit-example

解读：

1. 不论是cpu还是内存，在limitrange中，pod和container都可以设置min、max和maxlimit/requestsratio参数。container还可以设置default request和default limit参数，而pod不能设置default request和defaultlimit参数。
2. 对pod和container的参数解释如下：

• container的min（如上图100m和3mi）是pod中所有容器的requests值下限；container的max（如上图2和1gi）是pod中所有容器的limits值上限；container的default request（如上图200m和100mi）是pod中所有未指定requests值的容器的默认requests值；container的defaultlimit（如上图300m和200mi）是pod中所有未指定limits值的容器的默认limits值。对于同一资源类型，这4个参数必须满足以下关系：min ≤ default request ≤ default limit ≤ max。
• pod的min（如上图200m和6mi）是pod中所有容器的requests值的总和下限；pod的max（如上图4和2gi）是pod中所有容器的limits值的总和上限。当容器未指定requests值或者limits值时，将使用container的default request值或者default limit值。
• container的max limit/requests ratio（如上图5和4）限制了pod中所有容器的limits值与requests值的比例上限；而pod的maxlimit/requestsratio（如上图3和2）限制了pod中所有容器的limits值总和与requests值总和的比例上限。

3. 如果设置了container的max，那么对于该类资源而言，整个集群中的所有容器都必须设置limits，否则无法成功创建。pod内的容器未配置limits时，将使用default limit的值（本例中的300mcpu和200mib内存），如果也未配置default，则无法成功创建。
4. 如果设置了container的min，那么对于该类资源而言，整个集群中的所有容器都必须设置requests。如果创建pod的容器时未配置该类资源的requests，那么在创建过程中会报验证错误。pod里容器的requests在未配置时，可以使用默认值default request（本例中的200mcpu和100mib内存）；如果未配置而又没有使用默认值default request，那么会默认等于该容器的limits；如果此时limits也未定义，就会报错。
5. 对于任意一个pod而言，该pod中所有容器的requests总和必须大于或等于6mib，而且所有容器的limits总和必须小于或等于1gib；同样，所有容器的cpu requests总和必须大于或等于200m，而且所有容器的cpu limits总和必须小于或等于2。
6. pod里任何容器的limits与requests的比例都不能超过container的maxlimit/requestsratio；pod里所有容器的limits总和与requests的总和的比例不能超过pod的maxlimit/requestsratio。

[root@k8smaster01 study]# kubectl run nginx --image=nginx --replicas=1 --namespace=limit-example

[root@k8smaster01 study]# kubectl get pods --namespace=limit-example

name ready status restarts age

nginx-7bb7cd8db5-mzcvb 1/1 running 0 54s

解读：命名空间中limitrange只会在pod创建或者更新时执行检查。如果手动修改limitrange为一个新的值，那么这个新的值不会去检查或限制之前已经在该命名空间中创建好的pod。如果在创建pod时配置的资源值（cpu或者内存）超过了limitrange的限制，那么该创建过程会报错，在错误信息中会说明详细的错误原因。

[root@k8smaster01 study]# kubectl get pods nginx-7bb7cd8db5-mzcvb --namespace=limit-example -o yaml | grep resources -c 6 #查看该pod的resource

  1   uid: 5fd37e03-ea08-44f3-a2c7-30ad31c7ab4a
  2 spec:
  3   containers:
  4   - image: nginx
  5     imagepullpolicy: always
  6     name: nginx
  7     resources:
  8       limits:
  9         cpu: 300m
 10         memory: 200mi
 11       requests:
 12         cpu: 200m
 13         memory: 100mi
 14 

解读：由于该pod未配置资源requests和limits，所以使用了namespace limit-example中的默认cpu和内存定义的requests和limits值。

[root@k8smaster01 study]# vi invalid-pod.yaml

  1 apiversion: v1
  2 kind: pod
  3 metadata:
  4   name: invalid-pod
  5 spec:
  6   containers:
  7   - name: kubernetes-serve-hostname
  8     image: gcr.azk8s.cn/google_containers/server_hostname
  9     resources:
 10       limits:
 11         cpu: "3"
 12         memory: 100mi
 13 

[root@k8smaster01 study]# kubectl create -f invalid-pod.yaml --namespace=limit-example

error from server (forbidden): error when creating "invalid-pod.yaml": pods "invalid-pod" is forbidden: maximum cpu usage per container is 2, but limit is 3

解读：创建该pod，会出现系统报错了，并且提供的错误原因为超过资源限制。

[root@k8smaster01 study]# vi limit-test-nginx.yaml

  1 apiversion: v1
  2 kind: pod
  3 metadata:
  4   name: limit-test-nginx
  5   labels:
  6     name: limit-test-nginx
  7 spec:
  8   containers:
  9   - name: limit-test-nginx
 10     image: nginx
 11     resources:
 12       limits:
 13         cpu: "1"
 14         memory: 512mi
 15       requests:
 16         cpu: "0.8"
 17         memory: 250mi
 18 

[root@k8smaster01 study]# kubectl create -f limit-test-nginx.yaml -n limit-example

error from server (forbidden): error when creating "limit-test-nginx.yaml": pods "limit-test-nginx" is forbidden: memory max limit to request ratio per pod is 2, but provided ratio is 2.048000

解读：由于limit-test-nginx这个pod的全部内存limits总和与requests总和的比例为512∶250，大于在limitrange中定义的pod的最大比率2（maxlimitrequestratio.memory=2），因此创建失败。

[root@k8smaster01 study]# vi valid-pod.yaml

  1 apiversion: v1
  2 kind: pod
  3 metadata:
  4   name: valid-pod
  5   labels:
  6     name: valid-pod
  7 spec:
  8   containers:
  9   - name: kubernetes-serve-hostname
 10     image: gcr.io/google_containers/serve_hostname
 11     resources:
 12       limits:
 13         cpu: "1"
 14         memory: 512mi
 15 

[root@k8smaster01 study]# kubectl create -f valid-pod.yaml -n limit-example

[root@k8smaster01 study]# kubectl get pods valid-pod -n limit-example -o yaml | grep resources -c 6 #查看该pod的资源信息

  1   uid: 59e3d05a-8c09-479e-a3ad-1a4dbfd8e946
  2 spec:
  3   containers:
  4   - image: gcr.io/google_containers/serve_hostname
  5     imagepullpolicy: always
  6     name: kubernetes-serve-hostname
  7     resources:
  8       limits:
  9         cpu: "1"
 10         memory: 512mi
 11       requests:
 12         cpu: "1"
 13         memory: 512mi
 14 

解读：该pod配置了明确的limits和requests，因此该pod不会使用在namespace limit-example中定义的default和default request。

注意：cpu limits强制配置这个选项在kubernetes集群中默认是开启的；除非集群管理员在部署kubelet时，通过设置参数--cpucfs-quota=false来关闭该限制：如果集群管理员希望对整个集群中容器或者pod配置的requests和limits做限制，那么可以通过配置kubernetes命名空间中的limitrange来达到该目的。在kubernetes集群中，如果pod没有显式定义limits和requests，那么kubernetes系统会将该pod所在的命名空间中定义的limitrange的default和default requests配置到该pod上。

四 资源服务质量管理（resource qos）

4.1 服务资源质量

kubernetes会根据pod的requests和limits配置来实现针对pod的不同级别的资源服务质量控制（qos）。在kubernetes的资源qos体系中，需要保证高可靠性的pod可以申请可靠资源，而一些不需要高可靠性的pod可以申请可靠性较低或者不可靠的资源。

容器的资源配置分为requests和limits，其中requests是kubernetes调度时能为容器提供的完全可保障的资源量（最低保障），而limits是系统允许容器运行时可能使用的资源量的上限（最高上限）。pod级别的资源配置是通过计算pod内所有容器的资源配置的总和得出来的。

kubernetes中pod的requests和limits资源配置有如下特点：

1. 如果pod配置的requests值等于limits值，那么该pod可以获得的资源是完全可靠的。
2. 如果pod的requests值小于limits值，那么该pod获得的资源可分成两部分：
1. 完全可靠的资源，资源量的大小等于requests值；
2. 不可靠的资源，资源量最大等于limits与requests的差额，这份不可靠的资源能够申请到多少，取决于当时主机上容器可用资源的余量。

通过这种机制，kubernetes可以实现节点资源的超售（oversubscription），比如在cpu完全充足的情况下，某机器共有32gib内存可提供给容器使用，容器配置为requests值1gib，limits值为2gib，那么在该机器上最多可以同时运行32个容器，每个容器最多可以使用2gib内存，如果这些容器的内存使用峰值能错开，那么所有容器都可以正常运行。超售机制能有效提高资源的利用率，同时不会影响容器申请的完全可靠资源的可靠性。

4.2 requests和limits限制机制

容器的资源配置满足以下两个条件：

• requests <= 节点可用资源
• requests <= limits

kubernetes根据pod配置的requests值来调度pod，pod在成功调度之后会得到requests值定义的资源来运行；而如果pod所在机器上的资源有空余，则pod可以申请更多的资源，最多不能超过limits的值。requests和limits针对不同计算资源类型的限制机制存在差异。这种差异主要取决于计算资源类型是可压缩资源还是不可压缩资源。

1. 可压缩资源

kubernetes目前支持的可压缩资源是cpu。

pod可以得到pod的requests配置的cpu使用量，而能否使用超过requests值的部分取决于系统的负载和调度。不过由于目前kubernetes和docker的cpu隔离机制都是在容器级别隔离的，所以pod级别的资源配置并不能完全得到保障；pod级别的cgroups等待引入，以便于确保pod级别的资源配置准确运行。

空闲cpu资源按照容器requests值的比例分配。举例说明：容器a的cpu配置为requests 1 limits 10，容器b的cpu配置为request 2 limits8，a和b同时运行在一个节点上，初始状态下容器的可用cpu为3 cores，那么a和b恰好得到在它们的requests中定义的cpu用量，即1cpu和2cpu。如果a和b都需要更多的cpu资源，而恰好此时系统的其他任务释放出1.5cpu，那么这1.5 cpu将按照a和b的requests值的比例1∶2分配给a和b，即最终a可使用1.5cpu，b可使用3cpu。

如果pod使用了超过在limits 10中配置的cpu用量，那么cgroups会对pod中的容器的cpu使用进行限流（throttled）；如果pod没有配置limits 10，那么pod会尝试抢占所有空闲的cpu资源（kubernetes从1.2版本开始默认开启--cpu-cfs-quota，因此在默认情况下必须配置limits）

2. 不可压缩资源

kubernetes目前支持的不可压缩资源是内存。

pod可以得到在requests中配置的内存。如果pod使用的内存量小于它的requests的配置，那么这个pod可以正常运行；如果pod使用的内存量超过了它的requests的配置，那么这个pod有可能被kubernetes杀掉：比如pod a使用了超过requests而不到limits的内存量，此时同一机器上另外一个pod b之前只使用了远少于自己的requests值的内存，此时程序压力增大，pod b向系统申请的总量不超过自己的requests值的内存，那么kubernetes可能会直接杀掉pod a，而优先保障pod b的requests得到满足；另外一种情况是pod a使用了超过requests而不到limits的内存量，此时kubernetes将一个新的pod调度到这台机器上，新的pod需要使用内存，而只有pod a使用了超过了自己的requests值的内存，那么kubernetes也可能会杀掉pod a来释放内存资源。

如果pod使用的内存量超过了它的limits设置，那么操作系统内核会杀掉pod所有容器的所有进程中使用内存最多的一个，直到内存不超过limits为止。

4.3 对调度策略的影响

kubernetes的kubelet通过计算pod中所有容器的requests的总和来决定对pod的调度。

不管是cpu还是内存，kubernetes调度器和kubelet都会确保节点上所有pod的requests的总和不会超过在该节点上可分配给容器使用的资源容量上限。

4.4 服务质量等级（qosclasses）

在一个超用（over committed，容器limits总和大于系统容量上限）系统中，由于容器负载的波动可能导致操作系统的资源不足，最终可能导致部分容器被杀掉。在这种情况下，理想是优先杀掉那些不太重要的容器。kubernetes将容器划分成3个qos等级来衡量重要程度：

guaranteed（完全可靠的）、burstable（弹性波动、较可靠的）和besteffort（尽力而为、不太可靠的），这三种优先级依次递减。

qos等级和优先级的关系从理论上来说，qos级别应该作为一个单独的参数来提供api，并由用户对pod进行配置，这种配置应该与requests和limits无关。但在当前版本的kubernetes的设计中，为了简化模式及避免引入太多的复杂性，qos级别直接由requests和limits来定义。在kubernetes中容器的qos级别等于容器所在pod的qos级别，而kubernetes的资源配置定义了pod的如上三种qos级别。

1. guaranteed

如果pod中的所有容器对所有资源类型都定义了limits和requests，并且所有容器的limits值都和requests值全部相等（且都不为0），那么该pod的qos级别就是guaranteed。

注意：在这种情况下，容器可以不定义requests，因为requests值在未定义时默认等于limits。

示例1：如下定义的podqos级别就是guaranteed。

  1 containers：
  2   name: foo
  3     resources:
  4       limits:
  5         cpu: 10m
  6         memory: 1gi
  7   name: bar
  8     resources:
  9       limits:
 10         cpu: 100m
 11         memory: 100mi
 12 

解读：如上未定义requests值，所以其默认等于limits值。

示例2：

  1 containers：
  2   name: foo
  3     resources:
  4       requests:
  5         cpu: 10m
  6         memory: 1gi
  7       limits:
  8         cpu: 10m
  9         memory: 1gi
 10   name: bar
 11     resources:
 12       requests:
 13         cpu: 10m
 14         memory: 1gi
 15       limits:
 16         cpu: 100m
 17         memory: 100mi
 18 

解读：该定义的requests和limits的值完全相同。

2. besteffort

如果pod中所有容器都未定义资源配置（requests和limits都未定义），那么该pod的qos级别就是besteffort。

示例3：

  1 containers：
  2   name: foo
  3     resources:
  4   name: bar
  5     resources:
  6 

解读：该容器都未定义资源配置。

3. burstable

当一个pod既不为guaranteed级别，也不为besteffort级别时，该pod的qos级别就是burstable。burstable级别的pod包括两种情况。

• 第1种情况：pod中的一部分容器在一种或多种资源类型的资源配置中定义了requests值和limits值（都不为0），且requests值小于limits值；
• 第2种情况：pod中的一部分容器未定义资源配置（requests和limits都未定义）。

注意：在容器未定义limits时，limits值默认等于节点资源容量的上限。

示例4：容器foo的cpurequests不等于limits。

  1 containers：
  2   name: foo
  3     resources:
  4       requests:
  5         cpu: 5m
  6         memory: 1gi
  7       limits:
  8         cpu: 10m
  9         memory: 1gi
 10   name: bar
 11     resources:
 12       requests:
 13         cpu: 5m
 14         memory: 1gi
 15       limits:
 16         cpu: 100m
 17         memory: 100mi
 18 

示例5：容器bar未定义资源配置而容器foo定义了资源配置。

  1 containers：
  2   name: foo
  3     resources:
  4       requests:
  5         cpu: 10m
  6         memory: 1gi
  7       limits:
  8         cpu: 10m
  9         memory: 1gi
 10   name: bar
 11 

示例6：容器foo未定义cpu，而容器bar未定义内存。

  1 containers：
  2   name: foo
  3     resources:
  4       limits:
  5         memory: 1gi
  6   name: bar
  7     resources:
  8       limits:
  9         cpu: 100m
 10 

示例7：容器bar未定义资源配置，而容器foo未定义limits值。

containers： name: foo resources: requests: cpu: 5m memory: 1gi name: bar

4.5 kubernetes qos的工作特点

pod的cpu requests无法得到满足（比如节点的系统级任务占用过多的cpu导致无法分配足够的cpu给容器使用）时，容器得到的cpu会被压缩限流。由于内存是不可压缩的资源，所以针对内存资源紧缺的情况，会按照以下逻辑进行处理。

1. besteffort pod的优先级最低，在这类pod中运行的进程会在系统内存紧缺时被第一优先杀掉。当然，从另外一个角度来看，besteffort pod由于没有设置资源limits，所以在资源充足时，它们可以充分使用所有的闲置资源。
2. burstable pod的优先级居中，这类pod初始时会分配较少的可靠资源，但可以按需申请更多的资源。当然，如果整个系统内存紧缺，又没有besteffort容器可以被杀掉以释放资源，那么这类pod中的进程可能会被杀掉。
3. guaranteed pod的优先级最高，而且一般情况下这类pod只要不超过其资源limits的限制就不会被杀掉。当然，如果整个系统内存紧缺，又没有其他更低优先级的容器可以被杀掉以释放资源，那么这类pod中的进程也可能会被杀掉。

4.6 oom计分系统

oom（out of memory）计分规则包括如下内容：

oom计分的计算方法为：计算进程使用内存在系统中占的百分比，取其中不含百分号的数值，再乘以10的结果，这个结果是进程oom的基础分；将进程oom基础分的分值再加上这个进程的oom分数调整值oom_score_adj的值，作为进程oom的最终分值（除root启动的进程外）。在系统发生oom时，oom killer会优先杀掉oom计分更高的进程。

进程的oom计分的基本分数值范围是0～1000，如果a进程的调整值oom_score_adj减去b进程的调整值的结果大于1000，那么a进程的oom计分最终值必然大于b进程，会优先杀掉a进程。

不论调整oom_score_adj值为多少，任何进程的最终分值范围也是0～1000。在kubernetes，不同qos的oom计分调整值规则如下所示。

qos等级	oom_score_adj
guaranteed	-998
besteffort	1000
burstable	min(max(2,1000-(1000*memoryrequestbytes)/machinememorycapacitybytes),999)

其中：

• besteffortpod设置oom_score_adj调整值为1000，因此besteffortpod中容器里所有进程的oom最终分肯定是1000。
• guaranteedpod设置oom_score_adj调整值为-998，因此guaranteedpod中容器里所有进程的oom最终分一般是0或者1（因为基础分不可能是1000）。
• burstablepod规则分情况说明：如果burstablepod的内存requests超过了系统可用内存的99.8%，那么这个pod的oom_score_adj调整值固定为2；否则，设置oom_score_adj调整值为1000－10×(%of memory requested)；如果内存requests为0，那么oom_score_adj调整值固定为999。这样的规则能确保oom_score_adj调整值的范围为2～999，而burstablepod中所有进程的oom最终分数范围为2～1000。burstablepod进程的oom最终分数始终大于guaranteedpod的进程得分，因此它们会被优先杀掉。如果一个burstablepod使用的内存比它的内存requests少，那么可以肯定的是它的所有进程的oom最终分数会小于1000，此时能确保它的优先级高于besteffortpod。如果在一个burstablepod的某个容器中某个进程使用的内存比容器的requests值高，那么这个进程的oom最终分数会是1000，否则它的oom最终分会小于1000。假设在下面的容器中有一个占用内存非常大的进程，那么当一个使用内存超过其requests的burstablepod与另外一个使用内存少于其requests的burstablepod发生内存竞争冲突时，前者的进程会被系统杀掉。如果在一个burstablepod内部有多个进程的多个容器发生内存竞争冲突，那么此时oom评分只能作为参考，不能保证完全按照资源配置的定义来执行oomkill。

oom还有一些特殊的计分规则，如下所述。

• kubelet进程和docker进程的调整值oom_score_adj为-998。
• 如果配置进程调整值oom_score_adj为-999，那么这类进程不会被oomkiller杀掉。

五 资源配额管理（ resource quotas）

5.1 配额管理

resourcequotas通常用于在共享集群资源场景中平衡资源，通过resourcequota对象，可以定义资源配额，这个资源配额可以为每个命名空间都提供一个总体的资源使用的限制：它可以限制命名空间中某种类型的对象的总数目上限，也可以设置命名空间中pod可以使用的计算资源的总上限。

resourcequotas典型的场景如下：

1. 不同的团队工作在不同的命名空间下，目前这是非约束性的，在未来的版本中可能会通过acl（access control list，访问控制列表）来实现强制性约束。
2. 集群管理员为集群中的每个命名空间都创建一个或者多个资源配额项。
3. 当用户在命名空间中使用资源（创建pod或者service等）时，kubernetes的配额系统会统计、监控和检查资源用量，以确保使用的资源用量没有超过资源配额的配置。
4. 如果在创建或者更新应用时资源使用超过了某项资源配额的限制，那么创建或者更新的请求会报错（http 403 forbidden），并给出详细的出错原因说明。
5. 如果命名空间中的计算资源（cpu和内存）的资源配额启用，那么用户必须为相应的资源类型设置requests或limits；否则配额系统可能会直接拒绝pod的创建。这里可以使用limitrange机制来为没有配置资源的pod提供默认资源配置。

场景示例：

• 集群共有32gb内存和16cpu，两个小组。a小组使用20gb内存和10cpu，b小组使用10gb内存和2cpu，剩下的2gb内存和2cpu作为预留。在名为testing的命名空间中，限制使用1cpu和1gb内存；在名为production的命名空间中，资源使用不受限制。

在使用资源配额时，需要注意以下两点。

1. 如果集群中总的可用资源小于各命名空间中资源配额的总和，那么可能会导致资源竞争。资源竞争时，kubernetes系统会遵循先到先得的原则。
2. 不管是资源竞争还是配额的修改，都不会影响已经创建的资源使用对象。

5.2 开启资源配额特性

资源配额可以通过在kube-apiserver的--admission-control参数值中添加resourcequota参数进行开启。如果在某个命名空间的定义中存在resourcequota，那么对于该命名空间而言，资源配额就是开启的。一个命名空间可以有多个resourcequota配置项。

提示：在v 1.10后续的版本中，--admission-control 已经废弃,建议使用 --enable-admission-plugins。

[root@k8smaster01 study]# vi /etc/kubernetes/manifests/kube-apiserver.yaml …… - --enable-admission-plugins=noderestriction,resourcequota,limitranger …… [root@k8smaster01 study]# systemctl restart kubelet.service

5.3 资源配额类型

• 计算资源配额（computeresourcequota）

资源配额可以限制一个命名空间中所有pod的计算资源的总和。目前支持的计算资源类型如下表：

资源名称	说明
cpu	所有非终止状态的pod，cpu requests的总和不能超过该值
limits.cpu	所有非终止状态的pod，cpu limits的总和不能超过该值
limits.memory	所有非终止状态的pod，内存limits的总和不能超过该值
memory	所有非终止状态的pod，内存requests的总和不能超过该值
requests.cpu	所有非终止状态的pod，cpu requests的总和不能超过该值
requests.memory	所有非终止状态的pod，内存requests的总和不能超过该值

• 存储资源配额（volume count quota）

可以在给定的命名空间中限制所使用的存储资源（storageresources）的总量，目前支持的存储资源名称如下表：

资源名称	说明
requests.storage	所有pvc，存储请求总量不能超过此值
persistentvolumeclaims	在该命名空间中能存在的持久卷的总数上限
.storageclass.storage.k8s.io/requests.storage	和该存储类关联的所有pvc，存储请求总和不能超过此值
.storageclass.storage.k8s.io/persistentvolumeclaims	和该存储类关联的所有pvc的总和

• 对象数量配额（ object count quota）

指定类型的对象数量可以被限制。 如下表列出了resourcequota支持限制的对象类型：

资源名称	说明
configmaps	在该命名空间中能存在的configmap的总数上限
pods	在该命名空间中能存在的非终止状态pod的总数上限，pod终止状态等价于pod的status.phase in(failed, succeeded) = true
replicationcontrollers	在该命名空间中能存在的rc的总数上限
resourcequtas	在该命名空间中能存在的资源配额项的总数上限
services	在该命名空间中能存在的service的总数上限
service.loadbalancers	在该命名空间中能存在的负载均衡的总数上限
services.nodeports	在该命名空间中能存在的nodeport的总数上限
secrets	在该命名空间中能存在的secret的总数上限

通常，可以通过资源配额来限制在命名空间中能创建的pod的最大数量，这种设置可以防止某些用户大量创建pod而迅速耗尽整个集群的pod ip和计算资源。

5.4 配额的作用域（quotascopes）

每项资源配额都可以单独配置一组作用域，配置了作用域的资源配额只会对符合其作用域的资源使用情况进行计量和限制，作用域范围内超过了资源配额的请求都会报验证错误。resourcequota的4种作用域如下所示：

作用域	说明
termination	匹配所有spec.activedeadlineseconds 不小于0的pod
nottermination	匹配所有spec.activedeadlineseconds是nil的pod
besteffort	匹配所有qos是 besteffort的pod
notbesteffort	匹配所有qos不是besteffort的pod

其中，besteffort作用域可以限定资源配额来追踪pods资源的使用，terminating、notterminating和notbesteffort这三种作用域可以限定资源配额来追踪以下资源的使用：

• cpu
• limits.cpu
• limits.memory
• memory
• pods
• requests.cpu
• requests.memory

5.5 资源配额（resourcequota）设置requests和limits

资源配额也可以设置requests和limits。如果在资源配额中指定了requests.cpu或requests.memory，那么它会强制要求每个容器都配置自己的cpu requests或cpu limits（可使用limit range提供的默认值）。

同理，如果在资源配额中指定了limits.cpu或limits.memory，那么它也会强制要求每个容器都配置自己的内存requests或内存limits（可使用limitrange提供的默认值）。

5.6 资源配额的定义

与limitrange相似，resourcequota也被设置在namespace中。

示例1：

[root@k8smaster01 study]# kubectl create namespace myspace #创建名为myspace的namespace

[root@k8smaster01 study]# vi compute-resources.yaml #创建resourcequota配置文件

  1 apiversion: v1
  2 kind: resourcequota
  3 metadata:
  4   name: compute-resources
  5 spec:
  6   hard:
  7     pods: "4"
  8     requests.cpu: "1"
  9     requests.memory: 1gi
 10     limits.cpu: "2"
 11     limits.memory: 2gi
 12 

[root@k8smaster01 study]# kubectl create -f compute-resources.yaml --namespace=myspace #创建该resourcequota

创建另一个名为object-counts.yaml的文件，用于设置对象数量的配额：

[root@k8smaster01 study]# vi object-counts.yaml

  1 apiversion: v1
  2 kind: resourcequota
  3 metadata:
  4   name: object-counts
  5 spec:
  6   hard:
  7     configmaps: "10"
  8     persistentvolumeclaims: "4"
  9     replicationcontrollers: "20"
 10     secrets: "10"
 11     services: "10"
 12     services.loadbalancers: "2"
 13 

[root@k8smaster01 study]# kubectl create -f object-counts.yaml --namespace=myspace

[root@k8smaster01 study]# kubectl describe quota compute-resources --namespace=myspace

[root@k8smaster01 study]# kubectl describe quota object-counts --namespace=myspace

5.7 资源配额与集群资源总量的关系

资源配额与集群资源总量是完全独立的。资源配额是通过绝对的单位来配置的，这也就意味着如果在集群中新添加了节点，那么资源配额不会自动更新，而该资源配额所对应的命名空间中的对象也不能自动增加资源上限。在某些情况下，可能希望资源配额支持更复杂的策略，如下所述。

• 对于不同的租户，按照比例划分整个集群的资源。
• 允许每个租户都能按照需要来提高资源用量，但是有一个较宽容的限制，以防止意外的资源耗尽情况发生。
• 探测某个命名空间的需求，添加物理节点并扩大资源配额值。

这些策略可以通过将资源配额作为一个控制模块、手动编写一个控制器来监控资源使用情况，并调整命名空间上的资源配额来实现。资源配额将整个集群中的资源总量做了一个静态划分，但它并没有对集群中的节点做任何限制：不同命名空间中的pod仍然可以运行在同一个节点上。

参考链接：https://blog.csdn.net/dkfajsldfsdfsd/article/details/81004172