Aggiornare i supporti di installazione di Windows con Aggiornamento dinamico

Questo articolo illustra come acquisire e applicare pacchetti di aggiornamento dinamico alle immagini Windows esistenti prima della distribuzione e include script Windows PowerShell che è possibile usare per automatizzare questo processo.

I supporti con contratti multilicenza sono disponibili per ogni versione di Windows nel Volume Licensing Service Center (VLSC) e per altri canali pertinenti, ad esempio Windows Update per le aziende, Windows Server Update Services (WSUS) e Sottoscrizioni di Visual Studio. È possibile usare Aggiornamento dinamico per assicurarsi che i dispositivi Windows dispongano dei pacchetti di aggiornamento delle funzionalità più recenti come parte di un aggiornamento sul posto, mantenendo al tempo stesso language pack e funzionalità su richiesta che potrebbero essere state installate in precedenza. L'aggiornamento dinamico elimina anche la necessità di installare un aggiornamento qualitativo separato come parte del processo di aggiornamento sul posto.

Aggiornamento dinamico

Ogni volta che viene avviata l'installazione di un aggiornamento delle funzionalità (dal supporto o da un ambiente connesso a Windows Update), l'aggiornamento dinamico è uno dei primi passaggi. Installazione di Windows contatta un endpoint Microsoft per recuperare i pacchetti di Aggiornamento dinamico e quindi applica tali aggiornamenti al supporto di installazione del sistema operativo. I pacchetti di aggiornamento includono i tipi di aggiornamenti seguenti:

• Aggiornamenti per Setup.exe file binari o altri file usati dal programma di installazione per gli aggiornamenti delle funzionalità
• Aggiornamenti per il "sistema operativo sicuro" (SafeOS) usato per l'ambiente di ripristino di Windows
• Aggiornamenti allo stack di manutenzione necessario per completare l'aggiornamento delle funzionalità Per altre informazioni, vedere Aggiornamenti dello stack di manutenzione.
• Aggiornamento cumulativo (qualità) più recente
• Aggiornamenti ai driver applicabili già pubblicati dai produttori specificamente destinati all'aggiornamento dinamico

Aggiornamento dinamico mantiene i pacchetti Language Pack e Funzionalità su richiesta riacquisendoli.

I dispositivi devono essere in grado di connettersi a Internet per ottenere la Aggiornamenti dinamica. In alcuni ambienti non è possibile ottenere Aggiornamenti dinamiche. È comunque possibile eseguire un aggiornamento delle funzionalità basato su supporti acquisendo pacchetti di aggiornamento dinamico e applicandolo all'immagine prima di avviare l'installazione nel dispositivo.

Acquisire pacchetti di aggiornamento dinamico

È possibile ottenere pacchetti di aggiornamento dinamico dal catalogo di Microsoft Update. In tale sito usare la barra di ricerca in alto a destra per trovare i pacchetti di aggiornamento dinamico per una determinata versione. I vari pacchetti di aggiornamento dinamico potrebbero non essere tutti presenti nei risultati di una singola ricerca, quindi potrebbe essere necessario cercare con parole chiave diverse per trovare tutti gli aggiornamenti. Controllare varie parti dei risultati per assicurarsi di aver identificato i file necessari. Le tabelle seguenti mostrano i valori chiave da cercare o cercare nei risultati.

Pacchetti di Aggiornamento dinamico di Windows Server 2025

Il titolo può distinguere ogni pacchetto dinamico. Gli aggiornamenti cumulativi più recenti includono lo stack di manutenzione incorporato. Lo stack di manutenzione viene pubblicato solo se necessario per un determinato aggiornamento cumulativo.

Pacchetti di aggiornamento dinamico di Windows Server versione 23H2

Il titolo può distinguere ogni pacchetto dinamico. Gli aggiornamenti cumulativi più recenti includono lo stack di manutenzione incorporato. Lo stack di manutenzione viene pubblicato solo se necessario per un determinato aggiornamento cumulativo. Azure Stack HCI, versione 23H2, ha un formato simile.

Pacchetti di aggiornamento dinamico di Azure Stack HCI versione 22H2

Titolo, Prodotto e Descrizione sono necessari per distinguere ogni pacchetto dinamico. L'aggiornamento cumulativo più recente include lo stack di manutenzione incorporato. Stack di manutenzione pubblicato separatamente solo se necessario come prerequisito per un determinato aggiornamento cumulativo.

Pacchetti di Aggiornamento dinamico di Windows Server 2022 successivi

Titolo, Prodotto e Descrizione sono necessari per distinguere ogni pacchetto dinamico. L'aggiornamento cumulativo più recente include lo stack di manutenzione incorporato. Stack di manutenzione pubblicato separatamente solo se necessario come prerequisito per un determinato aggiornamento cumulativo.

Windows 11, versione 22H2 e pacchetti di aggiornamento dinamico successivi

Il titolo può distinguere ogni pacchetto dinamico. Gli aggiornamenti cumulativi più recenti includono lo stack di manutenzione incorporato. Lo stack di manutenzione viene pubblicato solo se necessario per un determinato aggiornamento cumulativo. I titoli seguenti sono per Windows 11 versione 22H2. Windows 11 versione 23H2 e 24H2 hanno un formato simile.

pacchetti di aggiornamento dinamico di Windows 11 versione 21H2

Titolo, Prodotto e Descrizione sono necessari per distinguere ogni pacchetto dinamico. L'aggiornamento cumulativo più recente include lo stack di manutenzione incorporato. Stack di manutenzione pubblicato separatamente solo se necessario come prerequisito per un determinato aggiornamento cumulativo.

