Tutorial complet: de la zero la self-hosting securizat.

Imaginează-ți că ai mai multe dispozitive - un calculator acasă, un laptop la serviciu, un telefon mobil și un server acasă. Toate aceste dispozitive sunt conectate la internet, dar fiecare are adresa sa proprie, se află în rețele diferite și, în mod normal, nu pot „vorbi„ direct între ele fără trucuri complicate.

Tailscale rezolvă exact această problemă. El creează o rețea privată virtuală (VPN) mesh între toate dispozitivele tale, indiferent unde se află pe glob. Odată instalat, calculatorul tău de acasă și laptopul de la serviciu se comportă ca și cum ar fi conectate la același router, la aceeași rețea locală.

Există multe soluții VPN tradiționale (OpenVPN, WireGuard manual, Cisco), dar toate au un mare dezavantaj: necesită un server central prin care trece tot traficul. Asta înseamnă latență mai mare și un singur punct de eșec.

Tailscale este diferit - el folosește o arhitectură numită mesh VPN. Asta înseamnă că dispozitivele tale se conectează direct între ele (peer-to-peer), fără să treacă printr-un server intermediar. Tailscale folosește WireGuard ca protocol de transport - unul dintre cele mai rapide și sigure protocoale VPN existente.

Tailscale folosește un server de coordonare (control plane) care rulează pe serverele Tailscale. Acesta nu vede traficul tău - el doar ajută dispozitivele să se găsească și să schimbe cheile criptografice. Odată ce dispozitivele se cunosc, traficul curge direct între ele, criptat cu WireGuard.

Fiecare dispozitiv primește o adresă IP din blocul 100.64.0.0/10 (CGNAT space). Aceste adrese sunt unice în rețeaua ta Tailscale (numită tailnet) și nu se schimbă niciodată - chiar dacă dispozitivul e la un alt ISP sau în altă țară.

Primul pas este să îți creezi un cont pe site-ul Tailscale. Procesul este simplu și nu necesită un card de credit pentru planul gratuit.

1. Mergi la https://tailscale.com și apasă butonul Get started sau Sign up
2. Alege un provider de autentificare. Tailscale nu are parole proprii - folosești un cont existent:
   • Google - recomandat dacă ai cont Google
   • GitHub - recomandat pentru utilizatorii tehnici
   • Microsoft - pentru conturi Microsoft / Azure AD
   • Apple - pentru utilizatorii de macOS / iOS
   • Email magic link - dacă nu vrei să folosești niciun provider de mai sus
3. Autorizează Tailscale să acceseze informațiile minime necesare din contul ales
4. Ești redirecționat automat la admin console: https://login.tailscale.com/admin

Odată autentificat, vei vedea panoul de control Tailscale. Cele mai importante secțiuni:

• Machines - lista tuturor dispozitivelor conectate la tailnet
• DNS - configurarea MagicDNS și a serverelor DNS personalizate
• Access Controls - regulile ACL care controlează cine accesează ce
• Settings - setări generale ale tailnet-ului
• Auth Keys - chei de autentificare pentru automatizare (Docker, servere)

Tailscale are clienți pentru practic orice sistem de operare. O să acoperim cele mai importante platforme.

Instalarea pe sistemele bazate pe Debian/Ubuntu este simplă și se face printr-un script oficial sau manual prin apt. Ambele metode sunt sigure.

Cel mai simplu mod este să folosești scriptul de instalare furnizat de Tailscale:

curl -fsSL https://tailscale.com/install.sh | sh

curl -fsSL https://tailscale.com/install.sh | less

Dacă preferi mai mult control sau dacă scriptul automat nu funcționează, poți instala manual:

# Pasul 1: Adaugă cheia GPG a Tailscale
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.noarmor.gpg \
  | sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg >/dev/null
 
# Pasul 2: Adaugă repository-ul APT
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/noble.tailscale-keyring.list \
  | sudo tee /etc/apt/sources.list.d/tailscale.list
 
# Pasul 3: Actualizează lista de pachete și instalează
sudo apt update && sudo apt install tailscale

După instalare, serviciul Tailscale trebuie pornit și autentificat cu contul tău:

# Pornește Tailscale și autentifică-te
sudo tailscale up
 
# Sau cu opțiuni avansate (recomandate pentru servere):
sudo tailscale up --advertise-tags=tag:server --ssh

La rularea comenzii vei primi un URL de forma https://login.tailscale.com/a/XXXX. Deschide-l în browser, loghează-te cu contul tău Tailscale, și dispozitivul va fi adăugat automat în rețeaua ta.

# Verifică statusul
tailscale status
 
# Află adresa ta IP în rețeaua Tailscale
tailscale ip -4
 
# Ping un alt dispozitiv Tailscale
tailscale ping nume-dispozitiv

1. Mergi la https://tailscale.com/download/windows
2. Descarcă installerul (.exe) și rulează-l
3. Tailscale va apărea în system tray (bara de notificări, lângă ceas)
4. Click pe iconița Tailscale → Log in
5. Se deschide browserul - autentifică-te cu contul tău
6. Dispozitivul apare automat în admin console

1. Instalare prin App Store: caută „Tailscale“ sau mergi la https://tailscale.com/download/mac
2. Alternativ, cu Homebrew: brew install –cask tailscale
3. Deschide aplicația și loghează-te

1. Caută Tailscale în Google Play Store sau F-Droid
2. Instalează aplicația, deschide-o și apasă Sign in
3. Activează VPN-ul din aplicație

1. Caută Tailscale în App Store
2. Instalează și deschide aplicația
3. Apasă Sign in și autentifică-te
4. iOS va cere permisiunea de a adăuga o configurație VPN - acceptă

Când configurezi un server la distanță sau un container Docker, nu poți deschide un browser pentru autentificare. Pentru aceasta folosești un Auth Key generat din admin console.

1. Mergi la https://login.tailscale.com/admin/settings/keys
2. Apasă Generate auth key
3. Setează opțiunile:
   • Reusable - permite folosirea cheii pentru mai multe dispozitive
   • Expiry - data la care cheia expiră (1 oră până la 90 zile)
   • Ephemeral - dispozitivele se șterg automat când se deconectează (util pentru containere)
   • Pre-authorized - dispozitivele sunt aprobate automat fără confirmare manuală
4. Copiază cheia generată (o vezi o singură dată!)

# Autentificare non-interactivă cu Auth Key
sudo tailscale up --authkey=tskey-auth-XXXXX
 
# Cu opțiuni suplimentare
sudo tailscale up \
  --authkey=tskey-auth-XXXXX \
  --hostname=server-nuc \
  --advertise-tags=tag:server

