How to Configure EKS Break Glass Access
You set up eks break glass access by mapping cloud roles to Kubernetes RBAC rules. This emergency path lets responders fix outages when normal login systems fail. Teams often create one emergency admin role for the whole cluster. This approach helps during an outage, but broad roles create huge security risks. Anyone who gets that role can read all secrets or delete live workloads. A good emergency setup limits what responders can do while they fix the problem. How eks break glass access work
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 break glass access by mapping cloud roles to Kubernetes RBAC rules. This emergency path lets responders fix outages when normal login systems fail.
Teams often create one emergency admin role for the whole cluster. This approach helps during an outage, but broad roles create huge security risks. Anyone who gets that role can read all secrets or delete live workloads. A good emergency setup limits what responders can do while they fix the problem.
How eks break glass access works in Kubernetes
Your setup relies on AWS identity roles and Kubernetes RBAC working together. First, an engineer assumes a dedicated emergency role in the cloud account. The cluster checks this cloud identity and maps it to a Kubernetes user or group. Then, Kubernetes RBAC checks what that user or group can do.
In Kubernetes RBAC, a Role or ClusterRole holds a set of permissions. These rules are purely additive, which means there are no deny rules. A standard Role always sets permissions within one single namespace. A ClusterRole is not namespaced and can cover cluster-wide resources like nodes. It can also cover namespaced resources across all namespaces in the cluster.
You connect identities to these rules with a RoleBinding or a ClusterRoleBinding. A RoleBinding grants permissions inside one namespace and can reference a Role or ClusterRole. A ClusterRoleBinding grants permissions across the entire cluster at once. For emergency work, teams often bind responder groups to specific namespaces first. They reserve cluster-wide bindings for severe node or network failures.
Why native RBAC leaves a gap during emergencies
Native roles and bindings solve the first part of an emergency. They let the right person log in when the main identity system goes down. They also block users from touching namespaces outside their assigned scope.
Still, Kubernetes RBAC only checks the initial API call. It decides who logs in, not what individual commands do in flight. This gap shows up clearly when responders need shell sessions or pod logs. RBAC treats pod logs and pod exec sessions as subresources in the API. You must grant permissions for these subresources so responders can debug live containers.
Break-Glass Access Procedures + EKS Access Management: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Once a responder starts an exec session, RBAC steps out of the way. The API server knows the user opened a shell in a pod. It does not inspect the shell commands that run inside that container. If a responder queries a database from that pod, RBAC sees nothing. Raw data like emails, phone numbers, card numbers, or national IDs can spill into terminals.
Scoping emergency roles for safer incident response
You can reduce risk by splitting emergency access into smaller tiers. Create one emergency role that only reads pod logs and checks cluster state. This read-only tier helps engineers find the root cause of most outages. Create a second tier that allows pod exec sessions inside one specific namespace. Keep cluster-wide admin roles locked behind a separate approval workflow.
Even with split roles, you must remove emergency bindings as soon as the outage ends. Leftover bindings turn temporary emergency paths into permanent backdoors. You also need clear audit trails of every command run during the incident. Standard Kubernetes audit logs record the API request, not the output inside an exec stream. Teams must pair RBAC with controls that inspect commands and mask sensitive fields in results.
Govern kubectl and API calls in flight
Identity providers and Kubernetes RBAC decide who logs into a cluster. They cannot redact keys inside returned JSON objects or hold a risky delete call for review. By design, hoop.dev sits inline as an open-source proxy, a sidecar for your Kubernetes API, without replacing RBAC. On every production call from an engineer or AI agent, hoop.dev decides to pass, mask, block, or hold it for human approval.
First, hoop.dev guardrails refuse banned methods, paths, or headers before they run or hold risky deletes for review. Next, hoop.dev data masking rewrites sensitive keys in returned Secret, ConfigMap, and log responses in memory, and writes each decision to the audit trail. Explore the repo on GitHub.
Frequently asked questions
What is the difference between a RoleBinding and a ClusterRoleBinding in an emergency?
A RoleBinding limits emergency permissions to one specific namespace. A ClusterRoleBinding grants permissions across all namespaces and cluster-scoped resources like nodes. Use a RoleBinding when an outage only affects one app or team.
Can I use a deny rule in Kubernetes RBAC to block secret reads during break glass?
No, Kubernetes RBAC permissions are purely additive and have no deny rules. To block secret reads, you must build a Role that leaves out secret permissions. Avoid granting broad wildcard roles during an incident.
Why do responders need subresource permissions for eks break glass access?
Kubernetes treats actions like reading pod logs or running exec commands as subresources. If a Role only grants access to pods, the responder cannot open a shell. You must explicitly include the log and exec subresources in your RBAC rules.
Related guides
In this post