Passbolt Community Edition ist der einzige vollständige Open-Source-Passwortmanager für Teams, der auf PGP-basierter Ende-zu-Ende-Verschlüsselung setzt: Der private Schlüssel des Nutzers verlässt nie den Browser — der Server sieht ausschließlich verschlüsselte Chiffretexte. Für KMU, DevOps-Teams und DSGVO-pflichtige Organisationen ist das ein entscheidender Unterschied gegenüber Cloud-Lösungen, bei denen der Betreiber theoretisch Zugriff auf entschlüsselte Passwörter hat. Mit Funktionen wie granularen Rollen (read-only, update, owner), vollständigem Audit-Log, MFA (TOTP, YubiKey, Duo), Browser-Extension für Chrome/Firefox/Edge/Brave und einer REST-API ist Passbolt eine ernst zu nehmende Enterprise-Alternative — kostenlos und selbst gehostet.

Voraussetzungen

Docker Engine >= 20.10 und Docker Compose v2 (Plugin oder Standalone) auf einem Linux-Host, einer VM oder einem NAS mit Docker-Unterstützung — siehe Docker und Docker Compose auf Linux installieren
Mindestens 1 GB RAM (empfohlen: 2 GB), 2 vCPUs, 10 GB freier Speicherplatz
Eigene Domain oder DNS-Eintrag für APP_FULL_BASE_URL — ohne passende URL verweigert die Browser-Extension die Verbindung
SMTP-Server oder SMTP-Relay (z. B. Brevo, SendGrid oder eigener Postfix) — ohne SMTP können keine Nutzer eingeladen werden
SSL-Zertifikat: Passbolt besteht auf HTTPS. Für Produktion empfiehlt sich ein Reverse Proxy (Traefik oder Nginx) mit Let's Encrypt; für Tests ist ein self-signed Zertifikat möglich
Passbolt Browser-Extension (Chrome, Firefox, Edge oder Brave) — ohne Extension ist kein Login möglich
openssl auf dem Host für die Generierung des Security-Salts

Eckdaten auf einen Blick

Eigenschaft	Wert
Image (App)	`passbolt/passbolt:5.13.0-1-ce` (oder `latest-ce`)
Image (DB)	`mariadb:10.11`
Ports	80 (HTTP→HTTPS-Redirect), 443 (HTTPS/UI/API)
Architektur	linux/amd64, linux/arm64
Volumes (Pflicht)	`database_volume`, `gpg_volume`, `jwt_volume`
Lizenz	AGPL v3, kostenlos (CE)
Einrichtungszeit	ca. 30 Minuten

Schritt 1: Projektordner und Verzeichnisstruktur anlegen

Erstelle einen dedizierten Ordner für den Passbolt-Stack. Alle weiteren Dateien kommen dort hinein:

mkdir -p /opt/passbolt
cd /opt/passbolt

Optional, wenn du ein eigenes SSL-Zertifikat einbinden möchtest:

mkdir -p /opt/passbolt/certs

Verifizieren: ls /opt/passbolt zeigt den leeren (oder nur certs/ enthaltenden) Ordner. Kein Fehler, kein Permission-Problem.

Schritt 2: .env-Datei mit Secrets anlegen

Alle sensiblen Werte kommen in eine .env-Datei, die niemals ins Git-Repository eingecheckt werden sollte. Besonders wichtig: Den SECURITY_SALT einmal zufällig generieren und danach nie mehr ändern — eine nachträgliche Änderung sperrt alle Nutzer sofort aus.

Generiere zunächst sichere Zufallswerte:

# Sicheres Datenbankpasswort (32 Bytes, Base64)
openssl rand -base64 32

# Security Salt für CakePHP (mindestens 32 Zeichen)
openssl rand -base64 32

Lege dann die .env-Datei an und trage die generierten Werte ein:

# /opt/passbolt/.env
# Datenbankpasswort (für MariaDB und Passbolt-App identisch!)
DB_PASSWORD=HIER_ZUFALLSPASSWORT_EINTRAGEN

# Vollständige URL inkl. https://, KEIN trailing slash
APP_FULL_BASE_URL=https://passbolt.example.com

# SMTP-Konfiguration (ohne SMTP können keine Nutzer eingeladen werden)
SMTP_HOST=smtp.example.com
SMTP_PORT=587
SMTP_USER=user@example.com
SMTP_PASSWORD=SMTP_PASSWORT_HIER
EMAIL_FROM=no-reply@example.com

