Resource quotas per namespace in Kubernetes - Commands & Configuration

Introduction

When many teams share the same Kubernetes cluster, some teams might use too many resources and leave none for others. Resource quotas help limit how much CPU, memory, and other resources each team can use in their own space, called a namespace.

When you want to make sure one team does not use all the CPU or memory in a shared cluster.

When you want to control how many pods or services a namespace can create to avoid overload.

When you want to track resource usage per project or team to plan capacity better.

When you want to prevent accidental resource hogging by limiting storage or load balancers.

When you want to enforce fair resource sharing in a multi-tenant Kubernetes environment.

Config File - resource-quota.yaml

resource-quota.yaml

apiVersion: v1
kind: ResourceQuota
metadata:
  name: example-quota
  namespace: example-namespace
spec:
  hard:
    pods: "10"
    requests.cpu: "4"
    requests.memory: "8Gi"
    limits.cpu: "8"
    limits.memory: "16Gi"
    persistentvolumeclaims: "5"

This file defines a ResourceQuota named example-quota in the example-namespace.

The hard section sets limits: maximum 10 pods, 4 CPUs requested, 8Gi memory requested, 8 CPUs limit, 16Gi memory limit, and 5 persistent volume claims allowed.

This ensures the namespace cannot use more resources than these limits.

Commands

This command creates the resource quota in the specified namespace to limit resource usage.

Terminal

kubectl apply -f resource-quota.yaml

Expected Output

resourcequota/example-quota created

This command lists all resource quotas in the example-namespace to verify the quota was created.

Terminal

kubectl get resourcequota -n example-namespace

Expected Output

NAME            AGE

example-quota   10s

→

-n - Specifies the namespace to look in

This command shows detailed information about the resource quota, including current usage and limits.

Terminal

kubectl describe resourcequota example-quota -n example-namespace

Expected Output

Name:            example-quota

Namespace:       example-namespace

Resource                   Used  Hard

--------                   ---   ----

pods                       0     10

requests.cpu               0     4

requests.memory            0     8Gi

limits.cpu                 0     8

limits.memory              0     16Gi

persistentvolumeclaims     0     5

→

-n - Specifies the namespace

Key Concept

If you remember nothing else from this pattern, remember: resource quotas limit how much CPU, memory, pods, and other resources a namespace can use to keep cluster resources fairly shared.

Common Mistakes

Applying a resource quota without specifying the correct namespace in the YAML file.

The quota will be created in the default namespace or wrong namespace, so it won't limit the intended namespace.

Always set the correct namespace under metadata.namespace in the resource quota YAML.

Setting resource limits in the quota but not setting matching requests and limits in pod specs.

Resource quota counts requests and limits; if pods don't specify them, quota enforcement may not work as expected.

Ensure pods specify resource requests and limits that align with the quota to enforce limits properly.

Not checking current usage with 'kubectl describe resourcequota' after applying quota.

You might miss that some resources are already over quota or that usage is near limits.

Use 'kubectl describe resourcequota' to monitor usage and adjust quotas as needed.

Summary

Create a resource quota YAML file specifying limits for CPU, memory, pods, and other resources in a namespace.

Apply the quota with 'kubectl apply -f' to enforce resource limits in that namespace.

Verify quota creation with 'kubectl get resourcequota' and check usage details with 'kubectl describe resourcequota'.

Practice

1. What is the main purpose of a ResourceQuota in a Kubernetes namespace?

easy

A. To limit the amount of resources like CPU and memory used in that namespace

B. To increase the CPU speed of all pods in the namespace

C. To delete unused pods automatically

D. To backup data stored in the namespace

Solution

1. Step 1: Understand ResourceQuota purpose

   A ResourceQuota sets limits on resource usage like CPU, memory, pods, and storage within a namespace.

2. Step 2: Compare options with purpose

   Only To limit the amount of resources like CPU and memory used in that namespace correctly describes limiting resource usage. Other options describe unrelated actions.

3. Final Answer:

   To limit the amount of resources like CPU and memory used in that namespace -> Option A

4. Quick Check:

   ResourceQuota limits resources = D [OK]

Hint: ResourceQuota controls resource limits per namespace [OK]

Common Mistakes:

• Thinking ResourceQuota speeds up pods
• Confusing quotas with backups
• Assuming quotas delete pods automatically

2. Which of the following is the correct YAML snippet to define a CPU limit of 2 cores in a ResourceQuota?

easy

A. hard:
limits.cpu: "2"

