Kubernetes 1.38 Preview: Enhancements Tracked for the December 2026 Release, Deprecations and How to Prepare Your Clusters
Most Kubernetes upgrade pain comes from removed API versions. The next release breaks that pattern. Kubernetes 1.38 is due on Wednesday, 16 December 2026, and code freeze passed on 16 November. The draft release-team sneak peek names no REST API removals at all. Instead, the breaking changes sit on the node and the client: the kubelet will refuse to guess its cgroup driver, two kubectl environment variables disappear, and pod-level resources change swap behaviour on some Linux nodes. That shift matters now because it moves upgrade risk away from manifest linting and toward node images, container runtimes and CI scripts, which most pre-upgrade tooling does not inspect. You will leave with a verified schedule, the full list of 62 enhancements still tracked after code freeze, an honest view of what is confirmed versus at risk, provider timelines for EKS, GKE and AKS, and a checklist you can run this week.
What this covers: the v1.38 release calendar, how the tracked list shrank from 102 to 62 KEPs, stable/beta/alpha tables with KEP links, breaking changes, managed-service timelines, a pre-upgrade checklist and an adoption decision matrix.
Context and Background
Kubernetes ships three minor releases a year, roughly every four months. Each cycle is run by a volunteer release team under SIG Release and is gated by a fixed set of freezes. A feature enters a release through a Kubernetes Enhancement Proposal, or KEP: a design document with a numbered tracking issue in the kubernetes/enhancements repository. The KEP names its target stage for the cycle (alpha, beta or stable) and must pass a production readiness review before the enhancements freeze.
The recent cadence is regular. Kubernetes v1.35 was released on 17 December 2025. v1.36, named “Haru”, followed on 22 April 2026; its release blog counts 18 stable, 25 beta and 25 alpha enhancements. v1.37, named “Garhwal”, was announced on 26 August 2026 with 16 stable, 23 beta and 27 alpha enhancements plus one deprecation or removal. We covered several of the v1.37 headline features in depth, including the v1.37 Memory QoS and pod-level resource managers beta and the stable Metrics API and rootless kubelet in v1.37.
Support windows put pressure on this cadence. The upstream releases page currently lists end-of-life dates of 27 October 2026 for v1.34, 28 February 2027 for v1.35, 28 June 2027 for v1.36 and 28 October 2027 for v1.37. In other words, v1.34 is already out of upstream patch support, and v1.35 has about ten weeks left after v1.38 ships. Teams on v1.35 today will be two minors behind on release day.
The primary sources for this article are the SIG Release v1.38 schedule, the kubernetes/enhancements issue labels as of 20 November 2026, and the draft v1.38 sneak-peek blog in kubernetes/website pull request 59188. That pull request was still open and unmerged when this was written, so we treat its contents as the release team’s current intent rather than a final announcement. The official “Deprecations and Removals” post is scheduled for 23 November, three days after publication.
The thesis is simple. In v1.38 the risk has moved. API version removals dominated upgrades from v1.16 through v1.32, and tools like kubectl convert and deprecated-API scanners were built for that world. In v1.38 the work is mostly about node bootstrapping, container runtime versions, client scripts and a handful of behaviour changes in features that are graduating. Treat it as a node and client upgrade first.
Kubernetes 1.38 Release Date, Schedule and Tracked Enhancements
Kubernetes 1.38 is scheduled for release on Wednesday, 16 December 2026. Enhancements freeze fell on 29 September (AoE), and code and test freeze on 16 November (AoE). As of 20 November, 62 KEPs carry the tracked/yes label for the v1.38 milestone: 11 targeting stable, 26 beta, 23 alpha and 2 without a stage label.

