Skip to main content
Lumovi acts with your credentials: the ones in your kubeconfig on the desktop, or the identity you signed in with when it runs in your cluster. It never has more access than you do, and it doesn’t need cluster-admin. An account that can only read a few namespaces works fine. In a fleet, each cluster applies your RBAC there: Lumovi impersonates you with credentials that may do nothing else, or passes your own token on. What you may do can differ from one cluster to the next. For whoever runs the fleet: in each cluster, Lumovi’s own credentials need nothing but impersonate on users and groups. See Add a cluster.
In your cluster: Lumovi’s admins can let you do less through Lumovi than your RBAC allows: no shells in production, say, or Secrets’ keys but not their values. Your access says what, and why.

Asked up front

Before it offers a change, Lumovi asks the cluster whether you’re allowed to make it, with a SelfSubjectAccessReview per action (the same check as kubectl auth can-i). Kubernetes lets every signed-in account make these checks.
  • An action you can’t take stays visible, but disabled, and says why: Your account can’t delete pods in shop.
  • If the cluster can’t say, the action stays available and the API server has the final word.
  • Answers are kept for five minutes.
A cluster made read-only disables every change regardless, with Changes are turned off for this cluster. (on a server, with who made it read-only for everyone). On a server, what your access doesn’t allow is disabled too, saying why: Your access doesn’t let you make changes in shop: none of your grants gives it here.

Looking around

Lists and details need list and get on the kinds you look at. With watch on a kind too, a list or an opened object updates within a second of a change, and while nothing changes it’s read again only once a minute. Without it, Lumovi asks again every few seconds (less often for long lists), as it does for Secrets on a server and for a fleet’s clusters reached through their agent. A watch tells Lumovi only that something changed: what’s shown is always read with list and get. If a page needs something you can’t read, it says Access denied, with Your account isn’t allowed to read this. If you only have access to some namespaces, pick one from the namespace menu.

Usage history

Charts over time come from a Prometheus-compatible server, reached through the API server’s service proxy with your own credentials. Without list on services, choose the service in Metrics source (on a server, Lumovi’s admins do, for everyone). See Usage history.

Helm releases

Lumovi reads releases from the Secrets (or ConfigMaps) Helm keeps them in, so looking at them needs list on secrets in their namespaces (or on configmaps, for releases kept there), and no helm. The built-in view ClusterRole doesn’t include Secrets, so it isn’t enough to see releases. Changing a release runs helm with your credentials, so you need whatever Helm needs to change the release’s objects. See Helm releases.

Making changes

Each action checks one permission first: A few notes:
  • Draining cordons the node, then evicts its pods a few at a time, so it also needs create on pods/eviction. A PodDisruptionBudget can refuse an eviction: the drain shows each pod’s progress, with Retry for any that fail.
  • Debug containers open a shell in the new container, which also needs pods/exec.
  • Shells on nodes run in a privileged pod Lumovi creates, so that namespace’s Pod Security must allow privileged pods. Without delete, the pod stays until its 12-hour deadline, and the tab says so before you start. See Shells on nodes.
  • Terminals in the desktop app aren’t checked: they’re your own shell, and what you run there needs what it would in any terminal.
  • Create and several at once don’t check first. The cluster checks each object, and the dialog shows what it refused.
To check a permission yourself, use kubectl auth can-i, for example kubectl auth can-i create pods/exec -n shop. Lumovi asks the cluster the same question.

AI assistants

AI assistants use Lumovi with your credentials, like everything else in it: in the desktop app, your kubeconfig’s; on a server, the ones you signed in with, so Lumovi impersonates you, or passes your own token on, as it does for your pages. An assistant can read and change only what your account can, and Lumovi gives it nothing of its own. Lumovi doesn’t ask the cluster up front for an assistant. It sends each change as a dry run first, which the API server checks against your RBAC like the real change, so one your account can’t make fails there, before you’re asked. Reading something you may not read fails the same way, and the assistant is told why. Once you approve a change, other than a deletion, it’s tried as a dry run again, with the same permissions. Within what your RBAC allows, your AI permissions narrow what assistants may do: namespaces they don’t see, Secrets’ values, env values and logs they don’t read, and changes they don’t make. A cluster you made read-only refuses assistants’ changes whatever your RBAC allows, and so does one where your permissions say Never.

An example

A teammate with the built-in view role can browse workloads and read logs. To let them see usage history from a Prometheus in monitoring too, bind a Role there:

Changing things safely

The guard rails on every change.

Read-only mode

Turn changes off for a cluster, whatever RBAC allows.