Memory requests and limits in Kubernetes - Step-by-Step Execution

Process Flow - Memory requests and limits

Pod Spec Created

↓

Set Memory Request

↓

Set Memory Limit

↓

Scheduler Checks Requests

↓

Pod Scheduled on Node

↓

Container Runs

↓

Memory Usage Monitored

↓

If Usage > Limit

↓

If Usage < Request

The pod spec defines memory requests and limits. The scheduler uses requests to place pods. The runtime enforces limits during execution.

Execution Sample

Kubernetes

apiVersion: v1
kind: Pod
metadata:
  name: memory-pod
spec:
  containers:
  - name: app
    resources:
      requests:
        memory: "200Mi"
      limits:
        memory: "500Mi"

This pod requests 200Mi memory and limits usage to 500Mi.

Process Table

Step	Action	Memory Request	Memory Limit	Scheduler Decision	Container State
1	Pod spec created	200Mi	500Mi	Pending scheduling	Not running
2	Scheduler checks node capacity	200Mi	500Mi	Node with >=200Mi free selected	Pending
3	Pod scheduled on node	200Mi	500Mi	Scheduled	Starting container
4	Container starts running	200Mi	500Mi	Scheduled	Running, memory usage 150Mi
5	Memory usage rises to 450Mi	200Mi	500Mi	Scheduled	Running, memory usage 450Mi
6	Memory usage exceeds 500Mi	200Mi	500Mi	Scheduled	Container killed by OOM
7	Container restarted	200Mi	500Mi	Scheduled	Running, memory usage 180Mi

💡 Container killed when memory usage exceeded limit 500Mi

Status Tracker

Variable	Start	After Step 4	After Step 5	After Step 6	After Step 7
Memory Usage	0Mi	150Mi	450Mi	Killed (OOM)	180Mi
Container State	Not running	Running	Running	Killed	Running

Key Moments - 3 Insights

Why does the container get killed even though it requested only 200Mi but used more?

The container requested 200Mi for scheduling but can use up to 500Mi. If usage exceeds 500Mi (limit), the container is killed as shown in step 6.

Can the scheduler place the pod on a node with only 150Mi free memory?

No, because the pod requests 200Mi memory. Scheduler must find a node with at least 200Mi free (step 2).

What happens if the container uses less memory than requested?

