---
title: Gpt custom
description: 
published: true
date: 2026-07-24T23:21:58.427Z
tags: 
editor: markdown
dateCreated: 2026-07-24T23:21:58.427Z
---

# GPT Custom: Guia Final de Instalacao no LXC Proxmox

Este guia instala e publica a aplicacao que esta nesta pasta. O projeto inclui:

- login individual com sessoes salvas no PostgreSQL;
- cadastro publico opcional;
- historico de conversas;
- upload privado de PDF, TXT, CSV, DOCX, PNG e JPEG;
- uso de arquivos nas perguntas enviadas a OpenAI;
- registro de tokens e custo estimado por usuario;
- limite mensal individual;
- painel administrativo;
- Nginx, HTTPS, PM2 e scripts de backup.

> A assinatura do ChatGPT nao inclui creditos da OpenAI API. Esta aplicacao usa uma chave da API e a cobranca ocorre na conta da plataforma OpenAI.

## 1. Arquitetura

```text
Navegador
   |
   | HTTPS
   v
Nginx no LXC
   |
   v
Next.js 16 + React 19
   |-- autenticacao e sessoes
   |-- chat e historico
   |-- upload privado
   |-- controle de limite
   |
   |-- PostgreSQL  -> usuarios, sessoes, conversas e consumo
   |-- Disco LXC   -> arquivos privados
   `-- OpenAI API  -> respostas e leitura de anexos
```

## 2. Requisitos

No Proxmox, crie um container com:

```text
Template: Debian 12 ou Ubuntu 24.04
CPU: 2 a 4 cores
RAM: 4 GB
Disco: 30 GB ou mais
Unprivileged container: sim
Start at boot: sim
Rede: IP fixo ou DHCP reservado
```

Tambem sera necessario:

- um dominio ou subdominio, por exemplo `gpt.seudominio.com`;
- redirecionamento das portas 80 e 443 para o LXC, se o acesso vier da internet;
- uma chave criada na plataforma OpenAI;
- saldo ou faturamento ativo na OpenAI API.

## 3. Conteudo da pasta

```text
gpt_custom/
|-- app/                         telas e APIs do Next.js
|-- components/                  componentes React
|-- lib/                         autenticacao, banco, OpenAI e custos
|-- prisma/
|   |-- schema.prisma            estrutura do banco
|   `-- migrations/              migration inicial
|-- deploy/
|   |-- ecosystem.config.cjs     configuracao do PM2
|   `-- nginx-gpt-custom.conf    configuracao do Nginx
|-- scripts/
|   |-- install-lxc.sh           prepara o LXC
|   |-- create-admin.ts          cria a conta administrativa
|   `-- backup.sh                backup do banco e uploads
|-- .env.example                 modelo das variaveis
|-- package.json                 dependencias e comandos
`-- GUIA-PASSO-A-PASSO.md        este documento
```

## 4. Entrar no LXC

Pelo host Proxmox:

```bash
pct enter ID_DO_CONTAINER
```

Ou por SSH:

```bash
ssh root@IP_DO_CONTAINER
```

## 5. Copiar o projeto para o LXC

Uma opcao e copiar por SCP a partir do computador que contem a pasta:

```bash
scp -r gpt_custom root@IP_DO_CONTAINER:/opt/
```

Outra opcao e manter o projeto em um repositorio Git privado:

```bash
git clone URL_DO_REPOSITORIO /opt/gpt_custom
```

Nao envie `.env`, chaves ou senhas para o Git.

## 6. Preparar o LXC

Entre na pasta e execute o instalador:

```bash
cd /opt/gpt_custom
chmod +x scripts/install-lxc.sh scripts/backup.sh
./scripts/install-lxc.sh
```

O script instala:

- Node.js 22;
- PostgreSQL;
- Nginx;
- Certbot;
- PM2;
- ferramentas de compilacao.

Confirme:

```bash
node -v
npm -v
psql --version
nginx -v
pm2 -v
```

## 7. Criar o banco PostgreSQL

Gere primeiro uma senha forte para o banco:

```bash
openssl rand -base64 32
```

Entre no PostgreSQL:

```bash
sudo -u postgres psql
```

Execute, substituindo a senha:

```sql
CREATE USER gpt_custom WITH ENCRYPTED PASSWORD 'SENHA_FORTE_DO_BANCO';
CREATE DATABASE gpt_custom OWNER gpt_custom;
\q
```

O banco fica acessivel apenas localmente no LXC. Nao abra a porta 5432 no roteador.

## 8. Criar o arquivo de configuracao

```bash
cd /opt/gpt_custom
cp .env.example .env
nano .env
```

Preencha:

```env
DATABASE_URL="postgresql://gpt_custom:SENHA_FORTE_DO_BANCO@127.0.0.1:5432/gpt_custom"
APP_URL="https://gpt.seudominio.com"
SESSION_COOKIE_NAME="gpt_custom_session"
SESSION_DAYS="30"

OPENAI_API_KEY="SUA_CHAVE_OPENAI"
OPENAI_MODEL="gpt-5.6-luna"
OPENAI_REASONING_EFFORT="low"
OPENAI_MAX_OUTPUT_TOKENS="2048"

MODEL_INPUT_PRICE_PER_MILLION="1.00"
MODEL_CACHED_INPUT_PRICE_PER_MILLION="0.10"
MODEL_OUTPUT_PRICE_PER_MILLION="6.00"

UPLOAD_DIR="/var/lib/gpt-custom/uploads"
MAX_UPLOAD_BYTES="10485760"
DEFAULT_MONTHLY_LIMIT_USD="5.00"
ALLOW_REGISTRATION="false"

ADMIN_EMAIL="seu-email@dominio.com"
ADMIN_PASSWORD="UMA_SENHA_ADMIN_FORTE"
ADMIN_NAME="Administrador"
```

Proteja o arquivo:

```bash
chown gpt-custom:gpt-custom .env
chmod 600 .env
```

### Escolha do modelo

O exemplo usa `gpt-5.6-luna`, pois e a opcao da familia GPT-5.6 voltada a alto volume e menor custo. Para mais qualidade, altere para `gpt-5.6-terra` ou `gpt-5.6-sol`, se estiver disponivel em sua conta.

Ao trocar o modelo, atualize tambem os tres precos por milhao de tokens. Consulte sempre a pagina oficial de precos. Os valores no exemplo representam a referencia consultada em 24 de julho de 2026 e podem mudar.

## 9. Instalar dependencias

```bash
cd /opt/gpt_custom
npm ci
```

`npm ci` usa exatamente as versoes registradas no `package-lock.json`.

## 10. Criar as tabelas

```bash
npm run db:deploy
```

Esse comando aplica os arquivos em `prisma/migrations`.

Para conferir o status:

```bash
npx prisma migrate status
```

## 11. Criar o administrador

Confirme que `ADMIN_EMAIL` e `ADMIN_PASSWORD` estao no `.env` e execute:

```bash
npm run admin:create
```

O comando pode ser executado novamente para redefinir a senha do mesmo administrador.

Depois, remova `ADMIN_PASSWORD` do `.env` ou substitua por um valor longo que nao seja reutilizado. O hash da senha ja esta salvo no PostgreSQL.

## 12. Testar em modo de desenvolvimento

```bash
npm run dev
```

No computador da mesma rede, acesse:

```text
http://IP_DO_CONTAINER:3000
```

Entre com a conta administrativa. Verifique:

1. criacao de uma nova conversa;
2. envio de uma mensagem;
3. abertura do historico;
4. envio de um PDF pequeno;
5. tela de consumo;
6. painel de administracao.

Pare com `Ctrl+C`.

## 13. Gerar a versao de producao

```bash
npm run lint
npm run typecheck
npm run build
```

Os tres comandos devem terminar sem erros.

## 14. Ajustar permissoes

```bash
chown -R gpt-custom:gpt-custom /opt/gpt_custom
chown -R gpt-custom:gpt-custom /var/lib/gpt-custom
chmod 750 /var/lib/gpt-custom/uploads
```

A aplicacao nao deve rodar como `root`.

## 15. Iniciar com PM2

O arquivo fornecido usa `/opt/gpt_custom` e a porta 3000.

```bash
cd /opt/gpt_custom
sudo -u gpt-custom pm2 start deploy/ecosystem.config.cjs
sudo -u gpt-custom pm2 save
```

Para ativar no boot:

```bash
pm2 startup systemd -u gpt-custom --hp /home/gpt-custom
```

O PM2 exibira um comando adicional. Execute exatamente o comando mostrado e depois:

```bash
sudo -u gpt-custom pm2 save
```

Comandos uteis:

```bash
sudo -u gpt-custom pm2 status
sudo -u gpt-custom pm2 logs gpt-custom
sudo -u gpt-custom pm2 restart gpt-custom
```

## 16. Configurar o Nginx

Copie o modelo:

```bash
cp deploy/nginx-gpt-custom.conf /etc/nginx/sites-available/gpt-custom
nano /etc/nginx/sites-available/gpt-custom
```

Troque:

```text
gpt.seudominio.com
```

pelo dominio real.

Ative:

```bash
ln -s /etc/nginx/sites-available/gpt-custom /etc/nginx/sites-enabled/gpt-custom
rm -f /etc/nginx/sites-enabled/default
nginx -t
systemctl reload nginx
```

O arquivo ja inclui:

- limite de 10 MB por upload;
- limite de tentativas no login;
- limite de chamadas nas APIs;
- timeout maior para respostas do modelo.

## 17. Configurar DNS

No provedor do dominio, crie um registro:

```text
Tipo: A
Nome: gpt
Valor: IP_PUBLICO_DO_SERVIDOR
```

Aguarde a propagacao e confirme:

```bash
nslookup gpt.seudominio.com
```

Se o Proxmox estiver atras de um roteador, encaminhe as portas TCP 80 e 443 para o IP do LXC.

## 18. Ativar HTTPS

```bash
certbot --nginx -d gpt.seudominio.com
```

Teste a renovacao:

```bash
certbot renew --dry-run
```

Depois, confirme no `.env`:

```env
APP_URL="https://gpt.seudominio.com"
```

Reinicie:

```bash
sudo -u gpt-custom pm2 restart gpt-custom
```

## 19. Criar usuarios

Por padrao:

```env
ALLOW_REGISTRATION="false"
```

Isso impede cadastros publicos. Para permitir temporariamente:

```env
ALLOW_REGISTRATION="true"
```

Reinicie o processo, crie a conta pela pagina `/register` e desative novamente.

O administrador tambem pode definir:

- usuario ativo ou bloqueado;
- perfil comum ou administrador;
- limite mensal em dolares.

Ao bloquear um usuario, as sessoes dele sao revogadas.

## 20. Como funciona o controle de custo

Para cada resposta, a aplicacao salva:

- modelo;
- tokens de entrada;
- tokens de entrada em cache;
- tokens de saida;
- tokens de raciocinio;
- total de tokens;
- custo estimado;
- identificador da resposta.

Antes de chamar a OpenAI, a aplicacao soma o custo do mes. Se o limite foi atingido, responde com HTTP 429 e nao realiza a chamada.

Uma trava no registro do usuario permite somente uma geracao simultanea por usuario. Isso reduz o risco de varias chamadas ultrapassarem o limite ao mesmo tempo.

O valor e uma estimativa calculada a partir dos precos configurados. Compare periodicamente com o painel oficial da OpenAI.

## 21. Como funcionam os uploads

Os arquivos ficam em:

```text
/var/lib/gpt-custom/uploads/ID_DO_USUARIO/
```

O navegador nunca recebe o caminho fisico. O backend verifica a sessao e a propriedade antes de permitir download.

Protecoes implementadas:

- tamanho maximo configuravel;
- lista de tipos permitidos;
- verificacao do tipo real do arquivo;
- nome fisico aleatorio;
- hash SHA-256;
- pasta fora de `public/`;
- exclusao junto com a conversa.

Arquivos anexados sao enviados a API somente quando usados em uma mensagem.

## 22. Backup manual

Carregue as variaveis e execute:

```bash
cd /opt/gpt_custom
set -a
source .env
set +a
chmod +x scripts/backup.sh
scripts/backup.sh
```

O resultado fica em:

```text
/var/backups/gpt-custom
```

Sao criados:

- `database-DATA.dump`;
- `uploads-DATA.tar.gz`.

Copie os backups para outro equipamento ou armazenamento. Um backup no mesmo disco nao protege contra falha do servidor.

## 23. Agendar backup

Edite o cron do root:

```bash
crontab -e
```

Exemplo diario as 02:30:

```cron
30 2 * * * cd /opt/gpt_custom && set -a && . ./.env && set +a && ./scripts/backup.sh >> /var/log/gpt-custom-backup.log 2>&1
```

O script nao apaga backups antigos automaticamente. Defina sua politica de retencao depois de confirmar que as copias externas funcionam.

## 24. Restaurar o banco

Crie um banco vazio e restaure:

```bash
sudo -u postgres dropdb --if-exists gpt_custom_restore
sudo -u postgres createdb -O gpt_custom gpt_custom_restore
pg_restore --dbname="postgresql://gpt_custom:SENHA@127.0.0.1:5432/gpt_custom_restore" /var/backups/gpt-custom/database-DATA.dump
```

Restaure os uploads em uma pasta de teste antes de substituir qualquer dado de producao.

## 25. Atualizar a aplicacao

Antes da atualizacao:

```bash
cd /opt/gpt_custom
set -a && source .env && set +a
scripts/backup.sh
```

Depois de receber os novos arquivos:

```bash
npm ci
npm run db:deploy
npm run build
sudo -u gpt-custom pm2 restart gpt-custom
```

Confira:

```bash
sudo -u gpt-custom pm2 logs gpt-custom --lines 100
```

## 26. Diagnostico

### Erro de conexao com banco

```bash
systemctl status postgresql
sudo -u postgres psql -d gpt_custom -c "SELECT 1;"
```

Confirme usuario, senha e URL no `.env`.

### Erro 502 no Nginx

```bash
sudo -u gpt-custom pm2 status
curl http://127.0.0.1:3000
nginx -t
```

### Erro da OpenAI

Confirme:

- `OPENAI_API_KEY`;
- faturamento e saldo;
- disponibilidade do modelo;
- limites da conta;
- logs do PM2.

Nunca publique a chave em mensagens, capturas de tela ou logs.

### Upload rejeitado

Confira os dois limites:

```text
MAX_UPLOAD_BYTES no .env
client_max_body_size no Nginx
```

Confira tambem se a extensao e o tipo real estao na lista permitida em `lib/storage.ts`.

## 27. Seguranca antes de publicar

- use HTTPS;
- mantenha `ALLOW_REGISTRATION=false` quando nao precisar;
- use senhas unicas e fortes;
- nao exponha PostgreSQL na internet;
- nao execute a aplicacao como root;
- proteja `.env` com permissao 600;
- mantenha Node.js e dependencias atualizados;
- acompanhe consumo e erros;
- teste restauracao de backup;
- prefira VPN se o acesso for apenas pessoal ou interno;
- defina uma politica de retencao e exclusao de conversas.

## 28. Comandos de verificacao final

```bash
cd /opt/gpt_custom
npm run lint
npm run typecheck
npm run build
sudo -u gpt-custom pm2 status
nginx -t
curl -I https://gpt.seudominio.com
```

Teste tambem pelo navegador em uma janela anonima.

## 29. Referencias oficiais

- [OpenAI: modelos](https://developers.openai.com/api/docs/models)
- [OpenAI: Responses API](https://developers.openai.com/api/reference/resources/responses)
- [OpenAI: arquivos](https://developers.openai.com/api/reference/resources/files)
- [OpenAI: precos](https://openai.com/api/pricing/)
- [Next.js: Route Handlers](https://nextjs.org/docs/app/getting-started/route-handlers)
- [Prisma com Next.js](https://www.prisma.io/docs/guides/frameworks/nextjs)
- [PostgreSQL](https://www.postgresql.org/docs/)
- [PM2](https://pm2.keymetrics.io/docs/usage/quick-start/)
- [Certbot](https://certbot.eff.org/)

## 30. Checklist de conclusao

- [ ] LXC criado e atualizado
- [ ] Node.js 22 e PostgreSQL instalados
- [ ] Banco e usuario PostgreSQL criados
- [ ] `.env` preenchido e protegido
- [ ] Dependencias instaladas com `npm ci`
- [ ] Migration aplicada
- [ ] Administrador criado
- [ ] Lint, tipos e build aprovados
- [ ] PM2 ativo no boot
- [ ] Nginx configurado
- [ ] DNS apontado
- [ ] HTTPS ativado
- [ ] Chat e upload testados
- [ ] Limite de usuario testado
- [ ] Backup criado e restauracao testada