Openshift Helm Charts

Published
Length
3 min read

Luis Felipe Dias

All posts

You deploy openshift helm charts by packaging manifests into templates and sending them to the cluster API. Your team must hold role permissions to create and update every resource in that package. Most teams start by giving developers broad role bindings so chart installs do not fail. Over time, those wide roles let users read secrets or run commands inside live pods. How openshift helm charts work with cluster roles A chart bundles all the manifests an app needs into one versioned package.

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 deploy openshift helm charts by packaging manifests into templates and sending them to the cluster API. Your team must hold role permissions to create and update every resource in that package. Most teams start by giving developers broad role bindings so chart installs do not fail. Over time, those wide roles let users read secrets or run commands inside live pods.

How openshift helm charts work with cluster roles

A chart bundles all the manifests an app needs into one versioned package. When a user installs a chart, the client sends those manifests to the API server. The API server checks the user role before it creates any object. In this system, a Role sets permissions inside one single namespace. A ClusterRole sets permissions across the whole cluster and covers cluster-scoped resources like nodes. Permissions are additive, which means there are no deny rules in the native role model.

You link a user or group to those rules with a binding. A RoleBinding grants permissions inside one namespace and can point to a Role or ClusterRole. A ClusterRoleBinding grants permissions across every namespace in the cluster at once. Many charts create workloads, service accounts, and config maps during a single install run. Because the user needs rights for every object type in the chart, admins often grant wide roles.

Why chart roles are not enough for live pods

Native role bindings control who can install a chart or view a pod. They also control subresources such as pod logs and pod exec endpoints. When you grant the pod exec subresource in a role, the user can open a shell. Native roles check permission only when the user starts the request at the API server.

Once a shell or database session starts, the cluster role cannot see individual commands in flight. A developer who needs to debug a deployed chart often gets full exec rights in that namespace. With that role, they can run any command inside the container or read raw app data. Native role rules cannot pause one risky command for approval while letting safe commands run. They also cannot mask sensitive fields like emails, phone numbers, card numbers, or national IDs in output. Teams need a way to inspect and control live sessions after the chart is running.

Helm Chart Security + OpenShift RBAC: architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

Best practices for scoping chart permissions

Start by separating the identity that installs charts from the human users who debug apps. Let an automated pipeline run the chart updates using a dedicated service account in that namespace. Bind that account with a RoleBinding instead of a ClusterRoleBinding whenever the chart allows it. Keep human roles small and remove permanent pod exec rules from daily developer accounts. When engineers need to inspect a live pod or database, control those actions at the command level.

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

Can a Role block a specific resource inside a chart?

No, native permissions are only additive and do not support deny rules. To block an action, you must leave that permission out of every Role bound to the user.

Should I use a RoleBinding or a ClusterRoleBinding for chart installs?

Use a RoleBinding whenever the chart deploys resources into a single namespace. You can point a RoleBinding to a shared ClusterRole while keeping the access inside that one namespace.

How does the cluster control shell access to pods deployed by a chart?

The API server checks if the user role includes permission for the pod exec subresource. If allowed, the server opens the stream, and native roles do not filter commands inside that shell.

The query runs. The emails stay hidden.