EKS Control Plane
An eks control plane runs the main Kubernetes API server and cluster state components. Teams protect it by setting up identity mapping and strict Kubernetes role rules. Most teams start by linking cloud identities to internal cluster roles. When those roles are too broad, one user can change production pods or read secrets. Scoping these rules down is the first step toward a safe cluster. How the eks control plane handles roles and permissions Every request to the cluster goes through the API
Your coding agents run with your access.
Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.
An eks control plane runs the main Kubernetes API server and cluster state components. Teams protect it by setting up identity mapping and strict Kubernetes role rules. Most teams start by linking cloud identities to internal cluster roles. When those roles are too broad, one user can change production pods or read secrets. Scoping these rules down is the first step toward a safe cluster.
How the eks control plane handles roles and permissions
Every request to the cluster goes through the API server first. The API server checks who the user is and what they want to do. It uses Role-Based Access Control to make this decision. In Kubernetes, permissions are purely additive, which means there are no deny rules. You start with zero access and add rules one by one.
A Role sets permissions inside one specific namespace. A ClusterRole sets permissions across the whole cluster. A ClusterRole can cover cluster-wide items like nodes, or namespaced items across all namespaces. To give these rules to a user, you create a binding. A RoleBinding grants permissions inside one namespace. It can point to a Role in that namespace or to a global ClusterRole. A ClusterRoleBinding grants permissions across the entire cluster at once.
The API server also uses subresources to control specific actions on a pod. For example, reading pod logs and running commands in a pod are separate subresources. In role rules, you write these subresources with a slash after the main resource name. Admins can let a developer read pod logs without letting them run shell commands.
What native eks control plane rules solve and leave open
Native roles are great at deciding who can reach a specific API endpoint. They stop unauthorized users from deleting workloads or reading cluster secrets. Separating namespace roles from cluster-wide roles keeps teams in their own lanes. This setup solves basic admission control for your cluster.
Still, native rules stop working once a live session begins. When a role allows pod command execution, the API server opens a stream. The control plane checks the initial request, not the commands typed inside that stream. If a developer opens a shell, they can run any binary inside that container. They might query an internal database or print raw customer emails and card numbers. Standard role bindings cannot inspect or filter what happens inside an active shell session.
Security Control Plane + EKS Access Management: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Scoping day-to-day cluster tasks
To reduce risk, teams should avoid giving out cluster-wide bindings for daily work. Bind users to specific namespaces using standard RoleBindings instead. Even if you use a shared ClusterRole to define read rules, bind it per namespace. This keeps a user from seeing workloads outside their own team area.
Treat pod execution subresources as high-risk permissions. Do not bundle shell access into standard developer roles. Keep log reading separate from command execution. When someone needs to fix a live pod, require an approval step for that command. Auditing what runs inside the container is just as important as checking who logged in.
Add request guardrails and response masking beside Kubernetes
Cluster roles and service accounts govern who reaches the Kubernetes API. Still, a broad role or agent can delete workloads or print sensitive values from ConfigMaps and logs. In practice, hoop.dev runs beside the API server as a sidecar for your Kubernetes API and checks every request and response alongside RBAC.
With hoop.dev Kubernetes controls, guardrails can allow listing Secret names while refusing reads of Secret data before execution. Data masking redacts matched keys in returned JSON responses and log streams in memory. Furthermore, hoop.dev holds SOC 2 Type II and is MIT licensed on GitHub.
Frequently asked questions
Can I write a deny rule in Kubernetes RBAC?
No, Kubernetes permissions are purely additive. You cannot write a rule to block one specific action from a broad role. Instead, you must build smaller roles and grant only the exact permissions needed.
What is the difference between a RoleBinding and a ClusterRoleBinding?
A RoleBinding applies permissions within a single namespace only. A ClusterRoleBinding applies permissions across every namespace and cluster-scoped resource at the same time.
How do I let developers read pod logs without giving them shell access?
Grant access only to the pod log subresource in your role definition. Leave out the pod execution subresource so the API server blocks shell requests.
Related guides
In this post