3 máquinas, Tailscale e SSH: montei minha própria mesh

O problema

Imagine que eu tenho três computadores diferentes: uma máquina na nuvem da Oracle (oracle-cloud-tiago), o meu PC físico que fica na minha casa (pc-tiago) e um servidor virtual alugado na empresa Hetzner (tiago). Por muito tempo, eu lidava com cada um deles como se fossem ilhas isoladas. Sempre que precisava mexer em um, tinha que abrir um programa de acesso remoto, digitar um endereço de IP (que é como se fosse o “número de telefone” do computador na internet) e torcer para dar tudo certo.

Numa terça-feira à noite, me fiz uma pergunta bem direta: “será que eu consigo fazer essas três máquinas se enxergarem juntas?”. A resposta mudou completamente o meu jeito de trabalhar.

O que eu queria não era só acessar uma máquina de cada vez. Eu queria criar uma rede em malha (mesh): um sistema inteligente onde qualquer um dos meus computadores pudesse conversar com qualquer outro de forma direta. Queria que a rede inteira se visse sem que eu precisasse decorar endereços de IP, sem precisar “abrir portas” no roteador da minha casa (o que pode ser um risco de segurança) e sem pagar um centavo por VPNs corporativas caras.

Descobrindo que eu já tinha a rede

O primeiro comando que rodei no meu terminal (a tela preta onde digitamos comandos no computador) foi tailscale status. E ali, sem eu perceber, a rede que eu queria já existia — só estava metade adormecida:

100.x.x.x   oracle-cloud-tiago    aerotg@  linux
100.x.x.x    pc-tiago              aerotg@  linux
100.x.x.x   tiago                 aerotg@  linux

Cada linha dessas representa uma máquina minha, acompanhada de um IP fixo que começa com 100.x.x.x (que é o intervalo de IPs do Tailscale, um serviço que cria redes privadas).

Esse é o segredo que muita gente que nunca usou o Tailscale demora para entender: esses endereços de IP só funcionam e podem ser acessados dentro da sua própria rede pessoal. Eles não existem na internet pública, ninguém de fora consegue ver. Qualquer uma das minhas três máquinas consegue conversar com a outra usando esse IP 100.x, e todas as informações trafegam protegidas por uma criptografia ponta a ponta super segura chamada WireGuard, sem que eu precise configurar senhas ou chaves complexas manualmente.

O meu celular (iphone172) também apareceu nessa lista assim que conectei o aplicativo do Tailscale nele. Isso mostra que a rede não serve só para servidores Linux: qualquer dispositivo com o aplicativo instalado entra na mesma “teia”. Isso inclui computadores com Windows, macOS, celulares com Android ou iOS, além de sistemas de armazenamento como Synology e minicomputadores como Raspberry Pi.

O vilão da experiência: Remmina em 24 bits

Enxergar a rede foi a parte fácil. O problema real era quando eu tentava usar a interface gráfica — ou seja, ver a “tela” do outro computador. Eu tentava acessar o servidor da Oracle a partir do meu PC de casa usando um aplicativo chamado Remmina, mas a lentidão (o famoso lag) era absurda: a janela arrastava travando, o mouse tremia e dava a sensação de estar controlando um computador no espaço via satélite.

Descobri o motivo do problema lendo o arquivo de configurações do Remmina (~/.local/share/remmina/oracle_vm_kiosk.remmina), que guarda os dados de cada conexão como se fosse um arquivo de texto .ini. O vilão estava escondido aqui:

colordepth=24
sound=on
quality=best

Explicando o que isso significa:

Profundidade de cor em 24 bits (colordepth=24): faz o computador enviar imagens super detalhadas (True Color), gerando uma quantidade gigantesca de dados pesados pela rede.
Som ligado (sound=on): fica empurrando transmissões de áudio em tempo real sem necessidade.
Qualidade no máximo (quality=best): força o sistema a priorizar uma imagem bonita e perfeita em vez de uma navegação rápida e fluida.

Era a pior combinação possível para uma conexão de computadores que estão em continentes diferentes!

A correção foi direta e precisa:

colordepth=16
sound=off
quality=fast

Ao reduzir a cor para 16 bits, cortei quase pela metade o volume de dados transmitidos. Desligar o som eliminou um envio de áudio que eu nem usava. E mudar a qualidade para “fast” (rápido) fez o servidor focar em deixar o movimento da tela suave, mesmo que perdesse um pouquinho de nitidez. A melhoria foi imediata: a janela parou de travar e o mouse voltou a responder na hora.

Para melhorar ainda mais, mudei o endereço do servidor no aplicativo para usar o IP do Tailscale (100.x.x.x) no lugar do IP público da Oracle. Trafegar pela rede interna do Tailscale é muito mais estável e seguro. Assim, posso deixar o firewall (o escudo de proteção) da máquina da Oracle totalmente fechado para acessos externos de área de trabalho (RDP) e continuar acessando tudo tranquilamente por dentro da minha rede privada.

SSH: a parte que realmente importa

