Skip to content

How to Manage Kubernetes Clusters Without a Platform Team (2026): The Day 2 Calendar, Version Lifecycles on EKS, GKE, and AKS, and What You Can Hand Off

A Day 2 calendar grid marking Kubernetes upgrades, monthly patches, node updates, certificate renewals, and backup drills
Blog
By Noah Grinstein
16 min read

Without a platform team, you keep Kubernetes clusters healthy by putting every recurring task on a calendar, turning on your provider’s automatic upgrades and node patching, cutting the number of clusters and add-ons you own, and handing off what you can. Control Plane can operate the Kubernetes control plane for you with Managed Kubernetes, or run your workloads with no cluster for your team to operate.

Engineering leads and senior engineers at companies of 20 to 200 people often own EKS, GKE, or AKS clusters part time. Minor versions arrive roughly three times a year, and each provider has its own support window and automatic-upgrade behavior. Add-ons follow their own release cycles, and one of the most widely used ingress controllers was retired in March 2026. This guide lays out the Day 2 calendar, the version lifecycle numbers and extended-support costs on each provider, and the options that shrink the work.

Disclosure: Control Plane publishes this guide.

TL;DR

Cluster work comes due on a predictable schedule, so a small team can plan for it.

  • Kubernetes ships a new minor version approximately three times per year, and each version gets roughly 14 months of patch support from the upstream project.
  • Extended support on EKS and GKE buys more time at $0.60 per cluster per hour, but the upgrade still has to happen.
  • Node patching is often still your job on managed services. Providers build patched images, and on EKS managed node groups you deploy them.
  • Add-ons such as the Cluster Autoscaler, cert-manager, and your CNI plugin have their own release cycles and supported Kubernetes version ranges.
  • ingress-nginx is retired. Best-effort maintenance ended in March 2026, with no further releases, bug fixes, or security fixes.
  • Put every recurring task on a calendar with a named owner, and review it monthly and quarterly.
  • Control Plane Managed Kubernetes operates the control plane and simplifies upgrades and scaling across clouds and private environments. Teams that want no cluster to operate can run workloads on Control Plane-managed locations with built-in observability and autoscaling.

How do you manage Kubernetes clusters without a platform team?

Schedule the recurring work, automate what the provider offers, and own fewer clusters and add-ons.

  1. Inventory your clusters, versions, and add-ons. List every cluster, its Kubernetes minor version, its provider support status, and every add-on installed, including the Cluster Autoscaler or Karpenter, the CNI plugin, CoreDNS, the ingress controller, and cert-manager.
  2. Pick a release channel and maintenance window. GKE and AKS offer auto-upgrade channels. Choose one that matches your risk tolerance and set a recurring maintenance window. On EKS, put each control plane upgrade on the calendar before its standard support ends.
  3. Automate node image patching. GKE Autopilot, AKS Automatic, and GKE Standard node pools with auto-upgrade (the default) patch nodes for you. On EKS, managed node groups receive patched AMIs that you must deploy. On AKS Standard, confirm the node OS upgrade channel is NodeImage (the default) or SecurityPatch and attach a maintenance window.
  4. Write a one-page upgrade runbook and test it on a non-production cluster. Cover pre-upgrade checks (deprecated API scans, add-on compatibility, PodDisruptionBudgets that would block node drains, surge capacity and quota), the upgrade itself (add-ons that must support the target version first, such as Karpenter, then the control plane one minor version at a time, then node pools, then the remaining add-ons such as CoreDNS, kube-proxy, and the Cluster Autoscaler), and post-upgrade validation.
  5. Cut clusters and add-ons. Every cluster you remove is an upgrade lifecycle you no longer run. Every add-on you remove is a compatibility matrix you no longer track.
  6. Schedule backup and restore drills. Velero or AWS Backup can protect Kubernetes objects and persistent volumes; databases outside the cluster, cloud IAM, and cluster configuration need their own backups or infrastructure as code. Only a restore proves the backup works. A quarterly drill is a sensible minimum.
  7. Assign a rotating owner with a monthly and quarterly checklist. One person owns the calendar each month, and the role rotates so knowledge spreads. The monthly checklist covers patch status, upcoming version deadlines, cost, and access. The quarterly checklist covers minor version upgrades, add-on updates, and restore drills.

Clusters usually fail when small maintenance tasks pile up, such as a missed security patch, an expired certificate, or a removed API that breaks a deploy. This plan works on EKS, GKE, AKS, and self-managed clusters.

How long is each Kubernetes version supported?

Each managed Kubernetes provider layers its own support policy on top of the upstream release cadence.

