BGInfo mostra “Server 2016” dopo l’upgrade: come correggere e standardizzare Windows Server 2022 (Registro, WMI, PowerShell, GPO)

BGInfo mostra ancora “Server 2016” dopo l’upgrade a Windows Server 2022? Succede più spesso di quanto si pensi. In questa guida trovi cause, diagnosi e soluzioni operative (Registro, BGInfo, WMI, PowerShell e GPO) per riallineare subito le informazioni di sistema e ripristinare coerenza nei tuoi cruscotti.

Indice

Panoramica del problema

Dopo un upgrade in‑place da Windows Server 2016 a Windows Server 2022, può capitare che la schermata Windows Specifications (Impostazioni → Sistema → Informazioni su) indichi correttamente Windows Server 2022 Standard, mentre BGInfo continua a visualizzare una stringa obsoleta come “Server 2016 Version 1.0”. La stessa anomalia può affiorare nella sezione Device specifications o in strumenti di inventory che leggono il Registro.

Il risultato è una incongruenza di versione potenzialmente fuorviante per operatori NOC, procedure automatizzate, dashboard CMDB o script che reagiscono a stringhe “matching” dell’OS.

Perché succede

Le cause ricorrenti sono due e, spesso, si sommano:

Valori di Registro non aggiornati: BGInfo legge alcune proprietà dal Registro di sistema, in particolare sotto HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion. Se l’upgrade non allinea campi come ProductName o CurrentVersion, BGInfo mostra ancora il vecchio nome.
Versione di BGInfo non allineata: build meno recenti (≤ 4.28) non riconoscono correttamente Windows Server 2022 e mappano i codici versione/Build a etichette precedenti (es. “Server 2016”), anche quando le API restituiscono 10.0.x.

Sintomi tipici

BGInfo stampa “Server 2016 Version 1.0” nonostante winver mostri Windows Server 2022.
In Impostazioni → Sistema → Informazioni su, “Windows Specifications” è corretto, ma “Device specifications” o strumenti che leggono dal Registro riportano valori incoerenti.
Strumenti RMM/monitoring basati su output BGInfo classificano il server come 2016 e applicano policy errate.

Come verificare lo stato reale della macchina

Prima di intervenire, accertati che l’OS sia effettivamente Windows Server 2022 e prendi nota della Build.

Comandi rapidi

winver
systeminfo | findstr /I "OS Name OS Version"
(Get-CimInstance Win32_OperatingSystem) | Select-Object Caption, Version, BuildNumber
Get-ComputerInfo | Select-Object OsName, OsVersion, OsBuildNumber

Riferimento utile: Windows Server 2022 tipicamente riporta Build 20348 (la UBR varia con gli aggiornamenti cumulativi).

Decisione rapida: quale strada scegliere

Usa questa traccia decisionale:

Hai pochi server e ti serve una correzione immediata? → Correzione del Registro (Approccio A).
Gestisci una farm e vuoi evitare dipendenze dal Registro? → Aggiorna BGInfo e usa WMI personalizzato (Approccio B).
Hai tempo e vuoi eliminare la classe di problema alla radice? → A+B: aggiorna BGInfo e riallinea i valori errati del Registro.

Soluzioni proposte a confronto

Approccio	Passaggi essenziali	Vantaggi	Rischi / Limitazioni
A. Correzione diretta del Registro	Apri `regedit.exe` come amministratore. Vai a `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion`. Verifica/forza i valori: `CurrentVersion` = `10.0` `ProductName` = `Windows Server 2022 Standard` (o Datacenter se applicabile) Chiudi BGInfo e rilancialo.	Effetto immediato. Non richiede modifiche al layout BGInfo.	Intervento sul Registro: fai backup/snapshot prima. Futuri aggiornamenti potrebbero sovrascrivere i valori.
B. Aggiornamento BGInfo + query WMI personalizzata	Installa BGInfo ≥ 4.30 (o la versione più recente disponibile nel tuo repository). In BGInfo, vai su Custom → New → WMI Query. Usa la query `SELECT Caption FROM Win32_OperatingSystem` e assegna il campo a, ad es., `OSCaption`. Sostituisci nel layout `%OS%` con `%OSCaption%`.	Nessuna dipendenza dal Registro. Resiliente a futuri cambi di naming. Puoi esporre anche Build e UBR.	Richiede la distribuzione del nuovo file `.bgi` o l’aggiornamento del tuo script di avvio. Versioni molto vecchie di BGInfo potrebbero non supportare WMI personalizzato.

Soluzione dettagliata: correzione del Registro

Avvertenze

Lavora sempre con autorizzazioni amministrative e pianifica una finestra di manutenzione. Prima di toccare il Registro, esporta la chiave o crea uno snapshot/backup della VM.

