Tailscale para Homelab: VPN Mesh sin Abrir Puertos (Guía Completa 2025)

Si tienes un homelab y quieres acceder a tus servicios desde cualquier lugar sin abrir puertos en tu router, sin configurar complejas VPNs tradicionales, y sin pagar por IPs estáticas, Tailscale es la solución.

En esta guía te explico qué es Tailscale, cómo funciona su magia de NAT traversal, cómo instalarlo en tu homelab (Docker incluido), y casos de uso reales que van desde acceso remoto seguro hasta conectar múltiples homelabs distribuidos geográficamente.

¿Qué es Tailscale?

Tailscale es una VPN mesh moderna basada en WireGuard que crea una red privada entre tus dispositivos sin necesidad de abrir puertos, configurar routers, o gestionar certificados.

Características principales

✅ Zero-config NAT traversal: Funciona detrás de CG-NAT, firewalls corporativos, 4G/5G
✅ Basado en WireGuard: El protocolo VPN más rápido y seguro actual
✅ Mesh networking: Cada dispositivo se conecta directamente con los demás (peer-to-peer)
✅ 100 dispositivos gratis: El tier gratuito es generoso
✅ Multi-plataforma: Linux, Windows, macOS, iOS, Android, BSD
✅ ACLs granulares: Control de acceso por usuario, dispositivo, subnet
✅ Magic DNS: Resuelve nombres de dispositivos automáticamente (server.tail-scale.ts.net)
✅ Subnet routing: Expone redes completas (ej: 192.168.1.0/24)
✅ Exit nodes: Usa un dispositivo como punto de salida (VPN tradicional)

Cómo funciona (sin magia)

• Control plane (coordinación): Servidores de Tailscale intercambian claves públicas y descubren IPs
• Data plane (tráfico real): Conexiones directas WireGuard entre dispositivos (P2P)
• DERP relays: Si P2P falla (firewalls agresivos), usa relays encriptados como fallback

El tráfico NUNCA pasa por servidores de Tailscale en modo P2P (solo metadata de coordinación).

¿Por qué Tailscale y no OpenVPN/WireGuard manual?

Veredicto:

• Facilidad y features: Tailscale gana
• Control y privacidad absoluta: WireGuard manual
• Compatibilidad legacy: OpenVPN

Casos de Uso Reales en Homelabs

1. Acceso remoto a servicios homelab (uso principal)

Accede a Portainer, n8n, Jellyfin, Home Assistant desde el móvil sin exponer nada a Internet.

Antes (inseguro):

# Abrir puertos en router
# Riesgo: expones servicios a scanners, bots, ataques
Router: 8080 → 192.168.1.100:8080 (Portainer)

Después (seguro con Tailscale):

# Sin puertos abiertos, acceso cifrado WireGuard
http://homelab-server:8080  # MagicDNS resuelve automáticamente

2. Conectar múltiples homelabs (mesh multi-site)

Tienes un homelab en casa y otro en casa de tus padres/amigos. Conecta ambos como si estuvieran en la misma LAN.

Casa:       192.168.1.0/24 (subnet routing)
Trabajo:    10.0.0.0/24 (subnet routing)
VPS cloud:  172.16.0.0/24

Tailscale mesh → Todos se ven entre sí

Caso real: Sincronizar backups entre homelabs, acceder a NAS remoto, distribuir carga de procesamiento.

3. Exit node (VPN tradicional)

Usa tu homelab como punto de salida cuando estás en WiFi pública.

# Configurar exit node en tu servidor homelab
tailscale up --advertise-exit-node

# En el móvil: activar exit node → Todo el tráfico va por tu homelab

Beneficios:

• IP fija de tu homelab
• Cifrado WireGuard en WiFis inseguras
• Acceso a servicios que bloquean VPNs comerciales

4. Desarrollo remoto con VS Code

Conecta VS Code en laptop a servidores remotos sin configurar SSH keys o tunnels.

