How to Create a Resource Quota for CPU and Memory in Kubernetes

Introduction

Kubernetes Resource Quotas are a powerful feature that allow you to set limits on the amount of resources (such as CPU, memory, storage, etc.) that can be consumed by a namespace or a set of pods. This is particularly useful in multi-tenant environments where you want to ensure that one tenant does not monopolize all the available resources, leaving other tenants without the resources they need.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL kubernetes(("`Kubernetes`")) -.-> kubernetes/TroubleshootingandDebuggingCommandsGroup(["`Troubleshooting and Debugging Commands`"]) kubernetes(("`Kubernetes`")) -.-> kubernetes/BasicCommandsGroup(["`Basic Commands`"]) kubernetes(("`Kubernetes`")) -.-> kubernetes/AdvancedCommandsGroup(["`Advanced Commands`"]) kubernetes(("`Kubernetes`")) -.-> kubernetes/ConfigurationandVersioningGroup(["`Configuration and Versioning`"]) kubernetes/TroubleshootingandDebuggingCommandsGroup -.-> kubernetes/describe("`Describe`") kubernetes/BasicCommandsGroup -.-> kubernetes/create("`Create`") kubernetes/BasicCommandsGroup -.-> kubernetes/get("`Get`") kubernetes/BasicCommandsGroup -.-> kubernetes/delete("`Delete`") kubernetes/AdvancedCommandsGroup -.-> kubernetes/apply("`Apply`") kubernetes/ConfigurationandVersioningGroup -.-> kubernetes/config("`Config`") subgraph Lab Skills kubernetes/describe -.-> lab-415075{{"`How to Create a Resource Quota for CPU and Memory in Kubernetes`"}} kubernetes/create -.-> lab-415075{{"`How to Create a Resource Quota for CPU and Memory in Kubernetes`"}} kubernetes/get -.-> lab-415075{{"`How to Create a Resource Quota for CPU and Memory in Kubernetes`"}} kubernetes/delete -.-> lab-415075{{"`How to Create a Resource Quota for CPU and Memory in Kubernetes`"}} kubernetes/apply -.-> lab-415075{{"`How to Create a Resource Quota for CPU and Memory in Kubernetes`"}} kubernetes/config -.-> lab-415075{{"`How to Create a Resource Quota for CPU and Memory in Kubernetes`"}} end

Understanding Kubernetes Resource Quotas

In Kubernetes, a resource quota is defined as a set of constraints that limit the total amount of resources that can be consumed by all the objects (such as pods, services, and persistent volume claims) within a namespace. This ensures that no single tenant can exhaust all the available resources, and that resources are distributed fairly among the different tenants.

graph TD A[Namespace] --> B[Resource Quota] B --> C[CPU Limit] B --> D[Memory Limit] B --> E[Storage Limit] B --> F[Object Count Limit]

The main use cases for Kubernetes Resource Quotas include:

Enforcing Resource Limits: Ensuring that a namespace or a set of pods does not consume more resources than the allocated limits, preventing resource starvation for other tenants.
Controlling Resource Allocation: Allocating resources based on the specific needs of each tenant, ensuring fair distribution and efficient utilization of cluster resources.
Preventing Resource Exhaustion: Preventing a single tenant from consuming all the available resources, leaving other tenants without the resources they need.
Monitoring Resource Usage: Tracking the resource usage of each namespace or set of pods, allowing for better resource management and planning.

To configure a resource quota, you can create a ResourceQuota object in your Kubernetes cluster. Here's an example:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-resources
  namespace: default
spec:
  hard:
    requests.cpu: "1"
    requests.memory: 1Gi
    limits.cpu: "2"
    limits.memory: 2Gi

In this example, we are setting a resource quota for the default namespace, which limits the total CPU requests to 1 core, the total memory requests to 1 GiB, the total CPU limits to 2 cores, and the total memory limits to 2 GiB.

Configuring Resource Quota Limits for CPU and Memory

When configuring resource quotas in Kubernetes, one of the most important aspects is setting appropriate limits for CPU and memory. These limits ensure that your workloads do not consume more resources than they are allowed, preventing resource starvation for other tenants in your cluster.

To configure CPU and memory limits for a resource quota, you can use the following parameters in the ResourceQuota object:

requests.cpu: The total amount of CPU requests that can be made across all pods in the namespace.
requests.memory: The total amount of memory requests that can be made across all pods in the namespace.
limits.cpu: The total amount of CPU limits that can be set across all pods in the namespace.
limits.memory: The total amount of memory limits that can be set across all pods in the namespace.

Here's an example of a resource quota that sets limits for CPU and memory:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-resources
  namespace: default
spec:
  hard:
    requests.cpu: "2" 
    requests.memory: 4Gi
    limits.cpu: "4"
    limits.memory: 8Gi

In this example, we are setting the following limits:

Total CPU requests across all pods in the namespace: 2 cores
Total memory requests across all pods in the namespace: 4 GiB
Total CPU limits across all pods in the namespace: 4 cores
Total memory limits across all pods in the namespace: 8 GiB

It's important to note that these limits apply to the entire namespace, not to individual pods. This means that the sum of the CPU and memory requests/limits of all pods in the namespace must not exceed the quota limits.

When setting these limits, you should carefully consider the resource requirements of your workloads and the overall capacity of your Kubernetes cluster. Overestimating the limits can lead to inefficient resource utilization, while underestimating the limits can result in resource starvation and performance issues for your applications.

Applying and Managing Resource Quotas

Once you have defined your resource quota, you can apply it to your Kubernetes cluster using the kubectl command-line tool. Here's an example of how to create a resource quota:

kubectl create -f resource-quota.yaml

Where resource-quota.yaml is the file containing the resource quota definition.

After applying the resource quota, you can use the following commands to manage and monitor it:

## List all resource quotas in a namespace
kubectl get resourcequota -n <namespace>

## Describe a specific resource quota
kubectl describe resourcequota <quota-name> -n <namespace>

## View the current resource usage for a namespace
kubectl describe namespace <namespace>

The describe commands will provide detailed information about the resource quota, including the current usage and limits.

You can also update an existing resource quota by modifying the YAML file and applying the changes:

kubectl apply -f resource-quota.yaml

This will update the resource quota with the new configuration.

It's important to note that resource quotas are enforced at the namespace level. This means that if a pod or a set of pods in a namespace exceeds the resource quota limits, Kubernetes will not allow the creation or scaling of those pods. Instead, it will return an error message indicating that the resource quota has been exceeded.

To ensure that your applications can still function within the resource quota limits, you should carefully plan the resource requests and limits for your pods. You can use the LimitRange object to set default and maximum resource limits for a namespace, which can help ensure that your pods stay within the resource quota.

By effectively applying and managing resource quotas, you can ensure that your Kubernetes cluster resources are distributed fairly and efficiently among your tenants, preventing resource starvation and improving the overall stability and performance of your applications.

Summary

In this tutorial, you'll learn how to configure a Kubernetes Resource Quota to limit the CPU and memory usage within a namespace. By setting these resource limits, you can ensure fair distribution of resources among different tenants and prevent resource exhaustion. You'll also learn how to apply and manage resource quotas in your Kubernetes cluster.