Tableau-Lizenzen kosten Tausende Euro pro Jahr, Power BI setzt auf Microsoft-Ökosystem-Bindung – Apache Superset bietet beides kostenlos und selbst gehostet. Mit 73.000+ GitHub-Stars und 500 Millionen Docker-Hub-Pulls ist es die meistgenutzte Open-Source-Business-Intelligence-Plattform weltweit. Du bekommst einen No-Code-Chartbuilder mit über 30 Diagrammtypen, einen vollständigen SQL-Editor mit Query-History und interaktive Dashboards, die sich direkt mit mehr als 40 Datenquellen verbinden – von PostgreSQL und MySQL über BigQuery und Snowflake bis hin zu ClickHouse und Trino. In dieser Anleitung baust du Superset 6.1.0 per Docker Compose auf: produktionsnahe Konfiguration mit PostgreSQL als Metadaten-Datenbank, Redis als Cache und Message-Broker sowie Celery-Workern für asynchrone Abfragen – alles mit einer einzigen compose.yaml und einer .env-Datei.

Voraussetzungen

Docker Engine 24+ mit dem docker compose-Plugin (V2) – nicht das veraltete docker-compose V1. Falls noch nicht installiert: Docker und Docker Compose auf Linux installieren.
Linux-Host, VM oder NAS mit Docker-Unterstützung (Ubuntu, Debian, Synology mit Container Manager o. ä.). Multi-Platform: linux/amd64 und linux/arm64 (Apple Silicon, Raspberry Pi 5) werden beide unterstützt.
Mindestens 4 GB RAM für den Betrieb, 8 GB empfohlen für flüssige Performance. Mindestens 10 GB freier Festplattenspeicher (Image ca. 753 MB + PostgreSQL-Daten).
openssl auf dem Host zum Generieren des Secret Keys (auf nahezu allen Linux-Distributionen vorinstalliert).
Internetzugang für den initialen Image-Download.
Für HTTPS/TLS empfiehlt sich ein vorgeschalteter Reverse Proxy – z. B. mit Traefik als Docker-Reverse-Proxy oder Caddy mit automatischem HTTPS.

Eckdaten auf einen Blick

Parameter	Wert
Image (Superset)	`apache/superset:6.1.0` (stable, Mai 2025)
Image (Metadaten-DB)	`postgres:17`
Image (Cache/Broker)	`redis:7`
Web-Port	`8088` → `http://localhost:8088`
Interne Ports	PostgreSQL `5432`, Redis `6379` (nicht nach außen exponieren)
Volumes	`superset_home`, `db_home`, `redis`
RAM (Minimum / Empfehlung)	4 GB / 8 GB
Installationszeit	ca. 20 Minuten
Lizenz	Apache License 2.0 (kostenlos, Open Source)

Schritt 1: Projektordner anlegen

Lege einen dedizierten Ordner für Superset an. Alle Konfigurationsdateien landen hier:

mkdir -p /opt/superset
cd /opt/superset

Du kannst stattdessen auch ~/superset in deinem Home-Verzeichnis verwenden – die Struktur bleibt identisch.

Verifizieren: ls /opt/superset zeigt ein leeres Verzeichnis ohne Fehlermeldung.

Schritt 2: .env mit Secrets erstellen

Der SUPERSET_SECRET_KEY ist absolut kritisch: Ohne ihn startet Superset nicht und wirft einen ValueError: The SECRET_KEY must be a long random value. Generiere ihn sicher mit openssl:

# Zufälligen Secret Key generieren – Ausgabe kopieren
openssl rand -base64 42

# Sicheres Datenbankpasswort generieren
openssl rand -base64 24

Erstelle nun die .env-Datei im Projektordner mit den generierten Werten:

# -----------------------------------------------
# Apache Superset – Umgebungsvariablen
# NIEMALS in ein öffentliches Repository einchecken!
# -----------------------------------------------

