AWS Builder Center

Amazon EKS Now Supports Advanced Kubernetes Control Plane Configuration Parameters

A walkthrough of the four new control plane parameters for Amazon EKS's scheduler, controller manager, and API server. It focuses on the HPA sync period's Provisioned Control Plane requirement and setup steps, along with where the other three parameters help with cost savings and migration.

Introduction

On August 12, 2026, AWS announced support for advanced Kubernetes control plane configuration parameters on Amazon EKS. Cluster administrators can now tune the behavior of the scheduler, controller manager, and API server, components that previously ran only with the default values AWS managed on your behalf.
If you run clusters on EKS, you may have wanted to increase node utilization to reduce cost, or tune how quickly autoscaling reacts to your workload, only to find that a managed service left you no room to do so. This update addresses that gap directly.
This post covers what changed, with a particular focus on the Horizontal Pod Autoscaler (HPA) sync period, a parameter that deserves extra care, along with the other parameters introduced in this release. It's aimed at infrastructure and platform engineers who operate EKS clusters, and at anyone interested in cost optimization or tuning autoscaling behavior.



What's Changed

You may never have thought much about the scheduler, controller manager, and API server that make up the EKS control plane. These components internally hold settings such as pod placement strategy, autoscaler responsiveness, and event retention, but until now, EKS applied only the default values AWS defined, with no way for users to change them.
This update introduces four new configurable parameters.
Component
Parameter
Description
Supported values
Default
kube-scheduler
nodeResourcesFit.scoringStrategy
Node scoring strategy used when placing pods
LeastAllocated / MostAllocated
LeastAllocated
kube-controller-manager
horizontalPodAutoscalerSyncPeriod
How frequently the HPA controller evaluates scaling decisions
10s to 15s
15s
kube-apiserver
eventTtl
How long the API server retains Kubernetes events
10m to 60m
60m
kube-apiserver
serviceNodePortRange
The port range assigned to a Service's NodePort
10260 to 32767
min: 30000 / max: 32767
Of these four, horizontalPodAutoscalerSyncPeriod is the only one that requires moving your cluster to Amazon EKS Provisioned Control Plane. We'll look at why in the next section.



Changing the HPA Sync Period

Of the four parameters, horizontalPodAutoscalerSyncPeriod on kube-controller-manager has the biggest impact on day-to-day operations. The range of values you can set is narrow, but the prerequisites for enabling it and its behavior afterward include a few pitfalls that are easy to miss, so let's look at it in detail.

How the Sync Period Drives API Server Load

The controller manager runs the various controllers that drive your cluster toward its desired state, and the Horizontal Pod Autoscaler (HPA) controller is one of them. On every cycle, the HPA controller retrieves metrics for each HorizontalPodAutoscaler object in the cluster, calculates the desired replica count, and updates the target workload if that count has changed. Shortening this cycle means your workloads scale sooner after load increases.
At the same time, shortening the sync period increases how often the controller reconciles every HorizontalPodAutoscaler object in the cluster, which drives up the number of requests sent to the API server. Each reconciliation consumes at least one API request, and a reconciliation that changes the replica count consumes two more, for up to three requests per cycle. To absorb this additional load reliably, this parameter requires moving to Amazon EKS Provisioned Control Plane as a prerequisite. Provisioned Control Plane pre-allocates control plane capacity, sized to handle demanding workloads at all times.

Provisioned Control Plane Is Required

Trying to set this parameter on a cluster running Standard mode will fail. You first need to move the cluster to a Provisioned Control Plane scaling tier.
Another point worth keeping in mind: this move comes with a constraint that's close to a one-way door. As long as horizontalPodAutoscalerSyncPeriod is set to a value other than the default, you can't move the control plane back from Provisioned mode to Standard mode. To return to Standard mode, you first need to reset this parameter to its default of 15s, and only then change the scaling tier back to standard.
Configuring the parameter itself carries no additional charge, but Provisioned Control Plane is billed at the hourly rate for your scaling tier. It's worth factoring that cost impact in before you make the move.

How to Enable It

Both the move to Provisioned Control Plane and the HPA sync period change go through the existing update-cluster-config API, now extended with new fields. You can configure it from the AWS Management Console, AWS CLI, AWS SDKs, eksctl, AWS CloudFormation, or AWS CDK; support for Terraform and AWS Controllers for Kubernetes (ACK) is coming soon.
Here's an illustrative example of the request body. Check your tooling's documentation for the exact option names before you apply this.
{
"name": "<cluster-name>",
"controlPlaneScalingConfig": {
"tier": "tier-xl"
},
"kubeControllerManagerConfig": {
"horizontalPodAutoscalerControllerConfig": {
"horizontalPodAutoscalerSyncPeriod": "10s"
}
}
}

You can track the progress of the update with describe-update.
aws eks describe-update \
--name <cluster-name> \
--update-id <update-id> \
--region <region-code>

The configuration change isn't in effect the moment update-cluster-config returns. EKS applies the new configuration through a rolling update of the control plane, so it typically takes a few minutes to take full effect. The update is complete once the cluster's status returns to ACTIVE. You can also block until the change completes with aws eks wait cluster-active.

Exceeding the Object Limit Silently Slows Down Scaling

