Resources

This section continues from the previous section - make sure you do the tutorial in sequence.
Deployment
Default Configuration
You can specify the computing resource needs for each of the containers. By default, each container is given 10% of a CPU and no memory use restrictions.
The defaults can cause issues:
If a Node has 1 full CPU, then Kubernetes may schedule up to 10 instances of the same container, which may overload the system.
If a Node has 16GB of RAM, and without memory restriction, then each container instance (JVM) may think they each can use up to 16GB, causing memory overuse (and thus, virtual memory swapping, etc)
You can see the current resource by describing a Pod instance, look for the Requests/Limits lines.
1
POD_NAME=$(kubectl get pods -lapp=helloworld -o jsonpath='{.items[0].metadata.name}')
2
​
3
kubectl describe pod $POD_NAME
Copied!
The details should have a Requests section with cpu value set to 100m:
1
Name:           helloworld-...
2
Namespace:      default...
3
Containers:
4
  helloworld:
5
    ...
6
    Requests:
7
      cpu:  100m
8
...
Copied!
The default value is 100m, which means 100 milli = 100/1000 = 10%of a vCPU core.
The default is configured per Namespace. The application was deployed into the default Namespace. Look at the default resource configuration for this Namespace:
1
kubectl describe ns default
Copied!
See the output:
1
Name:         default
2
Labels:       <none>
3
Annotations:  <none>
4
Status:       Active
5
​
6
Resource Quotas
7
 Name:                       gke-resource-quotas
8
 Resource                    Used  Hard
9
 --------                    ---   ---
10
 count/ingresses.extensions  1     100
11
 count/jobs.batch            0     5k
12
 pods                        3     1500
13
 services                    2     500
14
​
15
Resource Limits
16
 Type       Resource  Min  Max  Default Request  Default Limit  Max Limit/Request Ratio
17
 ----       --------  ---  ---  ---------------  -------------  -----------------------
18
 Container  cpu       -    -    100m             -              -
Copied!
However, the configuration is actually stored in a LimitRange Kubernetes resource:
1
kubectl get limitrange limits -oyaml
Copied!
The default can be updated. See Configure Default CPU Requests and Limits for a Namespace documentation.
Resource Request
In Kubernetes, you can reserve capacity by setting the Resource Requests to reserve more CPU and memory. Configure the deployment to reserve at least 20% of a CPU, and 128Mi of RAM.
k8s/deployment.yaml
1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  labels:
5
    app: helloworld
6
  name: helloworld
7
spec:
8
  replicas: 1
9
  selector:
10
    matchLabels:
11
      app: helloworld
12
  template:
13
    metadata:
14
      labels:
15
        app: helloworld
16
    spec:
17
      containers:
18
      - image: gcr.io/.../helloworld
19
        name: helloworld
20
        # Add the resources requests block
21
        resources:
22
          requests:
23
            cpu: 200m
24
            memory: 128Mi
Copied!
In this example, CPU request is 200m which means 200 milli=200/1000 = 20% of 1 vCPU core.
Memory is 128Mi, which is 128 Mebibytes = ~134 Megabytes.
See Kubernetes Resource Units documentation for the units descriptions such as m, M, and Mi.
When specifying the Memory resource allocation, do not accidentally use m as the unit. 128m means 0.128 bytes.
Resource Limit
The application can consume more CPU and memory than requested - it can burst up to the limit, but cannot exceed the limit. Configure the deployment to set the limit:
k8s/service.yaml
1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  labels:
5
    app: helloworld
6
  name: helloworld
7
spec:
8
  replicas: 1
9
  selector:
10
    matchLabels:
11
      app: helloworld
12
  template:
13
    metadata:
14
      labels:
15
        app: helloworld
16
    spec:
17
      containers:
18
      - image: gcr.io/.../helloworld
19
        name: helloworld
20
        # Add the resources requests block
21
        resources:
22
          requests:
23
            cpu: 200m
24
            memory: 256Mi
25
          limits:
26
            cpu: 500m
27
            memory: 256Mi
Copied!
CPU limit is a compressible resource. If the application exceeds the CPU limit, it'll simply be throttled, and thus capping the latency and throughput.
Memory is not a compressible resource. If the application exceeds the Memory limit, then the container will be killed (OOMKilled) and restarted.
For Java applications, read the Container Awareness section to make sure you are using a Container-Aware OpenJDK version to avoid unnecessary OOMKilled errors.

Deployment

Service

Last modified 1yr ago

Copy link

Contents

Default Configuration

Resource Request

Resource Limit