aviso

Este tutorial es una contribución de la comunidad y no está respaldado por el equipo de Open WebUI. Solo sirve como una demostración de cómo personalizar Open WebUI para su caso de uso específico. ¿Quieres contribuir? Revisa el tutorial de contribución.

HTTPS usando Nginx

Asegurar una comunicación segura entre tus usuarios y Open WebUI es primordial. HTTPS (Protocolo seguro de transferencia de hipertexto) cifra los datos transmitidos, protegiéndolos de espías e intervenciones. Configurando Nginx como proxy inverso, puedes agregar HTTPS de manera sencilla a tu implementación de Open WebUI, mejorando tanto la seguridad como la confianza.

Esta guía proporciona tres métodos para configurar HTTPS:

• Certificados autofirmados: Ideal para desarrollo y uso interno, utilizando Docker.
• Lets Encrypt: Perfecto para entornos de producción que requieren certificados SSL confiables, utilizando Docker.
• Windows+Autofirmados: Instrucciones simplificadas para desarrollo y uso interno en Windows, no se requiere Docker.

Elige el método que mejor se adapte a tus necesidades de implementación.

Nginx Proxy Manager

Nginx Proxy Manager

Nginx Proxy Manager (NPM) te permite gestionar fácilmente proxies inversos y proteger tus aplicaciones locales, como Open WebUI, con certificados SSL válidos de Lets Encrypt. Esta configuración habilita el acceso HTTPS, que es necesario para utilizar funciones de entrada por voz en muchos navegadores móviles debido a sus requisitos de seguridad, sin exponer directamente el puerto específico de la aplicación a internet.

Requisitos previos

• Un servidor doméstico que ejecute Docker y el contenedor de open-webui en funcionamiento.
• Un nombre de dominio (opciones gratuitas como DuckDNS o opciones de pago como Namecheap/GoDaddy).
• Conocimiento básico de configuración de Docker y DNS.

Pasos

1. Crear directorios para archivos de Nginx:

   mkdir ~/nginx_config
   cd ~/nginx_config

2. Configurar Nginx Proxy Manager con 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

Ejecuta el contenedor:

docker-compose up -d

3. Configurar DNS y dominio:

   • Inicia sesión en tu proveedor de dominio (por ejemplo, DuckDNS) y crea un dominio.
   • Asigna el dominio a la IP local de tu proxy (por ejemplo, 192.168.0.6).
   • Si usas DuckDNS, obtén un token API desde su panel de control.

Aquí hay un ejemplo simple de cómo se hace en https://www.duckdns.org/domains :

4. Configurar los certificados SSL:

• Accede a Nginx Proxy Manager en http://server_ip:81. Por ejemplo: 192.168.0.6:81
• Inicia sesión con las credenciales predeterminadas ([email protected] / changeme). Cambia las credenciales según se solicite.
• Ve a SSL Certificates → Add SSL Certificate → Lets Encrypt.
• Ingresa tu correo electrónico y el nombre de dominio que obtuviste de DuckDNS. Un nombre de dominio contiene un asterisco y otro no. Ejemplo: *.hello.duckdns.org y hello.duckdns.org.
• Selecciona Usar un desafío DNS, elige DuckDNS y pega tu token API. Ejemplo: dns_duckdns_token=f4e2a1b9-c78d-e593-b0d7-67f2e1c9a5b8
• Acepta los términos de Let’s Encrypt y guarda. Cambia el tiempo de propagación si es necesario (120 segundos).

5. Crear Hosts de Proxy:

• Para cada servicio (por ejemplo, openwebui, nextcloud), ve a Hosts → Proxy Hosts → Add Proxy Host.
• Completa el nombre de dominio (por ejemplo, openwebui.hello.duckdns.org).
• Configura el esquema como HTTP (predeterminado), activa Websockets support y apunta a tu IP de Docker (si Docker con open-webui está ejecutándose en el mismo ordenador que el administrador de NGINX, esta será la misma IP que antes: 192.168.0.6).
• Selecciona el certificado SSL generado anteriormente, forza SSL y activa HTTP/2.

6. Añade tu URL a open-webui (de lo contrario tendrás un error HTTPS):