Shortening the sync period means the controller has less time to work through the same queue, so there's a limit to how many HorizontalPodAutoscaler objects your control plane can reconcile on schedule. Shortening the period from 15s to 10s lowers the supported object count by roughly a third. Before you make the change, count the HorizontalPodAutoscaler objects already in your cluster.
kubectl get hpa --all-namespaces --no-headers | wc -l

One thing to watch for: EKS doesn't validate the sync period against your cluster's HorizontalPodAutoscaler object count. The configuration change succeeds even if your cluster already has more objects than the shorter period can support. If the count stays above what the controller can handle within the period, some objects stop being reconciled on schedule, and EKS doesn't emit an alarm or a Kubernetes event for this condition. The symptom you'll see is the opposite of what you wanted: autoscaling that responds more slowly. If you notice delayed scaling after shortening the sync period, check your object count first, and return the parameter to the default of 15s if needed.



Parameters That Help With Cost Savings and Migration

None of the remaining three parameters carry the same constraints as the HPA sync period, but each has a practical use case of its own. Here's a brief look at each.

Reduce Cost by Packing Pods Onto Fewer Nodes With MostAllocated

The scheduler first filters the nodes that can run a pod, then scores the remaining candidates and places the pod on the highest-scoring node. You can now switch the scoring strategy used by the nodeResourcesFit plugin from the default, LeastAllocated, to MostAllocated. LeastAllocated favors nodes with lower resource allocation, spreading pods across the cluster and leaving headroom on every node. MostAllocated favors nodes that already have higher allocation, which packs pods onto fewer nodes and reduces compute spend. It also pairs well with node consolidation performed by Cluster Autoscaler or Karpenter.
You can also customize the weight given to each resource considered during scoring. Beyond CPU and memory, you can assign a higher weight to an accelerator resource such as GPU (nvidia.com/gpu), which is useful on clusters where accelerator capacity is scarce and you want to concentrate GPU-requesting pods.
Keep in mind that this setting only affects future scheduling decisions; pods that are already running are never moved. Packing workloads onto fewer nodes also concentrates blast radius, so a single node or Availability Zone disruption affects more pods at once.

Reduce etcd Load by Shortening Event Retention

The API server records Kubernetes events, such as pod scheduling decisions, health check failures, and scaling actions, in the cluster database (etcd). On clusters running high-churn workloads such as batch jobs, CI/CD pipelines, AI workloads, or frequent CronJobs, these events accumulate quickly. Shortening eventTtl clears this short-lived diagnostic data sooner, reducing storage pressure and improving API server responsiveness for event-heavy queries.
A change to this parameter only applies to new events; it doesn't shorten the retention period of events already stored. Because deleted events can't be recovered, be careful not to shorten retention further than you intend if you don't have another system capturing events durably.

Adjust the NodePort Range

Kubernetes allocates a port from this range for every Service of type NodePort, and, in most cases, LoadBalancer as well. The default range is 30000 to 32767, and you can now set it anywhere between 10260 and 32767. This is particularly useful when migrating applications that expect specific fixed ports to EKS.
Narrowing the range doesn't affect ports already assigned to existing Services. Recreating a Service, however, reallocates its port, so confirm in advance that a port your Service depends on will still fall within the new range.



Use Cases

Here's a closer look at where each of these four parameters delivers real value.

Batch and ML Platforms: Reduce Cost Through Node Consolidation

For workloads that can tolerate high node utilization, such as machine learning training jobs or data pipelines, the scheduler's MostAllocated strategy is a good fit. If you're pursuing ongoing cloud cost optimization, a practical approach is to start with a batch-processing node pool where the blast radius is small, confirm the cost savings, and expand from there. Because the change is just a single scheduler field, it requires no changes to your existing node pool configuration or CI/CD pipelines, which lowers the barrier to adoption.

Preparing for Sudden Traffic Spikes: Shorten the HPA Sync Period

For services where load can spike sharply in a short time, such as during a sale, the frequency at which the HPA controller evaluates scaling decisions can itself become a bottleneck. Shortening the sync period from 15s to 10s reduces the delay between detecting increased load and the start of a scale-out. As covered above, though, this requires moving to Provisioned Control Plane and checking your HorizontalPodAutoscaler object count beforehand, so weigh the importance of the target service and the cost involved before deciding.

Migrating From On-Premises: NodePort Range Adjustments Simplify Planning

For on-premises migration projects, taking inventory of the ports your applications use ahead of time and configuring the NodePort range to match reduces rework during the post-migration connectivity verification phase. Because the range change applies cluster-wide in a single update, even a phased migration plan across multiple applications can widen the range once up front, without needing per-application adjustments.



Summary

Amazon EKS's control plane now offers room for tuning that didn't exist before. Pod placement strategy, HPA responsiveness, event retention, and NodePort range, areas that were previously only reachable on self-managed clusters, are now available without giving up a managed service.
The HPA sync period delivers the biggest impact of the four, but it also comes with characteristics that can lead to operational issues if overlooked: it requires moving to Provisioned Control Plane, and exceeding the object limit slows down scaling with no alarm to warn you. It calls for more careful verification than the other three parameters. Test the behavior in a non-production environment first, and work out the configuration that fits your workload.



References

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article