# Security Salt — EINMAL setzen, NIE mehr ändern!
SECURITY_SALT=HIER_ZUFALLS_SALT_EINTRAGEN

Dateiberechtigungen einschränken, damit der Salt nicht im Klartext für andere Nutzer lesbar ist:

chmod 600 /opt/passbolt/.env

Verifizieren: ls -la /opt/passbolt/.env zeigt Rechte -rw-------. Die Datei enthält keine Leerzeilen vor Variablennamen und keine Anführungszeichen um Werte mit Sonderzeichen (Docker Compose liest die Werte direkt).

Schritt 3: compose.yaml erstellen

Lege die Compose-Datei in /opt/passbolt/compose.yaml an. Der Stack besteht aus exakt zwei Services: MariaDB als Datenbankbackend und der Passbolt-App. Das eingebaute wait-for.sh-Skript stellt sicher, dass Passbolt erst startet, wenn die Datenbank auf Port 3306 erreichbar ist. Für reproduzierbare Deployments wird ein fixer Versions-Tag statt latest-ce empfohlen:

services:
  db:
    image: mariadb:10.11
    restart: unless-stopped
    environment:
      MYSQL_RANDOM_ROOT_PASSWORD: "true"
      MYSQL_DATABASE: "passbolt"
      MYSQL_USER: "passbolt"
      MYSQL_PASSWORD: "${DB_PASSWORD}"
    volumes:
      - database_volume:/var/lib/mysql

  passbolt:
    image: passbolt/passbolt:5.13.0-1-ce
    # Rootless-Variante (erhöhte Sicherheit, Ports dann 8080/4433):
    # image: passbolt/passbolt:5.13.0-1-ce-non-root
    restart: unless-stopped
    depends_on:
      - db
    environment:
      APP_FULL_BASE_URL: "${APP_FULL_BASE_URL:-https://passbolt.local}"
      DATASOURCES_DEFAULT_HOST: "db"
      DATASOURCES_DEFAULT_USERNAME: "passbolt"
      DATASOURCES_DEFAULT_PASSWORD: "${DB_PASSWORD}"
      DATASOURCES_DEFAULT_DATABASE: "passbolt"
      EMAIL_TRANSPORT_DEFAULT_HOST: "${SMTP_HOST}"
      EMAIL_TRANSPORT_DEFAULT_PORT: "${SMTP_PORT:-587}"
      EMAIL_TRANSPORT_DEFAULT_USERNAME: "${SMTP_USER}"
      EMAIL_TRANSPORT_DEFAULT_PASSWORD: "${SMTP_PASSWORD}"
      EMAIL_TRANSPORT_DEFAULT_TLS: "true"
      EMAIL_DEFAULT_FROM: "${EMAIL_FROM}"
      EMAIL_DEFAULT_FROM_NAME: "Passbolt"
      SECURITY_SALT: "${SECURITY_SALT}"
      PASSBOLT_SSL_FORCE: "true"
      PASSBOLT_PLUGINS_SELF_REGISTRATION_ENABLED: "false"
      DEBUG: "false"
    volumes:
      - gpg_volume:/etc/passbolt/gpg
      - jwt_volume:/etc/passbolt/jwt
      # Eigenes SSL-Zertifikat (optional, sonst self-signed):
      # - ./certs/certificate.crt:/etc/passbolt/certs/certificate.crt:ro
      # - ./certs/certificate.key:/etc/passbolt/certs/certificate.key:ro
    command:
      [
        "/usr/bin/wait-for.sh",
        "-t",
        "0",
        "db:3306",
        "--",
        "/docker-entrypoint.sh",
      ]
    ports:
      - "80:80"
      - "443:443"
      # Für non-root-Image stattdessen:
      # - "80:8080"
      # - "443:4433"

volumes:
  database_volume:
  gpg_volume:
  jwt_volume:

Wichtig: SELF_REGISTRATION_ENABLED: "false" stellt sicher, dass sich niemand selbst registrieren kann — nur explizit eingeladene Nutzer erhalten Zugang. Das ist für geschlossene Teams und DSGVO-konforme Deployments der richtige Standardwert.

Verifizieren: docker compose -f /opt/passbolt/compose.yaml config darf keinen Syntaxfehler ausgeben und muss alle Umgebungsvariablen aus der .env-Datei korrekt interpolieren (d. h. keine ${VAR}-Platzhalter mehr in der Ausgabe, sondern echte Werte).

Schritt 4: Stack starten

