Activepieces auf einem Hetzner Ubuntu-Server selbst hosten

Möchtest du No-Code-Automatisierungen und KI-Workflows mit Activepieces bauen, bevorzugst aber die volle Kontrolle über deine Infrastruktur? Durch das Selbsthosten von Activepieces auf einem Ubuntu-Server kannst du Kosten senken und deine Automatisierungsdaten selbst verwalten!

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

Für diesen Beitrag verwenden wir einen günstigen Server von Hetzner. Hetzner ist bekannt für großartigen Service zu einem außergewöhnlichen Preis-Leistungs-Verhältnis und ist daher eine ausgezeichnete Wahl für das Hosten von Automatisierungsplattformen wie Activepieces.

Voraussetzungen

Bevor wir beginnen, achte drauf, dass du ein Hetzner Cloud-Konto hast (oder bereit bist, eines zu erstellen).

Schritt 1: Deinen Hetzner-Server einrichten

Wenn du noch keinen Hetzner-Server hast, folge diesen Schritten, um einen zu erstellen:

1. Geh zur Hetzner Cloud Console, wähle ein Projekt aus oder erstelle ein neues, dann navigiere zu Servers → Add Server

2. Folge Hetzners Richtlinien, um zu wählen:
   • Server-Typ: Wähle einen Server-Typ, der deinen Bedürfnissen entspricht.

• Standort: Wähle einen Rechenzentrumsstandort, der dir oder deinen Nutzern am nächsten ist.

• Image: Wähle Ubuntu (neueste LTS-Version empfohlen).

3. SSH-Schlüssel hinzufügen: Füg deinen öffentlichen SSH-Schlüssel für sicheren Zugriff hinzu. Wenn du noch keinen SSH-Schlüssel hast, kannst du einen mit ssh-keygen generieren:

ssh-keygen -t ed25519 -C "your_email@example.com"

Prüf ihn mit cat ~/.ssh/id_ed25519.pub und füg ihn bei deinem Server ein.

4. Konfiguriere das Networking bei Bedarf, dann klick auf Create & Pay, um deinen Server bereitzustellen.

Sobald dein Server erstellt wurde, notier dir seine IP-Adresse. Du brauchst sie, um dich im nächsten Schritt per SSH zu verbinden.

Schritt 2: Deinen Server aktualisieren

Öffne dein Terminal und melde dich per SSH auf deinem Ubuntu-Server an:

ssh root@your-server-ip

und aktualisiere das System, damit es die neuesten Sicherheitspatches und Updates hat:

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

Sobald das durch ist, ist dein Server bereit für die Installation der Software.

Schritt 3: UFW-Firewall installieren und konfigurieren

Halte nur notwendige 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

Prüf deine Firewall-Konfiguration:

sudo ufw status verbose

Schritt 4: Docker-Installation

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

Dependencies und Docker-GPG-Schlüssel einrichten:

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

Docker-Repository hinzufügen:

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

Docker Engine und compose-plugin installieren:

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

Installation prüfen:

sudo docker run hello-world

Wenn du die "hello-world"-Nachricht siehst, ist Docker bereit.

Schritt 5: Caddy für automatische HTTPS installieren

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

Caddy installieren:

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

Bevor du Caddy konfigurierst, musst du deine Domain auf die IP-Adresse deines Servers zeigen. Wenn du DNS noch nicht konfiguriert hast, folge diesen Schritten:

DNS für deine Domain konfigurieren

1. Melde dich im Dashboard deines Domain-Registrars an (wo du deine Domain gekauft hast)
2. Geh zu den DNS-Einstellungen oder dem DNS-Verwaltungsbereich
3. Füg einen A-Record mit folgenden Einstellungen hinzu:
   • Typ: A
   • Name: @ (für Root-Domain) oder eine Subdomain wie activepieces (für activepieces.deinedomain.com)
   • Wert/Ziel: Die IPv4-Adresse deines Hetzner-Servers
