EKS EKS Zaqs
You set up eks eks zaqs by building role rules in Kubernetes RBAC. Then you link those rules to user groups with role bindings. Most engineering teams start by granting broad cluster roles to speed up work. That choice gives users wide permissions across every namespace and node. If one account fails, an attacker can run commands across the whole cluster. How eks eks zaqs works with Kubernetes RBAC Kubernetes uses its native authorization API group to check every cluster request. The API serv
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.
You set up eks eks zaqs by building role rules in Kubernetes RBAC. Then you link those rules to user groups with role bindings. Most engineering teams start by granting broad cluster roles to speed up work. That choice gives users wide permissions across every namespace and node. If one account fails, an attacker can run commands across the whole cluster.
How eks eks zaqs works with Kubernetes RBAC
Kubernetes uses its native authorization API group to check every cluster request. The API server checks these rules when RBAC mode is active. In this model, a Role sets permissions inside one single namespace. A ClusterRole sets permissions across the whole cluster. It can cover cluster resources like nodes or namespaced resources everywhere.
Every rule in Kubernetes RBAC is additive. There are no deny rules in this system. You start with zero permissions and add rules for specific verbs and resources. A RoleBinding gives those permissions to a user or group inside one namespace. A RoleBinding can point to a local Role or a shared ClusterRole. A ClusterRoleBinding grants permissions across the entire cluster at once.
Some Kubernetes API calls target subresources instead of top-level objects. In RBAC rules, you write a subresource with a slash. For example, reading pod logs uses the pods and log subresource path. Running a shell inside a container uses the pods and exec subresource path. You must list these subresources in your role rules to allow those actions.
Why native roles leave a gap during live sessions
Native RBAC roles solve the problem of who can reach the API server. You can limit a developer to one namespace with a standard RoleBinding. You can also block them from changing cluster nodes or reading other namespaces. This setup keeps basic cluster objects safe from stray changes.
Still, RBAC only checks the request when the user starts the action. Once a role allows the pod exec subresource, the user gets a shell. Kubernetes does not inspect the shell commands that run inside that container. A user with exec rights can read local files or query attached databases. They can also see emails, phone numbers, card numbers, or national IDs.
EKS Access Management: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Resource name filters also have limits in Kubernetes RBAC. On create actions, resource name limits only work on top-level resources. They do not apply to subresources in the same way. Because rules are purely additive, you cannot write a quick deny rule either. To revoke one risky right, you must rebuild the whole role structure.
Best practices for scoping cluster permissions
Start by replacing broad cluster bindings with single-namespace role bindings. Give each team a RoleBinding that applies only to their own app namespace. You can still reference a common ClusterRole to keep rule management simple. This step stops a user in one namespace from touching another team's pods.
Next, separate read rules from interactive subresource rules. A base role can allow reading pod status and viewing pod logs. Keep the pod exec subresource in a separate role for break-glass tasks. When users need to check data, data masking can rewrite matched fields in results. This keeps emails and card numbers hidden during routine checks.
Check Kubernetes API requests and responses on the wire
Kubernetes RBAC decides who may call the API server. RBAC does not check response payloads or split listing Secret names from reading Secret values when a role grants get access. With hoop.dev, you run an open-source HTTP proxy, a sidecar for your Kubernetes API. The kubectl client changes only the server address it talks to while RBAC stays in place.
On each call, hoop.dev guardrails read the method, normalized path, and headers to refuse bad deletes or full Secret reads with a 403 error. On the way back, hoop.dev data masking walks JSON responses by key and masks matched values in Secrets, ConfigMaps, and pod logs. Every request and verdict is logged without storing bearer tokens. View the project on GitHub.
Frequently asked questions
Can I add a deny rule to block one specific Kubernetes resource?
No, Kubernetes RBAC permissions are purely additive and never support deny rules. To block an action, you must remove the matching allow rule from the role.
What is the difference between a RoleBinding and a ClusterRoleBinding?
A RoleBinding grants permissions inside one specific namespace only. A ClusterRoleBinding grants permissions across all namespaces and cluster-scoped resources like nodes.
How does Kubernetes RBAC control pod log viewing and container shells?
RBAC uses subresources written with a slash, such as pods/log and pods/exec. You must add these exact subresource names to a Role or ClusterRole to allow them.
Related guides
In this post