O Remmina resolveu o acesso visual, mas o trabalho pesado do dia a dia acontece no terminal de texto via SSH (uma ferramenta que permite mandar comandos de texto de forma segura para outro computador). Com as três máquinas unidas pelo mesmo Tailscale, posso usar o SSH para saltar de qualquer uma para qualquer outra sem complicação:

ssh aerotg@100.x.x.x   # do Oracle pro PC físico
ssh aerotg@100.x.x.x  # do PC pro Oracle

Para transformar isso em uma rede em malha de verdade — e não apenas três caminhos isolados —, fiz três ajustes fundamentais.

Primeiro: criei uma chave de acesso digital (sem senha) e a copiei entre todos os computadores usando o comando ssh-copy-id. Quando a chave pública de um computador é salva no arquivo de autorizações (authorized_keys) do outro, o acesso passa a ser instantâneo, sem pedir senha toda vez:

ssh-keygen -t ed25519 -C "mesh" -f ~/.ssh/id_mesh -N ""
ssh-copy-id -i ~/.ssh/id_mesh.pub aerotg@100.x.x.x

Segundo: configurei o arquivo de atalhos do SSH (~/.ssh/config). Em vez de ter que memorizar números de IP complicados, criei apelidos amigáveis para cada máquina:

Host oracle
    HostName 100.x.x.x
    User aerotg
    IdentityFile ~/.ssh/id_mesh

Host pctiago
    HostName 100.x.x.x
    User aerotg
    IdentityFile ~/.ssh/id_mesh

Host hetzner
    HostName 100.x.x.x
    User aerotg
    IdentityFile ~/.ssh/id_mesh

Agora, basta eu digitar ssh oracle e o sistema já sabe exatamente onde se conectar. Além disso, adicionei a configuração ControlMaster, que permite reaproveitar uma conexão que já está aberta para fazer novos acessos sem precisar autenticar de novo:

Host *
    ControlMaster auto
    ControlPath ~/.ssh/cm-%r@%h:%p
    ControlPersist 10m
    ServerAliveInterval 60

Terceiro: o grande truque do ProxyJump. Quando um computador não consegue enxergar o outro diretamente por algum motivo, eu posso usar uma terceira máquina que está no meio do caminho como “trampolim”:

Host hetzner-via-oracle
    HostName 100.x.x.x
    User aerotg
    ProxyJump oracle

Na prática, quase não preciso usar isso — porque o Tailscale deixa todas as máquinas no mesmo nível de comunicação (Camada 3 da rede) —, mas é uma garantia excelente para caso alguma máquina perca a conexão direta.

O hub no Cloudflare Tunnel

A rede privada estava resolvida. Faltava resolver um cenário específico: “e se eu estiver fora de casa, usando um computador simples como um Chromebook ou a internet de um hotel, e precisar abrir um terminal?”. A solução foi criar um ponto de entrada público na internet, usando um endereço seguro com HTTPS, mas sem expor as portas do computador da Oracle para invasores.

Aproveitei um recurso chamado Cloudflare Tunnel (que usa o programa cloudflared) que eu já tinha rodando e apontando para o meu domínio pc-tiago.com.br. A ideia foi criar um centralizador (hub) para reunir três tipos de acesso: a tela visual via Remmina, um acesso visual equivalente via NoMachine e o terminal de texto puro do usuário tiago na Oracle. Tudo acessível pela mesma URL pública, com login e protegido por criptografia HTTPS.

O pulo do gato do Cloudflare Tunnel é que ele cria uma conexão que nasce de dentro da minha máquina para fora, em direção aos servidores da Cloudflare. Ou seja, eu não preciso abrir nenhuma “porta de entrada” no roteador ou na máquina — a conexão é sempre iniciada internamente. Do lado de fora, a Cloudflare mostra o meu site e cuida de toda a segurança (TLS). É o modelo mais seguro que existe para disponibilizar um serviço na internet sem deixar a sua máquina vulnerável.

O que aprendi

A maior lição desse processo não foi sobre o Tailscale nem sobre o Remmina. Foi sobre perceber o potencial da rede que eu já tinha nas mãos. Eu passei meses com três máquinas na mesma rede privada e continuava tratando cada uma como se fosse isolada. Simplesmente rodar o comando tailscale status e prestar atenção no resultado fez mais pela minha produtividade do que qualquer ferramenta nova.

A segunda lição é que usar a tela visual (interface gráfica) nunca será tão rápido e leve quanto usar o terminal de texto. O Remmina melhorou muito quando mudei para 16 bits, o NoMachine é mais fluido, mas nada supera um SSH bem configurado com arquivos de atalho (ssh_config) e saltos de conexão (ProxyJump). A integração de verdade acontece quando consigo pular de um computador para outro digitando apenas duas letras e apertando Enter.

E a terceira lição: acesso público só deve ser feito por conexões que saem de dentro para fora. Eu nunca deixei uma porta de SSH exposta diretamente no IP público da Oracle. Todo acesso que vem de fora da rede do Tailscale passa obrigatoriamente pelo Cloudflare Tunnel. Se a Cloudflare passar por instabilidades, o endereço público apenas esconde o acesso — enquanto a minha rede privada continua funcionando perfeitamente intacta.