Argos Kubernetes
You set up an argos kubernetes workflow by defining strict role rules in your cluster. These rules decide which team members or apps can read and change cluster resources. Most teams start by granting broad cluster roles to speed up their daily delivery tasks. Over time, these broad roles give too many people the power to run pod commands. A single bad command or leaked key can then put the whole cluster at risk. How native argos kubernetes permissions work Kubernetes uses role-based rules on
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 an argos kubernetes workflow by defining strict role rules in your cluster. These rules decide which team members or apps can read and change cluster resources. Most teams start by granting broad cluster roles to speed up their daily delivery tasks. Over time, these broad roles give too many people the power to run pod commands. A single bad command or leaked key can then put the whole cluster at risk.
How native argos kubernetes permissions work
Kubernetes uses role-based rules on the API server to control every action in a cluster. Each role holds a list of rules that grant permissions to specific cluster resources. These rules are only additive, which means there are no deny rules in the system. If a user has no role, the API server blocks their request right away.
You can scope permissions to one namespace or apply them across the entire cluster. A standard role sets rules inside a single namespace for local apps and workloads. A cluster role covers cluster-wide items like nodes, or resources across all namespaces at once. You then attach these rules to users or tools with a role binding.
A role binding grants permissions inside one namespace by linking to a role. A cluster role binding grants permissions across every namespace in the entire cluster. The API server checks these bindings each time someone tries to view or change pods. It also checks subresources, which represent specific actions like reading pod logs or running commands.
Where native cluster roles fall short
Native roles are great at deciding who can talk to the cluster API server. They let you separate read-only viewers from engineers who need to deploy new workloads. You can also limit a deployment tool so it only touches its own namespace. This stops a person on one team from deleting pods that belong to another team.
Still, native role rules stop working once a user starts an active pod session. When you grant the subresource rule to run commands in a pod, the check ends. The API server allows the session to start, and then steps out of the way. It does not inspect the shell commands that the user types inside that running container.
Inside the pod, the engineer can read local files or dump memory variables. They can also query connected databases and pull out emails, phone numbers, or card numbers. Native logs only show that a shell session started on a specific pod. They do not show the exact commands run or rewrite sensitive fields in the output.
Kubernetes RBAC: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Why scoping pod subresources is hard at scale
Many teams try to fix this gap by tightening their subresource rules across namespaces. In the API server, pod logs and pod command execution are treated as subresources. You write these rules by pairing the main resource name with the subresource name. While this sounds simple, it creates operational headaches when engineers need to fix live bugs.
If you remove command execution from every role, engineers cannot inspect broken containers during incidents. If you add it back for an emergency, the additive rule model keeps it open. Someone must remember to delete the role binding as soon as the fix is done. Without fine controls over active commands, teams face a tough choice between speed and safety.
Even if you restrict roles to specific resource names, create requests on subresources ignore them. That makes it hard to allow shell commands on just one diagnostic pod in production. Teams need a way to inspect each command and mask national IDs in real time. That is where command-level controls fill the gap left by static cluster bindings.
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 runs as an open-source proxy, a sidecar for your Kubernetes API, checking requests and responses without replacing RBAC.
First, hoop.dev guardrails refuse banned methods, paths, or headers before they run. 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
How do role bindings and cluster role bindings differ in an argos kubernetes setup?
A role binding grants permissions inside a single namespace for local resources. A cluster role binding grants permissions across all namespaces and cluster-scoped resources like nodes.
Can I write a deny rule in Kubernetes RBAC to block pod commands?
No, permissions in Kubernetes RBAC are purely additive and do not support deny rules. To block an action, you must remove the role binding that grants that permission.
How does Kubernetes RBAC control access to pod logs and shell sessions?
RBAC treats pod logs and command execution as subresources under the main pods resource. You must explicitly list these subresources in a role to allow log reading or shell sessions.
Related guides
In this post