aviso

Este tutorial é uma contribuição da comunidade e não é suportado pela equipe Nullcore. Serve apenas como uma demonstração sobre como personalizar o Nullcore para o seu caso de uso específico. Quer contribuir? Confira o tutorial contribuinte.

Https usando nginx

Garantir a comunicação segura entre seus usuários e o webui aberto é fundamental. HTTPS (Protocolo de transferência de hipertexto seguro) criptografa os dados transmitidos, protegendo -os de espionadoras e adulteração. Ao configurar o NGINX como um proxy reverso, você pode adicionar perfeitamente HTTPS à sua implantação aberta do WebUI, aumentando a segurança e a confiabilidade.

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

Certificados autoassinados: Ideal para desenvolvimento e uso interno, usando o Docker.
Vamos criptografar: Perfeito para ambientes de produção que requerem certificados SSL confiáveis, usando o Docker.
Windows+autoassinado: Instruções simplificadas para desenvolvimento e uso interno no Windows, não é necessário docker.

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

Gerenciador de proxy nginx
Vamos criptografar
Auto-inscrito
Windows

Gerenciador de proxy nginx

O NGINX Proxy Manager (NPM) permite gerenciar facilmente proxies reversos e proteger seus aplicativos locais, como o Nullcore, com certificados SSL válidos da Let's Encrypt. Essa configuração permite o acesso HTTPS, necessário para o uso de recursos de entrada de voz em muitos navegadores móveis devido aos seus requisitos de segurança, sem expor a porta específica do aplicativo diretamente à Internet.

Pré -requisitos

Um servidor doméstico executando o Docker e o contêiner de webui aberto em execução.
Um nome de domínio (opções gratuitas como puckdns ou pagas como namecheap/godaddy).
Conhecimento básico da configuração Docker e DNS.

Passos

Crie diretórios para arquivos nginx:
```
mkdir ~/nginx_config
cd ~/nginx_config
```
Configure o NGINX Proxy Manager com o Docker:
```
Nano Docker-compose.yml
```

serviços
  App
    imagem 'JC21/nginx-proxy-manager: mais recente'
    reiniciara menos queparou
    portas
       '80: 80 '
       '81: 81 '
       '443: 443'
    volumes
      ./dados/dados
      ./TetSencrypt/etc/letsencrypt

Execute o contêiner:

Docker -Compor Up -d

Configure DNS e Domain:
- 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 o DuckDNS, obtenha um token da API no painel.

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

Configurar certificados SSL:

Access Nginx Proxy Manager em http: // server_ip: 81. Por exemplo:192.168.0.6:81
Faça login com as credenciais padrão (admin@example.com/ changeMe). Mude -os conforme solicitado.
Vá para Certificados SSL → Adicionar Certificado SSL → Vamos Encrypt.
Escreva seu e -mail e nome de domínio que você obteve do DuckDNS. Um nome de domínio contém um asterisco e outro não. Exemplo:*.hello.duckdns.orgehello.duckdns.org
Selecione Use um desafio DNS, escolha DuckDNS e cole seu token da API. exemplo:dns_duckdns_token=f4e2a1b9-c78d-e593-b0d7-67f2e1c9a5b8
Concorde em deixar os termos e salvar. Alterar o tempo de propagaçãose necessário(120 segundos).

Crie hosts proxy:

Para cada serviço (por exemplo, nullcore, NextCloud), vá para hosts → hosts proxy → Adicionar host proxy.
Preencha o nome de domínio (por exemplo, nullcore.hello.duckdns.org).
Defina o esquema como http (padrão), habiliteWebsockets supportE aponte para o seu Docker IP (se o Docker com o Open-Webui estiver sendo executado no mesmo computador que o NGINX Manager, este será o mesmo IP do anterior (exemplo:192.168.0.6
Selecione o certificado SSL gerado anteriormente, Force SSL e Ativar HTTP/2.

Adicione seu URL ao webui aberto (caso contrário, obtendo erro https):

Vá para o seu painel de administração da Webui → Admin → Configurações → Geral
NoWebhook URLCampo de texto, digite seu URL através do qual você se conectará ao seu webui aberto via proxy reverso nginx. Exemplo:hello.duckdns.org(não essencial com este) ounullcore.hello.duckdns.org(essencial com este).

Acesse o webui:

Acesse abrir webui via https em qualquerhello.duckdns.orgounullcore.hello.duckdns.org(da maneira que você o configura).

Firewall Nota: Esteja ciente de que o software local do firewall (como o Portmaster) pode bloquear o tráfego de rede interno do docker ou as portas necessárias. Se você tiver problemas, verifique suas regras de firewall para garantir que a comunicação necessária para esta configuração seja permitida.

Vamos criptografar

O Let's Encrypt fornece certificados SSL gratuitos confiáveis pela maioria dos navegadores, ideais para ambientes de produção.

Pré -requisitos

CertBotinstalado no seu sistema.
O DNS registra corretamente configurado para apontar para o seu servidor.

Passos

Crie diretórios para arquivos nginx:
```
mkdir -p conf.d ssl
```

Crie Arquivo de Configuração Nginx:

conf.d/open-webui.conf

servidor {
Ouça 80;
server_name your_domain_or_ip;

Localização / {
proxy_pass http: //host.docker.internal: 3000;

# Adicionar suporte WebSocket (necessário para a versão 0.5.0 ou mais)
proxy_http_version 1.1;
Atualização proxy_set_header $ 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 para $ proxy_add_x_forwarded_for;
proxy_set_header x forwarded-proto $ esquema;

# (Opcional) Desative o buffer de proxy para obter uma melhor resposta de streaming de modelos
proxy_buffering off;

# (Opcional) Aumente o tamanho máximo da solicitação para acessórios grandes e mensagens de áudio longas
client_max_body_size 20m;
proxy_read_timeout 10m;

Simplificado Let's Encrypt Script:

enable_letsencrypt.sh

#!/bin/bash

# Descrição: Script simplificado para obter e instalar os certificados Let's Encrypt SSL usando o CERTBOT.

Domain = "your_domain_or_ip"
Email = "your_email@example.com"

# Instale o certbot se não estiver instalado
se ! comando -v certbot &> /dev /null; então
eco "certbot não encontrado. Instalando ..."
Atualização de sudo apt-get
sudo apt-get install -y certbot python3-certbot-nginx
fi

# Obtenha o certificado SSL
sudo certbot - -nginx -d "$ domain" -Non Interactive --Agree -tos -m "$ email"

# Recarregue o nginx para aplicar alterações
sudo systemctl recarregar nginx

Echo "Vamos Certificado SSL do Let's Encrypt foi instalado e Nginx Reloaded".

Faça o script executável:

chmod +x enable_letsEncrypt.sh

Atualizar Docker Compose Configuration:

Adicione o serviço Nginx ao seudocker-compose.yml

serviços
  nginx
    imagemnginxalpino
    portas
       "80:80"
       "443: 443"
    volumes
      ./conf.d/etc/nginx/conf.d
      ./SSL/etc/nginx/ssl
    depende_on
      abrirwebui

Inicie o serviço nginx:
```
Docker compõe -se -d nginx
```
Execute o script Let's Crypt:

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

Acesse o webui

Acesse o Nullcore via HTTPS em:

https: // your_domain_or_ip

Certificado autoassinado

O uso de 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 nginx:
```
mkdir -p conf.d ssl
```

Crie Arquivo de Configuração Nginx:

conf.d/open-webui.conf

servidor {
Ouça 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;

Localização / {
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 para $ proxy_add_x_forwarded_for;
proxy_set_header x forwarded-proto $ esquema;

# (Opcional) Desative o buffer de proxy para obter uma melhor resposta de streaming de modelos
proxy_buffering off;

# (Opcional) Aumente o tamanho máximo da solicitação para acessórios 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 = your_domain_or_ip"

Atualizar Docker Compose Configuration:

Adicione o serviço Nginx ao seudocker-compose.yml

serviços
  nginx
    imagemnginxalpino
    portas
       "443: 443"
    volumes
      ./conf.d/etc/nginx/conf.d
      ./SSL/etc/nginx/ssl
    depende_on
      abrirwebui

Inicie o serviço nginx:
```
Docker compõe -se -d nginx
```

Acesse o webui

Acesse o Nullcore via HTTPS em:

https: // your_domain_or_ip

Usando um certificado autoassinado e nginx no Windows sem Docker

Para instalações básicas internas/de desenvolvimento, você pode usar o NGINX e um certificado autoassinado para proxy abrir webui para https, permitindo o uso de recursos como entrada de microfone na LAN. (Por padrão, a maioria dos navegadores não permitirá a entrada de microfone nos URLs inseguros que não sejam do local)

Este guia pressupõe que você instalou o Nullcore usando o PIP e está executandoopen-webui serve

Etapa 1: Instalando o OpenSSL para geração de certificação

Você primeiro precisará instalar o OpenSSL

Você pode baixar e instalar binários pré -compilados doProduções leves brilhantes (SLP)site.

Alternativamente, se você tiverChocolateyInstalado, você pode usá -lo para instalar o OpenSSL rapidamente:

Abra um prompt de comando ou PowerShell.
Execute o seguinte comando para instalar o OpenSSL:
```
Choco Instale OpenSSL -y
```

Verifique a instalação

Após a instalação, abra um prompt de comando e digite:

Versão OpenSSL

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

Etapa 2: Instalando o nginx

Baixe o Nginx oficial para Windows denginx.orgOu use um gerente de pacotes como o Chocolatey. Extraia o arquivo zip baixado para um diretório (por exemplo, C: \ nginx).

Etapa 3: Gere Certificado

Execute o seguinte comando:

Openssl req -x509 -Nodes -Days 365 -NewKey RSA: 2048 -Keyout nginx.key -out nginx.crt

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

Etapa 4: Configurar Nginx

Aberto c: \ nginx \ conf \ nginx.conf em um editor de texto

Se você deseja que o Nullcore seja acessível em sua LAN local, não deixe de observar seu endereço IP da LAN usandoipconfigpor exemplo 192.168.1.15

Configure o seguinte:

#user ninguém;
trabalhador_processos 1;

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

#pid logs/nginx.pid;

Eventos {
trabalhador_connections 1024;


http {
incluir mime.types;
default_type Application/Octet-Stream;

#log_format main '$ remote_addr - $ remote_user [$ time_local] "$ solicitação"'
# '$ status $ body_bytes_sent "$ http_referer"'
# '"$ http_user_agent" "$ http_x_forwarded_for"';

#access_log logs/access.log main;

sendfile on;
#tcp_nopush ligado;

#keepalive_timeout 0;
keepalive_timeout 120;

#gzip em;

# necessário para lidar adequadamente com os websockets (streaming)
mapa $ http_upgrade $ connection_upgrade {
atualização padrão;
''      fechar;


# Redirecionar todo o tráfego HTTP para HTTPS
servidor {
Ouça 80;
server_name 192.168.1.15;

retornar 301 https: // $ host $ request_uri;


# Lide com tráfego HTTPS
servidor {
Ouça 443 SSL;
server_name 192.168.1.15;

# Configurações SSL (verifique se os caminhos estão corretos)
ssl_cetificate c: \\ nginx \\ nginx.crt;
ssl_certificate_key c: \\ nginx \\ nginx.key;
ssl_protocols tlsv1.2 tlsv1.3;
SSL_CIPHERS ECDHE-ECDSA-CACHA20-POLY1305: ECDHE-RSA-CACHA20-POLY1305: ECDHE-ECDSA-AES128-GCM-SHA256: ECDHE-RSA-AES128-GCM-SHA256;
ssl_prefer_server_ciphers on;

# OCSP grampeando
#SSL_Stapling ON;
#SSL_STAPLING_VERIFY ON;

# Configurações de proxy para o seu serviço local
Localização / {
# proxy_pass deve apontar para a sua versão de localhost em execução do Open-Webui
proxy_pass http: // localhost: 8080;

# Adicionar suporte WebSocket (necessário para a versão 0.5.0 ou mais)
proxy_http_version 1.1;
Atualização proxy_set_header $ http_upgrade;
proxy_set_header conexão $ conexão_upgrade;

proxy_set_header host $ host;
proxy_set_header x-real-ip $ remote_addr;
proxy_set_header x forwarded para $ proxy_add_x_forwarded_for;
proxy_set_header x forwarded-proto $ esquema;

# (Opcional) Desative o buffer de proxy para obter uma melhor resposta de streaming de modelos
proxy_buffering off;

# (Opcional) Aumente o tamanho máximo da solicitação para acessórios 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 tem erros ou problemas de sintaxe executandonginx -t. Você pode precisarcd C:\nginxprimeiro, dependendo de como você o instalou

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

Agora você deve poder acessar o Nullcorehttps://192.168.1.15(ou seu próprio IP LAN conforme apropriado). Certifique -se de permitir o acesso do Windows Firewall conforme necessário.

PRÓXIMOS PASSOS

Depois de configurar o HTTPS, acesse o Nullcore com segurança em:

https: // localhost

Verifique se os registros do DNS estão configurados corretamente se você estiver usando um nome de domínio. Para ambientes de produção, é recomendável usar o Let's Crypt para certificados SSL confiáveis.