--values values.yaml. The chart checks them against its schema, and refuses settings that don’t make sense before anything is installed.
To see the defaults, with a comment on each:
What it is
What the release is:
dashboard: Lumovi, showing this cluster to whoever signs in, or a fleet of clusters when thefleetvalues say where they are.member: what a fleet’s Lumovi needs to reach this cluster: a service account that may only impersonate, and its token. The chart’s notes print the kubeconfig to add. See Add a cluster.agent: a fleet’s agent, for a cluster its Lumovi can’t reach: it dials Lumovi. See Private clusters.
rbac.create is false) a ClusterRole and a ClusterRoleBinding that let it impersonate users and groups. A member adds a Secret with a token for it, and an agent a Deployment. The chart’s notes, after installing, say what to do next: for a member, the kubeconfig entry to add; for an agent, its token’s SHA-256 and its entry in Lumovi’s list.The cluster and its address
What Lumovi calls the cluster: in its pages, their addresses and titles. No slashes or spaces. In a fleet, the name of the cluster Lumovi runs in. For a member, the name its kubeconfig entry has, and for an agent, its name in the fleet.
What the cluster is labelled with, like
{ env: production }, for AI assistants’ rules that match clusters by label. In a fleet, the cluster Lumovi runs in takes fleet.labels instead.The address people open Lumovi at, like
https://lumovi.example.com. Single sign-on needs it, as the provider sends people back there. With https:, cookies are sent over HTTPS only. And Lumovi accepts sign-ins and connections from pages at this address even when a proxy in front of it changes the Host header. See Security.Where Lumovi is below that address, when it shares a host with other apps:
/lumovi, say. The ingress path and health checks follow it. See Give Lumovi an address.Sign-in
How people sign in:
token, oidc or proxy.token: with a token the cluster accepts. Each person’s requests carry their own token, and Lumovi’s service account needs no permissions. Not for a fleet. See Tokens.oidc: with an OpenID Connect provider. Lumovi impersonates whoever signs in, unlessauth.oidc.forwardTokenis set. See Single sign-on.proxy: behind an authenticating proxy that names people in request headers. Lumovi impersonates them. The chart then always makes a NetworkPolicy, and needsnetworkPolicy.fromto name the proxy’s pods. See Authenticating proxy.
The client’s secret, from which the chart makes a Secret. Leave it empty for a public client, or use
existingSecret instead.A Secret in Lumovi’s namespace with the client’s secret under the key
client-secret. Takes the place of clientSecret.The scopes Lumovi asks for, separated by spaces. Add
groups if your provider needs it to put groups in the ID token, offline_access for a refresh token, so that people’s groups follow the provider and tokens passed on are renewed, and, with Microsoft Entra ID, User.Read for many groups.The provider’s name on the sign-in button:
Okta makes it Sign in with Okta. Unset, the button says Sign in with single sign-on.id or access: the token people’s requests carry, when the API server trusts the provider itself (its --oidc-* flags, a structured authentication configuration, EKS’s OIDC identity providers…). Lumovi then needs no permissions, and renews tokens with refresh tokens. Unset, it impersonates people. See When the API server trusts the provider. In a fleet, only clusters with forwardToken: true get people’s tokens, and Lumovi impersonates people in the others, and in its own cluster.Where Lumovi reads the groups of someone in too many for their ID token: Microsoft Graph, over HTTPS. Unset, it’s
https://graph.microsoft.com for Microsoft Entra ID’s global issuers, and none for any other. Set it for a national cloud, like https://graph.microsoft.us. See Microsoft Entra ID and many groups.The request header in which the proxy lists their groups, separated by commas.
With
auth.mode: proxy: whether your proxy passes the browser’s Sec-Fetch-Site header through to Lumovi unchanged, on or off (true and false too). On: every request is checked, and one without the header is refused, so a browser that doesn’t send it can’t use Lumovi. Off: plugins that run code aren’t offered on this server. The chart refuses it on with another auth.mode. See Requests from Lumovi’s own page.Put before the names of the users Lumovi impersonates, like the API server’s
--oidc-username-prefix: oidc: makes alice@example.com oidc:alice@example.com in RBAC. In a fleet, in every cluster that doesn’t have its own.Whether a signed-in person’s requests must say they come from Lumovi’s own page,
on or off (true and false too). Turn it off only where something in front of Lumovi removes the Sec-Fetch-Site header from some requests, and can’t be made to keep it. Off: plugins that run code aren’t offered on this server. See Requests from Lumovi’s own page.Whether a restart, as an upgrade does, signs nobody out. The chart makes a Secret,
<release>-state, where Lumovi keeps sessions, the AI assistants people allowed, each cluster’s settings (read-only, metrics source, node shells), and people’s pins and saved views, each entry sealed, and lets Lumovi get and patch that Secret alone. It also makes the key they’re sealed with, once, in <release>-state-key, 64 random characters, and keeps it across upgrades; Kubernetes gives it to Lumovi as LUMOVI_STATE_KEY. With rbac.create: false, it makes the Secrets but no Role: give Lumovi’s service account get and patch on <release>-state yourself, or Lumovi doesn’t start. Reading the state shows nothing; whoever can write it and read its key can act as anyone: keep the namespace admin-only. Upgrades leave both as they are; uninstalling deletes them, and signs everyone out. false: sessions live in Lumovi’s memory, and a restart signs everyone out and loses people’s pins and saved views, and the chart refuses more than one replica. See Across restarts.A Secret of yours, in the release’s namespace, with the key sessions are sealed with under
key: at least 32 random characters. Give it where the chart is rendered with helm template, as Argo CD does: there, the chart can’t see the key it made before, and would make a new one each time, which signs everyone out. kubectl create secret generic lumovi-state-key --from-literal=key="$(openssl rand -base64 48)" makes one. The chart then makes no key of its own. Give each install its own: two with the same key open each other’s entries, so one copied from another install’s state opens. See Sessions across restarts.A fleet
Lumovi shows a fleet whenfleet.kubeconfigSecret, fleet.secrets, fleet.agentsSecret or fleet.addFromPage is set. A fleet needs auth.mode oidc or proxy: with token, the chart refuses to install. See A fleet of clusters.
A Secret in Lumovi’s namespace with a kubeconfig under the key
kubeconfig, each of whose contexts is a cluster. The chart mounts it at /etc/lumovi/fleet, so the pod doesn’t start until it’s there, and Lumovi reads it again as it changes.Secrets that describe clusters, by whose:
lumovi, cluster-api and argocd, each once. Lumovi reads them again every 30 seconds. See Clusters from Secrets.Where those Secrets are: the release’s namespace unless set. The chart lets Lumovi’s service account list Secrets in each, with a Role and a RoleBinding there, so each must exist before you install.
A Secret in Lumovi’s namespace with the agents that may connect under the key
agents.yaml: a list of { name, tokenSha256, caSha256, labels, groups, forwardToken }. caSha256, the SHA-256 of each agent’s cluster’s certificate authority (or a list of them, while it’s rotated), is the only one Lumovi trusts from that agent; without it, the one the agent first sends, which the chart’s notes warn of. Lumovi reads it when its pod starts, and the pod doesn’t start without it: restart Lumovi after changing it. See Private clusters.Whether Lumovi’s admins may add clusters on the Fleet page by pasting a kubeconfig or a token. Each is kept as a Secret, labelled
lumovi.dev/cluster, in fleet.addNamespace, so the chart lets Lumovi’s service account list, create and delete Secrets in that namespace, and nowhere else. Off, the hub keeps no credentials given on the page. See From the Fleet page.Where the clusters added on the Fleet page are kept, as Secrets: a namespace of their own, never the release’s (the chart refuses it). Lumovi reads there only the Secrets it made, unless
fleet.secrets and fleet.secretNamespaces name it.Whether the chart makes
fleet.addNamespace. It’s kept when the release is uninstalled, with the clusters in it: delete it to let them go. false: it must exist, and the chart only adds its Role there.Installed again under the same release name, the chart takes the kept namespace back as it was. Under another name, Helm refuses it, as it’s still the old release’s: set false, with fleet.addNamespace naming it, to keep its clusters, or delete it first, and them with it.Whether the cluster Lumovi runs in is one of the fleet’s, called
clusterName. Its service account may then impersonate users and groups here, and does, for everyone who signs in.The labels of the cluster Lumovi runs in, like
{ env: production, region: eu-west }, each a piece of text.An agent
Withmode: agent. clusterName is the agent’s name in the fleet, as Lumovi’s list of agents has it. The agent always runs one replica, and uses the chart’s image, extraEnv, podSecurityContext, securityContext, nodeSelector, tolerations, affinity, priorityClassName and serviceAccount values too.
The fleet’s Lumovi, like
https://lumovi.example.com, with its base path if it has one. Required, and over https: the agent’s token, and its cluster’s, travel there. http is taken only for a hub on the same machine (localhost, 127.0.0.1 or [::1]). Otherwise the chart refuses to install: agent.hubUrl must be https, not http://lumovi.example.com: the agent's token and its cluster's would cross the network as they are (http only reaches a hub on the same machine).A Secret in the release’s namespace with the agent’s token under the key
token, for an agent in Lumovi’s list. The agent doesn’t start until it’s there. Unset, the chart makes a Secret, <fullname>-agent, that the agent keeps the token Lumovi gives it in, for its agent.joinToken, and a Role that lets it change that Secret alone (unless rbac.create is false: grant it patch on it yourself).For a cluster connected from the Fleet page: its join token, given from a file or its input (
--set-file agent.joinToken=/dev/stdin), never on the command line. The agent exchanges it for a token of its own, and it no longer works.The agent’s resources, instead of
resources. By default it requests 10m of CPU and 32Mi of memory, and is limited to 128Mi of memory.What people can do
When
true, nobody changes anything through Lumovi, whatever their RBAC allows, in any cluster of a fleet, and neither do their AI assistants. Without it, a cluster can be made read-only on the page, for everyone, by Lumovi’s admins (or anyone, where there are none). See Read-only mode.Whether AI assistants (MCP clients) may sign in through Lumovi and connect, at
mcp below the base path, to act as whoever allows them. Below a base path, the chart’s ingress also routes the two addresses at the origin’s root where they look for how to sign in. With it on, the chart makes a ConfigMap, <release>-assistant-rules, where Lumovi keeps each person’s own rules, and which uninstalling keeps. See AI assistants for your team.Limits on what everyone’s assistants may do, which nothing of theirs loosens. Each rule has a See Limits for everyone.
name; where it applies, clusters and namespaces (names, patterns like tenant-*, labels like team=payments, or ! first to leave one out; none: all of them); and what it limits: visibility: hidden, changes (ask, never), secrets (keys, hidden), env (sensitive, all) or logs: off. The schema takes only these: a setting’s loosest value would limit nothing. A cluster’s labels are clusterLabels, or in a fleet, its clusters’ own.values.yaml
Changes as Lumovi 1.4 limited them, kept as a limit for every cluster that has none of its own:
ask or never, or allow, which limits nothing. Unset, people choose. See What their changes do.Clusters’ own limits on changes, by name:
{ staging: allow, production: never }. In a fleet, the fleet’s clusters’ names.Sites, by host name, that an assistant may send people back to over
https once they allow it, like [assistant.example.com]. Their own computer, apps, and VS Code’s vscode.dev need none: an assistant that runs on the person’s computer, or opens an app, works without it. See Where assistants go back to.Where usage history comes from, unless another source is set for a cluster, for everyone, on the page:
auto: Lumovi looks for Prometheus or VictoriaMetrics among the cluster’s services.off: no usage history.- A service, as
namespace/service:port:monitoring/prometheus-operated:9090. For vmselect, with its path after the port:vm/vmselect:8481/select/0/prometheus.
auto unless they all have the same service. See Usage history.Whether Lumovi offers its admins a small metrics stack to install where a cluster has no usage history. When
true, only Lumovi’s admins install or remove it, as themselves, so their RBAC decides; where access.admins names nobody, nobody can. When false, it’s never offered, installed or removed through Lumovi, in any cluster of a fleet.Whether people can copy files out of containers and into them through Lumovi. When
true, each person’s RBAC (create on pods/exec) and Lumovi’s access decide: a download needs what a shell needs, and an upload also needs changes. When false, Lumovi refuses every copy, in any cluster of a fleet. It sets LUMOVI_FILE_COPY_MAX_BYTES=off.The most one copy carries, in bytes of the files’ contents: 2 GiB unless you say otherwise. At least
1; to turn copying off, set fileCopy.enabled: false.Whether people can open shells on nodes through Lumovi. When
true, each person’s RBAC and the namespace’s Pod Security decide, as for kubectl debug node. When false, nobody can, whatever their RBAC allows, in any cluster of a fleet: a node’s Shell tab says Node shells are off. See Security.Where node shells’ pods are created, unless another namespace is set for a cluster, for everyone, on the page. Its Pod Security must allow privileged pods. A namespace’s name: lowercase letters, digits and
-, starting and ending with a letter or digit, at most 63 characters. In a fleet, it’s every cluster’s.The image node shells’ pods run, unless another is set for a cluster, for everyone, on the page. It needs
sh, and nsenter for shells on the node itself. Where nodes can’t pull from Docker Hub, use a copy in your own registry. No spaces, and at most 255 characters. In a fleet, it’s every cluster’s.When
true, charts may come from addresses inside private networks, such as a ChartMuseum or Harbor in your network. When false, Lumovi fetches charts only from public addresses, connects only to the addresses it checked, and fetches every chart itself; through a proxy (HTTPS_PROXY), the proxy resolves each name, so where it connects is the proxy’s to limit. See Security.Plugins everyone sees, by file name: each key is a file name ending in
.yaml or .yml, and its value the file’s contents. In a fleet, they’re for every cluster. See Plugins for everyone.Whose code runs here, of the plugins Lumovi comes with that draw pages of their own:
true, every one’s; false, none; or a list of plugins’ names, like [karpenter, argo-cd], only theirs. Off for a plugin, its pages and tabs aren’t offered, and no browser is checked for them; its kinds, lists and actions stay. Sets LUMOVI_PLUGIN_CODE. See Plugins’ code.Access
Who may do what through Lumovi, within what RBAC allows. See Access for your team.Who sees the Access pages and decides who may do what there: groups, exactly as people sign in with them, and people as
user:<name>, in any case, like [platform-admins, user:ana@example.com]. With someone named, the chart makes a ConfigMap, <release>-access, where Lumovi keeps what they set, and which uninstalling keeps. With nobody, everyone may do all their RBAC allows.What the chart says, which admins see on the page but can’t change there: See Set it in the chart.
everyone, groups, profiles, grants, limits and names. The schema checks its shape: each level and id. Lumovi checks what names what as it starts, like a grant naming a group there isn’t, and stops if one doesn’t make sense.values.yaml
The audit log
What Lumovi records, where it keeps and sends it, and who reads everyone’s. See Audit log for your team.access records everything; changes records changes, sign-ins, settings and Lumovi’s own events, but not what’s opened and read: shells, logs, Secrets’ values, and each tool an AI assistant calls.Who sees everyone’s events on the Audit log page, and may check its chain: groups, exactly as people sign in with them, and people as
user:<name>, in any case, like [platform-admins, user:ana@example.com]. Everyone else sees their own.Whether each event is also a line of JSON on Lumovi’s output, with
"type":"lumovi.audit", for whatever collects the cluster’s logs.Whether the history is kept on a volume: a PersistentVolumeClaim,
<release>-audit, that uninstalling keeps. Off, the history is in memory: what happened since Lumovi started.With it, the history is one Lumovi’s at a time: the chart runs one replica, and refuses more, and upgrades stop the old pod before starting the new one (Recreate), so Lumovi is away for those seconds. A second pod on the volume, scaled by hand or by an autoscaler, waits for the first, then doesn’t start. One replacing a pod whose node was lost waits half a minute at most. The pod’s fsGroup (podSecurityContext) must be one that may write to it. See Where it’s kept.The claim’s storage class. Unset, the cluster’s default: a cluster without one needs it set.
'' asks for none, for a volume made by hand with no class.How many days the history keeps, from 1 to 3650. Your log collector or webhook keeps its own copy for as long as it does.
An
http or https URL to send each event to as well, in batches, tried again until it takes them. See To a webhook.A Secret of yours, in Lumovi’s namespace, with the headers to send under
headers.yaml, as YAML: Authorization: Bearer ….Kubernetes objects
The service account’s name: the release’s full name unless set. Required when
serviceAccount.create is false.Whether the chart gives Lumovi’s service account the permissions it needs:
- to impersonate users and groups: for one cluster, with
oidc(unless tokens are passed on) andproxy; in a fleet, when it includes this cluster; and always as a member or an agent, - in a fleet, to list Secrets where
fleet.secretsare, - with
assistants.enabled, togetandpatchthe ConfigMap where it keeps people’s rules for their assistants, - with
access.admins, togetandpatchthe ConfigMap where it keeps what admins set, and no other, - with
auth.keepSessions, togetandpatchthe Secret where it keeps sessions across restarts, and no other Secret.
false to manage those permissions yourself.How many Lumovi pods to run. Each pod knows the sessions started on it (they’re kept for a restart, not shared as they change), and single sign-on has to finish on the pod it started on: more than one needs sticky sessions. Keep a fleet’s at one: each agent connects to one pod. With
assistants.enabled, the chart refuses more than one, saying AI assistants need a single replica (replicaCount 1): …: what people allowed, their assistants’ tokens, and the changes those ask for live in one pod’s memory, and assistants’ requests carry no cookies to stick to it. Set assistants.enabled: false to run more. With audit.persistence.enabled, it refuses more than one too, saying The audit history on its volume needs a single replica (replicaCount 1): …. Set audit.persistence.enabled: false to run more: each then keeps its events in memory, in a chain of its own. Without auth.keepSessions, it refuses more than one, saying More than one replica (replicaCount) needs auth.keepSessions: without it, each replica keeps who's signed in, and what's set for everyone (the clusters made read-only, say), in its own memory, and they don't agree.The hosts to serve Lumovi at, each with one rule for
basePath.The Ingress’
tls, as it is: [{ secretName: lumovi-tls, hosts: [lumovi.example.com] }].Annotations for the Ingress. Pages keep a WebSocket open, so give the ingress controller a long read timeout, like
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600".Whether the chart makes a NetworkPolicy that only lets in what
networkPolicy.from allows, on Lumovi’s port. With auth.mode: proxy, it always does, whatever this says. It holds only where the cluster’s network plugin enforces NetworkPolicies (most do; flannel alone doesn’t).The NetworkPolicy’s
from: who may reach Lumovi. With auth.mode: proxy, it’s required, and names the proxy’s pods: otherwise the chart refuses to install, saying auth.mode proxy trusts the X-Forwarded-User header from whoever reaches Lumovi: set networkPolicy.from to the proxy's pods (a podSelector, with a namespaceSelector if it runs in another namespace), so that nobody else can. Otherwise, empty, anything may, on Lumovi’s port. A podSelector on its own matches pods in Lumovi’s namespace only: for pods in another namespace, add a namespaceSelector to the same entry, as in A proxy in another namespace.A company’s network
For Lumovi, and an agent, behind a company’s proxy. See Proxies and certificate authorities.The proxy for
https addresses, as a URL: http://proxy.corp.example.com:3128. Sets HTTPS_PROXY. Lumovi’s own connections go through it: clusters whose kubeconfig names no proxy-url, single sign-on, Helm repositories, the audit webhook, and an agent’s to Lumovi. This cluster’s API server and services are always reached directly. Without a scheme, it’s taken as http://. A proxy that wants credentials takes them in the URL: give that with proxy.secret instead, as this value goes into the Deployment as it is.A Secret in the release’s namespace with the proxies’ URLs, under
HTTPS_PROXY, and HTTP_PROXY if plain http goes through one too, instead of proxy.https and proxy.http. Without the Secret, or its HTTPS_PROXY, the pod doesn’t start (CreateContainerConfigError). It’s for a proxy that wants credentials, which then stay out of the Deployment. Given with proxy.https or proxy.http, the chart refuses it: proxy.secret holds the proxies' URLs: give it, or proxy.https and proxy.http, not both. See Credentials.What’s never sent through the proxy, separated by commas: names, with what’s under them (
.corp.example.com), and addresses, each with a port or without. Not ranges (10.0.0.0/8). Sets NO_PROXY. See NO_PROXY.A ConfigMap in the release’s namespace with certificate authorities to trust besides the image’s and Node’s, as PEM, under
extraCA.key: the one a proxy that inspects HTTPS signs with, say. The chart mounts it at /etc/lumovi/ca, and sets LUMOVI_CA_FILE to the file. Lumovi doesn’t start without it, nor with a file that has no certificate in it.The pod
The image’s tag: the chart’s
appVersion unless set. Each chart is released with Lumovi, and its version and appVersion are the same, so the chart installs the image of its own version. To pin the image by its digest, give the digest after the tag: 1.23.2@sha256:…. See Pin it by digest.The container’s resources. By default it requests
50m of CPU and 128Mi of memory, and is limited to 512Mi of memory.The pod’s security context. By default: non-root, as user and group 65532, with
fsGroup 65532 too, and the RuntimeDefault seccomp profile. On OpenShift, without runAsUser, runAsGroup and fsGroup, which OpenShift gives: see openshift.The container’s security context. By default: no privilege escalation, a read-only root filesystem, and every capability dropped.
Whether the cluster is OpenShift, whose
restricted-v2 security context constraint gives each pod its user, group and fsGroup from the namespace’s ranges. There, the chart leaves those three out of podSecurityContext, for Lumovi and an agent. auto asks whether the cluster has security.openshift.io/v1; true or false says so. Rendering the chart without a cluster, with helm template, auto finds no OpenShift: set true. See OpenShift.More environment variables, as a container’s
env, for Lumovi or for an agent. See Configuration for the ones Lumovi reads, and Private clusters for an agent’s. They come after the chart’s own, and Kubernetes uses the last of two with the same name, so leave out the ones the chart sets itself: see Set by the chart itself.Configuration
The environment variables the chart sets, for running the image another way.
Install
Install or upgrade with a values file.