使用Namespaces
文章预览：
创建
#通过命令行直接创建
$ kubectl create namespace new-namespace
# 通过文件创建
$ cat my-namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
name: new-namespace
$ kubectl create -f ./my-namespace.yaml
注意：命名空间名称满足正则表达式a-z0-9?,最大长度为63位
删除
$ kubectl delete namespaces new-namespace
注意：
- 删除一个namespace会自动删除所有属于该namespace的资源。
- default和kube-system命名空间不可删除。
- PersistentVolumes是不属于任何namespace的，但PersistentVolumeClaim是属于某个特定namespace的。
- Events是否属于namespace取决于产生events的对象。
查看
# 列出群集中的当前的Namespace
$ kubectl get namespaces
NAME STATUS AGE
default Active 1d
kube-system Active 1d
Kubernetes从两个初始的Namespace开始：
- default
- kube-system 由Kubernetes系统创建的对象的Namespace
在namespace配置pod配额
1.创建一个单独的名字空间，以便于隔离在本练习中创建的资源和集群的其他资源
kubectl create namespace quota-pod-example
2.创建resourceQueta对象
quota-pod.yaml
apiVersion: v1
kind: ResourceQuota
metadata:
name: pod-demo
spec:
hard:
pods: "2"
下面，首先创建ResourceQuota对象
kubectl create -f ./quota-pod.yaml --namespace=quota-pod-example
然后可以通过以下命令查看ResourceQuota对象的详细信息：
kubectl get resourcequota pod-demo --namespace=quota-pod-example --output=yaml
命令输出显示了这个名字空间的Pod配额是2，由于目前没有Pod运行，所有配额并没有被使用。
spec:
hard:
pods: "2"
status:
hard:
pods: "2"
used:
pods: "0"
下面展示的是一个Deployment的配置文件：
quota-pod-deployment.yaml
apiVersion: apps/v1beta1
kind: Deployment
metadata:
name: pod-quota-demo
spec:
replicas: 3
template:
metadata:
labels:
purpose: quota-demo
spec:
containers:
- name: pod-quota-demo
image: nginx
从配置文件可以看到，replicas: 3将令Kubernetes尝试创建3个Pod，所有的Pod实例都将运行同样的应用程序。
接下来尝试创建这个Deployment：
kubectl create -f ./quota-pod-deployment.yaml --namespace=quota-pod-example
并通过以下命令查看Deployment的详细信息：
kubectl get deployment pod-quota-demo --namespace=quota-pod-example --output=yaml
从命令输出可以看到尽管在Deployment中我们设置了需要启动3个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
为namespace中配置默认的cpu请求和限额
1.创建一个命名空间
kubectl create namespace default-cpu-example
2.创建一个LimitRange和一个Pod
cpu-defaults.yaml
apiVersion: v1
kind: LimitRange
metadata:
name: cpu-limit-range
spec:
limits:
- default:
cpu: 1
defaultRequest:
cpu: 0.5
type: Container
在这个defaule-cpu-example命名空间中创建这个LimitRange:
kubectl create -f ./cpu-defaults.yaml --namespace=default-cpu-example
现在如果在这个defaule-cpu-example命名空间中创建一个容器，则该容器不需要指定它自己的CPU请求和CPU限额， 该容器会被赋予一个默认的CPU请求值0.5和一个默认的CPU限额值1
cpu-defaults-pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: default-cpu-demo
spec:
containers:
- name: default-cpu-demo-ctr
image: nginx
3.创建Pod
kubectl create -f ./cpu-defaults-pod.yaml --namespace=default-cpu-example
4.查看该Pod的配置：
kubectl get pod default-cpu-demo --output=yaml --namespace=default-cpu-example
输出显示该Pod的容器含有一个CPU请求值500m和一个CPU限额值1。 这些是由LimitRange指定的默认值。
containers:
- image: nginx
imagePullPolicy: Always
name: default-cpu-demo-ctr
resources:
limits:
cpu: "1"
requests:
cpu: 500m
如果你指定了一个容器的限额值，但未指定请求值，会发生什么？
以下是一个含有一个容器的Pod的配置文件。该容器指定了一个CPU限额，但未指定请求：
cpu-defaults-pod-2.yaml
apiVersion: v1
kind: Pod
metadata:
name: default-cpu-demo-2
spec:
containers:
- name: default-cpu-demo-2-ctr
image: nginx
resources:
limits:
cpu: "1"
创建该Pod:
kubectl create -f ./cpu-defaults-pod-2.yaml --namespace=default-cpu-example
查看该Pod的配置：
kubectl get pod cpu-limit-no-request --output=yaml --namespace=default-cpu-example
输出展示该容器的CPU请求值与它的限额值相等。
注意该容器并未被赋予这个默认的CPU请求值0.5。
resources:
limits:
cpu: "1"
requests:
cpu: "1"
如果你指定了一个容器的请求值，未指定限额值，会发生什么？
以下是含有一个容器的Pod的配置文件。该容器指定了一个CPU请求，但未指定一个限额：
cpu-defaults-pod-3.yaml
apiVersion: v1
kind: Pod
metadata:
name: default-cpu-demo-3
spec:
containers:
- name: default-cpu-demo-3-ctr
image: nginx
resources:
requests:
cpu: "0.75"
创建该Pod
kubectl create -f https://k8s.io/docs/tasks/administer-cluster/cpu-defaults-pod-3.yaml --namespace=default-cpu-example
输出显示该容器的CPU请求值被设置为该容器配置文件中指定的值。该容器的CPU限额设置为1，这是该命名空间的默认CPU的限额值。
resources:
limits:
cpu: "1"
requests:
cpu: 750m
在namespace中配置默认的内存请求和限额
1.创建一个命名空间，以便您在本练习中创建的资源与集群的其它部分相隔离。
kubectl create namespace default-mem-example
创建 LimitRange 和 Pod
以下是一个 LimitRange 对象的配置文件。该配置指定了默认的内存请求与默认的内存限额。
memory-defaults.yaml
apiVersion: v1
kind: LimitRange
metadata:
name: mem-limit-range
spec:
limits:
- default:
memory: 512Mi
defaultRequest:
memory: 256Mi
type: Container
2.在 default-mem-example 命名空间中创建 LimitRange：
kubectl create -f ./memory-defaults.yaml --namespace=default-mem-example
现在如果在这个 default-mem-example 命名空间中创建一个容器，并且该容器未指定它自己的内存请求与内存限额， 该容器会被赋予默认的内存请求值 256MiB 和默认的内存限额值 512MiB。
以下是一个 Pod 的配置文件，它含有一个容器。这个容器没有指定内存请求和限额。
memory-defaults-pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: default-mem-demo
spec:
containers:
- name: default-mem-demo-ctr
image: nginx
3.创建 Pod:
kubectl create -f ./memory-defaults-pod.yaml --namespace=default-mem-example
查看关于该 Pod 的详细信息：
kubectl get pod default-mem-demo --output=yaml --namespace=default-mem-example
输出显示该 Pod 的容器的内存请求值是 256MiB, 内存限额值是 512MiB. 这些是由 LimitRange 指定的默认值。
containers:
- image: nginx
imagePullPolicy: Always
name: default-mem-demo-ctr
resources:
limits:
memory: 512Mi
requests:
memory: 256Mi
4.删除 Pod:
kubectl delete pod default-mem-demo --namespace=default-mem-example
如果您指定了容器的限额值，但未指定请求值，会发生什么？
以下是含有一个容器的 Pod 的配置文件。该容器指定了内存限额，但未指定请求：
memory-defaults-pod-2.yaml
apiVersion: v1
kind: Pod
metadata:
name: default-mem-demo-2
spec:
containers:
- name: defalt-mem-demo-2-ctr
image: nginx
resources:
limits:
memory: "1Gi"
创建 Pod:
kubectl create -f ./memory-defaults-pod-2.yaml --namespace=default-mem-example
查看关于该 Pod 的详细信息：
kubectl get pod mem-limit-no-request --output=yaml --namespace=default-mem-example
输出显示该容器的内存请求值与它的限额值相等。
注意该容器并未被赋予默认的内存请求值 256MiB。
resources:
limits:
memory: 1Gi
requests:
memory: 1Gi
如果您指定了容器的请求值，但未指定限额值，会发生什么？
以下是含有一个容器的 Pod 的配置文件。该容器指定了内存请求，但未指定限额：
memory-defaults-pod-3.yaml
apiVersion: v1
kind: Pod
metadata:
name: default-mem-demo-3
spec:
containers:
- name: default-mem-demo-3-ctr
image: nginx
resources:
requests:
memory: "128Mi"
创建该 Pod:
kubectl create -f ./memory-defaults-pod-3.yaml --namespace=default-mem-example
查看该 Pod 的配置信息：
kubectl get pod default-mem-request-no-limit --output=yaml --namespace=default-mem-example
输出显示该容器的内存请求值被设置为该容器配置文件中指定的值。该容器的内存限额设置为 512Mi，这是该命名空间的默认内存限额值。
resources:
limits:
memory: 512Mi
requests:
memory: 128Mi
为namespace设置最小和最大内存限制
1.创建namespace
kubectl create namespace constraints-mem-example
2.创建一个 LimitRange 和一个 Pod
这是 LimitRange 的配置文件：
memory-constraints.yaml
apiVersion: v1
kind: LimitRange
metadata:
name: mem-min-max-demo-lr
spec:
limits:
- max:
memory: 1Gi
min:
memory: 500Mi
type: Container
3.创建 LimitRange:
kubectl create -f 。/memory-constraints.yaml --namespace=constraints-mem-example
查看 LimitRange 的详细信息：
kubectl get limitrange cpu-min-max-demo --namespace=constraints-mem-example --output=yaml
输出显示了符合预期的最小和最大内存限制。但请注意，即使您没有在配置文件中为 LimitRange 指定默认值，它们也会被自动创建。
limits:
- default:
memory: 1Gi
defaultRequest:
memory: 1Gi
max:
memory: 1Gi
min:
memory: 500Mi
type: Container
现在，每当在 constraints-mem-example namespace 中创建一个容器时，Kubernetes 都会执行下列步骤：
- 如果容器没有指定自己的内存请求（request）和限制（limit），系统将会为其分配默认值。
- 验证容器的内存请求大于等于 500 MiB。
- 验证容器的内存限制小于等于 1 GiB。
这是一份包含一个容器的 Pod 的配置文件。这个容器的配置清单指定了 600 MiB 的内存请求和 800 MiB 的内存限制。这些配置符合 LimitRange 施加的最小和最大内存限制。
memory-constraints-pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-mem-demo
spec:
containers:
- name: constraints-mem-demo-ctr
image: nginx
resources:
limits:
memory: "800Mi"
requests:
memory: "600Mi"
4.创建 Pod：
kubectl create -f ./memory-constraints-pod.yaml --namespace=constraints-mem-example
验证 Pod 的容器是否运行正常：
kubectl get pod constraints-mem-demo --namespace=constraints-mem-example
查看关于 Pod 的详细信息：
kubectl get pod constraints-mem-demo --output=yaml --namespace=constraints-mem-example
输出显示了容器的内存请求为 600 MiB，内存限制为 800 MiB。这符合 LimitRange 施加的限制。
resources:
limits:
memory: 800Mi
requests:
memory: 600Mi
5.删除 Pod：
kubectl delete pod constraints-mem-demo --namespace=constraints-mem-example
尝试创建一个超过最大内存限制的 Pod
这是一份包含一个容器的 Pod 的配置文件。这个容器的配置清单指定了 800 MiB 的内存请求和 1.5 GiB 的内存限制。
memory-constraints-pod-2.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-mem-demo-2
spec:
containers:
- name: constraints-mem-demo-2-ctr
image: nginx
resources:
limits:
memory: "1.5Gi"
requests:
memory: "800Mi"
尝试创建 Pod：
kubectl create -f ./memory-constraints-pod-2.yaml --namespace=constraints-mem-example
输出显示 Pod 没有能够成功创建，因为容器指定的内存限制值太大：
Error from server (Forbidden): error when creating "docs/tasks/administer-cluster/memory-constraints-pod-2.yaml":
pods "constraints-mem-demo-2" is forbidden: maximum memory usage per Container is 1Gi, but limit is 1536Mi.
尝试创建一个不符合最小内存请求的 Pod
这是一份包含一个容器的 Pod 的配置文件。这个容器的配置清单指定了 200 MiB 的内存请求和 800 MiB 的内存限制。
memory-constraints-pod-3.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-mem-demo-3
spec:
containers:
- name: constraints-mem-demo-3-ctr
image: nginx
resources:
limits:
memory: "800Mi"
requests:
memory: "100Mi"
尝试创建 Pod：
kubectl create -f ./memory-constraints-pod-3.yaml --namespace=constraints-mem-example
输出显示 Pod 没有能够成功创建，因为容器指定的内存请求值太小：
Error from server (Forbidden): error when creating "docs/tasks/administer-cluster/memory-constraints-pod-3.yaml":
pods "constraints-mem-demo-3" is forbidden: minimum memory usage per Container is 500Mi, but request is 100Mi.
创建一个没有指定任何内存请求和限制的 Pod
这是一份包含一个容器的 Pod 的配置文件。这个容器没有指定内存请求，也没有指定内存限制。
memory-constraints-pod-4.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-mem-demo-4
spec:
containers:
- name: constraints-mem-demo-4-ctr
image: nginx
创建 Pod：
kubectl create -f ./memory-constraints-pod-4.yaml --namespace=constraints-mem-example
查看关于 Pod 的细节信息：
kubectl get pod constraints-mem-demo-4 --namespace=constraints-mem-example --output=yaml
输出显示 Pod 的容器具有 1 GiB 的内存请求和 1 GiB 的内存限制。容器是如何获取这些值的呢？
resources:
limits:
memory: 1Gi
requests:
memory: 1Gi
因为您的容器没有指定自己的内存请求和限制，它将从 LimitRange 获取 默认的内存请求和限制值
到目前为止，您的容器可能在运行，也可能没有运行。回想起来，有一个先决条件就是节点必须拥有至少 1 GiB 内存。如果每个节点都只有 1 GiB 内存，那么任何一个节点上都没有足够的内存来容纳 1 GiB 的内存请求。如果碰巧使用的节点拥有 2 GiB 内存，那么它可能会有足够的内存来容纳 1 GiB 的内存请求。
删除 Pod：
kubectl delete pod constraints-mem-demo-4 --namespace=constraints-mem-example
应用最小和最大内存限制
LimitRange 在 namespace 中施加的最小和最大内存限制只有在创建和更新 Pod 时才会被应用。改变 LimitRange 不会对之前创建的 Pod 造成影响。
最小和最大内存限制的动因
作为一个集群管理员，您可能希望为 Pod 能够使用的内存数量施加限制。例如：
- 集群中每个节点拥有 2 GB 内存。您不希望任何 Pod 请求超过 2 GB 的内存，因为集群中没有节点能支持这个请求。
- 集群被生产部门和开发部门共享。 您希望生产负载最多使用 8 GB 的内存而将开发负载限制为 512 MB。这种情况下，您可以为生产环境和开发环境创建单独的 namespace，并对每个 namespace 应用内存限制。
删除 namespace：
kubectl delete namespace constraints-mem-example
为namespace配置cpu和内存配置
1.创建一个单独的名字空间，以便于隔离您在本练习中创建的资源与集群的其他资源。
kubectl create namespace quota-mem-cpu-example
2.创建ResourceQuota对象
以下展示了ResourceQuota对象的配置文件内容：
quota-mem-cpu.yaml
apiVersion: v1
kind: ResourceQuota
metadata:
name: mem-cpu-demo
spec:
hard:
requests.cpu: "1"
requests.memory: 1Gi
limits.cpu: "2"
limits.memory: 2Gi
3.ResourceQuota对象
kubectl create -f ./quota-mem-cpu.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名字空间中添加以下限制：
- 每个容器必须设置内存请求（memory request），内存限额（memory limit），cpu请求（cpu request）和cpu限额（cpu limit）。
- 所有容器的内存请求总额不得超过1 GiB。
- 所有容器的内存限额总额不得超过2 GiB。
- 所有容器的CPU请求总额不得超过1 CPU。
- 所有容器的CPU限额总额不得超过2 CPU。
4.创建一个Pod
以下展示了一个Pod的配置文件内容：
quota-mem-cpu-pod.yaml
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 create -f ./quota-mem-cpu-pod.yaml --namespace=quota-mem-cpu-example
运行以下命令验证这个Pod的容器已经运行：
kubectl get pod quota-mem-cpu-demo --namespace=quota-mem-cpu-example
然后再次查看ResourceQuota对象的详细信息：
kubectl get resourcequota mem-cpu-demo --namespace=quota-mem-cpu-example --output=yaml
除了配额本身信息外，上述命令还显示了目前配额中有多少已经被使用。可以看到，刚才创建的Pod的内存以及 CPU的请求和限额并没有超出配额。
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的配置文件如下所示：
quota-mem-cpu-pod-2.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的内存请求是700 MiB。可以注意到，如果创建第二个Pod, 目前的内存使用量加上新的内存请求已经超出了当前名字空间的内存请求配额。即600 MiB + 700 MiB > 1 GiB。
下面尝试创建第二个Pod：
kubectl create -f https://k8s.io/docs/tasks/administer-cluster/quota-mem-cpu-pod-2.yaml --namespace=quota-mem-cpu-example
以下命令输出显示第二个Pod并没有创建成功。错误信息说明了如果创建第二个Pod，内存请求总额将超出名字空间的内存请求配额。
Error from server (Forbidden): error when creating "docs/tasks/administer-cluster/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
通过删除名字空间即可完成环境清理：
kubectl delete namespace quota-mem-cpu-example
为namespace配置最小和最大cpu限制
1.创建一个namespace
kubectl create namespace constraints-cpu-example
2.创建一个 LimitRange 和一个 Pod
这是 LimitRange 的配置文件：
cpu-constraints.yaml
apiVersion: v1
kind: LimitRange
metadata:
name: cpu-min-max-demo-lr
spec:
limits:
- max:
cpu: "800m"
min:
cpu: "200m"
type: Container
3.创建 LimitRange:
kubectl create -f ./cpu-constraints.yaml --namespace=constraints-cpu-example
查看 LimitRange 的详细信息：
kubectl get limitrange cpu-min-max-demo-lr --output=yaml --namespace=constraints-cpu-example
输出显示了符合预期的最小和最大 CPU 限制。但请注意，即使您没有在配置文件中为 LimitRange 指定默认值，它们也会被自动创建。
limits:
- default:
cpu: 800m
defaultRequest:
cpu: 800m
max:
cpu: 800m
min:
cpu: 200m
type: Container
现在，每当在 constraints-cpu-example namespace 中创建一个容器时，Kubernetes 都会执行下列步骤：
- 如果容器没有指定自己的 CPU 请求（CPU request）和限制（CPU limit），系统将会为其分配默认值。
- 验证容器的 CPU 请求大于等于 200 millicpu。
- 验证容器的 CPU 限制小于等于 800 millicpu。
这是一份包含一个容器的 Pod 的配置文件。这个容器的配置清单指定了 500 millicpu 的 CPU 请求和 800 millicpu 的 CPU 限制。这些配置符合 LimitRange 施加的最小和最大 CPU 限制。
cpu-constraints-pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-cpu-demo
spec:
containers:
- name: constraints-cpu-demo-ctr
image: nginx
resources:
limits:
cpu: "800m"
requests:
cpu: "500m"
4.创建 Pod：
kubectl create -f ./cpu-constraints-pod.yaml --namespace=constraints-cpu-example
验证 Pod 的容器是否运行正常：
kubectl get pod constraints-cpu-demo --namespace=constraints-cpu-example
查看关于 Pod 的详细信息：
kubectl get pod constraints-cpu-demo --output=yaml --namespace=constraints-cpu-example
输出显示了容器的 CPU 请求为 500 millicpu，CPU 限制为 800 millicpu。这符合 LimitRange 施加的限制条件。
resources:
limits:
cpu: 800m
requests:
cpu: 500m
删除 Pod：
kubectl delete pod constraints-cpu-demo --namespace=constraints-cpu-example
尝试创建一个超过最大 CPU 限制的 Pod
这是一份包含一个容器的 Pod 的配置文件。这个容器的配置清单指定了 500 millicpu 的 CPU 请求和 1.5 cpu 的 CPU 限制。
cpu-constraints-pod-2.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-cpu-demo-2
spec:
containers:
- name: constraints-cpu-demo-2-ctr
image: nginx
resources:
limits:
cpu: "1.5"
requests:
cpu: "500m"
尝试创建 Pod：
kubectl create -f ./cpu-constraints-pod-2.yaml --namespace=constraints-cpu-example
输出显示 Pod 没有能够成功创建，因为容器指定的 CPU 限制值太大：
Error from server (Forbidden): error when creating "docs/tasks/administer-cluster/cpu-constraints-pod-2.yaml":
pods "constraints-cpu-demo-2" is forbidden: maximum cpu usage per Container is 800m, but limit is 1500m.
尝试创建一个不符合最小 CPU 请求的 Pod
这是一份包含一个容器的 Pod 的配置文件。这个容器的配置清单指定了 100 millicpu 的 CPU 请求和 800 millicpu 的 CPU 限制。
cpu-constraints-pod-3.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-cpu-demo-4
spec:
containers:
- name: constraints-cpu-demo-4-ctr
image: nginx
resources:
limits:
cpu: "800m"
requests:
cpu: "100m"
尝试创建 Pod：
kubectl create -f ./cpu-constraints-pod-3.yaml --namespace=constraints-cpu-example
输出显示 Pod 没有能够成功创建，因为容器指定的 CPU 请求值太小：
Error from server (Forbidden): error when creating "docs/tasks/administer-cluster/cpu-constraints-pod-3.yaml":
pods "constraints-cpu-demo-4" is forbidden: minimum cpu usage per Container is 200m, but request is 100m.
创建一个没有指定任何 CPU 请求和限制的 Pod
这是一份包含一个容器的 Pod 的配置文件。这个容器没有指定 CPU 请求，也没有指定 CPU 限制。
cpu-constraints-pod-4.yaml
apiVersion: v1
kind: Pod
metadata:
name: constraints-cpu-demo-4
spec:
containers:
- name: constraints-cpu-demo-4-ctr
image: vish/stress
创建 Pod：
kubectl create -f ./cpu-constraints-pod-4.yaml --namespace=constraints-cpu-example
查看关于 Pod 的详细信息：
kubectl get pod constraints-cpu-demo-4 --namespace=constraints-cpu-example --output=yaml
输出显示 Pod 的容器具有 800 millicpu 的 CPU 请求和 800 millicpu 的 CPU 限制。容器是如何获取这些值的呢？
resources:
limits:
cpu: 800m
requests:
cpu: 800m
因为您的容器没有指定自己的 CPU 请求和限制，所以它将从 LimitRange 获取 默认的 CPU 请求和限制值
到目前为止，您的容器可能在运行，也可能没有运行。回想起来，有一个先决条件就是节点必须至少拥有 1 CPU。如果每个节点都只有 1 CPU，那么任何一个节点上都没有足够的可用 CPU 来容纳 800 millicpu 的请求。如果碰巧使用的节点拥有 2 CPU，那么它可能会有足够的 CPU 来容纳 800 millicpu 的请求。
删除 Pod：
kubectl delete pod constraints-cpu-demo-4 --namespace=constraints-cpu-example
应用最小和最大 CPU 限制
LimitRange 在 namespace 中施加的最小和最大 CPU 限制只有在创建和更新 Pod 时才会被应用。改变 LimitRange 不会对之前创建的 Pod 造成影响。
最小和最大 CPU 限制的动因
作为一个集群管理员，您可能希望对 Pod 能够使用的 CPU 资源数量施加限制。例如：
- 集群中每个节点拥有 2 CPU。您不希望任何 Pod 请求超过 2 CPU 的资源，因为集群中没有节点能支持这个请求。
- 集群被生产部门和开发部门共享。 您希望生产负载最多使用 3 CPU 而将开发负载限制为 1 CPU。这种情况下，您可以为生产环境和开发环境创建单独的 namespace，并对每个 namespace 应用 CPU 限制。
删除 namespace：
kubectl delete namespace constraints-cpu-example