ProviderStandard supportExtended or long-term supportExtra costWhat happens at the end
Kubernetes upstreamAbout 14 months per minor version (12 months standard plus a 2-month maintenance mode)NoneNoneNo further patch releases; 1.34 reached end of life on October 27, 2026
Amazon EKS14 months12 more months, enabled by defaultStandard $0.10 per cluster per hour; extended $0.60 per cluster per hourEKS upgrades the control plane only; managed node groups and self-managed nodes stay on the previous version
Google GKEAbout 14 months from availability in the Regular channelExtended channel keeps a minor version up to 24 months; not available for Autopilot$0.60 per cluster per hour total once a version on the Extended channel passes standard supportGKE upgrades clusters automatically; control plane auto-upgrades cannot be disabled, and a “no upgrades” exclusion cannot exceed 90 days
Azure AKSThree GA minor versions (N, N-1, N-2)Long-term support adds a second year, about 24 months totalRequires the Premium tierStarting June 1, 2027, AKS upgrades clusters left on an unsupported version after a 60-day grace period

Extended support moves the deadline without removing the work. Node drains, add-on compatibility checks, and API migrations still come with every minor version, and the gap grows the longer you wait.

What recurring work does a Kubernetes cluster need?

The Day 2 calendar lists each recurring task, how often it comes due, what sets the deadline, and what breaks if you skip it.

TaskHow often it comes dueWhat sets the deadlineWhat breaks if you skip it
Minor version upgradeAbout every 4 months (3 releases per year)The upstream release cadence and your provider’s support windowThe cluster leaves standard support, pays $0.60 per cluster per hour in extended support (EKS, GKE Extended), and is eventually upgraded by the provider
Patch releasesUpstream ships patches about monthly; EKS and GKE apply control plane patches automatically, and AKS applies them if you enable the patch auto-upgrade channelUpstream patch releases, and your node pool patch versionKnown CVEs and bugs stay unpatched on nodes
Node OS image patchingMonthly, or as patched images shipThe provider builds patched images; you deploy them on EKS managed node groups, while GKE (Autopilot, and Standard with node auto-upgrade) and AKS Automatic deploy them for youOS-level vulnerabilities on every node
PodDisruptionBudget and drain readinessBefore every node upgradeEach node pool upgrade drains every nodeA PodDisruptionBudget that allows zero disruptions stalls or fails the node upgrade; single-replica workloads go down during the drain
Add-on upgrades (Cluster Autoscaler, CNI, CoreDNS, ingress controller, cert-manager)Every minor version upgrade, plus each add-on’s own releases (cert-manager ships roughly every 4 months)The Cluster Autoscaler should match the Kubernetes minor version; Karpenter publishes a compatibility matrix; cert-manager has no long-term support releasesAutoscaling failures, DNS issues, TLS errors, or a blocked cluster upgrade
Deprecated API checksBefore every minor version upgradeThe Kubernetes deprecation guide (the most recent removals were in v1.32); scanners such as Pluto or kube-no-trouble, the apiserver_requested_deprecated_apis metric, and provider insights (EKS cluster insights, GKE deprecation insights) flag upgrade blockersWorkloads that use removed APIs fail after the upgrade
Ingress controller replacement (ingress-nginx)Once, as soon as possibleingress-nginx best-effort maintenance ended in March 2026A component that handles all inbound traffic gets no security fixes
Certificate renewalYearly for kubeadm client certificates on self-managed clusters, unless a control plane upgrade within the year renewed them; more often for Let’s Encrypt certificates, whose default lifetime drops to 64 days on February 10, 2027 and 45 days on February 16, 2028Certificate expiry datesExpired kubeadm certificates break API server authentication on self-managed clusters; expired TLS certificates break HTTPS endpoints
Image vulnerability scanningContinuous, reviewed weekly (recommended)New CVEs in base images and dependenciesKnown vulnerabilities ship to production
Secret and credential rotationQuarterly or per policy (recommended)Compliance requirements and staff changesLong-lived tokens and keys stay valid after exposure
etcd snapshot (self-managed clusters only)Daily, with a quarterly restore test (recommended)Your recovery point objectiveLosing the control plane loses all cluster state
Backup and restore drillQuarterly, recommendedYour recovery time objectiveBackups fail during a real incident
Access and RBAC reviewQuarterly, recommendedStaff changes and compliance requirementsStale credentials and over-permissioned service accounts
Cost and capacity reviewMonthly, recommendedThe cloud billing cycle and workload growthSpending on idle capacity, or no headroom during traffic spikes

Which 2026 deadlines and upgrade behaviors do small teams miss?

Four deadlines and upgrade behaviors are easy to miss without someone watching the ecosystem full time.