pacchetti di aggiornamento dinamico di Windows 10 versione 22H2

Titolo, Prodotto e Descrizione sono necessari per distinguere ogni pacchetto dinamico. L'aggiornamento cumulativo più recente include lo stack di manutenzione incorporato. Stack di manutenzione pubblicato separatamente solo se necessario come prerequisito per un determinato aggiornamento cumulativo.

Se si vuole personalizzare l'immagine con altre lingue o funzionalità su richiesta, scaricare i file ISO dei supporti supplementari dal Centro servizi per contratti multilicenza. Ad esempio, se l'aggiornamento dinamico verrà disabilitato per i dispositivi e se gli utenti richiedono funzionalità specifiche su richiesta, è possibile preinstallarli nell'immagine.

Aggiornare i supporti di installazione di Windows

L'aggiornamento corretto del supporto di installazione comporta molte azioni che operano su diverse destinazioni (file di immagine). Alcune azioni vengono ripetute su destinazioni diverse. I file delle immagini di destinazione includono:

• Windows Preinstallation Environment (WinPE): un piccolo sistema operativo usato per installare, distribuire e ripristinare i sistemi operativi Windows
• Windows Recovery Environment (WinRE): corregge le cause comuni dei sistemi operativi non avviabili. WinRE è basato su WinPE e può essere personalizzato con driver, lingue, pacchetti facoltativi e altri strumenti di risoluzione dei problemi o diagnostica aggiuntivi.
• Sistema operativo Windows: una o più edizioni di Windows archiviate in \sources\install.wim
• Supporto di installazione di Windows: raccolta completa di file e cartelle nel supporto di installazione di Windows. Ad esempio, \sources folder, \boot folder, Setup.exe e così via.

Questa tabella mostra la sequenza corretta per l'applicazione delle varie attività ai file. Ad esempio, la sequenza completa inizia con l'aggiunta dell'aggiornamento dello stack di manutenzione a WinRE (1) e si conclude con l'aggiunta di Gestione avvio da WinPE al nuovo supporto (28).

Più edizioni di Windows

Il file del sistema operativo principale (install.wim) potrebbe contenere più edizioni di Windows. È possibile che sia necessario solo un aggiornamento per una determinata edizione per distribuirla, in base all'indice. In alternativa, potrebbe essere necessario un aggiornamento per tutte le edizioni. Assicurarsi inoltre che le lingue vengano installate prima di Funzionalità su richiesta e che l'aggiornamento cumulativo più recente venga sempre applicato per ultimo.

Lingue e funzionalità aggiuntive

Non è necessario aggiungere altre lingue e funzionalità all'immagine per eseguire gli aggiornamenti, ma è un'opportunità per personalizzare l'immagine con più lingue, componenti facoltativi e funzionalità su richiesta oltre a quanto contenuto nell'immagine iniziale. Quando si aggiungono altre lingue e funzionalità, è importante apportare queste modifiche nell'ordine corretto: applicare prima gli aggiornamenti dello stack di manutenzione, seguiti dalle aggiunte di linguaggio, quindi dalle aggiunte di funzionalità e infine dall'aggiornamento cumulativo più recente. Lo script di esempio fornito installa una seconda lingua (in questo caso giapponese (ja-JP)). Poiché questa lingua è supportata da un lp.cab, non è necessario aggiungere un Language Experience Pack. Il giapponese viene aggiunto sia al sistema operativo principale che all'ambiente di ripristino per consentire all'utente di visualizzare le schermate di ripristino in giapponese. Ciò include l'aggiunta di versioni localizzate dei pacchetti attualmente installati nell'immagine di ripristino.

I componenti facoltativi, insieme alla funzionalità .NET, possono essere installati offline, ma in questo modo vengono create operazioni in sospeso che richiedono il riavvio del dispositivo. Di conseguenza, la chiamata per eseguire la pulizia dell'immagine avrebbe esito negativo. Esistono due opzioni per evitare l'errore di pulizia. Un'opzione consiste nel ignorare il passaggio di pulizia dell'immagine, anche se ciò comporta un file install.wim più grande. Un'altra opzione consiste nell'installare .NET e i componenti facoltativi in un passaggio dopo la pulizia, ma prima dell'esportazione. Questa è l'opzione nello script di esempio. In questo modo, dovrai iniziare con il file install.wim originale (senza azioni in sospeso) quando gestisci o aggiorni l'immagine la volta successiva (ad esempio, il mese successivo).

Aggiornamenti cumulativi del checkpoint

A partire da Windows 11, versione 24H2 e Windows Server 2025, l'aggiornamento cumulativo più recente potrebbe avere un aggiornamento cumulativo prerequisito che deve essere installato per primo. Questi sono noti come aggiornamenti cumulativi del checkpoint. In questi casi, i differenziali a livello di file di aggiornamento cumulativo si basano su un aggiornamento cumulativo precedente anziché sulla versione di Windows RTM. Il vantaggio è un pacchetto di aggiornamento più piccolo e un'installazione più veloce. Quando si ottiene l'aggiornamento cumulativo più recente da Microsoft Update Catalog, gli aggiornamenti cumulativi del checkpoint saranno disponibili dal pulsante di download. Inoltre, l'articolo knowledge base per l'aggiornamento cumulativo fornirà informazioni aggiuntive.

