So hostest Du Psono selbst

Die Verwaltung von Passwörtern über einen Drittanbieter-Dienst ist nicht für jede Person oder Organisation die richtige Lösung, insbesondere wenn Datenschutz, Sicherheit und Kontrolle über die Infrastruktur oberste Priorität haben.

Durch das Self-hosting eines Passwortmanagers behältst Du die vollständige Kontrolle über Deine Zugangsdaten und kannst den Zugriff innerhalb Deiner eigenen Umgebung verwalten.

Bei meinem alten Unternehmen wollte ich zunächst die Kosten von 10 Euro pro Mitarbeiter und Monat für einen Passwortmanager nicht auf mich nehmen. Immerhin war ich selbst Hoster und hatte die kompetentesten Open-Source-Experten um mich herum. Nach Jahren mit Keepass, dessen Datenbank lokal auf dem Fileserver lag, war die Zeit für etwas Neues gekommen. Nach einiger Recherche sind wir auf Psono gestoßen. Meine Erkenntnisse daraus möchte ich hier gerne teilen.

Dieser Artikel erklärt, was Psono ist, warum es sich gut für den Eigenbetrieb eignet und was Du benötigst, bevor Du loslegst. Außerdem werden die Installation, häufige Probleme bei der Einrichtung und bewährte Vorgehensweisen für den sicheren Betrieb behandelt.

Was ist Psono und warum sollte man es selbst hosten?

Psono ist ein Open-Source-Passwortmanager, der Einzelpersonen und Organisationen dabei hilft, Passwörter, API-Schlüssel, Zertifikate und andere sensible Informationen sicher zu speichern, zu verwalten und zu teilen. Die Community Edition ist für self-hosted Bereitstellungen konzipiert, sodass Du die Plattform auf Deiner eigenen Infrastruktur betreiben kannst, anstatt auf einen Drittanbieter-Dienst angewiesen zu sein. Mit End-to-End-Verschlüsselung, sicherer Passwortfreigabe, Teamverwaltung und der Verwaltung vertraulicher Daten eignet sich Psono sowohl für den privaten als auch für den geschäftlichen Einsatz.

Durch das Self-hosting von Psono hast Du die volle Kontrolle über Deine Passwortverwaltungsumgebung, einschließlich Server, Datenbank, Backups und Sicherheitskonfiguration. Dieser Ansatz ist ideal für Organisationen mit strengen Sicherheits-, Datenschutz- oder Compliance-Anforderungen sowie für Nutzer, die mehr Flexibilität bei der Bereitstellung und Wartung ihres Passwortmanagers wünschen.

Psono unterstützt offiziell Docker-basierte Bereitstellungen, was die Installation und Verwaltung auf einem Linux-VPS vereinfacht. Bevor Du mit der Installation beginnst, stelle sicher, dass Dein Server die im nächsten Abschnitt beschriebenen Voraussetzungen erfüllt.

Voraussetzungen für das Self-hosting von Psono

Wenn Du diese Voraussetzungen im Voraus bereitstellst, läuft die Installation reibungsloser und die Wahrscheinlichkeit von Konfigurationsproblemen im weiteren Verlauf sinkt.

Bevor Du loslegst, benötigst Du Folgendes:

• Ein Linux-VPS mit Ubuntu und sudo-Rechten.
• Eine registrierte Domain oder Subdomain, die auf Deinen VPS verweist.
• Docker Engine und das Docker Compose-Plugin.
• PostgreSQL zum Speichern der Psono-Anwendungsdaten.
• Nginx, um Psono über einen Reverse-Proxy bereitzustellen.
• Ein vertrauenswürdiges SSL-Zertifikat, zum Beispiel eines von Let’s Encrypt.
• DNS-Zugriff, um Deine Domain-Einträge zu konfigurieren.
• Ein SMTP-Server für E-Mail-Benachrichtigungen und die Kontoaktivierung (empfohlen).

Sobald diese Voraussetzungen erfüllt sind, kannst Du Psono auf Deinem VPS bereitstellen, indem Du die folgende Schritt-für-Schritt-Anleitung befolgst.

