Skip to main content
Set these in a values file, and install or upgrade with --values values.yaml. The chart checks them against its schema, and refuses settings that don’t make sense before anything is installed.
The schema checks the values below, but mostly not the names in your file. A misspelt key, like readonly: true instead of readOnly: true, is ignored without a word, and the setting keeps its default. Check your keys against the names on this page, or in helm show values. Under fleet, agent, nodeShell, assistants, audit, access, proxy and extraCA, the schema refuses names it doesn’t know.
To see the defaults, with a comment on each:
Or browse them, version by version, on Artifact Hub.

What it is

string
default:"dashboard"
What the release is:
  • dashboard: Lumovi, showing this cluster to whoever signs in, or a fleet of clusters when the fleet values 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.
A member or an agent makes no Lumovi in the cluster, and no Service, Ingress, NetworkPolicy, or Secret and ConfigMap of Lumovi’s. Each makes a service account, and (unless 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 chart refuses settings that can’t work, before anything is installed, saying why, like:

The cluster and its address

string
default:"in-cluster"
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.
object
default:"{}"
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.
string
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.
string
default:"/"
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

string
default:"token"
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, unless auth.oidc.forwardToken is 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 needs networkPolicy.from to name the proxy’s pods. See Authenticating proxy.
string
The provider’s issuer URL, where /.well-known/openid-configuration is. Required with oidc.
string
Lumovi’s client ID at the provider. Required with oidc.
string
The client’s secret, from which the chart makes a Secret. Leave it empty for a public client, or use existingSecret instead.
string
A Secret in Lumovi’s namespace with the client’s secret under the key client-secret. Takes the place of clientSecret.
string
default:"openid email profile"
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.
string
default:"email"
The ID token claim that names people.
string
default:"groups"
The ID token claim that lists their groups.
string
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.
string
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.
string
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.
string
default:"X-Forwarded-User"
The request header in which the proxy names people.
string
default:"X-Forwarded-Groups"
The request header in which the proxy lists their groups, separated by commas.
string
Where signing out of the proxy is, like https://lumovi.example.com/oauth2/sign_out.
string
default:"off"
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.
string
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.
string
Put before the names of their groups. In a fleet, in every cluster that doesn’t have its own.
number
default:"12"
How long a session lasts, in hours: more than 0, at most 168 (a week).
string
default:"on"
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.
boolean
default:"true"
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.
string
default:"''"
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 when fleet.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.
string
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.
string[]
default:"[]"
Secrets that describe clusters, by whose: lumovi, cluster-api and argocd, each once. Lumovi reads them again every 30 seconds. See Clusters from Secrets.
string[]
default:"[]"
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.
string
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.
boolean
default:"false"
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.
string
default:"<release namespace>-clusters"
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.
boolean
default:"true"
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.
boolean
default:"true"
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.
object
default:"{}"
The labels of the cluster Lumovi runs in, like { env: production, region: eu-west }, each a piece of text.

An agent

With mode: 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.
string
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).
string
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).
string
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.
object
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

boolean
default:"false"
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.
boolean
default:"true"
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.
object[]
default:"[]"
Limits on what everyone’s assistants may do, which nothing of theirs loosens. Each rule has a 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
See Limits for everyone.
string
default:"''"
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.
object
default:"{}"
Clusters’ own limits on changes, by name: { staging: allow, production: never }. In a fleet, the fleet’s clusters’ names.
string[]
default:"[]"
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.
string
default:"auto"
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.
In a fleet, this is every cluster’s: leave it auto unless they all have the same service. See Usage history.
boolean
default:"true"
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.
boolean
default:"true"
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.
integer
default:"2147483648"
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.
boolean
default:"true"
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.
string
default:"kube-system"
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.
string
default:"alpine:3.22"
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.
boolean
default:"false"
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.
string
default:"https://artifacthub.io"
The Artifact Hub Lumovi searches for charts to install.
object
default:"{}"
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.
boolean | list
default:"true"
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.
string[]
default:"[]"
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.
object
default:"{}"
What the chart says, which admins see on the page but can’t change there: 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
See Set it in the chart.