# Pflicht: Zufälliger, langer Schlüssel für Flask-Sessions
# Generiert mit: openssl rand -base64 42
SUPERSET_SECRET_KEY=HIER_DEINEN_GENERIERTEN_KEY_EINTRAGEN

# PostgreSQL Metadaten-Datenbank
DATABASE_DB=superset
DATABASE_HOST=db
DATABASE_USER=superset
DATABASE_PASSWORD=HIER_SICHERES_DB_PASSWORT_EINTRAGEN
DATABASE_PORT=5432
DATABASE_DIALECT=postgresql

# PostgreSQL Container-Initialisierung (muss DATABASE_PASSWORD entsprechen)
POSTGRES_DB=superset
POSTGRES_USER=superset
POSTGRES_PASSWORD=HIER_SICHERES_DB_PASSWORT_EINTRAGEN

# Redis
REDIS_HOST=redis
REDIS_PORT=6379

# Superset-Betrieb
SUPERSET_ENV=production
SUPERSET_PORT=8088
SUPERSET_LOG_LEVEL=info
FLASK_DEBUG=false

# Admin-Benutzer (sofort nach erstem Login ändern!)
ADMIN_PASSWORD=HIER_SICHERES_ADMIN_PASSWORT_EINTRAGEN

# Optionen
SUPERSET_LOAD_EXAMPLES=no
MAPBOX_API_KEY=
SCARF_ANALYTICS=False

Setze restriktive Dateiberechtigungen, damit das Passwort nicht für alle Benutzer lesbar ist:

chmod 600 /opt/superset/.env

Verifizieren: ls -la /opt/superset/.env zeigt Berechtigung -rw-------. Wichtig: DATABASE_PASSWORD und POSTGRES_PASSWORD müssen identisch sein.

Schritt 3: compose.yaml erstellen

Die Architektur besteht aus sechs Diensten: PostgreSQL (Metadaten), Redis (Cache und Message-Broker), ein einmaliger Init-Container für DB-Migrationen und Admin-User-Anlage, der Superset-Webserver, ein Celery-Worker für asynchrone Abfragen sowie ein Celery-Beat-Scheduler für geplante Reports. Die depends_on-Bedingungen sorgen für die korrekte Startreihenfolge.

Warum Celery-Worker und Beat? Ohne den superset-worker laufen lang laufende SQL-Abfragen synchron im Web-Prozess – das führt bei großen Datensätzen zu Timeouts. Der superset-worker-beat ist für geplante Alert- und Dashboard-E-Mail-Reports zuständig; ohne ihn werden diese stillschweigend nicht versandt.

services:
  db:
    image: postgres:17
    container_name: superset_db
    restart: unless-stopped
    env_file:
      - .env
    environment:
      POSTGRES_DB: ${DATABASE_DB:-superset}
      POSTGRES_USER: ${DATABASE_USER:-superset}
      POSTGRES_PASSWORD: ${DATABASE_PASSWORD:?DATABASE_PASSWORD must be set}
    volumes:
      - db_home:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DATABASE_USER:-superset}"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7
    container_name: superset_cache
    restart: unless-stopped
    volumes:
      - redis:/data

  superset-init:
    image: apache/superset:6.1.0
    container_name: superset_init
    command: ["/bin/sh", "-c", "superset db upgrade && superset fab create-admin --username admin --firstname Admin --lastname User --email admin@superset.com --password ${ADMIN_PASSWORD:-admin} 2>/dev/null || true && superset init"]
    env_file:
      - .env
    environment:
      SUPERSET_SECRET_KEY: ${SUPERSET_SECRET_KEY:?SUPERSET_SECRET_KEY must be set}
      DATABASE_DIALECT: ${DATABASE_DIALECT:-postgresql}
      DATABASE_HOST: db
      DATABASE_PORT: ${DATABASE_PORT:-5432}
      DATABASE_DB: ${DATABASE_DB:-superset}
      DATABASE_USER: ${DATABASE_USER:-superset}
      DATABASE_PASSWORD: ${DATABASE_PASSWORD:?DATABASE_PASSWORD must be set}
      REDIS_HOST: redis
      REDIS_PORT: ${REDIS_PORT:-6379}
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    restart: "no"

  superset:
    image: apache/superset:6.1.0
    container_name: superset_app
    restart: unless-stopped
    ports:
      - "8088:8088"
    env_file:
      - .env
    environment:
      SUPERSET_SECRET_KEY: ${SUPERSET_SECRET_KEY:?SUPERSET_SECRET_KEY must be set}
      DATABASE_DIALECT: ${DATABASE_DIALECT:-postgresql}
      DATABASE_HOST: db
      DATABASE_PORT: ${DATABASE_PORT:-5432}
      DATABASE_DB: ${DATABASE_DB:-superset}
      DATABASE_USER: ${DATABASE_USER:-superset}
      DATABASE_PASSWORD: ${DATABASE_PASSWORD:?DATABASE_PASSWORD must be set}
      REDIS_HOST: redis
      REDIS_PORT: ${REDIS_PORT:-6379}
      SUPERSET_ENV: ${SUPERSET_ENV:-production}
      FLASK_DEBUG: "false"
      SUPERSET_LOG_LEVEL: ${SUPERSET_LOG_LEVEL:-info}
    volumes:
      - superset_home:/app/superset_home
    depends_on:
      superset-init:
        condition: service_completed_successfully
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:8088/health || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  superset-worker:
    image: apache/superset:6.1.0
    container_name: superset_worker
    restart: unless-stopped
    command: ["/bin/sh", "-c", "celery --app=superset.tasks.celery_app:app worker --loglevel=info"]
    env_file:
      - .env
    environment:
      SUPERSET_SECRET_KEY: ${SUPERSET_SECRET_KEY:?SUPERSET_SECRET_KEY must be set}
      DATABASE_DIALECT: ${DATABASE_DIALECT:-postgresql}
      DATABASE_HOST: db
      DATABASE_PORT: ${DATABASE_PORT:-5432}
      DATABASE_DB: ${DATABASE_DB:-superset}
      DATABASE_USER: ${DATABASE_USER:-superset}
      DATABASE_PASSWORD: ${DATABASE_PASSWORD:?DATABASE_PASSWORD must be set}
      REDIS_HOST: redis
      REDIS_PORT: ${REDIS_PORT:-6379}
    volumes:
      - superset_home:/app/superset_home
    depends_on:
      superset-init:
        condition: service_completed_successfully
    healthcheck:
      test: ["CMD-SHELL", "celery --app=superset.tasks.celery_app:app inspect ping -d celery@$$HOSTNAME"]
      interval: 30s
      timeout: 10s
      retries: 3

  superset-worker-beat:
    image: apache/superset:6.1.0
    container_name: superset_worker_beat
    restart: unless-stopped
    command: ["/bin/sh", "-c", "celery --app=superset.tasks.celery_app:app beat --loglevel=info"]
    env_file:
      - .env
    environment:
      SUPERSET_SECRET_KEY: ${SUPERSET_SECRET_KEY:?SUPERSET_SECRET_KEY must be set}
      DATABASE_DIALECT: ${DATABASE_DIALECT:-postgresql}
      DATABASE_HOST: db
      DATABASE_PORT: ${DATABASE_PORT:-5432}
      DATABASE_DB: ${DATABASE_DB:-superset}
      DATABASE_USER: ${DATABASE_USER:-superset}
      DATABASE_PASSWORD: ${DATABASE_PASSWORD:?DATABASE_PASSWORD must be set}
      REDIS_HOST: redis
      REDIS_PORT: ${REDIS_PORT:-6379}
    depends_on:
      superset-init:
        condition: service_completed_successfully

volumes:
  superset_home:
  db_home:
  redis:

Verifizieren: docker compose config im Projektordner prüft die Compose-Syntax und expandiert alle Variablen – keine Fehlerausgabe bedeutet: alles in Ordnung.

Schritt 4: Stack starten

Starte alle Dienste im Hintergrund. Docker lädt zunächst alle Images herunter (ca. 753 MB für Superset + PostgreSQL + Redis), was je nach Anbindung einige Minuten dauern kann:

cd /opt/superset
docker compose up -d

Der Init-Prozess braucht 2–3 Minuten: PostgreSQL muss erst bereit sein (Healthcheck), dann führt superset-init DB-Migrationen durch, legt den Admin-User an und initialisiert Rollen und Berechtigungen. Erst danach starten superset, superset-worker und superset-worker-beat.

Beobachte den Fortschritt live:

docker compose logs -f superset-init

Typische Erfolgsmeldungen im Init-Log:

INFO  [alembic.runtime.migration] Running upgrade ...
INFO  [superset.utils.core] Creating default roles and permissions
INFO  [flask_appbuilder.security.sqla.manager] Created 'Admin' user

Verifizieren:

docker compose ps

Erwartete Ausgabe nach vollständigem Start:

NAME                    IMAGE                      STATUS
superset_db             postgres:17                Up (healthy)
superset_cache          redis:7                    Up
superset_init           apache/superset:6.1.0      Exited (0)
superset_app            apache/superset:6.1.0      Up (healthy)
superset_worker         apache/superset:6.1.0      Up
superset_worker_beat    apache/superset:6.1.0      Up

Der superset_init-Container beendet sich mit Exit-Code 0 – das ist korrekt und gewollt. Zeigt superset_app noch „starting", warte weitere 60–90 Sekunden und führe docker compose ps erneut aus.

Schritt 5: Erste Schritte in der Web-UI

Öffne http://localhost:8088 im Browser (auf einem Remote-Server die IP oder den Hostnamen verwenden). Der Login-Screen erscheint:

Benutzername: admin
Passwort: Der Wert aus ADMIN_PASSWORD in deiner .env

Nach dem Login solltest du unmittelbar zwei Dinge tun:

Passwort ändern: Oben rechts auf den Benutzernamen → „Profile" → „Reset my password".
Datenbank verbinden: „Settings" → „Database Connections" → „+ Database". Wähle den Datenbanktyp (z. B. PostgreSQL), trage Host, Port, Datenbankname und Zugangsdaten ein.

Wichtiger Hinweis beim Verbinden lokaler Datenbanken: localhost als Hostname funktioniert in Superset nicht – er referenziert den Container selbst, nicht deinen Host. Verwende stattdessen host.docker.internal (Mac/Windows Docker Desktop) oder 172.18.0.1 (Linux, typische Docker-Bridge-IP).

Verifizieren:

curl -I http://localhost:8088/login

Erwartete Antwort: HTTP/1.1 200 OK. Im Browser erscheint die Superset-Login-Seite.

Schritt 6: Zusätzliche Datenbank-Treiber installieren

Für Standard-Datenbanken wie PostgreSQL und MySQL sind die nötigen Treiber im Superset-Image bereits enthalten. Für Cloud-Data-Warehouses und spezielle Engines wie BigQuery, Snowflake, ClickHouse oder Databricks muss der Python-Treiber nachinstalliert werden. Dazu erstellst du ein eigenes Dockerfile im Projektordner:

# Beispiel: Snowflake-Treiber hinzufügen
cat > /opt/superset/Dockerfile << 'EOF'
FROM apache/superset:6.1.0
USER root
RUN pip install --no-cache-dir snowflake-sqlalchemy
USER superset
EOF

Passe dann in der compose.yaml die Image-Einträge der betroffenen Dienste (superset, superset-worker, superset-worker-beat, superset-init) von image: apache/superset:6.1.0 auf build: . um. Anschließend neu bauen und starten:

docker compose build
docker compose up -d

Weitere verfügbare Extras: apache-superset[bigquery], apache-superset[clickhouse], apache-superset[trino].

Verifizieren: Öffne in Superset „Settings" → „Database Connections" → „+ Database". Der neu installierte Datenbanktyp (z. B. Snowflake) erscheint jetzt in der Auswahl.

Schritt 7: Updates und Backups

Alle Superset-Metadaten – Dashboards, Charts, Datenquellen-Verbindungen und Benutzer – liegen in PostgreSQL. Regelmäßige Backups sind daher essentiell. Ein einfaches Backup-Kommando:

# PostgreSQL-Backup erstellen
docker exec superset_db pg_dump -U superset superset > /opt/superset/backup_$(date +%Y%m%d_%H%M).sql

# Dateigröße prüfen (sollte > 0 sein)
ls -lh /opt/superset/backup_*.sql

Richte diesen Befehl als regulären Cron-Job ein – die Details dazu findest du in der Anleitung MySQL & PostgreSQL Backup automatisieren mit cron. Für eine robuste Offsite-Strategie eignet sich außerdem PostgreSQL pg_dump und pg_restore.

Update auf eine neue Superset-Version: Image-Tag in der compose.yaml anpassen, dann:

cd /opt/superset
# Zuerst Backup erstellen!
docker exec superset_db pg_dump -U superset superset > /opt/superset/backup_pre_update.sql
docker compose pull
docker compose up -d

Der superset-init-Container läuft beim Neustart erneut durch und führt automatisch superset db upgrade aus, falls neue Datenbank-Migrationen vorhanden sind.

Achtung: Niemals docker compose down -v verwenden – der -v-Flag löscht alle benannten Volumes inklusive db_home mit allen Dashboards und Konfigurationen. Nur docker compose down (ohne -v) zum Stoppen nutzen.

Verifizieren: Nach dem Update docker compose ps prüfen – alle Dienste zeigen Up. Im Browser unter „Settings" → „About" ist die neue Superset-Version sichtbar.

Troubleshooting / Typische Fehler

ValueError: The SECRET_KEY must be a long random value – SUPERSET_SECRET_KEY ist in der .env nicht gesetzt oder leer. Neuen Schlüssel mit openssl rand -base64 42 generieren und eintragen. Dann docker compose down && docker compose up -d.
superset_init beendet sich mit Exit-Code != 0 – Häufigste Ursache: Die PostgreSQL-Datenbank war noch nicht bereit oder DATABASE_PASSWORD und POSTGRES_PASSWORD stimmen nicht überein. Mit docker compose logs superset_init den genauen Fehler prüfen.
Seite unter http://localhost:8088 nicht erreichbar – Mit docker compose ps prüfen, ob superset_app den Status Up (healthy) hat. Der Start dauert bis zu 90 Sekunden. Port-Konflikt prüfen: ss -tlnp | grep 8088.
HTTPS statt HTTP schlägt fehl – Superset läuft intern auf HTTP. https://localhost:8088 gibt einen Verbindungsfehler. Für HTTPS einen Reverse Proxy (Traefik, Nginx, Caddy) vorschalten und ENABLE_PROXY_FIX=True in der Superset-Konfiguration setzen.
ModuleNotFoundError beim Verbinden einer Datenbank – Der Python-Treiber für diese Datenbank fehlt im Image (betrifft BigQuery, Snowflake, ClickHouse u. a.). Eigenes Dockerfile erstellen (siehe Schritt 6) und Stack neu bauen.
Asynchrone Abfragen hängen oder Alerts werden nicht versandt – Der superset-worker-Container läuft nicht. Mit docker compose ps und docker compose logs superset_worker prüfen.
„localhost" als Datenbankhost funktioniert nicht – Im Container-Kontext ist localhost der Container selbst. Für Host-Datenbanken host.docker.internal (Mac/Windows) oder 172.18.0.1 (Linux) verwenden.

Häufige Fragen

Welche Datenbanken kann Superset verbinden?