Starte den Stack aus dem Projektordner heraus:

cd /opt/passbolt
docker compose up -d

Beim ersten Start passiert folgendes automatisch im Hintergrund: MariaDB initialisiert die Datenbank und den Nutzer, Passbolt wartet auf Port 3306, migriert danach das Datenbankschema und generiert den GPG-Serverschlüssel sowie die JWT-Keys. Das dauert typischerweise 60–90 Sekunden.

Verfolge den Startvorgang in Echtzeit:

docker compose logs -f passbolt

Den Log-Stream beendest du mit Strg+C. Warte, bis keine neuen Zeilen mehr erscheinen und kein ERROR sichtbar ist.

Verifizieren:

docker compose ps

Erwartete Ausgabe (beide Container Up, kein Restarting):

NAME                IMAGE                           STATUS
passbolt-db-1       mariadb:10.11                   Up X minutes
passbolt-passbolt-1 passbolt/passbolt:5.13.0-1-ce   Up X minutes

Zusätzlich den Health-Check-Endpunkt prüfen (self-signed Zertifikat mit -k übergehen):

curl -sk https://localhost/healthcheck/status.json

Erwartete Antwort: {"body":{"isHealthy":true}}

Schritt 5: Ersten Admin-Benutzer anlegen

Passbolt hat keinen Web-Installer — der erste Admin wird per CLI-Befehl im laufenden Container angelegt. Der Befehl muss zwingend als Nutzer www-data ausgeführt werden, sonst entstehen falsche Dateiberechtigungen in den GPG-Verzeichnissen:

docker compose exec passbolt su -m -c \
  'bin/cake passbolt register_user \
  -u admin@example.com \
  -f Vorname \
  -l Nachname \
  -r admin' \
  -s /bin/sh www-data

Ersetze admin@example.com, Vorname und Nachname durch echte Werte. Der Befehl gibt eine Einladungs-URL aus, zum Beispiel:

The user has been registered successfully.
To complete the setup, follow the link provided below.
https://passbolt.example.com/setup/install/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

Öffne diese URL im Browser — mit installierter Passbolt Browser-Extension. Der Setup-Wizard führt dich durch die Erstellung deines persönlichen PGP-Schlüsselpaars und die Sicherung des privaten Schlüssels. Ohne diesen Schritt ist kein Login möglich.

Die Browser-Extension installierst du direkt aus dem jeweiligen Extension-Store (Chrome Web Store, Firefox Add-ons, Microsoft Edge Add-ons).

Verifizieren: Nach Abschluss des Setup-Wizards kannst du dich unter https://passbolt.example.com mit der Browser-Extension anmelden. Das Admin-Dashboard zeigt dich als einzigen Nutzer mit der Rolle „Admin".

Schritt 6: SMTP testen und weitere Nutzer einladen

Bevor du Kollegen einlädst, prüfe ob der SMTP-Versand funktioniert — sonst erhalten Nutzer keine Aktivierungs-E-Mail und der Einladungsprozess schlägt still fehl:

docker compose exec passbolt su -m -c \
  'bin/cake passbolt send_test_email \
  --recipient=deine@email.de' \
  -s /bin/sh www-data

Weitere Nutzer lädst du über die Passbolt-Weboberfläche ein: Benutzer → Neuer Benutzer. Passbolt sendet eine Einladungs-E-Mail mit einem Setup-Link. Jeder neue Nutzer muss ebenfalls die Browser-Extension installieren und beim ersten Login sein eigenes PGP-Schlüsselpaar erzeugen.

Für die Teamorganisation nutzt du Gruppen: Passwörter können gezielt mit einzelnen Nutzern oder ganzen Gruppen geteilt werden, mit konfigurierbaren Rechten (can-read, can-update, is-owner).

Verifizieren: Der Test-E-Mail-Befehl gibt The email was sent successfully. aus. Im Posteingang der Empfänger-Adresse erscheint eine Test-E-Mail von Passbolt. Neue Nutzer erhalten nach der Einladung eine E-Mail mit Aktivierungslink.

Schritt 7: Vollständigen Healthcheck ausführen

Passbolt bietet einen integrierten Diagnosebefehl, der alle Systemkomponenten prüft — Datenbankverbindung, GPG-Konfiguration, SMTP, SSL und mehr:

docker compose exec passbolt su -m -c \
  'bin/cake passbolt healthcheck' \
  -s /bin/sh www-data

Ein gesunder Stack gibt für alle Prüfpunkte grüne Häkchen aus. Warnungen zu self-signed Zertifikaten sind im Testbetrieb akzeptabel, sollten in der Produktion aber durch ein gültiges Zertifikat behoben werden.

Verifizieren: Die Ausgabe zeigt keine Fail-Zeilen. Zeilen wie SSL peer certificate or SSH remote key was not OK sind bei self-signed Zertifikaten erwartet und nur eine Warnung, kein Fehler.

Schritt 8: Updates und Backups

Für Details zur allgemeinen Docker-Volume-Backup-Strategie und zum 3-2-1-Prinzip lies 3-2-1-Backup-Strategie umsetzen. Für Passbolt gilt darüber hinaus: Verlust von gpg_volume oder jwt_volume bedeutet vollständigen Datenverlust — alle verschlüsselten Passwörter sind ohne den GPG-Serverschlüssel unwiederbringlich verloren.

Datenbank sichern:

docker compose exec db mysqldump \
  -u passbolt -p"${DB_PASSWORD}" passbolt \
  > /opt/passbolt/backup_$(date +%Y%m%d).sql

GPG-Volume sichern:

docker run --rm \
  -v passbolt_gpg_volume:/data \
  -v /opt/passbolt:/backup \
  alpine tar czf /backup/gpg_backup_$(date +%Y%m%d).tar.gz /data

Update durchführen: Image-Tag in compose.yaml auf die neue Version setzen, dann:

cd /opt/passbolt
docker compose pull
docker compose up -d

Passbolt führt Datenbankmigrationen beim Start automatisch aus. Vor jedem Update Backup erstellen und niemals docker compose down -v in der Produktion ausführen — das -v-Flag löscht die Named Volumes unwiederbringlich.

Verifizieren: Nach dem Update docker compose ps und erneut curl -sk https://localhost/healthcheck/status.json ausführen. Das Admin-Dashboard zeigt die neue Versionsnummer unter Administration → Server Info.

Troubleshooting / Typische Fehler

„SQLSTATE[HY000] [1045] Access denied" in docker compose logs passbolt: Das Datenbankpasswort in MYSQL_PASSWORD (db-Service) stimmt nicht mit DATASOURCES_DEFAULT_PASSWORD (passbolt-Service) überein. Lösung: Beide Services teilen sich die ${DB_PASSWORD}-Variable aus der .env-Datei — Wert prüfen und docker compose up -d neu starten.
Container startet in Restart-Loop: Häufigste Ursache ist ein noch nicht bereiter Datenbankserver. In den Logs auf waiting for db:3306 achten. MariaDB benötigt nach dem TCP-Listen noch einige Sekunden für die Initialisierung. Normalerweise löst wait-for.sh das automatisch — wenn nicht, hilft ein manuelles docker compose restart passbolt nach 30 Sekunden.
Browser-Extension: „domain mismatch": APP_FULL_BASE_URL stimmt nicht exakt mit der URL im Browser überein. Die URL muss https:// enthalten, darf keinen abschließenden Schrägstrich haben und muss DNS-auflösbar sein. Für lokale Tests /etc/hosts anpassen: 127.0.0.1 passbolt.local.
SMTP-Test schlägt fehl / Nutzer erhalten keine E-Mail: SMTP_HOST, SMTP_PORT und Zugangsdaten prüfen. Für Port 587 muss EMAIL_TRANSPORT_DEFAULT_TLS=true gesetzt sein. Den Test-Befehl aus Schritt 6 nutzen um SMTP direkt zu debuggen.
register_user-Befehl schlägt mit Permission-Fehler fehl: Der Befehl wurde nicht als www-data ausgeführt. Immer die vollständige Syntax mit su -m -c '...' -s /bin/sh www-data verwenden — niemals direkt als root.
SECURITY_SALT nachträglich geändert: Invalidiert sofort alle Sessions, MFA-Tokens und Auth-Tokens. Nutzer werden ausgesperrt. Einzige Lösung: Salt auf den ursprünglichen Wert zurücksetzen (aus Backup der .env) und Stack neu starten.
self-signed Zertifikat: Browser-Extension gibt Warnung: Für den Produktivbetrieb einen Reverse Proxy mit Let's Encrypt vorschalten (z. B. Traefik oder Nginx Proxy Manager). Eigenes Zertifikat per Bind-Mount in ./certs/ einbinden und in compose.yaml die auskommentierten Volume-Zeilen aktivieren.

Häufige Fragen

