Il PC in tasca: lasciare la workstation a casa e lavorarci da ovunque

Home » Tra dati e tratti » Esperienze e Progetti » Il PC in tasca: lasciare la workstation a casa e lavorarci da ovunque

Il problema

Parto per una vacanza. La mia workstation, un portatile "muscoloso" con una GPU seria, è troppo ingombrante e delicata da portarmi dietro. E comunque, in vacanza, non ho nessuna voglia di restare incollata al lavoro.

Però mi piacerebbe poterlo fare se e quando mi va: tenere un occhio sulle mie cose, o mettere mano con calma ai materiali del corso su MAF che sto preparando, nei momenti in cui ne ho voglia. Non per dovere, ma per libertà. Il punto non è "lavorare in vacanza": è avere a portata di mano tutta la potenza della mia workstation nel momento in cui mi venisse voglia di sperimentare, smanettare o creare qualcosa.

La domanda che mi sono fatta: posso lasciare la workstation a casa, accesa, e raggiungerla da un dispositivo leggero (un vecchio laptop come il mio vecchio lenovo t480, un tablet, il telefono, un iPad) come se fossi seduta davanti?

Sì. E la cosa più bella è che la potenza resta a casa: il dispositivo da viaggio fa solo da thin client (schermo e input, zero calcolo). Compilo, lancio script, uso la GPU… tutto gira sulla workstation. Il tablet da quattro etti in valigia non fatica.

Ecco come l'ho messo in piedi, pezzo per pezzo.

L'idea in uno schema

La rete: Tailscale collega tutti i device in una rete privata, senza aprire porte sul router.
Il terminale: SSH, solo con chiave.
L'editor: VS Code, in due modi a seconda del device.
Il calcolo: sempre e solo sulla workstation.

Nel resto dell'articolo:
workstation = il PC di casa;
USER = il tuo utente;
100.x.y.z = il suo indirizzo Tailscale;
legion = il nome che scegli tu per l'host SSH;
NOME = il nome che dai al tunnel VS Code (code tunnel --name NOME).

Parte 1 - Tailscale: la rete che ti segue

Il vero ostacolo non è SSH o VS Code: è raggiungere casa da fuori. L'IP di casa cambia, spesso c'è il CGNAT dell'operatore, e aprire porte sul router è fragile e insicuro.

Tailscale risolve tutto: è una VPN "mesh" basata su WireGuard. Installi un'app sulla workstation e su ogni device, fai login con lo stesso account, e ottieni una rete privata (la tua tailnet) in cui i device si vedono con un indirizzo fisso, ovunque siano. Il concetto chiave: non esponi niente su Internet, crei una tua rete privata che ti segue.

Sulla workstation (Linux):

curl -fsSL https://tailscale.com/install.sh | sh
sudo systemctl enable --now tailscaled
sudo tailscale up          # apri il link che stampa e autorizzaCode language: PHP (php)

Sui device: app Tailscale dallo store (Android/iOS) o installer (Mac/Windows), stesso account. Entrano da soli nella tailnet.

Verifica:

tailscale status     # tutti i tuoi device
tailscale ip -4      # l'indirizzo di questa macchina, es. 100.x.y.zCode language: PHP (php)

Ogni device ha un IP 100.x privato, identico da qualunque rete. Con MagicDNS (attivo di default) puoi usare i nomi invece degli IP.

Nota: alcuni client minimali (es. Termux) non risolvono i nomi MagicDNS → lì usa direttamente l'IP 100.x.y.z.

Se vuoi vedere Tailscale dentro un progetto più grande, l'ho usato nel mio Nextcloud self-hosted, dal setup manuale all'infrastructure as code (repo Terraform).

Parte 2 - Preparare la workstation

Non deve addormentarsi

Se è un portatile, di default va in standby e diventa irraggiungibile. Su GNOME:

gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-ac-type 'nothing'Code language: JavaScript (javascript)

e per il coperchio chiuso, un drop-in di logind:

# /etc/systemd/logind.conf.d/99-keepawake.conf
[Login]
HandleLidSwitch=ignore
HandleLidSwitchExternalPower=ignoreCode language: PHP (php)

Ha effetto dal prossimo riavvio (oppure subito con sudo systemctl restart systemd-logind, che però chiude la sessione grafica attiva).

SSH, solo con chiave

Attiva il server SSH e blindalo (niente password, solo chiave pubblica):

sudo systemctl enable --now sshd

# /etc/ssh/sshd_config.d/10-hardening.conf
PasswordAuthentication no
KbdInteractiveAuthentication no
PermitRootLogin prohibit-passwordCode language: PHP (php)

sudo sshd -t && sudo systemctl reload sshd   # verifica poi ricaricaCode language: PHP (php)

Ogni device avrà la sua chiave: la pubblica va in ~/.ssh/authorized_keys sulla workstation. Se perdi un device, revochi solo quella riga.

La chiave dentro 1Password (niente file sul disco)

Questa è la chiave con cui dal device ti colleghi alla workstation. Sui laptop non la tengo come file sparso in ~/.ssh: la genero dentro 1Password. Così la privata non tocca mai il disco, si sincronizza su tutti i miei computer, e ogni uso chiede lo sblocco biometrico. Se vuoi il dettaglio, ho scritto come gestisco le chiavi SSH e i file .env con 1Password.

1Password → New Item → SSH Key → genera Ed25519 → copia la chiave pubblica: mettila in authorized_keys sulla workstation e salvala come file locale (es. ~/.ssh/legion.pub), a cui punterà IdentityFile (la privata la fornisce l'agent)
1Password → Settings → Developer → "Use the SSH agent"
Punta SSH all'agent di 1Password (vedi il blocco ~/.ssh/config nella Parte 3)

Sui device dove 1Password non fa da agent SSH (Android/iPad), genera invece una chiave locale dedicata per quel device.

⚠️ L'agent 1Password va bene quando sei al PC. Per le connessioni in uscita dalla workstation mentre la usi da remoto (push su GitHub, salto su altri server) ti bloccherebbe con un popup irraggiungibile: vedi la Parte 5.

Parte 3 - Il terminale, da ogni dispositivo

Prerequisito ovunque: Tailscale acceso e sulla stessa tailnet.

Laptop (Linux, Mac) → ssh

Metti nel ~/.ssh/config un blocco che usa l'agent di 1Password:

Host legion
    HostName workstation.tua-tailnet.ts.net   # o l'IP Tailscale 100.x.y.z
    User USER
    IdentityAgent ~/.1password/agent.sock      # macOS: ~/Library/Group Containers/2BUA8C4S2C.com.1password/t/agent.sock
    IdentityFile ~/.ssh/legion.pub             # punta a QUESTA chiave
    IdentitiesOnly yes                         # offri solo lei (evita "too many authentication failures")Code language: PHP (php)

E ti colleghi con ssh legion: 1Password chiede lo sblocco e sei dentro. Lo stesso alias lo riusano VS Code (Remote-SSH → legion) e scp.

Android (tablet / telefono) → Termux

Installa Termux da GitHub releases o F-Droid (⚠️ non dal Play Store: quella versione è abbandonata). Poi:

pkg install openssh
ssh-keygen -t ed25519
cat ~/.ssh/id_ed25519.pub    # → aggiungi questa riga ad authorized_keys
ssh USER@100.x.y.zCode language: PHP (php)

Per digitare solo ssh legion, metti un ~/.ssh/config con Host legion, HostName 100.x.y.z (l'IP, non il nome: Termux non risolve bene i MagicDNS), User USER, IdentityFile ~/.ssh/id_ed25519.

iPad → Termius

Sull'iPad non esiste Termux. Usa un client SSH nativo: Termius (il piano gratuito basta per un host + una chiave). Generi la chiave nell'app, aggiungi la pubblica alla workstation, crei l'host (100.x.y.z, utente USER, la chiave) e ti colleghi. (Alternativa: iSH, ma è un emulatore, meno fluido.)

Parte 4 - VS Code, in due modi

Qui la scelta dipende dal device:

Laptop → Remote-SSH (nativo, il più fluido)

Installa l'estensione Remote - SSH, poi:

code --remote ssh-remote+legion /home/USER/Projects/mio-progetto

Si apre VS Code sul laptop, ma il "motore" (server, terminale, estensioni) gira sulla workstation.

Tablet / telefono / iPad → il tunnel

Questi device non possono far girare VS Code desktop. Soluzione: code tunnel sulla workstation, e apri https://vscode.dev/tunnel/NOME in un browser qualsiasi. Editor + terminale, dentro Safari/Chrome, con la potenza della workstation dietro.

Trucco: apri il singolo progetto

Aprire una cartella enorme (o l'intera home) fa impazzire il file watcher e diventa lentissimo. Apri sempre il progetto specifico:

# browser:
https://vscode.dev/tunnel/NOME/home/USER/Projects/mio-progettoCode language: PHP (php)

e nelle impostazioni del server VS Code escludi le cartelle pesanti dal watcher (files.watcherExclude: **/node_modules, **/.venv, **/.git…).

Parte 5 - Il tunnel che sopravvive ai riavvii (la lezione imparata)

Voglio che il tunnel sia sempre attivo, anche dopo un riavvio non presidiato. Lo installo come servizio (systemd utente) con un restart notturno (i tunnel Microsoft tendono a "morire" dopo un po') e loginctl enable-linger per farlo partire al boot senza login.

Ma qui è saltata fuori una trappola che vale la pena raccontare: code tunnel salva il token di login nel keyring di GNOME, che è bloccato se la macchina si avvia senza login grafico. Risultato: dopo un riavvio "alla cieca", il tunnel restava a chiedere un codice e non partiva.

La soluzione è forzare il token su file invece che nel keyring, rendendo irraggiungibile il D-Bus per quel processo:

# login che scrive il token su file (niente keyring)
DBUS_SESSION_BUS_ADDRESS=unix:path=/dev/null code tunnel user login --provider githubCode language: PHP (php)

e la stessa variabile nel servizio, con un drop-in systemd:

# ~/.config/systemd/user/code-tunnel.service.d/10-nokeyring.conf
[Service]
Environment=DBUS_SESSION_BUS_ADDRESS=unix:path=/dev/nullCode language: PHP (php)

Da lì il tunnel sopravvive a qualsiasi riavvio, senza bisogno di loggarsi. (Verificato con doppio reboot "alla cieca".)

Morale: SSH regge i riavvii senza fare nulla; il tunnel del browser ha bisogno di questo accorgimento in più.

Anche l'agent SSH di 1Password si blocca da remoto (stesso problema del tunnel)

Comodissimo quando sei al PC: la chiave privata non tocca il disco e ogni uso chiede lo sblocco biometrico. Ma l'agent SSH di 1Password funziona solo con l'app desktop aperta e sbloccata, e a ogni firma mostra un popup di approvazione sullo schermo della workstation. Se stai lavorando dal tablet, quel popup compare a casa: non puoi cliccarlo, e il comando resta appeso. (Su iOS/iPadOS il punto è ancora più netto: lì 1Password non fa proprio da agent, come detto nella Parte 2.)

Quindi 1Password va benissimo per le chiavi che usi quando sei fisicamente davanti al PC. Ma per le chiavi che la workstation usa per connessioni in uscita mentre sei via (push su GitHub, salto su un altro server), la soluzione più robusta è una chiave su file, senza agent, sempre - così il comportamento è identico da locale, tunnel, SSH e cron. In ~/.ssh/config, un blocco per host:

Host github.com
    HostName github.com
    User git
    IdentityAgent none        # niente agent → niente popup da approvare
    IdentitiesOnly yes         # una sola chiave → niente "Too many authentication failures"
    IdentityFile ~/.ssh/id_githubCode language: PHP (php)

Esiste anche una variante condizionale (Match host github.com exec "[ -n \"$SSH_CONNECTION\" ]") che usa 1Password in locale e la chiave-file solo in sessione SSH. Sconsigliata: dentro il tunnel di VS Code $SSH_CONNECTION non è impostata, quindi ricadresti sul path 1Password e il push si bloccherebbe - proprio lo scenario da evitare. Meglio la chiave-file secca.

Anche la firma dei commit segue lo stesso principio: la faccio con la chiave-file (id_github) via OpenSSH, non con l'agent di 1Password (in git config: gpg.ssh.program disattivato e user.signingkey che punta a ~/.ssh/id_github.pub). Così, con commit.gpgsign attivo, la firma non si blocca da remoto: avviene con la chiave su disco, senza popup di approvazione. Il prezzo è perdere lo sblocco biometrico sulla firma quando sei al PC, ma è la stessa chiave che usi già per il push, quindi nessuna nuova esposizione.

È lo stesso principio del token del tunnel: uno store legato alla GUI si blocca appena la macchina gira "alla cieca".

Parte 6 - Portarsi via i file

Il modello "tutto gira sulla workstation" vale per il calcolo. Ma a volte voglio scaricare un file e usarlo in locale (es. un video da guardare comodo). Sulla stessa connessione:

🥇 Taildrop (integrato in Tailscale, nessuna chiave):

  tailscale file cp video.mkv nome-device:Code language: CSS (css)

Sul device l'app Tailscale riceve il file (resta "in pending" nell'app finché non lo tocchi per salvarlo) → lo apri col player locale.

⚠️ Se l'app di destinazione è in background esce is not replying; trying anyway: il file parte comunque, lo ritrovi in pending aprendo l'app. E il cp chiede sudo finché non lanci una volta sudo tailscale set --operator=$USER.

scp / rsync (laptop): scp workstation:/percorso/file ~/Downloads/

VS Code: tasto destro sul file nel pannello remoto → Download

GUI: Cyberduck (SFTP) sul Mac; su iPad app come Documents/Secure ShellFish

.mkv su iOS: aprilo con VLC o Infuse (il player nativo non lo legge)

La riproduzione dei media è l'unico caso in cui non usi la workstation: scarichi il file e lo apri col player del device (locale = fluido). Streammare un video via desktop remoto sarebbe a scatti.

Il kit fisico: una tastiera che sta nel palmo

Il thin client può essere piccolo per davvero. La tastiera che mi porto è una ProtoArc pieghevole: chiusa ha letteralmente le dimensioni del mio tablet (un Lenovo Legion Tab gen 3, sugli 8 pollici), quindi entra in tasca o in una tasca dello zaino senza pesare né ingombrare. Aperta, invece, ha la spaziatura di una tastiera "vera": ci scrivo codice comodamente, non è un ripiego.

Il bello arriva quando in viaggio trovo un monitor (la TV della casa vacanze, uno schermo di passaggio): collego solo il telefono o il tablet allo schermo, aggancio la tastiera pieghevole e ho il setup ideale. Schermo grande, tastiera piena, e dietro tutta la potenza della workstation di casa via tunnel. Niente PC pesante in valigia, ma un'esperienza da scrivania.

Un esempio concreto: preparare il corso da lontano

In questo periodo sto preparando una serie di video-lezioni sugli agenti AI, con al centro Microsoft Agent Framework (MAF, la fusione di Semantic Kernel e AutoGen). Ogni puntata è una parte teorica con le slide più una pratica in un notebook Jupyter eseguibile, e poi registro la video-lezione.

Quel notebook fa girare agenti veri, e alcune puntate usano modelli in locale con Ollama, che per andare fluidi vogliono la GPU. In vacanza non ci penso; ma se mi prende l'idea, apro il notebook via tunnel e lo eseguo sulla GPU di casa (una NVIDIA 5070), come se fossi seduta alla scrivania. Slide, codice e prove restano lì dove c'è la potenza: io tocco solo lo schermo.

Le prime due puntate sono già online

Riepilogo per dispositivo

Device	Terminale	Editor
Laptop Linux / Mac	`ssh legion`	VS Code Remote-SSH
Tablet / telefono Android	Termux → `ssh legion`	browser → `vscode.dev/tunnel/NOME`
iPad	Termius → host	Safari → `vscode.dev/tunnel/NOME`

Sicurezza: cosa tenere a mente

Comodo sì, ma questo setup sposta un po' la superficie d'attacco. I punti che contano davvero:

Il tunnel è l'unico pezzo esposto a Internet, protetto solo dal login GitHub/Microsoft: chi entra nel tuo account entra nel tunnel → 2FA forte (passkey/chiave hardware) è d'obbligo. E puoi spegnerlo quando non serve: systemctl --user stop code-tunnel.
SSH solo con chiave (password off) e, meglio ancora, fuori dalla LAN: esposto solo sulla tua tailnet, non sul Wi-Fi di casa (firewall-cmd --zone=... --remove-service=ssh).
Chiavi: sui laptop in 1Password con sblocco biometrico; sui mobile una chiave per device → revoca mirata.
Tailscale key expiry: attivo sui device portatili (uno perso si stacca da solo), ma disattivato sul server che raggiungi da remoto: altrimenti rischi che esca dalla rete proprio mentre sei via.
Cifra il disco (LUKS): la workstation resta accesa e incustodita a casa mentre viaggi = più esposta al furto. Col disco in chiaro, chi la ruba legge chiavi, token e progetti. Va pianificata (backup + reinstallazione), ma è la difesa che conta di più contro il furto fisico.
git/ssh da remoto: l'agent di un password manager (1Password) si blocca da remoto (il popup di approvazione compare a casa, irraggiungibile) → per gli host esterni usa chiavi-file con IdentityAgent none + IdentitiesOnly yes. Config e spiegazione completa nella Parte 5.

La regola generale: il calcolo è a casa, ma anche i segreti sono a casa. Proteggi l'account che apre il tunnel e il disco che li contiene.

Conclusione

Parto con un tablet o un vecchio laptop in tasca, e, se mi va, ho la mia workstation intera a portata di mano (terminale, editor, GPU, progetti) da qualunque posto con una rete. Nessun obbligo: solo la libertà di sedermi e creare qualcosa quando mi viene l'ispirazione. Il PC pesante resta al sicuro a casa; io mi porto solo il thin client.

Il PC in tasca, letteralmente.

Link utili

Strumenti

Tailscale
Termux (Android: installalo da GitHub releases o F-Droid, non dal Play Store)
Termius (client SSH per iPad)
VS Code nel browser
1Password
Tastiera pieghevole ProtoArc

I miei articoli e repo

Tags: