Skip to main content

Overview

Open WebUI is a self-hosted, ChatGPT-style chat interface for large language models with user accounts, RAG (chat grounded in your uploaded documents), and model management. This template deploys a single stateful workload that keeps all of its state on a persistent volume and connects to your models through an in-GVC Ollama server and/or any OpenAI-compatible endpoint. The install is private by default: publicAccess.enabled is false and self-registration is closed, because the first account registered on a fresh install becomes the administrator. You reach the UI over a port-forward, claim that admin account, and then opt in to publishing it — see First Run.

Architecture

  • Open WebUI — A single-replica stateful workload serving the web UI and API on port 8080. A mounted start script sets its public WEBUI_URL from the canonical endpoint at boot, so links resolve correctly with no manual configuration.
  • Embedded SQLite on a persistent volume — All durable state (the webui.db database, uploaded files, the default Chroma vector store used for RAG, and cache) lives on the workload’s volume set at /app/backend/data. SQLite is single-writer, so there is no external database dependency and the workload runs as exactly one replica.
  • Model backends — Chat completions are served by an existing Ollama workload in the same GVC (default), an OpenAI-compatible API (optional), or both. Neither backend is bundled by this template — you point it at model providers you run or subscribe to.
  • No template-created credential — The key that signs sessions and JWTs lives only in a secret you create yourself, so it never enters the Helm release.

What Gets Created

  • Stateful Open WebUI Workload — A single replica serving the web UI and API on port 8080.
  • Volume Set — A 10 GiB persistent volume mounted at /app/backend/data holding the SQLite database, uploaded files, the RAG vector store, and cache. Scheduled snapshots protect the data, and a final snapshot is kept on delete.
  • Start-Script Secret — An opaque secret whose boot script sets WEBUI_URL from the canonical endpoint.
  • Identity & Policy — An identity bound to the workload with a least-privilege policy granting reveal access to exactly the secrets it mounts: your session-key secret, the start-script secret, and your OpenAI-key secret only when you configure one.
This template does not create a GVC. You must deploy it into an existing GVC.

Prerequisites

One opaque secret must exist before you install. The key that signs every session and JWT is a long-lived credential, so it is not a value — a value would sit in the Helm release for the life of the install.
1

Create the session signing key secret

Generate a random key and store it as the secret’s payload:
Set auth.secretKeyName to the name you used.
2

Keep it forever

Back the key up somewhere safe outside Control Plane. It is never rotated: replacing it invalidates every issued session and JWT, logging every user out.
A missing prerequisite secret wedges the install rather than failing it. cpln helm install still exits 0 and reports success, but the workload never starts: it sits at zero replicas with the message The secret <name> no longer exists. Workload updates are paused until the secret is added or the reference to the secret removed. Create the secret first, and after installing confirm with cpln workload get-deployments {release}-open-webui --gvc {gvc} rather than trusting the Helm output.
These are optional and only needed for the corresponding feature: License awareness — Open WebUI ships under the “Open WebUI License” (BSD-3-Clause plus a branding-protection clause). It is free to self-host and run in production at any scale, but you must keep the “Open WebUI” branding visible in the UI unless your deployment serves 50 or fewer users, or you obtain enterprise permission. See Important Notes. Once the secret exists, install the template using your preferred method:

UI

Browse, install, and manage templates visually

CLI

Manage templates from your terminal

Terraform

Declare templates in your Terraform configurations

Pulumi

Declare templates in your Pulumi programs

First Run

A default install is closed on every side: the canonical endpoint returns 403 to the internet, and internalAccess.type: none blocks other workloads in the GVC. Claim the admin account through a port-forward first, then publish the UI.
1

Install with the defaults

Install with auth.secretKeyName pointing at the secret you created, and leave publicAccess.enabled: false and auth.enableSignup: false alone. Wait for the workload to report ready:
2

Register the admin account over a port-forward

Forward the UI to your own machine:
Then open http://localhost:8080, which shows Open WebUI’s “create admin account” screen. Port forwarding reaches the workload even though it is closed to both the internet and the GVC, and the account you create there is the administrator.If you would rather not leave the terminal, the same registration works over the container’s own loopback address:
The response carries "role":"admin". A second registration attempt returns 403, because only the first account is exempt from auth.enableSignup: false.
3

