Master the IT-English vocabulary of Kubernetes resource management: requests, limits, throttling, QoS classes and overcommit.
0 / 18 completed
1 / 18
What does a CPU/memory 'request' do in Kubernetes?
A request is the guaranteed minimum the scheduler reserves; it drives placement decisions.
2 / 18
What does a 'limit' do?
A limit is the hard ceiling; exceeding the memory limit risks OOMKill, and CPU is throttled at its limit.
3 / 18
A container exceeds its CPU limit and is 'throttled'. What does that mean?
CPU is a compressible resource: hitting the limit throttles (slows) the container instead of killing it.
4 / 18
A pod with requests equal to limits gets the 'Guaranteed' QoS class. What is QoS?
QoS classes (Guaranteed, Burstable, BestEffort) determine eviction priority when a node is under resource pressure.
5 / 18
Which sentence correctly uses 'overcommit'?
Overcommit is scheduling more potential usage than physical capacity, relying on not all pods peaking at once.
6 / 18
Sarah from the DevOps team sent this Slack message: 'The API is returning a 503 error for requests exceeding 10 seconds. We're seeing a spike in traffic – maybe we need to increase the resource limits for that endpoint?' What does Sarah likely mean by 'increase the resource limits'?
Sarah is referring to limiting the amount of processing power (CPU) or execution time that the API server can use for each request. Increasing resource limits in this context means setting higher constraints on how much a single request can consume – preventing it from blocking other requests and degrading overall performance. Options A, B, and C represent different approaches to handling high traffic, but don't directly address the root cause of the 503 error.
7 / 18
Mark left this comment on a code review: 'This function is hitting the database connection limit. We should implement rate limiting to prevent excessive calls.' What is Mark referring to when he mentions 'the database connection limit'?
Mark is discussing connection pooling – a common technique to manage database resources. The 'database connection limit' specifically refers to the maximum *concurrent* connections allowed by the database server itself. This constraint prevents exhaustion and ensures stability; rate limiting focuses on controlling the *rate* of requests, not the number of active connections.
8 / 18
David from the backend team posted this comment on a recent Pull Request:
"The service is intermittently failing with HTTP 503 errors. Monitoring shows increased latency during peak hours. We need to ensure our API endpoints aren't being overloaded."
David is referring to a common strategy for handling overload: circuit breakers. These automatically stop making requests when an endpoint becomes unresponsive, preventing the entire system from crashing. Increasing concurrency (option A) could exacerbate the problem if resources are already strained. Quotas (option D) would be too granular and inflexible for this situation.
9 / 18
Elena is explaining a new deployment strategy to her team.
"We're using resource requests and limits. Requests are like *suggestions* for how much CPU or memory an application needs, while limits are hard boundaries. If a request is higher than the limit, the system will actively reduce the resources allocated to that process."
Elena is correctly distinguishing between requests and limits. Requests provide a *suggestion* to the system – it's not a guarantee. Limits, conversely, are enforced constraints. The system will actively reduce resources if a request exceeds the limit, preventing one application from monopolizing all available resources.
10 / 18
John from the Infrastructure team sent this message:
"We've observed that our web servers are consistently hitting their memory limits during peak hours. This is causing occasional slowdowns and impacting user experience. Should we increase the memory requests for the application?"
Requests are suggestions for resources an application *could* use, while limits are enforced boundaries. Increasing both allows the app to request more if needed but prevents it from exceeding the configured maximum. Setting the limit to zero forces the application to handle memory itself, which is often problematic.
11 / 18
Maria, a junior developer, asked: 'What's the difference between a request and a limit for a container? I keep seeing warnings about exceeding limits.'
It's important to understand that requests and limits have distinct roles. The request is a *request* for a certain amount of resource – the container can ask for more if available. The limit is a hard constraint; once reached, the container's resources are restricted to avoid impacting other applications.
12 / 18
David left this comment on a code review:
'The API endpoint is experiencing intermittent HTTP 503 errors during high traffic. Monitoring shows that the system is consistently exceeding its CPU limit. We need to investigate whether our code is inefficient or if we need to scale horizontally.' What does David mean by 'scaling horizontally'?
'Scaling horizontally' refers to adding more identical servers or containers to handle increased demand. This distributes the workload and prevents any single server from being overwhelmed by exceeding its limits. The other options represent different resource management strategies but don't address horizontal scaling.
13 / 18
During a code review, Liam from the frontend team comments: 'This component is consistently triggering timeouts when rendering large datasets. The backend API seems to be struggling under sustained load.' Considering this context, what does Liam *most likely* mean regarding resource limits?
Liam's comment points to performance issues with the backend. 'Timeouts' combined with 'struggling under sustained load' strongly suggests that the API endpoint itself – likely constrained by CPU or network limits – is overloaded. A poorly optimized front-end wouldn't typically cause *timeouts* directly; exhausted connection pools would manifest differently, and insufficient memory allocation is a common root cause of resource limit issues.
14 / 18
Sarah, the DevOps engineer, sends this Slack message to her team: 'We're seeing a lot of 503 errors on our staging environment. The monitoring dashboard shows that the API is consistently hitting its memory limit during peak load.' Which statement best describes Sarah's concern regarding resource limits?
Sarah's message directly states the API is hitting its memory limit. This indicates that the application is attempting to use more memory than what was *allowed* by the configured limit. Increasing server RAM wouldn't solve this; it's about controlling the resource usage of a specific service, not just the infrastructure itself.
15 / 18
Alex, a developer, is troubleshooting an API endpoint that's intermittently returning 503 errors. The monitoring dashboard shows the service consistently exceeding its memory limit during peak hours. Which of the following best describes the purpose of setting *limits* for resources in this scenario?
Limits define a hard boundary for resource consumption. Setting limits prevents the service from exhausting all available memory and potentially crashing or becoming unresponsive due to excessive memory usage. The goal is stability and controlled scaling, not guaranteed maximum availability or prioritization. Option A is incorrect because limits don't guarantee maximum allocation; options C and D are unrelated to the core concept of resource limits.
16 / 18
During a standup meeting, Ben mentions: 'We're seeing occasional 503 errors on our new feature. The logs show the database connection limit is being hit repeatedly.' What does Ben likely mean when he refers to 'hitting the database connection limit'?
Hitting a limit in this context refers to exceeding the configured maximum number of simultaneous connections the application can establish with the database. This typically happens when too many requests are competing for database resources, leading to errors and slowdowns. Options B, C, and D describe problems at the database server level or administrator restrictions, not the application's connection limit.
17 / 18
// Python example (conceptual)
resource_request = {'cpu': '0.5', 'memory': '2GB'}
resource_limit = {'cpu': '1', 'memory': '4GB'}
What is the primary difference between `resource_request` and `resource_limit` in this example?
The code illustrates that `resource_request` is a *suggestion* or desired amount of resources, whereas `resource_limit` defines a strict boundary. The system might not always honor the request, but it will never exceed the limit. It's crucial to understand this distinction for effective resource management.
18 / 18
Sarah, a developer, is explaining the concept of 'overcommitment' to her team. Which statement best describes what she means?
Overcommitment occurs when you allocate more resources (CPU, memory) to an application than it actually needs. This can lead to instability because the system has no headroom for unexpected spikes in demand or other processes competing for resources. Options B, C, and D describe related concepts but don't define overcommitment itself.
What will I practise in "Resource Limits & Requests"?
Master the IT-English vocabulary of Kubernetes resource management: requests, limits, throttling, QoS classes and overcommit.
How many exercises are in this module?
This module has 18 multiple-choice exercises, each with instant feedback and a full explanation of the correct answer.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account, sign-up, or paywall.
Do I need to create an account to do these exercises?
No account is required. Just click an option to answer — your score for this session is tracked automatically in the progress bar above.
What happens if I choose the wrong answer?
You'll immediately see which answer was correct, plus a full explanation covering the vocabulary and reasoning behind it — mistakes are where most of the learning happens.
Can I retry the exercises if I want a higher score?
Yes — use the "Try again" button on the results screen to reset and go through all the questions again.
Is my progress saved if I close the page?
No. Progress is tracked only for your current visit; reloading or leaving the page resets the counter. This keeps the exercise simple and account-free.
Where can I find more Kubernetes Operations exercises?
Browse the full Kubernetes Operations hub for related drills, or check the "Next up" link below to continue with a connected topic.
How is this different from reading an article on the same topic?
Articles explain vocabulary and concepts in prose; this exercise tests and reinforces that vocabulary through active recall with immediate feedback — the two work best together.
Who writes these exercises?
Every exercise is written by the CoderSlingo team, drawing on real workplace English used in IT roles, then reviewed for accuracy and clarity.