extraEnv.
Lumovi reads them when it starts, and checks most of them: one that doesn’t make sense stops it, and its log says which and why. A few aren’t checked. LUMOVI_READ_ONLY and LUMOVI_ALLOW_PRIVATE_CHARTS are on only when they’re exactly true or 1, and anything else leaves them off. LUMOVI_MAX_LIST_ITEMS and LUMOVI_REQUEST_TIMEOUT_MS keep their defaults when they aren’t numbers. LUMOVI_HELM and LUMOVI_ARTIFACT_HUB_URL are used as they are, so a wrong one shows up only when someone uses Helm.
Set by the chart itself
The chart sets a few of these without a value of its own:LUMOVI_PORT to 8080, the port its Service, probes and network policy point at, LUMOVI_PLUGINS_DIR to /etc/lumovi/plugins, where it mounts the plugins everyone sees, with audit.persistence, LUMOVI_AUDIT_DIR to /var/lib/lumovi/audit, where it mounts the audit history’s volume, with access.admins, LUMOVI_ACCESS_CONFIGMAP to <release>-access, the ConfigMap it makes for access, with auth.keepSessions, LUMOVI_STATE_SECRET to <release>-state, the Secret it makes to keep sessions across restarts, and LUMOVI_STATE_KEY from the Secret of the key they’re sealed with, and in a fleet with fleet.kubeconfigSecret, LUMOVI_FLEET_KUBECONFIG_FILE to /etc/lumovi/fleet/kubeconfig, where it mounts that Secret. For an agent, it sets LUMOVI_AGENT_HEALTH_PORT to 8081, where its probes point. Leave these out of extraEnv.
The chart puts extraEnv after its own variables. When two have the same name, Kubernetes uses the last, so a variable repeated in extraEnv wins over the chart’s. For the ones above, that breaks Lumovi: it listens on a port nothing sends to, or reads files from a folder the chart doesn’t mount. For the others, set the chart’s value instead. The chart builds more than the variable on its values, like the permission to impersonate for auth.mode, or the probes and the ingress path for basePath, while a variable in extraEnv changes only Lumovi.
Where it runs
The port to listen on, from
0 to 65535. 0 picks any free port, and the log says which. The chart sets it to 8080 itself.The port to listen on when
LUMOVI_PORT isn’t set, as platforms like Sevalla set it for the application they run. One that isn’t a port stops Lumovi, saying PORT must be a port number.The address people open it at, like
https://lumovi.example.com: an http or https URL. Single sign-on needs it. With https:, cookies are sent over HTTPS only.It’s also an origin Lumovi accepts sign-ins, sign-outs and pages’ connections from, besides the host each request is sent to. Set it when a proxy in front of Lumovi changes the Host header. See Security.It names one host: letters, digits, hyphens and dots, or an IPv6 address in brackets, and no user or password. Lumovi doesn’t start with anything else, and says why: LUMOVI_URL must name one host (letters, digits, hyphens and dots, or an address), not "…", or LUMOVI_URL can’t carry a user and password.Where it is below that address, like
/lumovi. Each part of the path can have letters, digits, _, ., ~ and -.The cluster it shows
What it calls the cluster:
in-cluster (or the kubeconfig’s context) unless set. In a fleet, the cluster it runs in.The labels of the cluster Lumovi runs in, like
env=production,region=eu-west: in a fleet, as one of its clusters; on a Lumovi of one cluster, for AI assistants’ rules that match clusters by label. Labels that aren’t like this stop Lumovi.The kubeconfig’s context to show: its current context unless set. A context the kubeconfig doesn’t have stops Lumovi.
Where the pod’s service account token and CA certificate are, inside a cluster. Lumovi needs the token there even when people sign in with their own tokens, and stops without it. In a fleet, it needs them for the cluster it runs in, and to read Secrets. The chart always mounts them.
Where the API server is, inside a cluster, with
KUBERNETES_SERVICE_PORT. Kubernetes sets both in every pod: you don’t. Without KUBERNETES_SERVICE_HOST or KUBECONFIG, Lumovi stops, saying it isn’t running in a cluster, unless it shows a fleet. In a fleet, it tells Lumovi it runs in a cluster: see LUMOVI_FLEET_LOCAL.A fleet
Many clusters, rather than one: see A fleet of clusters. Lumovi shows a fleet when any ofLUMOVI_FLEET_KUBECONFIG, LUMOVI_FLEET_KUBECONFIG_FILE, LUMOVI_FLEET_SECRETS and LUMOVI_FLEET_AGENTS is set, or LUMOVI_FLEET_LOCAL or LUMOVI_FLEET_ADD_FROM_PAGE is true. It then needs LUMOVI_AUTH to be oidc or proxy, and doesn’t use KUBECONFIG or LUMOVI_CONTEXT. The settings of a fleet’s agents are on Private clusters.
A kubeconfig, each of whose contexts is a cluster: YAML or JSON, or that encoded in base64 on one line. Read when Lumovi starts. One that isn’t a kubeconfig stops it, saying
LUMOVI_FLEET_KUBECONFIG isn't a kubeconfig: …, and base64 that isn’t YAML says LUMOVI_FLEET_KUBECONFIG must be YAML, or YAML encoded in base64.Kubeconfig files, separated by
:, each of whose contexts is a cluster. Read when Lumovi starts, again when one changes, and every LUMOVI_FLEET_REFRESH_SECONDS. A file that can’t be read keeps the clusters it had, and the log says why.Secrets of the cluster Lumovi runs in that describe clusters, by whose:
lumovi, cluster-api and argocd, separated by commas. Only in a cluster: outside one, and with any other name, Lumovi doesn’t start. See Clusters from Secrets.The agents that may connect, as a YAML list, or that encoded in base64 on one line: each with a
name, a token of at least 32 characters or its tokenSha256, and optional caSha256 (its cluster’s certificate authority’s SHA-256, or a list of them), labels, groups and forwardToken. Read when Lumovi starts. See Private clusters.true or false: whether the cluster Lumovi runs in is one of the fleet’s. Unless set, it is whenever Lumovi runs in a cluster and shows a fleet. true outside a cluster stops Lumovi, and true on its own makes a fleet of just that cluster.true or false: whether Lumovi’s admins may add clusters on the Fleet page, kept as Secrets in LUMOVI_FLEET_ADD_NAMESPACE. It needs Lumovi to run in a cluster: true outside one stops it. See From the Fleet page.The namespace the clusters added on the Fleet page are kept in, as Secrets. Unless set, Lumovi’s own namespace followed by
-clusters. Keep it to the administrators of every cluster in the fleet: see A fleet.How often kubeconfig files and Secrets are read again, in seconds: from 1 to 3600.
Sign-in
token, oidc or proxy. See Ways to sign in. A fleet needs oidc or proxy.id or access: pass people’s own token on (the API server must trust the provider) instead of impersonating them. The token must be a JWT that says when it expires. In a fleet, Lumovi passes it on only to clusters with forwardToken: true, and impersonates people in the others.Microsoft Graph’s address, where Lumovi reads the groups of someone in too many for their ID token. It must be
https:// (plain http:// only to this machine, like a stand-in for tests). Otherwise Lumovi doesn’t start, saying LUMOVI_OIDC_GRAPH_URL must be an http or https URL. for one that isn’t a URL, or LUMOVI_OIDC_GRAPH_URL must be https (plain http only to this machine). Set, it’s used with any issuer. Unset, it’s https://graph.microsoft.com for Microsoft Entra ID’s global issuers, and none for any other. See Microsoft Entra ID and many groups.The header a proxy names people in. Upper and lower case don’t matter.
With
LUMOVI_AUTH=proxy: whether your proxy passes the browser’s Sec-Fetch-Site header through to Lumovi unchanged, on or off. On: every request is checked as with single sign-on, and a request without the header is refused, so a browser that doesn’t send it (Safari before 16.4, Firefox before 90, Chrome before 76) can’t use Lumovi on this server. Off: Lumovi can’t tell a request from its own page from one sent by another page, so plugins that run code aren’t offered on this server. Turn it on only after checking that the header reaches Lumovi: a proxy that drops it locks everyone out, and one that sets it itself makes the check mean nothing. See Requests from Lumovi’s own page.Lumovi doesn’t start with it on and any other LUMOVI_AUTH: LUMOVI_PROXY_SEC_FETCH_SITE is for auth.mode proxy; with token the header is always checked., nor with it on and LUMOVI_SEC_FETCH_SITE=off: LUMOVI_PROXY_SEC_FETCH_SITE is on but LUMOVI_SEC_FETCH_SITE is off: nothing is checked. Turn one off or both on.Put before impersonated groups’ names. In a fleet, in every cluster that doesn’t have its own.
How long sessions last, in hours: more than 0, at most 168, a week. Behind a proxy, also how long an AI assistant someone allows acts as them.
Whether a signed-in person’s requests must say they come from Lumovi’s own page,
on or off. On: where a browser sends Sec-Fetch-Site as it signs in, every later request of that session must send it as same-origin, and any other is refused. Turn it off only where something in front of Lumovi removes that 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.A Secret in the namespace Lumovi runs in, where it keeps sessions, the AI assistants people allowed, and each cluster’s settings (read-only, metrics source, node shells), so a restart signs nobody out: see Across restarts. The chart sets it to
<release>-state, which it makes, with auth.keepSessions. Lumovi needs get and patch on it. Lumovi must run in a cluster for it: outside one, it doesn’t start, saying LUMOVI_STATE_SECRET keeps who’s signed in in the cluster Lumovi runs in, and it isn’t running in one (KUBERNETES_SERVICE_HOST isn’t set). Nor does it start without LUMOVI_STATE_KEY: LUMOVI_STATE_SECRET needs LUMOVI_STATE_KEY: the key what’s kept is sealed with, from a Secret of its own (the chart makes one)., or when it can’t read the Secret: Lumovi can’t read Secret lumovi/lumovi-state, where it keeps who’s signed in, the AI assistants they allowed, and people’s pins and saved views: …, with why.Without it, Lumovi keeps them in state.json in LUMOVI_DATA_DIR, which only its user can read, sealed with a key in state.key beside it, which it makes as it first starts. Without either, in memory, and its log says so, as it starts: Who’s signed in, the AI assistants they allowed, and people’s pins and saved views are kept in memory: they’re lost when Lumovi stops., then, in a cluster, The Helm chart’s auth.keepSessions keeps them (LUMOVI_STATE_SECRET)., or outside one, Set LUMOVI_DATA_DIR to keep them., and Run a single replica so: each would keep its own, and what’s set for everyone (the clusters made read-only, say) would differ between them. A restart then signs everyone out.The key what’s kept across restarts is sealed with: at least 32 random characters. With
LUMOVI_STATE_SECRET, it’s needed, from a Secret of its own: the chart sets it from <release>-state-key, which it makes, or from auth.stateKeySecret. Keep it apart from the state: whoever has both can act as anyone. Changed, what was sealed with the old one doesn’t open, and everyone signs in again: it’s left as it is, unused, until 15 minutes pass with nothing sealed with the old key added, then let go, and the log says so. Shorter, Lumovi doesn’t start: LUMOVI_STATE_KEY must be at least 32 characters, random ones. Changed, or lost, what was kept doesn’t open, and everyone signs in again. Without it, and without LUMOVI_STATE_SECRET, Lumovi keeps its own in state.key in LUMOVI_DATA_DIR, or makes a new one each start, in memory. See Across restarts.How often pages’ connections, and a fleet’s agents’, are checked, in seconds, at most 3600. Keep it shorter than the idle timeout of the proxies in front of Lumovi. An agent takes two of these and a second without a check for a lost connection, and connects again.
What people can do
true or 1: nobody changes anything through Lumovi, in any cluster of a fleet, AI assistants included, and the cluster switcher says “For everyone, on this server”. Anything else leaves changes on, and 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.Where usage history comes from, unless another source is set for a cluster, for everyone, on the page:
auto, off, or namespace/service:port, with a path after it for vmselect (vm/vmselect:8481/select/0/prometheus). In a fleet, it’s every cluster’s.on or off: whether Lumovi’s admins can install its metrics stack where a cluster has no usage history. The chart sets it from metrics.stack. Anything else stops the server from starting.The most one copy of files to or from a container carries: a whole number of bytes, or
off, which turns copying off. The chart sets it from fileCopy.enabled and fileCopy.maxBytes. Anything else stops the server from starting, and Lumovi logs the limit as it starts.on or off: whether people can open shells on nodes. With off, nobody can, in any cluster of a fleet, whatever their RBAC allows: a node’s Shell tab says Node shells are off, and Lumovi refuses to start one, saying Node shells are turned off on this Lumovi server (LUMOVI_NODE_SHELL=off). Anything else stops Lumovi, saying LUMOVI_NODE_SHELL must be on or off, not "…".Where node shells’ pods are created, unless another namespace is set for a cluster, for everyone, on the page: a namespace’s name, whose Pod Security must allow privileged pods. 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: one with
sh, and nsenter for shells on the node itself. No spaces, and at most 255 characters. In a fleet, it’s every cluster’s.A namespace that isn’t a namespace’s name, or an image with spaces, stops Lumovi, saying LUMOVI_NODE_SHELL_NAMESPACE must be a namespace's name and LUMOVI_NODE_SHELL_IMAGE an image, not "…" and "…".Where the plugins everyone sees are. The chart sets it itself, to the folder it mounts its
plugins value at.Whose code runs here, of the plugins Lumovi comes with that draw pages of their own:
on, every one’s; off, none; or plugins’ names separated by commas, like karpenter,argo-cd, only theirs. Anything else stops Lumovi as it starts: LUMOVI_PLUGIN_CODE must be on, off, or plugins’ names separated by commas: …. See Plugins’ code.The helm to run:
helm on the PATH unless set. The image sets it to /usr/local/bin/helm, the helm it comes with.Settings for everyone
People’s own settings, set for everyone and locked: Settings shows each with Set by your organization. The same keys as the desktop policy’s
settings, but shell and autoUpdate, like {"theme": "dark", "clock": "24"}. One that isn’t JSON, or has a value Lumovi doesn’t take, stops Lumovi, saying why: LUMOVI_SETTINGS must be JSON: …. What isn’t set stays each person’s, kept for them in the server’s state, on every device they sign in from.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, separated by commas: groups, exactly as people sign in with them, and people as
user: and their name, in any case, like platform-admins,user:ana@example.com. With none, everyone may do all their RBAC allows.What the server says, which admins see but can’t change: a map with
everyone, groups, profiles, grants, limits and names, as YAML or JSON, or either encoded in base64 on one line. Lumovi checks it as it starts, and one that doesn’t make sense stops it, saying where, like LUMOVI_ACCESS: limits[0].caps.helm is install, which limits nothing: it’s the most there is. See Set it in the chart.A ConfigMap in the namespace Lumovi runs in, where it keeps what admins set, under
access.json. The chart sets it to <release>-access, which it makes, when access.admins names someone. Lumovi needs get on it, and patch to save what admins change, and stops when it can’t read it, or isn’t running in a cluster. Without it, access.json in LUMOVI_DATA_DIR, or memory. See Where it’s kept.AI assistants
See AI assistants for your team.on or off: whether AI assistants may sign in and connect, at mcp below the base path. With off, their addresses answer 404, saying This server's administrator has turned AI assistants off. Anything else stops Lumovi, saying LUMOVI_ASSISTANTS must be on or off, not "…".Limits on what everyone’s assistants may do, which nothing of theirs loosens: a list of rules, as YAML or JSON, or either encoded in base64 on one line. Each has a
name, where it applies (clusters, namespaces), and what it limits (visibility, changes, secrets, env, logs). One that doesn’t make sense stops Lumovi, and its log says which. See Limits for everyone.Changes as Lumovi 1.4 limited them, kept as limits:
ask or never for every cluster, then clusters’ own, by name, separated by commas: ask,staging=allow,production=never. allow limits nothing: people choose. Unset, people choose everywhere. Anything else stops Lumovi, saying LUMOVI_ASSISTANT_CHANGES must be ask, allow or never, with clusters' own after it (ask,staging=allow), not "…". See What their changes do.A ConfigMap in the namespace Lumovi runs in, where it keeps each person’s own rules for their assistants. The chart sets it to
<release>-assistant-rules, which it makes. Lumovi needs get on it, and patch to save people’s rules, and doesn’t start when it can’t read it, or isn’t running in a cluster. See Where people’s rules are kept.Without
LUMOVI_STATE_SECRET, a folder where Lumovi keeps who’s signed in and the AI assistants they allowed, in state.json, sealed with a key in state.key, so a restart signs nobody out. Without LUMOVI_ASSISTANT_RULES_CONFIGMAP, where it keeps each person’s own rules for their assistants, in assistant-rules.json. Only Lumovi’s user can read either. Without either, it keeps them in memory, and they’re gone when it stops. Without LUMOVI_AUDIT_DIR, the audit history is kept in its audit folder, and without LUMOVI_ACCESS_CONFIGMAP, what admins set in access.json.Sites, by host name and separated by commas, that an assistant may send people back to over
https once they allow it: assistant.example.com. People’s own computers, apps, and VS Code’s vscode.dev need none. Anything but host names stops Lumovi, saying LUMOVI_ASSISTANT_REDIRECT_HOSTS must be host names, like assistant.example.com, not "…". See Where assistants go back to.The audit log
See Audit log for your team. The Helm chart sets the first eight from itsaudit values. Set the others with extraEnv.
access records everything; changes records changes, sign-ins, settings and Lumovi’s own events, but not shells, port forwards, logs and Secrets read, nor each tool an AI assistant calls. Anything else stops Lumovi, saying LUMOVI_AUDIT_LEVEL must be changes or access, not "…". See How much it records.The folder for the audit history, a file a day. Unset, the
audit folder in LUMOVI_DATA_DIR, or, without that either, memory: what happened since Lumovi started. See Where it’s kept.One Lumovi keeps a folder at a time: another that finds it held (audit.lock in it) waits for it to be let go, or not renewed for 30 seconds. Still held after about 40 seconds, it doesn’t start, saying Another Lumovi (process … on …) keeps its audit history in …: two can’t, or they’d number events the same. Stop it, or give this one a folder of its own. Lumovi’s user must be able to write there, or it doesn’t start either: LUMOVI_AUDIT_DIR (…) can’t be written in: …. As it starts, it makes the folder and its files only its own (0700, 0600).true or false: whether each event is also a line of JSON on Lumovi’s output, for the cluster’s log collector. See On the server’s output.An
http or https URL, in any case, to send each event to, in batches. One that isn’t stops Lumovi, saying LUMOVI_AUDIT_WEBHOOK_URL must be an http or https URL., without repeating it, since a URL can hold a token. It can’t hold a user and password: Lumovi stops, saying LUMOVI_AUDIT_WEBHOOK_URL can't carry a user and password: put an Authorization header in LUMOVI_AUDIT_WEBHOOK_HEADERS. See To a webhook.Headers to send with each request, like an
Authorization header: a map of text, as YAML or JSON, or either encoded in base64 on one line. The chart reads it from the headers.yaml of the Secret that audit.webhook.headersSecret names. Lumovi checks each as it starts, and says which can’t be sent without repeating its value: LUMOVI_AUDIT_WEBHOOK_HEADERS: Authorization’s value can’t be sent in a header (it has a line break, say).How many events wait for the webhook, at most, while it doesn’t take them, from 10 to 1,000,000.They hold 64 MiB at most, too. Past either, the oldest are let go, and counted. See To a webhook.
Without a folder, how many of the most recent events memory keeps, from 100 to 1,000,000.
How many events one search looks through before it stops, and the page offers to look further back, from 100 to 10,000,000.
LUMOVI_AUDIT_RETENTION_DAYS must be a whole number from 1 to 3,650, not "…". So do LUMOVI_AUDIT_WEBHOOK_HEADERS, _FORMAT or _BUFFER without LUMOVI_AUDIT_WEBHOOK_URL.
A company’s network
The chart sets these from itsproxy and extraCA values: proxy.secret sets the proxies from a Secret. See Proxies and certificate authorities.
The proxy for
https addresses, as a URL: http://proxy.corp.example.com:3128, with credentials in it if it wants them (http://user:password@…). Without a scheme, it’s taken as http://. https_proxy too, when HTTPS_PROXY isn’t set. One that isn’t a URL stops Lumovi: HTTPS_PROXY isn’t a proxy’s URL: give it as http://host:port (or https://). Lumovi’s own connections go through it: clusters whose kubeconfig names no proxy-url, single sign-on, Helm repositories and Artifact Hub, the audit webhook, and an agent’s to Lumovi. localhost, 127.0.0.1 and ::1 never do, nor, inside a cluster, KUBERNETES_SERVICE_HOST, kubernetes.default.svc, and names under .svc and .cluster.local. Lumovi’s log says which proxy it uses, without its credentials. helm gets it too.What’s never sent through the proxy, separated by commas or spaces:
* for all; names, with what’s under them (corp.example.com, .corp.example.com); addresses (10.1.2.3), but not ranges; each with a port (:8443) or without. no_proxy too. Lumovi adds what it never proxies, so helm leaves those out as well.Files of certificate authorities to trust besides Node’s and the system’s, separated by commas, each with PEM certificates: the one a proxy that inspects HTTPS signs with, say. Lumovi’s log says how many it took, and from where. A file that can’t be read, has no certificate in it, or one that isn’t a certificate, stops Lumovi, saying
The certificate authorities in … can’t be read: …, … has no certificates in it (PEM, as -----BEGIN CERTIFICATE-----)., or The certificate authorities in … can’t be read: its certificate 2 isn’t one (…). helm trusts them too: Lumovi gives it SSL_CERT_FILE, a file with all it trusts, unless SSL_CERT_FILE is set already. Clusters trust the certificate authority their kubeconfig names, as with kubectl.Large clusters and slow API servers
These work the same as in the desktop app, and the chart has no values for them: set them withextraEnv.
A server’s alone, not the desktop app’s. The most lists and objects one person’s pages watch at once, counted across all their tabs. Past it, a list is read every few seconds instead. A whole number above 0; anything else is 200.
values.yaml
Addresses it answers
All of these are below the base path. Whatever stands in front of Lumovi must pass them all through.
Any other address below the base path is Lumovi’s page or one of its files, for
GET and HEAD. Other methods get 405, and other addresses under api/ and auth/ get 404.
Without AI assistants (LUMOVI_ASSISTANTS=off), their addresses answer 404, and the authorize page says they’re off. Addresses outside the base path get 404, with a note saying where Lumovi is, except two for AI assistants, which Lumovi answers at the origin’s root when it has a base path, like /lumovi: GET /.well-known/oauth-authorization-server/lumovi and GET /.well-known/oauth-protected-resource/lumovi/mcp. See Below a base path. The base path without its trailing slash, like /lumovi, leads to /lumovi/.
Helm values
The chart’s settings, which set these for you.
Run it with Docker
Use these to run the image outside Kubernetes.