Redhat SSO Openshift
You set up redhat sso openshift by linking your identity server to the cluster login system. After users log in, you map their groups to native cluster roles. Most teams start by linking their central user list to the cluster. They then grant broad roles so engineers can check apps and fix bugs. When these roles are too wide, one account can change live workloads across the whole cluster. How redhat sso openshift works with cluster roles A redhat sso openshift setup splits user login from clu
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 redhat sso openshift by linking your identity server to the cluster login system. After users log in, you map their groups to native cluster roles. Most teams start by linking their central user list to the cluster. They then grant broad roles so engineers can check apps and fix bugs. When these roles are too wide, one account can change live workloads across the whole cluster.
How redhat sso openshift works with cluster roles
A redhat sso openshift setup splits user login from cluster rules. First, the identity server checks who the user is during login. Next, the cluster reads the user identity and group list. Finally, Kubernetes RBAC checks what that user can do inside the cluster.
In Kubernetes, a Role or ClusterRole holds a set of permission rules. These permissions are purely additive, which means there are no deny rules. A Role sets permissions inside one single namespace. A ClusterRole is not namespaced and can cover cluster-wide items like nodes. It can also cover namespaced items across all namespaces in the cluster.
To give these permissions to users, you create bindings. A RoleBinding grants permissions inside one specific namespace. It can point to a Role in that namespace or a shared ClusterRole. A ClusterRoleBinding grants access across the entire cluster at once.
Why native roles leave gaps during live sessions
Linking your login system to cluster roles solves the first step of security. You know who logs in, and you can turn off accounts from one place. You can also limit which namespaces a team can view or change.
Still, native roles only check the start of an API request. Kubernetes RBAC names resources the same way they appear in the API URL. Some APIs use a subresource, such as pod logs or pod exec sessions. Once a role grants access to the pod exec subresource, the check is over. The cluster lets the user open a shell inside the container.
OpenShift RBAC + Cross-Domain SSO: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Native roles do not inspect the shell commands that run inside that pod. They also do not check what data returns to the user screen. An engineer reading app logs or running a database tool inside a pod sees raw records. The cluster role cannot rewrite sensitive fields like emails, phone numbers, card numbers, or national IDs. Because permissions are purely additive, you cannot write a deny rule to block one bad command. Teams end up choosing between blocking pod shells completely or giving full container control.
Managing subresource rules and namespace boundaries
To reduce risk with native tools, teams split roles by namespace and task. You can create a RoleBinding in each app namespace instead of using a ClusterRoleBinding. This keeps a developer in one namespace from touching pods in another namespace.
You can also separate read rules from exec rules in your Role definitions. For example, many users only need access to the pod log subresource to read output. Only a small group of engineers should get permission for the pod exec subresource. Even with tight bindings, any user with exec rights still gets full shell control inside allowed pods. Controlling what happens inside those live sessions requires checks at the command level.
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 proxy, a sidecar for your Kubernetes API, inline on the API connection. On every kubectl or API call an AI agent or engineer runs against production, hoop.dev decides to pass, mask, block, or hold it for human review.
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, or hold risky calls for approval. On the way back, hoop.dev data masking walks JSON responses by key and masks matched values in Secrets, ConfigMaps, and pod logs in memory. View the project on GitHub.
Frequently asked questions
Does redhat sso openshift replace Kubernetes RBAC?
No, the identity server only checks who the user is during login. Kubernetes RBAC still controls which resources and namespaces that user can read or change.
Can I write a deny rule in a ClusterRole to block pod exec?
No, Kubernetes RBAC permissions are purely additive and have no deny rules. To block pod exec, you must remove that subresource from every role bound to the user.
What is the difference between a RoleBinding and a ClusterRoleBinding?
A RoleBinding grants permissions inside one namespace only. A ClusterRoleBinding grants permissions across all namespaces and cluster-scoped resources.
Related guides
In this post