warnung

Dieses Tutorial ist ein Beitrag der Community und wird nicht vom Open-WebUI-Team unterstützt. Es dient lediglich als Demonstration, wie Sie Open WebUI für Ihren spezifischen Anwendungsfall anpassen können. Möchten Sie beitragen? Schauen Sie sich das Beitragstutorial an.

HTTPS mit Nginx

Die Sicherstellung einer sicheren Kommunikation zwischen Ihren Benutzern und der Open WebUI ist von größter Bedeutung. HTTPS (HyperText Transfer Protocol Secure) verschlüsselt die übermittelten Daten und schützt diese vor Abhören und Manipulation. Durch die Konfiguration von Nginx als Reverse-Proxy können Sie HTTPS nahtlos zu Ihrer Open-WebUI-Implementierung hinzufügen und sowohl die Sicherheit als auch die Vertrauenswürdigkeit erhöhen.

Dieser Leitfaden bietet drei Methoden, um HTTPS einzurichten:

Selbstsignierte Zertifikate: Ideal für Entwicklung und interne Nutzung unter Verwendung von Docker.
Lets Encrypt: Perfekt für Produktionsumgebungen, die vertrauenswürdige SSL-Zertifikate erfordern, unter Verwendung von Docker.
Windows+Selbstsigniert: Vereinfachte Anweisungen für Entwicklung und interne Nutzung unter Windows, kein Docker erforderlich.

Wählen Sie die Methode, die Ihren Bereitstellungsanforderungen am besten entspricht.

Nginx Proxy Manager
Lets Encrypt
Selbstsigniert
Windows

Nginx Proxy Manager

Mit dem Nginx Proxy Manager (NPM) können Sie Reverse-Proxies einfach verwalten und Ihre lokalen Anwendungen, wie Open WebUI, mit gültigen SSL-Zertifikaten von Lets Encrypt sichern. Diese Konfiguration ermöglicht HTTPS-Zugriff, was erforderlich ist, um Sprach-eingabefunktionen in vielen mobilen Browsern nutzen zu können, aufgrund deren Sicherheitsanforderungen, ohne den spezifischen Port der Anwendung direkt dem Internet auszusetzen.

Voraussetzungen

Ein Heimserver mit Docker und einem laufenden open-webui-Container.
Ein Domainname (kostenlose Optionen wie DuckDNS oder kostenpflichtige wie Namecheap/GoDaddy).
Grundlegende Kenntnisse über Docker und DNS-Konfiguration.

Schritte

Verzeichnisse für Nginx-Dateien erstellen:
```
mkdir ~/nginx_config
cd ~/nginx_config
```
Nginx Proxy Manager mit Docker einrichten:
```
nano docker-compose.yml
```

services:
  app:
    image: jc21/nginx-proxy-manager:latest
    restart: unless-stopped
    ports:
      - 80:80
      - 81:81
      - 443:443
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt

Container starten:

docker-compose up -d

DNS und Domain konfigurieren:
- Melden Sie sich bei Ihrem Domainanbieter (z. B. DuckDNS) an und erstellen Sie eine Domain.
- Richten Sie die Domain auf die lokale IP Ihres Proxys (z. B. 192.168.0.6).
- Wenn Sie DuckDNS verwenden, holen Sie sich ein API-Token aus dem Dashboard.

Hier ein einfaches Beispiel, wie es auf https://www.duckdns.org/domains gemacht wird:

SSL-Zertifikate einrichten:

Greifen Sie auf den Nginx Proxy Manager unter http://server_ip:81 zu. Zum Beispiel: 192.168.0.6:81
Melden Sie sich mit den Standard-Anmeldeinformationen an ([email protected] / changeme). Ändern Sie diese wie verlangt.
Gehen Sie zu SSL-Zertifikate → SSL-Zertifikat hinzufügen → Lets Encrypt.
Geben Sie Ihre E-Mail-Adresse und den von DuckDNS erhaltenen Domainnamen ein. Ein Domainname enthält ein Sternchen und ein anderer nicht. Beispiel: *.hello.duckdns.org und hello.duckdns.org.
Wählen Sie die Verwendung einer DNS-Herausforderung, wählen Sie DuckDNS und fügen Sie Ihr API-Token ein. Beispiel: dns_duckdns_token=f4e2a1b9-c78d-e593-b0d7-67f2e1c9a5b8
Stimmen Sie den Bedingungen von Lets Encrypt zu und speichern Sie. Ändern Sie die Propagationszeit, falls erforderlich (120 Sekunden).

