Longhorn Kubernetes Architecture
The longhorn kubernetes architecture splits block storage into a control plane and a data plane. It runs dedicated micro-service engines and replicas for each volume across your cluster nodes. Teams often deploy this storage system with broad cluster roles so operators can fix volumes fast. When permissions stay too wide, any user with pod access can read or change live block data. How the longhorn kubernetes architecture works This storage layout relies on two main layers inside your cluster
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.
The longhorn kubernetes architecture splits block storage into a control plane and a data plane. It runs dedicated micro-service engines and replicas for each volume across your cluster nodes. Teams often deploy this storage system with broad cluster roles so operators can fix volumes fast. When permissions stay too wide, any user with pod access can read or change live block data.
How the longhorn kubernetes architecture works
This storage layout relies on two main layers inside your cluster. The manager sits in the control plane and watches volume state through the Kubernetes API. It schedules new volume requests and runs health checks on every node disk. When an app asks for storage, the manager starts a dedicated storage controller for that single volume.
That controller lives in the data plane and writes data to multiple replica pods across nodes. Because each volume gets its own isolated controller, a crash in one volume does not stop others. Replicas store copies of the block data on local node disks to keep data safe if hardware fails. If a node drops offline, the manager spots the missing replica and builds a new copy elsewhere.
All these parts run as standard pods inside a dedicated storage namespace. Kubernetes RBAC rules control who can view or change these storage resources. A Role sets permissions inside one namespace, while a ClusterRole covers nodes and resources across all namespaces. Because RBAC rules are additive with no deny rules, teams must scope RoleBindings with care.
How native RBAC controls storage operations
To manage volumes, engineers need permissions on both custom storage objects and core pod resources. A RoleBinding grants access within the storage namespace by linking a user group to a Role. Admins often grant access to pod subresources such as pod logs and pod exec for daily fixes. In Kubernetes RBAC, you define these subresources with a slash between the resource and the action.
This native setup solves basic login and role checks at the cluster API level. It makes sure only approved engineers can list volumes, read pod logs, or start an exec session. It also binds storage controllers to specific service accounts so apps cannot alter cluster nodes on their own.
Zero Trust Architecture + Kubernetes RBAC: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Where native cluster roles fall short
Native RBAC decides who can start a session, not what commands run inside that session. Once an engineer gets pod exec permissions in the storage namespace, they have full shell control inside the container. They can read raw volume blocks, alter replica files, or copy sensitive data out of mounted disks. Kubernetes RBAC also does not let you restrict create requests by resource name on subresources.
Standard API audit logs record that an exec call started on a specific storage pod. Still, those logs do not show the shell commands typed or the data returned during the session. If a database stores emails, phone numbers, or card numbers on a volume, raw disk tools expose them. Teams need command-level controls and data masking to keep storage operations safe during live fixes.
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 does the storage engine isolate volume failures?
Each block volume runs its own controller and replica pods in the data plane. If one volume controller crashes, other volumes on the same node keep running without interruption.
Should teams use a Role or a ClusterRole for storage admins?
Use a Role with a RoleBinding to limit engineer permissions to the specific storage namespace. Use a ClusterRole only when a role must inspect cluster-scoped nodes or persistent volumes across all namespaces.
Why are pod exec permissions risky in a storage namespace?
Pod exec lets a user run any shell command inside a running storage engine or replica pod. Native RBAC cannot block destructive shell commands or rewrite sensitive fields like card numbers once the session starts.
Short role checks help teams work fast. Simple rules make each review clear. Good logs keep every team safe. Scoped keys stop bad changes early.
Related guides
In this post