The audit log

What Lumovi records, where it keeps and sends it, and who reads everyone’s. See Audit log for your team.
string
default:"access"
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.
string[]
default:"[]"
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.
boolean
default:"true"
Whether each event is also a line of JSON on Lumovi’s output, with "type":"lumovi.audit", for whatever collects the cluster’s logs.
boolean
default:"true"
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.
string
default:"2Gi"
The claim’s size.
string
default:"null"
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.
string
default:"''"
A claim of your own to keep the history on, instead of the chart’s.
integer
default:"90"
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.
string
default:"''"
An http or https URL to send each event to as well, in batches, tried again until it takes them. See To a webhook.
string
default:"json"
json: an array of events in each request; ndjson: a line of JSON each.
string
default:"''"
A Secret of yours, in Lumovi’s namespace, with the headers to send under headers.yaml, as YAML: Authorization: Bearer ….

Kubernetes objects

boolean
default:"true"
Whether the chart makes Lumovi’s service account.
string
The service account’s name: the release’s full name unless set. Required when serviceAccount.create is false.
object
default:"{}"
Annotations for the service account.
boolean
default:"true"
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) and proxy; in a fleet, when it includes this cluster; and always as a member or an agent,
  • in a fleet, to list Secrets where fleet.secrets are,
  • with assistants.enabled, to get and patch the ConfigMap where it keeps people’s rules for their assistants,
  • with access.admins, to get and patch the ConfigMap where it keeps what admins set, and no other,
  • with auth.keepSessions, to get and patch the Secret where it keeps sessions across restarts, and no other Secret.
Otherwise, the chart makes no RBAC objects either way. Set it to false to manage those permissions yourself.
integer
default:"1"
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.
string
default:"ClusterIP"
ClusterIP, NodePort or LoadBalancer.
integer
default:"80"
The Service’s port. Lumovi itself listens on 8080.
object
default:"{}"
Annotations for the Service.
boolean
default:"false"
Whether the chart makes an Ingress for Lumovi.
string
The Ingress’ class, like nginx.
string[]
default:"[lumovi.example.com]"
The hosts to serve Lumovi at, each with one rule for basePath.
object[]
default:"[]"
The Ingress’ tls, as it is: [{ secretName: lumovi-tls, hosts: [lumovi.example.com] }].
object
default:"{}"
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".
boolean
default:"false"
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).
object[]
default:"[]"
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.
string
default:"''"
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.
string
default:"''"
The proxy for http addresses. Sets HTTP_PROXY.
string
default:"''"
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.
string
default:"''"
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.
string
default:"''"
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.
string
default:"''"
A Secret instead of a ConfigMap, the same way. With both, the ConfigMap is used.
string
default:"ca.crt"
The key the certificate authorities are under, in the ConfigMap or Secret.

The pod

string
default:"ghcr.io/lumovi/lumovi"
The image to run.
string
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.
string
default:"IfNotPresent"
Always, IfNotPresent or Never.
object[]
default:"[]"
Secrets for pulling the image, for a copy in a private registry.
object
The container’s resources. By default it requests 50m of CPU and 128Mi of memory, and is limited to 512Mi of memory.
object
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.
object
The container’s security context. By default: no privilege escalation, a read-only root filesystem, and every capability dropped.
string
default:"auto"
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.
object[]
default:"[]"
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.
object
default:"{}"
Annotations for the pod.
object
default:"{}"
Labels for the pod.
object
default:"{}"
The pod’s node selector.
object[]
default:"[]"
The pod’s tolerations.
object
default:"{}"
The pod’s affinity.
string
The pod’s priority class.
string
Replaces the chart’s name in the objects’ names.
string
Replaces the objects’ full name. Installed as lumovi, they’re all called lumovi.

Configuration

The environment variables the chart sets, for running the image another way.

Install

Install or upgrade with a values file.