Proxy-Hosts erstellen:

Für jeden Dienst (z. B. openwebui, nextcloud) gehen Sie zu Hosts → Proxy-Hosts → Proxy-Host hinzufügen.
Geben Sie den Domainnamen ein (z. B. openwebui.hello.duckdns.org).
Stellen Sie das Schema auf HTTP (Standard), aktivieren Sie Websockets-Support und richten Sie Ihre Docker-IP ein (wenn Docker mit open-webui auf demselben Computer wie der NGINX-Manager läuft, ist dies dieselbe IP wie zuvor (Beispiel: 192.168.0.6).
Wählen Sie das zuvor generierte SSL-Zertifikat aus, erzwingen Sie SSL und aktivieren Sie HTTP/2.

Fügen Sie Ihre URL zu open-webui hinzu (sonst gibt es HTTPS-Fehler):

Gehen Sie zu Ihrem open-webui → Admin-Panel → Einstellungen → Allgemein
Geben Sie im Textfeld Webhook-URL Ihre URL ein, über die Sie über den Nginx-Reverse-Proxy eine Verbindung zu Ihrem open-webui herstellen. Beispiel: hello.duckdns.org (nicht unbedingt notwendig mit diesem) oder openwebui.hello.duckdns.org (essentiell mit diesem).

Zugriff auf das WebUI:

Greifen Sie über HTTPS auf Open WebUI zu, entweder unter hello.duckdns.org oder openwebui.hello.duckdns.org (je nachdem, wie Sie es eingerichtet haben).

Hinweis zur Firewall: Beachten Sie, dass lokale Firewall-Software (wie Portmaster) möglicherweise den internen Docker-Netzwerkverkehr oder erforderliche Ports blockiert. Wenn Probleme auftreten, überprüfen Sie Ihre Firewall-Regeln, um sicherzustellen, dass die notwendige Kommunikation für diese Konfiguration ermöglicht wird.

Lets Encrypt

Lets Encrypt bietet kostenlose SSL-Zertifikate an, die von den meisten Browsern akzeptiert werden und sich ideal für Produktionsumgebungen eignen.

Voraussetzungen

Certbot auf Ihrem System installiert.
DNS-Einträge korrekt konfiguriert, die auf Ihren Server zeigen.

Schritte

Verzeichnisse für Nginx-Dateien erstellen:
```
mkdir -p conf.d ssl
```

Nginx-Konfigurationsdatei erstellen:

conf.d/open-webui.conf:

server {
    listen 80;
    server_name your_domain_or_IP;

    location / {
        proxy_pass http://host.docker.internal:3000;

        # Unterstützung für WebSocket hinzufügen (Notwendig für Version 0.5.0 und höher)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        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;

        # (Optional) Proxy-Pufferung deaktivieren für bessere Streaming-Antworten von Modellen
        proxy_buffering off;

        # (Optional) Maximale Anfragegröße für große Anhänge und lange Audionachrichten erhöhen
        client_max_body_size 20M;
        proxy_read_timeout 10m;
    }
}

Vereinfachtes Lets Encrypt-Skript:

enable_letsencrypt.sh:

#!/bin/bash

# Beschreibung: Vereinfachtes Skript zur Beschaffung und Installation von Lets Encrypt SSL-Zertifikaten mit Certbot.

DOMAIN="your_domain_or_IP"
EMAIL="[email protected]"

# Certbot installieren, falls nicht installiert
if ! command -v certbot &> /dev/null; then
    echo "Certbot nicht gefunden. Wird installiert..."
    sudo apt-get update
    sudo apt-get install -y certbot python3-certbot-nginx
fi

# SSL-Zertifikat beschaffen
sudo certbot --nginx -d "$DOMAIN" --non-interactive --agree-tos -m "$EMAIL"

# Nginx neu laden, um Änderungen anzuwenden
sudo systemctl reload nginx

echo "Das Lets Encrypt SSL-Zertifikat wurde installiert und Nginx neu geladen."

Machen Sie das Skript ausführbar:

chmod +x enable_letsencrypt.sh

Aktualisieren Sie die Docker-Compose-Konfiguration:

Fügen Sie den Nginx-Dienst zu Ihrer docker-compose.yml hinzu:

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./conf.d:/etc/nginx/conf.d
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - open-webui

Nginx-Dienst starten:
```
docker compose up -d nginx
```
Führen Sie das Lets Encrypt-Skript aus:

Führen Sie das Skript aus, um das SSL-Zertifikat zu beschaffen und zu installieren:
```
./enable_letsencrypt.sh
```

Zugriff auf das WebUI

Greifen Sie über HTTPS auf Open WebUI zu unter:

https://your_domain_or_IP

Selbstsigniertes Zertifikat

Die Verwendung selbstsignierter Zertifikate ist für die Entwicklung oder interne Nutzung geeignet, bei der Vertrauen keine kritische Rolle spielt.

Schritte

Verzeichnisse für Nginx-Dateien erstellen:
```
mkdir -p conf.d ssl
```

Nginx-Konfigurationsdatei erstellen:

conf.d/open-webui.conf:

server {
    listen 443 ssl;
    server_name your_domain_or_IP;

    ssl_certificate /etc/nginx/ssl/nginx.crt;
    ssl_certificate_key /etc/nginx/ssl/nginx.key;
    ssl_protocols TLSv1.2 TLSv1.3;

    location / {
        proxy_pass http://host.docker.internal:3000;
        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;

        # (Optional) Proxy-Buffering deaktivieren für bessere Streaming-Antworten von Modellen
        proxy_buffering off;

        # (Optional) Maximale Anfragegröße für große Anhänge und lange Audiobotschaften erhöhen
        client_max_body_size 20M;
        proxy_read_timeout 10m;
    }
}

Selbstsignierte SSL-Zertifikate generieren:

openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout ssl/nginx.key \
-out ssl/nginx.crt \
-subj "/CN=your_domain_or_IP"

Docker Compose-Konfiguration aktualisieren:

Fügen Sie den Nginx-Dienst zu Ihrer docker-compose.yml hinzu:

services:
  nginx:
    image: nginx:alpine
    ports:
      - "443:443"
    volumes:
      - ./conf.d:/etc/nginx/conf.d
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - open-webui

Nginx-Dienst starten:
```
docker compose up -d nginx
```

Zugriff auf die WebUI

Zugriff auf Open WebUI über HTTPS unter:

https://your_domain_or_IP

Verwendung eines selbstsignierten Zertifikats und Nginx unter Windows ohne Docker

Für einfache interne/Entwicklungsinstallationen können Sie Nginx und ein selbstsigniertes Zertifikat verwenden, um Open WebUI auf HTTPS zu proxieren, wodurch Funktionen wie die Mikrofoneingabe über LAN ermöglicht werden. (Standardmäßig erlauben die meisten Browser keine Mikrofoneingabe auf unsicheren Nicht-Localhost-URLs)

In dieser Anleitung wird davon ausgegangen, dass Sie Open WebUI mit pip installiert haben und open-webui serve ausführen.

Schritt 1: Installation von OpenSSL zur Zertifikatserstellung

Zunächst müssen Sie OpenSSL installieren.

Sie können vorkompilierte Binärdateien von der Website von Shining Light Productions (SLP) herunterladen und installieren.

Alternativ, wenn Sie Chocolatey installiert haben, können Sie damit OpenSSL schnell installieren:

Öffnen Sie eine Eingabeaufforderung oder PowerShell.
Führen Sie den folgenden Befehl aus, um OpenSSL zu installieren:
```
choco install openssl -y
```

Installation überprüfen

Nach der Installation öffnen Sie eine Eingabeaufforderung und geben Sie ein:

openssl version

Wenn die OpenSSL-Version angezeigt wird (z. B. OpenSSL 3.x.x ...), ist es korrekt installiert.

Schritt 2: Installation von Nginx

Laden Sie die offizielle Windows-Version von Nginx von nginx.org herunter oder verwenden Sie einen Paketmanager wie Chocolatey. Entpacken Sie die heruntergeladene ZIP-Datei in ein Verzeichnis (z. B. C:\nginx).

Schritt 3: Zertifikat erstellen

Führen Sie folgenden Befehl aus:

openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout nginx.key -out nginx.crt

Verschieben Sie die generierten Dateien nginx.key und nginx.crt in einen Ordner Ihrer Wahl oder in das Verzeichnis C:\nginx.

Schritt 4: Nginx konfigurieren

Öffnen Sie die Datei C:\nginx\conf\nginx.conf in einem Texteditor.

Wenn Sie möchten, dass Open WebUI über Ihr lokales LAN zugänglich ist, notieren Sie sich die LAN-IP-Adresse mit ipconfig, z. B. 192.168.1.15.

Richten Sie es wie folgt ein:

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  $remote_addr - $remote_user [$time_local] "$request" 
    #                  $status $body_bytes_sent "$http_referer" 
    #                  "$http_user_agent" "$http_x_forwarded_for";

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  120;

    #gzip  on;

    # erforderlich für die ordnungsgemäße Handhabung von Websockets (Streaming)
    map $http_upgrade $connection_upgrade {
        default upgrade;
              close;
    }

    # Leitet allen HTTP-Verkehr zu HTTPS um
    server {
        listen 80;
        server_name 192.168.1.15;

        return 301 https://$host$request_uri;
    }

    # verarbeitet HTTPS-Verkehr
    server {
        listen 443 ssl;
        server_name 192.168.1.15;

        # SSL-Einstellungen (stellen Sie sicher, dass die Pfade korrekt sind)
        ssl_certificate C:\\nginx\\nginx.crt;
        ssl_certificate_key C:\\nginx\\nginx.key;
        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
        ssl_prefer_server_ciphers on;

        # OCSP-Stapling
        #ssl_stapling on;
        #ssl_stapling_verify on;

        # Proxy-Einstellungen für Ihren lokalen Dienst
        location / {
            # proxy_pass sollte auf Ihre lokal laufende Version von open-webui verweisen
            proxy_pass http://localhost:8080;

            # WebSocket-Unterstützung hinzufügen (erforderlich für Version 0.5.0 und höher)
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection $connection_upgrade;

            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;

            # (Optional) Proxy-Pufferung deaktivieren für bessere Streaming-Antwort von Modellen
            proxy_buffering off;

            # (Optional) Maximale Anfragengröße erhöhen für große Anhänge und lange Audiomeldungen
            client_max_body_size 20M;
            proxy_read_timeout 10m;
        }
    }

}

