How to configure a ResourceQuota to limit CPU and memory in a Kubernetes namespace?

Introduction

Kubernetes, the popular open-source container orchestration platform, provides a powerful feature called Resource Quotas to help you manage and control the resources used by your applications. In this tutorial, we will guide you through the process of configuring a Resource Quota to limit the CPU and memory usage within a Kubernetes namespace.

Skills Graph

Understanding Resource Quotas in Kubernetes

Kubernetes is a powerful container orchestration platform that helps manage and scale applications in a distributed environment. One of the key features in Kubernetes is the concept of Resource Quotas, which allows you to set limits on the amount of resources (such as CPU and memory) that can be consumed by a namespace.

What is a Resource Quota?

A Resource Quota is a set of constraints that can be applied to a Kubernetes namespace to limit the total amount of resources that can be consumed by all the pods and containers within that namespace. This helps prevent a single namespace from monopolizing all the available resources in the cluster, ensuring fair and efficient resource utilization.

Why Use Resource Quotas?

Resource Quotas are essential for managing resource allocation in a Kubernetes cluster, especially in multi-tenant environments where multiple teams or applications share the same cluster. Some key benefits of using Resource Quotas include:

1. Fairness and Isolation: Resource Quotas ensure that each namespace has a fair share of the cluster's resources, preventing a single namespace from consuming all available resources and impacting other applications.
2. Predictable Resource Usage: By setting resource limits, you can ensure that your applications have a predictable amount of resources available, which is crucial for performance and reliability.
3. Cost Optimization: Resource Quotas help you optimize your cloud infrastructure costs by preventing over-provisioning and ensuring that resources are used efficiently.
4. Enforcement and Automation: Resource Quotas can be automatically enforced by Kubernetes, ensuring that resource usage stays within the defined limits without manual intervention.

Resource Quota Scope

Resource Quotas can be applied to different types of resources, including:

• Compute Resources: CPU and memory
• Storage Resources: Persistent volume claims (PVCs) and storage classes
• Object Counts: The number of different Kubernetes objects, such as services, secrets, and configmaps

You can configure Resource Quotas to set limits on these resources, ensuring that your namespace stays within the defined constraints.

Configuring Resource Quota Limits for CPU and Memory

Defining CPU and Memory Limits

To configure a Resource Quota for CPU and memory limits, you need to create a YAML file that defines the desired constraints. Here's an example:

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

In this example, the Resource Quota sets the following limits:

• Requests:
  • CPU: 1 core
  • Memory: 1 gigabyte
• Limits:
  • CPU: 2 cores
  • Memory: 2 gigabytes

These limits apply to the entire namespace, ensuring that the total resource consumption across all pods and containers does not exceed the specified values.

Understanding Requests and Limits

In Kubernetes, each container can specify two types of resource constraints:

1. Requests: The minimum amount of resources (CPU and memory) that the container needs to run.
2. Limits: The maximum amount of resources (CPU and memory) that the container can use.

When you define a Resource Quota, you can set limits for both requests and limits, as shown in the example above.

Applying Resource Quota to Pods

Once you have defined the Resource Quota, Kubernetes will automatically enforce the limits on any new pods or containers created in the namespace. If a pod or container exceeds the specified limits, Kubernetes will prevent it from being scheduled or will terminate the pod.

Here's an example of a pod that respects the Resource Quota limits:

apiVersion: v1
kind: Pod
metadata:
  name: my-app
  namespace: example-namespace
spec:
  containers:
    - name: my-container
      image: my-app:v1
      resources:
        requests:
          cpu: 500m
          memory: 256Mi
        limits:
          cpu: 1
          memory: 1Gi

In this example, the pod's container requests 500 millicores of CPU and 256 megabytes of memory, and has a limit of 1 core of CPU and 1 gigabyte of memory, which are within the Resource Quota limits defined earlier.

Applying Resource Quota to a Namespace

Creating a Resource Quota

To apply a Resource Quota to a Kubernetes namespace, you need to create a ResourceQuota object and apply it to the target namespace. Here's an example:

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

In this example, we're creating a ResourceQuota object named compute-resources and applying it to the example-namespace namespace. The Resource Quota sets the following limits:

• CPU requests: 1 core
• Memory requests: 1 gigabyte
• CPU limits: 2 cores
• Memory limits: 2 gigabytes

To apply the Resource Quota, you can use the kubectl command:

kubectl apply -f resource-quota.yaml

This will create the Resource Quota in the specified namespace.

Verifying Resource Quota Usage

After applying the Resource Quota, you can verify the current usage and limits by running the following command:

kubectl get resourcequota compute-resources -n example-namespace --output=yaml

This will output the current status of the Resource Quota, including the used and remaining resources.

apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-resources
  namespace: example-namespace
status:
  hard:
    limits.cpu: "2"
    limits.memory: 2Gi
    requests.cpu: "1"
    requests.memory: 1Gi
  used:
    limits.cpu: "1"
    limits.memory: 512Mi
    requests.cpu: "500m"
    requests.memory: 256Mi

In this example, you can see that the namespace is currently using 500 millicores of CPU requests, 256 megabytes of memory requests, 1 core of CPU limits, and 512 megabytes of memory limits, which are within the defined Resource Quota limits.

Enforcing Resource Quota

Once the Resource Quota is applied, Kubernetes will automatically enforce the limits on any new pods or containers created in the namespace. If a pod or container exceeds the specified limits, Kubernetes will prevent it from being scheduled or will terminate the pod.

By using Resource Quotas, you can ensure that your Kubernetes namespace stays within the defined resource limits, promoting fairness and efficient resource utilization across your cluster.

Summary

By the end of this Kubernetes tutorial, you will have learned how to set up a Resource Quota to limit the CPU and memory resources used by your applications in a specific namespace. This will help you optimize resource allocation, prevent resource exhaustion, and ensure the efficient use of your Kubernetes cluster resources.