4. Füg einen AAAA-Record für IPv6-Unterstützung hinzu:
   • Typ: AAAA
   • Name: @ (für Root-Domain) oder dieselbe Subdomain wie beim A-Record
   • Wert/Ziel: Die IPv6-Adresse deines Hetzner-Servers

Caddy konfigurieren

Bearbeite die Caddyfile-Konfigurationsdatei:

sudo nano /etc/caddy/Caddyfile

Gib deine Domain ein und konfiguriere den Reverse-Proxy. Ersetze "yourdomain.com" mit deinem tatsächlichen Domain-Namen:

yourdomain.com {
    reverse_proxy localhost:8080
}

Wenn du noch keine Domain hast, nutze das vorübergehend:

:80 {
    reverse_proxy localhost:8080
}

Starte Caddy neu, um die Config zu laden:

sudo systemctl restart caddy

Schritt 6: Activepieces mit Docker Compose ausführen

Wir nutzen Docker Compose für eine einfachere Einrichtung. Die folgende compose.yml basiert auf dem offiziellen Activepieces-Docker-Setup. Sie verwendet PGLite (eingebettetes PostgreSQL) und eine In-Memory-Queue—ideal für persönliche Nutzung oder kleine Teams auf einem einzelnen Server. Für Produktion mit mehreren Instanzen nutze stattdessen die Docker-Compose-Option mit PostgreSQL und Redis.

Erstelle zuerst ein Verzeichnis für Activepieces, navigiere dorthin und erstelle die Compose-Datei:

mkdir -p ~/activepieces
cd ~/activepieces
sudo nano compose.yml

Kopiere folgenden Inhalt in compose.yml. Wenn du eine Domain hast, ersetze http://localhost:8080 mit deiner tatsächlichen URL (erforderlich für Webhooks und Trigger):

services:
  activepieces:
    image: activepieces/activepieces:0.77.8
    restart: always
    ports:
      - "8080:80"
    volumes:
      - activepieces_data:/root/.activepieces
    environment:
      - AP_REDIS_TYPE=MEMORY
      - AP_DB_TYPE=PGLITE
      - AP_FRONTEND_URL=http://localhost:8080

volumes:
  activepieces_data:

Dieses Setup stellt sicher:

• Deine Daten bleiben über Container-Neustarts hinweg erhalten
• Webhooks und Trigger funktionieren korrekt mit deiner öffentlichen URL
• Der Container startet automatisch neu, wenn er abstürzt

Deploy Activepieces jetzt mit Docker Compose:

sudo docker compose up -d

Docker lädt das Activepieces-Image und führt es im Hintergrund auf Port 8080 aus.

Schritt 7: Auf deine selbstgehostete Activepieces-Instanz zugreifen

Besuche deine Domain in einem beliebigen Webbrowser. Deine Activepieces-Instanz sollte jetzt erfolgreich unter https://yourdomain.com laden. Erstelle dein Admin-Konto und leg los mit den Automatisierungen!

Sicherheitsempfehlungen

Öffentliche Server sollten immer sicher sein. Die folgenden Maßnahmen werden empfohlen:

• Wende regelmäßig Updates und Sicherheitspatches an.
• Setze starke Passwörter und kontrolliere den Benutzerzugriff.
• Überwache Server-Logs auf verdächtige Aktivitäten.
• Installiere Tools wie Fail2ban für zusätzliche Sicherheit.

Deine Activepieces-Installation aktualisieren

Wenn du deine Activepieces-Instanz aktualisieren möchtest, prüf zuerst die neueste Version auf Docker Hub, aktualisiere dann die Image-Version in deiner compose.yml und führe aus:

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

Docker lädt aktualisierte Versionen automatisch herunter und ersetzt deine aktuellen Container.

Kostenvergleich mit anderen Anbietern

Das Selbsthosten von Activepieces führt typischerweise zu niedrigeren Kosten im Vergleich zu gehosteten Automatisierungsplattformen:

Du behältst die volle Kontrolle und vermeidest nutzungsbasierte Gebühren durch das Selbsthosten. Aber natürlich gibt es kein kostenloses Mittagessen—du bist jetzt verantwortlich für die Verwaltung deines eigenen Servers!