# En VS Code Remote SSH:
ssh user@homelab-server  # MagicDNS + Tailscale = funciona directo

5. Juegos LAN remotos (Minecraft, Valheim, etc.)

Juega con amigos como si estuvieran en la misma LAN.

# Servidor Minecraft en tu homelab (sin port forward)
Server IP: homelab-server:25565

# Amigos instalan Tailscale → Conectan a tu red mesh → Juegan

Instalación Paso a Paso

Opción 1: Instalación en Linux (nativo)

Ubuntu/Debian:

# Añadir repositorio oficial
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.noarmor.gpg | sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg >/dev/null
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.tailscale-keyring.list | sudo tee /etc/apt/sources.list.d/tailscale.list

# Instalar
sudo apt update
sudo apt install tailscale

# Iniciar y autenticar
sudo tailscale up

# Verificar conexión
tailscale status

Arch Linux:

sudo pacman -S tailscale
sudo systemctl enable --now tailscaled
sudo tailscale up

Opción 2: Docker (recomendado para homelabs)

Si eres nuevo en Docker, revisa primero nuestra guía completa de Docker para novatos.

docker-compose.yml:

version: '3.8'

services:
  tailscale:
    image: tailscale/tailscale:latest
    container_name: tailscale
    hostname: homelab-docker
    environment:
      - TS_AUTH_KEY=${TS_AUTH_KEY}  # Generar en https://login.tailscale.com/admin/settings/keys
      - TS_ROUTES=192.168.1.0/24     # Subnet routing (opcional)
      - TS_STATE_DIR=/var/lib/tailscale
      - TS_EXTRA_ARGS=--advertise-exit-node --accept-routes  # Exit node (opcional)
    volumes:
      - tailscale-data:/var/lib/tailscale
      - /dev/net/tun:/dev/net/tun
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    network_mode: host  # Necesario para subnet routing
    restart: unless-stopped

volumes:
  tailscale-data:

Generar TS_AUTH_KEY:

# 1. Ve a https://login.tailscale.com/admin/settings/keys
# 2. Genera Auth Key (reusable, no expira recomendado para servers)
# 3. Guarda en .env:
echo "TS_AUTH_KEY=tskey-auth-XXXXXX" > .env

# Iniciar
docker compose up -d

# Verificar
docker logs tailscale
docker exec tailscale tailscale status

Opción 3: Instalación en Synology NAS

# Desde Package Center:
1. Buscar "Tailscale" en Community
2. Instalar
3. Abrir → Configurar
4. Autenticar con cuenta Tailscale

# O via SSH (DSM 7+):
sudo synopkg install Tailscale
sudo tailscale up

Opción 4: Windows/macOS/Mobile

Windows/macOS:

• Descarga desde https://tailscale.com/download
• Instala
• Autentica con Google/GitHub/Microsoft

iOS/Android:

• App Store / Play Store → “Tailscale”
• Instala → Login → Conecta

Subnet Routing: Exponer tu LAN completa

Por defecto, solo el dispositivo con Tailscale es accesible. Para acceder a TODA tu red local (ej: impresoras, IoT, NAS sin Tailscale):

1. Configurar subnet router

En el servidor con Tailscale (Linux):

# Habilitar IP forwarding
echo 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
echo 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
sudo sysctl -p /etc/sysctl.d/99-tailscale.conf

# Anunciar subnet
sudo tailscale up --advertise-routes=192.168.1.0/24

# Verificar
tailscale status

En Docker:

# Ya incluido en el docker-compose.yml anterior
environment:
  - TS_ROUTES=192.168.1.0/24

2. Aprobar subnet en admin console

# 1. Ve a https://login.tailscale.com/admin/machines
# 2. Encuentra tu servidor
# 3. Edit route settings → Approve subnets

3. Usar en clientes

En laptop/móvil:

# Habilitar aceptar rutas
tailscale up --accept-routes