Publish the UI

Now that the admin account is claimed, upgrade the release with publicAccess.enabled: true and sign in at the canonical endpoint. Allow up to a couple of minutes for the firewall change to take effect — a measured toggle moved through 403503200 over about 143 seconds.
Do not plan to close sign-ups later with an upgrade — it does nothing. auth.enableSignup is read only while no account exists. Creating the first account writes the setting into webui.db, and from then on the stored value wins over the environment: an upgrade can neither open nor close self-registration. Add users, or re-open self-service sign-ups, from Admin Settings → Users in the UI.

Configuration

The default values.yaml for this template:

Instance & Resources

  • image — The Open WebUI container image.
  • resources — CPU and memory for the container. RAG loads a local embedding model into RAM on first use, so keep memory at or above the default.
  • volumeset.capacity — Volume size in GiB (minimum 10) for the SQLite database, uploads, RAG vector store, and cache.

Backup

Scheduled, crash-consistent snapshots of the data volume, managed by the platform — no cloud account or bucket is required. See Backing Up for how snapshots work and Restoring a Backup for the manual restore procedure.
  • backup.enabled — Take periodic snapshots of the data volume (default true).
  • backup.schedule — Cron expression in UTC (default 0 3 * * *, daily at 03:00). The platform does not accept schedules more frequent than hourly.
  • backup.retention — How long each snapshot is kept, e.g. 7d, 720h, 30d.

Authentication

  • auth.secretKeyName — Name of the opaque secret holding the session and JWT signing key. It must exist before you install (see Prerequisites) and must never change afterward.
  • auth.enableSignup — Whether users can create their own accounts (default false). The first account on a fresh install is exempt, so a default install is still usable — that is how you create the admin in First Run.
auth.enableSignup only has an effect while no account exists. Once the first account is created the value is stored in webui.db and the stored setting wins permanently, so changing this knob in a later helm upgrade has no effect in either direction. Manage users and self-registration from Admin Settings → Users.

Model Backends