Kann ich Passbolt hinter einem Reverse Proxy (Traefik/Nginx) betreiben?

Ja, das ist sogar der empfohlene Weg für die Produktion. Traefik oder Nginx als SSL-Terminator vorschalten, Port 80 und 443 weiterleiten und zusätzlich PASSBOLT_SECURITY_PROXIES_ACTIVE=true in der Umgebung setzen. APP_FULL_BASE_URL muss die öffentliche HTTPS-URL des Reverse Proxy sein. Wie du Traefik als Docker-Reverse-Proxy einrichtest, erklärt die gleichnamige Anleitung.

Was ist der Unterschied zwischen CE und Pro?

Die Community Edition ist vollständig kostenlos, Open Source (AGPL v3) und enthält alle Kernfunktionen: unbegrenzte Nutzer, unbegrenzte Gruppen, vollständiges Audit-Log, MFA, Browser-Extension, REST-API und Import/Export. Die Pro-Edition ergänzt Active-Directory-Synchronisation, erweiterten Support mit SLA und einige administrative Komfort-Features. Für die meisten KMU ist die CE vollständig ausreichend.

Wie sichere ich meine Passbolt-Instanz gegen unbefugten Zugriff ab?

PASSBOLT_PLUGINS_SELF_REGISTRATION_ENABLED=false ist bereits in der Compose-Vorlage gesetzt — nur explizit eingeladene Nutzer können ein Konto erstellen. Zusätzlich empfiehlt sich MFA für alle Nutzer (PASSBOLT_PLUGINS_MFA_PROVIDERS_TOTP=true), ein gehärteter Linux-Host und das Absichern des Docker-Compose-Setups — dazu bietet sich die Anleitung Docker Compose absichern: Secrets, Healthchecks, Non-Root als Ergänzung an.

Welche Architekturen werden unterstützt?

Das offizielle Image ist Multi-Arch und unterstützt linux/amd64 (Standard-Server, VMs) und linux/arm64 (Raspberry Pi 4/5, Apple-M-Chips). ARMv7 (32-Bit) wird nicht offiziell unterstützt.

Wie kann ich Docker Secrets statt Klartext-Passwörter in der .env nutzen?

Alle Passwortvariablen unterstützen ein _FILE-Suffix. Statt DATASOURCES_DEFAULT_PASSWORD=geheim kannst du DATASOURCES_DEFAULT_PASSWORD_FILE=/run/secrets/db_password setzen und das Secret als Docker-Secret-Volume einbinden. Das ist besonders in Umgebungen mit Docker Swarm oder strengeren Compliance-Anforderungen sinnvoll.

Wie lese ich Logs bei Problemen?

Für Anwendungsfehler: docker compose logs passbolt. Für Datenbankprobleme: docker compose logs db. Den integrierten Healthcheck für eine vollständige Systemdiagnose nutzen: docker compose exec passbolt su -m -c 'bin/cake passbolt healthcheck' -s /bin/sh www-data.

Fazit

Passbolt CE ist die überzeugendste Open-Source-Lösung für Teams, die einen Passwortmanager mit echter Ende-zu-Ende-Verschlüsselung selbst hosten wollen. Die PGP-Architektur ist technisch durchdacht: Der Server kann physisch keinen Zugriff auf die Klartextpasswörter erlangen, selbst wenn er kompromittiert wird. Der Docker-Stack ist mit zwei Services überschaubar, die Konfiguration über die .env-Datei klar strukturiert und die Three-Volume-Strategie für Persistenz zuverlässig — solange man die Volumes nie leichtfertig löscht und regelmäßig sichert.

Der wichtigste Einrichtungsschritt, den viele unterschätzen, ist SMTP: Ohne funktionierenden E-Mail-Versand ist der Admin zwar arbeitsfähig, aber kein einziger Kollege kann eingeladen werden. Plane das vor dem ersten docker compose up ein. Wer die Browser-Extension-Pflicht als Einstiegshürde kommuniziert und einen soliden Backup-Prozess für die drei Named Volumes etabliert, betreibt damit einen DSGVO-konformen Unternehmens-Passwort-Safe auf eigener Infrastruktur — ohne monatliche Lizenzkosten und ohne Cloud-Abhängigkeit.

Weiterführende Anleitungen und Quellen

Offizielle Quellen: Passbolt — Install on Docker (offizielle Dokumentation) | passbolt/passbolt_docker auf GitHub | Passbolt Environment Variables Reference | passbolt/passbolt auf Docker Hub