# Ahora puedes acceder a TODA la LAN:
http://192.168.1.10  # Raspberry Pi
http://192.168.1.50  # Impresora
ssh user@192.168.1.100  # NAS

Exit Nodes: VPN Tradicional Mode

Usa tu homelab como salida a Internet (útil en WiFis públicas o para IP fija).

Configurar exit node (servidor)

# En tu servidor homelab:
sudo tailscale up --advertise-exit-node

# Aprobar en admin console:
# https://login.tailscale.com/admin/machines → Edit → Allow as exit node

Usar exit node (cliente)

Linux/macOS:

tailscale set --exit-node=homelab-server

Windows/iOS/Android:

• Abrir app Tailscale
• Tap en “Exit node”
• Seleccionar servidor

Verificar:

curl ifconfig.me  # Debería mostrar IP pública de tu homelab

Desactivar:

tailscale set --exit-node=

MagicDNS: Resolución de Nombres Automática

Por defecto, Tailscale asigna IPs como 100.64.0.5. MagicDNS te da nombres legibles.

Activar MagicDNS

# 1. Ve a https://login.tailscale.com/admin/dns
# 2. Enable MagicDNS
# 3. (Opcional) Custom nameservers: 1.1.1.1, 8.8.8.8

Usar MagicDNS

# Antes:
ssh user@100.64.0.5

# Después:
ssh user@homelab-server
ping laptop.tail-scale.ts.net
http://portainer:9000

Custom hostnames:

# Cambiar hostname:
sudo tailscale up --hostname=mi-servidor-cool

ACLs: Control de Acceso Granular

Por defecto, todos los dispositivos en tu Tailnet pueden acceder entre sí. ACLs permiten control fino.

Ejemplo: Separar dispositivos personales y trabajo

En https://login.tailscale.com/admin/acls:

{
  "groups": {
    "group:homelab": ["user@example.com"],
    "group:mobile": ["user@example.com"]
  },
  "acls": [
    {
      "action": "accept",
      "src": ["group:mobile"],
      "dst": ["group:homelab:*"]
    },
    {
      "action": "accept",
      "src": ["group:homelab"],
      "dst": ["*:*"]
    }
  ],
  "ssh": [
    {
      "action": "accept",
      "src": ["group:homelab"],
      "dst": ["group:homelab"],
      "users": ["autogroup:nonroot", "root"]
    }
  ]
}

Explicación:

• Mobile puede acceder a homelab
• Homelab puede acceder a todo
• Solo homelab puede SSH

Ejemplo: Bloquear acceso a subnet específica

{
  "acls": [
    {
      "action": "accept",
      "src": ["*"],
      "dst": ["*:*"]
    },
    {
      "action": "deny",
      "src": ["tag:mobile"],
      "dst": ["192.168.1.10:*"]  # Bloquear acceso a un dispositivo
    }
  ]
}

Tailscale SSH: SSH sin Claves

Tailscale puede gestionar SSH automáticamente (sin configurar ~/.ssh/authorized_keys).

Activar Tailscale SSH

En servidor:

sudo tailscale up --ssh

Desde cliente:

ssh user@homelab-server  # Autentica automáticamente

Ventajas:

• No necesitas gestionar SSH keys
• ACLs de Tailscale controlan quién puede SSH
• Logs centralizados en Tailscale admin

Troubleshooting

Error: “Cannot establish connection”

Causa: Firewall bloquea WireGuard (UDP 41641).

Solución:

# Linux: Permitir UDP 41641
sudo ufw allow 41641/udp

# Verificar conectividad a DERP relays
tailscale netcheck

Error: “Subnet route not working”

Causa: IP forwarding no habilitado.

Solución:

# Verificar:
sysctl net.ipv4.ip_forward  # Debe ser 1

# Si es 0:
sudo sysctl -w net.ipv4.ip_forward=1
echo 'net.ipv4.ip_forward=1' | sudo tee -a /etc/sysctl.conf