• Ve a tu open-webui → Admin Panel → Settings → General
• En el campo de texto de Webhook URL, ingresa tu URL a través de la cual te conectarás a tu open-webui mediante el proxy inverso de Nginx. Ejemplo: hello.duckdns.org (no esencial en este caso) o openwebui.hello.duckdns.org (esencial en este caso).

Acceder a la WebUI:

Accede a Open WebUI vía HTTPS en hello.duckdns.org o openwebui.hello.duckdns.org (según cómo lo hayas configurado).

Nota sobre el firewall: Ten en cuenta que el software de firewall local (como Portmaster) podría bloquear el tráfico de la red interna de Docker o los puertos requeridos. Si experimentas problemas, verifica las reglas de tu firewall para asegurarte de que se permita la comunicación necesaria para esta configuración.

Lets Encrypt

Lets Encrypt

Lets Encrypt ofrece certificados SSL gratuitos confiables por la mayoría de los navegadores, ideales para entornos de producción.

Requisitos previos

• Certbot instalado en tu sistema.
• Registros DNS configurados correctamente para apuntar a tu servidor.

Pasos

1. Crear directorios para los archivos de Nginx:

   mkdir -p conf.d ssl

2. Crear archivo de configuración de Nginx:

   conf.d/open-webui.conf:

   server {
       listen 80;
       server_name tu_dominio_o_IP;
   
       location / {
           proxy_pass http://host.docker.internal:3000;
   
           # Agregar soporte para WebSocket (Necesario para la versión 0.5.0 en adelante)
           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;
   
           # (Opcional) Desactivar almacenamiento en caché de proxy para una mejor respuesta de flujo de modelos
           proxy_buffering off;
   
           # (Opcional) Aumentar el tamaño máximo de solicitud para archivos adjuntos grandes y mensajes de audio largos
           client_max_body_size 20M;
           proxy_read_timeout 10m;
       }
   }

3. Script simplificado de Lets Encrypt:

   enable_letsencrypt.sh:

   #!/bin/bash
   
   # Descripción: Script simplificado para obtener e instalar certificados SSL de Lets Encrypt utilizando Certbot.
   
   DOMAIN="tu_dominio_o_IP"
   EMAIL="[email protected]"
   
   # Instalar Certbot si no está instalado
   if ! command -v certbot &> /dev/null; then
       echo "Certbot no encontrado. Instalando..."
       sudo apt-get update
       sudo apt-get install -y certbot python3-certbot-nginx
   fi
   
   # Obtener el certificado SSL
   sudo certbot --nginx -d "$DOMAIN" --non-interactive --agree-tos -m "$EMAIL"
   
   # Recargar Nginx para aplicar los cambios
   sudo systemctl reload nginx
   
   echo "El certificado SSL de Lets Encrypt ha sido instalado y Nginx recargado."

   Haz que el script sea ejecutable:

   chmod +x enable_letsencrypt.sh

4. Actualizar configuración de Docker Compose:

   Agrega el servicio Nginx a tu 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. Iniciar el servicio Nginx:

   docker compose up -d nginx

6. Ejecutar el script de Lets Encrypt:

   Ejecuta el script para obtener e instalar el certificado SSL:

   ./enable_letsencrypt.sh

Acceder a la WebUI

Accede a Open WebUI mediante HTTPS en:

https://tu_dominio_o_IP

Certificados autofirmados

Certificado Auto-firmado

El uso de certificados auto-firmados es adecuado para desarrollo o uso interno donde la confianza no sea una preocupación crítica.

Pasos

1. Crear Directorios para Archivos de Nginx:

   mkdir -p conf.d ssl

2. Crear Archivo de Configuración de Nginx:

   conf.d/open-webui.conf:

   server {
       listen 443 ssl;
       server_name tu_dominio_o_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;
   
           # (Opcional) Desactivar el almacenamiento en búfer del proxy para mejor respuesta de transmisión desde los modelos
           proxy_buffering off;
   
           # (Opcional) Aumentar el tamaño máximo de solicitud para archivos adjuntos grandes y mensajes de audio largos
           client_max_body_size 20M;
           proxy_read_timeout 10m;
       }
   }

3. Generar Certificados SSL Auto-Firmados:

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

