DocuSeal auf einem Hetzner Ubuntu Server selbst hosten

Du möchtest Dokumente mit DocuSeal signieren, aber lieber die volle Kontrolle über deine Infrastruktur behalten? Indem du DocuSeal auf einem Linux Ubuntu Server selbst hostest, kannst du Kosten senken, deine sensiblen Dokumente privat halten und Gebühren pro Unterschrift vermeiden!

Du suchst etwas Einfacheres? Wenn du lieber auf Server-Management verzichten und DocuSeal in nur 25 Sekunden für 9€/Monat deployen möchtest, schau dir unsere Anleitung zum einfachen Selbst-Hosten von DocuSeal mit Sliplane an.

Folge dieser leicht verständlichen Anleitung, um zu lernen, wie du deine eigene DocuSeal-Instanz mit Docker und dem Caddy Webserver für automatisches HTTPS deployen kannst.

Bevor wir starten, stelle sicher, dass du hast:

• Ein Hetzner Konto (oder ein anderer Cloud-Anbieter)
• Grundlegende SSH-Erfahrung
• Ein SSH-Schlüsselpaar auf deinem lokalen Rechner

Schritt 0: Server bei Hetzner erstellen

Zuerst müssen wir einen Ubuntu Server erstellen. Melde dich bei deiner Hetzner Cloud Console an und klicke auf den Create Resource Button oben rechts.

Klicke auf "Create Resource" um deinen Server zu erstellen

Server-Typ auswählen

Wähle Shared Resources und dann Cost-Optimized. Für DocuSeal ist der CX23 Server (2 vCPU, 4GB RAM, 40GB SSD) eine gute Wahl für nur 2,99€/Monat.

Wähle Cost-Optimized und den CX23 Server-Typ

Standort und Betriebssystem auswählen

Wähle einen Standort in der Nähe deiner Nutzer (z.B. Nürnberg für die EU) und wähle Ubuntu 24.04 als Betriebssystem.

Wähle deinen bevorzugten Standort und Ubuntu 24.04

SSH-Schlüssel hinzufügen

Du musst deinen öffentlichen SSH-Schlüssel hinzufügen, um auf den Server zugreifen zu können. Auf deinem lokalen Rechner kopierst du deinen öffentlichen Schlüssel in die Zwischenablage:

# Auf macOS
pbcopy < ~/.ssh/id_ed25519.pub

# Auf Linux
cat ~/.ssh/id_ed25519.pub
# Dann kopiere die Ausgabe

Kopiere deinen öffentlichen SSH-Schlüssel aus dem Terminal

In der Hetzner Console klicke auf Add SSH Key und füge deinen öffentlichen Schlüssel ein. Gib ihm einen erkennbaren Namen.

Füge deinen SSH-Schlüssel ein und gib ihm einen Namen

Server erstellen

Gib deinem Server einen Namen und klicke auf Create & Buy now.

Benenne deinen Server und klicke auf Create & Buy now

Server-IP abrufen

Nach der Erstellung siehst du die IP-Adresse deines Servers in der Übersicht. Kopiere diese IP - du brauchst sie für die SSH-Verbindung.

Kopiere die IP-Adresse deines Servers

Per SSH verbinden

Verbinde dich nun per SSH mit deinem Server:

ssh root@DEINE_SERVER_IP

Erfolgreich mit deinem Ubuntu Server verbunden

Schritt 1: Server aktualisieren

Nach dem Login aktualisiere das System, um die neuesten Sicherheitspatches und Updates zu erhalten.

sudo apt-get update
sudo apt-get upgrade -y

Server-Update abgeschlossen

Sobald das erledigt ist, ist dein Server bereit für die Software-Installation.

Schritt 2: UFW Firewall installieren und konfigurieren

Halte nur die notwendigen Ports offen: SSH (22), HTTP (80), HTTPS (443).

Installiere UFW und konfiguriere die Firewall wie folgt:

sudo apt install ufw -y
sudo ufw allow 22    # SSH
sudo ufw allow 80    # HTTP
sudo ufw allow 443   # HTTPS
sudo ufw enable

Überprüfe deine Firewall-Konfiguration:

sudo ufw status verbose

Firewall ist aktiv mit offenen Ports 22, 80 und 443

Hinweis: Docker kann manchmal UFW-Regeln ignorieren. Um das zu beheben, überprüfe zusätzliche Einstellungen wie hier erklärt.

Schritt 3: Docker Installation

Docker wird das Container-System sein, das DocuSeal ausführt. Installiere Docker mit diesen Befehlen:

Richte Abhängigkeiten und Dockers GPG-Schlüssel ein:

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
| sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Füge das Docker Repository hinzu:

echo \
  "deb [arch=$(dpkg --print-architecture) \
signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo $VERSION_CODENAME) stable" \
| sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Installiere Docker Engine und das Compose-Plugin:

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

Überprüfe die Installation:

sudo docker run hello-world

Docker ist installiert und funktioniert korrekt

Wenn du die "Hello from Docker!" Nachricht siehst, ist Docker bereit.

Schritt 4: Caddy für automatisches HTTPS installieren

Caddy vereinfacht die HTTPS-Konfiguration, da es SSL-Zertifikate automatisch von Let's Encrypt bezieht.

Wichtig: Bevor du Caddy mit deiner Domain konfigurierst, stelle sicher, dass du den A-Record (für IPv4) und den AAAA-Record (für IPv6) deiner Domain auf die IP-Adressen deines Servers zeigen lässt. Ohne korrekte DNS-Konfiguration kann Caddy keine SSL-Zertifikate ausstellen.

Installiere Caddy:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
| sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
| sudo tee /etc/apt/sources.list.d/caddy-stable.list

sudo apt update
sudo apt install caddy -y

Bearbeite die Caddyfile-Konfigurationsdatei:

sudo nano /etc/caddy/Caddyfile

Ersetze den Inhalt mit deinem Domainnamen für automatisches HTTPS:

deinedomain.com {
    reverse_proxy localhost:3000
}

Speichere die Datei (Strg+O, Enter, Strg+X) und starte Caddy neu:

sudo systemctl restart caddy

Schritt 5: DocuSeal mit Docker Compose starten

Wir werden Docker Compose für eine einfachere Einrichtung verwenden. Erstelle zuerst ein Verzeichnis für DocuSeal und navigiere dorthin:

mkdir ~/docuseal
cd ~/docuseal

Erstelle compose.yml:

nano compose.yml

Füge folgenden Inhalt hinzu:

services:
  docuseal:
    image: docuseal/docuseal:2.2.9
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - docuseal_data:/data

volumes:
  docuseal_data:

compose.yml für DocuSeal

Speichere die Datei und deploye DocuSeal:

sudo docker compose up -d

Docker lädt das DocuSeal-Image herunter und startet es im Hintergrund auf Port 3000.

Schritt 6: Auf deine selbst gehostete DocuSeal-Instanz zugreifen

Besuche die IP-Adresse deines Servers (oder Domain) in einem beliebigen Webbrowser. Deine DocuSeal-Instanz sollte nun erfolgreich laden. Folge den Einrichtungsschritten in der Oberfläche, um dein Admin-Konto zu erstellen.

DocuSeal Ersteinrichtung - Erstelle dein Admin-Konto

Nach Abschluss der Einrichtung wirst du zur Dokumentenvorlagen-Seite weitergeleitet, wo du mit dem Erstellen und Verwalten deiner Dokumente beginnen kannst!

DocuSeal ist einsatzbereit! Beginne mit dem Hochladen von Dokumenten

🎉 Herzlichen Glückwunsch! Du hast jetzt deine eigene selbst gehostete DocuSeal-Instanz auf Ubuntu!

PostgreSQL statt SQLite verwenden (Optional)

Standardmäßig verwendet DocuSeal SQLite, was perfekt für kleine bis mittlere Deployments ist. Für Produktionsumgebungen oder größere Nutzung kannst du DocuSeal so konfigurieren, dass es PostgreSQL verwendet.

Aktualisiere zuerst deine compose.yml, um PostgreSQL einzubinden:

services:
  docuseal:
    image: docuseal/docuseal:2.2.9
    restart: always
    depends_on:
      - postgres
    ports:
      - "3000:3000"
    volumes:
      - docuseal_data:/data
    environment:
      - DATABASE_URL=postgres://docuseal:dein_sicheres_passwort@postgres:5432/docuseal

  postgres:
    image: postgres:16
    restart: always
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=docuseal
      - POSTGRES_PASSWORD=dein_sicheres_passwort
      - POSTGRES_DB=docuseal

volumes:
  docuseal_data:
  postgres_data:

Stelle sicher, dass du dein_sicheres_passwort durch ein starkes Passwort ersetzt.

Dann starte die Services neu:

sudo docker compose down
sudo docker compose up -d

E-Mail-Benachrichtigungen konfigurieren (Optional)

