
Podの自動スケーリングとリソース管理:Adrian Moisey氏とJakub Pawełczak氏が語る IPPR・VPA・CPU Boost
Pod Autoscaling and Resource Management, with Adrian Moisey and Jakub Pawełczak

Podの自動スケーリングとリソース管理:Adrian Moisey氏とJakub Pawełczak氏が語る IPPR・VPA・CPU Boost
Kubernetes Podcast from Google
要約
Kubernetes SIG AutoscalingのテックリードであるAdrian Moisey氏と、GKEのプロダクトマネージャーJakub Pawełczak氏が、In-Place Pod Resizing(IPPR)とVPAの新モード、Startup CPU Boostを解説した回。再起動を伴わないリソース変更の仕組み、VPAとHPAの併用、Javaワークロードでの効果、AIエージェント時代のオートスケーリングの方向性が語られた。SIGの現状の取り組みやコミュニティへの参加方法も紹介されている。
この回のポイント
- ●IPPRはPod specの変更をkubeletが受け、空き容量を確認したうえでCRI経由でコンテナランタイムがcgroupを調整する。コンテナは再起動されず、処理は非同期・非ブロッキングである。
- ●VPAの従来モードはOff・Initial・Recreate(Autoは非推奨)。新たにIn-Place or Recreate(GA)とIn-Place Only(alpha、VPA 1.7.0)が加わった。
- ●Recreateは退避APIを使うためPDBが効き、一度に退避する割合などのセーフガードもあるため、適切に設定すれば比較的安全だとAdrian氏は述べている。
- ●JVM系ワークロードは起動時に多くのCPUを要する。CPU Boostで起動を安定・高速化し、その後に縮小することでノード密度を高められる(60%から80%への例が挙がった)。
- ●同じCPU・メモリ指標でHPAとVPAを併用すると衝突する。Adrian氏はHPAをキュー深度などのカスタム指標、VPAをPodサイズ調整に使い分けている。GKEではCPU指標での併用機能を開発中と説明された。
- ●今後はノードの空き状況を考慮したワークロード単位のオートスケーリングや、CarpenterなどノードレベルのツールとのPod形状の予測に関する調整が課題として挙がった。
章立て
ニュースと今回のテーマ紹介
Karmadaの卒業やllm-d 1.0などのニュースの後、再起動コストを減らすIPPRとCPU Boostがテーマだと紹介される。
ゲストの自己紹介
Adrian氏はSIG AutoscalingのテックリードでSIG Networkにも貢献。Jakub氏はGKEでワークロードのオートスケーリングを担当するPM。
IPPRの仕組み
KEP-1287によるIPPRの流れを、API・kubelet・CRI・cgroupの順に解説。容量不足の場合はResize Pendingになる。
VPAの歴史と新モード
Off・Initial・Recreateの従来モードと、In-Place or Recreate、In-Place Onlyの新モード、退避時の安全策を説明する。
JavaワークロードとCPU Boost
JVM起動時のCPU需要への対処と、スケジューラーがブースト後の値を見ること、ノード密度向上の効果を議論する。
HPAとVPAの併用
同一指標での衝突、カスタム指標との使い分け、GKEでのCPU指標併用の取り組みを紹介する。
AI・エージェント時代の展望
Agent Substrate、Carpenter、Rayとの連携を例に、ノードを意識したオートスケーリングの可能性を議論する。
SIGの活動とコミュニティ参加
VPAの設定をAPIに引き上げる取り組みや、Slack・GitHubでのフィードバックの呼びかけ、Java記事の紹介。
解説記事
Kubernetes Podcast from Googleの本エピソードでは、Kubernetes SIG AutoscalingのテックリードAdrian Moisey氏と、GKEでワークロードのオートスケーリングを担当するJakub Pawełczak氏が登場した。CPUやメモリの上限を変えるためにPodを落として再作成する「再起動税」をどう減らすかを軸に、IPPR、VPAの新モード、Startup CPU Boostの現状と今後が語られた。
IPPRはどう動くのか
In-Place Pod Resizing(IPPR)はKEP-1287で提案され、Kubernetes 1.27で最初に導入された機能だと説明された。Jakub氏によれば、Pod manifestのCPUやメモリを変更するとAPI経由でノードに渡り、kubeletがまず空きリソースを確認する。要求を満たせる場合、kubeletはCRIを通じてcontainerdなどのコンテナランタイムに伝え、ランタイムがcgroupを調整してコンテナを再起動せずにリソースを増減させる。容量が足りなければPodはresize pending状態となり、容量が空くのを待つ。この処理は非同期・非ブロッキングで、kubeletは他の作業を並行して続けられる。
IPPRで別ノードへの再スケジュールが起きるかという質問には、それはIPPRを使う側(たとえばVPA)のロジック次第だと答えた。ノードに空きがない状態が数分続けば、VPAがPodを移す設計もありうるという。
VPAの新モードと安全性
Adrian氏はVPAの歴史を整理した。従来はOff(推奨値の算出のみ)、Initial(再起動や再スケジュールなど自然にPodが作り直されるときにだけ新しいサイズを適用)、Recreate(Podを退避して正しいサイズで作り直す)があり、AutoはRecreateの別名だったが定義が曖昧なため非推奨になった。
IPPR対応として、最新のVPA 1.7.0では二つのモードが加わっている。GAのIn-Place or Recreateは、まずインプレースでの変更を試み、5分たってもできなければPodを退避する。alphaのIn-Place Onlyは一切Podを中断しない。Adrian氏は冗談交じりに「in-place or suffer」と呼びたかったと語った。
Recreateは中断が大きいと見られがちだが、Adrian氏は、退避できる割合の制限や新Podが準備できてから次に進むセーフガードがあり、退避APIを使うためPDB(Pod Disruption Budget)も尊重されるので、デプロイのロールアウトやHPAより危険とは言えないという見方を示した。Jakub氏は、GKEではVPAが動作する最小レプリカ数を2から1に変更するなど、レプリカ数の管理はHPAやデプロイに任せる方針を取っていると述べた。CPUはメモリと違って変更時の中断がほぼないため、過剰確保しているCPUからVPAを始めるのが良いとも語った。
JavaワークロードとStartup CPU Boost
Spring Bootのような従来型JVMは、起動時に多くのCPUを必要とする。大きく確保すれば無駄になり、小さければ起動が遅くなるというジレンマがある。Jakub氏は、CPU Boostにより、たとえば1 CPUで起動して12秒で立ち上げ、その後300〜500ミリコアに縮小するといった運用ができると説明した。スケジューラーはブースト後の値を見て配置するため、急なスケールアウトのスパイクにはcapacity bufferのような仕組みで備えるという。そのうえでノードの利用率を60%から80%程度に高められる可能性に触れた。
HPAとVPAの併用
同じCPU・メモリ指標でHPAとVPAを使うと、HPAが最大までスケールアウトし、VPAが最小サイズへ縮小して、小さなPodが大量にできるという理解をAdrian氏は示した。同氏の運用では、HPAはキューの深さやリクエスト遅延など負荷に応じた指標で、VPAはPodのサイズ決定に使うと相性が良いという。「HPAがトラックの台数、VPAがトラックの大きさを決める」という比喩も使われた。
Jakub氏は、CPU指標のHPAが簡単なため広く使われていることを踏まえ、GKEでHPAとVPAをCPU指標で併用できる機能に取り組んでいると述べた。これは冒頭のニュースで紹介されたパブリックプレビューにも対応する。コミュニティではmultidimensional pod autoscalerの議論もあるが、Kubernetesエコシステムにはまだ該当ツールがないとAdrian氏は述べている。
AI時代とノードレベルとの連携
Jakub氏は、オートスケーリングが開発者にとってより透明になり、プラットフォームチームが高い視点で挙動を管理する方向に進むとの見通しを示した。Rayとの統合例では、他のジョブが早く終わって空いたノードの余力を使い、実行中のジョブに追加リソースを与えて完了を早める使い方が紹介された。エージェントのサブタスクは事前に予測しにくいため、こうしたノードを意識した仕組みが有用だという。
Adrian氏は、ブーストされたPodを退避すると再作成時に大きなサイズで現れ、追加ノードが必要になりうるため、Carpenterの開発者と議論していると語った。Podのサイズが動的に変わる世界では、退避やリサイズ後の姿をどう定義するかが課題になる。
SIGの取り組みと参加方法
SIG Autoscalingは現在、VPAコントローラーのフラグで行っていた挙動の調整を、リソース単位でAPIから設定できるよう引き上げる作業を進めている。従来は用途ごとに複数のコントローラーを動かす必要があったが、それを避け、VPAをより使いやすくするのが狙いだ。VPAはgithub.com/kubernetes/autoscalerで開発されており、Kubernetes Slackの#vertical-pod-autoscalerなどでフィードバックを歓迎している。あるユーザーの報告からメモリ使用量を90%削減できた例も挙げられた。
まとめ
IPPRとVPAの新モードにより、リソース調整のために再起動を受け入れる必要は薄れつつある。日本の運用現場でも、JavaアプリのCPU過剰確保に悩むチームは、まずCPUに限定してIn-Place or Recreateを試すところから始められそうだ。一方で、ブースト後の退避やHPAとの併用、ノードレベルのツールとの調整はまだ発展途上である。自社の環境で試した結果をコミュニティに共有することが、改善につながるとゲストは呼びかけている。
文字起こし(英語・自動生成)
Hello, and welcome to the Kubernetes Podcast from Google. I'm your host, Kazlin Fields. In this episode, we sat down with Adrian Moisy, SRE, and Jakub Pavelczyk, Cloud Product Manager at Google Cloud. For years, updating container resources meant paying a steep restart tax by killing and rescheduling pods just to adjust CPU or memory limits. In this episode, we unpack how in-place pod resizing and startup CPU boost are changing that, how the vertical pod autoscaler integrates with in-place updates, and where Kubernetes autoscaling is heading next. But first, let's get to the news. Karmada has officially reached graduated status within the CNCF. Originally open-sourced by Huawei in 2021, Karmada, short for Kubernetes Armada, provides a centralized control plane for running and coordinating workloads across multiple Kubernetes clusters, regions, and cloud providers without changing application manifests.
The project's graduation coincides with the 1.19 release, which introduces multi-component scheduling for distributed AI training workloads and promotes priority-based multi-cluster scheduling to beta. The open-source LLMD project has reached version 1.0 under CNCF governance. Founded by Google Cloud, Red Hat, IBM, CoreWeave, and NVIDIA, LLMD is designed to optimize large language model serving and distributed inference across cloud-native infrastructure. Version 1.0 brings production-ready distributed scheduling and memory optimization for bursty token-intensive AI agent workloads. Google Kubernetes Engine announced public preview support for combining Vertical Pod Autoscaler and Horizontal Pod Autoscaler. Traditionally, running VPA and HPA simultaneously on the same metric risked severe control loop conflict. With this update, platform teams can automatically right-size container CPU requests via VPA, while letting HPA scale horizontal replicas based on real-time traffic demand.
GKE Standard has introduced in-place node upgrades for CPU node pools. GKE can now perform minor and patch node upgrades by updating the existing compute engine VM in place rather than terminating the VM and creating a brand new instance. This preserves compute capacity, attached storage, and underlying IP allocations during cluster upgrade cycles. Google Cloud has also announced the general availability of the micro VM sandbox type in GKE Sandbox for clusters running 1.37 and later. Under the hood, this uses Kata containers and Cloud Hypervisor to spin up tiny hardware-isolated virtual machine instances with its own dedicated Linux kernel for each pod in sub-second time. Unlike GVisor, which intercepts syscalls in user space, micro VMs provide full hardware virtualization and full Linux kernel compatibility, so your untrusted agent workloads get a true VM isolation boundary with container-native scheduling.
KubeCon CloudNativeCon North America 2026 is taking place November 9-12 in Salt Lake City, Utah. The flagship community conference features sessions and keynotes from experts across the cloud-native ecosystem. Alongside pre-conference prep in their October update, the CNCF celebrated passing 500 golden CubesterNuts worldwide and announced that the dot-project metadata governance rollout is now 97.8% complete across 228 hosted projects. As mentioned in our release episode, Kubernetes 1.37 promotes rootless mode to beta. This milestone allows node components, including the Kubelet, CRI container runtime, CNI plugins, and KubeProxy, to run as an unprivileged user inside Linux user namespaces on the host. This technique provides strong defense in depth against host-compromised CVEs originating from container breakouts. Check out the blog in the show notes for more information. Kubernetes 1.34 has officially reached end of life.
As signaled during the 1.37 launch, support for Kubernetes 1.34 officially ended on October 27, 2026. Version 1.34 will no longer receive upstream security patches or bug fixes, and cluster operators are encouraged to upgrade to version 1.35 or higher. Volcano version 1.16 has been released. The CNCF batch scheduling engine for high-performance AI ML and big data workloads added namespace queue isolation, fair share improvements, and broader hypernode integration. Windows 11 developers can now build, run, and manage native Linux OCI containers directly via WSL and a new CLI without needing Docker Desktop. It also integrates directly with Microsoft Intune for registry-allow listing and Microsoft Defender for endpoint for container runtime threat detection. And that's the news. For years, updating container resources meant paying a steep restart tax by killing and rescheduling pods in Kubernetes just to adjust CPU or memory limits.
Today, in-place pod resizing and startup CPU boost are changing that by allowing dynamic compute adjustment on the fly without touching the pod lifecycle. We are joined today by Adrian Moisy and Jakob Pavlojek to unpack how in-place updates work under the hood, how CPU Boost solves the startup hacks for heavy runtimes, and where Kubernetes auto-scaling is hidden next. Welcome to the show, Adrian and Jakob. Thank you. Thank you. Thank you, Havlo. Thank you for having us. All right, so to kick things off, can you please briefly introduce yourself and tell us what do you do with the Kubernetes community and how did you come to work on this in-place pod resource, resize resource management, Maybe starting with you, Adrian. Hi. So I've been with the Kubernetes community for about two years now. It all started at KubeCon EU in Paris, where it was my first KubeCon, and there was the new contributors session. And so I walked into that quite boldly, looking for somebody to chat to, and no one was ready. So I turned around and left. And then five minutes later, I came back in and chatted to a few SIGs.
I spent most of my time chatting to SIG Network and SIG Autoscaling, but eventually just started contributing to both of those SIGs. I'm currently a tech lead on SIG autoscaling and a contributor on SIG network. Awesome. Kathleen, my co-host, will be very happy about this because she is one of the leads for the SIG contributor experience. She was the person who I first spoke to when I walked in. Awesome. She'll be very happy. What about you, Jakub? So, I'm Jakub Pavelczak. I work as a product manager at GKE, and I'm focused on the workload autoscaling. And I'm engaged in the Kubernetes community through VerticalPod Autoscaler. We work with the communities to bring new features like in-place pod resizing. And I engage in in-place pod resizing because I saw an opportunity to remove operation toil for developers so they don't have to worry about resource requests and limits.
And instead can focus on developing features and innovation. Awesome. And we've been talking together for a while. We both work at Google. I think that this in-place pod update or in-place pod resizing or IPPR for short was introduced in CAP1287. That was like the first one in Kubernetes 127, I believe. Correct. Can you talk a little bit under the hood? Like, what's the relationship between that, and how does that trickle down through, like, the kubelet, the container run interface, the C groups, and all that underlying stuff? Sure, sure. So let's break down the process step by step. So you modify the container resources. So is the CPU memorable in the pod manifest? The changes are then pushed to the Kubernetes API, kubep API. And then once the request goes to the kubep API, it passes the updated pod spec to the node. And once it hits the node, Kublet checks if there are enough resources. And the check is very quick We lately introduced additional improvements in the latency so you have sub latency for getting information from Kublet about the in potter size
And once it gets the feedback from the node, if the sum of all node resources available for containers are greater or equal to the resources requested, then Kublet will apply the resources that you requested. If not, if there is not enough capacity, the pot is marked as a pot resizing pending, waiting to release the capacity, and it checks if the capacity is back. So let's say the changes are applied. Following the check, Kublet uses then the container runtime interface, CRI, to inform the container runtime, search container D, that is basically the container needs more or less resources. and the container runtime automatically adjusts the container C groups, increasing or decreasing the allocated resources without restarting the container. So the process is asynchronous and non-blocking,
allowing Kublet to continue on with other tasks in parallel. And I have talked about the IPPR in a couple of conferences, And one question I get often is, would this process in any moment in time trigger a pod being rescheduled on a different node to accommodate the increase in size or not? It's more on the logic of a container that uses IPPR. So, for example, VPA, if you're thinking about VPA, Vertical Pod Autoscaler, there could be a logic that if there is no space on Node, then move the pod somewhere else after some time. When, let's say, after a few minutes, the Node doesn't have still the resources, then the pod can be rescheduled. But about VPA, we can definitely talk and talk about it. Yeah, we're going to talk about this. And so you spoke about VPA, and this is a question to you, Adrian, maybe. So VPA, it has existed for a while. I think historically it was basically the only way you could vertically resize a pod was to kill it and recreate it, right?
And up to the new changes. Right. Let's talk about that first. Let's talk about the history of VPA and then maybe we'll dive a little bit into the new stuff. Okay. So the sort of historical modes in the VPA were recreate initial and off. There was also auto. Auto was at that moment in time an alias for recreate. And we've since defrecated auto because the definition is a little bit too fuzzy. What does auto mean? So in this case, we can use auto and recreate interchangeably. But starting from the least disruptive, we had off mode. The purpose of off is to look at the pods and to recommend what the slides should be and take no action. This is useful for monitoring over time to try and get an idea of what the BPA would do under certain circumstances. Then the next one, which I actually use quite heavily, is initial. and the idea is not to terminate a pod if it needs resizing, but rather if a pod is naturally recreated through a rollout, restart, or maybe a node is scheduled down or up, that sort of thing,
then the new pod will get the resize without being disruptive to the workload. And then recreate is the full-blown mode where when the VPA decides it needs to resize a pod, it will kill the pod so it can get recreated with the correct size. So those are all the historical versions, the historical modes before in-place pod resize. Interesting. I never thought about initial in the way you described it. So initial would resize the pod in the case that the pod had already been disrupted? Correct. Oh, interesting. Okay. So it's how recreate used to work. Recreate would not resize. Recreate would just kill the pod, allowing the admission controller to create the new pod of the new size. A much bigger pod, yeah. Or much smaller. So it's recreate without killing the pod, effectively. Letting something else kill the pod. Let the system kill the pod. Yeah, so I'm coming from the hardware space. That's basically what I would call opportunistic upgrade. 100%. Like we take advantage of something going down, and then we just do an upgrade anyway, right? Exactly, yeah. It comes with some downsides. If you need to resize the pod and nothing is going to kill the pod, you're kind of stuck.
Yeah. But it's less harsh than actively killing pods. Yeah, and I'm hoping... I mean, I know that a lot of people use pods as virtual machines, which is a different problem, but hopefully in a dynamic Kubernetes environment, pods would be eventually restarted, right? Correct. So then the follow-up question is, I feel like maybe historically the recreate mode was probably the least used mode in VPA because it's quite disruptive, right? Like, how does the integration now, like what's new in the new VPA API? Right. So let's talk about the new one. there's two new modes. The one is fully GA and the other one is currently in alpha in the latest VPA release 1.7.0. The GA version is in place or recreate. And the idea is attempt to do an inside replace. And if we can't, then after five minutes, kill the pod. The idea is if there's a need to resize the pod, then we kind of have to resize it at some stage, be it in place or a recreate. And that was released a few versions of VPA ago. And then since then, we've
added in-place only. And the idea is to not disrupt the pod at all. My personal opinion is I was going to call it in-place or suffer, because I assumed if the pod needed to be replaced, eventually you'd start, you'd either get um-killed or see if it's rattled. But that's not a great name, so we settled for in-place only. I like that. I'd also like to talk about recreate a little bit more. There's this perception that it seems to be disruptive, and I think it is, but I don't think it's more disruptive than rolling a new deployment or an HPA, for example. The VPA doesn't just go and kill all your pods at the same time. It's got various safeguards in place to only kill a certain percentage of your pods and to ensure that the new pods are ready before it'll continue killing the pods in that deployment or whatever your target is. It also uses the evictions API, so your PDB, the pod disruption budget, will protect your workload if you have configured. So I think recreate is pretty safe if you have the correct safeguards in place. And are these safeguards today configurable or they are hard coded? I forget
the details. The PDB I feel is since we're using the Victions API if a PDB exists it will use it. PDB is configurable of course. But you can't ask the VPA to opt out of that. If you have a PDB it will be in the path. The other settings I think they are configurable. I believe they are. I forget exactly what they're called, though. But the defaults should be same. They're pretty safe defaults. Maybe, Jacob, do you have an answer to this? Do you have more details? So, if you take the VPA OSS, you have definitely more ways to configure those things, aspects. In GKE, we use more approach to having more default behaviors. So, for example, we lately changed default behavior we had that VPA works if you have at least two pods up and running. Then the resize kicks in, but we changed that to one pod because this aspect,
how many replicas are in the deployment should be really handled by HPA and the deployment itself. So that kind of things you can change. And at the end of the day, VPA is very good for stateless workloads when you want to write size, right? And also the approach, how we create the recommendations, it's essentially to make sure the recommendations and the changes are reasonable. so I would say that there is a lot of mechanism that the disruption is minimized but in place we even further minimize that because for CPU you don't have really any disruptions right so CPU could be very very good candidate to start VPA with especially if you currently have over-provisioned workloads on CPU. Got it. So, following upon this I going to get to a question which I think I feel like this whole IPPR CPU boost one of the core things is Java workloads right I not sure how much of Java you have done in your career
I have done a little. So Java workloads, and I'm talking here about JVM specifically, because you can also do Java with native stuff with GraalVM where you don't have a JVM. You just have a native image. So we're going to put that aside and we're going to talk traditional JVM Spring Boot, which is I believe what like 90% of the industry is doing. Normally those require more CPU headroom at the beginning to be able to do all the stuff that the GVM does before the workload runs, right? So that leaves people at this dilemma which is oversized and then waste resources later or undersized and have the app start much slower, right? So the question is like where does IPPR and the new version of VPA kind of fits in this particular use case? So I can take that question. So what we hear from customers is that CPUs can help them in a way that the whole startup of application is more predictable.
So you can have, like, give me one CPU because then I know the application is up and running in, let's say, 12 seconds rather than 40 seconds. and then scale down to, let's say, 500 millicores or 300 millicores because this is enough I need to run my application. And what really we are adding with this is, and also with VPA itself, increased density of the workloads on the nodes. So you can have a bigger node with more workloads, but they are dense. They are more accurately right-sized, I would say. And with this, you have just better utilization. So you can go from 60% utilization of the node, maybe to 80% if you nicely fine-tune those things, those two features, VPA in place, or recreate and CPU boost.
Okay, so one follow-up question then. Does the VPA intervene after the scheduler in the Kubernetes scheduling process? In other terms, like, would the scheduler schedule based on the request initially, and then VPA will resize later, right? Because what you are saying is, for density, if we resize the pod before we schedule it, then we don't get the density we want. Do you see what I mean? So, as for CPU boost, the scheduler sees the boosted value. Okay. Right? One CPU. And the idea here is that if you have a lot of sudden pods that you need to boost, right, then you have other tools that we are bringing that can help you to absorb those spikes. So capacity buffers we see as enabling technology to get those spikes, but having a node with dense workloads that are handling, let's say, this general traffic. Got it. So this way you have very nice utilization, but you're also prepared for spike,
and you can improve the latency of the application having the CPU boost, right? So it's more about that. If you need to run hand-read pods, all our Java, you can make sure with CPU boost that you run those faster. You capture the traffic faster and then scale down for another growth. So that's kind of where we see it. Got it. Interesting. Yeah, because this is typically the kind of questions I would get when I talk about this, because the thing that makes Kubernetes quite complex is always this intersection of like VPA, horizontal port autoscaler, and scheduler itself. My next question then is going to be the following. You can horizontally scale, or you can vertically scale. Can you do both? And why would you want to or not want to? So I think the answer is yes, but. So my understanding, if you, I've never tried this, and I really should. If you both horizontally scale and vertically scale on the same metrics, in other words, CPU and memory,
my understanding is that what you end up with is the horizontal scalar will scale up to its max, and the VPA would have scaled down to its smallest value. So you end up with many small pods. That's my understanding. So they're kind of conflict. What I have found works really nicely is we have our HPS configured to scale on effectively queue depth. So if it's asynchronous workers, we can do the HPA based on how many items on the queue. If it's serving web requests, we can have metrics based on either web latency or request queuing or something to that effect. So effectively, the more requests we have, the more pods we have to handle it. So the HPA will scale up and down based on effectively load on the system. And in the VPA, we've configured to scale the sizing of the pod. As features are rolled out to the pods and they're potentially doing more work for the users, we might want bigger or smaller pods depending on what is happening in the system. So we found that works for us. I think there's probably many other smart solutions out there to scale both VPA and HPA.
There's also been talks in the community about a multidimensional pod autoscaler. But as far as I know, there's no tool that does that yet, at least in the Kubernetes ecosystem. I have heard of this before. There was something at GKE that does multidimensional. Correct. Yeah. Where is that now? Yeah, so I can definitely share a few things here. So what we also know that a lot of customers use HPA on CPU to manage scaling because it's very, very simple to set up. And teams that need to manage workloads, they don't have a lot of expertise in the space, so they prefer the simplest way to scale, which is CPU. And we know that VPA doesn't work well with HPA on CPU and VPA to right-size the CPU resources. But what we did in GKE, we are working on making sure that HPA and VPA work together on CPU metric and handles those aspects, should it be smaller pods or a few bigger.
So this is something we are working on. We shared that during the Google Next presentation a few months ago, and we are working with customers on testing this functionality. So we believe that that's the next step in having this automated workload-right sizing. So as a developer and platform thing, you don't have to think about those if-this-then-that situations. It just works. Got it. But I do really like the way you described how you're using this, Adrian, which is effectively VPA on standards metrics and HPA on custom metrics, right? That's essentially what you're saying. Correct. I kind of see it like a multi-lane highway. The HPA says I would like 10 trucks, which means I need a 10-lane highway. And then the VPA is saying, like, how big that truck is, what sort of, you know, oh, the road needs to be able to handle such a big truck. And so the VPA will ensure that the workload is sized correctly, and the HPA will ensure that I have enough workload or enough queues or workers
or whatever the thing is that you're using to handle the traffic that I'm serving. For us, it's worked really well. Yeah, I can see that as a pretty good setup if you have sticky sessions, for example. If you have the same pod handling more and more users, then you can VPA resize it or app resize it to just handle more users. But then as you have more users coming to the system, you just spin up more pods. Yeah. That's interesting. And so since we are in our lord of the year of 2026 and everything is AI, I want to switch a little bit toward AI. So how is this like auto-scaling dimensions kind of interact with the current landscape of like inference, GPUs, DRA, AI agents, all of that stuff? So I can start here. As I mentioned our goal is to make the autoscaling as invisible for developers as possible So how the Kubernetes autoscaling can evolve over the next few years is becoming more and more transparent really for developers
And giving the platform teams more and more capabilities to really manage on a more high-level view the autoscaling behavior. and get the intelligence inside itself, the VPA recommender, right? That you get the recommendations for right sizing. So that's how I believe the systems will evolve. Also, with all the agent skills, I'm sure there are plenty of platform engineers who will write on skills for many of those things. Of course. So I'm sure that's yet another angle here. Yeah, and I just had an interview early this week with Tim Hocken and one of our PMs about agent substrate. And I can see actually the way agent substrate works is that it decouples like the agent themselves from the pods. So I can see where VPA could actually fit in the agent substrate space. Because then the pods are just like the worker pools. And with VPA, we can upscale them so we can multiplex more agents into the same set of pods, right?
Maybe one thing we didn't touch on, and this is a random question that is not on the list, but we can completely scrape it if we don't have an answer. Because so far we just talked about, like, workload-level autoscaling. How is this kind of translating down to the infrastructure layer? Like to the cluster autoscaler, carpenter, all these existing tools, KDA, whatever. So I think they definitely do relate to one another. We have been in touch with the carpenter group about a CPU boost, particularly because they need to know what the shape of the pod will be if they were to evict a pod. And that is now becoming more tricky because they could evict a pod now a certain size, and it comes up boosted, which means they need to schedule an additional node. And so the discussion is around what will this pod look like in the future after I evict it? And maybe there's some sort of, touching back to the AI question, there's some sort of need to have a predictable VPA and HPA potentially is this agent is about to begin. Let me pre-allocate the resources.
But is there space on the node? And if there's no space on the node currently, how do I know that the new pod that I create is going to be, or what size that new pod will be? So I think in the traditional world of Kubernetes, when things were slightly more static, it was a lot easier for the various pods to interact with each other. And now that we're having this world where pods are dynamically changing on a node, it is getting more tricky, and we need to figure out a way to define what the pod will look like in some space in the future, either after an eviction or after a resize or something. Does that answer your question? I think it does. Like, maybe, Jakob, go for it, Jakob. I think you know what I'm trying to come. Yeah, yeah. So my thinking is that the system workload-level autoscane will also be more node-aware, right? And we have examples of that kind of use case when in-place spot resizing was integrated with Ray Platform. and the idea here is that if the system will recognize that the node has more resources
because some job finished earlier, it basically gives more resources so the current job can finish faster. Oh, interesting. And basically finish the task sooner. And that, I think, time to this metric, that time to completion is improved, utilization is improved, and so on. So I think that with that kind of approach, when the workload autoscaling is node-aware, we are going to more kind of flexible compute, right, where we can see, all right, we have 40% headroom on the node, but this workload may need more capacity, right, so it goes higher with CPN memory and can make the whole task faster. So, in a way, what you're describing is creating a sort of a feedback loop within the node itself. Yeah. But without really the pods talking to each other.
It's just basically the fact that you have pods trying to resize. So, if one is waiting for the resize and one other pod finishes earlier, it frees up the resources. So, then the other one can resize and then finish faster. Yeah. Oh, that's interesting. Okay. Yeah. So I think that's where we will go, especially with all the work related to agents and tasks that agents are spinning up. Yeah, I can see how that would be probably something that we need for these agentic workloads, because the sub-tasks spun up by an agent are very unpredictable up front, right? So you need to be able to allocate the compute resources for those. Yeah. Okay, cool. This is pretty cool. I have one last question for you, folks. Maybe this is for you, Adrian, working on the SIG auto-scaling. I think two questions. Where do you see the entry point to all of this, to like CPU, boost, VPA, in-placeable VPA? And like, what is your SIG working on? Let's start there, and then we can talk about that stuff.
What is the SIG working on? So we're actually working on improving the CPU startup boost at the moment. The VPA controller has various flags to control its behavior. And what we're doing is we're trying to bubble these up into the API to allow people to adjust the VPA based on the resource as opposed to the controller. The previous thing we would say is, please run multiple controllers with the various customizations that you want. So what we're trying to do is make the VPA more approachable, more customizable, more friendly to people's workloads and what they want out of it. Awesome. Jacob? So we definitely invite everybody to contribute to any caps that are for workload autoscenning. We also invite everybody to share their ideas, ask caps, for example, for their discussion and contribute with your perspectives. We have Slack channel where you can talk with Adrian directly on this channel, Vertical Put Autoscaler Kubernetes Slack channel. I'm there as well, so happy to engage with the community
and discuss how we can get Vertical Put Autoscaler to be a robust resource management API. Awesome. Could I continue on the previous topic of the contribution? Yeah, go ahead. Okay. Vertical Bot Autoscaler runs out of github.com slash kubernetes slash autoscaler. So people are welcome to create issues and pull requests there. Something that I think we really do value is feedback from the community. I could be wrong, but I have a feeling some people might try it out. It might not scoop them, and they would move on and not bring us feedback. And so any feedback, be it positive or negative, is very welcome because it helps us figure out what we need to do. we recently got somebody who put in a bug about VPA's memory usage, and in their particular use case, we managed to save 90% of memory, which I'm very happy about. Nice. But that's because they filed an issue, and we could actually work on it. So people running this thing at scale, please let us know. We'd love to hear how you're working with it and what we can do to improve it for you. Awesome. We'll make sure to include the links to the Slack channel and to the GitHub repository in the show notes.
And before we wrap up, I'm going to make a personal plug. I wrote an article on a Java magazine about the impact of CPU boost and IPPR. Jacob is uploading on GVM type workloads and how the GVM ergonomics kind of fit within that space. I believe it's going to be out by the time this episode is out. So we'll make sure we include the link in the show notes. Thank you, folks. Thank you, Adrian. Thank you, Jacob. Thank you, guys. Thank you. It's good to be on the show. Awesome. Awesome. Bye. That brings us to the end of another episode. If you enjoyed the show, please help us spread the word and tell a friend. If you have any feedback for us, you can find us on social media at kubernetespod or reach us by email at kubernetespodcasts at google.com. You can also check out the website at kubernetespodcasts.com where you'll find transcripts, show notes, and links to subscribe. Please consider rating us in your podcast player so we can help more people find and enjoy the show. Thanks for listening, and we'll see you next time.
Thank you.
番組の概要欄(原文)
Adrian Moisey is a Staff Site Reliability Engineer (SRE), a Technical Lead for Kubernetes SIG Autoscaling, and a contributor to SIG Network. Jakub Pawełczak is a Cloud Product Manager on Google Kubernetes Engine (GKE) at Google Cloud focused on workload autoscaling. For years, updating container resources meant paying a steep "restart tax" by killing and rescheduling Pods just to adjust CPU or memory limits. In this episode, we unpack how In-Place Pod Resizing (IPPR) and Startup CPU Boost are changing that, how the Vertical Pod Autoscaler (VPA) integrates with in-place updates, and where Kubernetes autoscaling is heading next. Do you have something cool to share? Some questions? Let us know: web: kubernetespodcast.com mail: kubernetespodcast@google.com twitter: @kubernetespod bluesky: @kubernetespodcast.com News of the week CNCF announces Karmada graduation (and Karmada v1.19 release) llm-d reaches version 1.0 under CNCF governance GKE Public Preview: Combining Vertical Pod Autoscaler (VPA) with Horizontal Pod Autoscaler (HPA) GKE Standard: In-Place Node Upgrades for CPU node pools GKE Sandbox: General Availability of the microVM sandbox type KubeCon + CloudNativeCon North America 2026 CNCF October Update: Passing 500 Golden Kubestronauts & .project metadata governance Kubernetes v1.37: KubeletInUserNamespace (aka Rootless mode) Graduates to Beta (and Kubernetes Podcast Episode 271: Kubernetes 1.37, with Dipesh Rawat) Kubernetes v1.34 reaches End of Life Volcano v1.16 released WSL Containers (WSLc) now Generally Available on Windows 11 (Cloud Native Now coverage) Links from the interview KEP-1287: In-Place Update of Pod Resources (IPPR) Resize CPU and Memory Resources assigned to Containers (Kubernetes Docs) Kubernetes Autoscaler & Vertical Pod Autoscaler (VPA) on GitHub Accelerate application startup with CPU startup boost in GKE Google Cloud Blog: GKE CPU startup boost: Faster pod starts, lower costs JAVAPRO Magazine (09-2026): The Next Chapter of Kubernetes and Java: Java Apps and Dynamic Resource Allocation (Direct PDF) Kubernetes SIG Autoscaling & Kubernetes Slack (#sig-autoscaling / #vertical-pod-autoscaler) Kubernetes SIG Contributor Experience Specifying a Disruption Budget for your Application (PDB) Karpenter & KEDA KubeRay (Ray on Kubernetes) Kubernetes Podcast Episode 272: Agent Substrate, with Tim Hockin and Brandon Royal
出典・この記事について
- 番組
- Kubernetes Podcast from Google(Abdel Sghiouar, Kaslin Fields)
- 元の回
- Pod Autoscaling and Resource Management, with Adrian Moisey and Jakub Pawełczak
- 配信日
- 要約作成日
- 公式サイト
- kubernetespodcast.com
この要約・解説記事は、元の音声を文字起こしした内容をもとに AI(Claude)が日本語で作成したものです。 固有名詞や数値に誤りを含む場合があるため、正確な内容は元の音声でご確認ください。制作方法について