Admin console (https://login.tailscale.com/admin) este locul unde controlezi tot ce ține de rețeaua ta Tailscale. Hai să explorăm fiecare secțiune importantă.

Secțiunea Machines îți arată toate dispozitivele conectate. Pentru fiecare dispozitiv poți vedea și configura:

• Adresa IP Tailscale (ex: 100.64.x.x) - permanentă, nu se schimbă niciodată
• MagicDNS hostname - un nume de genul laptop.tail12345.ts.net
• OS și versiunea clientului Tailscale
• Ultima conexiune
• Subroute-urile anunțate

Din meniul cu trei puncte al fiecărui dispozitiv poți:

• Dezactiva / activa temporar un dispozitiv
• Redenumi dispozitivul
• Aproba subrețele (subnet routes)
• Șterge dispozitivul din rețea

Una dintre cele mai utile funcții din Tailscale este MagicDNS. În loc să memorezi adrese IP de genul 100.64.23.45, poți accesa dispozitivele tale folosind nume ca server-nuc sau laptop-mint.

1. Mergi la secțiunea DNS din admin console
2. Activează butonul Enable MagicDNS
3. Gata! Acum toate dispozitivele tale au un hostname DNS automat

Formatul numelui DNS este: hostname.tailnet-name.ts.net. De exemplu, dacă tailnet-ul tău se numește „tail12345„ și dispozitivul se numește „server-nuc“, poți accesa https://server-nuc.tail12345.ts.net.

ACL-urile (Access Control Lists) controlează cine poate accesa ce în rețeaua ta. Implicit, Tailscale permite tuturor dispozitivelor să se conecteze la orice alt dispozitiv - ceea ce e perfect pentru uz personal.

Configurarea ACL se face printr-un fișier JSON/HuJSON în secțiunea Access Controls din admin console.

{
  "acls": [
    {
      "action": "accept",
      "src": ["*"],
      "dst": ["*:*"]
    }
  ]
}

Tag-urile îți permit să grupezi dispozitivele și să definești reguli clare. De exemplu: device-urile cu tag-ul server pot fi accesate doar de device-urile tale personale.

{
  "tagOwners": {
    "tag:server": ["autogroup:owner"],
    "tag:client": ["autogroup:owner"]
  },
  "acls": [
    {
      "action": "accept",
      "src": ["tag:client"],
      "dst": ["tag:server:*"]
    },
    {
      "action": "accept",
      "src": ["autogroup:owner"],
      "dst": ["*:*"]
    }
  ]
}

# La pornirea Tailscale, specifică tag-urile
sudo tailscale up --advertise-tags=tag:server
 
# Sau din linia de comandă (fără restart)
sudo tailscale set --advertise-tags=tag:server

Subnet routes îți permit să expui întreaga rețea locală printr-un singur dispozitiv Tailscale. De exemplu, dacă serverul tău de acasă are Tailscale instalat și anunță subrețeaua 192.168.1.0/24, vei putea accesa orice dispozitiv din rețeaua ta de acasă (inclusiv routerul, NAS-ul, televizorul smart) de pe orice dispozitiv Tailscale - chiar dacă acel dispozitiv nu are Tailscale instalat.

# Anunță subrețeaua locală (înlocuiește cu IP-ul rețelei tale)
sudo tailscale up --advertise-routes=192.168.1.0/24
 
# Activează IP forwarding (necesar pentru subnet routes)
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

1. Mergi la secțiunea Machines din admin console
2. Găsește dispozitivul care anunță subnet-ul
3. Meniu cu trei puncte → Edit route settings
4. Activează subrețeaua dorită

Un exit node este un dispozitiv Tailscale prin care poți ruta TOT traficul tău internet. Dacă ești la o cafenea cu Wi-Fi nesigur și activezi serverul tău de acasă ca exit node, tot traficul tău va trece prin conexiunea ta de acasă - ca un VPN tradițional.

# Pe dispozitivul care va fi exit node (serverul de acasă)
sudo tailscale up --advertise-exit-node
 
# Activare IP forwarding (necesar)
echo 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
sudo sysctl -p /etc/sysctl.d/99-tailscale.conf

1. Aprobă exit node-ul din admin console (Machines → Edit route settings → Use as exit node)
2. Pe dispozitivul client, activează exit node-ul:

# Pe Linux
sudo tailscale up --exit-node=server-nuc
 
# Dezactivare exit node
sudo tailscale up --exit-node=

Pe Windows / macOS / mobile: meniul Tailscale → Use exit node → selectează dispozitivul.

Tailscale SSH este o funcție care îți permite să te conectezi prin SSH la dispozitivele tale fără să gestionezi chei SSH și fără să deschizi portul 22. Autentificarea se face prin identitatea Tailscale.

# Activează Tailscale SSH pe server
sudo tailscale up --ssh
 
# Conectare de pe orice dispozitiv Tailscale
ssh user@server-nuc
 
# Sau folosind adresa Tailscale
ssh user@100.64.x.x

Una dintre cele mai impresionante funcții ale Tailscale este posibilitatea de a obține certificate HTTPS valide pentru serviciile tale self-hosted - fără să deții un domeniu propriu, fără Nginx, fără Certbot, fără configurații complicate.

Tailscale colaborează cu Let's Encrypt pentru a emite certificate TLS valide pentru hostname-urile tale MagicDNS. De exemplu, poți obține un certificat valid pentru server-nuc.tail12345.ts.net. Certificatele sunt emise automat și reînnoite fără nicio intervenție din partea ta.

Înainte de a obține un certificat, asigură-te că MagicDNS este activat (secțiunea 4.2).

# Obține certificatul pentru dispozitivul curent
sudo tailscale cert server-nuc.tail12345.ts.net
 
# Sau mai simplu, Tailscale detectează automat hostname-ul
sudo tailscale cert $(tailscale status --json | jq -r .Self.DNSName | sed 's/\.$//')
 
# Certificatele sunt salvate în:
# /var/lib/tailscale/certs/server-nuc.tail12345.ts.net.crt
# /var/lib/tailscale/certs/server-nuc.tail12345.ts.net.key

Odată ce ai certificatul, poți configura Nginx ca reverse proxy cu HTTPS pentru serviciile tale:

# /etc/nginx/conf.d/vaultwarden.conf
server {
    listen 443 ssl;
    server_name server-nuc.tail12345.ts.net;
 
    ssl_certificate /var/lib/tailscale/certs/server-nuc.tail12345.ts.net.crt;
    ssl_certificate_key /var/lib/tailscale/certs/server-nuc.tail12345.ts.net.key;
 
    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
 
server {
    listen 80;
    server_name server-nuc.tail12345.ts.net;
    return 301 https://$host$request_uri;
}

Tailscale are și un reverse proxy integrat, numit Tailscale Serve, care nu necesită Nginx sau Apache. Poți expune un serviciu local direct prin HTTPS cu o singură comandă:

# Expune serviciul de pe portul 8080 prin HTTPS
tailscale serve https / http://localhost:8080
 
# Verifică ce servezi
tailscale serve status
# Rezultat: https://server-nuc.tail12345.ts.net/ proxied from http://localhost:8080

tailscale funnel https / http://localhost:8080

Acum că știm cum funcționează Tailscale, hai să vedem cum îl integrăm cu servicii concrete self-hosted. Vom folosi ca exemple Vaultwarden (manager de parole) și Paperless-ngx (gestionare documente), dar principiile se aplică pentru orice serviciu.

Ai un server acasă (un Intel NUC, un Raspberry Pi, un PC vechi) care rulează mai multe servicii în Docker. Vrei să accesezi aceste servicii de pe telefon sau de pe laptopul de la serviciu, dar fără să expui porturile pe internet.

Soluția cu Tailscale este elegantă: instalezi Tailscale pe server, iar serviciile rulează în continuare pe localhost - accesibile doar prin rețeaua Tailscale.

# Pe serverul Ubuntu/Debian
curl -fsSL https://tailscale.com/install.sh | sh
 
# Pornire cu opțiunile recomandate pentru server
sudo tailscale up \
  --hostname=server-nuc \
  --advertise-tags=tag:server \
  --ssh
 
# Verifică că e conectat
tailscale status

Vaultwarden este un server compatibil Bitwarden, scris în Rust. Este ușor, rapid și perfect pentru self-hosting. Necesită HTTPS pentru a funcționa cu extensia de browser.

# /opt/services/vaultwarden/docker-compose.yml
services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      DOMAIN: https://server-nuc.tail12345.ts.net
      WEBSOCKET_ENABLED: "true"
      SIGNUPS_ALLOWED: "false"   # dezactivează înregistrările noi
    volumes:
      - ./data:/data
    ports:
      - "127.0.0.1:8082:80"     # accesibil DOAR pe localhost!
      - "127.0.0.1:3012:3012"   # WebSocket

# Obține certificatul Tailscale
sudo tailscale cert server-nuc.tail12345.ts.net
 
# Creează configurația Nginx
sudo nano /etc/nginx/conf.d/vaultwarden.conf

# Conținut /etc/nginx/conf.d/vaultwarden.conf
server {
    listen 443 ssl http2;
    server_name server-nuc.tail12345.ts.net;
 
    ssl_certificate /var/lib/tailscale/certs/server-nuc.tail12345.ts.net.crt;
    ssl_certificate_key /var/lib/tailscale/certs/server-nuc.tail12345.ts.net.key;
    ssl_protocols TLSv1.2 TLSv1.3;
 
    # Vaultwarden principal
    location / {
        proxy_pass http://127.0.0.1:8082;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
 
    # WebSocket pentru notificări în timp real
    location /notifications/hub {
        proxy_pass http://127.0.0.1:3012;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
 
server {
    listen 80;
    server_name server-nuc.tail12345.ts.net;
    return 301 https://$host$request_uri;
}

# Testează configurația și reîncarcă Nginx
sudo nginx -t && sudo systemctl reload nginx

Dacă ai mai multe servicii (Paperless, FreshRSS, Linkding etc.), poți fie să le expui pe subdomenii diferite (necesită configurații DNS suplimentare), fie să le accesezi direct pe portul specific prin Tailscale.

# Serviciile sunt legate pe toate interfețele sau pe interfața Tailscale
 
# În docker-compose, schimbă binding-ul:
# ÎN LOC DE: "127.0.0.1:8080:80"  (doar localhost)
# FOLOSEȘTE: "100.64.x.x:8080:80"  (doar pe IP-ul Tailscale)
 
# Sau lasă portul deschis pe toate interfețele și restricționează cu firewall:
# "0.0.0.0:8080:80"
 
# Adaugă reguli UFW pentru a permite acces DOAR din rețeaua Tailscale
sudo ufw allow in on tailscale0 to any port 8080
sudo ufw allow in on tailscale0 to any port 9090
sudo ufw allow in on tailscale0 to any port 6500
 
# Blochează accesul de pe alte interfețe
sudo ufw deny 8080
sudo ufw deny 9090
sudo ufw deny 6500

# Paperless pe portul 8000
tailscale serve https:8000 / http://localhost:8000
 
# FreshRSS pe portul 8080
tailscale serve https:8080 / http://localhost:8080
 
# Verifică toate serviciile configurate
tailscale serve status

Certificatele Tailscale expiră la 90 de zile. Poți automatiza reînnoirea cu un cronjob sau un systemd timer:

# Adaugă în crontab (rulează în fiecare zi la 3 AM)
sudo crontab -e
 
# Adaugă linia:
0 3 * * * tailscale cert server-nuc.tail12345.ts.net && systemctl reload nginx

Un script mai robust care verifică dacă certificatul expiră în mai puțin de 30 de zile:

#!/bin/bash
CERT=/var/lib/tailscale/certs/server-nuc.tail12345.ts.net.crt
DOMAIN=server-nuc.tail12345.ts.net
DAYS=$(( ($(openssl x509 -noout -enddate -in $CERT \
  | cut -d= -f2 | date -f - +%s) - $(date +%s)) / 86400 ))
if [ $DAYS -lt 30 ]; then
    tailscale cert $DOMAIN && systemctl reload nginx
fi

O abordare elegantă pentru containerizare este să rulezi Tailscale ca sidecar - un container separat care gestionează rețeaua pentru întregul stack Docker.

# docker-compose.yml cu Tailscale ca sidecar
services:
  tailscale:
    image: tailscale/tailscale:latest
    container_name: tailscale
    hostname: server-nuc
    environment:
      TS_AUTHKEY: tskey-auth-XXXXX
      TS_STATE_DIR: /var/lib/tailscale
      TS_SERVE_CONFIG: /config/serve.json
    volumes:
      - tailscale-state:/var/lib/tailscale
      - ./tailscale-config:/config
      - /dev/net/tun:/dev/net/tun
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    restart: unless-stopped

  vaultwarden:
    image: vaultwarden/server:latest
    network_mode: service:tailscale   # folosește rețeaua containerului Tailscale
    volumes:
      - ./vw-data:/data
    depends_on:
      - tailscale

volumes:
  tailscale-state:

Taildrop este funcția de transfer de fișiere din Tailscale - similar cu AirDrop de la Apple, dar cross-platform și fără fir. Poți trimite fișiere direct între dispozitivele tale fără niciun server intermediar.

# Trimite un fișier pe alt dispozitiv Tailscale
tailscale file cp document.pdf laptop-mint:
 
# Trimite mai multe fișiere
tailscale file cp *.jpg server-nuc:
 
# Primește fișierele pe destinatar
tailscale file get ~/Downloads/

Implicit, cheile de autentificare ale dispozitivelor expiră la 180 de zile. Asta înseamnă că la fiecare 6 luni trebuie să re-autentifici fiecare dispozitiv. Pentru servere, asta poate fi inconvenient.

Poți dezactiva expirarea cheilor pentru dispozitive specifice:

1. Mergi la Machines în admin console
2. Click pe meniul cu trei puncte al dispozitivului
3. Selectează Disable key expiry

# Status detaliat al rețelei
tailscale status --json | jq
 
# Vizualizează adresa IP Tailscale
tailscale ip
 
# Test latență și calitate conexiune
tailscale ping --until-direct server-nuc
 
# Informații debug
tailscale debug derp-map
 
# Deconectare temporară (fără a șterge configurația)
sudo tailscale down
 
# Reconectare
sudo tailscale up
 
# Actualizare la ultima versiune
sudo tailscale update
 
# Logout (șterge autentificarea)
sudo tailscale logout

• Verifică dacă Tailscale rulează: systemctl status tailscaled
• Verifică dacă ai finalizat autentificarea în browser
• Verifică conexiunea la internet
• Rulează sudo tailscale up –reset pentru a reseta configurația

• Verifică IP-ul Tailscale al serverului: tailscale ip -4
• Testează conectivitatea: tailscale ping server-nuc
• Verifică că serviciul ascultă pe portul corect: netstat -tlnp sau ss -tlnp
• Verifică dacă portul este permis în firewall: sudo ufw status
• Verifică ACL-urile din admin console - poate o regulă blochează accesul

Dacă conexiunea merge prin relay (DERP servers) în loc să fie directă, poate fi mai lentă:

# Verifică dacă conexiunea e directă sau prin relay
tailscale ping --until-direct server-nuc
 
# Dacă scrie "via DERP"  → conexiunea nu e directă
# Dacă scrie "direct"    → conexiunea e optimă

Conexiunile prin DERP apar când routerul blochează conexiunile directe UDP. Soluții:

• Activează UPnP pe router
• Adaugă o regulă de port forwarding pentru UDP pe portul 41641 (cel implicit)
• Pe server, activează: sudo tailscale up –advertise-exit-node –stateful-filtering=false

# Verifică data expirării certificatului
openssl x509 -noout -dates \
  -in /var/lib/tailscale/certs/server-nuc.tail12345.ts.net.crt
 
# Reînnoire manuală
sudo tailscale cert server-nuc.tail12345.ts.net
 
# Reîncarcă Nginx după reînnoire
sudo systemctl reload nginx

• Documentație oficială Tailscale
• Admin console
• Download clienți
• Referință comenzi CLI
• Forum comunitate Tailscale