Error: “Exit node slow”

Causa: Usando DERP relay en lugar de P2P.

Solución:

# Ver conexión real:
tailscale status --json | jq '.Peer[] | {name:.HostName, relay:.Relay, direct:.CurAddr}'

# Si muestra relay en lugar de direct → Firewall bloquea P2P
# Abrir UDP 41641 o configurar port forwarding en router

Eliminar dispositivo de Tailnet

# Desde admin console:
# https://login.tailscale.com/admin/machines → ... → Remove

# Desde dispositivo:
sudo tailscale down
sudo tailscale logout

Alternativas a Tailscale

Headscale (selfhosted Tailscale)

Qué es: Implementación open-source del control plane de Tailscale.

Ventajas:

• Control total (selfhosted)
• Sin límite de dispositivos
• Sin dependencia de SaaS

Desventajas:

• Requiere servidor público con IP estática
• Más complejo de configurar
• Sin admin UI oficial (hay terceros)

Cuándo usar Headscale:

• Necesitas +100 dispositivos
• Privacidad extrema (no confías en Tailscale Inc.)
• Compliance/regulaciones que prohíben SaaS

ZeroTier

Comparación:

Veredicto: Tailscale es más moderno, rápido (WireGuard) y con mejores ACLs.

Netbird

Qué es: Alternativa open-source a Tailscale con UI selfhosted.

Ventajas:

• Completamente open-source
• Selfhosted con UI bonita
• WireGuard también

Desventajas:

• Comunidad más pequeña
• Menos features que Tailscale

Best Practices para Homelabs

1. Usa tags para organizar dispositivos

# En admin console → Machines → Edit tags
Tags: homelab, production, docker

2. Configura DNS custom para LAN

# En https://login.tailscale.com/admin/dns
Nameservers:
- 192.168.1.1 (tu router/Pi-hole)
- 1.1.1.1 (fallback)

3. Habilita Tailscale SSH en todos los servers

sudo tailscale up --ssh

4. Monitorea conexiones activas

# Ver status completo
tailscale status --json | jq

# Ver solo conexiones P2P
tailscale status | grep "direct"

# Logs
sudo journalctl -u tailscaled -f

5. Backups de ACLs (GitOps)

# Versiona tus ACLs en Git
# https://tailscale.com/kb/1018/acls/#gitops

# Exportar ACLs:
tailscale configure acls > acls.json
git add acls.json && git commit -m "Update ACLs"

Monitoreo y Observabilidad con Tailscale

Una vez que tienes Tailscale funcionando, es importante monitorear el estado de las conexiones y diagnosticar problemas.

Ver estado de conexiones en tiempo real

# Status básico
tailscale status

# Status detallado con IPs
tailscale status --json | jq

# Solo mostrar conexiones directas (P2P)
tailscale status | grep "direct"

# Ver latencia a cada dispositivo
tailscale ping homelab-server
tailscale ping laptop

Verificar tipo de conexión (P2P vs DERP)

Es importante saber si tus dispositivos están conectados directamente (rápido) o via relay (más lento):

# Ver detalles de conexión
tailscale status --json | jq '.Peer[] | {name:.HostName, relay:.Relay, direct:.CurAddr, latency:.LastSeen}'

# Output ejemplo:
{
  "name": "homelab-server",
  "relay": "",  # Vacío = conexión directa ✅
  "direct": "192.168.1.100:41641",
  "latency": "2024-10-25T10:30:15Z"
}

{
  "name": "mobile-phone",
  "relay": "sfo",  # Usando relay de San Francisco ⚠️
  "direct": "",
  "latency": "2024-10-25T10:30:10Z"
}

Si ves relays constantemente:

• Firewall está bloqueando UDP 41641
• Estás en red muy restrictiva (corporativa)
• Considera abrir puerto o usar UPnP

Diagnóstico de conectividad

