# Kubernetes In-Place Pod Resource Updates And Vertical Pod Resize Source: https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html Published: 2026-08-16T04:07:21.000-07:00 Updated: 2026-10-10T10:39:40.121-07:00 Author: Unknown Topics: autoscaling, devops, kubernetes, resource-management, sre, vertical-scaling, vpa **Listen to this article** AI-narrated article - 19 min 42 sec. Prose is preserved; code and diagram cues refer to the examples below. Your browser does not support audio playback. [Open the MP3](https://manomatt.github.io/devopsdreams-audio/audio/post-7278216743243491204-v1.mp3). [Read the narration transcript](https://manomatt.github.io/devopsdreams-audio/transcripts/post-7278216743243491204-v1.html) - [Open audio](https://manomatt.github.io/devopsdreams-audio/audio/post-7278216743243491204-v1.mp3) # Kubernetes In-Place Pod Resource Updates And Vertical Pod Resize Kubernetes can now resize a running Pod's CPU and memory without replacing it. This deep dive explains the resize API, kubelet behavior, failure states, VPA integration, and production limits. ## TL;DR [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-1) Kubernetes in-place Pod resource updates make container CPU and memory requests and limits mutable through the Pod resize subresource. Kubernetes records the requested values as desired state, while kubelet reports the resources actually configured on the existing node. CPU changes can usually avoid restarts; memory changes need deliberate resize policies and remain riskier, especially when decreasing limits. The feature is stable from Kubernetes 1.35, but it does not reschedule an undersized Pod, change its QoS class, update its controller template, or guarantee that application runtimes adapt automatically. ![Kubernetes Pod changing CPU and memory resources in place while retaining its identity, network, and storage.](data:image/svg+xml;base64,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) In-place Pod resize separates resource changes from Pod replacement: Kubernetes can change CPU and memory on the existing node while preserving Pod identity. ## Vertical Scaling No Longer Has to Mean Pod Replacement [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-2) For most of Kubernetes' history, changing a container's CPU or memory meant replacing its Pod. A Deployment or StatefulSet controller created a new Pod from an updated template; the scheduler placed it; kubelet rebuilt the sandbox; and the application started again. That model is simple, but it is expensive for stateful services, long-running jobs, game servers, pre-warmed workers, and latency-sensitive processes. [In-place Pod resize](https://kubernetes.io/docs/tasks/configure-pod-container/resize-container-resources/) breaks that coupling. CPU and memory requests and limits become mutable on the existing Pod. The Pod stays on its node and retains its UID, IP address, volumes, and sandbox. Depending on the container's policy and runtime behavior, even the container can continue running. The feature, also known as **In-Place Pod Vertical Scaling**, entered alpha in Kubernetes 1.27, became beta and default-enabled in 1.33, and [graduated to stable in Kubernetes 1.35](https://kubernetes.io/blog/2025/12/19/kubernetes-v1-35-in-place-pod-resize-ga/). Stable does not mean every resize is immediate or restart-free. It means the API and core behavior are production-grade; capacity, runtime, QoS, and workload-controller constraints still matter. **Version and client boundaries:** | Component | Minimum or feature state | Why it matters | | --- | --- | --- | | Kubernetes server | 1.33 or later for the current workflow | The feature was beta in 1.33 and stable in 1.35. | | Kubernetes 1.35+ | Stable, enabled by default | Container-level CPU and memory resize is GA. | | `kubectl` | 1.32 or later | Older clients do not support `--subresource=resize`. | | Kubernetes 1.36 Pod-level resize | Separate beta feature | It resizes a Pod-level resource budget rather than only container fields. | Start with the [official resize task](https://kubernetes.io/docs/tasks/configure-pod-container/resize-container-resources/) and confirm the versions you actually operate: ```bash kubectl version kubectl get nodes \ -o custom-columns='NAME:.metadata.name,KUBELET:.status.nodeInfo.kubeletVersion,RUNTIME:.status.nodeInfo.containerRuntimeVersion' ``` ## The Core Contract: Desired Resources Are Not Actual Resources [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-3) The most important architectural change is not that `resources` became mutable. It is that Kubernetes now exposes a deliberate gap between **what you requested** and **what kubelet has applied**. - `spec.containers[*].resources` is the desired CPU and memory state. - `status.containerStatuses[*].resources` is the resource state currently configured for the container. - `status.containerStatuses[*].allocatedResources` is kubelet-confirmed allocation data used mainly for internal scheduling decisions. - `status.conditions` explains whether a resize is pending or in progress. An accepted API patch only proves that Kubernetes stored the desired state. It does not prove that the node had capacity, the runtime changed its cgroups, or the application adapted. ![Execution path from kubectl resize request through the API server, scheduler accounting, kubelet, container runtime, and cgroups.](data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="760" viewBox="0 0 1200 760" role="img" aria-labelledby="title desc">
  <title id="title">Kubernetes in-place Pod resize execution path</title>
  <desc id="desc">A Kubernetes-branded architecture diagram showing a resize request moving from kubectl or VPA through the API server and scheduler, then to kubelet, the container runtime, Linux cgroups, and back as actual Pod status.</desc>
  <defs>
    <linearGradient id="pageBg" x1="0" y1="0" x2="1" y2="1">
      <stop offset="0" stop-color="#f7faff"/>
      <stop offset="1" stop-color="#e5efff"/>
    </linearGradient>
    <linearGradient id="controlBg" x1="0" y1="0" x2="1" y2="1">
      <stop offset="0" stop-color="#326ce5"/>
      <stop offset="1" stop-color="#2454b8"/>
    </linearGradient>
    <linearGradient id="nodeBg" x1="0" y1="0" x2="1" y2="1">
      <stop offset="0" stop-color="#f8fbff"/>
      <stop offset="1" stop-color="#e9f1ff"/>
    </linearGradient>
    <filter id="shadow" x="-25%" y="-25%" width="150%" height="160%">
      <feDropShadow dx="0" dy="10" stdDeviation="13" flood-color="#173465" flood-opacity=".22"/>
    </filter>
    <filter id="softShadow" x="-25%" y="-25%" width="150%" height="160%">
      <feDropShadow dx="0" dy="5" stdDeviation="7" flood-color="#173465" flood-opacity=".16"/>
    </filter>
    <marker id="blueArrow" markerWidth="11" markerHeight="11" refX="9" refY="4" orient="auto">
      <path d="M0 0 10 4 0 8Z" fill="#326ce5"/>
    </marker>
    <marker id="whiteArrow" markerWidth="11" markerHeight="11" refX="9" refY="4" orient="auto">
      <path d="M0 0 10 4 0 8Z" fill="#ffffff"/>
    </marker>
    <marker id="statusArrow" markerWidth="11" markerHeight="11" refX="9" refY="4" orient="auto">
      <path d="M0 0 10 4 0 8Z" fill="#f59e0b"/>
    </marker>

    <!-- Kubernetes seven-spoke wheel, redrawn as native vector geometry. -->
    <g id="kubeWheel" fill="none" stroke="#ffffff" stroke-linecap="round" stroke-linejoin="round">
      <circle r="29" stroke-width="7"/>
      <circle r="9" fill="#ffffff" stroke-width="3"/>
      <g stroke-width="7">
        <path d="M0-28V-50"/>
        <path d="M0-28V-50" transform="rotate(51.43)"/>
        <path d="M0-28V-50" transform="rotate(102.86)"/>
        <path d="M0-28V-50" transform="rotate(154.29)"/>
        <path d="M0-28V-50" transform="rotate(205.71)"/>
        <path d="M0-28V-50" transform="rotate(257.14)"/>
        <path d="M0-28V-50" transform="rotate(308.57)"/>
      </g>
    </g>
    <g id="kubeMark">
      <polygon points="0,-78 61,-49 76,17 34,70 -34,70 -76,17 -61,-49" fill="#326ce5"/>
      <use href="#kubeWheel"/>
    </g>
    <g id="podMark">
      <polygon points="0,-29 23,-18 29,7 13,26 -13,26 -29,7 -23,-18" fill="#326ce5"/>
      <circle r="11" fill="none" stroke="#ffffff" stroke-width="4"/>
      <path d="M0-10V-20M9-4l9-4M6 8l7 8M-6 8l-7 8M-9-4l-9-4" fill="none" stroke="#ffffff" stroke-width="4" stroke-linecap="round"/>
    </g>
  </defs>

  <rect width="1200" height="760" rx="30" fill="url(#pageBg)"/>
  <g opacity=".22" fill="none" stroke="#9bb9e8">
    <path d="M0 110H1200M0 220H1200M0 330H1200M0 440H1200M0 550H1200M0 660H1200"/>
    <path d="M120 0V760M240 0V760M360 0V760M480 0V760M600 0V760M720 0V760M840 0V760M960 0V760M1080 0V760"/>
  </g>

  <g font-family="Segoe UI, Arial, sans-serif">
    <text x="54" y="54" fill="#173465" font-size="30" font-weight="800">Kubernetes in-place Pod resize</text>
    <text x="54" y="86" fill="#4b6485" font-size="17">Desired resources enter through the control plane; actual resources return from the existing node.</text>

    <!-- Step 1: client -->
    <g transform="translate(42 178)" filter="url(#shadow)">
      <rect width="196" height="168" rx="24" fill="#ffffff" stroke="#326ce5" stroke-width="3"/>
      <circle cx="34" cy="34" r="20" fill="#326ce5"/>
      <text x="34" y="41" text-anchor="middle" fill="#ffffff" font-size="20" font-weight="800">1</text>
      <g transform="translate(98 55)" fill="none" stroke="#326ce5" stroke-width="5" stroke-linecap="round">
        <rect x="-35" y="-21" width="70" height="45" rx="7"/>
        <path d="M-19 8-7 17 17-8M-22 37H22"/>
      </g>
      <text x="98" y="113" text-anchor="middle" fill="#173465" font-size="20" font-weight="800">kubectl or VPA</text>
      <text x="98" y="139" text-anchor="middle" fill="#5b7190" font-size="15">PATCH Pod /resize</text>
    </g>

    <!-- Kubernetes control plane -->
    <g transform="translate(310 126)" filter="url(#shadow)">
      <rect width="354" height="390" rx="30" fill="url(#controlBg)"/>
      <rect x="2" y="2" width="350" height="386" rx="28" fill="none" stroke="#ffffff" stroke-opacity=".34" stroke-width="2"/>
      <g transform="translate(177 88)">
        <polygon points="0,-70 55,-44 68,15 30,63 -30,63 -68,15 -55,-44" fill="#ffffff"/>
        <g transform="scale(.82)">
          <use href="#kubeMark"/>
        </g>
      </g>
      <text x="177" y="178" text-anchor="middle" fill="#ffffff" font-size="23" font-weight="800">Kubernetes control plane</text>
      <text x="177" y="204" text-anchor="middle" fill="#dbe8ff" font-size="15">Validate, store, and account for intent</text>

      <g transform="translate(24 233)" filter="url(#softShadow)">
        <rect width="306" height="62" rx="15" fill="#ffffff"/>
        <circle cx="31" cy="31" r="18" fill="#326ce5"/>
        <text x="31" y="37" text-anchor="middle" fill="#ffffff" font-size="17" font-weight="800">2</text>
        <text x="62" y="27" fill="#173465" font-size="18" font-weight="800">API server</text>
        <text x="62" y="47" fill="#5b7190" font-size="14">Stores desired requests and limits</text>
      </g>
      <path d="M177 300V318" fill="none" stroke="#ffffff" stroke-width="3" marker-end="url(#whiteArrow)"/>
      <g transform="translate(24 321)" filter="url(#softShadow)">
        <rect width="306" height="48" rx="14" fill="#163f95" stroke="#90b6ff"/>
        <circle cx="27" cy="24" r="16" fill="#ffffff"/>
        <text x="27" y="30" text-anchor="middle" fill="#326ce5" font-size="16" font-weight="800">3</text>
        <text x="54" y="21" fill="#ffffff" font-size="16" font-weight="800">Scheduler accounting</text>
        <text x="54" y="38" fill="#dbe8ff" font-size="12">Protects node capacity while state converges</text>
      </g>
    </g>

    <!-- Worker node -->
    <g transform="translate(738 126)" filter="url(#shadow)">
      <rect width="420" height="390" rx="30" fill="url(#nodeBg)" stroke="#326ce5" stroke-width="3"/>
      <rect x="18" y="18" width="384" height="54" rx="16" fill="#173465"/>
      <g transform="translate(47 45) scale(.36)"><use href="#kubeMark"/></g>
      <text x="82" y="42" fill="#ffffff" font-size="20" font-weight="800">Existing worker node</text>
      <text x="82" y="60" fill="#c9d9f2" font-size="13">Same Pod UID · IP · volumes · sandbox</text>

      <g transform="translate(24 94)">
        <rect width="372" height="66" rx="16" fill="#ffffff" stroke="#326ce5" stroke-width="2"/>
        <circle cx="32" cy="33" r="19" fill="#326ce5"/>
        <text x="32" y="40" text-anchor="middle" fill="#ffffff" font-size="18" font-weight="800">4</text>
        <text x="64" y="29" fill="#173465" font-size="18" font-weight="800">kubelet</text>
        <text x="64" y="50" fill="#5b7190" font-size="14">Checks capacity and resize policy</text>
      </g>
      <path d="M210 164V180" fill="none" stroke="#326ce5" stroke-width="3" marker-end="url(#blueArrow)"/>
      <g transform="translate(24 184)">
        <rect width="372" height="66" rx="16" fill="#ffffff" stroke="#326ce5" stroke-width="2"/>
        <circle cx="32" cy="33" r="19" fill="#326ce5"/>
        <text x="32" y="40" text-anchor="middle" fill="#ffffff" font-size="18" font-weight="800">5</text>
        <text x="64" y="29" fill="#173465" font-size="18" font-weight="800">Container runtime</text>
        <text x="64" y="50" fill="#5b7190" font-size="14">Updates or restarts the container</text>
        <g transform="translate(329 33)"><use href="#podMark"/></g>
      </g>
      <path d="M210 254V270" fill="none" stroke="#326ce5" stroke-width="3" marker-end="url(#blueArrow)"/>
      <g transform="translate(24 274)">
        <rect width="372" height="86" rx="16" fill="#173465"/>
        <circle cx="32" cy="31" r="19" fill="#ffffff"/>
        <text x="32" y="38" text-anchor="middle" fill="#326ce5" font-size="18" font-weight="800">6</text>
        <text x="64" y="28" fill="#ffffff" font-size="18" font-weight="800">Linux cgroups</text>
        <text x="64" y="49" fill="#c9d9f2" font-size="14">Apply CPU and memory controls</text>
        <text x="64" y="70" fill="#75a7ff" font-size="13">cpu.max · cpu.weight · memory.max</text>
      </g>
    </g>

    <!-- Main desired-state arrows -->
    <path d="M238 262H294" fill="none" stroke="#326ce5" stroke-width="5" marker-end="url(#blueArrow)"/>
    <text x="266" y="245" text-anchor="middle" fill="#326ce5" font-size="13" font-weight="700">DESIRED</text>
    <path d="M664 321H720Q728 321 728 311V225Q728 215 738 215" fill="none" stroke="#326ce5" stroke-width="5" marker-end="url(#blueArrow)"/>
    <text x="701" y="300" text-anchor="middle" fill="#326ce5" font-size="13" font-weight="700" transform="rotate(-90 701 300)">ALLOCATE</text>

    <!-- Step 7: actual status returning -->
    <g transform="translate(52 594)" filter="url(#shadow)">
      <rect width="1096" height="108" rx="24" fill="#ffffff" stroke="#f59e0b" stroke-width="3"/>
      <circle cx="42" cy="42" r="22" fill="#f59e0b"/>
      <text x="42" y="50" text-anchor="middle" fill="#ffffff" font-size="21" font-weight="800">7</text>
      <text x="82" y="37" fill="#173465" font-size="21" font-weight="800">Kubelet reports actual Pod status</text>
      <text x="82" y="63" fill="#5b7190" font-size="16">status.containerStatuses[*].resources and resize conditions confirm what the node applied.</text>
      <rect x="82" y="76" width="950" height="2" fill="#e4ebf5"/>
      <text x="82" y="99" fill="#8a5a00" font-size="15" font-weight="700">Verify desired spec ≠ actual status until actuation completes.</text>
      <path d="M1048 0V-35Q1048-50 1033-50H992" fill="none" stroke="#f59e0b" stroke-width="4" marker-end="url(#statusArrow)"/>
    </g>
  </g>
