在k8s中使用Namespaces

使用Namespaces

文章预览：

• • 使用Namespaces
  • • 创建
    • 删除
    • 查看
  • 在namespace配置pod配额
  • 为namespace中配置默认的cpu请求和限额
  • 在namespace中配置默认的内存请求和限额
  • 为namespace设置最小和最大内存限制
  • 为namespace配置cpu和内存配置
  • 为namespace配置最小和最大cpu限制

创建

#通过命令行直接创建
$ 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

注意：

1. 删除一个namespace会自动删除所有属于该namespace的资源。
2. default和kube-system命名空间不可删除。
3. PersistentVolumes是不属于任何namespace的，但PersistentVolumeClaim是属于某个特定namespace的。
4. 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