Kubernetes 1.38 Preview: Enhancements Tracked for the December 2026 Release, Deprecations and How to Prepare Your Clusters

Kubernetes 1.38 Preview: Enhancements Tracked for the December 2026 Release, Deprecations and How to Prepare Your Clusters

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.

Kubernetes 1.38 release schedule from cycle start to GA and managed provider availability

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.

Kubernetes 1.38 enhancements funnel from opt-in to code freeze by stage

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.

Kubernetes 1.38 kubelet startup sequence with cgroup driver discovery from the container runtime

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.

Kubernetes upgrade checklist flow for preparing clusters for Kubernetes 1.38

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 cgroupDriver from kubelet config templates once runtimes are confirmed; plan for LegacyCgroupDriverFallback only as a stopgap.
  • Retire any cgroup v1 node images.
  • Delete the two kubectl WebSocket variables from CI, and test exec and port-forward through your proxies.
  • Change kuberc name entries to command.
  • Audit LimitedSwap nodes 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

By Riju — about

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *