Basta YAML per ora: tre server, Windows Server 2025 e un corso accelerato sul lato oscuro

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski
È il momento delle confessioni. Dopo il diario di battaglia della migrazione di Nextcloud, un numero a due cifre di esecuzioni di playbook, un ruleset nftables che ha allegramente svuotato le tabelle di K3s e più YAML di quanto un essere umano dovrebbe leggere in una sola settimana, ne avevo ufficialmente fin sopra i capelli di Nextcloud, di Ansible e di qualsiasi cosa contenesse la parola “migrazione”.
Così ho fatto quello che ogni nerd Linux ragionevole fa quando è in burnout da Linux: sono passato dall’altra parte. Tre server, tre installazioni fresche di Windows Server 2025 e qualche serata di Active Directory, DNS, DHCP, Group Policy, Storage Spaces e BitLocker. Niente YAML. Solo un sacco di Get- e Set-.
Per essere chiari, questa non è una storia di conversione. Ora viaggio su due binari: Linux resta dov’è e continua a fare il lavoro pesante, mentre in privato voglio imparare per bene il lato Microsoft, e in particolare il server. Non “clicca su Avanti finché funziona”. Capire cosa fa un domain controller quando si avvia, perché il failover DHCP ha la forma che ha e cosa scrive davvero una Group Policy nel registro. L’homelab è l’aula.
O, detto in modo meno formale: voglio semplicemente giocare per un po’ con una vera infrastruttura Windows. Dominio, policy, servizi file, patching, cifratura, virtualizzazione, il pacchetto completo, con abbastanza macchine da comportarsi come una piccola azienda e non come una singola VM di test che cancellerò dopo un’ora.
Indice
🖥️ La formazione
Tre box HP, tutte con iLO, tutte ora con Windows Server 2025, tutte promosse a domain controller nella stessa foresta:
- HP1: domain controller, emulatore PDC, DNS, DHCP
- HP2: domain controller, DNS, DHCP (partner di failover di HP1)
- HP3: domain controller, DNS, più tre SSD in un pool Storage Spaces, e il futuro file server centrale di casa
Il dominio è muench.home.arpa. home.arpa è la zona che la RFC 8375 riserva esattamente a questo: le reti domestiche. Niente più finti .local che litigano con mDNS, e niente registrazione di un dominio pubblico solo per dare un nome a un laboratorio.
Tre DC per una famiglia sono oggettivamente esagerati. È proprio questo il punto. Con tre posso spegnerne uno, riavviarlo o romperlo, e guardare gli altri due che vanno avanti. Come si è visto, è esattamente quello che ho potuto osservare (più sotto).
E sì, le vecchie abitudini sono venute con me. Non ho intenzione di cliccare in Server Manager su tre macchine. Tutto è gestito da remoto via WinRM dal mio jump box Linux con pywinrm. Le vecchie abitudini sono dure a morire, ma almeno adesso parlano PowerShell.
Primo intoppo del viaggio: WinRM spedisce lo script come base64 sulla riga di comando, e Windows limita una riga di comando a 8191 caratteri. Tutto ciò che è più lungo non fallisce. Semplicemente, in silenzio, non fa niente. Il workaround: caricare gli script in piccoli pezzi, verificare uno SHA256 sulla macchina di destinazione, poi eseguire. Molto Windows, molto istruttivo.
Secondo intoppo: ho attivato il server OpenSSH come fallback manuale, e la porta 22 andava in timeout dall’esterno anche se il servizio girava e la regola del firewall diceva “abilitata”. La regola creata automaticamente copriva solo il profilo Private. Un server membro di un dominio usa il profilo Domain. Un Set-NetFirewallRule -Profile Domain,Private dopo, funzionava.
🤖 Il mio co-amministratore è un’IA (e no, non è “vibe admin”)
Trasparenza totale su quella pipeline WinRM: non sono l’unico a usarla. Quando mi blocco, Claude (l’IA di Anthropic, che gira come Claude Code sul jump box Linux) si collega ai server esattamente attraverso quell’interfaccia WinRM e mi aiuta con la configurazione. Legge lo stato attuale, propone modifiche, le spiega, le applica dopo il mio sì e poi controlla il risultato.
Come funziona in pratica, visto che non c’è nessuna magia: Claude gira in un terminale sulla macchina Linux e lì può eseguire comandi shell. Per i one-liner rapidi chiama i server direttamente tramite pywinrm. Per qualsiasi cosa più grande, il flusso di lavoro è questo:
1. write a PowerShell script locally (check_hp2.ps1, gpo_bitlocker.ps1, …)
2. open a WinRM session to the server (HTTP 5985, NTLM, message-encrypted)
3. upload the script in ~1200-char base64 chunks → C:\Temp\
4. compare SHA256 locally vs. on the server → abort if they differ
5. execute it, collect stdout + errors (unwrapping PowerShell's CLIXML error stream)
6. read the output, decide the next step → back to 1
L’upload a pezzi e il checksum ci sono per via del limite di 8191 caratteri dell’intoppo di cui sopra: uno script troncato durante il trasferimento è peggio di uno che non arriva affatto. Gli script sono normali file .ps1, quindi posso leggerli tutti prima o dopo l’esecuzione. Ed è anche il bell’effetto collaterale: alla fine di una sessione mi ritrovo con una pila di PowerShell leggibile che mostra esattamente cosa è stato fatto, e posso imparare da lì.
Probabilmente hai sentito il termine vibe coding. Andrej Karpathy lo ha coniato all’inizio del 2025 per uno stile di programmazione in cui descrivi in linguaggio naturale quello che vuoi, lasci che l’IA scriva il codice e accetti più o meno tutto quello che ne esce senza leggerlo con attenzione. Riguarda il codice, e la parte “vibe” è proprio il non controllare.
Quello che faccio qui è la versione da amministratore della prima metà, ma deliberatamente non della seconda. Lasciare che un’IA spari comandi non revisionati ai tuoi domain controller sarebbe “vibe admin”, ed è un ottimo modo per conoscere da vicino la tua strategia di backup. Quindi le regole di base sono:
- Prima leggere, poi cambiare. Ogni compito inizia con un inventario in sola lettura di ciò che è davvero configurato, non di ciò che crediamo sia configurato.
- Io decido, lei esegue. Le modifiche avvengono dopo il mio consenso, e per qualsiasi cosa distruttiva c’è prima una domanda esplicita.
- Verificare dall’altra parte. Una GPO non è finita quando
New-GPOritorna. È finita quando il valore di registro compare sulla macchina di destinazione. Il failover DHCP non è sistemato finché entrambi i partner non riportano la nuova impostazione. - Spiegare il perché. Voglio imparare Windows Server, non esternalizzarlo. Quindi faccio un sacco di domande del tipo “perché è così?”, e alcune delle parti migliori di questo post sono nate da quelle risposte.
Un esempio reale dalla sessione in cui ho scritto questo post: volevamo attivare il takeover automatico nella relazione di failover DHCP. Il cmdlet su HP1 ha risposto con un semplice PermissionDenied, nonostante i diritti di domain admin. Claude ha riconosciuto lo schema: il classico double hop. Ero collegato a HP1 da remoto, il cmdlet deve cambiare contemporaneamente l’impostazione su HP2, e HP1 non è autorizzato a passare le mie credenziali a una terza macchina. La soluzione è stata un’attività pianificata una tantum che gira localmente su HP1 con un logon vero e proprio, e che poi viene cancellata di nuovo. Poi abbiamo controllato l’impostazione su entrambi i partner. È una cosa che avrei cercato su Google per un’ora. Invece ho ricevuto una lezione di dieci minuti su come funziona la delega delle credenziali in Windows.
Non sostituisce la comprensione. L’IA è veloce e sa tante cose, ma fa anche errori, e in questo viaggio ha sovrascritto una variabile PowerShell perché aveva dimenticato che non distinguono tra maiuscole e minuscole. È più come fare pair programming con un collega che ha letto ogni articolo di Microsoft Learn mai scritto, non si stanca mai delle domande e il cui lavoro rivedi comunque.
🌐 DNS: la parte senza cui AD non può vivere
Active Directory è, in fondo, un consumatore di DNS con opinioni molto precise. I client trovano i loro domain controller tramite record SRV (_ldap._tcp.dc._msdcs...), quindi se il DNS è sbagliato, è sbagliato tutto, di solito in modi confusi. Vale l’antico haiku del sysadmin: Non è il DNS. / Non può essere il DNS. / Era il DNS.
Tutti e tre i DC usano DNS integrato in AD, quindi le zone si replicano insieme alla directory stessa invece che tramite trasferimenti di zona. Tutti e tre sono anche global catalog, e il DHCP li distribuisce tutti e tre come server DNS, quindi uno qualsiasi può sparire senza che i client se ne accorgano:
PS> Get-DhcpServerv4OptionValue -ScopeId $scope -OptionId 6
OptionId Name Type Value
-------- ---- ---- -----
6 DNS Servers IPv4Address {…, …, …}
Tre voci. L’ordine dei resolver è comunque una faccenda lato client, ma almeno ogni client conosce tutte e tre le porte.
📦 La FritzBox viene degradata
Fino ad ora la mia FritzBox faceva quello che fa ogni router consumer: DHCP e DNS per tutta la casa. Con Active Directory non funziona. I membri del dominio devono usare i domain controller come server DNS, perché solo i DC conoscono i record SRV che dicono a un client dove vive il suo dominio. Distribuire il router come DNS è il classico errore di configurazione di AD: il join al dominio fallisce, le GPO in silenzio non si applicano e i logon durano cinque minuti senza un motivo apparente.
Quindi il server DHCP della FritzBox è spento, il DHCP ora gira come ruolo sui server Windows (vedi sotto) e distribuisce come server DNS i tre DC, non la FritzBox.
La FritzBox però non è disoccupata. Resta il default gateway, quindi tutto il traffico internet continua a uscire di casa attraverso di lei. E i DC inoltrano ogni query DNS di cui non sono responsabili, cioè tutto ciò che sta fuori da muench.home.arpa, alla FritzBox, che chiede al mondo esterno. Una divisione dei compiti pulita: Windows conosce la casa, la FritzBox conosce internet.
client ──DHCP────► HP1 / HP2 address, gateway = FritzBox, DNS = the 3 DCs
client ──DNS─────► any DC ──┬─ *.muench.home.arpa → answers itself
└─ everything else → forwards to FritzBox → internet
client ──traffic─► FritzBox (default gateway) ──────────────────────────► internet
La FritzBox è stata degradata da “manda avanti la casa” a “fa la guardia alla porta d’ingresso”. L’ha presa sorprendentemente bene.
📡 Failover DHCP: la sorpresa delle coppie
Il mio piano era semplice: tre server, tre nodi DHCP, tutti in un unico, felice cluster di failover.
Windows aveva altri piani. Il failover DHCP funziona rigorosamente a coppie. Una relazione di failover ha esattamente due partner, e uno scope può appartenere a una sola relazione. Non c’è una modalità a tre, nessun quorum, nessuna mesh. Il DHCP di Windows è rigorosamente monogamo. Così il terzo ruolo DHCP è stato di nuovo disinstallato, e ora HP1 e HP2 condividono lo scope in modalità load-balance, dividendo il pool di indirizzi 50/50 e sincronizzando i lease tra loro.
PS> Get-DhcpServerv4Failover | Select Name, Mode, State
Name Mode State
---- ---- -----
hp1-…-hp2 LoadBalance Normal
Il pool in sé è volutamente noioso: una /24, e il range dinamico va da .70 a .245. Sono 176 indirizzi per portatili, telefoni, TV e qualsiasi altra cosa entri dalla porta. Tutto ciò che sta sotto .70 è configurato staticamente e resta fuori dal pool: il router, i server, le loro interfacce iLO e il resto dell’infrastruttura che non deve mai spostarsi. La parte alta resta libera come riserva.
PS> Get-DhcpServerv4Scope | Select ScopeId, StartRange, EndRange, LeaseDuration
ScopeId StartRange EndRange LeaseDuration
------- ---------- -------- -------------
192.168.10.0 192.168.10.70 192.168.10.245 8.00:00:00
Option 3 Router
Option 6 DNS Servers (all three DCs)
Option 15 DNS Domain Name muench.home.arpa
Alcuni dettagli da sapere:
- Lease di 8 giorni. In una famiglia in cui gli stessi dispositivi tornano ogni giorno, lease lunghi significano meno chiacchiere. Significano anche che un’interruzione del DHCP passa inosservata per giorni invece che per minuti.
- Load balancing 50/50. Rispondono entrambi i server, e ciascuno è responsabile di metà dei client (decisa da un hash dell’indirizzo MAC). Se un partner sparisce, l’altro continua a servire tutti, rinnovando anche i client del partner, a passi limitati dall’MCLT. Dopo 60 minuti senza contatto passa automaticamente a
PartnerDowne si prende l’intero pool. (Quel passaggio automatico era disattivato di default, e l’ho attivato solo mentre scrivevo questo post.) - MCLT di un’ora. La Maximum Client Lead Time limita di quanto un server può estendere un lease oltre ciò che sa il suo partner. È il margine di sicurezza che impedisce a due server di distribuire lo stesso indirizzo dopo aver perso il contatto.
- Aggiornamenti DNS dinamici. I client si registrano da soli nelle zone AD, quindi ogni portatile è raggiungibile per nome, e il DHCP cancella il record quando il lease scade.
- Autorizzazione in AD. Un server DHCP Windows distribuisce lease solo dopo essere stato autorizzato in Active Directory. Un server DHCP abusivo collegato da qualche persona ben intenzionata resta muto, purché sia un server Windows.
Al momento in cui scrivo il pool è a un vertiginoso 3% di utilizzo. Capacity planning di livello enterprise.
Un’altra piccola lezione: volevo tenere un elenco di tutti i dispositivi configurati staticamente sotto il range dinamico, come “prenotazioni di documentazione” direttamente nella console DHCP. Niente da fare. Add-DhcpServerv4Reservation accetta solo indirizzi dentro il range dello scope. Il DHCP non è un CMDB, e te lo fa sapere.
🔐 Secure Boot, e un DC che aspetta i suoi amici
Tutte e tre le macchine erano state installate in UEFI/GPT con un TPM 2.0 a bordo, ma il Secure Boot era ancora spento nel firmware. Quindi oggi era la giornata del giro nel BIOS: un server alla volta, girare l’interruttore, riavviare, verificare.
“Uno alla volta” è diventata una piccola lezione a sé. HP2 è tornato su mentre HP1 era ancora a metà del riavvio, e per circa sette minuti HP2 rispondeva al ping, aveva tutte le porte aperte… e rifiutava ogni singolo login con HTTP 401. Luci accese, nessuno in casa.
Non era rotto niente. Un domain controller appena avviato vuole completare una sincronizzazione iniziale con i suoi partner di replica prima di assumere pienamente il ruolo di DC. Uno di quei partner stava ancora guardando una schermata del POST, quindi HP2 ha aspettato educatamente un timeout. Appena HP1 è tornato, tutto è ridiventato verde: replica senza errori, failover DHCP di nuovo da CommunicationInterrupted a Normal.
Lezione presa: non riavviare i domain controller in parallelo. Il che porta dritto al prossimo argomento.
🪦 WSUS: installato nella mia testa, deprecato nella realtà
Per qualsiasi amministratore Windows di una certa età, “patch management” significa WSUS. Era nella mia lista: installarlo su HP2, sincronizzare il catalogo, approvare gli aggiornamenti, sentirmi una vera enterprise e guardare SUSDB crescere come un lievito madre che nessuno ha chiesto.
Poi ho letto le clausole in piccolo. Nel 2024 Microsoft ha ufficialmente messo WSUS nella lista dei deprecati. È ancora incluso in Server 2025 e continua a funzionare, ma non riceverà nuove funzionalità, e tutto lo sviluppo va al lato cloud: Windows Autopatch, Intune e Azure Update Manager. Imparare un prodotto nell’anno in cui viene segnato per il pensionamento mi sembrava come studiare per un esame già cancellato. (Inoltre, far girare WSUS con il suo database e IIS su un domain controller non è esattamente una best practice.)
Quindi gli aggiornamenti arrivano direttamente da Microsoft, e la Group Policy decide quando. Il che ci porta alla vera star di questo post.
📜 Group Policy: lo YAML del mondo Windows
Se Ansible è “descrivi lo stato desiderato e lascia che uno strumento lo imponga”, la Group Policy è la stessa idea, integrata nel sistema operativo dal 2000. In più viene distribuita dai domain controller stessi e riapplicata ogni 90 minuti, senza bisogno di eseguire nessun playbook. Lo ammetto, sono un po’ impressionato. Per favore non dirlo ai miei ruoli Ansible.
Ecco cosa è attivo ora nel dominio, tutto creato da PowerShell (New-GPO, Set-GPRegistryValue, New-GPLink) e poi verificato rileggendo i valori di registro reali sulle macchine di destinazione:
1. Unità di rete mappate. HP3 ha una cartella e una condivisione SMB per utente (\\HP3\user1, \\HP3\user2, …). Ogni utente possiede la propria cartella con Full Control sia sui permessi NTFS che su quelli della condivisione, più l’access-based enumeration, così non vedi nemmeno le cartelle che non puoi aprire. Gli account utente vivono nella loro OU, e una singola GPO mappa le lettere di unità. Le Group Policy Preferences con item-level targeting decidono chi riceve cosa: user1 (cioè io, l’amministratore di casa) riceve tutte le unità, e user2 solo la propria. I percorsi usano il nome del server invece dell’IP, così l’autenticazione passa da Kerberos invece di ripiegare su NTLM.
2. Windows Update per i client. Il mio desktop e il mio portatile raramente restano accesi di notte, quindi “installa alle 3 di notte” per loro è inutile. Invece:
- aggiornamenti di qualità rimandati di 3 giorni, così il resto di internet trova per primo le patch difettose
- versione delle feature bloccata, quindi nessun upgrade a sorpresa alla prossima release di Windows 11
- scadenze di 3 giorni (qualità) e 7 giorni (feature), più 2 giorni di tolleranza, dopo i quali il riavvio avviene che mi piaccia o no. Windows Update è sempre stato un prodotto “che ti piaccia o no”; adesso almeno la data la scelgo io
- orario di attività 07:00–23:00
- “aggiorna e arresta” nel menu di accensione, così spegnere la sera fa il lavoro
- Delivery Optimization limitata alla LAN, così gli aggiornamenti vengono scaricati una sola volta per tutta la casa
3. Windows Update per i server: scaglionato. Una GPO di base sulla OU Domain Controllers (download automatico, installazione secondo pianificazione), più una piccola GPO di pianificazione per ogni server con security filtering, così ognuna si applica esattamente a una macchina:
HP3 Saturday 03:00 ← the canary
HP1 Sunday 03:00
HP2 Sunday 05:00
HP3 è il canarino nella miniera delle patch: riceve gli aggiornamenti un giorno prima degli altri. Se un aggiornamento cumulativo rompe qualcosa, lo scopro il sabato e ho ancora un giorno per fermare il resto. E HP1 e HP2 non si riavviano mai contemporaneamente. Vedi la sezione precedente per capire perché è importante.
Piccola trappola laterale nel security filtering: quando togli “Authenticated Users” dal filtro, il gruppo ha comunque bisogno di Read sulla GPO, altrimenti nessuno riesce più a leggerla (MS16-072 manda i suoi saluti). Il computer stesso riceve Apply, e Authenticated Users mantiene Read.
4. Dark mode, e addio Spotlight. Puramente estetico, ed esattamente il mio gusto: ogni utente di casa riceve la dark mode per Windows e per le app, più un desktop nero e semplice. Niente Windows Spotlight, e niente foto a rotazione del tipo “sapevi che questa montagna è in Norvegia?” con un hotspot che ti invita a saperne di più. Spotlight è in pratica uno screensaver con un reparto marketing.
Il problema qui era l’edizione. La policy ufficiale “Turn off all Windows spotlight features” funziona solo su Windows Enterprise ed Education. I miei client girano con Windows 11 Pro, dove la policy viene semplicemente ignorata. Il workaround sono le Group Policy Preferences: invece di una policy ufficiale, la GPO scrive i valori di registro che imposterebbe l’app Impostazioni stessa:
HKCU\…\Themes\Personalize AppsUseLightTheme = 0 # dark apps
HKCU\…\Themes\Personalize SystemUsesLightTheme = 0 # dark taskbar/start
HKCU\…\Explorer\Wallpapers BackgroundType = 1 # solid color, kills Spotlight
HKCU\Control Panel\Colors Background = "0 0 0" # black
HKCU\Control Panel\Desktop Wallpaper = ""
L’azione è impostata su Update, quindi un utente può cambiare lo sfondo, ma il successivo aggiornamento delle policy lo rimette nero. In più la GPO imposta la policy ufficiale “Turn off Spotlight collection on Desktop”, come cintura e bretelle per il giorno in cui una macchina venga aggiornata a Enterprise. Le modifiche entrano in vigore al logon successivo.
5. BitLocker. Quello merita una sezione a parte.
🔒 BitLocker: da cosa protegge davvero?
Prima di attivare qualsiasi cosa, volevo un modello delle minacce chiaro, perché “cifratura = sicurezza” è troppo semplice.
BitLocker protegge i dati a riposo. Il suo lavoro è il portatile rubato, il disco estratto da un server o l’SSD che torna indietro in garanzia. Quello che non fa: proteggere un sistema in funzione e sbloccato. Malware, un account compromesso o una password debole vedono tutto in chiaro, esattamente come prima.
Poi viene la questione di come la chiave viene sbloccata:
- Solo TPM: il TPM rilascia la chiave se la catena di avvio è invariata. È comodo e protegge il disco estratto. Ma l’intera macchina si avvia da sola fino alla schermata di login, quindi se viene rubata l’intera macchina, l’unico ostacolo per il ladro è il login di Windows.
- TPM + PIN: in più un PIN prima ancora che Windows parta. Il dispositivo rubato ora è solo un mattone con un disco cifrato, o un fermacarte molto costoso con una ventola. Meno comodo, ma per un portatile che viaggia con me è la scelta giusta.
La parte divertente: il giorno prima avevo già attivato BitLocker sul mio portatile, solo TPM e senza PIN. La buona notizia: il PIN si può aggiungere dopo. È solo un protettore di chiave aggiuntivo, e non viene ricifrato niente:
manage-bde -protectors -add C: -TPMAndPIN
Il problema: Windows consente un PIN di pre-avvio solo se una policy lo permette. Quindi, sorpresa, un’altra GPO. Ora nel dominio ci sono due policy BitLocker:
- Tutti i client: BitLocker viene attivato automaticamente sull’unità del sistema operativo, e la chiave di ripristino viene salvata in Active Directory. Niente più chiavi in un file di testo su qualche condivisione o su un post-it sotto la tastiera. L’abbiamo visto tutti. Qualcuno di noi l’ha anche scritto.
- Il portatile: TPM + PIN è obbligatorio all’avvio, tramite una GPO dedicata con security filtering esattamente su quella macchina.
Con le GPO al loro posto, i prossimi passi sono gpupdate /force, aggiungere il protettore PIN e poi controllare che la chiave di ripristino compaia davvero nell’oggetto computer in AD. Un backup che non hai mai controllato è una speranza, non un backup.
Poi tocca ai server, a partire da HP3. Come futuro file server centrale, anche il suo volume Storage Spaces viene cifrato, e le chiavi vanno in AD. Per un server che deve tornare su senza nessuno davanti, solo TPM è la scelta pragmatica, perché nessuno vuole digitare un PIN in iLO alle 3 di notte dopo un riavvio per le patch.
💾 Storage Spaces: RAID 5, in stile Microsoft
HP3 ha ricevuto tre SSD SATA da 2 TB per i dati (il sistema operativo sta su un SSD separato). Su Linux avrei preso mdadm o OpenZFS RAIDZ1. Su Windows l’equivalente è Storage Spaces: un pool composto dai dischi fisici, sopra un disco virtuale con resilienza parity (parità singola con tre dischi, quindi RAID 5 nello spirito), formattato con ReFS:
PS> New-StoragePool -FriendlyName BackupPool -PhysicalDisks $disks ...
PS> New-VirtualDisk -StoragePoolFriendlyName BackupPool -ResiliencySettingName Parity ...
PS> Format-Volume -FileSystem ReFS ...
D:\ ReFS ~3.6 TB usable
Poi ovviamente è stato sottoposto a benchmark, con DiskSpd, il generatore di carico storage di Microsoft e più o meno la sua risposta a fio. Ancora una volta passando per la strada IA-su-WinRM. Il metodo:
- Procurarsi lo strumento: non si installa niente. Il server stesso scarica l’ufficiale
DiskSpd.zipdalle release GitHub di Microsoft inC:\Temp, lo estrae e usa il binarioamd64. È un singolo.exeportatile. - File di test: un file da 20 GB direttamente sul volume a parità
D:. - Quattro profili classici: sequenziale con blocchi da 1 MB (un thread, queue depth 8) e casuale con blocchi da 4 KB (quattro thread, queue depth 32 ciascuno), ognuno una volta in lettura e una in scrittura.
- Condizioni eque: 5 secondi di riscaldamento, 30 secondi di misura,
-Shper bypassare sia la cache file di Windows sia la cache di scrittura dei dischi (altrimenti stai misurando la RAM),-Lper i percentili di latenza. - Pulizia: alla fine lo strumento e il file di test vengono cancellati di nuovo, e l’unica cosa che resta sul server è un volume libero.
# sequential write, 1 MB blocks
diskspd.exe -b1M -d30 -W5 -o8 -t1 -si -w100 -Sh -L D:\disktest.dat
# random read, 4 KB blocks, 4 threads x QD32
diskspd.exe -b4K -d30 -W5 -o32 -t4 -r -w0 -Sh -L D:\disktest.dat
Un piccolo script di supporto sul lato Linux esegue ogni profilo via WinRM ed estrae dal report molto loquace di DiskSpd solo la riga total: e il 99° percentile. E ovviamente il primo benchmark mi ha mentito, proprio come aveva fatto dd sulla macchina ZFS:
Sequential read (1 MB) 20997 MiB/s ← three SATA SSDs. Sure.
Random read (4 KB) 739327 IOPS
Venti gigabyte al secondo da tre dischi SATA con un limite di interfaccia complessivo di circa 1,6 GB/s. Il colpevole: il flag -c di DiskSpd ricrea il file di test a ogni esecuzione, e ReFS sa che le aree mai scritte contengono solo zeri. Quindi risponde a quelle letture dai metadati, senza mai toccare un disco. È un benchmark velocissimo del nulla assoluto. L’SSD di Schrödinger: velocissimo, finché nessuno guarda i dati.
Riempi il file una volta con dati veri, poi misura senza -c, e la realtà si fa vedere:
Profile Throughput IOPS avg latency 99th pct
Sequential read (1 MB) 1169 MiB/s 1169 6.8 ms 24 ms
Random read (4 KB, 4x32) 633 MiB/s 162,109 0.55 ms 7.3 ms
Sequential write (1 MB) 88 MiB/s* 88 90.6 ms 427 ms
Random write (4 KB, 4x32) 1.8 MiB/s 461 276 ms 1095 ms
* up to 163 MiB/s in a separate 60-second run
Le letture sono ottime. Le scritture sono… parità. Ogni piccola scrittura si trasforma in un read-modify-write di dati più parità, e senza un tier di cache write-back su SSD/NVMe la parità di Storage Spaces è notoriamente lenta in questo. La colonna della latenza racconta la stessa storia: una piccola scrittura su cento aspetta più di un secondo. È abbastanza tempo per riconsiderare le proprie scelte di vita. Per un file server e una destinazione di backup, dove i dati vengono scritti una volta e letti spesso, va bene. Per qualsiasi cosa con molte piccole scritture casuali, è un no.
Aggiornamento (6 ottobre 2026): la parità era solo metà della storia. Il firmware HPE aveva disattivato all’avvio la cache di scrittura di tutti e tre gli SSD, e -Sh di DiskSpd ha misurato esattamente quello stato, che guarda caso era il modo in cui il server girava ogni giorno. Con la cache attivata, un ripristino sugli stessi dischi (ormai sotto Linux) è andato circa tre volte più veloce. La storia completa: Due cose che mancavano ai miei SSD: il TRIM dopo BitLocker e una cache di scrittura che il mio server HPE aveva spento in silenzio.
(Per correttezza: l’esecuzione si è sovrapposta a un grosso job di copia sullo stesso volume, quindi una nuova misura pulita è ancora nella mia lista. Ma lo schema è chiaro.)
🧪 Prossima tappa: un hypervisor e i miei certificati
“Qualsiasi cosa con molte piccole scritture casuali” è, ovviamente, una descrizione educata delle macchine virtuali. Ed è proprio la prossima cosa con cui voglio giocare: Hyper-V. Windows Server 2025 lo porta comunque con sé, e voglio vedere come si sente rispetto al mondo Proxmox che conosco: live migration tra host, checkpoint, switch virtuali e virtualizzazione annidata per un laboratorio di test dentro il laboratorio.
Il benchmark qui sopra ha già risposto a una domanda di progettazione prima ancora che iniziassi. I dischi delle VM non staranno sul pool a parità. Con ~460 IOPS di scrittura casuale, una VM Windows passerebbe la vita a fissare un cerchio che gira. Il cerchio di caricamento come stile di vita. Quindi un setup da hypervisor come si deve ha bisogno di un layout di storage diverso: mirror invece di parità, oppure NVMe locale. Materiale per il prossimo post.
Il secondo punto della lista: emettere i miei certificati. Windows Server porta con sé una propria PKI, Active Directory Certificate Services. Sul lato Linux, cert-manager e Let’s Encrypt si occupano di tutto ciò che è esposto a internet. Internamente però c’è un intero zoo che nessuno firmerà mai pubblicamente: interfacce web iLO, RDP, LDAPS sui domain controller e le pagine di amministrazione di dispositivi assortiti. Ognuno di essi al momento mi accoglie con un avviso sul certificato che mi sono abituato a cliccare via. È esattamente il riflesso che non vuoi avere.
Il piano è una piccola CA interna, il cui certificato radice viene distribuito a ogni membro del dominio tramite (ovviamente) Group Policy. Con i modelli di certificato e l’auto-enrollment, le macchine richiedono e rinnovano da sole i propri certificati, come cert-manager, solo in edizione Microsoft. Il design da manuale è una root CA offline con sotto una CA emittente. Se un homelab abbia davvero bisogno di due livelli, o se sia quello il momento in cui l’apprendimento diventa cosplay, resta da vedere.
🎯 In sintesi
Una settimana fa ti avrei detto che amministrare Windows significa cliccare attraverso dei wizard. Viene fuori che con PowerShell e WinRM è sorprendentemente scriptabile, e la Group Policy è in pratica configuration management con un sistema operativo costruito intorno.
Le lezioni lungo la strada sono state le stesse di Linux: leggi le clausole in piccolo (il failover DHCP è a coppie, WSUS è deprecato), non fidarti del primo benchmark (ReFS e i suoi zeri) e non riavviare tutto in una volta (i domain controller sono creature socievoli).
Due binari, dunque. Linux continua a far girare la roba di produzione, e Windows Server diventa il parco giochi dove imparo. E sinceramente? Dopo una settimana di YAML, Get-ADReplicationPartnerMetadata mi è sembrato una vacanza. 🏖️
P.S. Ora, se permetti, devo andare a spiegare alla famiglia perché lo sfondo del loro desktop è improvvisamente diventato nero. “È una policy” non ha mai funzionato nemmeno una volta come spiegazione a casa.
📚 Altro in questa serie: Windows Server 2025 nell’homelab
- 🐧➡️🪟 Dal pinguino a Windows: perché nel mio homelab torno a usare Windows Server 2025
- Day Two Operations: mettere in sicurezza tre domain controller Windows (e trovare un orologio che non rispondeva a nessuno)
- La mia piccola Certificate Authority: AD CS, auto-enrollment e addio a “La connessione non è privata”
