Last reviewed: November 14, 2026 (UTC); official Kubernetes references checked November 14, 2026.
Direct answer
Review a node-pressure change as a kubelet recovery and workload-availability change. Render the candidate Pod resources, storage use, priority, quality-of-service inputs, and any node or kubelet policy that controls eviction. Then identify the signal that can cross its threshold, the Pods eligible to be terminated, the grace-period behavior, and the application recovery path. A Pod that is admitted, scheduled, or protected by a PodDisruptionBudget can still be terminated when the node is out of resources.
Kubernetes defines node-pressure eviction as the kubelet proactively terminating Pods to reclaim node resources. The kubelet watches signals such as memory.available, nodefs or imagefs availability and inode counts, and containerfs signals where that split filesystem is enabled. Soft and hard thresholds have different grace-period behavior. The node-pressure reference also makes clear that this mechanism is different from API-initiated eviction: the kubelet does not honor a configured PodDisruptionBudget for node pressure. The Pod lifecycle reference defines Pending broadly: it includes Pods that have been accepted but are still waiting for scheduling, image pulls, container setup, or initialization, so the phase alone does not identify an unscheduled Pod or an eviction.
Keep four decisions separate. Admission asks whether the Pod satisfies namespace policy. Scheduling asks whether its requests fit an eligible node. Node-pressure eviction asks which running Pods must be removed to recover a pressured node. Application recovery asks whether the controller and workload can return safely without losing or duplicating work. Evidence from one boundary cannot prove the others.
Who this is for
Use this workflow when a coding agent changes container requests or limits, ephemeral-storage settings, workload priority, Pod quality-of-service inputs, node labels or taints, eviction thresholds, or a controller’s recovery behavior. It applies to Deployments, StatefulSets, Jobs, DaemonSets, and other workloads whose running Pods consume node resources. It also applies when an agent changes logging, temporary files, caches, or image behavior that can fill node filesystems.
Give the agent the supported Kubernetes and node versions, the kubelet eviction configuration, the workload’s availability or completion contract, representative peak usage, and the owner of any data-recovery decision. Ask it to render every overlay and state which pressure signal the patch is intended to affect. The examples below are review fixtures and proposed checks; this article reports no authenticated cluster test or deployment outcome.
Key takeaways
- Node pressure is evaluated by the kubelet from resource and filesystem signals; a Pod phase or Deployment status alone does not explain an eviction.
- Requests influence scheduling and the kubelet’s eviction ranking, while limits constrain container behavior. A larger limit is not an eviction shield.
- Soft thresholds allow a configured grace period; hard thresholds can terminate with zero grace. Record the actual node policy instead of assuming a default.
- Node-pressure eviction is involuntary and is not protected by a PodDisruptionBudget. API eviction, preemption, and NoExecute taints are separate paths.
- QoS, priority, usage relative to requests, and controller ownership must be tied to the same Pod UID and rendered revision.
- Recovery evidence must show whether the replacement Pod used the candidate template and whether the application reconciled partial work.
Sources checked
Six primary Kubernetes references were retrieved successfully on November 14, 2026 UTC:
- Node-pressure eviction defines eviction signals, soft and hard thresholds, monitoring, Pod selection, grace periods, reclaim behavior, and the distinction from API-initiated eviction.
- Resource management for Pods and containers defines requests, limits, quantity units, scheduling effects, CPU throttling, memory termination, and local ephemeral-storage accounting.
- Resource quotas defines namespace aggregate limits, object counts, ephemeral-storage quota keys, and priority-class scopes.
- Limit Ranges defines per-container and per-Pod minimums, maximums, ratios, default injection, and admission failures.
- Pod disruptions distinguishes voluntary and involuntary disruption and explains the intended scope and limits of PodDisruptionBudget protection.
- Pod lifecycle defines the broad Pending phase and distinguishes scheduling, image pulls, initialization, and container setup from later running or failed states.
These maintained references support an evergreen review task. The node-pressure page is the current source for signal and threshold behavior; the policy pages are current references for the admitted resource contract. Match fields and feature behavior to the target node and control-plane versions. The test matrix below is an operating recommendation, not a report of a cluster change.
Contract details to verify
Define the pressure contract before reading the diff
Write the workload contract in operational terms. For a serving Deployment, specify the minimum number of ready replicas, the maximum tolerated interruption, and whether a replacement can serve before the old Pod exits. For a Job, specify whether partial output is committed, how an attempt is identified, and how a retry reconciles an uncertain result. For a StatefulSet, record volume ownership and the time needed for a replacement to reattach safely.
Record the candidate revision, renderer inputs, namespace, service account, controller, replica or completion settings, container and init-container resources, volume mounts, log paths, temporary directories, image references, and node pool. Include any sidecar or injected container. A patch that leaves the main container unchanged can still increase pressure through a new sidecar, larger logs, image layers, or an unbounded emptyDir volume.
State which signal is in scope. The kubelet can act on memory.available, nodefs.available, nodefs.inodesFree, imagefs.available, imagefs.inodesFree, and containerfs signals when the node uses a split filesystem. A statement such as “the Pod was evicted for disk” is incomplete until it names the signal, the threshold, the observation time, and the filesystem that was pressured. Keep node-level capacity and allocatable values with the candidate rather than inferring them from a Pod manifest.
Separate requests, limits, and node signals
The resource-management reference says requests guide scheduler placement and limits are enforced by the kubelet. CPU limits can throttle a running container; memory overuse can result in an OOM kill. Neither outcome is the same as node-pressure eviction. Local ephemeral-storage requests and limits also have their own accounting, while image layers, writable layers, logs, and temporary files can consume node filesystems.
Inspect the effective Pod after admission. A LimitRange can add defaults to omitted requests or limits, enforce minimums and maximums, and reject a Pod with HTTP 403. If more than one LimitRange supplies defaults, the selected default is not deterministic. A limit-only edit can therefore alter the request used for scheduling and quota calculations. Compare the rendered and admitted resource blocks for every container and init container.
ResourceQuota is an admission boundary for aggregate namespace usage, including request and limit keys for CPU, memory, and ephemeral storage where configured. It can also count Pods and scope usage by a priority class. A quota rejection prevents creation; it does not describe a running Pod later evicted by the kubelet. Keep the quota object, current usage, hard value, and exact API diagnostic in the review packet.
Use this comparison when interpreting a failure:
| Observation | Boundary to investigate | Evidence to retain |
|---|---|---|
| Pod create request is rejected | LimitRange, ResourceQuota, or another admission rule | API status, field or quota key, admitted-policy snapshot |
| Pod is Pending | First check whether it is bound: inspect spec.nodeName, the PodScheduled condition, container states, and events. An unbound Pod points toward scheduler filters, requests, taints, affinity, or capacity; a bound Pending Pod may be waiting for image pulls, initialization, or container setup. | Pod UID, binding and condition fields, container states, effective requests, node allocatable data, image/setup events, and scheduler events where relevant |
| Container is OOMKilled | Container memory behavior or memory limit | Container termination reason, restart count, working-set observations |
| Node reports pressure and Pod is terminated | Kubelet signal and eviction policy | Node condition, signal, threshold, Pod event, grace-period evidence |
| Pod is removed for a NoExecute taint | Taint and toleration contract | Node taint, Pod toleration, timestamps, eviction event |
Inspect threshold and eviction policy as deployed
Capture the node’s kubelet configuration and the runtime’s filesystem layout through the approved read-only administration path. Record eviction-soft and eviction-hard values, eviction-soft-grace-period, eviction-max-pod-grace-period, eviction-pressure-transition-period, monitoring interval, and any minimum reclaim policy. Do not copy a threshold from documentation and call it the cluster’s value.
Soft thresholds allow the configured grace period before eviction when the signal remains below the threshold. Hard thresholds have no grace period in the documented kubelet behavior and can result in immediate termination. The node-pressure reference also describes the kubelet reclaiming node-level resources and setting an evicted Pod’s phase to Failed. Capture the node condition and event stream before cleanup removes the evidence.
Review how the candidate’s QoS and priority interact with the policy. Inspect whether the Pod is BestEffort, Burstable, or Guaranteed from its admitted requests and limits, and compare usage with each container’s requests. Record the priority class and controller owner. Do not describe a high limit, a PDB, or a priority value as an absolute shield: eviction selection is a node-recovery decision, and the application still has to tolerate interruption.
Keep API-initiated eviction separate. The disruptions reference describes PDBs as a way to limit selected voluntary disruptions, while out-of-resources eviction is involuntary. A drain that uses the Eviction API and a kubelet responding to memory pressure produce different evidence and different protections. Likewise, a NoExecute taint can remove a Pod because its toleration is absent or expired; that is a taint contract, not proof of node pressure.
Build a candidate-specific test matrix
Use an approved disposable node pool with synthetic data and a bounded observation window. Establish a healthy baseline, isolate one pressure or policy change at a time, and restore the baseline between cases. These checks are proposed review fixtures:
| Controlled case | Acceptance evidence |
|---|---|
| Valid candidate under normal headroom | Admitted resource blocks, Pod UID, node, QoS, priority, readiness, and baseline node signals |
| LimitRange default or maximum applies | Server-side dry-run output or exact rejection, with the policy object and final quantities |
| Namespace quota is near its hard value | Quota usage before and after, create response, and no hidden quota edit |
| Memory or filesystem signal crosses a soft threshold | Node signal timeline, threshold and grace policy, eviction event, Pod phase, and observed grace period |
| Hard threshold is crossed | Signal and threshold evidence, immediate termination behavior, and preserved diagnostics |
| Candidate is replaced by its controller | Old and new Pod UIDs, controller revision, admitted template, readiness time, and application recovery result |
| A NoExecute taint is applied separately | Taint, toleration, eviction timestamp, and evidence that the case is not being labeled pressure eviction |
| Partial work exists when a Pod exits | Durable work key, commit or rollback state, retry result, and duplicate-effect check |
For a memory case, drive a bounded synthetic workload rather than allocating until the node becomes unusable. For a filesystem case, use a disposable volume and known-size files, and monitor nodefs, imagefs, or containerfs separately. Preserve the exact signal source and units. A low free-space percentage from an application metric is not interchangeable with the kubelet’s available-byte or inode signal.
When the candidate is evicted, read the Pod event, status phase, reason, deletion timestamps, termination grace setting, owner reference, and replacement template. Compare the replacement’s resource quantities with the candidate render; a controller can recreate a Pod using an older revision or a defaulted value. If a StatefulSet or Job owns the Pod, retain volume and attempt identity as well.
Verify application behavior after the infrastructure event. A serving workload should meet its readiness and error budget contract after replacement. A batch workload should either resume from a durable checkpoint or mark the attempt for reconciliation. Do not call a replacement Ready proof that the original write completed. Keep an uncertain external result pending until the application owner resolves it.
When a patch also changes resource sizing, pair this review with Review Kubernetes Requests and Limits in Coding-Agent Patches . If it changes priority or victim behavior, use Review Kubernetes Pod Priority and Preemption in Coding-Agent Patches as a companion review.
Failure modes
A Pending Pod is called an eviction or assumed to be unscheduled. Pending also covers a bound Pod waiting for image pulls, initialization, or container setup. Check spec.nodeName, PodScheduled, container states, and events first. Require scheduler evidence only for an unbound Pod; for an eviction, require the eviction reason and event plus node-pressure signals and threshold evidence.
A quota or LimitRange repair is used to solve node pressure. Admission policy and node recovery are separate owners. Diagnose the signal and the admitted quantities before changing namespace policy.
A PDB is treated as protection from out-of-resources eviction. PDBs target voluntary disruption. Node pressure is involuntary and can terminate matching Pods.
A hard threshold is tested with a graceful shutdown expectation. Confirm the deployed hard-threshold policy; documented hard eviction can use zero grace.
A high memory limit is treated as more node protection. Limits affect container enforcement. Compare usage, requests, QoS, priority, and node pressure together.
A replacement Pod is accepted without a recovery check. Retain old and new UIDs, revision data, and application-level reconciliation evidence.
FAQ
Does a PodDisruptionBudget prevent node-pressure eviction?
No. A PDB is designed for selected voluntary disruptions. The node-pressure documentation identifies out-of-resources eviction as a different, involuntary path that does not honor the configured PDB.
Does a memory limit prevent a Pod from being evicted?
No. A memory limit constrains the container and can produce an OOM kill. If the node remains under pressure, the kubelet can still evict a running Pod. Capture the container termination reason and the node signal separately.
Does increasing a request make a Pod safe from eviction?
No. Requests affect scheduling and eviction ranking, but they do not reserve an indestructible slice of a node. A larger request can also make the Pod harder to schedule and increase quota consumption.
Is a NoExecute taint the same as node pressure?
No. A NoExecute taint can evict Pods that lack a matching toleration. Keep taint, toleration, timestamps, and node conditions in separate evidence paths.
Does a controller automatically make the workload reliable after eviction?
It can create a replacement, but reliability depends on the admitted template, readiness, storage, checkpoint, and application recovery behavior. Verify those pieces with the old and new Pod identities.
Reader next step
Choose one agent-written workload or node-policy patch. Render the complete Pod template, capture LimitRange and ResourceQuota, and record the deployed kubelet signal and threshold policy. In an approved disposable node pool, run one normal baseline, one bounded soft-pressure or filesystem case, and one recovery case with synthetic data. Attach node conditions, Pod events, old and new UIDs, admitted quantities, controller revision, and application reconciliation evidence to the pull request before approval.