DocuSeal kann E-Mail-Benachrichtigungen für Dokumenten-Signatur-Events senden. Füge SMTP-Einstellungen zu deiner compose.yml hinzu:

services:
  docuseal:
    image: docuseal/docuseal:2.2.9
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - docuseal_data:/data
    environment:
      - SMTP_ADDRESS=smtp.beispiel.com
      - SMTP_PORT=587
      - SMTP_USERNAME=deine-email@beispiel.com
      - SMTP_PASSWORD=dein-passwort
      - SMTP_DOMAIN=deine-domain.com

volumes:
  docuseal_data:

Sicherheitsempfehlungen

Öffentliche Server sollten immer sicher sein. Folgende Praktiken werden empfohlen:

• Wende regelmäßig Updates und Sicherheitspatches an.
• Setze starke Passwörter und kontrolliere den Benutzerzugang.
• Überwache Server-Logs auf verdächtige Aktivitäten.
• Installiere Tools wie Fail2ban für zusätzliche Sicherheit.
• Halte deine Docker-Images aktuell.
• Richte regelmäßige Backups deines /data Volumes ein. Schau dir unsere Anleitung zu 4 einfachen Wegen Docker Volumes zu sichern für Backup-Strategien an.

DocuSeal-Installation aktualisieren

Da wir einen spezifischen Versions-Tag (2.2.9) verwenden, musst du den Tag manuell aktualisieren, wenn eine neue Version veröffentlicht wird.

1. Prüfe auf neue Versionen auf der DocuSeal DockerHub-Seite
2. Aktualisiere den Image-Tag in deiner compose.yml Datei (z.B. ändere 2.2.9 zur neuen Version)
3. Lade die neue Version herunter und starte neu:

cd ~/docuseal
sudo docker compose pull
sudo docker compose up -d

Docker lädt die neue Version herunter und ersetzt deinen aktuellen Container.

Tipp: Wenn du automatische Updates bevorzugst und dir mögliche Breaking Changes nichts ausmachen, kannst du statt eines spezifischen Versions-Tags den latest-Tag verwenden. Für Produktionsumgebungen werden jedoch spezifische Versions-Tags empfohlen, da sie dir mehr Kontrolle über Updates geben.

Kostenvergleich mit SaaS-Alternativen

DocuSeal selbst zu hosten führt typischerweise zu massiven Einsparungen im Vergleich zu SaaS-Dokumenten-Signatur-Diensten:

Kostenvergleich mit Managed Hosting Plattformen

Wenn du Managed Hosting dem Selbst-Hosten vorziehst, hier ein Kostenvergleich:

*Hinweis: Railway berechnet nach tatsächlich genutztem Speicher und CPU-Zeit. 66€ ist der Maximalpreis, der tatsächliche Preis kann variieren.

Mit Selbst-Hosting auf Hetzner (wie in dieser Anleitung gezeigt) bekommst du ähnliche Spezifikationen für nur ~3€/Monat — aber du bist für die gesamte Einrichtung und Wartung verantwortlich. Managed Plattformen nehmen dir das ab, kosten aber mehr.

Fehlerbehebung

DocuSeal Container startet nicht

Überprüfe die Logs auf Fehler:

sudo docker compose logs docuseal

Kann nicht vom Browser auf DocuSeal zugreifen

1. Stelle sicher, dass deine Firewall die Ports 80 und 443 erlaubt
2. Überprüfe, ob Caddy läuft: sudo systemctl status caddy
3. Prüfe, ob DocuSeal läuft: sudo docker compose ps
4. Stelle sicher, dass dein DNS auf die IP-Adresse deines Servers zeigt

SSL-Zertifikat-Probleme

Caddy kümmert sich automatisch um SSL-Zertifikate, aber wenn du Probleme hast:

1. Stelle sicher, dass dein Domain-DNS richtig konfiguriert ist
2. Überprüfe Caddy-Logs: sudo journalctl -u caddy
3. Stelle sicher, dass Ports 80 und 443 offen sind und nicht von deinem Hosting-Anbieter blockiert werden

Jetzt hast du deine eigene selbst gehostete DocuSeal-Instanz auf Ubuntu! Beginne mit dem Erstellen von Dokumentenvorlagen und sende sie zum Unterschreiben.

Wenn die Verwaltung und Absicherung deines eigenen Servers etwas zu viel für dich ist, schau dir an, wie einfach es ist, eine verwaltete DocuSeal-Instanz auf Sliplane zu deployen - es dauert nur 25 Sekunden!

Cheers, Atakan