Per installare i checkpoint durante la manutenzione del sistema operativo Windows (passaggi 9 & 12) e WinPE (passaggi 17 & 23), chiamare Add-WindowsPackage con l'aggiornamento cumulativo di destinazione. La cartella da -PackagePath verrà usata per individuare e installare uno o più checkpoint in base alle esigenze. Nella cartella devono essere presenti solo gli aggiornamenti cumulativi di destinazione e i -PackagePath checkpoint cumulativi. Pacchetti di aggiornamento cumulativo con una revisione <= l'aggiornamento cumulativo di destinazione verrà elaborato. Se non si personalizza l'immagine con lingue aggiuntive e/o funzionalità facoltative, è possibile usare chiamate separate a Add-WindowsPackage (prima gli aggiornamenti cumulativi del checkpoint) per i passaggi 9 & 17 precedenti. Non è possibile usare chiamate separate per i passaggi 12 e 23.

Windows PowerShell script per applicare la Aggiornamenti dinamica a un'immagine esistente

Questi esempi sono solo a scopo illustrativo e pertanto mancano di gestione degli errori. Lo script presuppone che i pacchetti seguenti siano archiviati localmente in questa struttura di cartelle:

Informazioni di base

Lo script inizia dichiarando le variabili globali e creando cartelle da usare per il montaggio di immagini. Quindi, creare una copia del supporto originale, da \oldMedia a \newMedia, mantenendo il supporto originale nel caso in cui si verifichi un errore di script ed è necessario ricominciare da uno stato noto. Inoltre, offre un confronto tra supporti vecchi e nuovi per valutare le modifiche. Per assicurarsi che i nuovi aggiornamenti multimediali non siano di sola lettura.

#Requires -RunAsAdministrator

function Get-TS { return "{0:HH:mm:ss}" -f [DateTime]::Now }

Write-Output "$(Get-TS): Starting media refresh"

# Declare language for showcasing adding optional localized components
$LANG  = "ja-jp"
$LANG_FONT_CAPABILITY = "jpan"

# Declare media for FOD and LPs
# Note: Starting with Windows 11, version 21H2, the language pack (LANGPACK) ISO has been superseded by the FOD ISO.
# Language packs and the \Windows Preinstallation Environment packages are part of the LOF ISO.
# If you are using this script for Windows 10, modify to mount and use the LANGPACK ISO.
$FOD_ISO_PATH    = "C:\mediaRefresh\packages\FOD-PACKAGES_OEM_PT1_amd64fre_MULTI.iso"

# Declare Dynamic Update packages. A dedicated folder is used for the latest cumulative update, and as needed
# checkpoint cumulative updates.
$LCU_PATH        = "C:\mediaRefresh\packages\CU\LCU.msu"
$SSU_PATH        = "C:\mediaRefresh\packages\Other\SSU_DU.msu"
$SETUP_DU_PATH   = "C:\mediaRefresh\packages\Other\Setup_DU.cab"
$SAFE_OS_DU_PATH = "C:\mediaRefresh\packages\Other\SafeOS_DU.cab"
$DOTNET_CU_PATH  = "C:\mediaRefresh\packages\Other\DotNet_CU.msu"

# Declare folders for mounted images and temp files
$MEDIA_OLD_PATH  = "C:\mediaRefresh\oldMedia"
$MEDIA_NEW_PATH  = "C:\mediaRefresh\newMedia"
$WORKING_PATH    = "C:\mediaRefresh\temp"
$MAIN_OS_MOUNT   = "C:\mediaRefresh\temp\MainOSMount"
$WINRE_MOUNT     = "C:\mediaRefresh\temp\WinREMount"
$WINPE_MOUNT     = "C:\mediaRefresh\temp\WinPEMount"

# Mount the Features on Demand ISO
Write-Output "$(Get-TS): Mounting FOD ISO"
$FOD_ISO_DRIVE_LETTER = (Mount-DiskImage -ImagePath $FOD_ISO_PATH -ErrorAction stop | Get-Volume).DriveLetter

# Note: Starting with Windows 11, version 21H2, the correct path for main OS language and optional features
# moved to \LanguagesAndOptionalFeatures instead of the root. For Windows 10, use $FOD_PATH = $FOD_ISO_DRIVE_LETTER + ":\"
$FOD_PATH = $FOD_ISO_DRIVE_LETTER + ":\LanguagesAndOptionalFeatures"

# Declare language related cabs
$WINPE_OC_PATH              = "$FOD_ISO_DRIVE_LETTER`:\Windows Preinstallation Environment\x64\WinPE_OCs"
$WINPE_OC_LANG_PATH         = "$WINPE_OC_PATH\$LANG"
$WINPE_OC_LANG_CABS         = Get-ChildItem $WINPE_OC_LANG_PATH -Name
$WINPE_OC_LP_PATH           = "$WINPE_OC_LANG_PATH\lp.cab"
$WINPE_FONT_SUPPORT_PATH    = "$WINPE_OC_PATH\WinPE-FontSupport-$LANG.cab"
$WINPE_SPEECH_TTS_PATH      = "$WINPE_OC_PATH\WinPE-Speech-TTS.cab"
$WINPE_SPEECH_TTS_LANG_PATH = "$WINPE_OC_PATH\WinPE-Speech-TTS-$LANG.cab"
$OS_LP_PATH                 = "$FOD_PATH\Microsoft-Windows-Client-Language-Pack_x64_$LANG.cab"

# Create folders for mounting images and storing temporary files
New-Item -ItemType directory -Path $WORKING_PATH -ErrorAction Stop | Out-Null
New-Item -ItemType directory -Path $MAIN_OS_MOUNT -ErrorAction stop | Out-Null
New-Item -ItemType directory -Path $WINRE_MOUNT -ErrorAction stop | Out-Null
New-Item -ItemType directory -Path $WINPE_MOUNT -ErrorAction stop | Out-Null

# Keep the original media, make a copy of it for the new, updated media.
Write-Output "$(Get-TS): Copying original media to new media path"
Copy-Item -Path $MEDIA_OLD_PATH"\*" -Destination $MEDIA_NEW_PATH -Force -Recurse -ErrorAction stop | Out-Null
Get-ChildItem -Path $MEDIA_NEW_PATH -Recurse | Where-Object { -not $_.PSIsContainer -and $_.IsReadOnly } | ForEach-Object { $_.IsReadOnly = $false }

Aggiornare WinRE e ogni edizione principale di Windows del sistema operativo

Lo script aggiornerà ogni edizione di Windows all'interno del file del sistema operativo principale (install.wim). Per ogni edizione viene montata l'immagine del sistema operativo principale.

Per la prima immagine, Winre.wim viene copiato nella cartella di lavoro e montato. Applica quindi lo stack di manutenzione Aggiornamento dinamico, poiché i relativi componenti vengono usati per l'aggiornamento di altri componenti. Poiché lo script aggiunge facoltativamente il giapponese, aggiunge il Language Pack all'immagine e installa le versioni giapponesi di tutti i pacchetti facoltativi già installati in Winre.wim. Applica quindi il pacchetto di aggiornamento dinamico del sistema operativo sicuro. Termina pulendo ed esportando l'immagine per ridurre le dimensioni dell'immagine.

Successivamente, per l'immagine del sistema operativo montata, lo script inizia applicando lo stack di manutenzione Aggiornamento dinamico. Aggiunge quindi il supporto della lingua giapponese e quindi le funzionalità della lingua giapponese. A differenza dei pacchetti di aggiornamento dinamico, usa Add-WindowsCapability per aggiungere queste funzionalità. Per un elenco completo di tali funzionalità e il relativo nome di funzionalità associato, vedere Funzionalità disponibili su richiesta. Ora è il momento di abilitare altri componenti facoltativi o aggiungere altre funzionalità su richiesta. Se a tale funzionalità è associato un aggiornamento cumulativo (ad esempio, .NET), questo è il momento di applicarli. Lo script procede quindi con l'applicazione dell'aggiornamento cumulativo più recente. Infine, lo script pulisce ed esporta l'immagine. È possibile installare i componenti facoltativi, insieme alla funzionalità .NET, offline, ma ciò richiede il riavvio del dispositivo. Questo è il motivo per cui lo script installa .NET e Componenti facoltativi dopo la pulizia e prima dell'esportazione.

Questo processo viene ripetuto per ogni edizione di Windows all'interno del file del sistema operativo principale. Per ridurre le dimensioni, il file Winre.wim serviced della prima immagine viene salvato e usato per aggiornare ogni edizione di Windows successiva. In questo modo si riducono le dimensioni finali di install.wim.

#
# Update each main OS Windows image including the Windows Recovery Environment (WinRE)
#

# Get the list of images contained within the main OS
$WINOS_IMAGES = Get-WindowsImage -ImagePath $MEDIA_NEW_PATH"\sources\install.wim"

