
For most of Kubernetes history, one rule quietly shaped every capacity decision: change a container CPU request or memory limit, and the pod restarts. Stateful services, long-running batch jobs, and in-memory caches all paid the same tax — eviction, rescheduling, cold start — just to add half a CPU. In December 2025, Kubernetes 1.35 graduated In-Place Pod Resize to General Availability, and the tax disappeared. CPU and memory requests and limits are now mutable on a running pod, often without a container restart. Combined with the Vertical Pod Autoscaler moving its InPlaceOrRecreate mode to beta, this is the most practical resource-efficiency win for SMB clusters in years.
Why resizing a pod used to mean a restart
The old model treated spec.containers[*].resources as immutable. If your nginx pod needed more memory at 9 a.m., the only path was editing the Deployment and letting the controller roll a replacement pod — new Pod IP, new cgroups, cold caches, and a brief gap in your error budget. Teams responded by over-provisioning: pad every request by 40 percent and hope. In-place resize flips the model. The spec now holds the desired resources, while status.containerStatuses[*].resources reports what the kubelet has actually applied. You request a change through the new /resize subresource, and the kubelet adjusts the container cgroup directly when the workload allows it.
Whether a container can be resized without a restart is now declared explicitly via resizePolicy. A container that can absorb a CPU bump without recycling declares restartPolicy: NotRequired; one that must restart to pick up a new memory limit declares RestartContainer. The kubelet consults that policy on every resize. Sidecar containers are supported too, and Kubernetes 1.36 pushed the same mechanism to pod-level resource budgets, so sidecar-heavy pods can resize their shared pool in one operation.
Resizing a live pod with kubectl
The feature is on by default in any cluster running 1.35 or later (it has been since 1.33 in beta). Here is a resize against a running pod — note the --subresource resize flag, required on kubectl 1.32+:
kubectl patch pod web-7d9c4f6b5-x2k9p --subresource resize \
--patch '{"spec":{"containers":[{"name":"app","resources":{"requests":{"cpu":"500m"},"limits":{"cpu":"500m"}}}]}}'
Verify what the container is actually running with, not what you asked for:
kubectl get pod web-7d9c4f6b5-x2k9p \
-o jsonpath='{.status.containerStatuses[*].resources}'
Two conditions tell you what happened. PodResizePending means the kubelet cannot grant the request right now (Deferred if the node is temporarily full, Infeasible if it is impossible). PodResizeInProgress means the change is being applied. Watch them live:
kubectl get events --field-selector involvedObject.name=web-7d9c4f6b5-x2k9p | grep -i resize
For Deployments and StatefulSets you edit the controller spec as usual; the control plane applies the change through the resize subresource without killing existing pods. Confirm the rollout converged, then spot-check a pod:
kubectl rollout status deployment/web
kubectl describe pod -l app=web | grep -A 4 "Conditions:"
Automating resize with the Vertical Pod Autoscaler
Manual patches are a demo; automation is the product. VPA on Kubernetes 1.35+ can act on its own recommendations using InPlaceOrRecreate: it tries a non-disruptive resize first, and only evicts the pod if in-place is impossible. Set controlledValues to RequestsAndLimits to keep the request-to-limit ratio intact:
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
name: web-vpa
spec:
targetRef:
apiVersion: "apps/v1"
kind: Deployment
name: web
updatePolicy:
updateMode: "InPlaceOrRecreate"
resourcePolicy:
containerPolicies:
- containerName: app
minAllowed:
cpu: 100m
memory: 128Mi
maxAllowed:
cpu: "2"
memory: 2Gi
Start in Off mode for a week to collect recommendations, then switch to InPlaceOrRecreate. Check the recommendation before you automate:
kubectl describe vpa web-vpa | grep -A 8 "Recommendation"
Gotchas: deferred resizes, memory ceilings, and the cost math
Three operational cautions. First, scale-ups need node headroom — if the node is packed, the resize sits Deferred until capacity frees up (Kubernetes 1.37 adds scheduler preemption for deferred resizes behind a feature gate). Pair in-place resize with node autoscaling; our Karpenter guide covers that layer. Second, memory limit decreases are now allowed but only best-effort protected against OOM kills — never shrink a limit below current usage. Third, resize is CPU and memory only; ephemeral-storage changes still restart the pod, extended resources like GPUs still require recreation, and pods under memory pressure behave exactly as described in our node pressure and eviction guide.
Alert on the failure modes, not just the feature: a pod parked in PodResizePending with reason Deferred for more than a few minutes means your node pool is full, and your VPA is silently stuck. The payoff, though, is measurable. Right-sizing requests across a fleet typically reclaims 20 to 35 percent of wasted CPU and memory, and you can prove it with the OpenCost workflow in our Kubernetes FinOps article. Measure before and after: kubectl top pods plus OpenCost allocation reports turn a nice feature into a budget line.
If your team runs stateful Kubernetes workloads and wants a resize and rightsizing policy that actually sticks, book a free 30-minute DevOps consultation — we will audit your requests, set VPA guardrails, and show you the savings on a real cluster.