ingress-nginx is retired. The Kubernetes project announced the retirement on November 11, 2025, with best-effort maintenance until March 2026 and no further releases, bug fixes, or security fixes after that. A January 29, 2026 statement said about 50% of cloud native environments relied on it and that no alternative is a drop-in replacement. A cluster still running it has an unpatched component in front of every inbound request.

AKS will upgrade unsupported clusters from June 2027. Starting June 1, 2027, AKS automatically upgrades any cluster left on an unsupported version after a 60-day grace period. Platform-initiated upgrades ignore maintenance windows, do not stop for deprecated API usage, and can override a PodDisruptionBudget that blocks a node drain. Teams that defer upgrades on AKS need a regular cadence or long-term support on the Premium tier.

Certificate lifetimes are getting shorter. Let’s Encrypt will cut its default certificate lifetime to 64 days on February 10, 2027 and to 45 days on February 16, 2028. Renewal automation that assumes 90-day certificates needs a check. Client certificates generated by kubeadm expire after one year, so self-managed kubeadm clusters need either a control plane upgrade or a manual renewal at least once a year.

EKS upgrades only the control plane at the end of extended support. When extended support ends, EKS upgrades the control plane to the next version, and managed node groups and self-managed nodes stay where they were. Managed node groups and self-managed nodes never upgrade themselves; only EKS Auto Mode nodes may update automatically. The kubelet is supported up to three minor versions behind the API server, and node pools can move to the control plane’s version in one step within that skew, so the node upgrade still lands on your team.

How can a small team shrink cluster work?

Six options take work off a small team, each with a different trade-off.

OptionWhat it takes off your plateWhat you still ownTrade-off
Auto-upgrade channels with maintenance windowsControl plane upgrades happen on the provider’s schedule inside your windowNode upgrades, add-on upgrades, deprecated API checks, application availability during upgradesLess control over timing; GKE caps “no upgrades” exclusions at 90 days, while “no minor upgrades” exclusions can run to the version’s end of support
Extended or long-term supportUp to 12 more months on EKS, or about 24 months total on GKE Extended and AKS long-term supportThe upgrade itself, node and add-on work, and the higher hourly cost ($0.60 per cluster per hour on EKS and GKE)Delays the work without removing it, and changes accumulate
EKS Auto Mode, GKE Autopilot, or AKS AutomaticNode provisioning and scaling, OS patching, and core components such as networking and DNSStarting control plane upgrades (EKS Auto Mode), application availability, security policy, monitoring, and costLimits on node configuration; GKE Extended is not available for Autopilot; EKS Auto Mode adds a management fee per instance
Fewer clusters and fewer add-onsEach removed cluster removes an upgrade lifecycle; each removed add-on removes a compatibility matrixThe remaining clusters and add-ons, plus the consolidation workA larger blast radius per cluster; some add-on removals need application changes
Control Plane Managed KubernetesControl Plane operates the Kubernetes control plane and simplifies upgrades and scaling; on AWS it handles node autoscaling, load balancer provisioning, version upgrades, and storage management, and lets you manage a fleet of clusters across AWS accounts from one placeApplication deployment, workload configuration, triggering node image refreshes, and the cloud account or servers the worker nodes run onWorker nodes run in your own AWS account, GCP project, or servers, so compute stays in accounts you control and on your existing cloud bill
Running workloads on Control Plane with no cluster for your team to operateThe whole cluster lifecycle; autoscaling, observability, and security come built inApplication code, workload configuration, and deployment decisionsTuning happens at the workload level through autoscaling and Control Plane’s Capacity AI right-sizing

How does Control Plane reduce Kubernetes cluster work?

Control Plane handles Day 2 operations for you, including autoscaling, built-in observability, and security.

Managed Kubernetes (MK8s) is Control Plane operating the Kubernetes control plane while worker nodes run in your AWS account, your GCP project, another supported provider’s account such as Hetzner, or on servers you provide. Control Plane’s docs describe it as simplifying the creation and management of clusters, including upgrades and scaling, across multiple clouds and private environments. On AWS, Control Plane handles node autoscaling, load balancer provisioning, version upgrades, and storage management, and lets you manage a fleet of clusters across AWS accounts centrally.

Control Plane’s Bring Your Own Kubernetes (BYOK) installs a few components into a cluster you already run and registers it as a location. Control Plane then rolls out workloads onto it. Your team keeps operating those clusters.

Control Plane-managed locations and MK8s clusters need no control plane work from your team. A Global Virtual Cloud (GVC) is Control Plane’s named set of locations, which can mix provider regions on AWS, GCP, Azure, and Oracle Cloud Infrastructure, clusters you registered, and your own hardware. A workload runs in every location of its GVC. Traffic goes to the nearest healthy location, so if one location fails, traffic shifts to the locations that remain without a change to the workload.