Foreach ($IMAGE in $WINOS_IMAGES) {

    # first mount the main OS image
    Write-Output "$(Get-TS): Mounting main OS, image index $($IMAGE.ImageIndex)"
    Mount-WindowsImage -ImagePath $MEDIA_NEW_PATH"\sources\install.wim" -Index $IMAGE.ImageIndex -Path $MAIN_OS_MOUNT -ErrorAction stop| Out-Null

    if ($IMAGE.ImageIndex -eq "1") {

        #
        # update Windows Recovery Environment (WinRE) within this OS image
        #
        Copy-Item -Path $MAIN_OS_MOUNT"\windows\system32\recovery\winre.wim" -Destination $WORKING_PATH"\winre.wim" -Force -ErrorAction stop | Out-Null
        Write-Output "$(Get-TS): Mounting WinRE"
        Mount-WindowsImage -ImagePath $WORKING_PATH"\winre.wim" -Index 1 -Path $WINRE_MOUNT -ErrorAction stop | Out-Null

        # Add servicing stack update (Step 1 from the table)

        # Depending on the Windows release that you are updating, there are 2 different approaches for updating the servicing stack
        # The first approach is to use the combined cumulative update. This is for Windows releases that are shipping a combined 
        # cumulative update that includes the servicing stack updates (i.e. SSU + LCU are combined). Windows 11, version 21H2 and 
        # Windows 11, version 22H2 are examples. In these cases, the servicing stack update is not published seperately; the combined 
        # cumulative update should be used for this step. However, in hopefully rare cases, there may breaking change in the combined 
        # cumulative update format, that requires a standalone servicing stack update to be published, and installed first before the 
        # combined cumulative update can be installed.

        # This is the code to handle the rare case that the SSU is published and required for the combined cumulative update
        # Write-Output "$(Get-TS): Adding package $SSU_PATH"
        # Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $SSU_PATH | Out-Null

        # Now, attempt the combined cumulative update.
        # There is a known issue where the servicing stack update is installed, but the cumulative update will fail. This error should 
        # be caught and ignored, as the last step will be to apply the Safe OS update and thus the image will be left with the correct 
        # packages installed.

        
        Write-Output "$(Get-TS): Adding package $LCU_PATH to WinRE"        
        try
        {
            
            Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $LCU_PATH | Out-Null  
        }
        Catch
        {
            $theError = $_
            Write-Output "$(Get-TS): $theError"
    
            if ($theError.Exception -like "*0x8007007e*") {
                Write-Output "$(Get-TS): This failure is a known issue with combined cumulative update, we can ignore."
            }
            else {
                throw
            }
        }

        # The second approach for Step 1 is for Windows releases that have not adopted the combined cumulative update
        # but instead continue to have a seperate servicing stack update published. In this case, we'll install the SSU
        # update. This second approach is commented out below.

        # Write-Output "$(Get-TS): Adding package $SSU_PATH"
        # Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $SSU_PATH | Out-Null

        #
        # Optional: Add the language to recovery environment
        #
        # Install lp.cab cab
        Write-Output "$(Get-TS): Adding package $WINPE_OC_LP_PATH to WinRE"
        Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $WINPE_OC_LP_PATH -ErrorAction stop | Out-Null

        # Install language cabs for each optional package installed
        $WINRE_INSTALLED_OC = Get-WindowsPackage -Path $WINRE_MOUNT
        Foreach ($PACKAGE in $WINRE_INSTALLED_OC) {

            if ( ($PACKAGE.PackageState -eq "Installed") -and ($PACKAGE.PackageName.startsWith("WinPE-")) -and ($PACKAGE.ReleaseType -eq "FeaturePack") ) {

                $INDEX = $PACKAGE.PackageName.IndexOf("-Package")
                if ($INDEX -ge 0) {
                    $OC_CAB = $PACKAGE.PackageName.Substring(0, $INDEX) + "_" + $LANG + ".cab"
                    if ($WINPE_OC_LANG_CABS.Contains($OC_CAB)) {
                        $OC_CAB_PATH = Join-Path $WINPE_OC_LANG_PATH $OC_CAB
                        Write-Output "$(Get-TS): Adding package $OC_CAB_PATH to WinRE"
                        Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $OC_CAB_PATH -ErrorAction stop | Out-Null  
                    }
                }
            }
        }

        # Add font support for the new language
        if ( (Test-Path -Path $WINPE_FONT_SUPPORT_PATH) ) {
            Write-Output "$(Get-TS): Adding package $WINPE_FONT_SUPPORT_PATH to WinRE"
            Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $WINPE_FONT_SUPPORT_PATH -ErrorAction stop | Out-Null
        }

        # Add TTS support for the new language
        if (Test-Path -Path $WINPE_SPEECH_TTS_PATH) {
            if ( (Test-Path -Path $WINPE_SPEECH_TTS_LANG_PATH) ) {

                Write-Output "$(Get-TS): Adding package $WINPE_SPEECH_TTS_PATH to WinRE"
                Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $WINPE_SPEECH_TTS_PATH -ErrorAction stop | Out-Null

                Write-Output "$(Get-TS): Adding package $WINPE_SPEECH_TTS_LANG_PATH to WinRE"
                Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $WINPE_SPEECH_TTS_LANG_PATH -ErrorAction stop | Out-Null
            }
        }

        # Add Safe OS
        Write-Output "$(Get-TS): Adding package $SAFE_OS_DU_PATH to WinRE"
        Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $SAFE_OS_DU_PATH -ErrorAction stop | Out-Null

        # Perform image cleanup
        Write-Output "$(Get-TS): Performing image cleanup on WinRE"
        DISM /image:$WINRE_MOUNT /cleanup-image /StartComponentCleanup /ResetBase /Defer | Out-Null

        # Dismount
        Dismount-WindowsImage -Path $WINRE_MOUNT  -Save -ErrorAction stop | Out-Null

        # Export
        Write-Output "$(Get-TS): Exporting image to $WORKING_PATH\winre.wim"
        Export-WindowsImage -SourceImagePath $WORKING_PATH"\winre.wim" -SourceIndex 1 -DestinationImagePath $WORKING_PATH"\winre2.wim" -ErrorAction stop | Out-Null

    }
    
    Copy-Item -Path $WORKING_PATH"\winre2.wim" -Destination $MAIN_OS_MOUNT"\windows\system32\recovery\winre.wim" -Force -ErrorAction stop | Out-Null
    
    #
    # update Main OS
    #

    # Add servicing stack update (Step 18 from the table)

    # Depending on the Windows release that you are updating, there are 2 different approaches for updating the servicing stack
    # The first approach is to use the combined cumulative update. This is for Windows releases that are shipping a combined cumulative update that
    # includes the servicing stack updates (i.e. SSU + LCU are combined). Windows 11, version 21H2 and Windows 11, version 22H2 are examples. In these
    # cases, the servicing stack update is not published seperately; the combined cumulative update should be used for this step. However, in hopefully
    # rare cases, there may breaking change in the combined cumulative update format, that requires a standalone servicing stack update to be published, 
    # and installed first before the combined cumulative update can be installed.

    # This is the code to handle the rare case that the SSU is published and required for the combined cumulative update
    # Write-Output "$(Get-TS): Adding package $SSU_PATH"
    # Add-WindowsPackage -Path $MAIN_OS_MOUNT -PackagePath $SSU_PATH | Out-Null

    # Now, attempt the combined cumulative update. Unlike WinRE and WinPE, we don't need to check for error 0x8007007e
    Write-Output "$(Get-TS): Adding package $LCU_PATH to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsPackage -Path $MAIN_OS_MOUNT -PackagePath $LCU_PATH | Out-Null

    # The second approach for Step 18 is for Windows releases that have not adopted the combined cumulative update
    # but instead continue to have a seperate servicing stack update published. In this case, we'll install the SSU
    # update. This second approach is commented out below.

    # Write-Output "$(Get-TS): Adding package $SSU_PATH to main OS, index $($IMAGE.ImageIndex)"
    # Add-WindowsPackage -Path $MAIN_OS_MOUNT -PackagePath $SSU_PATH | Out-Null

    # Optional: Add language to main OS
    Write-Output "$(Get-TS): Adding package $OS_LP_PATH to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsPackage -Path $MAIN_OS_MOUNT -PackagePath $OS_LP_PATH -ErrorAction stop | Out-Null

    # Optional: Add a Features on Demand to the image
    Write-Output "$(Get-TS): Adding language FOD: Language.Fonts.Jpan~~~und-JPAN~0.0.1.0 to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "Language.Fonts.$LANG_FONT_CAPABILITY~~~und-$LANG_FONT_CAPABILITY~0.0.1.0" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

    Write-Output "$(Get-TS): Adding language FOD: Language.Basic~~~$LANG~0.0.1.0 to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "Language.Basic~~~$LANG~0.0.1.0" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

    Write-Output "$(Get-TS): Adding language FOD: Language.OCR~~~$LANG~0.0.1.0 to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "Language.OCR~~~$LANG~0.0.1.0" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

    Write-Output "$(Get-TS): Adding language FOD: Language.Handwriting~~~$LANG~0.0.1.0 to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "Language.Handwriting~~~$LANG~0.0.1.0" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

    Write-Output "$(Get-TS): Adding language FOD: Language.TextToSpeech~~~$LANG~0.0.1.0 to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "Language.TextToSpeech~~~$LANG~0.0.1.0" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

    Write-Output "$(Get-TS): Adding language FOD: Language.Speech~~~$LANG~0.0.1.0 to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "Language.Speech~~~$LANG~0.0.1.0" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

    # Note: If I wanted to enable additional Features on Demand, I'd add these here.

    # Add latest cumulative update
    Write-Output "$(Get-TS): Adding package $LCU_PATH to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsPackage -Path $MAIN_OS_MOUNT -PackagePath $LCU_PATH -ErrorAction stop | Out-Null

    # Perform image cleanup
    Write-Output "$(Get-TS): Performing image cleanup on main OS, index $($IMAGE.ImageIndex)"
    DISM /image:$MAIN_OS_MOUNT /cleanup-image /StartComponentCleanup | Out-Null

    #
    # Note: If I wanted to enable additional Optional Components, I'd add these here.
    # In addition, we'll add .NET 3.5 here as well. Both .NET and Optional Components might require
    # the image to be booted, and thus if we tried to cleanup after installation, it would fail.
    #

    Write-Output "$(Get-TS): Adding NetFX3~~~~ to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "NetFX3~~~~" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

    # Add .NET Cumulative Update
    Write-Output "$(Get-TS): Adding package $DOTNET_CU_PATH to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsPackage -Path $MAIN_OS_MOUNT -PackagePath $DOTNET_CU_PATH -ErrorAction stop | Out-Null

    # Dismount
    Dismount-WindowsImage -Path $MAIN_OS_MOUNT -Save -ErrorAction stop | Out-Null

    # Export
    Write-Output "$(Get-TS): Exporting image to $WORKING_PATH\install2.wim"
    Export-WindowsImage -SourceImagePath $MEDIA_NEW_PATH"\sources\install.wim" -SourceIndex $IMAGE.ImageIndex -DestinationImagePath $WORKING_PATH"\install2.wim" -ErrorAction stop | Out-Null

}