The container runs normally. Requests are minimum guaranteed memory for scheduling, not limits on usage (step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the container state at step 5 when memory usage is 450Mi?

A Pending

B Running

C Killed

D Not running

💡 Hint

Check the 'Container State' column at step 5 in the execution_table.

At which step does the container get killed due to exceeding memory limit?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look for 'Container killed by OOM' in the 'Container State' column.

If the memory request was increased to 600Mi, what would happen during scheduling?

A Scheduler would find a node with at least 600Mi free memory

B Scheduler would ignore the request and schedule anyway

C Container would be killed immediately

D Memory limit would automatically increase

💡 Hint

Memory requests affect scheduler decisions as shown in step 2.

Concept Snapshot

Memory requests reserve minimum memory for scheduling.
Memory limits cap max memory usage.
Scheduler uses requests to place pods.
Container killed if usage exceeds limit.
Requests ≤ Limits always.
Requests do not limit usage, limits do.

Full Transcript

In Kubernetes, memory requests and limits control how much memory a container reserves and can use. The pod spec sets these values. The scheduler uses the request to find a node with enough free memory. The container can use memory up to the limit. If usage goes beyond the limit, the container is killed by the system. This trace shows a pod requesting 200Mi and limiting 500Mi memory. The scheduler places it on a node with enough memory. The container runs normally until usage exceeds 500Mi, then it is killed and restarted. Requests ensure scheduling success, limits protect node stability.

Practice

1. What does the memory request specify in a Kubernetes pod configuration?

easy

A. The total memory available on the node

B. The maximum amount of memory the container can use

C. The amount of memory the container has currently used

D. The minimum amount of memory guaranteed for the container

Solution

1. Step 1: Understand memory request meaning

   Memory request is the minimum memory Kubernetes guarantees to a container so it can run without being killed due to lack of memory.

2. Step 2: Differentiate from memory limit

   Memory limit is the max memory allowed, not the minimum guaranteed.

3. Final Answer:

   The minimum amount of memory guaranteed for the container -> Option D

4. Quick Check:

   Memory request = minimum guaranteed memory [OK]

Hint: Requests = minimum guaranteed memory, limits = max allowed [OK]

Common Mistakes:

• Confusing memory request with memory limit
• Thinking request is the max memory
• Assuming request is current usage

2. Which of the following is the correct way to specify memory requests and limits in a Kubernetes pod YAML?

easy

A. resources:
requests:
memory: "256Mi"
limits:
memory: "512Mi"

B. resources:
memory:
request: 256
limit: 512

C. memory:
requests: 256Mi
limits: 512Mi

D. resources:
requests:
mem: 256Mi
limits:
mem: 512Mi

Solution

1. Step 1: Recall correct YAML structure for resources

   In Kubernetes, memory requests and limits are under resources.requests.memory and resources.limits.memory with values as strings including units like "Mi".

2. Step 2: Check each option for syntax correctness

   resources: requests: memory: "256Mi" limits: memory: "512Mi" matches the correct syntax. Options A, B, and C use wrong keys or structure.

3. Final Answer:

   resources: requests: memory: "256Mi" limits: memory: "512Mi" -> Option A

4. Quick Check:

   Correct YAML keys and units = resources: requests: memory: "256Mi" limits: memory: "512Mi" [OK]

Hint: Use resources.requests.memory and resources.limits.memory keys [OK]

Common Mistakes:

• Using wrong keys like 'mem' or 'memory' outside resources
• Omitting quotes or units for memory values
• Swapping 'request' and 'requests'

3. Given this pod spec snippet:

resources:
  requests:
    memory: "128Mi"
  limits:
    memory: "256Mi"

What happens if the container tries to use 300Mi of memory?

medium

A. The container is allowed to use 300Mi without issues

B. The container is throttled but not killed

C. The container is killed by Kubernetes for exceeding the memory limit

D. The container's memory usage is capped at 256Mi but continues running

Solution

1. Step 1: Understand memory limit enforcement

   Memory limit is the maximum memory a container can use. If it exceeds this, Kubernetes kills the container.

2. Step 2: Apply to given values

   The limit is 256Mi. Using 300Mi exceeds this limit, so the container will be terminated.

3. Final Answer:

   The container is killed by Kubernetes for exceeding the memory limit -> Option C

4. Quick Check:

   Memory usage > limit = container killed [OK]

Hint: Memory over limit kills container, not throttled [OK]

Common Mistakes:

• Thinking container is throttled instead of killed
• Confusing requests with limits
• Assuming container can burst beyond limit safely

4. You set memory requests to 512Mi and limits to 256Mi in your pod YAML. What is the problem?

medium

A. Memory limits cannot be lower than 256Mi

B. Memory requests cannot be higher than memory limits

C. This configuration is valid and will work fine

D. Requests and limits must be equal

Solution

1. Step 1: Recall relationship between requests and limits

   Memory requests must be less than or equal to memory limits. Requests are minimum guaranteed, limits are max allowed.

2. Step 2: Analyze given values

   Requests = 512Mi, Limits = 256Mi. Requests are higher than limits, which is invalid and causes an error.

3. Final Answer:

   Memory requests cannot be higher than memory limits -> Option B

4. Quick Check:

   Requests ≤ Limits rule violated [OK]

Hint: Requests must be ≤ limits, else config error [OK]

Common Mistakes:

• Setting requests higher than limits
• Assuming limits can be lower than requests
• Thinking requests and limits can be any values

5. You want to ensure your pod always has at least 200Mi memory but never uses more than 400Mi. How should you set memory requests and limits in the pod spec?

hard

A. requests.memory: "200Mi" and limits.memory: "400Mi"

B. requests.memory: "400Mi" and limits.memory: "200Mi"

C. requests.memory: "200Mi" only, no limits

D. limits.memory: "400Mi" only, no requests

Solution

1. Step 1: Identify minimum guaranteed memory

   Minimum memory guaranteed is set by requests.memory, so set it to 200Mi.

2. Step 2: Identify maximum allowed memory

   Maximum memory allowed is set by limits.memory, so set it to 400Mi.

3. Step 3: Verify correct order

   Requests must be ≤ limits, so 200Mi ≤ 400Mi is valid.

4. Final Answer:

   requests.memory: "200Mi" and limits.memory: "400Mi" -> Option A

5. Quick Check:

   Requests = 200Mi, Limits = 400Mi [OK]

Hint: Requests = min guaranteed, limits = max allowed [OK]

Common Mistakes:

• Swapping requests and limits values
• Setting only requests or only limits
• Setting requests higher than limits