Control Plane’s Capacity AI adjusts each container’s CPU and memory between configured minimum and maximum values based on historical usage; it is not available with CPU-utilization or multi-metric autoscaling, or for GPU workloads. Autoscaling strategies include concurrency, requests per second, CPU utilization, latency percentile, and memory. Every workload arrives with logs and metrics collected, and tracing is turned on per GVC or org. A tamper-proof audit trail records every action, whichever interface performed it. Control Plane’s Template Catalog deploys databases, queues, and other services alongside your workloads.

Control Plane is PCI DSS Level 1, SOC 2 Type II, HIPAA, and GDPR compliant.

The guide to getting Kubernetes benefits without hiring a platform team compares who does the work under each operating model. The guide to managing Kubernetes across multiple clouds without vendor lock-in covers portability, and the guide to developer self-service with guardrails covers giving developers safe deploy access.

FAQ

Teams running Kubernetes without a platform team ask these questions most often.

How do you manage Kubernetes clusters without a platform team?

Put every recurring task on a calendar with a named owner, turn on your provider’s auto-upgrade channels and node patching, reduce the clusters and add-ons you maintain, write a one-page upgrade runbook, and run restore drills quarterly. A rotating monthly owner works through a checklist of patches, cost, access, and upcoming version deadlines.

How often do you need to upgrade Kubernetes?

About every four months to stay current, and at least once before each version’s support ends. Kubernetes ships roughly three minor releases per year, and each minor version gets about 14 months of upstream patch support. Control plane upgrades cannot skip minor versions, so deferring means catching up one version at a time.

What happens if you don’t upgrade your EKS cluster?

By default, EKS moves the cluster to extended support at $0.60 per cluster per hour, up from $0.10, after 14 months of standard support. Extended support lasts 12 more months. At its end, EKS upgrades the control plane to the next version, while managed node groups and self-managed nodes stay on the previous version, so you still have to upgrade the nodes.

Is EKS extended support worth it?

Only as a short buffer while you catch up. Extended support costs $0.60 per cluster per hour, six times the standard rate, or about $365 more per cluster per month at 730 hours. It buys 12 months without removing any upgrade work. Teams that keep a regular upgrade cadence avoid the cost.

What replaces ingress-nginx?

Another ingress controller that implements the Ingress resource, or an implementation of the Gateway API, the Kubernetes project’s newer API for routing traffic into a cluster. No alternative is a drop-in replacement, so audit your ingress-nginx annotations and configuration first and test the migration on a non-production cluster. The ingress2gateway tool converts Ingress resources to Gateway API resources.

Does GKE Autopilot remove the need for a platform team?

No, but it removes a large share of the work. Autopilot manages nodes, scaling, and node security patches, and GKE upgrades clusters automatically. You still own application deployment, security policy, monitoring, incident response, cost, add-ons, backup and restore, and compliance. The GKE Extended channel, which keeps a minor version for up to 24 months, is not available for Autopilot clusters.

How many people does it take to run Kubernetes?

There is no fixed number, because the work scales with the number of clusters and add-ons you run. Every cluster needs a named owner and a backup who can follow the runbook during vacations or incidents. Fewer clusters, fewer add-ons, provider automation, and managed services all reduce the load on each person.

Can Control Plane manage my Kubernetes clusters?

Yes. Control Plane’s Managed Kubernetes (MK8s) creates clusters and operates their Kubernetes control plane while worker nodes run in your AWS account, your GCP project, another supported provider’s account such as Hetzner, or on servers you provide. On AWS it handles node autoscaling, load balancer provisioning, version upgrades, and storage management. Clusters you already run can join through Control Plane’s Bring Your Own Kubernetes (BYOK), which rolls out workloads onto them while your team keeps operating them. Teams that want no cluster to operate can run workloads on Control Plane-managed locations with built-in autoscaling, observability, and security.

What should go in a Kubernetes upgrade runbook?

Pre-upgrade checks, the upgrade sequence, post-upgrade validation, and a rollback plan. Check for deprecated APIs, add-on compatibility, PodDisruptionBudgets that would block drains, and a recent successful backup. Upgrade add-ons that must support the target version first, such as Karpenter. Then upgrade the control plane one minor version at a time, then the node pools, then the remaining add-ons such as CoreDNS, kube-proxy, and the Cluster Autoscaler. Validate workload health, DNS resolution, and certificate status, and test the runbook on a non-production cluster before every production upgrade.

Talk to the Control Plane team about Managed Kubernetes or running workloads with no cluster to operate, or sign up free to start.

Run Unbreakable
Apps and Agents