Superset unterstützt nativ über 40 Datenquellen via SQLAlchemy: PostgreSQL, MySQL, MariaDB, SQLite, Oracle, MS SQL Server, BigQuery, Snowflake, Redshift, Databricks, Trino, Presto, Hive, Spark SQL, ClickHouse, DuckDB und viele mehr. Für Standard-Datenbanken sind die Treiber bereits im Image enthalten. Für Cloud-Data-Warehouses muss der entsprechende Python-Treiber per eigenem Dockerfile nachinstalliert werden.

Ist Docker Compose für den Produktionseinsatz geeignet?

Apache selbst warnt ausdrücklich: Docker Compose ist offiziell nicht für High-Availability-Produktion unterstützt. Es gibt kein automatisches Failover, kein HA und kein integriertes Backup. Für echte Enterprise-Produktion mit Hochverfügbarkeit empfiehlt Apache den offiziellen Kubernetes-Helm-Chart. Für den internen KMU-Einsatz mit solider Backup-Strategie und Monitoring ist Compose jedoch praktikabel – und erspart teure Lizenzkosten.

Wie lade ich die Beispiel-Dashboards?

Setze in der .env vor dem ersten Start SUPERSET_LOAD_EXAMPLES=yes. Alternativ nachträglich per Terminal: docker exec -it superset_app superset load_examples. Der Ladevorgang dauert mehrere Minuten und benötigt eine aktive Internetverbindung.

Wie richte ich HTTPS ein?

Superset spricht intern HTTP. Für HTTPS einen Reverse Proxy vorschalten (Traefik, Nginx Proxy Manager, Caddy). In der Superset-Konfiguration muss außerdem ENABLE_PROXY_FIX=True gesetzt werden, damit Flask die X-Forwarded-Proto-Header korrekt verarbeitet. Port 8088 bleibt intern; der Reverse Proxy hört auf Port 443 nach außen.

Was bedeutet SCARF_ANALYTICS=False?

Das offizielle Superset-Image enthält Telemetrie-Tracking über Scarf.sh, das anonyme Nutzungsdaten an die Apache Foundation sendet. Mit SCARF_ANALYTICS=False in der .env deaktivierst du dieses Tracking – relevant für DSGVO-konforme Umgebungen in der DACH-Region.

Wie aktualisiere ich auf eine neue Superset-Version?

Image-Tag in der compose.yaml ändern, dann docker compose pull && docker compose up -d. Der Init-Container führt automatisch superset db upgrade aus. Vorher zwingend ein PostgreSQL-Backup erstellen.

Fazit

Apache Superset 6.1.0 per Docker Compose ist in etwa 20 Minuten installiert und bietet danach eine vollständige Business-Intelligence-Plattform ohne Lizenzkosten: No-Code-Chartbuilder, SQL-Editor, interaktive Dashboards und native Konnektoren für über 40 Datenquellen. Die Architektur mit PostgreSQL, Redis und Celery-Workern ist für asynchrone Abfragen und geplante Reports ausgelegt. Wer heute noch Tableau- oder Power-BI-Lizenzen bezahlt, sollte Superset ernsthaft als Alternative evaluieren.

Denk daran: Regelmäßige pg_dump-Backups sind Pflicht, da alle Dashboards und Verbindungen in PostgreSQL liegen. Für externe Zugriffe empfiehlt sich ein Reverse Proxy mit HTTPS. Für wirkliche Hochverfügbarkeit mit mehreren Knoten ist der Kubernetes-Helm-Chart der offizielle Weg. Wer weitere Self-Hosted-Datenbanktools sucht, findet im Batch-Geschwister Supabase mit Docker eine interessante Open-Source-Firebase-Alternative.

Weiterführende Anleitungen und Quellen

Offizielle Quellen: Apache Superset – Using Docker Compose (offizielle Dokumentation) | Apache Superset GitHub Repository | apache/superset auf Docker Hub