B. resources:
limits:
cpu: "2"

C. hard:
cpu: "2"

D. hard:
limits.cpu: 2

Solution

1. Step 1: Recall ResourceQuota syntax for limits

   ResourceQuota uses the hard field with resource names like limits.cpu as keys and string values.

2. Step 2: Check each option's syntax

   hard: limits.cpu: "2" correctly uses hard: with limits.cpu: "2". resources: limits: cpu: "2" uses wrong keys, C misses limits., D uses number instead of string.

3. Final Answer:

   hard: limits.cpu: "2" -> Option A

4. Quick Check:

   ResourceQuota hard limits use string values with resource keys [OK]

Hint: ResourceQuota limits use 'hard' with string values [OK]

Common Mistakes:

• Using numeric values instead of strings
• Omitting 'limits.' prefix in resource keys
• Placing limits under wrong YAML keys

3. Given this ResourceQuota YAML applied to namespace dev:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: dev-quota
  namespace: dev
spec:
  hard:
    pods: "3"
    requests.cpu: "1"
    requests.memory: "1Gi"

What happens if you try to create a 4th pod in dev namespace?

medium

A. The pod will be created normally without any error

B. The pod will be created but with limited CPU

C. The pod creation will fail due to exceeding the pod count quota

D. The pod will be created but memory will be limited to 1Gi

Solution

1. Step 1: Understand pod count limit in ResourceQuota

   The quota limits pods to 3 in the dev namespace.

2. Step 2: Effect of creating 4th pod

   Creating a 4th pod exceeds the pod count quota, so Kubernetes rejects the creation with an error.

3. Final Answer:

   The pod creation will fail due to exceeding the pod count quota -> Option C

4. Quick Check:

   Pod count quota exceeded = creation fails [OK]

Hint: Pod count quota blocks pods beyond limit [OK]

Common Mistakes:

• Assuming pod is created with limited resources
• Thinking quota only warns but allows creation
• Confusing CPU/memory limits with pod count

4. You applied this ResourceQuota YAML but it fails to create:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: test-quota
  namespace: test
spec:
  hard:
    cpu: "2"
    memory: "4Gi"

What is the likely error?

medium

A. Missing 'apiVersion' field

B. Namespace 'test' does not exist

C. Values should be numbers, not strings

D. Resource keys 'cpu' and 'memory' are invalid; should use 'limits.cpu' and 'limits.memory'

Solution

1. Step 1: Check resource keys in ResourceQuota

   ResourceQuota requires full resource names like limits.cpu or requests.memory, not just cpu or memory.

2. Step 2: Validate YAML fields

   API version is present, namespace existence is unrelated to syntax error, and values must be strings (which they are).

3. Final Answer:

   Resource keys 'cpu' and 'memory' are invalid; should use 'limits.cpu' and 'limits.memory' -> Option D

4. Quick Check:

   Use full resource keys like limits.cpu [OK]

Hint: Use full resource keys like limits.cpu in quotas [OK]

Common Mistakes:

• Using short keys like 'cpu' instead of 'limits.cpu'
• Assuming missing namespace causes syntax error
• Using numeric values instead of strings

5. You want to limit a namespace to 5 pods and 2Gi memory requests, but allow unlimited CPU. Which ResourceQuota YAML snippet achieves this?

hard

A. spec:
hard:
pods: "5"
requests.memory: "2Gi"
requests.cpu: "0"

B. spec:
hard:
pods: "5"
requests.memory: "2Gi"

C. spec:
hard:
pods: "5"
requests.memory: "2Gi"
limits.cpu: "unlimited"

D. spec:
hard:
pods: "5"
requests.memory: "2Gi"
requests.cpu: "-1"

Solution

1. Step 1: Understand ResourceQuota limits

   To limit pods and memory requests, specify those keys under hard. Omitting CPU means no limit on CPU.

2. Step 2: Evaluate options for CPU limits

   spec: hard: pods: "5" requests.memory: "2Gi" omits CPU limits, allowing unlimited CPU. Options A, C, D try to set CPU limits with invalid or restrictive values.

3. Final Answer:

   spec: hard: pods: "5" requests.memory: "2Gi" -> Option B

4. Quick Check:

   Omit CPU limit to allow unlimited CPU [OK]

Hint: Omit resource in quota to allow unlimited usage [OK]

Common Mistakes:

• Setting CPU limit to 0 or negative disables pods
• Using 'unlimited' as a value (not valid)
• Trying to limit CPU when unlimited is desired