Self-host Open WebUI on a Cube

Open WebUI is a self-hosted, MIT-licensed chat interface for any LLM — the closest open-source equivalent to ChatGPT, with multi-user support, RAG across nine vector databases, plugins, and a built-in browser extension. About 152,000 stars on GitHub (verified 2026-09-13). A Cube is a good place to run it: real resources, no public IP needed for the UI itself, and the per-minute billing suits an always-on chat server.

The install is one Docker command. The part worth reading carefully is Step 5 — the Open WebUI web UI runs on port 8080, and a Cube has no public inbound of its own. The path is to point a domain at the Cube and let the Krova edge terminate TLS.

Before you start

Open WebUI is a Python + Svelte/TypeScript app that ships as a single Docker image. It runs against any OpenAI-compatible endpoint — local Ollama, OpenAI, Anthropic via an OpenAI-compatible proxy, or a hosted provider. The framework itself is small; the heavy resource is the LLM it serves.

• A Cube of 2 vCPU, 4 GB RAM, 40 GB disk — about $0.0140/hour, roughly $0.34/day or $10/month if left running. Comfortable for Open WebUI plus a small local model.
• If you want to run a capable local model (around 7B parameters), plan on 8 GB RAM and 8 GB of disk for the model weights alone, in addition to the UI. The Cube size for that is 4 vCPU, 16 GB RAM, 100 GB disk.
• An SSH key pair, as with any Cube.
• An API key from an AI provider — or a local Ollama install if you would rather skip the paid API.

Step 1 — Create the Cube

Create a Cube with the Ubuntu 24.04 + Docker image. Open WebUI ships as a Docker image, and starting from the Docker image skips the apt-install step. If your Cube image picker does not have a Docker image, plain Ubuntu 24.04 works.

Size it at 2 vCPU / 4 GB / 40 GB if you are pointing Open WebUI at a paid AI provider, or 4 vCPU / 16 GB / 100 GB if you want to run a local 7B model through Ollama on the same Cube.

Step 2 — Connect over SSH

ssh ubuntu@<cube-host> -p <port>

Step 3 — Run Open WebUI in Docker

Open WebUI ships a single Docker image. The canonical install maps host port 3000 to the container's internal port 8080, persists data in a named volume, and uses host.docker.internal so the UI can reach Ollama running on the host if you want a local model:

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  -e WEBUI_SECRET_KEY=$(openssl rand -hex 32) \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Confirm the container is up:

docker ps

Step 4 — Pick the model backend

Open WebUI accepts any OpenAI-compatible provider. The two reasonable choices on a Cube are the same shape as the other self-host guides.

Paid API (the simplest)

On first launch, open Settings → Connections and add an OpenAI or OpenAI-compatible endpoint. Paste the API key and Open WebUI routes every chat through that provider. Billing is on the provider, not Krova.

Local Ollama on the same Cube

For a no-per-message bill, install Ollama on the same Cube and point Open WebUI at it. Ollama exposes an OpenAI-compatible API on http://localhost:11434:

curl -fsSL https://ollama.com/install.sh | sh

Pull a model — llama3.1:8b is a good first choice on 16 GB of RAM:

ollama pull llama3.1:8b

Open WebUI detects Ollama at host.docker.internal:11434 automatically (the --add-host flag in the run command makes that hostname resolve inside the container). Pick the model in the UI. Everything from there is local.

Step 5 — Give the UI a real address

The Open WebUI web UI listens on port 8080 inside the container (mapped to host port 3000 by the run command). On the Cube's Networking tab, add a domain and map it to the container's host port 3000:

• Add a DNS record for your domain pointing at dns.krova.cloud (the Cube's networking tab has a copy button for it).
• On the Cube's Networking tab, choose Add Domain:

• Domain — the hostname, e.g. chat.example.com.
• Port — 3000, the host port the container maps to 8080.
• This app serves HTTPS itself — leave it unchecked. Open WebUI serves over plain HTTP internally; Krova adds the TLS.

Once the domain reads Active, the UI is at https://chat.example.com with no tunnel and no published port. The first screen creates the owner account — do that through the tunnel (or, after the domain is live, at the domain itself) before publishing the port to the internet.

Step 6 — Add users, RAG, and plugins

Open WebUI ships multi-user support with role-based access, a RAG pipeline across nine vector databases, and a plugin system for custom filters, actions, and tools. All of it is configured in the web UI under Settings. Persistent chat history and memory are built in — the closest open-source answer to ChatGPT's memory feature.

For enterprise auth, Open WebUI supports LDAP, SSO and SCIM. For observability, OpenTelemetry is built in. The full feature list lives on the project README.

What it costs

The 2 vCPU / 4 GB / 40 GB Cube described here bills at about $0.0140/hour — roughly $0.34/day, or $10/month if left running. Usage is metered by the minute.

On top of that, either an AI provider bill (paid per message) or the local Ollama path. Ollama is free to run; the only cost is the larger Cube to fit the model weights in RAM. Open WebUI is fully MIT-licensed with no paid tier.

Cleaning up

Deleting the Cube removes Open WebUI, the SQLite database with every user account and chat history, and any local model weights along with the disk. If chat history matters, snapshot the Cube first.

Next steps

• Custom domains — required if you want the chat UI at your own address.
• Cubes — resizing, snapshots, and how billing works when a Cube is stopped.
• Self-host OpenClaw on a Cube — if you want the AI to live in your chat apps, not in a web UI.