Introdução

Quer rodar serviços pesados em um servidor potente em casa, mesmo com o seu provedor te colocando atrás de CGNAT? Este guia mostra exatamente como colocá-los online — do jeito clássico e à prova de balas, usando túneis SSH reversos.

Sem Cloudflare Tunnel. Sem Ngrok. Só SSH + systemd.

As desvantagens (e por que dá para lidar com elas)

• Internet de casa não tem a qualidade de um datacenter (quedas acontecem)
• A maioria dos provedores usa CGNAT → não dá para abrir portas do jeito normal

Solução: use uma VPS barata como “ponte” pública. Seu servidor pesado fica em casa. A VPS só encaminha as portas.

Como funciona – a mágica dos túneis SSH reversos (-R)

Internet → Cheap VPS (public IP) → SSH reverse tunnel → Your home server (behind CGNAT)

O seu servidor de casa abre uma conexão SSH de saída até a VPS e diz: “Tudo o que chegar na sua porta 8096 → mande para o meu Jellyfin local na 8096”

Nenhuma porta aberta no roteador de casa. Nenhuma exposição.

Configuração passo a passo

1. No seu servidor de casa (o potente)

# Create folder for tunnel configs
sudo mkdir -p /etc/sshtunnels

# Example: expose Jellyfin (port 8096)
sudo nano /etc/sshtunnels/jellyfin.conf

Conteúdo do arquivo:

8096:8096   # remote_port:local_port
443:8443    # optional: HTTPS reverse proxy on VPS → your local 8443
80:8080

Uma linha por serviço. O primeiro número = porta na VPS, o segundo = porta no seu servidor de casa.

2. Gere uma chave SSH (se você ainda não tiver uma)

ssh-keygen -t ed25519 -C "home-server-tunnel"

Copie a chave pública para a sua VPS:

ssh-copy-id user@your-vps-ip

3. Crie o script que gerencia os túneis

sudo nano /usr/local/bin/sshtunnel.sh

#!/bin/bash

# === EDIT THESE ===
REMOTE_USER="root"                  # or your VPS user
REMOTE_HOST="123.45.67.89"          # your VPS public IP
SSH_KEY="/home/youruser/.ssh/id_ed25519"
SSH_PORT="22"                       # change if you use a non-standard port
# ==================

INSTANCE="$1"
CONFIG_FILE="/etc/sshtunnels/${INSTANCE}.conf"

if [[ ! -f "$CONFIG_FILE" ]]; then
    echo "Error: Config file $CONFIG_FILE not found!"
    exit 1
fi

# Build -R arguments
FORWARD_OPTS=""
while IFS=: read -r remote_port local_port; do
    [[ -z "$remote_port" || "$remote_port" =~ ^# ]] && continue
    # Clean any old process using the remote port
    ssh -p "$SSH_PORT" "$REMOTE_USER@$REMOTE_HOST" \
        "lsof -i :$remote_port -t | xargs -r kill -9" 2>/dev/null
    FORWARD_OPTS="$FORWARD_OPTS -R $remote_port:localhost:$local_port"
done < "$CONFIG_FILE"

echo "Starting tunnel $INSTANCE → $REMOTE_HOST ($FORWARD_OPTS)"

exec ssh -o StrictHostKeyChecking=no \
     -o ServerAliveInterval=30 \
     -o ServerAliveCountThreshold=3 \
     -o ExitOnForwardFailure=yes \
     -o GatewayPorts=yes \
     -N -T \
     -i "$SSH_KEY" \
     -p "$SSH_PORT" \
     $FORWARD_OPTS \
     "$REMOTE_USER@$REMOTE_HOST"

Torne-o executável:

sudo chmod +x /usr/local/bin/sshtunnel.sh

4. Crie um serviço do systemd (início e reconexão automáticos)

sudo nano /etc/systemd/system/sshtunnel@.service

[Unit]
Description=SSH Reverse Tunnel for %i
After=network-online.target
Wants=network-online.target

[Service]
User=youruser              # ← change to your home user (not root!)
Group=youruser
ExecStart=/usr/local/bin/sshtunnel.sh %i
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Recarregue e ative:

sudo systemctl daemon-reload

# Start a tunnel (example: jellyfin)
sudo systemctl enable --now sshtunnel@jellyfin.service

Confira o status:

sudo systemctl status sshtunnel@jellyfin.service

5. No lado da VPS (opcional, mas recomendado)

Instale um servidor web pequeno ou o Caddy/nginx para cuidar do TLS e fazer proxy para as portas encaminhadas.

Exemplo com o Caddy (HTTPS automático):

# On the VPS
apt install caddy

# /etc/caddy/Caddyfile
jellyfin.yourdomain.com {
    reverse_proxy localhost:8096
}

Agora jellyfin.yourdomain.com → o seu Jellyfin de casa, totalmente criptografado.

Tudo rodando no meu servidor parrudo de casa, atrás de CGNAT.

Vantagens desta configuração

• Funciona atrás de qualquer CGNAT / bloqueio do provedor
• Nenhuma dependência de terceiros (sem Cloudflare, sem Ngrok)
• Criptografia completa possível
• Sobrevive a reinicializações (systemd + Restart=always)
• Custa quase nada

Palavras finais

Este é o jeito realmente bacana que encontrei para hospedar serviços pesados em casa em 2025.

O seu hardware potente fica em casa. A sua VPS de US$ 1/mês é só uma guarda de trânsito.

Obrigado pela leitura — agora vá montar o seu home lab imbatível!