Psono selbst hosten

Schritt 1: Verbinde Dich mit Deinem VPS

Stelle zunächst über SSH eine Verbindung zu Deinem VPS her.

ssh root@vps_ip

Sobald die Verbindung hergestellt ist, aktualisiere die Server-Pakete:

sudo apt update
sudo apt upgrade -y

Dadurch wird sichergestellt, dass der VPS auf dem neuesten Stand ist, bevor Du Docker, PostgreSQL, Nginx und Psono installierst.

Schritt 2: Richte Deine Domain auf den VPS aus

Psono benötigt eine echte Domain oder Subdomain mit HTTPS.

Erstelle bei Deinem DNS-Anbieter einen A-Eintrag, der Deine Psono-Domain auf die IP-Adresse des VPS verweist.

Beispiel:

psono.example.com → 213.160.77.169

Nachdem Du den DNS-Eintrag gespeichert hast, überprüfe vom VPS aus, ob die Auflösung korrekt funktioniert:

sudo apt install dnsutils -y
dig +short psono.example.com

Die Ausgabe sollte die öffentliche IP-Adresse Deines VPS anzeigen.

Fahre erst fort, wenn die Domain korrekt aufgelöst wird.

Schritt 3: Öffne die erforderlichen Firewall-Ports

Psono wird über Nginx per HTTP und HTTPS bereitgestellt, daher müssen die Ports 80 und 443 offen sein.

Wenn Dein VPS UFW verwendet, gib diese Ports frei:

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw reload

Schritt 4: Docker und Docker Compose installieren

Psono unterstützt offiziell die Docker-basierte Installation. Installiere Docker aus dem offiziellen Docker-Repository.

Installiere zunächst die erforderlichen Pakete:

sudo apt update
sudo apt install ca-certificates curl -y

Erstelle das Schlüsselring-Verzeichnis von Docker:

sudo install -m 0755 -d /etc/apt/keyrings

Lade den offiziellen GPG-Schlüssel von Docker herunter:

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

Stelle die richtigen Berechtigungen ein:

sudo chmod a+r /etc/apt/keyrings/docker.asc

Füge das offizielle Docker-Repository hinzu:

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Typen: deb
URIs: https://download.docker.com/linux/ubuntu
Suiten: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Komponenten: stable
Architekturen: $(dpkg --print-architecture)
Signiert von: /etc/apt/keyrings/docker.asc
EOF

Aktualisiere die Paketliste:

sudo apt update

Installiere die Docker Engine und das Docker Compose-Plugin:

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Schritt 5: Erstelle die Psono-Verzeichnisstruktur

Erstelle ein Arbeitsverzeichnis für die Psono-Installation:

sudo mkdir -p /opt/docker/psono
sudo mkdir -p /opt/docker/psono/postgres
sudo mkdir -p /opt/docker/psono/backups

Wechsle in das Psono-Verzeichnis:

cd /opt/docker/psono

In diesem Verzeichnis werden folgende Dateien gespeichert:

/opt/docker/psono/settings.yaml
/opt/docker/psono/config.json
/opt/docker/psono/docker-compose.yml
/opt/docker/psono/postgres
/opt/docker/psono/backups

Die PostgreSQL-Daten werden dauerhaft unter folgendem Pfad gespeichert:

/opt/docker/psono/postgres

Schritt 6: Psono-Server-Schlüssel generieren

Psono benötigt kryptografische Schlüssel, bevor der Server gestartet werden kann.

Führe den offiziellen Befehl zur Schlüsselgenerierung aus:

sudo docker run --rm -ti psono/psono-combo:latest python3 ./psono/manage.py generateserverkeys

Der Befehl gibt mehrere Werte aus, darunter:

SECRET_KEY
ACTIVATION_LINK_SECRET
DB_SECRET
EMAIL_SECRET_SALT
PRIVATE_KEY
ÖFFENTLICHER_SCHLÜSSEL

Speichere diese Werte vorübergehend an einem sicheren Ort. Du wirst sie im nächsten Schritt in die Psono-Konfigurationsdatei einfügen.