Move-Item -Path $WORKING_PATH"\install2.wim" -Destination $MEDIA_NEW_PATH"\sources\install.wim" -Force -ErrorAction stop | Out-Null

Aggiornare WinPE

Questo script è simile a quello che aggiorna WinRE, ma invece monta Boot.wim, applica i pacchetti con l'ultimo aggiornamento cumulativo più recente e salva. Ripete questa operazione per tutte le immagini all'interno di Boot.wim, in genere due immagini. Si inizia applicando lo stack di manutenzione Aggiornamento dinamico. Poiché lo script sta personalizzando questo supporto con il giapponese, installa il Language Pack dalla cartella WinPE nel Language Pack ISO. Aggiunge inoltre il supporto per i tipi di carattere e il supporto per la sintesi vocale .TTS.It additionally, it adds font support and text to speech (TTS). Poiché lo script aggiunge un nuovo linguaggio, ricompila lang.ini, usato per identificare le lingue installate nell'immagine. Per la seconda immagine, verranno salvati setup.exe e setuphost.exe per un uso successivo, per garantire che queste versioni corrispondano alla versione \sources\setup.exe e \sources\setuphost.exe dal supporto di installazione. Se questi file binari non sono identici, l'installazione di Windows avrà esito negativo durante l'installazione. Verranno anche salvati i file di Gestione avvio serviced per un uso successivo nello script. Infine, lo script pulisce ed esporta Boot.wim e lo copia nuovamente nel nuovo supporto.

#
# update Windows Preinstallation Environment (WinPE)
#

# Get the list of images contained within WinPE
$WINPE_IMAGES = Get-WindowsImage -ImagePath $MEDIA_NEW_PATH"\sources\boot.wim"