# Test completo de conectividad
tailscale netcheck

# Output ejemplo:
    * UDP: true
    * IPv4: yes, 203.0.113.45:41641
    * IPv6: yes, [2001:db8::1]:41641
    * MappingVariesByDestIP: false
    * HairPinning: true
    * PortMapping: UPnP
    * Nearest DERP: San Francisco
    * DERP latency:
        - sfo: 12ms (San Francisco)
        - lax: 45ms (Los Angeles)
        - nyc: 78ms (New York)

Logs y debugging

# Ver logs en tiempo real (Linux con systemd)
sudo journalctl -u tailscaled -f

# Ver logs de conexiones específicas
sudo journalctl -u tailscaled --since "10 minutes ago" | grep "connection"

# Aumentar verbosidad
sudo tailscale up --verbose

# Docker logs
docker logs -f tailscale

Métricas con Prometheus (avanzado)

Tailscale expone métricas en formato Prometheus:

# Habilitar métricas
sudo tailscale up --metrics-listen=:9001

# Scrape desde Prometheus
curl http://localhost:9001/metrics

Prometheus scrape config:

scrape_configs:
  - job_name: 'tailscale'
    static_configs:
      - targets: ['homelab-server:9001']

Métricas útiles:

• tailscale_peer_connection_state – Estado de conexión P2P
• tailscale_derp_home_relay – Relay actual
• tailscale_bytes_sent_total – Tráfico enviado
• tailscale_bytes_recv_total – Tráfico recibido

Alertas con Uptime Kuma

Si usas Uptime Kuma para monitorear tu homelab, puedes añadir checks de Tailscale:

# Crear endpoint de health check
echo '#!/bin/bash
tailscale status | grep -q "homelab-server" && echo "OK" || exit 1' > /usr/local/bin/tailscale-health.sh
chmod +x /usr/local/bin/tailscale-health.sh

# Exponer via HTTP (puerto 9002)
while true; do
  echo -e "HTTP/1.1 200 OK\n\n$(tailscale status)" | nc -l -p 9002 -q 1
done &

En Uptime Kuma:

• Type: HTTP(S)
• URL: http://homelab-server:9002
• Expected: 200

Casos de Uso Avanzados

1. Site-to-Site VPN entre Homelabs

Conecta tu homelab con el de un amigo/familiar para compartir recursos:

Setup:

# Homelab A (casa):
sudo tailscale up --advertise-routes=192.168.1.0/24 --hostname=homelab-casa

# Homelab B (oficina):
sudo tailscale up --advertise-routes=10.0.0.0/24 --hostname=homelab-oficina

# Aprobar rutas en admin console
# Ahora ambas LANs se ven mutuamente

Casos de uso:

• Backups distribuidos (rsync entre NAS)
• Load balancing de procesamiento IA (útil si despliegas Kubernetes para IA)
• Redundancia de servicios críticos
• Colaboración en proyectos (compartir Gitlab, n8n, etc.)

2. Tailscale como Ingress para Kubernetes

Expone servicios K8s sin Ingress controller público:

# Instalar operador Tailscale
kubectl apply -f https://github.com/tailscale/tailscale/releases/latest/download/operator.yaml

# Crear servicio con anotación
apiVersion: v1
kind: Service
metadata:
  name: nginx
  annotations:
    tailscale.com/expose: "true"
    tailscale.com/hostname: "nginx-k8s"
spec:
  type: LoadBalancer
  selector:
    app: nginx
  ports:
    - port: 80

Acceso: http://nginx-k8s (via MagicDNS)

3. Tailscale + Cloudflare Tunnel (double VPN)

Combina Tailscale (acceso privado) con Cloudflare Tunnel (acceso público selectivo):

# docker-compose.yml
services:
  cloudflared:
    image: cloudflare/cloudflared:latest
    command: tunnel --no-autoupdate run --token ${CF_TOKEN}
    network_mode: "service:tailscale"  # Usa red de Tailscale
    depends_on:
      - tailscale

  tailscale:
    image: tailscale/tailscale:latest
    # ... configuración normal