Figure 1: The Kubernetes 1.38 release calendar from the SIG Release schedule, with typical managed-provider lag after GA.
Figure 1 reads left to right. The cycle opened on Monday 31 August, and the KEP readiness deadline and enhancements freeze followed in weeks 4 and 5. Three alpha builds and one beta build preceded code freeze, then the release candidates and docs freeze arrive on 3 December. The right-hand branches show when managed services have historically followed, which we unpack later.
The schedule is final, and one early date changed
The schedule in the SIG Release repository is the authoritative one. Its key dates are below, with Anywhere-on-Earth (AoE) deadlines translated to UTC by the release team itself.
| Milestone | Date | Notes |
|---|---|---|
| Release cycle begins | Mon 31 Aug 2026 | Enhancements tracking opens |
| KEP readiness deadline | Tue 22 Sep 2026 AoE | Wed 23 Sep, 12:00 UTC |
| v1.38.0-alpha.1 | Wed 23 Sep 2026 | First pre-release |
| Enhancements freeze | Tue 29 Sep 2026 AoE | Wed 30 Sep, 12:00 UTC |
| v1.38.0-alpha.2 / alpha.3 | 7 Oct / 21 Oct 2026 | |
| v1.38.0-beta.0 | Wed 4 Nov 2026 | Feature blog freeze same day |
| Code and test freeze | Mon 16 Nov 2026 AoE | Tue 17 Nov, 12:00 UTC |
| Deprecations and removals blog | Mon 23 Nov 2026 | Official list published |
| release-1.38 branch, rc.0, docs freeze | Thu 3 Dec 2026 | Docs freeze AoE |
| v1.38.0-rc.1 | Wed 9 Dec 2026 | Last planned candidate |
| v1.38.0 released | Wed 16 Dec 2026 | Release blog same day |
One discrepancy is worth noting for anyone reading older sources. The original “Release Cycle Sneak Peek” email on the Kubernetes dev list proposed code freeze for 18 November (AoE), and said the schedule was still being finalised. The published schedule moved it to 16 November. The release date itself, 16 December, has not changed in any source we checked.
The cycle also shifted where its slack sits. The dev-list email explained that the usual gap between releases was moved to the period between enhancements freeze and code freeze, to give contributors more implementation time. That is why the gap from freeze to code freeze is seven weeks, which is longer than in many past cycles.
How 102 opted-in KEPs became 62
Enhancement counts shrink during every cycle, and v1.38 is no exception. The “Last Week in Kubernetes Development” newsletter for the week ending 4 October reported that 102 enhancements were opted in, 86 were tracked at enhancements freeze, and 16 were removed from the milestone. By 20 November, after code freeze, a search of the enhancements repository returns 62 open issues labelled tracked/yes with the v1.38 milestone.