Foreach ($IMAGE in $WINPE_IMAGES) {

    # update WinPE
    Write-Output "$(Get-TS): Mounting WinPE, image index $($IMAGE.ImageIndex)"
    Mount-WindowsImage -ImagePath $MEDIA_NEW_PATH"\sources\boot.wim" -Index $IMAGE.ImageIndex -Path $WINPE_MOUNT -ErrorAction stop | Out-Null

    # Add servicing stack update (Step 9 from the table)

    # Depending on the Windows release that you are updating, there are 2 different approaches for updating the servicing stack
    # The first approach is to use the combined cumulative update. This is for Windows releases that are shipping a combined 
    # cumulative update that includes the servicing stack updates (i.e. SSU + LCU are combined). Windows 11, version 21H2 and 
    # Windows 11, version 22H2 are examples. In these cases, the servicing stack update is not published separately; the combined 
    # cumulative update should be used for this step. However, in hopefully rare cases, there may breaking change in the combined 
    # cumulative update format, that requires a standalone servicing stack update to be published, and installed first before the 
    # combined cumulative update can be installed.

    # This is the code to handle the rare case that the SSU is published and required for the combined cumulative update
    # Write-Output "$(Get-TS): Adding package $SSU_PATH"
    # Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $SSU_PATH | Out-Null

    # Now, attempt the combined cumulative update.
    # There is a known issue where the servicing stack update is installed, but the cumulative update will fail.
    # This error should be caught and ignored, as the last step will be to apply the cumulative update 
    # (or in this case the combined cumulative update) and thus the image will be left with the correct packages installed.

    try
    {
        Write-Output "$(Get-TS): Adding package $LCU_PATH to WinPE, image index $($IMAGE.ImageIndex)"
        Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $LCU_PATH | Out-Null  
    }
    Catch
    {
        $theError = $_
        Write-Output "$(Get-TS): $theError"

        if ($theError.Exception -like "*0x8007007e*") {
            Write-Output "$(Get-TS): This failure is a known issue with combined cumulative update, we can ignore."
        }
        else {
            throw
        }
    }

    # The second approach for Step 9 is for Windows releases that have not adopted the combined cumulative update
    # but instead continue to have a separate servicing stack update published. In this case, we'll install the SSU
    # update. This second approach is commented out below.

    # Write-Output "$(Get-TS): Adding package $SSU_PATH"
    # Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $SSU_PATH | Out-Null

    # Install lp.cab cab
    Write-Output "$(Get-TS): Adding package $WINPE_OC_LP_PATH to WinPE, image index $($IMAGE.ImageIndex)"
    Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $WINPE_OC_LP_PATH -ErrorAction stop | Out-Null

    # Install language cabs for each optional package installed
    $WINPE_INSTALLED_OC = Get-WindowsPackage -Path $WINPE_MOUNT
    Foreach ($PACKAGE in $WINPE_INSTALLED_OC) {

        if ( ($PACKAGE.PackageState -eq "Installed") -and ($PACKAGE.PackageName.startsWith("WinPE-")) -and ($PACKAGE.ReleaseType -eq "FeaturePack") ) {

            $INDEX = $PACKAGE.PackageName.IndexOf("-Package")
            if ($INDEX -ge 0) {

                $OC_CAB = $PACKAGE.PackageName.Substring(0, $INDEX) + "_" + $LANG + ".cab"
                if ($WINPE_OC_LANG_CABS.Contains($OC_CAB)) {
                    $OC_CAB_PATH = Join-Path $WINPE_OC_LANG_PATH $OC_CAB
                    Write-Output "$(Get-TS): Adding package $OC_CAB_PATH to WinPE, image index $($IMAGE.ImageIndex)"
                    Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $OC_CAB_PATH -ErrorAction stop | Out-Null  
                }
            }
        }
    }

    # Add font support for the new language
    if ( (Test-Path -Path $WINPE_FONT_SUPPORT_PATH) ) {
        Write-Output "$(Get-TS): Adding package $WINPE_FONT_SUPPORT_PATH to WinPE, image index $($IMAGE.ImageIndex)"
        Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $WINPE_FONT_SUPPORT_PATH -ErrorAction stop | Out-Null
    }

    # Add TTS support for the new language
    if (Test-Path -Path $WINPE_SPEECH_TTS_PATH) {
        if ( (Test-Path -Path $WINPE_SPEECH_TTS_LANG_PATH) ) {

            Write-Output "$(Get-TS): Adding package $WINPE_SPEECH_TTS_PATH to WinPE, image index $($IMAGE.ImageIndex)"
            Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $WINPE_SPEECH_TTS_PATH -ErrorAction stop | Out-Null

            Write-Output "$(Get-TS): Adding package $WINPE_SPEECH_TTS_LANG_PATH to WinPE, image index $($IMAGE.ImageIndex)"
            Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $WINPE_SPEECH_TTS_LANG_PATH -ErrorAction stop | Out-Null
        }
    }

    # Generates a new Lang.ini file which is used to define the language packs inside the image
    if ( (Test-Path -Path $WINPE_MOUNT"\sources\lang.ini") ) {
        Write-Output "$(Get-TS): Updating lang.ini"
        DISM /image:$WINPE_MOUNT /Gen-LangINI /distribution:$WINPE_MOUNT | Out-Null
    }

    # Add latest cumulative update
    Write-Output "$(Get-TS): Adding package $LCU_PATH to WinPE, image index $($IMAGE.ImageIndex)"
    Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $LCU_PATH -ErrorAction stop | Out-Null

    # Perform image cleanup
    Write-Output "$(Get-TS): Performing image cleanup on WinPE, image index $($IMAGE.ImageIndex)"
    DISM /image:$WINPE_MOUNT /cleanup-image /StartComponentCleanup /ResetBase /Defer | Out-Null

    if ($IMAGE.ImageIndex -eq "2") {

        # Save setup.exe for later use. This will address possible binary mismatch with the version in the main OS \sources folder
        Copy-Item -Path $WINPE_MOUNT"\sources\setup.exe" -Destination $WORKING_PATH"\setup.exe" -Force -ErrorAction stop | Out-Null
        
        # Save setuphost.exe for later use. This will address possible binary mismatch with the version in the main OS \sources folder
        # This is only required starting with Windows 11 version 24H2
        $TEMP = Get-WindowsImage -ImagePath $MEDIA_NEW_PATH"\sources\boot.wim" -Index $IMAGE.ImageIndex
        if ([System.Version]$TEMP.Version -ge [System.Version]"10.0.26100") {
            
            Copy-Item -Path $WINPE_MOUNT"\sources\setuphost.exe" -Destination $WORKING_PATH"\setuphost.exe" -Force -ErrorAction stop | Out-Null
        }
        else {

            Write-Output "$(Get-TS): Skipping copy of setuphost.exe; image version $($TEMP.Version)"
        }
        
        # Save serviced boot manager files later copy to the root media.
        Copy-Item -Path $WINPE_MOUNT"\Windows\boot\efi\bootmgfw.efi" -Destination $WORKING_PATH"\bootmgfw.efi" -Force -ErrorAction stop | Out-Null
        Copy-Item -Path $WINPE_MOUNT"\Windows\boot\efi\bootmgr.efi" -Destination $WORKING_PATH"\bootmgr.efi" -Force -ErrorAction stop | Out-Null
    
    }
        
    # Dismount
    Dismount-WindowsImage -Path $WINPE_MOUNT -Save -ErrorAction stop | Out-Null

    #Export WinPE
    Write-Output "$(Get-TS): Exporting image to $WORKING_PATH\boot2.wim"
    Export-WindowsImage -SourceImagePath $MEDIA_NEW_PATH"\sources\boot.wim" -SourceIndex $IMAGE.ImageIndex -DestinationImagePath $WORKING_PATH"\boot2.wim" -ErrorAction stop | Out-Null

}