At least one backend is needed to actually chat. The Ollama backend is on by default; the OpenAI-compatible backend is off until you supply a key secret. You can enable both.
  • ollama.enabled — Connect to an existing Ollama workload in this GVC (default true).
  • ollama.workloadName — The Ollama workload’s name in this GVC. The base URL is derived as http://{workloadName}.{gvc}.cpln.local:{port}.
  • ollama.port — The Ollama API port (default 11434).
  • openai.baseUrl — Any OpenAI-compatible endpoint (default https://api.openai.com/v1). The workload’s outbound firewall is open, so hosted providers such as api.openai.com are reachable.
  • openai.apiKeySecretName — Name of your pre-created opaque secret holding the API key (see Prerequisites). Empty (default) leaves the OpenAI backend off, and the policy grants no access to any key secret.
Backend settings apply on the first boot only, and a later change fails silently. ollama.*, openai.* and customDomain are read from the environment the first time the workload starts and are then stored in webui.db; a later helm upgrade is ignored. The danger is that nothing looks wrong — the original backend keeps working, so a user who “retargets” their model provider by upgrade sees the upgrade succeed and keeps talking to the old provider. Set these at install, and change model connections afterward from the admin UI under Settings → Connections.

Access

  • customDomain — Full URL of a custom domain, e.g. https://chat.example.com. The scheme is required; the chart fails the render without it. Empty (default) uses the canonical *.cpln.app endpoint.
  • publicAccess.enabled — Serve the UI over public HTTPS on the canonical *.cpln.app endpoint (default false). While it is off, external requests are rejected at the edge with 403 and only in-GVC callers reach the workload, per internalAccess.
  • internalAccess.type — Internal firewall scope for in-GVC callers of the Open WebUI API:
customDomain sets WEBUI_URL and nothing else. It does not create a Control Plane domain, and the install succeeds with no error or warning if none exists — the hostname simply never resolves, and the canonical endpoint remains the only way in. Create and verify the domain separately. Because it is also frozen after the first boot, set it at install rather than adding it to a running release.
An access change takes effect at the edge after a short propagation delay — allow up to a couple of minutes before concluding a firewall knob did not work.

Connecting

Using a Model Backend

Deploy the Ollama template into the same GVC and pull at least one model, then install Open WebUI with ollama.workloadName set to that workload’s name — its models appear in the model picker automatically. To use a hosted provider instead, create the API-key secret (see Prerequisites), set openai.apiKeySecretName, and Open WebUI lists that provider’s models. If a configured Ollama backend is unreachable the UI still boots and simply shows no Ollama models — an empty model list is the symptom of a wrong ollama.workloadName. Confirm it names a ready Ollama workload in the same GVC.

Backing Up

Backups are scheduled volume snapshots managed by the platform — no cloud account or bucket is required. On the configured cron schedule the platform takes a crash-consistent snapshot of the data volume; SQLite recovers cleanly from one. Snapshots are pruned automatically after backup.retention, and a final snapshot is always taken when the release is uninstalled.
  • Default schedule — Daily at 03:00 UTC (backup.schedule: "0 3 * * *"), kept for 7 days (backup.retention: 7d).
  • Minimum interval — The platform does not accept schedules more frequent than hourly.
List the snapshots for the release’s volume set:
Snapshots live in the platform storage layer alongside the volume, not off-site. They protect against data corruption and accidental changes, but losing the whole GVC would lose them too.

Restoring a Backup

There is no automated restore. backup.enabled only takes snapshots; recovering from one is a manual, deliberate operation you run yourself. Restore is in-place on the release’s own volume set: the platform provisions a fresh volume from the chosen snapshot and swaps it in, then the workload restarts to remount it.
Restoring reverts the volume to the exact snapshot state, so everything written after the snapshot is gone — including user accounts. A user who registered after the snapshot was taken can no longer sign in. It also restarts the single-replica workload, so the UI is unavailable during the swap.
1

Find the snapshot to restore

List snapshots and note the name, location, and volumeIndex of the one you want:
2

Restore it in place

Provision a fresh volume from the snapshot and swap it in. The workload restarts to remount it:
A measured restore took about 2.5 minutes end to end, of which roughly 40 seconds was workload downtime.
3

Verify

Once the workload is ready again, sign in and confirm your chats and settings are present.

Important Notes

  • Create the session-key secret before installing, and never change it. auth.secretKeyName only names the secret; the workload wedges waiting on one that does not exist. The key signs every session and JWT, so replacing it logs every user out.
  • The first account registered becomes the administrator. That is why the UI ships private with sign-ups closed — an unclaimed admin account on a public URL belongs to whoever finds it first. Claim it over a port-forward before turning publicAccess.enabled on; see First Run.
  • auth.enableSignup is only read while no account exists. After the first account it is stored in webui.db and the stored value wins, so a later helm upgrade can neither open nor close sign-ups. Use Admin Settings → Users instead.
  • ollama.*, openai.* and customDomain apply at install, then persist in the app database. A later helm upgrade is ignored and the old backend keeps working, so there is no symptom to warn you. Change model connections from the admin UI under Settings → Connections.
  • customDomain does not create a domain. It sets WEBUI_URL only; create the Control Plane domain and its DNS separately, or the hostname will not resolve while the install reports success.
  • Restoring a snapshot is manual and loses post-snapshot data, including accounts created after it was taken. See Restoring a Backup.
  • Single replica, by design. The embedded SQLite is single-writer and the volume set is per-replica, so the workload is pinned to one replica with no replicas knob. A restart or upgrade is a brief full outage of about a minute — including the first helm upgrade after an install, which re-applies the workload even when nothing changed.
  • Data lives only on the volume set. Uninstall deletes it (a final snapshot is taken first); a reinstall starts empty, including the admin account. Your own prerequisite secrets are not deleted, since the chart does not own them.
  • Ollama unreachable is non-fatal. The UI boots and shows no Ollama models rather than failing, so check the model list after install.
  • License / branding clause — You must keep the “Open WebUI” branding visible in the UI unless your deployment serves 50 or fewer users, or you have enterprise permission. Removing the branding outside those cases violates the license; it is not a template setting.

External References

Open WebUI on GitHub

Upstream source repository

Open WebUI Documentation

Official documentation and getting-started guides

Environment Variable Reference

Full list of supported configuration variables

License

The Open WebUI License and its branding clause

Ollama Template

Deploy the in-GVC Ollama model backend

Open WebUI Template

View the source files, default values, and chart definition