CKA Workloads and Scheduling Practice Question
Which TWO statements about Kubernetes resource requests and limits are correct? (Select 2)
⚠ Common exam trap
Test-takers frequently confuse compressible (CPU) and incompressible (memory) resources — candidates often think memory can be throttled like CPU, but exceeding memory limits always results in termination, not throttling.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Limits can be set independently for CPU and memory.
Option A is correct because Kubernetes allows CPU and memory limits to be configured separately per container via resources.limits.cpu and resources.limits.memory, so you can cap one resource without capping the other. Option D is correct because the kube-scheduler uses the sum of container CPU requests (resources.requests.cpu) when filtering and scoring nodes, ensuring a node has enough allocatable CPU to satisfy the pod's guaranteed share. Option B is wrong because memory is incompressible: exceeding a memory limit triggers OOMKill rather than throttling, whereas CPU is the compressible resource. Option C is wrong because exceeding a memory limit causes the container to be terminated with an OOMKilled status, not throttled; CPU limit overuse is what gets throttled via CFS quota. Option E is wrong because a pod without explicit limits is not truly unlimited: it can burst up to node allocatable capacity, but it is still constrained by the node's resources and may be evicted under pressure, and in namespaces with a LimitRange, default limits may be applied automatically.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
Limits can be set independently for CPU and memory.
Why this is correct
Kubernetes allows fine-grained resource configuration, meaning you can define a CPU limit without specifying a memory limit, or vice versa. This independence allows operators to tailor resource constraints to the specific workload profile, such as CPU-bound or memory-bound applications.
- ✗
Memory requests and limits are both compressible.
Why it's wrong here
Unlike CPU, which is a compressible resource that can be throttled when limits are reached, memory is an incompressible resource. If a container attempts to allocate more memory than is available or exceeds its defined limit, the kernel cannot throttle its memory usage and will instead terminate the process via the Out-Of-Memory (OOM) killer.
- ✗
If a container exceeds its memory limit, it is throttled.
Why it's wrong here
Throttling is a mechanism applied exclusively to compressible resources like CPU by CFS bandwidth control. When a container attempts to allocate memory beyond its configured limit, the Linux kernel's OOM killer immediately terminates the container's processes with an Exit Code 137, rather than slowing down its execution.
- ✓
CPU requests are used for scheduling decisions.
Why this is correct
The kube-scheduler relies on resource requests to determine which node has sufficient allocatable capacity to host a Pod. Limits are ignored during the scheduling phase, meaning a node can be overcommitted on limits as long as the sum of the existing requests plus the new Pod's requests does not exceed the node's allocatable capacity.
- ✗
If no limits are specified, the pod can use unlimited resources.
Why it's wrong here
While a Pod without defined limits can theoretically consume all available resources on its host node, its consumption is physically bounded by the node's hardware capacity. Additionally, default LimitRanges applied to the namespace may automatically inject default limits, preventing truly unrestricted resource consumption.
Go deeper
Related to this question
Learn chapter
Installing Kubernetes with kubeadm
Key term
Network Policies
A Kubernetes resource that controls how pods communicate with each other and with other network endpoints, acting as a firewall for pod-to-pod traffic.
Key term
Ingress Resources
Ingress Resources are Kubernetes API objects that manage external access to services inside a cluster, typically HTTP and HTTPS traffic, by defining rules for routing requests based on hostnames and paths.
About these practice questions
One of 726 original CKA practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This CKA practice question is part of Courseiva's free CNCF certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the CKA exam.