attention

Ce tutoriel est une contribution de la communauté et n'est pas pris en charge par l'équipe d'Open WebUI. Il sert uniquement de démonstration sur la façon de personnaliser Open WebUI pour votre cas d'utilisation spécifique. Vous souhaitez contribuer ? Consultez le tutoriel de contribution.

HTTPS en utilisant Nginx

Assurer une communication sécurisée entre vos utilisateurs et Open WebUI est primordial. HTTPS (HyperText Transfer Protocol Secure) crypte les données transmises, les protégeant contre les interceptions et les altérations. En configurant Nginx comme proxy inverse, vous pouvez ajouter HTTPS à votre déploiement Open WebUI de manière transparente, renforçant ainsi la sécurité et la fiabilité.

Ce guide propose trois méthodes pour configurer HTTPS :

• Certificats auto-signés : Idéal pour le développement et l'utilisation interne, en utilisant Docker.
• Lets Encrypt : Parfait pour les environnements de production nécessitant des certificats SSL fiables, en utilisant Docker.
• Windows+Auto-signés : Instructions simplifiées pour le développement et l'utilisation interne sur Windows, sans besoin de Docker.

Choisissez la méthode qui correspond le mieux à vos besoins de déploiement.

Nginx Proxy Manager

Nginx Proxy Manager

Nginx Proxy Manager (NPM) vous permet de gérer facilement les proxys inversés et de sécuriser vos applications locales, comme Open WebUI, avec des certificats SSL valides de Lets Encrypt. Cette configuration permet un accès HTTPS, nécessaire pour utiliser les fonctionnalités d'entrée vocale sur de nombreux navigateurs mobiles en raison de leurs exigences de sécurité, sans exposer directement le port spécifique de l'application à Internet.

Conditions préalables

• Un serveur domestique exécutant Docker et un conteneur open-webui en cours d'exécution.
• Un nom de domaine (options gratuites comme DuckDNS ou payantes comme Namecheap/GoDaddy).
• Connaissances de base en configuration Docker et DNS.

Étapes

1. Créer des répertoires pour les fichiers Nginx:

   mkdir ~/nginx_config
   cd ~/nginx_config

2. Configurer Nginx Proxy Manager avec Docker:

   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

Exécutez le conteneur :

docker-compose up -d

3. Configurer DNS et domaine:

   • Connectez-vous à votre fournisseur de domaine (par exemple, DuckDNS) et créez un domaine.
   • Pointez le domaine vers l'IP locale de votre proxy (par exemple, 192.168.0.6).
   • Si vous utilisez DuckDNS, obtenez un jeton API depuis leur tableau de bord.

Voici un exemple simple de configuration sur https://www.duckdns.org/domains :

4. Configurer les certificats SSL:

• Accédez à Nginx Proxy Manager à l'adresse http://server_ip:81. Par exemple : 192.168.0.6:81
• Connectez-vous avec les identifiants par défaut ([email protected] / changeme). Changez-les comme demandé.
• Allez à Certificats SSL → Ajouter un certificat SSL → Lets Encrypt.
• Entrez votre email et le nom de domaine obtenu via DuckDNS. Un nom de domaine contient un astérisque et un autre ne le contient pas. Exemple : *.hello.duckdns.org et hello.duckdns.org.
• Sélectionnez l'option Utiliser un défi DNS, choisissez DuckDNS et collez votre jeton API. Exemple : dns_duckdns_token=f4e2a1b9-c78d-e593-b0d7-67f2e1c9a5b8
• Acceptez les conditions de Let’s Encrypt et sauvegardez. Modifiez le temps de propagation si nécessaire (120 secondes).

5. Créer des proxys hôtes:

• Pour chaque service (par exemple, openwebui, nextcloud), allez à Hôtes → Proxys hôtes → Ajouter un proxy hôte.
• Remplissez le nom de domaine (par exemple, openwebui.hello.duckdns.org).
• Définissez le schéma sur HTTP (par défaut), activez Support Websockets et pointez vers l'IP de votre Docker (si Docker avec open-webui est exécuté sur le même ordinateur que le gestionnaire NGINX, ce sera la même IP que précédemment (exemple : 192.168.0.6)
• Sélectionnez le certificat SSL généré précédemment, forcez SSL et activez HTTP/2.

6. Ajoutez votre URL à open-webui (sinon vous obtiendrez une erreur HTTPS) :

