EKS Anywhere on Azure

Published
Length
3 min read

Luis Felipe Dias

All posts

You run eks anywhere on azure by deploying an upstream Kubernetes distribution onto Azure virtual machines. Teams manage the control plane, worker nodes, and network layers directly on those cloud instances. Most teams start by sharing admin files or broad cluster roles with their developers. When roles stay too broad, any user can read secrets or delete workloads across namespaces. How eks anywhere on azure handles native cluster permissions Once your virtual machines run the cluster, native

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 run eks anywhere on azure by deploying an upstream Kubernetes distribution onto Azure virtual machines. Teams manage the control plane, worker nodes, and network layers directly on those cloud instances. Most teams start by sharing admin files or broad cluster roles with their developers. When roles stay too broad, any user can read secrets or delete workloads across namespaces.

How eks anywhere on azure handles native cluster permissions

Once your virtual machines run the cluster, native Kubernetes role-based access control governs user actions. You enable this authorization mode directly on the API server. The system uses four main objects to manage permissions across your cluster. A Role sets permissions within one single namespace. A ClusterRole sets permissions across the whole cluster. It covers cluster-wide resources like nodes and namespaced items across every namespace.

To give permissions to a user, you create a binding object. A RoleBinding grants access inside one specific namespace. It can point to a Role in that same namespace or a shared ClusterRole. A ClusterRoleBinding grants access across the entire cluster at once. All rules in this system are purely additive. There are no deny rules in native Kubernetes permissions. You must build roles from zero and add only the verbs a team needs.

Engineers also need to check pod logs or run debug commands inside containers. Kubernetes treats these actions as subresources under the main pod resource. You write the rule with a slash to target the log or exec subresource. This lets you separate pod viewing from live shell entry.

What native roles solve and what they leave open

Native roles and bindings do a good job of sorting users by namespace. You can give a development team read rights in production and write rights in staging. You can also restrict who can request a shell inside a running pod. The API server checks these rules before it allows the session to start.

Still, native access control stops once the API server approves the request. When a user gets permission for the pod exec subresource, they open a shell. Kubernetes does not check the individual shell commands they run inside that container. A user with exec rights can read local files, inspect memory, or change app state. Also, standard API audit logs record that an exec session started. They do not record the actual commands typed or the output returned inside the shell.

Azure RBAC + Single Sign-On (SSO): architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

Managing static cluster credentials across hybrid cloud machines also creates extra work for platform teams. Engineers often store client certificates or token files on their laptops for days. If a laptop is lost, someone can use those files until the credential expires. Native roles decide who logs in, not what commands do in flight. Teams also lack a built-in way to mask emails or card numbers in output.

Why hybrid clusters need tighter command and data controls

Running self-managed clusters on cloud virtual machines puts every security task on your team. You own the host operating system, the network rules, and the API server settings. When an incident happens, an engineer needs fast shell entry to fix the broken app. Giving them a permanent ClusterRoleBinding leaves the cluster exposed every other day of the year.

Teams need a way to approve single actions or time-bound sessions for specific tasks. They also need visibility into every command run inside a container or database pod. Without command-level checks, a routine debug session can turn into an accidental outage. Adding runtime checks closes the gap between basic login rules and real production safety.

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

Can I use deny rules in Kubernetes RBAC on Azure virtual machines?

No, Kubernetes role rules are purely additive and do not support deny statements. You must start with zero permissions and grant only the exact verbs each user needs.

How do I let developers view pod logs without granting shell access?

Create a Role that grants get and list verbs on the pods log subresource only. Leave the pods exec subresource out of the role so users cannot open a shell.

Does a RoleBinding grant access across every namespace in the cluster?

No, a RoleBinding only grants permissions inside the single namespace where you create it. Even if it references a ClusterRole, the user only gets those rights in that namespace.

The query runs. The emails stay hidden.