reg export "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" "C:\Temp\CurrentVersion.backup.reg"

Valori attesi

Chiave	Valore	Note
`CurrentVersion`	`10.0`	Linea Windows 10/Server 2016+.
`ProductName`	`Windows Server 2022 Standard` / `Windows Server 2022 Datacenter`	Usa l’edizione corretta.
`CurrentBuild` / `CurrentBuildNumber`	Tipicamente `20348`	Non sempre necessario toccarlo.

Impostazione veloce da prompt elevato

reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v CurrentVersion /t REG_SZ /d 10.0 /f
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v ProductName /t REG_SZ /d "Windows Server 2022 Standard" /f

Se l’edizione è Datacenter, sostituisci la riga corrispondente:

reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v ProductName /t REG_SZ /d "Windows Server 2022 Datacenter" /f

Script PowerShell “fix‑it” sicuro e idempotente

Questo script verifica che il sistema sia davvero Server 2022 e solo in quel caso riallinea i valori. Di default gira in modalità -WhatIf (simulazione); rimuovi -WhatIf quando sei pronto.

$ErrorActionPreference = 'Stop'

function Test-IsServer2022 {
$os = Get-CimInstance Win32_OperatingSystem
return ($os.Caption -match 'Windows Server 2022' -or $os.BuildNumber -eq '20348')
}

function Backup-CurrentVersionKey {
$backup = "C:\Temp\CurrentVersion.$((Get-Date).ToString('yyyyMMdd-HHmmss')).reg"
New-Item -ItemType Directory -Path (Split-Path $backup) -Force | Out-Null
& reg.exe export "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" $backup /y | Out-Null
return $backup
}

function Set-OsRegistryStrings {
param(
[Parameter(Mandatory=$true)][ValidateSet('Standard','Datacenter')] [string] $Edition,
[switch] $WhatIf
)
$targetName = "Windows Server 2022 $Edition"
$regPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion"
```
$current = Get-ItemProperty -Path $regPath -Name ProductName, CurrentVersion -ErrorAction SilentlyContinue
if ($null -ne $current -and $current.ProductName -eq $targetName -and $current.CurrentVersion -eq '10.0') {
    Write-Host "Registro già coerente: $($current.ProductName) ($($current.CurrentVersion))."
    return $true
}

$backup = Backup-CurrentVersionKey
Write-Host "Backup creato: $backup"

$splat = @{
    Path  = $regPath
    Name  = 'CurrentVersion'
    Value = '10.0'
    Type  = 'String'
}
if ($WhatIf) { Set-ItemProperty @splat -WhatIf } else { Set-ItemProperty @splat }

$splat = @{
    Path  = $regPath
    Name  = 'ProductName'
    Value = $targetName
    Type  = 'String'
}
if ($WhatIf) { Set-ItemProperty @splat -WhatIf } else { Set-ItemProperty @splat }

Write-Host "Registro aggiornato a '$targetName' (CurrentVersion=10.0)."
return $true
```
}

if (Test-IsServer2022) {
Imposta 'Standard' o 'Datacenter' in base alla tua edizione
Set-OsRegistryStrings -Edition 'Standard' -WhatIf
} else {
Write-Warning "La macchina non risulta Server 2022. Nessuna modifica applicata."
}

Verifica post‑fix

