Kubernetes resource management

This is the 9th day of my participation in the November Gwen Challenge. Check out the event details: The last Gwen Challenge 2021.

Kubernetes resource management

We can specify resource configurations for pods through Requests and limits, but it’s a bit cumbersome to specify resource configurations for each Pod. We can use LimitRange to specify a global default configuration. In addition, with the ResourceQuota object, we can define resource quotas, which can provide an overall limit on resource usage for each namespace: it can limit the total number of objects of a certain type in the namespace, and it can set a total limit on computing resources that can be used by pods in the namespace.

LimitRange

Create a namespace before using LimitRange:

apiVersion: v1
kind: Namespace
metadata:
  name: test-resource
Copy the code

Then define the LimitRange configuration (limit-range.yml) :

apiVersion: v1
kind: LimitRange
metadata:
  name: limit-range-example
spec:
  limits:
    - max:
        cpu: 2
        memory: 2Gi
      min:
        cpu: 200m
        memory: 6Mi
      maxLimitRequestRatio:
        cpu: 3
        memory: 2
      type: Pod
    - default:
        cpu: 300m
        memory: 200Mi
      defaultRequest:
        cpu: 200m
        memory: 100Mi
      max:
        cpu: 2
        memory: 1Gi
      min:
        cpu: 100m
        memory: 3Mi
      maxLimitRequestRatio:
        cpu: 5
        memory: 4
      type: Container
Copy the code

Create this LimitRange:

You can see that the configuration has taken effect. The following describes the meanings of these configurations:

The configuration above is divided into Pod and Container configuration. Container resource configuration corresponds to resource configuration of each Docker Container, and Pod resource configuration corresponds to the sum of all Container resources in a Pod. Where Pod and Container can specify min, Max, and maxLimitRequestRatio:

1. min: Specifies the lower limit of resources. That is, the minimum resource configuration cannot be lower than this value.
2. max: Specifies the upper limit of resources, that is, the maximum resource usage cannot be higher than this value.
3. maxLimitRequestRatio: This value specifies the upper limit of the ratio of requests and limits values.

In contrast to Pod, containers can also specify defaultRequest and default:

1. defaultRequest: default for the global containerrequestsValue;
2. default: default for the global containerlimitsValue.

Here are a few examples to see if the LimitRange we created takes effect. Define a Pod configuration file (test-default.yml) :

apiVersion: v1
kind: Pod
metadata:
  name: test-default
spec:
  containers:
    - name: nginx
      image: nginx
      ports:
        - containerPort: 80
Copy the code

Create the Pod:

You can see that we don’t define requests and limits configurations in test-default.yml, but yaml of the Pod instance does specify these values, which are the default values we defined above in LimitRange.

Then define a new Pod configuration (test-max.yml) :

apiVersion: v1
kind: Pod
metadata:
  name: test-max
spec:
  containers:
    - name: nginx
      image: nginx
      ports:
        - containerPort: 80
      resources:
        limits:
          cpu: 3
          memory: 500Mi
Copy the code

Create the Pod:

As you can see, an error was reported at creation time because the CPU configuration exceeds the maximum CPU configuration of both the Container and Pod as defined in LimtRange.

Create a Pod configuration (test-ratio. Yml) :

apiVersion: v1
kind: Pod
metadata:
  name: test-ratio
spec:
  containers:
    - name: nginx
      image: nginx
      ports:
        - containerPort: 80
      resources:
        limits:
          cpu: 2
          memory: 500Mi
        requests:
          cpu: 300m
          memory: 50Mi
Copy the code

Create the Pod:

You can see that an error was also reported because the ratio of requests to limits does not match the maxLimitRequestRatio configuration for LimitRange.

LimitRange test: LimitRange test: LimitRange test: LimitRange test: LimitRange test: LimitRange test: LimitRange test: LimitRange test: LimitRange test

ResourceQuota

ResourceQuota is used to manage resource quotas, which can provide an overall resource usage limit for each namespace. Resource quotas are classified into the following types:

Computing Resource Quota

Storage Resource Quota

Object Quantity Quota

test

Let’s also create a namespace before testing ResourceQuota:

apiVersion: v1
kind: Namespace
metadata:
  name: quota-ns
Copy the code

Create a simple ResourceQuota configuration (test-quota.yml) :

apiVersion: v1
kind: ResourceQuota
metadata:
  name: test-quota
spec:
  hard:
    pods: "4"
Copy the code

Create this ResourceQuota:

Then define an RC configuration (nginx-rc.yml) :

apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx-rc
spec:
  replicas: 3
  selector:
    name: nginx
  template:
    metadata:
      labels:
        name: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
Copy the code

Create the RC:

As you can see, there are already three Pod instances. If you expand the number of pods to five, see what happens:

There will only be 4 Pod instances, because we specified a maximum of 4 pods in ResourceQuota above.