Resultado:

• Acceso privado via Tailscale (para ti)
• Acceso público via Cloudflare (para visitantes)
• Un solo servidor ejecuta ambos

4. Desarrollo multiplataforma

Desarrolla en laptop, ejecuta en servidor potente via Tailscale:

# En laptop (VS Code):
# Remote SSH → homelab-server
# O Remote Containers → Docker en homelab via Tailscale

# Ejecutar builds pesados remotamente:
ssh homelab-server "cd /projects && docker build -t myapp ."

# Sincronizar código:
rsync -avz --progress ./proyecto homelab-server:/projects/

5. Game streaming (Moonlight/Sunshine)

Streamea juegos desde PC gaming a cualquier dispositivo via Tailscale:

# En PC gaming: instalar Sunshine
# https://github.com/LizardByte/Sunshine

# Configurar para escuchar solo en Tailscale IP
sunshine --address 100.64.0.X

# En móvil/laptop:
# Moonlight → Add PC manually → 100.64.0.X
# Juega con latencia mínima (P2P directo)

6. Backup remoto con Restic

Usa Tailscale para backups cifrados sin exponer SSH:

# Servidor backup (B2, Wasabi, homelab remoto):
sudo tailscale up --advertise-routes=192.168.2.0/24

# Cliente (homelab local):
# Backup via SFTP sobre Tailscale
restic -r sftp:backup-server:/backups/homelab backup /data

# O via REST server:
restic -r rest:http://backup-server:8000/repo backup /data

Integración con Otros Servicios de Homelab

Tailscale + Traefik (reverse proxy)

# docker-compose.yml
services:
  traefik:
    image: traefik:latest
    command:
      - "--providers.docker=true"
      - "--entrypoints.web.address=:80"
    ports:
      - "80:80"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - tailscale-net

networks:
  tailscale-net:
    external: true
    name: tailscale0  # Red de Tailscale

Tailscale + Pi-hole (DNS homelab)

Si usas Pi-hole o AdGuard Home para bloquear ads en tu homelab, puedes exponerlo via Tailscale:

# En Tailscale admin → DNS → Nameservers
Nameserver: 100.64.0.5  # IP Tailscale de tu Pi-hole

# Ahora todos los dispositivos usan Pi-hole via Tailscale
# Incluso fuera de casa: adblocker everywhere!

Tailscale + Proxmox (acceso VMs)

# Instalar Tailscale en Proxmox host:
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up --advertise-routes=192.168.1.0/24

# Acceso a VMs sin Tailscale:
https://proxmox-vm-ip:8006

Preguntas Frecuentes (FAQ)

¿Tailscale puede ver mi tráfico?

No en modo P2P (95% del tiempo). El tráfico va directo entre dispositivos con cifrado WireGuard. Solo metadata (IPs, conexiones) pasa por servidores Tailscale para coordinación.

Sí en DERP relay (5% fallback). Si P2P falla, usa relays cifrados. Tailscale podría técnicamente descifrar (tienen las claves simétricas), pero afirman no hacerlo. Para privacidad absoluta: usa Headscale.

¿Cuánto consume de ancho de banda/batería?

Ancho de banda: Solo tráfico real que generas. No hay overhead significativo (WireGuard es eficiente).

Batería (móvil): ~2-5% al día con conexión activa. Menos que OpenVPN.

¿Puedo usar Tailscale en China/países restrictivos?

Depende. Tailscale usa DERP relays que pueden ser bloqueados. Algunos usuarios reportan que funciona, otros no. No está diseñado para evasión de censura (usa Tor/Shadowsocks para eso).

¿Qué pasa si Tailscale Inc. desaparece?

Tus conexiones P2P siguen funcionando mientras tengas las configuraciones. Pero el control plane dejaría de funcionar (no podrías añadir dispositivos nuevos). Migración a Headscale sería necesaria.