Move-Item -Path $WORKING_PATH"\boot2.wim" -Destination $MEDIA_NEW_PATH"\sources\boot.wim" -Force -ErrorAction stop | Out-Null

Aggiornare i file multimediali rimanenti

Questa parte dello script aggiorna i file di installazione. Copia semplicemente i singoli file nel pacchetto di aggiornamento dinamico dell'installazione nel nuovo supporto. Questo passaggio include i file di installazione aggiornati in base alle esigenze, insieme al database di compatibilità più recente e ai manifesti dei componenti sostitutivi. Questo script esegue anche una sostituzione finale dei file di setup.exe, setuphost.exe e gestione di avvio usando le versioni salvate in precedenza da WinPE.

#
# update remaining files on media
#

# Add Setup DU by copy the files from the package into the newMedia
Write-Output "$(Get-TS): Adding package $SETUP_DU_PATH"
cmd.exe /c $env:SystemRoot\System32\expand.exe $SETUP_DU_PATH -F:* $MEDIA_NEW_PATH"\sources" | Out-Null

# Copy setup.exe from boot.wim, saved earlier.
Write-Output "$(Get-TS): Copying $WORKING_PATH\setup.exe to $MEDIA_NEW_PATH\sources\setup.exe"
Copy-Item -Path $WORKING_PATH"\setup.exe" -Destination $MEDIA_NEW_PATH"\sources\setup.exe" -Force -ErrorAction stop | Out-Null

# Copy setuphost.exe from boot.wim, saved earlier.
if (Test-Path -Path $WORKING_PATH"\setuphost.exe") {

    Write-Output "$(Get-TS): Copying $WORKING_PATH\setuphost.exe to $MEDIA_NEW_PATH\sources\setuphost.exe"
    Copy-Item -Path $WORKING_PATH"\setuphost.exe" -Destination $MEDIA_NEW_PATH"\sources\setuphost.exe" -Force -ErrorAction stop | Out-Null
}

# Copy bootmgr files from boot.wim, saved earlier.
$MEDIA_NEW_FILES = Get-ChildItem $MEDIA_NEW_PATH -Force -Recurse -Filter b*.efi

Foreach ($File in $MEDIA_NEW_FILES){
    if (($File.Name -ieq "bootmgfw.efi") -or ($File.Name -ieq "bootx64.efi") -or ($File.Name -ieq "bootia32.efi") -or ($File.Name -ieq "bootaa64.efi")) 
    {

        Write-Output "$(Get-TS): Copying $WORKING_PATH\bootmgfw.efi to $($File.FullName)"
        Copy-Item -Path $WORKING_PATH"\bootmgfw.efi" -Destination $File.FullName -Force -ErrorAction stop | Out-Null
    }
    elseif ($File.Name -ieq "bootmgr.efi") 
    {

        Write-Output "$(Get-TS): Copying $WORKING_PATH\bootmgr.efi to $($File.FullName)"
        Copy-Item -Path $WORKING_PATH"\bootmgr.efi" -Destination $File.FullName -Force -ErrorAction stop | Out-Null
    }
}

Fine

Come ultimo passaggio, lo script rimuove la cartella di lavoro dei file temporanei e smonta il Language Pack e le funzionalità degli ISO su richiesta.

#
# Perform final cleanup
#

# Remove our working folder
Remove-Item -Path $WORKING_PATH -Recurse -Force -ErrorAction stop | Out-Null

# Dismount ISO images
Write-Output "$(Get-TS): Dismounting ISO images"
Dismount-DiskImage -ImagePath $FOD_ISO_PATH -ErrorAction stop | Out-Null

Write-Output "$(Get-TS): Media refresh completed!"