Workload · Running Superset dashboards

Apache Superset, Self Hosted on a Server You Control

Self-hosting Apache Superset means running four things together: the Superset web app, a PostgreSQL or MySQL database for its own metadata, a Redis cache, and Celery workers for reports and async queries, with a strong SECRET_KEY set before the first start. Skip one and you find out the day a dashboard vanishes or a saved database password stops decrypting.

The short version
  1. Four parts: the app, a PostgreSQL or MySQL metadata database, Redis, Celery workers
  2. Set a strong SECRET_KEY before the first start, and keep a copy somewhere safe
  3. Docker Compose is for trying it; the project does not support it for production
  4. Connect your data through a read-only database user, never an admin login
  5. A whole machine with root, an unmetered port and month-to-month terms

What a Superset install is made of

A working Superset is one application plus three helpers. When someone opens a chart, Superset sends a SQL query to the database that holds the data, then draws the result. The heavy lifting happens in that database, not in Superset.

PieceWhat it doesCan you skip it?
Superset app (Flask behind Gunicorn)Serves the web interface and the API, sends queries to your dataNo
Metadata databaseKeeps every chart, dashboard, user, saved connection and logNo. PostgreSQL 10 to 16 or MySQL 5.7 and 8 are the tested engines
Cache (Redis, usually)Holds query results and filter state; acts as the message broker for workersPartly. Filter and explore state fall back to the metadata database
Celery worker and beatRun async queries, alert and report snapshots, thumbnailsYes, if you need none of those features

The project publishes no memory or core figures for production, so size by where your data lives: if Superset reads a warehouse elsewhere, the box mostly runs a web app, a small PostgreSQL and Redis; if the charted database sits on the same server, size for that database first.

Choose the install route before the server

The docs describe three routes and are frank about each.

  • Docker Compose starts everything in one go, with admin / admin as the login. The project says it does not support or recommend its Compose files for production: they target a single host, cannot do high availability, and keep the metadata in a Docker volume that nothing backs up.
  • Kubernetes is what the docs call best practice. The 6.1.0 docs use the Helm chart, with minikube for a single host; newer docs deprecate the chart in favour of the official Superset Kubernetes Operator. The chart ships a default secret key and a default PostgreSQL password, and both must be replaced.
  • PyPI installs Superset as a Python package. It needs no container knowledge but leaves you to wire up PostgreSQL, Redis and the workers yourself. This page walks through it, because on one dedicated server it is the most transparent route.

Compose publishes port 8088 on every interface with the admin / admin login and a test secret key, and Docker's docs say published ports bypass host firewall rules such as ufw. Before starting a trial, change the mapping to 127.0.0.1:8088:8088, reach it through an SSH tunnel, and take it down afterwards.

Why a whole machine suits a BI server

Superset, its metadata database, Redis and the workers all want to live close together, and a dedicated server gives you one physical computer that runs your work and nobody else's. Every core, all the memory and all the disks are yours.

  • Root access for the drivers, Redis and the headless browser reports need.
  • An unmetered port, with no transfer allowance to watch when results move.
  • A console you open yourself on rack servers, blades and the m510 and m710x cartridges, for the day a firewall rule locks SSH out.
  • Reinstalls from the control panel, as often as you like.
  • Month-to-month terms, no contract.

The server that fits

Match the class to where your data sits. A single-processor everyday server is what most apps and databases actually need, and it suits Superset reading a warehouse elsewhere. When the charted database lives on the same box, a two-processor server keeps a busy database and the dashboards from fighting; our database server builds are made for a database like that. Fast disks shorten queries on local data, so look at the NVMe dedicated servers too.

Memory, disks and port speed can be added to the machine you already have later, with no migration and no new IP address. For a short trial with a handful of users, a Cloud VPS is sold for jobs too small to need a server of their own; it shares its host with other customers.

Up and running in an evening: the PyPI route

These steps assume Ubuntu. Release 6.1.0 on PyPI lists Python 3.10 to 3.12 as supported (the 6.1.0 install page still says to add 3.11 on Ubuntu 24.04), so check the release you install. Stop at any step that fails.

  1. Install the build packages the docs list, sudo apt-get install build-essential libssl-dev libffi-dev python3-dev python3-pip libsasl2-dev libldap2-dev default-libmysqlclient-dev, plus python3-venv, postgresql and redis-server.
  2. Create a service account: sudo useradd --system --create-home --home-dir /opt/superset --shell /usr/sbin/nologin superset.
  3. Create the metadata role and database. sudo -u postgres createuser --pwprompt superset asks for the password instead of taking it on the command line; then sudo -u postgres createdb -O superset superset.
  4. Work as the new account with sudo -u superset bash and create the secrets file once: test -e /opt/superset/superset.env || (umask 077; printf 'SUPERSET_SECRET_KEY=%s\n' "$(openssl rand -base64 42)" > /opt/superset/superset.env). The guard stops a second run from replacing the key.
  5. Add two lines to that file with an editor: SUPERSET_CONFIG_PATH=/opt/superset/superset_config.py and SUPERSET_DB_URI=postgresql://superset:YOUR_DB_PASSWORD@localhost/superset. Copy the key into your password manager too.
  6. Save the configuration below as /opt/superset/superset_config.py, then run the install block.
import os
from datetime import timedelta