¿Puedo conectar más de 100 dispositivos gratis?

No oficialmente. El tier gratuito tiene límite de 100. Opciones:

• Pagar plan Teams ($5/user/mes)
• Usar Headscale (selfhosted, ilimitado)
• Usar múltiples Tailnets (no recomendado, complica gestión)

¿Tailscale soporta IPv6?

Sí. Tailscale asigna IPs IPv6 (fd7a:115c:a1e0::/48) además de IPv4 (100.64.0.0/10).

¿Puedo usar Tailscale con VLANs?

Sí. Puedes anunciar múltiples subnets:

tailscale up --advertise-routes=192.168.1.0/24,192.168.10.0/24,192.168.20.0/24

¿Cómo afecta Tailscale a Docker networking?

Usa network_mode: host para Tailscale container. Otros containers funcionan normal. Para subnet routing, necesitas configurar iptables o usar macvlan.

¿Tailscale funciona con CG-NAT (CGNAT)?

Sí, perfecto. Es uno de los casos de uso principales. NAT traversal automático funciona incluso con Carrier-Grade NAT (típico en móviles 4G/5G).

¿Puedo self-hostear Tailscale completamente?

Sí, con Headscale. Implementación open-source del control plane. Requiere:

• Servidor con IP pública
• DNS configurado
• HTTPS (certificados Let’s Encrypt)

Tutorial: https://github.com/juanfont/headscale

¿Tailscale es compatible con Kubernetes?

Sí. Hay operador oficial:

kubectl apply -f https://github.com/tailscale/tailscale/releases/latest/download/operator.yaml

Permite exponer servicios Kubernetes via Tailscale sin Ingress controllers.

¿Puedo usar Tailscale para acceso SSH a servidores cloud?

Sí. Instala Tailscale en VPS → Deshabilita SSH público (port 22) → Solo accesible via Tailscale. Mucho más seguro que exponer SSH a Internet.

¿Hay límite de tráfico?

No. Todo el tráfico P2P es ilimitado (va directo entre dispositivos). DERP relays tienen límite teórico pero es generoso (varios GB/día).

Conclusión

Tailscale es la forma más fácil y segura de acceder a tu homelab remotamente sin abrir puertos, configurar VPNs complejas, o depender de servicios inseguros.

Úsalo si:

• Tienes homelab con servicios que necesitas remotamente (Portainer, n8n, Jellyfin)
• Estás detrás de CG-NAT o firewall restrictivo
• Quieres conectar múltiples homelabs/dispositivos en mesh
• Valoras facilidad sobre control absoluto

No lo uses si:

• Necesitas privacidad extrema (usa Headscale o WireGuard manual)
• Tienes +100 dispositivos y no quieres pagar (usa Headscale)
• Necesitas evasión de censura (usa Tor)

Mi setup personal:

• Tailscale en todos mis servidores (homelab + VPS)
• Subnet routing para acceso completo a LAN
• Exit node para WiFis públicas
• ACLs para separar dispositivos trabajo/personal

¿Ya usas Tailscale en tu homelab? ¿Qué casos de uso tienes? Cuéntame en los comentarios.

Enlaces relacionados en eldiarioia.es:

• Portainer: Gestión Visual de Docker para tu Homelab – Complementa perfecto con Tailscale para gestionar containers remotamente
• Docker para Novatos: Guía Definitiva 2025 – Base para entender el docker-compose de Tailscale
• N8N con Webhooks: Automatización Avanzada – Accede a n8n de forma segura via Tailscale
• Homelab Completo 2025: Guía Definitiva – Tailscale es pieza clave de cualquier homelab moderno
• Kubernetes para IA en Producción – Usa Tailscale Operator para exponer servicios K8s
• Browserless + Playwright para Web Scraping – Ejecuta scraping remoto via Tailscale sin exponer puertos