Skip to main content
INS // Insights

EKS Control Plane Logging in a Locked Account

Updated October 2026 · 7 min read

EKS control plane logging is the export of Kubernetes API, audit, and authenticator logs from the managed control plane into CloudWatch, and the copy of those logs into a log account the cluster's admins cannot delete. The pain is an auditor's question about who changed a production workload. The cluster account's log group is empty, because control plane logs are off unless someone enables them. Or the log group exists and a cluster admin, who is the person the question is about, can also delete the retention and the streams. The workload account is the wrong sole custodian for a record of its own admins.

The EKS control plane logs guide lists five types: api, audit, authenticator, controllerManager, and scheduler. Delivery to CloudWatch is best effort and usually arrives within minutes. Nothing is sent until the type is enabled. Rutagon enables the three types that answer "who did what," copies them to a locked log account, and leaves the two noisy diagnostic types off. The evidence is a query in the log account, not a toggle in the cluster console.

Which EKS control plane logging types we enable

Audit logs are the Kubernetes record of requests: the user, the verb, the object, the stage. Authenticator logs are the EKS-specific record of which IAM principal the control plane accepted when it mapped a caller into Kubernetes RBAC. API server logs include the API server's own output, and if they are enabled early they include the flags the server started with. Together those three types are the sample. Controller manager and scheduler logs are useful while debugging a control loop. They are expensive and they do not identify the human or the role that changed an object. We send an update that enables the three and leaves the other two disabled.

{
  "clusterLogging": [
    {
      "types": ["api", "audit", "authenticator"],
      "enabled": true
    },
    {
      "types": ["controllerManager", "scheduler"],
      "enabled": false
    }
  ]
}

The call is UpdateClusterConfig. The cluster keeps serving during the update. We store the update id and read it back with DescribeUpdate until the status is successful. A config that was requested and never became successful is an open row. The console can show a checkbox from a previous attempt. The update status is the field we trust.

Logs land in the CloudWatch log group /aws/eks/<cluster-name>/cluster in the cluster's account and Region. Enabling a type needs spare IP addresses in the subnets, up to five in each subnet. A cluster whose subnets are full fails the logging update in a way that looks like an IAM error if nobody checks the subnet. We check free addresses before the call. The log group is created when logging is on. We set a retention on it so the cluster account does not accumulate an unbounded bill, and we set a KMS key so the streams are encrypted with a key the log account's readers can be granted.

CloudWatch has a maximum event size. Kubernetes API requests can be larger than that event. Oversized audit records can arrive truncated, often to metadata. The evidence procedure says so. A truncated record still supports "this user, this verb, this object" more often than it supports a full request body. We do not tell an auditor the log is a complete capture of every request payload.

The copy in the log account

The cluster account holds the first copy, and cluster admins usually have to be able to read it to operate. They should not be the only people who can destroy it. A subscription filter on the log group forwards the three types to a CloudWatch Logs destination in a separate log account. The destination policy allows logs:PutSubscriptionFilter from the cluster account and nothing broader. The log account's bucket or log group has a retention of its own, a KMS key the cluster role cannot disable, and a resource policy that denies delete from the workload account.

cluster: prod-a
types_enabled: [api, audit, authenticator]
source_log_group: /aws/eks/prod-a/cluster
destination_account: log-archive
subscription_filter: eks-control-plane
recheck_query: authenticator principal in window

The recheck is a query in the log account, not a describe call in the cluster account. We look for an authenticator event and an audit event inside the last day for a cluster that had API traffic. A cluster that is genuinely idle can return zero rows. The row then records idle, with the last non-zero day, instead of pretending the filter fired. A cluster that served traffic and returns zero rows in the log account is a broken subscription. The source group may still have data. The locked copy does not, and the row stays open.

Security Lake can collect EKS audit logs as a native source in OCSF, which is the right place to join them with CloudTrail. That source does not include the authenticator log, and it does not replace the log-account copy. We keep the subscription even when the lake is on. The authenticator line is how we tie an IAM principal to the Kubernetes user name the audit log shows. Without it, the audit user is a name whose mapping lives in a config someone can edit.

Kubernetes in regulated environments covers how the cluster is built. This pipeline is only the control plane record. Node logs, application logs, and VPC flow logs are other groups with other owners. Mixing them into the same subscription makes the locked account pay for data the audit sample does not use, and it makes the query slower on the day someone needs the admin history.

What the sample is allowed to claim

The sample we hand a reviewer is a bounded query: cluster, day, verb, and the principal from the authenticator log when the audit user maps to one. It is stored with the query text, the time, and the row count. It shows that the types were enabled and that the copy landed. It does not show that every request was innocent, and it does not open an incident process. If the question is whether that principal should have had the verb, the answer is the access review for the IAM role or the Kubernetes RBAC binding. The log is the record. The review is the decision.

Cost is the reason the other two types stay off. Each enabled type is ingested and stored at CloudWatch rates, in the cluster account and again in the log account if the subscription forwards it. A cluster fleet that enables all five types, in every environment, including ephemeral test clusters, will notice. Test clusters that exist for a day get the same three types only when they are in scope for the same evidence. A cluster outside the evidence boundary is listed as excluded, with an owner, so "we log every cluster" does not become an unmeasured bill or an unmeasured gap.

Kubernetes and containerization is the capability that builds the logging update, the subscription, and the log-account permission boundary. The GRC file receives the per-cluster row. The log account keeps the streams.

Rutagon delivers the three enabled types, the update-status recheck, and the copy an admin of the workload account cannot delete. The control plane stays managed by EKS. The record of who called it does not stay only in the account they administer.

Frequently Asked Questions

Why leave scheduler and controller manager logs off?

Those types describe control loops, not the caller who changed an object. Audit, authenticator, and API server logs are the evidence set: the request, the IAM principal, and the server record. The other two types add ingestion cost and stay available for a debugging window if a cluster needs them.

Where do the logs land first?

In the cluster account, in /aws/eks/<cluster-name>/cluster, after UpdateClusterConfig reports success. A subscription filter copies them to a destination in the log account. The evidence query runs in the log account. Data that exists only in the cluster account still fails the row, because that is the copy the admin can remove.

What does a truncated audit event mean?

CloudWatch has a maximum event size, and some Kubernetes API requests are larger. The stored record can contain metadata without the full body. The sample still uses user, verb, and object when those fields are present. We do not describe the log as a full capture of every request payload.

Does this include node or application logs?

Those streams come from the data plane and from the workloads, through a different agent and a different log group. This configuration is only the managed control plane types named above. A cluster with rich application logging and a disabled audit type still fails this check.

Ask for an AWS infrastructure diagnostic that checks which EKS control plane logs are enabled and whether a locked account holds a copy. Contact Rutagon at https://rutagon.com/contact, 907-841-8407, or contact@rutagon.com.