Figure 2: How the Kubernetes 1.38 enhancements list narrowed from opt-in to code freeze, with the post-freeze split by target stage.
Figure 2 makes the attrition visible. Roughly 24 KEPs, or about 28 percent of the frozen list, left the milestone between enhancements freeze and our snapshot. This is normal behaviour, not a sign of a troubled release. Code freeze is when SIGs discover that a feature is not merged, tested or documented in time, and the release team removes it rather than ship a half-finished gate.
Some of the departures are visible in the labels. KEP-4412, projected service account tokens for kubelet image credential providers, was reported as “targeting GA in Kubernetes 1.38” in early October. Its issue now has no milestone. A group of issues updated on 17 and 18 November now carry tracked/no with the milestone cleared. These include KEP-2570 (Memory QoS with cgroup v2, beta), KEP-5419 (pod-level resources with in-place vertical scaling, stable), KEP-5440 (mutable container resources for suspended Jobs, stable), KEP-1979 (Container Object Storage Interface, beta) and KEP-4438 (restarting sidecar containers during Pod termination, alpha). The labels alone do not record why or exactly when each left, so treat these as “not in v1.38 unless the release notes say otherwise”.
What “tracked” does and does not guarantee
A tracked/yes label after code freeze is a strong signal, but not a promise. The release team can still pull a feature during burndown if tests regress, and docs freeze on 3 December can remove features that lack documentation. Exceptions can also add work back. The final count is whatever the v1.38 changelog and release blog list on 16 December.
The stage/* label is also subtler than it looks. It names the stage the KEP targets in this cycle, not necessarily a graduation. Gang scheduling (KEP-4671), for example, carries stage/beta, but its kep.yaml records beta in v1.37 and stable planned for v1.39. In v1.38 it is continuing beta work. Where we could read the kep.yaml milestone fields, we note whether a KEP is graduating or continuing.
Finally, the 62 count is not directly comparable to the v1.37 headline of 67. Release blogs often count deprecations and removals in the total, while our snapshot counts only open enhancement issues. On a like-for-like stage basis, v1.37 shipped 66 graduating or new enhancements, so v1.38 looks similar in size, with fewer GA items.
Deeper Analysis: The 62 Tracked KEPs, Stage by Stage
The tables below list every KEP labelled tracked/yes for Kubernetes 1.38 on 20 November 2026. Each number links to its tracking issue. “Graduating” means the KEP’s kep.yaml names v1.38 as the milestone for that stage; “continuing” means the stage was reached earlier and work continues. Where we did not read the kep.yaml, the column says “label only”.
Stable (GA) targets: 11
| KEP | Enhancement | SIG | Status in v1.38 |
|---|---|---|---|
| 2837 | Pod-level resources | node | Graduating (alpha 1.33, beta 1.34) |
| 3104 | kuberc: kubectl user preferences | cli | Graduating (alpha 1.33, beta 1.34) |
| 3157 | WatchList: streaming informers instead of chunked LIST | api-machinery | Graduating (alpha 1.27, beta 1.32) |
| 4006 | Transition from SPDY to WebSockets | api-machinery | Graduating (alpha 1.29, beta 1.31) |
| 4815 | DRA: partitionable devices | scheduling | Graduating (alpha 1.33, beta 1.36) |
| 4858 | IP/CIDR validation improvements | network | Graduating (alpha 1.33, beta 1.36) |
| 5007 | DRA: device binding conditions | scheduling | Graduating (alpha 1.34, beta 1.36) |
| 5075 | DRA: consumable capacity | scheduling | Graduating (alpha 1.34, beta 1.36) |
| 5905 | Move kubernetes-mixin to kubernetes-sigs | instrumentation | Label only (project process) |
| 5922 | Explicitly indicating future conformance tests | architecture | Label only (project process) |
| 6356 | Publishing ktesting | testing | Label only (project process) |
Three themes dominate the GA list. First, Dynamic Resource Allocation (DRA) continues its march: partitionable devices, binding conditions and consumable capacity all target stable. Second, API server scalability gets a long-awaited GA in WatchList. Third, two kubectl changes, kuberc and the WebSocket transition, finish their multi-year journeys.
Beta targets: 26
| KEP | Enhancement | Status |
|---|---|---|
| 2371 | CRI-only container and pod stats, no cAdvisor | Continuing (beta 1.37) |
| 3541 | StatefulSet Recreate update strategy | Graduating (alpha 1.37) |
| 4671 | Gang scheduling | Continuing (beta 1.37) |
| 4885 | Windows CPU and memory affinity | Label only |
| 4939 | TLS credentials in gRPC probes | Label only |
| 4960 | Container stop signals | Label only |
| 5237 | Watch-based route controller in cloud controller manager | Label only |
| 5502 | Sticky bit for emptyDir volumes | Label only |
| 5517 | DRA: node allocatable resource requests | Label only |
| 5547 | Workload APIs integrated with the Job controller | Label only |
| 5710 | Workload-aware preemption | Continuing (beta 1.37) |
| 5732 | Topology-aware workload scheduling | Label only |
| 5793 | Manifest-based admission control config | Continuing (beta 1.37) |
| 5825 | CRI list streaming | Label only |
| 5836 | Scheduler preemption for in-place pod resize | Graduating (alpha 1.37) |
| 5866 | Server-side sharded LIST and WATCH | Graduating (alpha 1.36) |
| 5936 | User fields for atomic-write volumes | Label only |
| 5945 | DRA: optional node operations | Label only |
| 5996 | Default pod sysctls in the kubelet | Label only |
| 5999 | HTTP/2 cleartext (h2c) container probes | Label only |
| 6012 | CompositePodGroup API | Label only |
| 6030 | Dynamic resize of memory-backed volumes | Label only |
| 6032 | Localhost NodePort userspace proxy for nftables | Label only |
| 6089 | Workload-aware scheduling: controller integration APIs | Label only |
| 6132 | PreQueueingHint scheduler extension point | Label only |
| 6404 | API server write throughput improvements | Label only |
Alpha targets: 23, plus 2 unlabelled
| KEP | Enhancement |
|---|---|
| 4443 | Granular failure reasons for Job PodFailurePolicy |
| 4563 | EvictionRequest API |
| 5474 | Writable cgroups for unprivileged containers |
| 5491 | DRA: list types for attributes |
| 5677 | DRA: resource availability visibility |
| 5681 | Conditional authorization |
| 5683 | Specialized lifecycle management |
| 5714 | Choose whether to unshare cgroup namespaces |
| 5758 | Per-container ulimits |
| 5941 | DRA: shared consumable capacity |
| 5972 | Dynamic pod mutation |
| 6007 | Topology Manager option for single-NUMA-node density |
| 6011 | CSI ControllerGetNodeInfo |
| 6058 | CSI global mount fallback for volume reconstruction |
| 6060 | API server authentication to webhooks |
| 6061 | OCI artifact-based security profile distribution |
| 6252 | Hugepages in kubelet system-reserved and kube-reserved |
| 6264 | Configurable etcd object compression in kube-apiserver |
| 6268 | Stall and resume slow watch streams |
| 6276 | Workload APIs integrated with the Deployment controller |
| 6283 | Leveraging certificate APIs in the platform |
| 6313 | Network-isolated pods |
| 6406 | DRA extended resource capacity |
| 6315 | Weighted load balancing for kube-apiserver (no stage label) |
| 6361 | Controller leader election recovery (no stage label) |
Five GA changes that alter day-two operations
Pod-level resources (KEP-2837). This lets you set CPU, memory and hugepages requests and limits for a Pod as a whole, so containers can share a budget. At GA it becomes a stable API you can build platform defaults on. The catch is swap: on Linux nodes with cgroup v2 and LimitedSwap, the v1.38 kubelet will derive swap limits from pod-level memory settings. A Pod whose pod-level memory request equals its limit gets no swap at all, for every container, even if a container’s own request is below its limit. We explained the cgroup mechanics of pod-level managers in our v1.37 memory QoS guide.
WatchList (KEP-3157). Informers have historically started with a LIST call, which forces the API server to build an entire response in memory. The KEP’s own summary describes the API server as “vulnerable to memory explosion” in large clusters, where a few concurrent LISTs can cause serious disruption. WatchList lets clients start a watch that streams initial state from the watch cache instead. At GA the WatchList feature gate is expected to lock on, which should reduce memory spikes during controller restarts. Clients built on older client-go versions still use LIST, so the benefit depends on your controllers’ library versions.
IP/CIDR validation (KEP-4858). API validation of IP and CIDR strings has been lax since the Go 1.17 change that followed CVE-2021-29923. The KEP rejects IPv4 addresses with leading zeros, such as 010.0.0.1, and IPv4-mapped IPv6 addresses, such as ::ffff:1.2.3.4. It uses ratcheting validation, so existing objects with bad values keep working until you change that field. New manifests, generated Helm values and GitOps sources with such values will be rejected.
DRA partitionable devices, binding conditions and consumable capacity (KEPs 4815, 5007, 5075). Partitionable devices let a DRA driver advertise a GPU both whole and as partitions, while the scheduler only allocates combinations that fit. Consumable capacity lets several claims share a device’s capacity. Binding conditions let the scheduler wait for a device to be attached before binding a Pod. Together they make DRA viable as the default GPU-sharing path, which we compared to the classic device plugin in our v1.37 DRA versus device plugin analysis.
kuberc (KEP-3104) and WebSockets (KEP-4006). kuberc moves kubectl aliases, default flags and a credential plugin allowlist out of kubeconfig and into a separate preferences file, and the stable kubectl.config.k8s.io/v1 API arrives with v1.38. WebSockets have been the default for exec, attach and cp since v1.30 and for port-forward since v1.31. In v1.38 the opt-out environment variables are removed, and the server-side gates such as PortForwardWebsockets and TranslateStreamCloseWebsocketRequests are expected to lock on.
Beta and alpha features worth watching
Several betas change how operators work even before GA. The StatefulSet Recreate strategy (KEP-3541) deletes all Pods, waits for termination, then recreates them. That fixes a long-standing complaint: a rolling update stuck on a broken Pod will not repair itself even after you fix the spec. Scheduler preemption for in-place resize (KEP-5836) lets a resize that exceeds node capacity evict lower-priority Pods, rather than sitting in a Deferred state. That complements the in-place pod resize mechanics we covered earlier.
Server-side sharded LIST and WATCH (KEP-5866) lets a client ask the API server for one shard of a resource. Horizontally scaled controllers such as kube-state-metrics then receive only the objects they own, instead of filtering everything client-side. For large clusters this pairs naturally with WatchList at GA.
Among the alphas, three deserve attention. The EvictionRequest API (KEP-4563) adds a coordinated eviction path in which responders can finish work or migrate data before a Pod is terminated, falling back to the classic eviction API and its PodDisruptionBudgets. Network-isolated pods (KEP-6313) give a Pod a network namespace with only loopback, useful for sandboxed batch work. Writable cgroups (KEP-5474) adds a CgroupOptions field in the container security context so unprivileged containers can manage their own cgroup v2 subtree, relying on the kernel’s nsdelegate mount option.
Kubernetes 1.38 Deprecations and Breaking Changes
The draft sneak peek groups the v1.38 changes into deprecations and removals, ongoing major changes, and breaking changes. None of them is a REST API version removal. All of them are easy to miss with manifest-only tooling.
The kubelet must learn its cgroup driver from the runtime
This is the change most likely to break a self-managed upgrade. Since KEP-4033 reached stable in v1.34, the kubelet can ask the container runtime for its cgroup driver through the CRI RuntimeConfig call. Older kubelets kept a fallback: if the runtime did not answer, they used the cgroupDriver field in the kubelet configuration. According to the draft sneak peek, v1.38 makes that fallback unavailable by default.

Figure 3: Kubelet startup in Kubernetes 1.38. The runtime must answer the CRI RuntimeConfig call, or the kubelet exits before the node registers.
Figure 3 shows the new ordering requirement. The container runtime must be running before the kubelet starts, because the kubelet queries it during initialisation. If the runtime lacks the RPC, the kubelet retries and then exits with an error before registering the Node. The draft says the cgroupDriver field is deprecated and rejected unless you enable a temporary LegacyCgroupDriverFallback feature gate. It also says kubeadm will stop setting cgroupDriver: systemd by default and its preflight checks will fail if the runtime lacks support.
There is an honest uncertainty here. The implementing pull request, kubernetes/kubernetes#136731, was deferred out of v1.37 after reviewers asked for a temporary escape hatch. We could not confirm its final merge state in Kubernetes 1.38 from public pages. The draft blog’s description, including the gate name, is the best current signal, but check the v1.38 changelog on release day.
Client and webhook changes
Two kubectl changes affect scripts. The KUBECTL_REMOTE_COMMAND_WEBSOCKETS and KUBECTL_PORT_FORWARD_WEBSOCKETS environment variables are removed and will have no effect. kubectl will always try WebSockets first and fall back to SPDY. If a proxy or bastion in your path cannot handle WebSocket upgrades, setting the variable to false will no longer save you. Separately, kuberc credential-plugin allowlist entries using name must switch to command, because the stable v1 API drops the alias that was deprecated in v1.36.
The webhook change started in v1.37. With ExcludeAdmissionWebhookVirtualResources on by default, admission webhooks no longer see virtual writes such as TokenReview, SubjectAccessReview and SelfSubjectRulesReview. Configurations naming those resources now produce a deprecation warning. The gate is planned to lock on when KEP-5793 reaches stable, so any audit webhook that relied on seeing those requests needs a replacement, such as API server audit logging.
cgroup v1 is still on borrowed time
Since v1.35 the kubelet refuses to start on cgroup v1 nodes unless failCgroupV1: false is set. That option remains available in Kubernetes 1.38, but the release team describes it as a short-term fix and points to KEP-5573 for full removal in a future release. If any node image still boots with cgroup v1, the v1.38 cycle is the time to retire it.
Capacity and cost implications
None of these changes adds direct cost, but the upgrade path does. Consider an illustrative fleet of 20 EKS clusters. At the published $0.10 per cluster-hour for standard support, that fleet costs about $1,460 a month in control-plane fees (20 × $0.10 × 730 hours). If upgrade work slips and the clusters fall into extended support at $0.60 per cluster-hour, the same fleet costs about $8,760 a month, a $7,300 monthly penalty. For v1.34 clusters on EKS, standard support ends on 2 December 2026, two weeks before v1.38 ships. The arithmetic is illustrative, but the six-fold rate difference is AWS’s published pricing.
Managed Kubernetes Timelines: EKS, GKE and AKS
Managed services never ship a minor on upstream release day. The question for planning is the lag, and the three large providers differ sharply. For the broader feature comparison, see our EKS vs GKE vs AKS comparison of networking, upgrades and cost.
| Provider | v1.38 status on 20 Nov 2026 | Historical lag | Support model |
|---|---|---|---|
| Amazon EKS | Not on the calendar yet | 1.35: 41 days; 1.36: 41 days; 1.37: 36 days | 14 months standard, 12 months extended; $0.10 vs $0.60 per cluster-hour |
| Google GKE | No 1.38 row yet | Rapid channel 6 to 7 days after upstream for 1.36 and 1.37 | Rapid, Regular and Stable channels; standard plus extended support |
| Azure AKS | Preview listed Nov 2026, GA listed Feb 2027 | GA two to three months after upstream for 1.35 to 1.37 | 12 months GA support; optional LTS adds a year |
On EKS, the lags are computed from AWS’s own release calendar. v1.37 shipped upstream on 26 August 2026 and on EKS on 1 October 2026. If that pattern holds, an EKS v1.38 release in late January 2027 is a reasonable projection, not an announcement. EKS also supports rolling a cluster back to the previous minor within seven days of an in-place upgrade, which reduces, but does not remove, the risk of moving early.
On GKE, v1.37 reached the Rapid channel on 2 September 2026, the Regular channel on 22 October and is expected on Stable around January 2027. A 1.38 Rapid release before the end of December would match the past two cycles, but Google had not published a date at the time of writing.
On AKS, the published calendar lists v1.38 preview for November 2026 and GA for February 2027. It also lists v1.34 end of life in November 2026, with platform support until v1.38 GA. AKS clusters still on v1.34 should upgrade now rather than wait for Kubernetes 1.38.
Trade-offs, Gotchas, and What Goes Wrong
The first trap is trusting manifest scanners alone. Tools that check deprecated API versions, such as Pluto or kube-no-trouble, remain useful for older debt, but they will report a clean bill of health for Kubernetes 1.38. They do not read kubelet configuration files, node images, container runtime versions or CI environment variables. A green scan followed by NotReady nodes is the most likely failure mode for self-managed clusters.
The second trap is node image drift. Many fleets run several node pools built at different times. One old pool with a container runtime that predates RuntimeConfig support will fail only when that pool upgrades. Because the kubelet exits before registration, the symptom is nodes that never join, and cluster autoscalers may keep launching replacements that fail the same way.
The third trap is swap. Teams that enabled LimitedSwap for memory-heavy workloads, and also adopted pod-level resources during beta, may see Guaranteed-style pods lose swap entirely. The resulting failure is an OOM kill where none happened before, often under peak load rather than during testing.
The fourth trap is strict IP validation inside GitOps. Ratcheting protects stored objects, but a GitOps controller that re-applies a manifest with a leading-zero IP is changing that field. The apply will be rejected, and the sync will stall. Grep your repositories before the upgrade, not after.
There are also limits to this preview. The tracked list can still shrink before 16 December, and stage labels do not reveal whether a beta feature is on by default. Some new betas are disabled by default, and EKS states that it does not enable new beta APIs by default and does not support alpha features. Do not plan production work around an alpha such as EvictionRequest or network-isolated pods. Treat alphas as lab material for at least two more releases.
Finally, upgrading too early has a cost. The first patch release usually lands a few weeks after a minor, and regressions found by early adopters are fixed there. For most production fleets, waiting for the first or second patch release is the conservative default.
Practical Recommendations
Start with an inventory, because the oldest cluster sets your timeline. Any cluster on v1.34 is already outside upstream support and, on EKS, about to leave standard support. Those clusters need to move one minor at a time through v1.35, v1.36 and v1.37 before v1.38 is relevant. The kubelet may lag the API server by up to three minors under the version skew policy, but the control plane must step one minor at a time.

Figure 4: A Kubernetes upgrade checklist for v1.38, ordered so node and client risks are cleared before the control plane moves.
Figure 4 orders the work so the cheapest checks run first. Node and client readiness come before staging, because those are the v1.38-specific risks. The control plane, node pools and add-ons then follow the usual order.
A short preflight script covers the node and client checks. Run it against each cluster and on representative nodes.
# 1. Kubelet and runtime versions per node
kubectl get nodes -o custom-columns=NAME:.metadata.name,KUBELET:.status.nodeInfo.kubeletVersion,RUNTIME:.status.nodeInfo.containerRuntimeVersion
# 2. On each node image: cgroup v2 check (expect cgroup2fs)
stat -fc %T /sys/fs/cgroup/
# 3. On each node image: legacy cgroupDriver in kubelet config
grep -n "cgroupDriver" /var/lib/kubelet/config.yaml
# 4. In CI and scripts: removed kubectl variables
grep -rn "KUBECTL_REMOTE_COMMAND_WEBSOCKETS\|KUBECTL_PORT_FORWARD_WEBSOCKETS" .
# 5. In GitOps repos: leading-zero IPv4 and IPv4-mapped IPv6 values
grep -rnE "(^|[^0-9.])0[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+|::ffff:[0-9]+\." .
# 6. Webhooks that name review resources
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations -o yaml | grep -n "tokenreviews\|subjectaccessreviews\|selfsubject"
Then work through this checklist:
- Upgrade any v1.34 or older cluster now, one minor at a time.
- Confirm every node pool runs a container runtime that implements CRI
RuntimeConfig, and that the runtime starts before the kubelet. - Remove
cgroupDriverfrom kubelet config templates once runtimes are confirmed; plan forLegacyCgroupDriverFallbackonly as a stopgap. - Retire any cgroup v1 node images.
- Delete the two kubectl WebSocket variables from CI, and test
execandport-forwardthrough your proxies. - Change kuberc
nameentries tocommand. - Audit
LimitedSwapnodes running Pods with pod-level resources. - Run a staging cluster on rc.1 (9 December) or GA, then wait for the first patch release before production.
When to Adopt Kubernetes 1.38: A Decision Matrix
The right adoption date depends on who runs your control plane and which features you need. The matrix below is a judgement based on the facts above, not a vendor recommendation.
| Your situation | Recommended timing | Why |
|---|---|---|
| Self-managed, GPU or AI workloads on DRA | Staging on rc.1, production at first or second patch | Three DRA features reach GA; node-level changes need testing |
| Self-managed, general workloads | Production after first patch, ideally Q1 2027 | Node bootstrapping change is the main risk |
| EKS | Plan for the EKS release, projected late January 2027 | Seven-day rollback window helps; extended support costs six times more |
| GKE Rapid or Regular channel | Let the channel deliver it; pin with maintenance exclusions if needed | Rapid historically follows within a week |
| AKS | Preview for testing; production after GA, listed for February 2027 | v1.34 reaches end of life first |
| Edge or air-gapped fleets | Skip to v1.38 only after node images are rebuilt and tested | Mixed runtime versions are the highest risk |
| Regulated, change-averse fleets | Stay on v1.37 into mid-2027 | v1.37 is supported upstream until 28 October 2027 |
The pattern is consistent. Teams that need GA DRA or WatchList have real reasons to move early. Everyone else gains little by being first and should spend December fixing node images and scripts so the upgrade is uneventful in Q1.
Frequently Asked Questions
When is the Kubernetes 1.38 release date?
The SIG Release schedule sets the Kubernetes v1.38.0 release for Wednesday, 16 December 2026, with the release blog published the same day. Release candidates are planned for 3 December (rc.0) and 9 December (rc.1), and docs freeze falls on 3 December. Code and test freeze already took effect on 16 November (Anywhere on Earth). The date can slip if blocking test failures appear during burndown, but no source we checked on 20 November suggested a change. Managed services follow later, typically by days on GKE and weeks on EKS and AKS.
How many enhancements are in Kubernetes 1.38?
On 20 November 2026, 62 KEPs carried the tracked/yes label with the v1.38 milestone: 11 targeting stable, 26 beta, 23 alpha and 2 without a stage label. At enhancements freeze on 30 September, the Last Week in Kubernetes Development newsletter reported 86 tracked, out of 102 opted in. The final number will appear in the release blog on 16 December and may differ, both because features can still be removed and because release blogs often count deprecations in the total.
Does Kubernetes 1.38 remove any APIs?
The draft release-team sneak peek lists no REST API version removals for Kubernetes 1.38. Its deprecations and removals are client and node changes instead: two kubectl WebSocket environment variables are removed, the name alias disappears from kuberc’s stable v1 API, and the kubelet’s legacy cgroup driver fallback is disabled by default. The official “Deprecations and Removals” blog is scheduled for 23 November 2026, so confirm against that post. Deprecated-API scanners are still worth running for older technical debt.
What is the biggest breaking change in Kubernetes 1.38?
For self-managed clusters, it is the cgroup driver change. The kubelet will expect the container runtime to report its cgroup driver through the CRI RuntimeConfig call, and will exit before registering the node if it cannot. The cgroupDriver kubelet config field becomes deprecated and rejected unless a temporary LegacyCgroupDriverFallback gate is enabled. kubeadm preflight checks will also fail on runtimes without the call. Managed node images from cloud providers should handle this, but custom images need checking.
When will EKS, GKE and AKS support Kubernetes 1.38?
None had announced a date on 20 November. AKS’s calendar lists a v1.38 preview in November 2026 and GA in February 2027. GKE placed v1.36 and v1.37 in its Rapid channel six to seven days after upstream, so late December is plausible for Kubernetes 1.38. EKS shipped v1.35, v1.36 and v1.37 between 36 and 41 days after upstream, which projects to late January 2027. These are projections from published calendars, not commitments.
Should I upgrade to Kubernetes 1.38 immediately?
Most production teams should not. Run v1.38 in staging from rc.1 or GA, fix any node image, runtime or script issues it exposes, and move production after the first or second patch release. Teams that need the GA DRA features for GPU sharing, or WatchList for API server memory stability, have stronger reasons to move early. Clusters on v1.34 or older should upgrade now regardless, since v1.34 left upstream support on 27 October 2026.
Further Reading
- Kubernetes 1.37 Memory QoS and pod-level resource managers beta guide — the cgroup v2 background for the v1.38 swap change.
- Kubernetes 1.37 pod certificates and cluster trust bundles for workload identity — the certificate APIs that v1.38’s alpha KEP-6283 builds on.
- Kubernetes 1.37 HPA scale-to-zero beta compared with KEDA and Knative — autoscaling context for the previous release.
- Graceful shutdown, PodDisruptionBudgets and zero-downtime rollouts — the eviction model that the EvictionRequest alpha extends.
- containerd vs CRI-O as a Kubernetes runtime — useful when checking runtime readiness for the cgroup driver change.
- SIG Release: Kubernetes v1.38 release information — the authoritative schedule.
- Amazon EKS Kubernetes version lifecycle — release calendar and extended support rules.
By Riju — about