• Allez à votre open-webui → Panneau d'administration → Paramètres → Général
• Dans le champ de texte Webhook URL, entrez votre URL via laquelle vous vous connecterez à votre open-webui via le proxy inverse Nginx. Exemple : hello.duckdns.org (non essentiel pour celui-ci) ou openwebui.hello.duckdns.org (essentiel pour celui-ci).

Accéder au WebUI :

Accédez à Open WebUI via HTTPS à l'adresse hello.duckdns.org ou openwebui.hello.duckdns.org (selon la façon dont vous l'avez configuré).

Remarque sur le pare-feu : Sachez que les logiciels de pare-feu locaux (comme Portmaster) peuvent bloquer le trafic réseau interne Docker ou les ports requis. Si vous rencontrez des problèmes, vérifiez les règles de votre pare-feu pour garantir la communication nécessaire à cette configuration.

Lets Encrypt

Lets Encrypt

Lets Encrypt fournit des certificats SSL gratuits acceptés par la plupart des navigateurs, idéal pour les environnements de production.

Conditions préalables

• Certbot installé sur votre système.
• Enregistrements DNS correctement configurés pour pointer vers votre serveur.

Étapes

1. Créer des répertoires pour les fichiers Nginx :

   mkdir -p conf.d ssl

2. Créer un fichier de configuration Nginx :

   conf.d/open-webui.conf:

   server {
       listen 80;
       server_name your_domain_or_IP;
   
       location / {
           proxy_pass http://host.docker.internal:3000;
   
           # Ajouter la prise en charge de WebSocket (Nécessaire pour la version 0.5.0 et supérieure)
           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;
   
           # (Optionnel) Désactiver le buffering du proxy pour une meilleure réponse en streaming des modèles
           proxy_buffering off;
   
           # (Optionnel) Augmenter la taille maximale des requêtes pour les fichiers joints volumineux et les longs messages audio
           client_max_body_size 20M;
           proxy_read_timeout 10m;
       }
   }

3. Script simplifié de Lets Encrypt :

   enable_letsencrypt.sh:

   #!/bin/bash
   
   # Description : Script simplifié pour obtenir et installer des certificats SSL Lets Encrypt à laide de Certbot.
   
   DOMAIN="your_domain_or_IP"
   EMAIL="[email protected]"
   
   # Installer Certbot si non installé
   if ! command -v certbot &> /dev/null; then
       echo "Certbot non trouvé. Installation..."
       sudo apt-get update
       sudo apt-get install -y certbot python3-certbot-nginx
   fi
   
   # Obtenir le certificat SSL
   sudo certbot --nginx -d "$DOMAIN" --non-interactive --agree-tos -m "$EMAIL"
   
   # Recharger Nginx pour appliquer les changements
   sudo systemctl reload nginx
   
   echo "Le certificat SSL Lets Encrypt a été installé et Nginx rechargé."

   Rendre le script exécutable :

   chmod +x enable_letsencrypt.sh

4. Mettre à jour la configuration de Docker Compose :

   Ajouter le service Nginx à votre docker-compose.yml :

   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

5. Démarrer le service Nginx :

   docker compose up -d nginx

6. Exécuter le script de Lets Encrypt :

   Exécutez le script pour obtenir et installer le certificat SSL :

   ./enable_letsencrypt.sh

Accéder à WebUI

Accédez à Open WebUI via HTTPS à :

https://your_domain_or_IP

Auto-signé

Certificat Auto-signé

L'utilisation de certificats auto-signés est adaptée au développement ou à une utilisation interne où la confiance n'est pas une préoccupation cruciale.

Étapes

1. Créer des répertoires pour les fichiers Nginx :

   mkdir -p conf.d ssl

2. Créer un fichier de configuration Nginx :

   conf.d/open-webui.conf:

   server {
       listen 443 ssl;
       server_name votre_domaine_ou_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;
   
           # (Optionnel) Désactiver la mise en mémoire tampon du proxy pour une meilleure réponse en streaming des modèles
           proxy_buffering off;
   
           # (Optionnel) Augmenter la taille maximale des requêtes pour les pièces jointes volumineuses et les longs messages audio
           client_max_body_size 20M;
           proxy_read_timeout 10m;
       }
   }

3. Générer des certificats SSL auto-signés :

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

4. Mettre à jour la configuration Docker Compose :

   Ajouter le service Nginx à votre docker-compose.yml :

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