Speichern Sie die Datei und überprüfen Sie die Konfiguration auf Fehler oder Syntaxprobleme, indem Sie nginx -t ausführen. Möglicherweise müssen Sie zuerst cd C:\nginx ausführen, je nachdem, wie Sie es installiert haben.

Führen Sie nginx aus, indem Sie nginx ausführen. Wenn bereits ein nginx-Dienst gestartet ist, können Sie die neue Konfiguration mit nginx -s reload neu laden.

Sie sollten jetzt in der Lage sein, über https://192.168.1.15 (oder Ihre eigene LAN-IP, falls zutreffend) auf Open WebUI zuzugreifen. Stellen Sie sicher, dass Sie im Windows-Firewall-Zugriff die erforderlichen Berechtigungen erteilen.

Nächste Schritte

Nachdem Sie HTTPS eingerichtet haben, greifen Sie sicher auf Open WebUI zu unter:

https://localhost

Stellen Sie sicher, dass Ihre DNS-Einträge korrekt konfiguriert sind, wenn Sie einen Domainnamen verwenden. Für Produktionsumgebungen wird empfohlen, Lets Encrypt für vertrauenswürdige SSL-Zertifikate zu verwenden.

Nginx Proxy Manager​

Voraussetzungen​

Schritte​

Hier ein einfaches Beispiel, wie es auf https://www.duckdns.org/domains gemacht wird:​