SECRET_KEY = os.environ['SUPERSET_SECRET_KEY']
SQLALCHEMY_DATABASE_URI = os.environ['SUPERSET_DB_URI']

REDIS = 'redis://localhost:6379/0'
FILTER_STATE_CACHE_CONFIG = {
    'CACHE_TYPE': 'RedisCache',
    'CACHE_DEFAULT_TIMEOUT': 86400,
    'CACHE_KEY_PREFIX': 'superset_filter_cache',
    'CACHE_REDIS_URL': REDIS,
}
EXPLORE_FORM_DATA_CACHE_CONFIG = {**FILTER_STATE_CACHE_CONFIG,
    'CACHE_KEY_PREFIX': 'superset_explore_cache'}
DATA_CACHE_CONFIG = {**FILTER_STATE_CACHE_CONFIG,
    'CACHE_KEY_PREFIX': 'superset_data_cache'}

ENABLE_PROXY_FIX = True
TALISMAN_ENABLED = True
PERMANENT_SESSION_LIFETIME = timedelta(hours=8)
SESSION_COOKIE_SECURE = True
SESSION_COOKIE_HTTPONLY = True
SESSION_COOKIE_SAMESITE = 'Lax'
set -a; . /opt/superset/superset.env; set +a
python3 -m venv /opt/superset/venv
/opt/superset/venv/bin/pip install "apache_superset[postgres,gevent]"
/opt/superset/venv/bin/superset db upgrade
/opt/superset/venv/bin/superset fab create-admin
/opt/superset/venv/bin/superset init

Because the config reads the key and database address from the environment, a missing secrets file stops Superset instead of falling back to SQLite. fab create-admin prompts for the password; pick a username other than admin.

The development server (superset run) is not for production; run Gunicorn under systemd with EnvironmentFile=/opt/superset/superset.env, User=superset and the docs' production arguments, binding to loopback instead of the docs' all-interfaces example: /opt/superset/venv/bin/gunicorn -w 10 -k gevent --worker-connections 1000 --timeout 120 -b 127.0.0.1:8088 --limit-request-line 0 --limit-request-field_size 0 "superset.app:create_app()". Start it with systemctl enable --now superset; plain enable waits for the next reboot. curl http://127.0.0.1:8088/health should answer OK.

Put a reverse proxy such as nginx in front on port 443 with TLS 1.2 or newer and HSTS, which is why the config sets ENABLE_PROXY_FIX. If you turn on a host firewall, allow SSH before enabling it, open only 22, 80 and 443, and make sure the rules cover IPv6 as well.

Connecting your databases without handing over the keys

Give Superset its own database user with SELECT on the schemas it needs and nothing else: no insert, update, delete or admin rights. The project says plainly that Superset is not a database firewall: DISALLOWED_SQL_FUNCTIONS is a second layer, your database's permissions the first.

  • Keep the data database listening on loopback, or allow only the Superset server's address in its access rules.
  • Connection passwords you save in Superset are encrypted with the SECRET_KEY. Change the key carelessly and they stop decrypting.
  • Leave self-registration (AUTH_USER_REGISTRATION) off unless you sign people in through OAuth or LDAP, and never make Admin the registration role.
  • Give each person the narrowest role that does their job, and add row-level security where one team must not see another's rows.

Keeping it healthy: backups, upgrades, the key

  • Back up the metadata database on a schedule and copy it off the server; every chart and dashboard lives there.
  • Upgrade on a staging copy first. Take a fresh backup, then pip install apache_superset --upgrade in the venv, superset db upgrade and superset init, and restart the service. Read UPDATING.md for breaking changes between major versions.
  • Rotate the key properly. Put the current key in PREVIOUS_SECRET_KEY, the new one in SECRET_KEY, then run superset re-encrypt-secrets. Every user is signed out. Do it after any suspected leak and when someone with the key leaves.
  • Watch it. Point an uptime check at /health; alert on repeated failed logins and role changes.

When one server is the wrong answer

One machine is one point of failure. If dashboards must survive a hardware fault with no gap, the docs point to Kubernetes, which can scale and roll updates without downtime; you can run the Helm chart across several machines on Kubernetes you run yourself. And if nobody on your team will patch Superset, rotate keys and test backups, think twice: you manage the server, and we keep the hardware and the network running.

Questions people ask

What breaks if the SECRET_KEY changes?
It signs session cookies and encrypts saved database passwords, so swapping it carelessly leaves those passwords undecryptable. The safe way is to set the old key as PREVIOUS_SECRET_KEY, the new one as SECRET_KEY, and run superset re-encrypt-secrets.
Can the metadata stay in SQLite?
SQLite is the default for a PyPI install, and the docs discourage it for production on security, scale and data-integrity grounds. Use PostgreSQL 10 to 16 or MySQL 5.7 or 8, and back it up regularly.
Do I really need Redis?
Superset needs a cache for dashboard filter state and chart editing state; without one it falls back to storing them in the metadata database. Redis is the recommended backend and also carries messages for Celery, which alerts, reports and async queries depend on. Once configured, Superset fails rather than degrades if the cache goes away.
How much memory does a Superset server need?
The project publishes no production figure. Superset hands each query to your database, so size for that database if it shares the box, and add memory later without moving.

Get a server for your Superset dashboards

A whole machine with root, an unmetered port and no contract, handed over within 30 minutes of approval.

Choose your server

Read next