5. Démarrer le service Nginx :

   docker compose up -d nginx

Accéder au WebUI

Accédez à Open WebUI via HTTPS à :

https://votre_domaine_ou_IP

---

Windows

Utilisation d'un certificat auto-signé et de Nginx sous Windows sans Docker

Pour les installations internes/de développement basiques, vous pouvez utiliser nginx et un certificat auto-signé pour proxy Open WebUI en HTTPS, permettant ainsi d'utiliser des fonctionnalités comme l'entrée microphone via LAN. (Par défaut, la plupart des navigateurs n'autorisent pas l'entrée microphone sur des URL non sécurisées non-localhost)

Ce guide suppose que vous avez installé Open WebUI avec pip et que vous exécutez open-webui serve

Étape 1 : Installer openssl pour la génération de certificat

Vous devez d'abord installer openssl

Vous pouvez télécharger et installer les binaires précompilés depuis le site web Shining Light Productions (SLP).

Alternativement, si vous disposez de Chocolatey installé, vous pouvez l'utiliser pour installer rapidement OpenSSL :

1. Ouvrez une invite de commande ou PowerShell.
2. Exécutez la commande suivante pour installer OpenSSL :

   choco install openssl -y

---

Vérifier l'installation

Après l'installation, ouvrez une invite de commande et tapez :

openssl version

Si la version d'OpenSSL s'affiche (par exemple, OpenSSL 3.x.x ...), elle est correctement installée.

Étape 2 : Installer nginx

Téléchargez la version officielle de Nginx pour Windows depuis nginx.org ou utilisez un gestionnaire de paquets comme Chocolatey. Extrayez le fichier ZIP téléchargé dans un répertoire (par ex., C:\nginx).

Étape 3 : Générer le certificat

Exécutez la commande suivante :

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

Déplacez les fichiers nginx.key et nginx.crt générés vers un dossier de votre choix, ou vers le répertoire C:\nginx

Étape 4 : Configurer nginx

Ouvrez C:\nginx\conf\nginx.conf dans un éditeur de texte

Si vous souhaitez rendre Open WebUI accessible via votre réseau local (LAN), assurez-vous de noter votre adresse IP LAN en utilisant ipconfig, par exemple 192.168.1.15

Configurez-le comme suit :

#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;

    # nécessaire pour gérer correctement les websockets (streaming)
    map $http_upgrade $connection_upgrade {
        default upgrade;
              close;
    }

    # Redirige tout le trafic HTTP vers HTTPS
    server {
        listen 80;
        server_name 192.168.1.15;

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

    # Gérer le trafic HTTPS
    server {
        listen 443 ssl;
        server_name 192.168.1.15;

        # Paramètres SSL (assurez-vous que les chemins sont corrects)
        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;

        # Paramètres de proxy vers votre service local
        location / {
            # proxy_pass doit pointer vers votre version localhost en cours d'exécution d'open-webui
            proxy_pass http://localhost:8080;

            # Ajouter la prise en charge des WebSocket (Nécessaire pour la version 0.5.0 et ultérieures)
            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;

            # (Optionnel) Désactiver le buffering du proxy pour une meilleure réponse streaming des modèles
            proxy_buffering off;

            # (Optionnel) Augmenter la taille maximale des requêtes pour les pièces jointes volumineuses et les messages audio longs
            client_max_body_size 20M;
            proxy_read_timeout 10m;
        }
    }

}

Enregistrez le fichier, et vérifiez que la configuration ne contient pas d'erreurs ou de problèmes de syntaxe en exécutant nginx -t. Vous devrez peut-être faire cd C:\nginx en premier, selon comment vous l'avez installé

Exécutez nginx en lançant la commande nginx. Si un service nginx est déjà démarré, vous pouvez recharger la nouvelle configuration en exécutant nginx -s reload

---

Vous devriez maintenant pouvoir accéder à Open WebUI sur https://192.168.1.15 (ou votre propre IP LAN selon le cas). Assurez-vous de permettre l'accès au pare-feu Windows si nécessaire.

Prochaines étapes

Après avoir configuré HTTPS, accédez à Open WebUI en toute sécurité à l'adresse suivante :

• https://localhost

Assurez-vous que vos enregistrements DNS sont correctement configurés si vous utilisez un nom de domaine. Pour les environnements de production, il est recommandé d'utiliser Lets Encrypt pour des certificats SSL fiables.

---