Veröffentliche diese Schlüssel nicht. Verwende keine Schlüssel aus einer anderen Installation erneut.

Schritt 7: Erstelle die Psono-Server-Konfigurationsdatei

Erstelle die Psono-Server-Konfigurationsdatei:

sudo nano /opt/docker/psono/settings.yaml

Füge die folgende Konfiguration ein.

Ersetze:

psono.example.com
example.com
dein-sicheres-Datenbank-Passwort
deine-generierten-geheimen-Werte
deine-SMTP-Werte

durch Deine tatsächlichen Werte.

SECRET_KEY: 'FÜGE_DEN_GENERIERTEN_GEHEIMSCHLÜSSEL_HIER_EIN'
ACTIVATION_LINK_SECRET: 'FÜGE_HIER_DEN_GENERIERTEN_AKTIVIERUNGSLINK-SCHLÜSSEL_EIN'
DB_SECRET: 'FÜGE_HIER_DEN_GENERIERTEN_DB_SECRET_EIN'
EMAIL_SECRET_SALT: 'FÜGE_HIER_DEN_GENERIERTEN_EMAIL_SECRET_SALT_EIN'
PRIVATE_KEY: 'FÜGE_DEN_GENERIERTEN_PRIVATEN_SCHLÜSSEL_HIER_EIN'
PUBLIC_KEY: 'FÜGE_HIER_DEN_GENERIERTEN_ÖFFENTLICHEN_SCHLÜSSEL_EIN'

WEB_CLIENT_URL: 'https://psono.example.com'

NUM_PROXIES: 1

FAVICON_SERVICE_URL: 'https://favicon.psono.com/v1/icon/'

DEBUG: False

ZULÄSSIGE_HOSTS: ['psono.example.com']

ZULÄSSIGE DOMAINS: ['example.com']

HOST_URL: 'https://psono.example.com/server'

EMAIL_FROM: 'psono@example.com'
EMAIL_HOST: 'smtp.example.com'
EMAIL_HOST_USER: 'smtp-username'
EMAIL_HOST_PASSWORD: 'smtp-password'
EMAIL_PORT: 587
EMAIL_SUBJECT_PREFIX: ''
EMAIL_USE_TLS: True
EMAIL_USE_SSL: Falsch
EMAIL_SSL_CERTFILE:
EMAIL_SSL_KEYFILE:
EMAIL_TIMEOUT: 10

MANAGEMENT_ENABLED: True

DATENBANKEN:
 Standard:
 'ENGINE': 'django.db.backends.postgresql_psycopg2'
 'NAME': 'psono'
 'USER': 'psono'
 'PASSWORD': 'dein-sicheres-Datenbank-Passwort'
 'HOST': 'psono-database'
 'PORT': '5432'

TEMPLATES: [
 {
 'BACKEND': 'django.template.backends.django.DjangoTemplates',
 'DIRS': ['/root/psono/templates'],
 'APP_DIRS': True,
 'OPTIONS': {
 'context_processors': [
 'django.template.context_processors.debug',
 'django.template.context_processors.request',
 'django.contrib.auth.context_processors.auth',
 'django.contrib.messages.context_processors.messages',
 ],
 },
 },
]

Speichere und schließe die Datei.

In Nano:

STRG + O

Enter

STRG + X

Wichtige Hinweise:

• WEB_CLIENT_URL ist die URL, die die Nutzer aufrufen werden.
• HOST_URL ist die URL des Backend-Servers.
• ALLOWED_DOMAINS legt fest, welche E-Mail-Domains sich registrieren oder anmelden dürfen.
• MANAGEMENT_ENABLED: Für das Admin-Portal ist „True“ erforderlich.
• HOST: „psono-database“ wird verwendet, da PostgreSQL als Docker-Compose-Dienst läuft.

Schritt 8: Erstelle die Konfigurationsdatei für den Psono-Webclient

Erstelle die Konfigurationsdatei für den Web-Client:

sudo nano /opt/docker/psono/config.json

Füge diese Konfiguration ein:

{

 "backend_servers": [

 {

 "title": "Psono",

 "url": "https://psono.example.com/server"

 }

 ],

 "base_url": "https://psono.example.com/",

 "allow_custom_server": false,

 "allow_registration": true,

 "allow_lost_password": true,

 "disable_download_bar": false,

 "remember_me_default": false,

 "trust_device_default": false,

 "authentication_methods": ["AUTHKEY"],

 "saml_provider": []

}

Speichere und schließe die Datei.

Diese Datei legt fest, welchen Backend-Server der Psono-Webclient verwenden soll.

Schritt 9: Erstelle die Docker-Compose-Datei

Erstelle die Docker-Compose-Datei:

sudo nano /opt/docker/psono/docker-compose.yml

Füge Folgendes ein:

services:
 psono-database:
  container_name: psono-database
  image: postgres:18-alpine
  Umgebung:
  POSTGRES_DB: psono
  POSTGRES_USER: psono
  POSTGRES_PASSWORD: dein-sicheres-Datenbank-Passwort
  Volumes:
  - /opt/docker/psono/postgres:/var/lib/postgresql
  Neustart: sofern nicht angehalten
  Zustandsprüfung:
  test: ["CMD-SHELL", "pg_isready -U psono -d psono"]
  Intervall: 10 s
  timeout: 5s
  Wiederholungen: 5

 psono-combo:
  Containername: psono-combo
  Image: psono/psono-combo:latest
  depends_on:
  psono-Datenbank:
  Bedingung: service_healthy
  Ports:
  - „127.0.0.1:10200:80“
  Volumes:
  - /opt/docker/psono/settings.yaml:/root/.psono\_server/settings.yaml:ro
  - /opt/docker/psono/config.json:/usr/share/nginx/html/config.json:ro
  - /opt/docker/psono/config.json:/usr/share/nginx/html/portal/config.json:ro
  sysctls:
  - net.core.somaxconn=65535
  Befehl: sh -c "sleep 10 && /bin/sh /root/configs/docker/cmd.sh"
  Neustart: sofern nicht angehalten

Ersetze:

dein-sicheres-Datenbank-Passwort

durch dasselbe Datenbankpasswort, das Du in der Datei „settings.yaml“ verwendet hast.

Speichere und schließe die Datei.

Diese Compose-Datei erstellt zwei Container:

• „psono-database“, auf dem PostgreSQL 18 läuft

• psono-combo, auf dem der Psono-Server, der Web-Client und das Admin-Portal laufen

Der Psono-Container ist an folgende Adresse gebunden:

127.0.0.1:10200

Das bedeutet, dass er nur lokal auf dem VPS erreichbar ist. Nginx leitet den öffentlichen HTTPS-Verkehr an ihn weiter.

Schritt 10: Starte die PostgreSQL-Datenbank

Starte zunächst nur die Datenbank:

cd /opt/docker/psono
sudo docker compose up -d psono-database

Überprüfe, ob die Datenbank läuft:

sudo docker compose ps

Du solltest sehen, dass „psono-database“ läuft und in gutem Zustand ist.

Schritt 11: Die Psono-Datenbank vorbereiten

Führe die Datenbank-Migrationen aus:

cd /opt/docker/psono
sudo docker compose run --rm
psono-combo python3 ./psono/manage.py migrate

Dadurch werden die erforderlichen Psono-Datenbanktabellen erstellt.

Falls die Migration fehlschlägt, überprüfe Folgendes:

sudo docker compose logs psono-database

Stelle außerdem sicher, dass das Datenbankpasswort in settings.yaml und docker-compose.yml identisch ist.

Schritt 12: Starte den Psono-Container

Starte Psono:

cd /opt/docker/psonosudo docker compose up -d psono-combo

Zu diesem Zeitpunkt läuft Psono lokal auf dem VPS unter:

http://127.0.0.1:10200

Es ist noch nicht öffentlich zugänglich. Der nächste Schritt ist die Konfiguration von Nginx und HTTPS.

Schritt 13: Nginx und Certbot installieren

Installiere Nginx und Certbot:

sudo apt update
sudo apt install nginx
certbot python3-certbot-nginx -y

Nginx aktivieren und starten:

sudo systemctl enable nginx
sudo systemctl start nginx

Nginx-Status prüfen:

sudo systemctl status nginx

Schritt 14: Erstelle die Nginx-Reverse-Proxy-Konfiguration

Erstelle eine neue Nginx-Konfigurationsdatei:

sudo nano /etc/nginx/sites-available/psono.example.com.conf

Füge zunächst diese vorläufige HTTP-Konfiguration ein:

server {

 listen 80;

 server_name psono.example.com;

 location / {

 proxy_set_header Host $host;

 proxy_set_header X-Real-IP $remote_addr;

 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

 proxy_set_header X-Forwarded-Proto $scheme;

 proxy_pass http://127.0.0.1:10200;

 proxy_read_timeout 90;

 }

}

Speichere und schließe die Datei.

Aktiviere die Website:

sudo ln -s /etc/nginx/sites-available/psono.example.com.conf /etc/nginx/sites-enabled/

Entferne die Standard-Nginx-Site, falls vorhanden:

sudo rm -f /etc/nginx/sites-enabled/default

Teste die Nginx-Konfiguration:

sudo nginx -t

Starte Nginx neu:

sudo systemctl restart nginx

Jetzt HTTP testen:

curl -I http://psono.example.com

Du solltest eine HTTP-Antwort von Nginx erhalten.

Schritt 15: Ein vertrauenswürdiges SSL-Zertifikat beantragen

Verwende Certbot, um ein Let’s Encrypt-Zertifikat anzufordern:

sudo certbot --nginx -d psono.example.com

Folge den Anweisungen.

Wenn Du gefragt wirst, ob HTTP auf HTTPS umgeleitet werden soll, wähle die Option „Umleiten“.

Nachdem Certbot fertig ist, teste die Verlängerung:

sudo certbot renew --dry-run

Wenn der Testlauf erfolgreich ist, sollte die automatische Zertifikatsverlängerung funktionieren.

Öffne nun:

https://psono.example.com

Du solltest nun die Psono-Weboberfläche sehen.

Schritt 16: Den ersten Psono-Benutzer anlegen

Wenn SMTP nicht konfiguriert ist, erstelle den ersten Benutzer über die Befehlszeile:

cd /opt/docker/psono
sudo docker compose run --rm psono-combo python3 ./psono/manage.py createuser username@example.com 'StrongUserPassword' email@example.com

Ersetze:

username@example.com
StrongUserPassword
email@example.com

durch Deine eigenen Werte.

Psono-Benutzernamen müssen dem Format einer E-Mail-Adresse entsprechen. Der Domain-Teil sollte mit einer der in ALLOWED_DOMAINS aufgeführten Domains übereinstimmen.

Beispiel:

sudo docker compose run --rm psono-combo python3 ./psono/manage.py createuser admin@example.com 'Use-A-Strong-Password' admin@example.com

Schritt 17: Den ersten Benutzer zum Admin befördern

Ernenne den ersten Benutzer zum Superuser:

cd /opt/docker/psonosudo docker compose run --rm psono-combo python3 ./psono/manage.py promoteuser admin@example.com superuser

Ersetze:

admin@example.com

durch den von Dir erstellten Benutzer.

Öffne nun das Admin-Portal:

https://psono.example.com/portal/

Melde Dich mit dem beförderten Admin-Konto an.

Nur der erste Admin muss über die Befehlszeile befördert werden. Danach können Admin-Aufgaben über das Admin-Portal erledigt werden.

Häufige Probleme bei der Psono-Installation und deren Behebung

Bad Gateway (Fehler 502)

Ein 502 Bad Gateway-Fehler bedeutet in der Regel, dass Nginx nicht mit dem Psono-Container kommunizieren kann. Überprüfe zunächst, ob die erforderlichen Container laufen:

sudo docker compose ps

Überprüfe anschließend, ob Psono auf Port 10200 lauscht:

sudo ss -tulpn | grep 10200

Wenn der Container nicht richtig läuft, starte ihn neu:

sudo docker compose up -d psono-combo

Der Health-Check gibt „Bad Request“ zurück

Wenn der Health Check eine „Bad Request“-Antwort zurückgibt, testest Du den Dienst wahrscheinlich über 127.0.0.1 statt über Deine konfigurierte Domain. Verwende Deine öffentliche Domain, wenn Du den Zustand des Servers überprüfst:

curl https://psono.example.com/server/healthcheck/

Probleme mit SSL-Zertifikaten

Wenn Certbot kein SSL-Zertifikat ausstellen kann, überprüfe, ob Deine Domain auf den richtigen VPS verweist und ob die Ports 80 und 443 erreichbar sind.

Überprüfe Deinen DNS-Eintrag:

dig +short psono.example.com

Überprüfe Deine Firewall-Konfiguration:

sudo ufw status

Teste anschließend Deine Nginx-Konfiguration auf Syntaxfehler:

sudo nginx -t

Fehler bei der Datenbankverbindung

Datenbankverbindungsfehler werden häufig durch ein falsches Datenbankpasswort oder eine ungültige Datenbank-Host-Konfiguration verursacht. Überprüfe, ob das PostgreSQL-Passwort sowohl in settings.yaml als auch in docker-compose.yml übereinstimmt.

Stelle außerdem sicher, dass der Datenbank-Host wie folgt konfiguriert ist:

HOST: 'psono-database'

SMTP-E-Mail funktioniert nicht

Wenn Registrierungs- oder Aktivierungs-E-Mails nicht zugestellt werden, überprüfe Deine SMTP-Einstellungen in der Datei „settings.yaml“, einschließlich Mailserver, Anmeldedaten, Port und Verschlüsselungseinstellungen.

Nachdem Du Deine Konfiguration aktualisiert hast, sende eine Test-E-Mail:

sudo docker compose run --rm psono-combo python3 ./psono/manage.py sendtestmail you@example.com

Wenn Du SMTP nicht konfigurieren möchtest, musst Du Benutzer manuell über die Befehlszeile anlegen.

Erweitere Deine self-hosted Umgebung

Psono ist nur eine von vielen Anwendungen, die Du selbst hosten kannst, um mehr Kontrolle über Deine Infrastruktur zu erlangen und die Abhängigkeit von Drittanbieterdiensten zu verringern. Wenn Du Deinen VPS um weitere self-hosted Tools für Dateiverwaltung, Content-Management, Dokumentation oder Geschäftsabläufe erweitern möchtest, schau Dir unsere entsprechenden Installationsanleitungen an:

• So hostest Du Padloc selbst
• So installierst Du ApplyPilot auf einem VPS
• So installierst Du X-Reader auf einem VPS
• So installierst Du Calibre-Web automatisiert
• So installierst Du Ralph Loop auf einem VPS
• So installierst Du Magento auf einem VPS
• So installierst Du HomeDock OS auf einem VPS

Jede Anleitung enthält Schritt-für-Schritt-Anweisungen, die Dir dabei helfen, eine weitere self-hosted Anwendung bereitzustellen und zu verwalten, sodass Du auf Deinem eigenen Server leichter eine sichere, flexible und vollständig verwaltete Umgebung aufbauen kannst.

Fazit

Durch das Self-hosting von Psono hast Du die vollständige Kontrolle über Deine Passwortverwaltungsumgebung und kannst sensible Zugangsdaten sicher auf Deiner eigenen Infrastruktur speichern und verwalten. Wenn Du die Schritte in dieser Anleitung befolgst, kannst Du die Psono Community Edition auf einem Linux-VPS mit Docker, PostgreSQL, Nginx und HTTPS bereitstellen. Aktualisiere Deine Installation nach der Installation regelmäßig, überwache Deine Container und erstelle zuverlässige Backups, damit Dein Psono-Server sicher, stabil und für den täglichen Einsatz bereit bleibt.

Artikel von

Oliver Dick

Hallo! Ich bin Oliver, einer der Gründer und Geschäftsführer von hosting.de. Seit dem Jahr 2000 arbeite ich als Hosting-Unternehmer.