Zugriff auf das WebUI:​

Lets Encrypt​

Voraussetzungen​

Schritte​

Zugriff auf das WebUI​

Selbstsigniertes Zertifikat​

Schritte​

Zugriff auf die WebUI​

Verwendung eines selbstsignierten Zertifikats und Nginx unter Windows ohne Docker​

Schritt 1: Installation von OpenSSL zur Zertifikatserstellung​

Installation überprüfen​

Schritt 2: Installation von Nginx​

Schritt 3: Zertifikat erstellen​

Schritt 4: Nginx konfigurieren​

Nächste Schritte​

Nginx Proxy Manager

Voraussetzungen

Schritte

Hier ein einfaches Beispiel, wie es auf https://www.duckdns.org/domains gemacht wird:

Zugriff auf das WebUI:

Lets Encrypt

Voraussetzungen

Schritte

Zugriff auf das WebUI

Selbstsigniertes Zertifikat

Schritte

Zugriff auf die WebUI

Verwendung eines selbstsignierten Zertifikats und Nginx unter Windows ohne Docker

Schritt 1: Installation von OpenSSL zur Zertifikatserstellung

Installation überprüfen

Schritt 2: Installation von Nginx

Schritt 3: Zertifikat erstellen

Schritt 4: Nginx konfigurieren

Nächste Schritte