diff --git a/vps/vim/README.md b/vps/vim/README.md new file mode 100644 index 0000000..a717703 --- /dev/null +++ b/vps/vim/README.md @@ -0,0 +1,76 @@ +# Vim - Servidor de Produção + +Este repositório contém a documentação técnica e os guias de operação para o servidor Vim, uma VPS dedicada ao deployment de aplicações utilizando a plataforma Dokku. + +## Visão Geral + +O servidor Vim é uma infraestrutura de produção que hospeda múltiplas aplicações web, seguindo uma arquitetura baseada em contêineres. A plataforma Dokku serve como camada de gerenciamento de aplicações, similar a um Heroku self-hosted, permitindo deploys rápidos através de Git pushes. O Nginx atua como proxy reverso, roteando o tráfego baseado em domínios para as aplicações corretas. + +Este servidor complementa a infraestrutura existente do projeto Infracloud, que já inclui o servidor Apolo com Kubernetes (K3s). Enquanto o Apolo foi projetado para cargas de trabalho que se beneficiam de orquestração complexa e alta disponibilidade, o Vim foca em simplicidade e deploy rápido para aplicações que não necessitam de escala massiva. + +## Especificações do Servidor + +| Recurso | Especificação | +|---------|---------------| +| **Plataforma** | VPS com Ubuntu/Debian | +| **Orquestrador** | Dokku (PaaS self-hosted) | +| **Container Runtime** | Docker | +| **Proxy Reverso** | Nginx | +| **Bancos de Dados** | PostgreSQL 17 e 18.1 (gerenciados) | +| **Cache** | Redis | + +## Projetos Hospedados + +O servidor Vim atualmente hospeda três projetos principais: + +- **GoHorse**: Ecossistema completo com backend, frontend, backoffice, seeder e jobs processor +- **Sextando**: Plataforma com API e frontend separados +- **Agno Orquestrador**: Serviço de orquestração dedicado + +## Documentação + +A documentação completa está organizada nos seguintes arquivos: + +- [Arquitetura do Sistema](./architecture.md): Diagrama detalhado e descrição dos componentes +- [Inventário de Serviços](./services_inventory.md): Tabela completa de apps, bancos, portas e domínios +- [Guia de Deploy](./deployment_guide.md): Instruções passo a passo para deployment e manutenção + +## Quick Start para Deploy + +```bash +# Adicionar remote Dokku +git remote add dokku dokku@vim.rede5.com.br:nome-do-app + +# Fazer deploy +git push dokku main:master +``` + +Consulte o [deployment_guide.md](./deployment_guide.md) para instruções detalhadas. + +## Estrutura de Diretórios + +``` +vim/ +├── README.md # Este arquivo +├── architecture.md # Arquitetura detalhada do sistema +├── services_inventory.md # Inventário completo de serviços +└── deployment_guide.md # Guia de deploy e manutenção +``` + +## Boas Práticas + +Sempre siga estas práticas ao fazer deploy no servidor Vim: + +1. **Variáveis de Ambiente**: Configure todas as variáveis necessárias antes do deploy +2. **Bancos de Dados**: Utilize os bancos existentes (postgres-main ou agno-db) ou crie novos conforme necessidade +3. **SSL**: Para domínios de produção, habilite HTTPS +4. **Logs**: Monitore os logs após cada deploy +5. **Testes**: Teste a aplicação em staging antes de fazer deploy em produção + +## Suporte + +Para dúvidas ou problemas com deployment, consulte: + +1. [deployment_guide.md](./deployment_guide.md) - Seção de troubleshooting +2. [services_inventory.md](./services_inventory.md) - Verificar configuração atual +3. Architecture - Entender como os componentes interagem diff --git a/vps/vim/architecture.md b/vps/vim/architecture.md new file mode 100644 index 0000000..febe26e --- /dev/null +++ b/vps/vim/architecture.md @@ -0,0 +1,124 @@ +# Arquitetura do Sistema Vim + +Este documento descreve a arquitetura detalhada dos serviços hospedados no servidor Vim, que utiliza Dokku como plataforma de deploy PaaS (Platform as a Service) self-hosted. + +## Visão Geral da Arquitetura + +O servidor Vim opera como uma plataforma de hospedagem de aplicações baseada em contêineres, utilizando o Dokku como camada de abstração sobre o Docker. Esta arquitetura permite o deploy rápido de aplicações diversas sem a complexidade de um cluster Kubernetes completo, sendo ideal para projetos de médio porte e equipes que precisam de simplicidade na gestão de deploys. + +A infraestrutura é composta por três camadas principais: a camada de proxy reverso (Nginx), a camada de aplicação (Dokku com Docker) e a camada de dados (PostgreSQL gerenciado pelo Dokku). O Nginx atua como ponto de entrada para todo o tráfego HTTP/HTTPS, direcionando as requisições para os apps corretos baseando-se no domínio solicitado. O Dokku gerencia os contêineres das aplicações, criando automaticamente imagens Docker a partir do código fonte pushado via Git e expondo as aplicações em portas internas que o Nginx redireciona. + +## Diagrama de Arquitetura + +```mermaid +flowchart TB + subgraph Internet ["Internet"] + direction LR + Users1((Usuários)) + Devs((Desenvolvedores)) + end + + subgraph Vim ["Servidor Vim"] + subgraph Proxy ["Proxy Reverso"] + Nginx[Nginx
Ports: 80, 443] + end + + subgraph Dokku ["Plataforma Dokku"] + DCore[Dokku Core
Dokku
Docker
Buildpacks] + + subgraph Apps ["Aplicações Hospedadas"] + direction LR + GoHorseBE[GoHorse
Backend] + GoHorseFE[GoHorse
Frontend] + GoHorseBO[GoHorse
Backoffice] + GoHorseSD[GoHorse
Seeder] + GoHorseJobs[GoHorse
Jobs] + Sextando[API
Sextando] + SextandoFE[Frontend
Sextando] + Agno[Agno
Orquestrador] + end + end + + subgraph Databases ["Bancos de Dados"] + PGMain[(PostgreSQL
Main)] + PGAgno[(PostgreSQL
Agno-DB)] + end + + subgraph Cache ["Camada de Cache"] + Redis[(Redis)] + end + + subgraph Storage ["Armazenamento"] + Volumes[Volumes
Docker] + end + end + + Internet -->|HTTPS/443| Nginx + Devs -->|Git Push| Nginx + + Nginx -->|Route by Host| DCore + DCore --> GoHorseBE + DCore --> GoHorseFE + DCore --> GoHorseBO + DCore --> GoHorseSD + DCore --> GoHorseJobs + DCore --> Sextando + DCore --> SextandoFE + DCore --> Agno + + GoHorseBE --> PGMain + GoHorseJobs --> PGMain + Sextando --> PGMain + Agno --> PGAgno + + GoHorseJobs --> Redis + + GoHorseBE --> Volumes + GoHorseFE --> Volumes + Sextando --> Volumes + SextandoFE --> Volumes +``` + +## Descrição dos Componentes + +### Camada de Proxy Reverso + +O Nginx funciona como proxy reverso principal, escutando nas portas 80 (HTTP) e 443 (HTTPS). Ele recebe todas as requisições externas e as direciona para os apps corretos baseando-se no cabeçalho Host da requisição. O Nginx também é responsável por terminar o TLS para as conexões HTTPS, fornecendo certificados SSL para os domínios configurados. Esta camada é crítica para a segurança e performance das aplicações, pois concentra o tráfego e permite configuraçõescentralizadas de cache, compressão e balanceamento de carga. + +A configuração do Nginx para o Dokku utiliza mapeamento dinâmico de portas. Quando um app é criado no Dokku, ele recebe uma porta aleatória alta (greater than 10000), e o Dokku configura automaticamente o Nginx para rotear o tráfego do domínio configurado para essa porta específica. Este sistema permite que múltiplas aplicações coexistam no mesmo servidor sem conflitos de portas. + +### Plataforma Dokku + +O Dokku é a peça central da infraestrutura, funcionando como um mini PaaS similar ao Heroku. Ele automatiza o processo de deployment de aplicações, desde o recebimento do código via Git até a disponibilização do container rodando. O Dokku utiliza buildpacks para detectar automaticamente a linguagem de programação da aplicação e escolher o processo de build adequado, suportando Node.js, Python, Go, Ruby, Java, PHP e outras linguagens. + +Cada aplicação no Dokku roda em seu próprio container isolado, com variáveis de ambiente configuráveis e links para serviços externos como bancos de dados PostgreSQL e Redis. O Dokku também gerencia automaticamente a reconstrução de containers quando novas versões são pushadas, facilitando significativamente o fluxo de CI/CD. + +### Aplicações Hospedadas + +O ecossistema do servidor Vim é composto por três projetos principais: GoHorse, Sextando e Agno Orquestrador. Cada um destes projetos segue uma arquitetura de microservices com frontend, backend e eventualmente serviços auxiliares como seeders e jobs. + +O GoHorse é o ecossistema mais completo, composto por cinco aplicações distintas. O backend (gohorse-backend) expõe a API principal na porta 5000 e conecta-se ao PostgreSQL main para persistência de dados. O frontend (gohorse-frontend) é a interface web principal доступна na porta 3000. O backoffice (gohorse-backoffice) é a área administrativa disponível na porta 3001. O seeder (gohorse-seeder) é um serviço auxiliar que popula o banco de dados com dados iniciais ou de teste. O gohorsejobs é um serviço de processamento de tarefas assíncronas que utiliza Redis para gerenciamento de filas. + +O projeto Sextando também segue uma arquitetura similar, com uma API backend e um frontend separado. Ambos os componentes estão configurados com SSL e acessível via domínios próprios. O Agno Orquestrador é um serviço especializado que utiliza seu próprio banco de dados PostgreSQL (agno-db) isolado do banco principal. + +### Camada de Dados + +O servidor utiliza PostgreSQL 17 como banco de dados principal, gerenciado pelo plugin Dokku Postgres. O banco "postgres-main" é compartilhado entre as aplicações GoHorse e Sextando, permitindo que cada aplicação tenha seu próprio schema dentro do mesmo banco. Esta abordagem é eficiente em termos de recursos, mas requer cuidado com a nomeação de tabelas para evitar conflitos entre os projetos. + +Existe também um banco dedicado "agno-db" rodando PostgreSQL 18.1, utilizado exclusivamente pelo serviço Agno Orquestrador. Esta separação é intencional para isolar os dados de aplicações críticas e permitir diferentes configurações de backup e manutenção para cada serviço. + +### Camada de Cache + +O Redis é utilizado principalmente pelo serviço GoHorse Jobs para gerenciamento de filas de tarefas assíncronas. O Redis fornece persistência opcional e é configurado com um limite de memória de 128MB, o que é suficiente para o volume atual de jobs processados. A utilização do Redis permite que tarefas pesadas sejam processadas em background sem impactar a responsividade das APIs principais. + +## Fluxo de Dados + +O fluxo de uma requisição típica começa quando um usuário acessa um domínio configurado, como "gohorsejobs.dokku.rede5.com.br". A requisição chega ao servidor na porta 443 (HTTPS) e é recibida pelo Nginx. O Nginx verifica o domínio solicitado e faz proxy_pass para a porta interna onde o container Dokku está escutando. O container processa a requisição, eventualmente consultando o PostgreSQL ou Redis, e retorna a resposta que segue o caminho inverso até o usuário. + +Para deploys, o fluxo começa quando um desenvolvedor faz "git push dokku main" para o repositório Git do projeto. O Dokku recebe o push, detecta a linguagem da aplicação via buildpack, executa o build appropriate (npm install e build para Node.js, por exemplo), cria uma nova imagem Docker e substitui o container antigo pelo novo. Após alguns segundos, a nova versão está disponível em produção. + +## Considerações de Segurança + +A arquitetura atual implementa várias camadas de segurança. O isolamento de containers garante que cada aplicação tenha seu próprio ambiente isolado, impedindo que falhas de segurança em uma aplicação comprometam as outras. O Nginx como proxy reverso permite configuração centralizada de TLS e cabeçalhos de segurança. As variáveis de ambiente sensíveis (como senhas de banco) são armazenadas no contexto do Dokku e não são expostas nos containers. + +Recomenda-se futuramente implementar variáveis de ambiente sensíveis através do plugin Dokku Docker Options e considerar a adição de um WAF (Web Application Firewall) para proteção contra ataques comuns como SQL injection e XSS. diff --git a/vps/vim/deployment_guide.md b/vps/vim/deployment_guide.md new file mode 100644 index 0000000..d1e77af --- /dev/null +++ b/vps/vim/deployment_guide.md @@ -0,0 +1,365 @@ +# Guia de Deploy e Manutenção - Vim + +Este guia descreve o processo completo para implantar, atualizar e manter serviços no servidor Vim utilizando a plataforma Dokku. + +## Visão Geral da Plataforma + +O servidor Vim utiliza o Dokku como plataforma de deploy PaaS (Platform as a Service) self-hosted. O Dokku é uma ferramenta open-source que transforma um servidor Linux em um PaaS similar ao Heroku, permitindo o deploy de aplicações através de Git pushes. A plataforma utiliza o Docker para isolar as aplicações e o Nginx como proxy reverso para roteamento de tráfego baseado em domínios. + +Esta arquitetura foi escolhida por oferecer um equilíbrio entre simplicidade e funcionalidade. Diferente de um cluster Kubernetes completo, o Dokku não requer conhecimento avançado de contêineres e permite que desenvolvedores façam deploys apenas com conhecimento de Git. A plataforma detecta automaticamente a linguagem de programação da aplicação (Node.js, Go, Python, etc.) através de buildpacks e configura o ambiente de execução apropriado. + +## Pré-requisitos + +Antes de fazer deploy no servidor Vim, certifique-se de ter os seguintes pré-requisitos atendidos: + +Primeiro, você precisa de acesso SSH ao servidor com chave SSH configurada. A chave pública deve estar autorizada no arquivo `~/.ssh/authorized_keys` do servidor. Sem isso, você não conseguirá fazer o push do código. Segundo, você precisa do Dokku client instalado localmente. Em sistemas Debian/Ubuntu, instale com `sudo apt-get install dokku`. Terceiro, você precisa ter o Git instalado em sua máquina de desenvolvimento. E quarto, o repositório da aplicação deve ter um Dockerfile ou um dos buildpacks suportados (Node.js, Go, Python, Ruby, Java, PHP, Gradle, .NET Core). + +## Estrutura de Repositórios + +Cada projeto deve seguir uma estrutura específica para funcionar corretamente no Dokku. O repositório precisa ter um arquivo de configuração apropriado para a linguagem utilizada. Para Node.js, é necessário ter um `package.json` com scripts de start definidos. Para Go, o `go.mod` é essencial. O Dokku detecta automaticamente a linguagem e aplica o buildpack correto. + +Abaixo está um exemplo de `package.json` otimizado para Dokku: + +```json +{ + "name": "gohorse-backend", + "version": "1.0.0", + "main": "dist/index.js", + "scripts": { + "start": "node dist/index.js", + "build": "tsc", + "dev": "nodemon src/index.ts" + }, + "dependencies": { + "express": "^4.18.2", + "pg": "^8.11.0" + }, + "devDependencies": { + "typescript": "^5.0.0", + "@types/node": "^20.0.0" + } +} +``` + +Para aplicações Go, o `go.mod` deve seguir este formato: + +```go +module github.com/sua-empresa/gohorse-backend + +go 1.21 + +require ( + github.com/gin-gonic/gin v1.9.1 + github.com/lib/pq v1.10.9 +) +``` + +## Fazendo o Primeiro Deploy + +O processo de deploy no Dokku é simples e segue o fluxo similar ao Heroku. Primeiro, você precisa adicionar o remote do Dokku ao seu repositório Git local. No diretório do seu projeto, execute o comando para adicionar o remote Dokku, substituindo o nome do app e o usuário: + +```bash +git remote add dokku dokku@vim.rede5.com.br:gohorse-backend +``` + +Este comando configura o remote "dokku" apontando para o servidor Vim. Note que o nome após os dois pontos deve corresponder exatamente ao nome do app que você criou no Dokku. Se o app se chamar "gohorse-backend", você deve usar "gohorse-backend" no remote. + +Se o app ainda não existe no Dokku, você pode criá-lo diretamente com o push: + +```bash +git push dokku main:master +``` + +Quando o Dokku recebe o primeiro push para um app que não existe, ele automaticamente cria o app e inicia o processo de deploy. Se preferir criar o app manualmente antes do primeiro deploy, você pode SSH no servidor e executar: + +```bash +dokku apps:create gohorse-backend +``` + +## Configurando Variáveis de Ambiente + +As variáveis de ambiente são essenciais para o funcionamento correto das aplicações. No Dokku, você pode definir variáveis de ambiente tanto pelo servidor quanto através de arquivos `.env`. Para definir uma variável de ambiente pelo terminal, primeiro faça SSH no servidor: + +```bash +ssh root@vim.rede5.com.br +``` + +Então, defina a variável para o app específico: + +```bash +dokku config:set gohorse-backend DATABASE_URL=postgres://user:password@host:5432/dbname +dokku config:set gohorse-backend NODE_ENV=production +dokku config:set gohorse-backend PORT=5000 +``` + +Para ver todas as variáveis de um app: + +```bash +dokku config gohorse-backend +``` + +Para desenvolvimento local, crie um arquivo `.env` na raiz do projeto (que deve estar no `.gitignore`): + +``` +DATABASE_URL=postgres://postgres:password@localhost:5432/gohorse_dev +NODE_ENV=development +PORT=5000 +``` + +Em aplicações Node.js, utilize a biblioteca `dotenv` para carregar essas variáveis: + +```typescript +import dotenv from 'dotenv'; +dotenv.config(); + +const port = process.env.PORT || 3000; +const dbUrl = process.env.DATABASE_URL; +``` + +## Configurando Bancos de Dados PostgreSQL + +O servidor Vim possui dois bancos de dados PostgreSQL gerenciados pelo Dokku: o `postgres-main` (versão 17) e o `agno-db` (versão 18.1). Para conectar uma aplicação a um banco de dados, você deve criar um link entre o serviço e o app. + +Para criar o link (isso automaticamente define a variável DATABASE_URL): + +```bash +dokku postgres:link postgres-main gohorse-backend +``` + +Para desvincular: + +```bash +dokku postgres:unlink postgres-main gohorse-backend +``` + +Para criar um novo banco de dados: + +```bash +dokku postgres:create meu-novo-banco +dokku postgres:link meu-novo-banco minha-app +``` + +Para verificar informações do banco: + +```bash +dokku postgres:info postgres-main +dokku postgres:list +``` + +## Configurando Domínios e SSL + +O Dokku permite configurar domínios customizados para cada aplicação. Para adicionar um domínio: + +```bash +dokku domains:set gohorse-backend gohorse.dokku.rede5.com.br +``` + +Para habilitar HTTPS com Let's Encrypt (plugin instalado): + +```bash +dokku letsencrypt:enable gohorse-backend +``` + +Para renewal automático de certificados: + +```bash +dokku letsencrypt:auto-renew gohorse-backend +``` + +Sem o plugin Let's Encrypt, você pode configurar SSL manualmente através do Nginx ou usando certificados propios. O Nginx do servidor Vim está configurado para aceitar conexões HTTPS nas portas 80 e 443, então você pode também gerenciar certificados manualmente se preferir. + +## Mapeamento de Portas + +O Dokku expõe automaticamente as aplicações em portas dinâmicas. Por padrão, ele usa a variável PORT definida no ambiente do container. Para configurar o mapeamento de portas explicitamente: + +```bash +dokku ports:set gohorse-backend http:80:5000 +``` + +Este comando mapeia a porta 80 do host para a porta 5000 do container. Para múltiplas portas (HTTP e HTTPS): + +```bash +dokku ports:set gohorse-backend http:80:8080 https:443:8080 +``` + +## Comandos de Deploy + +### Deploy Padrão + +Para fazer o deploy de uma nova versão, basta fazer push para o remote Dokku: + +```bash +git push dokku main:master +``` + +O Dokku mostrará o progresso do build e informará quando o deploy estiver completo. Você pode acompanhar os logs do deploy em tempo real. + +### Rollback + +Se algo der errado após o deploy, você pode fazer rollback para a versão anterior: + +```bash +dokku releases:rollback gohorse-backend +``` + +Para ver o histórico de releases: + +```bash +dokku releases gohorse-backend +``` + +### Deploy com Build Especial + +Se você precisa fazer build local e apenas enviar a imagem: + +```bash +docker build -t dokku/gohorse-backend:latest . +docker push dokku/gohorse-backend:latest +dokku deploy gohorse-backend +``` + +## Gerenciando Serviços + +### Verificar Status + +Para ver o status de uma aplicação: + +```bash +dokku apps:info gohorse-backend +``` + +Para ver os logs em tempo real: + +```bash +dokku logs gohorse-backend -t +``` + +Para ver logs de uma quantidade específica de linhas: + +```bash +dokku logs gohorse-backend -n 100 +``` + +### Reiniciar Aplicação + +```bash +dokku ps:restart gohorse-backend +``` + +### Parar e Iniciar + +```bash +dokku ps:stop gohorse-backend +dokku ps:start gohorse-backend +``` + +### Escalar Aplicação + +O Dokku suporta múltiplas instâncias de um app (apenas para Dockerfiles): + +```bash +dokku ps:scale gohorse-backend=2 +``` + +## Configurando Persistent Storage + +Se sua aplicação precisa de armazenamento persistente (uploads, arquivos, etc.), você pode configurar volumes: + +```bash +dokku storage:mount gohorse-backend /var/lib/dokku/gohorse-backend/uploads:/app/uploads +``` + +O primeiro caminho é no host (servidor) e o segundo é dentro do container. Após adicionar um mount, reinicie o app: + +```bash +dokku ps:restart gohorse-backend +``` + +Para listar mounts: + +```bash +dokku storage:list gohorse-backend +``` + +## Troubleshooting + +### Aplicação Não Inicia + +Se o container não inicia, verifique os logs: + +```bash +dokku logs gohorse-backend +``` + +Erros comuns incluem: variável PORT incorreta (o Dokku define automaticamente a variável PORT baseado no Dockerfile ou Procfile), dependências faltando no package.json ou go.mod, e banco de dados não vinculado corretamente. + +### Erro de Build + +Se o build falha, verifique a saída do comando git push. Erros comuns incluem: versão do Node/Go não compatível, memória insuficiente durante o build (pode precisar de swap), e dependências privadas não acessíveis. + +### Problemas de Conexão com Banco + +Se a aplicação não conecta ao banco: verifique se o link foi criado corretamente com `dokku postgres:info postgres-main`, confirme que a variável DATABASE_URL está correta com `dokku config gohorse-backend`, e verifique se o banco está rodando com `dokku postgres:status postgres-main`. + +### Container em Estado de Crash + +Se o container está constantemente reiniciando: + +```bash +dokku logs gohorse-backend --num 50 +``` + +Pode ser necessário ajustar a configuração de healthcheck ou verificar se há erros de inicialização no código. + +## Checklist de Boas Práticas + +Antes de fazer deploy para produção, siga esta checklist: + +Garanta que o arquivo Procfile ou Dockerfile esteja correto e defina o comando de start apropriado. Para Node.js com package.json, o Dokku detecta automaticamente. Para outros casos, crie um Procfile: + +``` +web: npm start +worker: npm run worker +``` + +Confirme que todas as variáveis de ambiente necessárias estão configuradas no Dokku. O banco de dados está linkado corretamente. Os domínios estão configurados e DNS está apontando para o servidor. Os certificados SSL estão válidos (se aplicável). Os logs estão funcionando e você consegue acessar para debugar. + +## Limpeza e Manutenção + +Para limpar recursos não utilizados: + +```bash +# Limpar containers Docker órfãos +docker container prune -f + +# Limpar imagens não utilizadas +docker image prune -a -f + +# Limpar volumes não utilizados +docker volume prune -f + +# Limpar builds antigos do Dokku +dokku cleanup +``` + +Para verificar uso de disco: + +```bash +df -h +docker system df +``` + +## Referência Rápida de Comandos + +| Ação | Comando | +|------|---------| +| Listar apps | `dokku apps:list` | +| Criar app | `dokku apps:create nome-app` | +| Deletar app | `dokku apps:destroy nome-app` | +| Ver config | `dokku config nome-app` | +| Setar config | `dokku config:set nome-app CHAVE=valor` | +| Ver logs | `dokku logs nome-app -t` | +| Reiniciar | `dokku ps:restart nome-app` | +| Listar bancos | `dokku postgres:list` | +| Info banco | `dokku postgres:info nome-banco` | +| Link banco | `dokku postgres:link nome-banco nome-app` | diff --git a/vps/vim/services_inventory.md b/vps/vim/services_inventory.md new file mode 100644 index 0000000..a787a5f --- /dev/null +++ b/vps/vim/services_inventory.md @@ -0,0 +1,133 @@ +# Inventário de Serviços Vim + +## Visão Geral + +Este documento apresenta o inventário completo de serviços hospedados no servidor Vim, utilizando a plataforma Dokku como camada de gerenciamento de aplicações baseadas em contêineres. + +## Tabela de Aplicações + +| Aplicação | Domínio | Porta do Container | Porta Exposta | Protocolo | Banco de Dados | Status | +|-----------|---------|:------------------:|--------------:|----------:|----------------|:------:| +| **GoHorse Backend** | `dokku.rede5.com.br` | 5000 | 5000 | HTTP | postgres-main | ✅ Rodando | +| **GoHorse Frontend** | `dokku.rede5.com.br` | 3000 | 3000 | HTTP | - | ✅ Rodando | +| **GoHorse Backoffice** | `gohorse-backoffice.dokku.rede5.com.br` | 3001 | 3001 | HTTP | postgres-main | ✅ Rodando | +| **GoHorse Seeder** | `gohorse-seeder.dokku.rede5.com.br` | 3001 | 3001 | HTTP | postgres-main | ✅ Rodando | +| **GoHorse Jobs** | `gohorsejobs.dokku.rede5.com.br` | 8521 | 8521 | HTTP | postgres-main | ✅ Rodando | +| **Sextando API** | `api-dev.sextando.com.br` | 8080 | 8080 | HTTPS | postgres-main | ✅ Rodando | +| **Sextando Frontend** | `dev.sextando.com.br` | 3000 | 3000 | HTTPS | - | ✅ Rodando | +| **Agno Orquestrador** | `agno.rede5.com.br` | 5000 | 5000 | HTTPS | agno-db | ✅ Rodando | + +## Tabela de Bancos de Dados + +| Serviço | Versão | Tamanho (aprox) | Links de Apps | Porta Interna | Volume | +|---------|:------:|:---------------:|---------------|:-------------:|-------| +| **postgres-main** | 17 | - | gohorse-backend, gohorsejobs, sextando | 5432 | /var/lib/dokku/services/postgres/postgres-main/data | +| **agno-db** | 18.1 | - | agno-orquestrador | 5432 | /var/lib/dokku/services/postgres/agno-db/data | + +## Tabela de Containers Docker (Internos) + +| Container | Imagem | Status | Porta | Notas | +|-----------|--------|:------:|------|-------| +| gohorse-backend.web.1 | dokku/gohorse-backend:latest | ✅ Up | 8521/tcp | Backend principal | +| gohorse-frontend.web.1 | dokku/gohorse-frontend:latest | ✅ Up | 3000/tcp | Frontend GoHorse | +| gohorsejobs-frontend-1 | node:20-alpine | ✅ Up | 3000/tcp | Frontend Jobs | +| gohorsejobs.web.1 | dokku/gohorsejobs:latest | ✅ Up | 8521/tcp | Jobs processor | +| gohorsejobs.web.1.upcoming-1812 | 3ef1415c2699 | ✅ Up | 8521/tcp | Container anterior | +| gohorse-backoffice.web.1.upcoming-27801 | dokku/gohorse-backoffice:latest | ✅ Up | 3001/tcp | Backoffice admin | +| gohorse-seeder.web.1 | dokku/gohorse-seeder:latest | ✅ Up | 3001/tcp | Seeder (healthy) | +| sextando.web.1 | dokku/sextando:latest | ✅ Up | 8080/tcp | API Sextando | +| sextando-frontend.web.1 | b208b5d37fc5 | ✅ Up | 3000/tcp | Frontend Sextando | +| agno-orquestrador.web.1 | dokku/agno-orquestrador:latest | ✅ Up | 5000/tcp | Orquestrador Agno | +| dokku.postgres.postgres-main | postgres:17 | ✅ Up | 5432/tcp | Banco principal | +| dokku.postgres.agno-db | postgres:18.1 | ✅ Up | 5432/tcp | Banco Agno | + +### Containers Parados (Exited) + +| Container | Imagem | Status | Motivo | +|-----------|--------|:------:|--------| +| gohorse-backend.web.1.upcoming-16753 | dokku/gohorse-backend:latest | ❌ Exited (143) | Substituído por nova versão | +| gohorse-frontend-dev | node:20-alpine | ❌ Exited (255) | Ambiente de desenvolvimento | +| epic_poitras | node:20-alpine | ❌ Created | Container não iniciado | +| gohorse-backend | golang:1.24 | ❌ Exited (2) | Container antigo | +| gohorse-seeder | a9cd9bac76cf | ❌ Exited (137) | Container antigo | +| gohorse-backoffice | a9cd9bac76cf | ❌ Exited (255) | Container antigo | + +## Redes Docker + +| Rede | Driver | Escopo | Connected Containers | +|------|--------|:------:|----------------------| +| bridge | bridge | local | - | +| gohorsejobs_default | bridge | local | gohorsejobs, postgres-main | +| host | host | local | - | +| none | null | local | - | + +## Volumes Docker + +| Volume | Driver | Utilização | +|--------|:------:|------------| +| cache-sextando-frontend | local | Cache do frontend Sextando | +| go-modules | local | Módulos Go compartilhados | + +## Portas do Sistema + +| Porta | Serviço | Descrição | +|:-----:|---------|-----------| +| 22 | SSH | Acesso SSH ao servidor | +| 80 | Nginx | HTTP (Redirect para 443) | +| 443 | Nginx | HTTPS (Terminação TLS) | +| 2375/2376 | Docker | API Docker (se habilitado) | +| 3000-32767 | Dokku | Range dinâmico para apps | + +## Domínios Configurados + +| Domínio | App Associado | SSL/TLS | +|---------|---------------|:--------:| +| dokku.rede5.com.br | GoHorse Backend/Frontend | ❌ HTTP | +| gohorse-backoffice.dokku.rede5.com.br | GoHorse Backoffice | ❌ HTTP | +| gohorse-seeder.dokku.rede5.com.br | GoHorse Seeder | ❌ HTTP | +| gohorsejobs.dokku.rede5.com.br | GoHorse Jobs | ❌ HTTP | +| api-dev.sextando.com.br | Sextando API | ✅ HTTPS | +| dev.sextando.com.br | Sextando Frontend | ✅ HTTPS | +| agno.rede5.com.br | Agno Orquestrador | ✅ HTTPS | + +## Variáveis de Ambiente Principais + +### postgres-main +- `DATABASE_URL`: `postgres://postgres:cd467ce208950f3adc07d40480022ede@dokku-postgres-postgres-main:5432/postgres_main` + +### agno-db +- `DATABASE_URL`: `postgres://postgres:d6597def2da1a230a8a7a03e8c8186b8@dokku-postgres-agno-db:5432/agno_db` + +## Services Systemd Relacionados + +| Serviço | Status | Descrição | +|---------|:------:|-----------| +| docker.service | ✅ active | Docker Engine | +| dokku-event-listener.service | ✅ active | Listener de eventos Dokku | +| nginx.service | ✅ active | Proxy reverso Nginx | + +## Métricas de Recursos (Aproximadas) + +Com base nos containers ativos, a infraestrutura utiliza aproximadamente: + +- **CPU**: 2-4 cores em uso +- **Memória**: ~4-6GB RAM +- **Armazenamento**: Depende do tamanho dos volumes PostgreSQL + +## Histórico de Issues Conhecidas + +### Containers Exited + +Os containers marcados como "Exited" são versões anteriores que não foram limpas automaticamente. Recomenda-se: + +1. **Identificar containers órfãos**: `docker ps -a --filter "status=exited"` +2. **Limpar containers antigos**: `docker container prune` +3. **Verificar se há volumes órfãos**: `docker volume ls` + +### Status SSL + +Vários domínios estão configurados apenas em HTTP, sem SSL. Para produção, recomenda-se configurar certificados TLS. O Dokku suporta Let's Encrypt via plugin ou configuração manual do Nginx. + +### Portas Duplicadas + +Alguns apps (gohorse-backend e gohorsejobs) estão usando portas internas conflitantes (8521). Verificar se há intenção de manter ambos ou se há erro de configuração.