atenção

Este tutorial é uma contribuição da comunidade e não é suportado pela equipe do Open WebUI. Ele serve apenas como uma demonstração de como customizar o Open WebUI para seu caso de uso específico. Quer contribuir? Confira o tutorial de contribuição.

HTTPS usando Nginx

Garantir uma comunicação segura entre seus usuários e o Open WebUI é fundamental. O HTTPS (HyperText Transfer Protocol Secure) criptografa os dados transmitidos, protegendo-os contra espionagem e adulteração. Ao configurar o Nginx como proxy reverso, você pode adicionar HTTPS à sua implantação do Open WebUI, melhorando tanto a segurança quanto a confiabilidade.

Este guia fornece três métodos para configurar o HTTPS:

Certificados Autofirmados: Ideal para desenvolvimento e uso interno, utilizando docker.
Lets Encrypt: Perfeito para ambientes de produção que exigem certificados SSL confiáveis, utilizando docker.
Windows+Autofirmado: Instruções simplificadas para desenvolvimento e uso interno no Windows, sem necessidade de docker.

Escolha o método que melhor atenda às suas necessidades de implantação.

Gerenciador de Proxy Nginx
Lets Encrypt
Autofirmado
Windows

Nginx Proxy Manager

O Nginx Proxy Manager (NPM) permite gerenciar facilmente proxies reversos e proteger suas aplicações locais, como o Open WebUI, com certificados SSL válidos da Lets Encrypt. Essa configuração habilita acesso HTTPS, necessário para utilizar recursos de entrada por voz em muitos navegadores móveis devido às exigências de segurança, sem expor diretamente a porta específica da aplicação para a internet.

Pré-requisitos

Um servidor doméstico executando Docker e o contêiner do open-webui em execução.
Um nome de domínio (opções gratuitas como DuckDNS ou pagas como Namecheap/GoDaddy).
Conhecimento básico de Docker e configuração de DNS.

Etapas

Criar diretórios para os arquivos do Nginx:
```
mkdir ~/nginx_config
cd ~/nginx_config
```
Configurar o Nginx Proxy Manager com o 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

Execute o contêiner:

docker-compose up -d

Configurar DNS e domínio:
- Faça login no seu provedor de domínio (por exemplo, DuckDNS) e crie um domínio.
- Aponte o domínio para o IP local do seu proxy (por exemplo, 192.168.0.6).
- Se estiver usando DuckDNS, obtenha um token de API no painel deles.

Aqui está um exemplo simples de como isso é feito em https://www.duckdns.org/domains :

Configurar certificados SSL:

Acesse o Nginx Proxy Manager em http://server_ip:81. Por exemplo: 192.168.0.6:81
Faça login com as credenciais padrão ([email protected] / changeme). Altere-as quando solicitado.
Vá para SSL Certificates → Add SSL Certificate → Lets Encrypt.
Insira seu e-mail e o nome de domínio obtido do DuckDNS. Um nome de domínio contém um asterisco e outro não. Exemplo: *.hello.duckdns.org e hello.duckdns.org.
Selecione Use a DNS challenge, escolha DuckDNS, e cole seu token de API. Exemplo: dns_duckdns_token=f4e2a1b9-c78d-e593-b0d7-67f2e1c9a5b8
Concorde com os termos da Let’s Encrypt e salve. Altere o tempo de propagação se necessário (120 segundos).

Criar hosts de proxy:

Para cada serviço (por exemplo, openwebui, nextcloud), vá para Hosts → Proxy Hosts → Add Proxy Host.
Preencha o nome do domínio (por exemplo, openwebui.hello.duckdns.org).
Configure o esquema para HTTP (padrão), habilite Websockets support e aponte para o IP do Docker (se o docker com o open-webui estiver sendo executado no mesmo computador que o gerenciador do NGINX, este será o mesmo IP anterior (exemplo: 192.168.0.6)).
Selecione o certificado SSL gerado anteriormente, force SSL, e habilite HTTP/2.

Adicione sua URL ao open-webui (caso contrário, aparecerá um erro de HTTPS):

Vá para seu open-webui → Painel de Administração → Configurações → Geral
No campo de texto Webhook URL, insira sua URL através da qual você conectará ao open-webui via Nginx reverse proxy. Exemplo: hello.duckdns.org (não essencial com este) ou openwebui.hello.duckdns.org (essencial com este).

Acessar o WebUI:

Acesse o Open WebUI via HTTPS em hello.duckdns.org ou openwebui.hello.duckdns.org (dependendo de como foi configurado).

Nota sobre firewall: Esteja ciente de que o software local de firewall (como Portmaster) pode bloquear o tráfego de rede interna Docker ou as portas necessárias. Se houver problemas, verifique as regras do seu firewall para garantir que a comunicação necessária para esta configuração esteja permitida.

Lets Encrypt

Lets Encrypt fornece certificados SSL gratuitos confiáveis pela maioria dos navegadores, ideal para ambientes de produção.

Pré-requisitos

Certbot instalado no seu sistema.
Registros DNS configurados corretamente para apontar para o seu servidor.

Etapas

Crie Diretórios para Arquivos do Nginx:
```
mkdir -p conf.d ssl
```

Crie o Arquivo de Configuração do Nginx:

conf.d/open-webui.conf:

server {
    listen 80;
    server_name seu_dominio_ou_IP;

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

        # Adicionar suporte para WebSocket (Necessário para a versão 0.5.0 e superiores)
        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) Desativar o buffer do proxy para melhor resposta de streaming dos modelos
        proxy_buffering off;

        # (Opcional) Aumentar o tamanho máximo da solicitação para anexos grandes e mensagens de áudio longas
        client_max_body_size 20M;
        proxy_read_timeout 10m;
    }
}

Script Simplificado do Lets Encrypt:

enable_letsencrypt.sh:

#!/bin/bash

# Descrição: Script simplificado para obter e instalar certificados SSL Lets Encrypt usando o Certbot.

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

# Instalar Certbot se não estiver instalado
if ! command -v certbot &> /dev/null; then
    echo "Certbot não encontrado. Instalando..."
    sudo apt-get update
    sudo apt-get install -y certbot python3-certbot-nginx
fi

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

# Recarregar Nginx para aplicar mudanças
sudo systemctl reload nginx

echo "O certificado SSL Lets Encrypt foi instalado e o Nginx recarregado."

Tornar o script executável:

chmod +x enable_letsencrypt.sh

Atualize a Configuração do Docker Compose:

Adicione o serviço Nginx ao seu 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

Inicie o Serviço Nginx:
```
docker compose up -d nginx
```
Execute o Script do Lets Encrypt:

Execute o script para obter e instalar o certificado SSL:
```
./enable_letsencrypt.sh
```

Acesse o WebUI

Acesse o Open WebUI via HTTPS em:

https://seu_dominio_ou_IP

Certificado Autoassinado

Usar certificados autoassinados é adequado para desenvolvimento ou uso interno onde a confiança não é uma preocupação crítica.

Passos

Crie Diretórios para Arquivos do Nginx:
```
mkdir -p conf.d ssl
```

Crie o Arquivo de Configuração do Nginx:

conf.d/open-webui.conf:

server {
    listen 443 ssl;
    server_name seu_dominio_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;

        # (Opcional) Desativar buffering do proxy para melhor transmissão de respostas dos modelos
        proxy_buffering off;

        # (Opcional) Aumentar o tamanho máximo da solicitação para anexos grandes e mensagens de áudio longas
        client_max_body_size 20M;
        proxy_read_timeout 10m;
    }
}

Gerar Certificados SSL Autoassinados:

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

Atualizar Configuração do Docker Compose:

Adicione o serviço Nginx ao seu 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

Iniciar o Serviço Nginx:
```
docker compose up -d nginx
```

Acessar a WebUI

Acesse o Open WebUI via HTTPS em:

https://seu_dominio_ou_IP

Utilizando um Certificado Autoassinado e Nginx no Windows sem Docker

Para instalações internas/de desenvolvimento básicas, você pode usar o nginx e um certificado autoassinado para redirecionar o Open WebUI para https, permitindo o uso de recursos como entrada de microfone em uma rede LAN. (Por padrão, a maioria dos navegadores não permitirá entrada de microfone em URLs inseguras que não sejam localhost)

Este guia assume que você instalou o Open WebUI usando pip e está executando open-webui serve

Passo 1: Instalando openssl para geração de certificado

Primeiro você precisará instalar o openssl

Você pode baixar e instalar binários pré-compilados do site Shining Light Productions (SLP).

Alternativamente, se você tiver Chocolatey instalado, pode utilizá-lo para instalar o OpenSSL rapidamente:

Abra o Prompt de Comando ou PowerShell.
Execute o seguinte comando para instalar o OpenSSL:
```
choco install openssl -y
```

Verificar Instalação

Após a instalação, abra um Prompt de Comando e digite:

openssl version

Se exibir a versão do OpenSSL (por exemplo, OpenSSL 3.x.x ...), ele foi instalado corretamente.

Passo 2: Instalando nginx

Baixe o Nginx oficial para Windows de nginx.org ou use um gerenciador de pacotes como Chocolatey. Extraia o arquivo ZIP baixado para um diretório (ex.: C:\nginx).

Passo 3: Gerar certificado

Execute o seguinte comando:

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

Mova os arquivos nginx.key e nginx.crt gerados para uma pasta de sua escolha, ou para o diretório C:\nginx

Passo 4: Configurar nginx

Abra o arquivo C:\nginx\conf\nginx.conf em um editor de texto

Se você quiser que o Open WebUI seja acessível pela sua LAN local, certifique-se de anotar o endereço IP da sua LAN usando ipconfig, por exemplo, 192.168.1.15

Configure conforme segue:

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

    # necessário para lidar corretamente com websockets (transmissão)
    map $http_upgrade $connection_upgrade {
        default upgrade;
              close;
    }

    # Redirecionar todo o tráfego HTTP para HTTPS
    server {
        listen 80;
        server_name 192.168.1.15;

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

    # Lidar com tráfego HTTPS
    server {
        listen 443 ssl;
        server_name 192.168.1.15;

        # Configurações SSL (certifique-se de que os caminhos estão corretos)
        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;

        # Configuração de proxy para o serviço local
        location / {
            # proxy_pass deve apontar para sua versão localhost em execução do open-webui
            proxy_pass http://localhost:8080;

            # Adicionar suporte ao WebSocket (Necessário para versão 0.5.0 e superior)
            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) Desabilitar o buffer de proxy para melhor resposta de streaming dos modelos
            proxy_buffering off;

            # (Opcional) Aumentar o tamanho máximo de requisição para anexos grandes e mensagens de áudio longas
            client_max_body_size 20M;
            proxy_read_timeout 10m;
        }
    }

}

Salve o arquivo e verifique se a configuração não possui erros ou problemas de sintaxe executando nginx -t. Você pode precisar executar cd C:\nginx primeiro, dependendo de como você o instalou.

Execute o nginx executando nginx. Se um serviço nginx já estiver iniciado, você pode recarregar a nova configuração executando nginx -s reload

Agora você deve conseguir acessar o Open WebUI em https://192.168.1.15 (ou no endereço IP de sua LAN conforme apropriado). Certifique-se de permitir acesso no firewall do Windows conforme necessário.

Próximos Passos

Após configurar o HTTPS, acesse o Open WebUI com segurança em:

https://localhost

Certifique-se de que seus registros DNS estão corretamente configurados se você estiver usando um nome de domínio. Para ambientes de produção, é recomendado usar o Lets Encrypt para obter certificados SSL confiáveis.

Nginx Proxy Manager​

Pré-requisitos​

Etapas​

Aqui está um exemplo simples de como isso é feito em https://www.duckdns.org/domains :​

Acessar o WebUI:​

Lets Encrypt​

Pré-requisitos​

Etapas​

Acesse o WebUI​

Certificado Autoassinado​

Passos​

Acessar a WebUI​

Utilizando um Certificado Autoassinado e Nginx no Windows sem Docker​

Passo 1: Instalando openssl para geração de certificado​

Verificar Instalação​

Passo 2: Instalando nginx​

Passo 3: Gerar certificado​

Passo 4: Configurar nginx​

Próximos Passos​

Nginx Proxy Manager

Pré-requisitos

Etapas

Aqui está um exemplo simples de como isso é feito em https://www.duckdns.org/domains :

Acessar o WebUI:

Lets Encrypt

Pré-requisitos

Etapas

Acesse o WebUI

Certificado Autoassinado

Passos

Acessar a WebUI

Utilizando um Certificado Autoassinado e Nginx no Windows sem Docker

Passo 1: Instalando openssl para geração de certificado

Verificar Instalação

Passo 2: Instalando nginx

Passo 3: Gerar certificado

Passo 4: Configurar nginx

Próximos Passos