Advanced
Containers & Virtualization
#orchestration#kubernetes#autoscaling#probes
Orchestration Concepts
5 exercises — Master the English vocabulary of container orchestration: scheduler resource requests and limits, QoS classes, node selection (taints, tolerations, affinity), self-healing probes, and autoscaling.
0 / 24 completed
1 / 24
A Pod manifest sets: resources.requests.cpu: "250m" and resources.limits.cpu: "500m". A colleague asks what the difference is between a request and a limit.
Which explanation is correct?
Requests drive scheduling; limits enforce a runtime ceiling.
The scheduler reads each Pod's
Setting
Key vocabulary:
• resource request — the minimum amount of CPU/memory the scheduler reserves for a container
• resource limit — the maximum amount a container is allowed to consume at runtime
• throttling — CPU usage capped at the limit rather than terminated
• scheduler — the control-plane component that decides which node runs each Pod
The scheduler reads each Pod's
requests to find a node with enough spare capacity — it never places a Pod on a node that cannot satisfy the request. The limits field is enforced by the kubelet/container runtime at runtime: a container that tries to use more CPU than its limit is throttled, and one that tries to use more memory than its limit is OOM-killed.Setting
requests too low causes over-packing (nodes become noisy and contended); setting limits too low causes throttling or OOM kills under normal load. Setting requests equal to limits (a "Guaranteed" pattern) gives the most predictable performance.Key vocabulary:
• resource request — the minimum amount of CPU/memory the scheduler reserves for a container
• resource limit — the maximum amount a container is allowed to consume at runtime
• throttling — CPU usage capped at the limit rather than terminated
• scheduler — the control-plane component that decides which node runs each Pod
2 / 24
Three Pods are described in a postmortem:
Pod A: requests == limits for both CPU and memory
Pod B: requests set, but no limits
Pod C: no requests, no limits
Which sentence correctly matches each Pod to its Kubernetes QoS class?
QoS class is derived automatically from how requests and limits are set — it is not configured directly.
• Guaranteed — every container has requests == limits for both CPU and memory. Evicted last under node pressure.
• Burstable — at least one container has a request set (but requests ≠ limits, or limits are missing for some resource). Evicted after BestEffort Pods.
• BestEffort — no requests or limits set at all. Evicted first when the node runs low on resources.
This vocabulary matters in incident reviews: "the noisy neighbour Pod was BestEffort, so it was the first candidate for eviction" is a standard sentence when explaining why a low-priority workload was killed to protect higher-priority Guaranteed Pods on the same node.
Key vocabulary:
• QoS class — Guaranteed / Burstable / BestEffort; determines eviction priority under resource pressure
• eviction — the kubelet terminating a Pod to reclaim resources on a starved node
• node pressure — a node running low on CPU, memory, or disk
• Guaranteed — every container has requests == limits for both CPU and memory. Evicted last under node pressure.
• Burstable — at least one container has a request set (but requests ≠ limits, or limits are missing for some resource). Evicted after BestEffort Pods.
• BestEffort — no requests or limits set at all. Evicted first when the node runs low on resources.
This vocabulary matters in incident reviews: "the noisy neighbour Pod was BestEffort, so it was the first candidate for eviction" is a standard sentence when explaining why a low-priority workload was killed to protect higher-priority Guaranteed Pods on the same node.
Key vocabulary:
• QoS class — Guaranteed / Burstable / BestEffort; determines eviction priority under resource pressure
• eviction — the kubelet terminating a Pod to reclaim resources on a starved node
• node pressure — a node running low on CPU, memory, or disk
3 / 24
A platform engineer writes in a design doc: "We place the database Pod on a dedicated node using a taint-and-toleration strategy, combined with a nodeSelector so other workloads never land there by accident."
What does a taint actually do, and how does a toleration relate to it?
Taints repel; tolerations permit — but neither one attracts.
A taint (
That is exactly why the design doc combines two mechanisms: the taint+toleration pair excludes other workloads from the dedicated node, while a separate nodeSelector (or node affinity) is what actually attracts the database Pod to that specific node. Taints/tolerations alone do not guarantee placement — only exclusion.
Key vocabulary:
• taint — applied to a node; repels Pods unless they tolerate it (effects: NoSchedule, PreferNoSchedule, NoExecute)
• toleration — applied to a Pod; permits scheduling onto a matching tainted node
• node selector — a simple key/value match that constrains which nodes a Pod can run on
• node affinity / anti-affinity — richer rule sets for attracting Pods to (affinity) or keeping them apart from (anti-affinity) certain nodes or other Pods
A taint (
kubectl taint nodes node1 dedicated=db:NoSchedule) tells the scheduler "do not place any Pod here unless it explicitly tolerates this taint." A toleration in the Pod spec says "I am allowed to run on nodes with this taint" — but it does not force the scheduler to choose that node.That is exactly why the design doc combines two mechanisms: the taint+toleration pair excludes other workloads from the dedicated node, while a separate nodeSelector (or node affinity) is what actually attracts the database Pod to that specific node. Taints/tolerations alone do not guarantee placement — only exclusion.
Key vocabulary:
• taint — applied to a node; repels Pods unless they tolerate it (effects: NoSchedule, PreferNoSchedule, NoExecute)
• toleration — applied to a Pod; permits scheduling onto a matching tainted node
• node selector — a simple key/value match that constrains which nodes a Pod can run on
• node affinity / anti-affinity — richer rule sets for attracting Pods to (affinity) or keeping them apart from (anti-affinity) certain nodes or other Pods
4 / 24
A Pod keeps receiving traffic even though the application inside is deadlocked and cannot process requests, while a separate Pod is stuck in a crash loop during a slow database migration on startup.
Which combination of Kubernetes probes correctly addresses both problems?
Each probe answers a different question about the same container.
• Liveness probe — "is this process still alive/healthy?" A failure causes the kubelet to restart the container. Use it to recover from deadlocks or unrecoverable internal states.
• Readiness probe — "is this process ready to serve traffic right now?" A failure removes the Pod from the Service's endpoints (no restart) — perfect for the deadlocked Pod: stop sending it traffic without killing it, in case a human needs to inspect it live.
• Startup probe — runs only during container startup and disables the liveness probe until it succeeds, giving slow-starting applications (large migrations, cache warmup) time before liveness checks can kill them for false "unhealthy" failures.
This trio is the standard vocabulary for "self-healing": Kubernetes automatically restarts Pods that fail liveness checks and automatically stops routing traffic to Pods that fail readiness checks — without a human paging anyone.
Key vocabulary:
• liveness probe — failure triggers a container restart
• readiness probe — failure removes the Pod from Service endpoints, no restart
• startup probe — protects slow-starting containers from premature liveness failures
• self-healing — the orchestrator automatically restarting or rerouting around failed containers
• Liveness probe — "is this process still alive/healthy?" A failure causes the kubelet to restart the container. Use it to recover from deadlocks or unrecoverable internal states.
• Readiness probe — "is this process ready to serve traffic right now?" A failure removes the Pod from the Service's endpoints (no restart) — perfect for the deadlocked Pod: stop sending it traffic without killing it, in case a human needs to inspect it live.
• Startup probe — runs only during container startup and disables the liveness probe until it succeeds, giving slow-starting applications (large migrations, cache warmup) time before liveness checks can kill them for false "unhealthy" failures.
This trio is the standard vocabulary for "self-healing": Kubernetes automatically restarts Pods that fail liveness checks and automatically stops routing traffic to Pods that fail readiness checks — without a human paging anyone.
Key vocabulary:
• liveness probe — failure triggers a container restart
• readiness probe — failure removes the Pod from Service endpoints, no restart
• startup probe — protects slow-starting containers from premature liveness failures
• self-healing — the orchestrator automatically restarting or rerouting around failed containers
5 / 24
A team configures a Horizontal Pod Autoscaler (HPA) with targetCPUUtilizationPercentage: 70 and minReplicas: 3, maxReplicas: 10. A new engineer asks what this actually does.
Which explanation is accurate?
HPA is horizontal scaling: it changes the number of replicas, not the size of each one.
The HPA controller polls metrics (by default, CPU utilisation relative to each Pod's resource request, not an absolute value) on a regular interval. If average utilisation across replicas is above the target, it scales the replica count up; if well below, it scales down — always staying within
This is why CPU requests matter for autoscaling correctness: a Pod with no request has nothing to calculate "70% of" against, so the HPA cannot compute utilisation percentage for it. "Horizontal" is contrasted with "vertical" scaling (Vertical Pod Autoscaler, VPA), which resizes the CPU/memory of individual Pods instead of changing their count.
Key vocabulary:
• Horizontal Pod Autoscaler (HPA) — automatically adjusts replica count based on observed metrics
• horizontal scaling — adding/removing instances (as opposed to vertical scaling, resizing one instance)
• target utilisation — the desired average metric value the HPA tries to maintain
• minReplicas / maxReplicas — the floor and ceiling the HPA will not cross
The HPA controller polls metrics (by default, CPU utilisation relative to each Pod's resource request, not an absolute value) on a regular interval. If average utilisation across replicas is above the target, it scales the replica count up; if well below, it scales down — always staying within
minReplicas/maxReplicas bounds to prevent scaling to zero unexpectedly or runaway scale-out.This is why CPU requests matter for autoscaling correctness: a Pod with no request has nothing to calculate "70% of" against, so the HPA cannot compute utilisation percentage for it. "Horizontal" is contrasted with "vertical" scaling (Vertical Pod Autoscaler, VPA), which resizes the CPU/memory of individual Pods instead of changing their count.
Key vocabulary:
• Horizontal Pod Autoscaler (HPA) — automatically adjusts replica count based on observed metrics
• horizontal scaling — adding/removing instances (as opposed to vertical scaling, resizing one instance)
• target utilisation — the desired average metric value the HPA tries to maintain
• minReplicas / maxReplicas — the floor and ceiling the HPA will not cross
6 / 24
Sarah's observation highlights a common misunderstanding. While it might *seem* redundant, `resources.requests` tells the scheduler the *minimum* resources a Pod needs to function correctly – this is crucial for placement decisions. `resources.limits`, however, sets a hard cap; if a Pod attempts to exceed this limit, Kubernetes will actively throttle or potentially terminate it to protect overall system stability and prevent noisy neighbor problems. Therefore, using both ensures responsible resource allocation.
7 / 24
This question tests your ability to articulate a fundamental distinction. While containers do utilize virtualization under the hood (often through technologies like Docker's OCI), the crucial difference lies in their architecture: containers share the host operating system's kernel, resulting in much lighter-weight and faster deployment compared to full virtual machines which each have their own complete OS. Using VMs implies a full hypervisor layer, adding significant overhead, whereas containerization focuses on process isolation at the OS level. The incorrect options either oversimplify the relationship or incorrectly state that containers and VMs are directly interchangeable.
8 / 24
PR Description:
Subject: Deploying New User Service - Initial Rollout
Body:
Hi team,
We've just deployed the new User Service to staging. I've set up a deployment using Docker Compose with resource limits defined for each container – specifically, `resources.requests` and `resources.limits`. I wanted to get your feedback on whether this approach is appropriate. It feels like we're potentially restricting the containers unnecessarily, but I want to ensure we're protecting our application from unexpected spikes.
Thanks,
DavidDavid's description correctly highlights a key aspect of container resource management. `resources.requests` defines the minimum amount of CPU and memory a container is guaranteed to receive – this ensures the application always has enough resources to function properly. `resources.limits` sets the maximum amount of CPU and memory a container can *consume*, preventing it from starving other containers or exhausting host resources. Setting both ensures a baseline level of performance while also providing protection against unexpected spikes in demand, which is crucial for stability.
9 / 24
Sarah's observation highlights a common misunderstanding. While it might *seem* redundant, `resources.requests` tells the scheduler the *minimum* resources a Pod needs to function correctly – this is crucial for placement decisions. `resources.limits`, however, sets a hard cap; if a Pod attempts to exceed this limit, Kubernetes will actively throttle or potentially terminate it to protect overall system stability and prevent noisy neighbor problems. Therefore, using both ensures responsible resource allocation.
10 / 24
This question tests your ability to articulate a fundamental distinction. While containers do utilize virtualization under the hood (often through technologies like Docker's OCI), the crucial difference lies in their architecture: containers share the host operating system's kernel, resulting in much lighter-weight and faster deployment compared to full virtual machines which each have their own complete OS. Using VMs implies a full hypervisor layer, adding significant overhead, whereas containerization focuses on process isolation at the OS level. The incorrect options either oversimplify the relationship or incorrectly state that containers and VMs are directly interchangeable.
11 / 24
PR Description:
Subject: Deploying New User Service - Initial Rollout
Body:
Hi team,
We've just deployed the new User Service to staging. I've set up a deployment using Docker Compose with resource limits defined for each container – specifically, `resources.requests` and `resources.limits`. I wanted to get your feedback on whether this approach is appropriate. It feels like we're potentially restricting the containers unnecessarily, but I want to ensure we're protecting our application from unexpected spikes.
Thanks,
DavidDavid's description correctly highlights a key aspect of container resource management. `resources.requests` defines the minimum amount of CPU and memory a container is guaranteed to receive – this ensures the application always has enough resources to function properly. `resources.limits` sets the maximum amount of CPU and memory a container can *consume*, preventing it from starving other containers or exhausting host resources. Setting both ensures a baseline level of performance while also providing protection against unexpected spikes in demand, which is crucial for stability.
12 / 24
Sarah's observation highlights a common misunderstanding. While it might *seem* redundant, `resources.requests` tells the scheduler the *minimum* resources a Pod needs to function correctly – this is crucial for placement decisions. `resources.limits`, however, sets a hard cap; if a Pod attempts to exceed this limit, Kubernetes will actively throttle or potentially terminate it to protect overall system stability and prevent noisy neighbor problems. Therefore, using both ensures responsible resource allocation.
13 / 24
This question tests your ability to articulate a fundamental distinction. While containers do utilize virtualization under the hood (often through technologies like Docker's OCI), the crucial difference lies in their architecture: containers share the host operating system's kernel, resulting in much lighter-weight and faster deployment compared to full virtual machines which each have their own complete OS. Using VMs implies a full hypervisor layer, adding significant overhead, whereas containerization focuses on process isolation at the OS level. The incorrect options either oversimplify the relationship or incorrectly state that containers and VMs are directly interchangeable.
14 / 24
PR Description:
Subject: Deploying New User Service - Initial Rollout
Body:
Hi team,
We've just deployed the new User Service to staging. I've set up a deployment using Docker Compose with resource limits defined for each container – specifically, `resources.requests` and `resources.limits`. I wanted to get your feedback on whether this approach is appropriate. It feels like we're potentially restricting the containers unnecessarily, but I want to ensure we're protecting our application from unexpected spikes.
Thanks,
DavidDavid's description correctly highlights a key aspect of container resource management. `resources.requests` defines the minimum amount of CPU and memory a container is guaranteed to receive – this ensures the application always has enough resources to function properly. `resources.limits` sets the maximum amount of CPU and memory a container can *consume*, preventing it from starving other containers or exhausting host resources. Setting both ensures a baseline level of performance while also providing protection against unexpected spikes in demand, which is crucial for stability.
15 / 24
Sarah's observation highlights a common misunderstanding. While it might *seem* redundant, `resources.requests` tells the scheduler the *minimum* resources a Pod needs to function correctly – this is crucial for placement decisions. `resources.limits`, however, sets a hard cap; if a Pod attempts to exceed this limit, Kubernetes will actively throttle or potentially terminate it to protect overall system stability and prevent noisy neighbor problems. Therefore, using both ensures responsible resource allocation.
16 / 24
This question tests your ability to articulate a fundamental distinction. While containers do utilize virtualization under the hood (often through technologies like Docker's OCI), the crucial difference lies in their architecture: containers share the host operating system's kernel, resulting in much lighter-weight and faster deployment compared to full virtual machines which each have their own complete OS. Using VMs implies a full hypervisor layer, adding significant overhead, whereas containerization focuses on process isolation at the OS level. The incorrect options either oversimplify the relationship or incorrectly state that containers and VMs are directly interchangeable.
17 / 24
PR Description:
Subject: Deploying New User Service - Initial Rollout
Body:
Hi team,
We've just deployed the new User Service to staging. I've set up a deployment using Docker Compose with resource limits defined for each container – specifically, `resources.requests` and `resources.limits`. I wanted to get your feedback on whether this approach is appropriate. It feels like we're potentially restricting the containers unnecessarily, but I want to ensure we're protecting our application from unexpected spikes.
Thanks,
DavidDavid's description correctly highlights a key aspect of container resource management. `resources.requests` defines the minimum amount of CPU and memory a container is guaranteed to receive – this ensures the application always has enough resources to function properly. `resources.limits` sets the maximum amount of CPU and memory a container can *consume*, preventing it from starving other containers or exhausting host resources. Setting both ensures a baseline level of performance while also providing protection against unexpected spikes in demand, which is crucial for stability.
18 / 24
The Slack message indicates a persistent issue. The *most* appropriate next step is to examine the resource configuration (requests/limits) – this is often where problems originate when scaling.
Option A is premature rollback; Option C ignores the problem and Option B is too general.
19 / 24
High CPU utilization often points to resource constraints. If the Pod's limits are too restrictive, it will be constantly throttled, leading to high CPU usage.
Option A is possible but doesn't explain *why* it's high; Option C suggests a faulty tool and option D is an unrelated problem.
20 / 24
During a standup update, David (a DevOps Engineer) says: 'We're using Kubernetes to orchestrate our containerized applications. We've configured Horizontal Pod Autoscaling for the Order Service, aiming for an average CPU utilization of 60%. However, I'm noticing that the system frequently scales *down* to just one replica when there's a sudden spike in order volume. What's the most likely underlying issue?',
HPA algorithms are designed to react to observed metrics. The Order Service might have a natural limit on how quickly it can process orders; the HPA isn't necessarily 'wrong,' but rather responding to a constraint inherent in the application itself. Options A and B suggest fundamental misconfigurations that aren't the most immediate cause, while option C directly addresses a potential bottleneck.
21 / 24
You are reviewing a Slack message from Elena (a Software Engineer): 'I'm trying to deploy my microservice using Docker Compose and I've set `resources.limits` on the container definition. But when I scale up, it seems like the pods aren't respecting these limits – they're still consuming a huge amount of memory. What should you advise her to investigate first?',
Resource limits in Kubernetes are enforced at the node level. If other pods on the same node are heavily utilizing CPU or memory, the limit set for this container will be ineffective; the orchestrator won't prevent resource contention. Option A is incorrect because Compose *does* support constraints. Option C suggests a misconfiguration of limits themselves and option D points to a code issue.
22 / 24
PR Description:
Subject: Deploying New Payment Service - Staging Environment
Body:
Hi team,
We've deployed the new Payment Service to staging. I've used Docker Compose with resource requests defined for each container, specifying 512MB of RAM and 1 CPU core. Later, during testing, we observed that the service consistently needs more than this allocated memory. What is the primary purpose of setting `resources.requests` in this scenario?
`resources.requests` defines a minimum guaranteed resource allocation. It tells the orchestrator that the application *needs* at least this much; it's not about limiting consumption or predicting future demand – those are handled by `resources.limits`. Setting requests ensures the pod gets enough to start.
23 / 24
During a code review, Mark (a Senior Developer) says: 'We're running our application in containers orchestrated by Kubernetes. We've set `resources.limits` for each container to prevent them from consuming excessive resources and potentially crashing the node. However, I'm concerned about potential performance degradation if a limit is consistently approached. What should we consider implementing to mitigate this?',
HPA is designed to proactively respond to increased demand. Constantly approaching a limit indicates the application needs more resources; HPA will automatically scale up the number of replicas to handle the load, preventing performance degradation and potential outages. Option A would simply increase the problem; option B addresses failures, not scaling; option C provides the correct solution.
24 / 24
During a code review of a new deployment script for our e-commerce microservices architecture, Liam (the Release Manager) comments: "I noticed you've set both `resources.requests` and `resources.limits` in the container definition. Can you explain why we're using both? It feels like we are restricting resources unnecessarily."
The key difference between `resources.requests` and `resources.limits` is their purpose. Requests specify the *minimum* resources a container needs, while limits define the *maximum*. Using both provides a robust approach to resource management – guaranteeing availability while preventing uncontrolled consumption. The misconception here is that limits are solely for testing; they're critical in production.
Frequently Asked Questions
What does the "Orchestration Concepts" exercise practise?
Practice Kubernetes orchestration vocabulary in English: scheduler requests and limits, QoS classes, taints and tolerations, liveness/readiness/startup probes, and Horizontal Pod Autoscaler. 5 advanced exercises.
How many questions are in this exercise?
This exercise has 24 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Advanced. If the vocabulary feels difficult, browse the Containers & Virtualization category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "Orchestration Concepts" part of a larger series?
Yes — it's one exercise in the Containers & Virtualization category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Containers & Virtualization category page for related exercises, or browse the main Exercises hub for other IT English topics.