Langflow auf einem Ubuntu Server selbst hosten

Möchtest du leistungsstarke KI-Workflows mit Langflow erstellen, aber dabei die volle Kontrolle über deine Infrastruktur behalten? Durch das Selbst-Hosten von Langflow auf einem Linux Ubuntu Server kannst du Kosten reduzieren und deine Daten selbst verwalten!

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

Bevor wir beginnen, stelle sicher, dass du folgendes hast:

• eine laufende Ubuntu Linux Server-Instanz. Eine gute Option ist Hetzner, aber jeder Ubuntu Server, auf den du dich per SSH einloggen kannst und der eine öffentliche IP-Adresse hat, funktioniert.
• grundlegende SSH-Erfahrung.

Schritt 1: Server aktualisieren

Logge dich per SSH in deinen Ubuntu Server ein und aktualisiere das System, um sicherzustellen, dass es die neuesten Sicherheits-Patches und Updates hat.

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

Wenn das erledigt ist, ist dein Server bereit für die Installation der Software.

Schritt 2: 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

Überprüfe deine Firewall-Konfiguration:

sudo ufw status verbose

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

Schritt 3: Docker Installation

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

Abhängigkeiten und Dockers 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 überprüfen:

sudo docker run hello-world

Wenn du die "hello-world" 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 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

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:7860
}

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

:80 {
    reverse_proxy localhost:7860
}

Starte Caddy neu, um die Konfiguration zu laden:

sudo systemctl restart caddy

Schritt 5: Langflow mit Docker Compose ausführen

Wir werden Docker Compose für ein einfacheres Setup verwenden. Erstelle zunächst ein Verzeichnis für Langflow und navigiere dorthin:

mkdir ~/langflow
cd ~/langflow

SQLite-Konfiguration (Einfaches Setup)

Erstelle compose.yml mit folgendem Inhalt für SQLite-Datenbank:

services:
  langflow:
    image: docker.io/langflowai/langflow:latest
    restart: always
    ports:
      - "7860:7860"
    environment:
      - LANGFLOW_HOST=0.0.0.0
      - LANGFLOW_CONFIG_DIR=/app/langflow
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=change_me_to_secure_password
      - LANGFLOW_SECRET_KEY=your_secret_key_here
      - DO_NOT_TRACK=true
      - LANGFLOW_AUTO_LOGIN=false
    volumes:
      - langflow_data:/app/langflow

volumes:
  langflow_data:

PostgreSQL-Konfiguration (Produktionssetup)

Für Produktionsumgebungen wird PostgreSQL empfohlen. Erstelle compose.yml mit folgendem Inhalt:

services:
  postgres:
    image: docker.io/library/postgres:16.4
    restart: always
    environment:
      - POSTGRES_USER=langflow
      - POSTGRES_PASSWORD=your_postgres_password
      - POSTGRES_DB=langflow
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  langflow:
    image: docker.io/langflowai/langflow:latest
    restart: always
    ports:
      - "7860:7860"
    environment:
      - LANGFLOW_HOST=0.0.0.0
      - LANGFLOW_CONFIG_DIR=/app/langflow
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=change_me_to_secure_password
      - LANGFLOW_SECRET_KEY=your_secret_key_here
      - DO_NOT_TRACK=true
      - LANGFLOW_AUTO_LOGIN=false
      - DATABASE_URL=postgresql://langflow:your_postgres_password@postgres:5432/langflow
    volumes:
      - langflow_data:/app/langflow
    depends_on:
      - postgres

volumes:
  langflow_data:
  postgres_data:

Wichtig: Ersetze your_postgres_password, change_me_to_secure_password und your_secret_key_here mit sicheren Werten vor der Bereitstellung.

Stelle nun Langflow mit Docker Compose bereit:

sudo docker compose up -d

Docker lädt das Langflow-Image herunter und führt es im Hintergrund-Modus mit Port 7860 aus.

Schritt 6: Zugriff auf deine selbst gehostete Langflow-Instanz

Besuche deine Domain in einem beliebigen Webbrowser. Deine Langflow-Instanz sollte nun erfolgreich unter https://yourdomain.com laden. Logge dich mit den Superuser-Anmeldedaten ein, die du konfiguriert hast, um dein anfängliches Setup abzuschließen.

Sicherheitsempfehlungen

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

• Regelmäßig Updates und Sicherheits-Patches anwenden.
• Starke Passwörter setzen und Benutzerzugriff kontrollieren.
• Server-Logs auf verdächtige Aktivitäten überwachen.
• Tools wie Fail2ban für zusätzliche Sicherheit installieren.
• Umgebungsvariablen für Geheimnisse verwenden, anstatt sie hart zu codieren.

Langflow-Installation aktualisieren

Wenn du deine Langflow-Instanz aktualisieren möchtest, führe einfach aus:

sudo docker compose pull
sudo docker compose up -d

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

Kostenvergleich mit anderen Anbietern

Selbst-Hosting von Langflow führt typischerweise zu geringeren Kosten im Vergleich zu gehosteten Diensten:

Du behältst die vollständige Kontrolle und vermeidest zusätzliche nutzungsbasierte Gebühren durch Selbst-Hosting. Aber natürlich gibt es nichts umsonst und du bist nun für die Verwaltung deines eigenen Servers verantwortlich!

Fehlt etwas bei einer selbst gehosteten Langflow?

Selbst gehostetes Langflow bietet die vollständige Open-Source-Erfahrung mit allen verfügbaren Funktionen. Du kannst komplexe KI-Workflows erstellen, verschiedene APIs und Modelle integrieren und alles nach deinen Bedürfnissen anpassen.

Jetzt hast du deine eigene selbst gehostete Langflow-Instanz auf Ubuntu laufen! Zeit, mit dem Aufbau deiner KI-Workflows zu beginnen.

Wenn dir die Verwaltung und Sicherung deines eigenen Servers etwas zu viel ist, schau dir an, wie einfach es ist, eine verwaltete Langflow-Instanz auf sliplane bereitzustellen (dauert 45 Sekunden!)