gatoflix/REDE-LOCAL.md

# Configuração para Rede Local

Este guia explica como configurar o Gatoflix Media Center para uso em rede doméstica **SEM exposição à internet**.

## Por que Let's Encrypt não funciona?

**Let's Encrypt NÃO funciona em redes locais** porque:

1. Let's Encrypt precisa validar que você controla o domínio
2. Servidores do Let's Encrypt acessam seu servidor via internet (porta 80 ou 443)
3. Em rede local doméstica sem IP público acessível, isso é impossível

## Opções para Rede Local

### Opção 1: HTTPS com Certificados Auto-Assinados (Configuração Atual)

O Caddyfile está configurado para usar `tls internal`, que gera certificados auto-assinados automaticamente.

**Vantagens:**
- Conexão criptografada (HTTPS)
- Zero configuração adicional
- Funciona offline

**Desvantagens:**
- Navegador mostrará aviso de certificado não confiável
- Precisa aceitar o certificado manualmente em cada dispositivo

**Como usar:**
1. Configure o `.env` com `DOMAIN=media.local`
2. Adicione entradas ao `/etc/hosts`:
```bash
sudo nano /etc/hosts

# Adicione estas linhas:
127.0.0.1 plex.media.local
127.0.0.1 transmission.media.local
127.0.0.1 jackett.media.local
127.0.0.1 sonarr.media.local
127.0.0.1 radarr.media.local
127.0.0.1 bazarr.media.local
```

3. Inicie os containers:
```bash
docker-compose up -d
```

4. Acesse via HTTPS:
   - `https://plex.media.local`
   - `https://sonarr.media.local`
   - etc.

5. **Aceite o aviso de segurança:**
   - Chrome/Edge: Clique em "Avançado" → "Continuar para media.local"
   - Firefox: Clique em "Avançado" → "Aceitar o risco e continuar"

### Opção 2: HTTP sem SSL (Mais Simples)

Se preferir evitar avisos de certificado, use HTTP puro (sem criptografia).

**Vantagens:**
- Sem avisos de certificado
- Acesso direto sem aceitar nada

**Desvantagens:**
- Conexão não criptografada
- Senhas trafegam em texto claro na rede

**Como usar:**

1. Edite o `Caddyfile` e **comente** todos os blocos HTTPS:
```caddyfile
# plex.{$DOMAIN} {
#     tls internal
#     reverse_proxy plex:32400
# }
```

2. **Descomente** os blocos HTTP no final do arquivo:
```caddyfile
http://plex.{$DOMAIN} {
    reverse_proxy plex:32400
}

http://transmission.{$DOMAIN} {
    reverse_proxy transmission:9091
}

# ... etc
```

3. Reinicie o Caddy:
```bash
docker-compose restart caddy
```

4. Acesse via HTTP:
   - `http://plex.media.local`
   - `http://sonarr.media.local`
   - etc.

### Opção 3: Sem Caddy - Portas Diretas

Se não quiser usar proxy reverso, pode acessar diretamente pelas portas.

**Como usar:**

1. Edite `docker-compose.yml` e exponha as portas:
```yaml
services:
  sonarr:
    ports:
      - 8989:8989

  radarr:
    ports:
      - 7878:7878

  bazarr:
    ports:
      - 6767:6767

  jackett:
    ports:
      - 9117:9117
```

2. Remova ou pare o container do Caddy:
```bash
docker-compose stop caddy
```

3. Acesse diretamente pelo IP:
   - `http://localhost:8989` (Sonarr)
   - `http://localhost:7878` (Radarr)
   - `http://localhost:32400/web` (Plex)
   - etc.

## Acesso de outros dispositivos na rede

### Configurar /etc/hosts em outros dispositivos

**Linux/macOS:**
```bash
sudo nano /etc/hosts

# Substitua 192.168.1.100 pelo IP do seu servidor
192.168.1.100 plex.media.local
192.168.1.100 sonarr.media.local
192.168.1.100 radarr.media.local
192.168.1.100 transmission.media.local
192.168.1.100 jackett.media.local
192.168.1.100 bazarr.media.local
```

**Windows:**
1. Abra o Bloco de Notas como Administrador
2. Abra: `C:\Windows\System32\drivers\etc\hosts`
3. Adicione as mesmas linhas acima

**Android:**
- Requer root ou app como "Hosts Editor"

**iOS:**
- Requer jailbreak ou usar DNS local

### Opção Melhor: DNS Local

Configure um servidor DNS local (Pi-hole, AdGuard Home, ou router DNS):

1. Adicione registros A apontando para o IP do servidor:
```
plex.media.local       → 192.168.1.100
sonarr.media.local     → 192.168.1.100
radarr.media.local     → 192.168.1.100
transmission.media.local → 192.168.1.100
jackett.media.local    → 192.168.1.100
bazarr.media.local     → 192.168.1.100
```

2. Configure DHCP do roteador para usar o DNS local

3. Todos os dispositivos da rede resolverão automaticamente!

## mDNS/Avahi (Alternativa Avançada)

Para usar `.local` sem editar hosts:

1. Instale Avahi no servidor:
```bash
sudo apt install avahi-daemon
```

2. Configure para responder por múltiplos nomes

3. Dispositivos Apple (macOS, iOS) resolverão automaticamente
4. Linux com avahi também resolve
5. Windows precisa de Bonjour Print Services

## Resumo - Recomendação

**Para uso doméstico simples:**
- Use **Opção 2 (HTTP sem SSL)**
- Configure `/etc/hosts` em cada dispositivo
- OU configure DNS local no roteador

**Para segurança adicional:**
- Use **Opção 1 (HTTPS com certificados auto-assinados)**
- Aceite os certificados uma vez em cada navegador/dispositivo
- Conexão criptografada mesmo em rede local

**Para máxima simplicidade:**
- Use **Opção 3 (sem Caddy)**
- Acesse direto pelo IP:porta
- Sem subdomínios, sem proxy

## Migração para Internet (Futuro)

Se futuramente quiser expor na internet com Let's Encrypt:

1. Registre um domínio real
2. Configure DNS A/AAAA para seu IP público
3. Abra portas 80 e 443 no roteador
4. Edite `Caddyfile`:
   - Remova `tls internal` de todos os serviços
   - Adicione email no global options:
```caddyfile
{
    email seu@email.com
}
```
5. Reinicie: `docker-compose restart caddy`
6. Caddy obterá certificados Let's Encrypt automaticamente!