</svg>) Resize is asynchronous. The API server stores intent; kubelet on the existing node actuates it; container status reports what actually changed. The request follows this path: 1. A user or autoscaler writes the Pod's `/resize` subresource. 2. Admission and API validation check the new values and preserve the Pod's QoS invariants. 3. Kubernetes stores the desired resources in the Pod specification. 4. Kubelet sees that desired and actual resources differ. 5. Kubelet checks node capacity and coordinates the change with the container runtime. 6. The runtime updates CPU and memory controls, typically Linux cgroups. 7. Kubelet updates container status and Pod resize conditions. During an incomplete resize, the scheduler accounts for the maximum of desired, allocated, and actual requests. That conservative rule prevents Kubernetes from treating capacity as free while different components still observe different generations of the Pod. Create a Pod with explicit CPU and memory policies: ```yaml apiVersion: v1 kind: Pod metadata: name: resize-demo namespace: qos-example spec: containers: - name: application image: registry.k8s.io/pause:3.10 resizePolicy: - resourceName: cpu restartPolicy: NotRequired - resourceName: memory restartPolicy: RestartContainer resources: requests: cpu: 500m memory: 256Mi limits: cpu: 500m memory: 256Mi ``` This is a Guaranteed-QoS Pod because request equals limit for both resources. Apply it and inspect the initial state: ```bash kubectl create namespace qos-example kubectl apply -f resize-demo.yaml kubectl get pod resize-demo -n qos-example -o yaml ``` ## CPU and Memory Need Different Resize Policies [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-4) The per-container `resizePolicy` separates two decisions: which resource changes and whether that change requires a container restart. ```yaml resizePolicy: - resourceName: cpu restartPolicy: NotRequired - resourceName: memory restartPolicy: RestartContainer ``` `NotRequired` is the default. It tells kubelet to update the running container. `RestartContainer` restarts that container within the same Pod before applying the new value. It does not replace the Pod. ![Decision diagram for CPU and memory resize policies followed by completed, deferred, infeasible, and in-progress outcomes.](data:image/svg+xml;base64,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) Policy determines whether a container restart is allowed; node capacity and runtime actuation determine the resulting resize state. CPU is usually the safer no-restart case. The runtime can adjust CPU shares, weight, or quota while the process continues. A larger CPU envelope still does not force the application to create more workers, and a smaller limit can increase throttling. Memory is harder. Raising a cgroup memory limit does not guarantee that a managed runtime expands its heap. Lowering a limit can place current usage above the new boundary and trigger an OOM kill. Since Kubernetes 1.35, kubelet allows memory-limit decreases and performs a best-effort usage check when the policy is `NotRequired`, but the [GA announcement explicitly warns](https://kubernetes.io/blog/2025/12/19/kubernetes-v1-35-in-place-pod-resize-ga/) that the check is not race-free. Increase CPU without restarting the container: ```bash kubectl patch pod resize-demo -n qos-example \ --subresource resize \ --patch '{"spec":{"containers":[{"name":"application","resources":{"requests":{"cpu":"1"},"limits":{"cpu":"1"}}}]}}' ``` Increase memory with the policy above: ```bash kubectl patch pod resize-demo -n qos-example \ --subresource resize \ --patch '{"spec":{"containers":[{"name":"application","resources":{"requests":{"memory":"384Mi"},"limits":{"memory":"384Mi"}}}]}}' ``` The CPU change should leave `restartCount` unchanged. The memory change should increment it because `RestartContainer` applies to memory. If both resources change in one request, the container restarts when either policy requires it. A Pod with `restartPolicy: Never` cannot declare a resize policy that requires a restart. Every resizable resource in that Pod must use `NotRequired`. ## A Resize Is an Asynchronous State Machine [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-5) Production automation must treat resize like reconciliation, not like a synchronous setter. Read the desired values, actual values, conditions, and generation together: ```bash kubectl get pod resize-demo -n qos-example -o json | jq '{ generation: .metadata.generation, observedGeneration: .status.observedGeneration, desired: [.spec.containers[] | {name, resources}], actual: [.status.containerStatuses[] | {name, resources, restartCount}], resizeConditions: [ .status.conditions[]? | select(.type == "PodResizePending" or .type == "PodResizeInProgress") ] }' ``` The main outcomes are: ### Completed [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-completed) Desired and actual resources match, the relevant resize condition has cleared, and `status.observedGeneration` shows that kubelet has acknowledged the current Pod generation. ### `PodResizePending` with `Deferred` [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-podresizepending-with-deferred) The node cannot grant the request now, but the request might become feasible after another Pod terminates or shrinks. Kubelet retries deferred resizes. It prioritizes higher `PriorityClass`, then Guaranteed over Burstable at equal priority, then older deferred requests. ### `PodResizePending` with `Infeasible` [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-podresizepending-with-infeasible) The resize cannot be satisfied on the current node—for example, the requested CPU exceeds node capacity. Kubernetes does not automatically reschedule the Pod onto a larger node. Submit a feasible value or use higher-level automation that can replace the Pod or change cluster capacity. ### `PodResizeInProgress` [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-podresizeinprogress) Kubelet accepted the allocation, but runtime actuation is incomplete. The condition can include `reason: Error` and a message when the runtime cannot apply the change. This distinction changes alerting. Do not page because `spec` and `status` differ for a few seconds. Alert when the gap persists beyond an operational threshold, when `Infeasible` appears, or when an in-progress resize reports an error. ## The Limits That Matter in Kubernetes 1.36 [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-6) The [current Kubernetes documentation](https://kubernetes.io/docs/tasks/configure-pod-container/resize-container-resources/#limitations) lists boundaries that determine whether in-place resize fits a workload: - Only CPU and memory are resizable. - Resize cannot change the Pod's original Guaranteed, Burstable, or BestEffort QoS class. - Guaranteed Pods must keep CPU and memory requests equal to limits. - BestEffort Pods cannot gain requests or limits through resize. - Non-restartable init containers and ephemeral containers cannot be resized; sidecar containers can. - A request or limit cannot be removed entirely after it is set; it can only change value. - Windows Pods do not support in-place resize. - Pods managed by static CPU Manager or static Memory Manager policies cannot be resized. - Pods using swap cannot resize memory requests unless memory uses `RestartContainer`. - Memory-limit reduction without restart remains best-effort and can still race with allocation. There is also a critical controller boundary: resizing a Pod does **not** update its owning Deployment or StatefulSet template. ```text Deployment template: 500m CPU Running Pod after resize: 1000m CPU Replacement Pod from unchanged template: 500m CPU ``` If the new size must survive Pod replacement, update the controller template as well or use a system that reconciles both lifecycle stages. Be deliberate when a GitOps controller owns the manifest; otherwise, live and declared state can diverge in ways your next rollout silently reverses. Kubernetes 1.36 also exposes a separate beta workflow for [in-place Pod-level resource resize](https://kubernetes.io/docs/tasks/configure-pod-container/resize-pod-resources/). Do not confuse that Pod-wide resource budget with the stable container-level mechanism explained here. ## VPA Turns the Mechanism Into an Autoscaling Policy [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-7) Core Kubernetes provides the resize actuator but does not decide the correct size. [Vertical Pod Autoscaler](https://kubernetes.io/docs/concepts/workloads/autoscaling/vertical-pod-autoscale/) supplies recommendations and update policy. Its relevant modes are: | VPA mode | Existing Pod behavior | | --- | --- | | `Off` | Produce recommendations only. | | `Initial` | Apply recommendations only when a Pod starts. | | `Recreate` | Evict the Pod so its controller creates a replacement. | | `InPlaceOrRecreate` | Attempt in-place resize, then fall back to eviction when necessary. | | `InPlace` | Never evict; wait and retry pending resize. Alpha in VPA 1.7.0. | ```yaml apiVersion: autoscaling.k8s.io/v1 kind: VerticalPodAutoscaler metadata: name: payments-api spec: targetRef: apiVersion: apps/v1 kind: Deployment name: payments-api updatePolicy: updateMode: InPlaceOrRecreate resourcePolicy: containerPolicies: - containerName: application minAllowed: cpu: 250m memory: 256Mi maxAllowed: cpu: "4" memory: 4Gi controlledResources: [cpu, memory] controlledValues: RequestsAndLimits ``` `InPlaceOrRecreate` is the pragmatic default when availability matters but eventual convergence matters more: it avoids disruption when possible and retains an eviction fallback. `InPlace` is stricter about continuity, but an infeasible resize can remain pending indefinitely because that mode will not evict the Pod. Coordinate VPA with [Horizontal Pod Autoscaler](https://kubernetes.io/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale/). HPA commonly evaluates CPU utilization as usage divided by requested CPU. Changing the request changes that denominator, so an in-place vertical resize can alter horizontal scaling decisions even when traffic and raw CPU consumption stay constant. Assign each autoscaler clear ownership of metrics and resources; otherwise, two valid control loops can work against each other. ## Why Kubernetes Built It This Way [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-8) Mutating the Pod specification directly without an explicit resize contract would hide too much. The `/resize` subresource creates a narrower authorization and validation surface. Separate desired and actual fields make asynchronous node actuation observable. Per-resource restart policies acknowledge that CPU and memory have different runtime semantics. Resize conditions distinguish a temporary capacity problem from an impossible request. The design also preserves the scheduler's fundamental safety model. A Pod remains bound to one node, so kubelet cannot promise resources that the node does not have. Conservative accounting protects the cluster while control plane, kubelet, and runtime converge. The trade-off is intentional: in-place resize minimizes disruption, but it is not rescheduling, node autoscaling, preemption, or application-level reconfiguration. That boundary makes the feature composable. VPA can decide values and fallback behavior. A node autoscaler can add capacity. An application controller can adapt worker counts or heap settings. Kubernetes core provides a reliable actuator and an observable state machine instead of pretending one resize primitive solves the entire vertical-scaling problem. ## A Production Rollout Checklist [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-9) Before enabling automated in-place resizing across a fleet: 1. Confirm API server, kubelet, container runtime, and `kubectl` versions. 2. Inventory QoS classes, static CPU/Memory Manager use, swap, Windows workloads, init containers, and sidecars. 3. Define CPU and memory `resizePolicy` explicitly rather than relying on defaults. 4. Test scale-up, scale-down, restart-required memory changes, `Deferred`, and `Infeasible` behavior. 5. Compare desired and actual resource fields in monitoring. 6. Alert on persistent generation gaps and resize error conditions. 7. Verify that application runtimes use newly available CPU or memory as expected. 8. Decide whether controller templates, GitOps state, or VPA own durable resource values. 9. Test HPA and VPA together under stable traffic and changing recommendations. 10. Keep disruption budgets and a recreate fallback for workloads where convergence outranks zero restart. Clean up the manual example when finished: ```bash kubectl delete namespace qos-example ``` ## Frequently Asked Questions [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-10) **Q: What are Kubernetes in-place Pod resource updates?** A: They let Kubernetes change a running container's CPU and memory requests or limits through the Pod `/resize` subresource. The Pod remains on its current node and retains its identity, IP address, sandbox, and mounted volumes. **Q: Does an in-place Pod resize restart the container?** A: Not necessarily. `resizePolicy` can use `NotRequired` to update the running container or `RestartContainer` to restart that container. If no policy is specified for a resource, Kubernetes defaults to `NotRequired`. **Q: How do I verify that a Pod resize succeeded?** A: Compare desired values in `spec.containers[*].resources` with actual values in `status.containerStatuses[*].resources`. Inspect `PodResizePending`, `PodResizeInProgress`, `status.observedGeneration`, and the container restart count before declaring success. **Q: Does resizing a Pod update its Deployment or StatefulSet?** A: No. The resize subresource changes one Pod, not the owning controller's template. Update the template or use a reconciling autoscaler if replacement Pods must inherit the new resources. **Q: Can VPA resize Pods without evicting them?** A: Yes. `InPlaceOrRecreate` first attempts in-place resize and can fall back to eviction. VPA's alpha `InPlace` mode never evicts; it keeps waiting and retrying if a resize is deferred, in progress, or infeasible. ## Primary Sources and Next Steps [Section link](https://devopsdreams.blogspot.com/2026/08/kubernetes-in-place-pod-resource.html#dd-section-11) - [Resize CPU and memory resources assigned to containers](https://kubernetes.io/docs/tasks/configure-pod-container/resize-container-resources/) - [Kubernetes 1.35: In-Place Pod Resize graduates to stable](https://kubernetes.io/blog/2025/12/19/kubernetes-v1-35-in-place-pod-resize-ga/) - [Kubernetes 1.33: In-Place Pod Resize graduates to beta](https://kubernetes.io/blog/2025/05/16/kubernetes-v1-33-in-place-pod-resize-beta/) - [KEP-1287: In-place update of Pod resources](https://github.com/kubernetes/enhancements/blob/master/keps/sig-node/1287-in-place-update-pod-resources/README.md) - [Resource management for Pods and containers](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) - [Vertical Pod Autoscaling](https://kubernetes.io/docs/concepts/workloads/autoscaling/vertical-pod-autoscale/) - [Horizontal Pod Autoscaling](https://kubernetes.io/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale/) - [Pod lifecycle and resize status](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/) - [Resize CPU and memory resources assigned to Pods](https://kubernetes.io/docs/tasks/configure-pod-container/resize-pod-resources/)