4. Actualizar Configuración de Docker Compose:

   Agrega el servicio Nginx a tu 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. Iniciar el Servicio Nginx:

   docker compose up -d nginx

Acceder a la WebUI

Accede a Open WebUI vía HTTPS en:

https://tu_dominio_o_IP

---

Windows

Uso de un certificado autofirmado y Nginx en Windows sin Docker

Para instalaciones internas/de desarrollo básicas, puede usar nginx y un certificado autofirmado para hacer proxy de Open WebUI a https, permitiendo el uso de funciones como entrada de micrófono a través de LAN. (Por defecto, la mayoría de los navegadores no permitirán la entrada de micrófono en URLs inseguras que no sean localhost)

Esta guía asume que instaló Open WebUI usando pip y que está ejecutando open-webui serve

Paso 1: Instalación de openssl para la generación de certificados

Primero, deberá instalar openssl

Puede descargar e instalar binarios precompilados desde el sitio web de Shining Light Productions (SLP).

Alternativamente, si tiene instalado Chocolatey, puede usarlo para instalar OpenSSL rápidamente:

1. Abra un símbolo del sistema o PowerShell.
2. Ejecute el siguiente comando para instalar OpenSSL:

   choco install openssl -y

---

Verificar la instalación

Después de la instalación, abra un símbolo del sistema y escriba:

openssl version

Si muestra la versión de OpenSSL (por ejemplo, OpenSSL 3.x.x ...), entonces está instalado correctamente.

Paso 2: Instalación de nginx

Descargue la versión oficial de Nginx para Windows desde nginx.org o use un gestor de paquetes como Chocolatey. Extraiga el archivo ZIP descargado a un directorio (por ejemplo, C:\nginx).

Paso 3: Generar certificado

Ejecute el siguiente comando:

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

Mueva los archivos nginx.key y nginx.crt generados a una carpeta de su elección, o al directorio C:\nginx

Paso 4: Configurar nginx

Abra C:\nginx\conf\nginx.conf en un editor de texto

Si desea que Open WebUI sea accesible a través de su LAN local, asegúrese de anotar su dirección IP de LAN utilizando ipconfig, por ejemplo, 192.168.1.15

Configúrelo de la siguiente manera:

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

    # necesario para manejar adecuadamente websockets (streaming)
    map $http_upgrade $connection_upgrade {
        default upgrade;
              close;
    }

    # Redirigir todo el tráfico HTTP a HTTPS
    server {
        listen 80;
        server_name 192.168.1.15;

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

    # Manejar tráfico HTTPS
    server {
        listen 443 ssl;
        server_name 192.168.1.15;

        # Configuraciones SSL (asegúrese de que las rutas sean correctas)
        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;

        # Configuración de proxy a su servicio local
        location / {
            # proxy_pass debe apuntar a su versión local en ejecución de open-webui
            proxy_pass http://localhost:8080;

            # Agregar soporte para WebSocket (Necesario para la versión 0.5.0 en adelante)
            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;

            # (Opcional) Deshabilitar el almacenamiento en búfer del proxy para una mejor respuesta en streaming desde los modelos
            proxy_buffering off;

            # (Opcional) Aumentar el tamaño máximo de solicitud para archivos adjuntos grandes y mensajes de audio largos
            client_max_body_size 20M;
            proxy_read_timeout 10m;
        }
    }

}

Guarde el archivo y compruebe que la configuración no tiene errores o problemas de sintaxis ejecutando nginx -t. Puede que necesite ejecutar cd C:\nginx primero dependiendo de cómo lo haya instalado

Ejecute nginx ejecutando nginx. Si ya hay un servicio nginx iniciado, puede recargar la nueva configuración ejecutando nginx -s reload

---

Ahora debería poder acceder a Open WebUI en https://192.168.1.15 (o su propia dirección IP LAN según corresponda). Asegúrese de permitir el acceso al firewall de Windows según sea necesario.

Próximos pasos

Después de configurar HTTPS, accede a Open WebUI de forma segura en:

• https://localhost

Asegúrate de que los registros DNS estén configurados correctamente si estás usando un nombre de dominio. Para entornos de producción, se recomienda usar Lets Encrypt para certificados SSL confiables.

---