(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ProductName
(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").CurrentVersion
(Get-CimInstance Win32_OperatingSystem) | Select-Object Caption, Version, BuildNumber

Chiudi e riapri BGInfo (o riesegui lo script di avvio) e verifica che la riga OS riporti “Windows Server 2022 …”.

Soluzione dettagliata: aggiornamento BGInfo e campo WMI

Se preferisci evitare qualunque dipendenza dal Registro o vuoi rendere l’indicatore più ricco e robusto, aggiorna BGInfo e usa WMI come fonte principale.

Passi consigliati

Distribuisci BGInfo ≥ 4.30 su tutti i server (es. share centralizzata o pacchetto di gestione software).
Apri BGInfo e vai su Custom → New → WMI Query.
Inserisci la query: SELECT Caption FROM Win32_OperatingSystem Assegna il nome del campo a OSCaption.
Nel layout sostituisci il campo %OS% con %OSCaption%.

Estendere le informazioni visibili

Puoi aggiungere altri campi WMI per una telemetria più utile:

SELECT Version FROM Win32_OperatingSystem     -- restituisce "10.0.x"
SELECT BuildNumber FROM Win32_OperatingSystem -- restituisce la build (es. 20348)
SELECT CSName FROM Win32_ComputerSystem       -- nome computer

Esempio di riga OS “parlante” combinata (via layout BGInfo):

%OSCaption% (ver. %WMIVersion%, build %WMIBuildNumber%)

Distribuzione del layout via comando

BGInfo può essere lanciato silenziosamente da script di logon/startup o attività pianificate:

\\fileserver\tools\bginfo\Bginfo.exe \\fileserver\tools\bginfo\layout2022.bgi /timer:0 /nolicprompt /silent /accepteula /log \\fileserver\logs\bginfo\%computername%.log

Automazione e distribuzione su larga scala

Esecuzione via GPO (Startup script)

Copia Bginfo.exe e il tuo .bgi in una share accessibile in sola lettura dai server.
Crea una GPO collegata all’OU dei server con uno Startup Script (Computer Configuration → Policies → Windows Settings → Scripts).
Script di esempio che prima corregge il Registro (se necessario) e poi richiama BGInfo:

# Fix condizionale (solo se OS = Server 2022 ma registro "sembra" 2016)
$os = Get-CimInstance Win32_OperatingSystem
$cv = Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion"
if (($os.Caption -match 'Windows Server 2022' -or $os.BuildNumber -eq '20348') -and ($cv.ProductName -match '2016')) {
    reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v CurrentVersion /t REG_SZ /d 10.0 /f
    reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v ProductName /t REG_SZ /d "Windows Server 2022 Standard" /f
}

BGInfo (layout con campi WMI)

\fileserver\tools\bginfo\Bginfo.exe \fileserver\tools\bginfo\layout2022.bgi /timer:0 /nolicprompt /silent /accepteula </code></pre>

<h3>Remediation remota PowerShell</h3>
<p>Se vuoi correggere un set di server selezionati e hai PSRemoting attivo:</p>
<pre><code class="language-powershell">$targets = @('SRV-FILE01','SRV-APP02','SRV-DB03')
Invoke-Command -ComputerName $targets -ScriptBlock {
    $os = Get-CimInstance Win32_OperatingSystem
    $cv = Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion"
    if (($os.Caption -match 'Windows Server 2022' -or $os.BuildNumber -eq '20348') -and ($cv.ProductName -match '2016')) {
        & reg.exe add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v CurrentVersion /t REG_SZ /d 10.0 /f
        & reg.exe add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v ProductName /t REG_SZ /d "Windows Server 2022 Standard" /f
        "Remediated on $env:COMPUTERNAME"
    } else {
        "No change on $env:COMPUTERNAME"
    }
}
</code></pre>

<h2>Buone pratiche supplementari</h2>
<ul>
  <li><strong>Verifica multisorgente</strong>: oltre a BGInfo, controlla <code>winver</code>, <code>systeminfo</code> e PowerShell (<code>Get-ComputerInfo</code>, <code>Get-CimInstance Win32_OperatingSystem</code>). Per Server 2022, aspettati <strong>10.0.20348</strong> come build line.</li>
  <li><strong>Aggiorna BGInfo regolarmente</strong>: mantieni la stessa versione su tutto il parco server per evitare comportamenti diversi.</li>
  <li><strong>Standardizza il layout</strong>: conserva il file <code>.bgi</code> in un repository versionato; ogni modifica (es. nuovi campi WMI) diventa una release con changelog.</li>
  <li><strong>Automatizza</strong>: usa GPO/Intune/strumenti di gestione per forzare BGInfo a ogni logon o riavvio (<code>/timer:0 /silent</code>).</li>
  <li><strong>Backup del Registro</strong>: prima di cambiare valori, <code>reg export</code> della chiave <code>CurrentVersion</code> o snapshot della VM.</li>
</ul>

<h2>Diagnostica avanzata: come capire dove nasce l’incongruenza</h2>
<ol>
  <li><strong>Controlla cosa legge BGInfo</strong>: se nel layout usi il campo “OS” predefinito, è probabile che provenga dal Registro. Se usi un campo WMI personalizzato e resta errato, sospetta la versione di BGInfo.</li>
  <li><strong>Ispeziona la chiave di Registro</strong>: verifica <code>ProductName</code> e <code>CurrentVersion</code>. Se contengono riferimenti a 2016, sei nel caso A.</li>
  <li><strong>Confronta con WMI</strong>:
    <pre><code>(Get-CimInstance Win32_OperatingSystem).Caption
(Get-CimInstance Win32_OperatingSystem).BuildNumber

Se WMI dice “Windows Server 2022” ma BGInfo mostra “2016”, il layout/vers. BGInfo è il colpevole.

Esamina il layout .bgi: aprilo e verifica che non ci siano campi duplicati o macro personalizzate non aggiornate.

Checklist di validazione finale

Output di BGInfo: riga OS corretta e coerente con quanto mostrato da WMI.
Impostazioni → Sistema → Informazioni su: entrambe le sezioni “Windows Specifications” e “Device specifications” coerenti.
systeminfo e Get-ComputerInfo riportano Server 2022.
Eventuali dashboard di monitoring aggiornano la classificazione host dopo il prossimo poll.

Domande frequenti

È sicuro cambiare `ProductName` nel Registro?

Se eseguito correttamente e solo per allineare un valore rimasto obsoleto dopo l’upgrade, sì. Non toccare chiavi legate a licensing/attivazione (EditionID, InstallationType, ecc.). Esegui sempre un backup e documenta la modifica.

BGInfo continua a mostrare il valore vecchio anche con WMI

Verifica di aver sostituito %OS% con %OSCaption% nel layout e di aver salvato il .bgi aggiornato. Assicurati inoltre che lo script lanci BGInfo con quel file (controlla percorsi e permessi).

Quali build identificano le famiglie recenti di Windows Server?

Prodotto	Build “line” tipica	Nota
Windows Server 2016	14393	Versione associata a 1607.
Windows Server 2019	17763	Versione associata a 1809.
Windows Server 2022	20348	UBR cresce con i cumulativi; la “line” resta 20348.

Posso forzare BGInfo a un refresh senza logon?

Sì, con un’Attività Pianificata in esecuzione come SYSTEM o come un account di servizio con privilegi, che richiama il comando BGInfo in modalità /silent e layout predefinito.

Template operativo riutilizzabile

Di seguito un Playbook conciso da adattare nella tua documentazione interna.

Rilevazione: script che segnala host dove Win32_OperatingSystem.Caption contiene “2022” ma ProductName nel Registro contiene “2016”.
Remediation: applica la correzione del Registro (Approccio A) oppure aggiorna BGInfo e layout WMI (Approccio B).
Verifica: confronta output BGInfo vs WMI e registra esito in un log centralizzato.

Rilevazione mirata (PowerShell)

$report = foreach ($c in Get-Content .\serverlist.txt) {
    try {
        $os = Invoke-Command -ComputerName $c -ScriptBlock { Get-CimInstance Win32_OperatingSystem } -ErrorAction Stop
        $cv = Invoke-Command -ComputerName $c -ScriptBlock { Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" } -ErrorAction Stop
        [pscustomobject]@{
            ComputerName = $c
            WMI_Caption  = $os.Caption
            WMI_Build    = $os.BuildNumber
            Reg_Product  = $cv.ProductName
            Drift        = ($os.Caption -match '2022') -and ($cv.ProductName -match '2016')
        }
    } catch {
        [pscustomobject]@{ ComputerName=$c; WMICaption=$null; WMIBuild=$null; RegProduct=$null; Drift=$null; Note=$.Exception.Message }
    }
}
$report | Where-Object Drift | Format-Table -Auto
Esporta per audit
$report | Export-Csv .\Bginfo-Server2022-Drift.csv -NoTypeInformation -Encoding UTF8

Ripristino in caso di problemi

Se qualcosa non torna, importa il backup del Registro creato prima della modifica o reimposta manualmente i valori precedenti. Ricorda che l’obiettivo è armonizzare la visualizzazione, non forzare uno “spoofing” dell’edizione.

reg import "C:\Temp\CurrentVersion.backup.reg"

Riepilogo esecutivo

Problema: BGInfo continua a mostrare “Server 2016” anche dopo l’upgrade a Server 2022.
Cause: chiavi del Registro non aggiornate e/o BGInfo obsoleto che non mappa correttamente Windows Server 2022.
Soluzioni:
1. Allinea il Registro (ProductName e CurrentVersion), con backup e verifica.
2. Aggiorna BGInfo e usa WMI (Win32_OperatingSystem.Caption) nel layout.
Best practice: verifica con comandi di sistema (winver, systeminfo, PowerShell), mantieni BGInfo aggiornato, automatizza la distribuzione e conserva un template standardizzato.

Conclusioni

Questa anomalia nasce da una combinazione di fattori tecnici e storici (upgrade in‑place, mapping di versioni e fonti dati diverse). La buona notizia è che la correzione è rapida e ripetibile. Che tu scelga un fix mirato al Registro o una soluzione più “future‑proof” basata su WMI, con i passaggi sopra puoi ripristinare coerenza informativa e prevenire errori nei tuoi processi di gestione.

Riferimenti operativi rapidi

Chiave: HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion
Valori chiave: ProductName, CurrentVersion (= 10.0)
WMI: Win32_OperatingSystem → Caption, Version, BuildNumber
Build line Server 2022: 20348
BGInfo: usa campo personalizzato %OSCaption% da WMI

Metti in produzione seguendo la regola d’oro: backup → change → verifica → automatizza. In questo modo BGInfo tornerà ad essere un alleato affidabile per il tuo fleet management.