Rui
153 lines
7.9 KiB
Markdown
153 lines
7.9 KiB
Markdown
# 📂 Guia de Compartilhamento da Pasta de Instruções entre VPSs
|
|
|
|
Este documento descreve as melhores estratégias e o passo a passo técnico para que **agentes (humanos, automatizados ou IA)** em outras VPSs da sua rede segura (`10.99.0.0/24`) tenham acesso de leitura e escrita à pasta `/home/deploy/instrucoes`.
|
|
|
|
Como você já possui uma infraestrutura de rede privada criptografada baseada em **WireGuard**, podemos aproveitar essa segurança para compartilhar os arquivos de forma extremamente protegida e eficiente.
|
|
|
|
---
|
|
|
|
## 🗺️ Tabela Comparativa de Abordagens
|
|
|
|
| Abordagem | Tipo | Sincronização | Segurança | Complexidade | Recomendação |
|
|
| :--- | :--- | :--- | :--- | :--- | :--- |
|
|
| **1. Git Privado** | Repositório | Manual / CI-CD | 🟢 **Máxima** (Chaves SSH) | 🟡 Baixa | **Altamente Recomendado** para desenvolvimento e IA |
|
|
| **2. Syncthing** | P2P Ativo | Instantânea | 🟢 **Excelente** (TLS + VPN) | 🟡 Média | **Ideal** para espelhamento em tempo real bidirecional |
|
|
| **3. SSHFS** | Mount Direto | Sob demanda | 🟢 **Excelente** (SSH s/ VPN) | 🟢 Muito Baixa | **Excelente** para montagem rápida sem duplicar arquivos |
|
|
| **4. Rsync + Cron** | Script Push/Pull | Periódica | 🟢 **Excelente** (SSH) | 🟢 Muito Baixa | Para espelhamento simples de leitura apenas |
|
|
|
|
---
|
|
|
|
## 🕸️ Opção 1: Repositório Git Privado (Recomendado para Agentes & IA)
|
|
|
|
Esta é a abordagem padrão da indústria. Em vez de compartilhar a pasta fisicamente via rede (o que gera dependência de conexão direta), transformamos a pasta `instrucoes` em um **repositório Git privado** (ex: no GitHub ou GitLab).
|
|
|
|
### Como funciona:
|
|
Cada VPS possui um clone local em `/home/deploy/instrucoes`. Quando um agente ou você altera algo, faz um `git commit` e `git push`. As outras VPSs fazem `git pull`.
|
|
|
|
### Vantagens para Agentes de IA:
|
|
Os agentes de IA (como o Antigravity e outros) lidam nativamente de forma excelente com comandos Git. Isso garante controle de versão, histórico de quem alterou o quê, facilidade de rollback e elimina riscos de corrupção de arquivos por escrita simultânea.
|
|
|
|
### Passo a Passo de Configuração:
|
|
|
|
1. **Inicializar o Git localmente na máquina de origem (ex: VPS 1):**
|
|
```bash
|
|
cd /home/deploy/instrucoes
|
|
git init
|
|
# Adicionar um .gitignore para ignorar arquivos temporários ou chaves sensíveis que não devem subir
|
|
echo "gcal_key.json" >> .gitignore
|
|
echo "ssh_alerts_config.json" >> .gitignore
|
|
git add .
|
|
git commit -m "feat: commit inicial das instrucoes"
|
|
```
|
|
|
|
2. **Criar um Repositório Privado** no GitHub/GitLab.
|
|
|
|
3. **Gerar chaves de acesso SSH (Deploy Keys) nas outras VPSs:**
|
|
Em cada VPS que precisa de acesso, gere uma chave SSH para o usuário `deploy`:
|
|
```bash
|
|
ssh-keygen -t ed25519 -C "vps-instrucoes-deploy" -f ~/.ssh/id_ed25519_github
|
|
```
|
|
Adicione a chave pública (`.pub`) gerada como **Deploy Key** (com permissão de escrita, se necessário) nas configurações do repositório no GitHub.
|
|
|
|
4. **Clonar o repositório nas outras VPSs:**
|
|
```bash
|
|
cd /home/deploy
|
|
git clone git@github.com:seu-usuario/seu-repositorio.git instrucoes
|
|
```
|
|
|
|
5. **Automatizar o Pull (Opcional):**
|
|
Se quiser que as outras VPSs atualizem as instruções automaticamente sempre que houver mudanças no repositório remoto, configure um cronjob de 5 em 5 minutos para rodar o pull:
|
|
```bash
|
|
crontab -e
|
|
# Adicione a linha abaixo:
|
|
*/5 * * * * cd /home/deploy/instrucoes && git pull origin main > /dev/null 2>&1
|
|
```
|
|
|
|
---
|
|
|
|
## 🔄 Opção 2: Syncthing (Sincronização em Tempo Real Descentralizada)
|
|
|
|
O **Syncthing** é um serviço peer-to-peer de sincronização contínua de arquivos. Ele roda como um daemon leve nas VPSs e garante que qualquer arquivo criado ou modificado em uma pasta seja propagado instantaneamente para as outras em questão de segundos.
|
|
|
|
### Como configurar de forma segura via VPN WireGuard:
|
|
|
|
1. **Instalar o Syncthing em todas as VPSs:**
|
|
```bash
|
|
sudo apt-get update
|
|
sudo apt-get install -y syncthing
|
|
```
|
|
|
|
2. **Configurar para escutar apenas no IP da VPN (Zero-Trust):**
|
|
Edite o arquivo de configuração do Syncthing (gerado após a primeira execução em `~/.config/syncthing/config.xml`) e ajuste o endereço da interface gráfica e de sincronização para rodar apenas nos IPs locais ou de VPN, prevenindo exposição pública.
|
|
* Altere a linha do GUI para escutar localmente: `<address>127.0.0.1:8384</address>` (Você pode acessar usando um túnel SSH do seu notebook: `ssh -L 8384:127.0.0.1:8384 deploy@10.99.0.1`).
|
|
|
|
3. **Adicionar os Servidores como Peers:**
|
|
* No painel do Syncthing da VPS 1, copie o **Device ID**.
|
|
* Adicione esse Device ID no painel da VPS 4/5, especificando o endereço fixo da VPN (ex: `tcp://10.99.0.1:22000`).
|
|
* Compartilhe a pasta `/home/deploy/instrucoes` entre eles.
|
|
|
|
4. **Habilitar o Serviço na inicialização:**
|
|
```bash
|
|
sudo systemctl enable syncthing@deploy.service
|
|
sudo systemctl start syncthing@deploy.service
|
|
```
|
|
|
|
---
|
|
|
|
## 🔗 Opção 3: SSHFS (Montagem de Pasta sobre SSH na VPN)
|
|
|
|
O **SSHFS** permite montar um diretório remoto de um servidor em outro servidor de forma transparente, utilizando o próprio protocolo SSH de transporte. Como a sua porta SSH (22) está aberta e protegida dentro da rede privada da VPN (`10.99.0.0/24`), este método é extremamente simples e não exige serviços extras rodando em segundo plano além do próprio SSH.
|
|
|
|
### Como configurar:
|
|
|
|
Digamos que a pasta física está na **VPS 1 (IP `10.99.0.1`)** e você deseja acessá-la em tempo real na **VPS 4 (IP `10.99.0.4`)**:
|
|
|
|
1. **Instalar o SSHFS na VPS de destino (ex: VPS 4):**
|
|
```bash
|
|
sudo apt-get update
|
|
sudo apt-get install -y sshfs
|
|
```
|
|
|
|
2. **Garantir que o usuário `deploy` da VPS 4 tem acesso SSH sem senha à VPS 1:**
|
|
Adicione a chave SSH pública (`~/.ssh/id_ed25519.pub`) do usuário `deploy` da VPS 4 no arquivo `/home/deploy/.ssh/authorized_keys` da VPS 1.
|
|
|
|
3. **Criar a pasta de montagem na VPS de destino (VPS 4):**
|
|
```bash
|
|
mkdir -p /home/deploy/instrucoes
|
|
```
|
|
|
|
4. **Montar o diretório manualmente para testar:**
|
|
```bash
|
|
sshfs deploy@10.99.0.1:/home/deploy/instrucoes /home/deploy/instrucoes -o IdentityFile=/home/deploy/.ssh/id_ed25519 -o allow_other -o reconnect -o ServerAliveInterval=15
|
|
```
|
|
|
|
5. **Tornar a montagem permanente pós-reboot (fstab):**
|
|
Adicione a seguinte linha ao final do arquivo `/etc/fstab` na VPS de destino:
|
|
```text
|
|
deploy@10.99.0.1:/home/deploy/instrucoes /home/deploy/instrucoes fuse.sshfs x-systemd.automount,IdentityFile=/home/deploy/.ssh/id_ed25519,allow_other,reconnect,ServerAliveInterval=15,ServerAliveCountMax=3,_netdev 0 0
|
|
```
|
|
|
|
---
|
|
|
|
## 🚀 Opção 4: Rsync Automatizado via Cron (Espelhamento Simples)
|
|
|
|
Se os agentes nas outras VPSs precisam apenas ler as instruções ou executar instaladores (como o `install.sh`) e você quer uma solução extremamente leve e direta sem montagens de disco.
|
|
|
|
### Script de sincronização unidirecional (VPS 1 -> VPS de Destino):
|
|
|
|
Na **VPS 1**, crie um script simples ou configure uma tarefa recorrente no Cron para enviar as atualizações:
|
|
|
|
```bash
|
|
# Sincroniza a pasta de instruções para a VPS 4 através da VPN segura
|
|
rsync -avz --delete -e "ssh -i /home/deploy/.ssh/id_ed25519" /home/deploy/instrucoes/ deploy@10.99.0.4:/home/deploy/instrucoes/
|
|
```
|
|
|
|
Você pode programar isso para rodar a cada hora ou a cada 15 minutos de forma silenciosa e imperceptível.
|
|
|
|
---
|
|
|
|
## 🎯 Veredito: Qual escolher?
|
|
|
|
* **Escolha o Git Privado (Opção 1)** se você deseja que múltiplos agentes (incluindo IAs) façam alterações nos scripts e nos documentos de forma colaborativa, sem riscos de conflitos cegos de escrita e mantendo histórico de auditoria perfeito.
|
|
* **Escolha o SSHFS (Opção 3)** se você quer facilidade máxima de implementação imediata: a pasta fica unificada, consome armazenamento físico de apenas uma máquina e reflete edições instantaneamente sem sincronizações adicionais.
|