Aggiornare i supporti di installazione di Windows con Aggiornamento dinamico

Articolo
11/18/2024
Si applica a:

✅ Windows 11, ✅ Windows 10, ✅ Windows Server

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 Windows Server 2025

Aggiornare i pacchetti	Title
Aggiornamento dinamico del sistema operativo sicuro	Aggiornamento dinamico del sistema operativo sicuro AAAA-MM per il sistema operativo server Microsoft versione 24H2
Configurare l'aggiornamento dinamico	Aggiornamento dinamico configurazione AAAA-MM per il sistema operativo server Microsoft versione 24H2
Aggiornamento cumulativo più recente	Aggiornamento cumulativo AAAA-MM per il sistema operativo server Microsoft versione 24H2
Aggiornamento dinamico dello stack di manutenzione	Aggiornamento dello stack di manutenzione AAAA-MM per il sistema operativo server Microsoft versione 24H2

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.

Aggiornare i pacchetti	Title
Aggiornamento dinamico del sistema operativo sicuro	Aggiornamento dinamico del sistema operativo sicuro AAAA-MM per il sistema operativo server Microsoft versione 23H2
Configurare l'aggiornamento dinamico	Aggiornamento dinamico dell'installazione AAAA-MM per il sistema operativo server Microsoft versione 23H2
Aggiornamento cumulativo più recente	Aggiornamento cumulativo AAAA-MM per il sistema operativo server Microsoft versione 23H2
Aggiornamento dinamico dello stack di manutenzione	Aggiornamento dello stack di manutenzione AAAA-MM per il sistema operativo server Microsoft versione 23H2

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.

Aggiornare i pacchetti	Title	Prodotto	Descrizione
Aggiornamento dinamico del sistema operativo sicuro	Aggiornamento dinamico AAAA-MM per il sistema operativo server Microsoft, versione 22H2	Windows Safe OS Dynamic Update	ComponentUpdate
Configurare l'aggiornamento dinamico	Aggiornamento dinamico AAAA-MM per il sistema operativo server Microsoft, versione 22H2	aggiornamento dinamico Windows 10 e versioni successive	SetupUpdate
Aggiornamento cumulativo più recente	Aggiornamento cumulativo AAAA-MM per il sistema operativo server Microsoft, versione 22H2
Aggiornamento dinamico dello stack di manutenzione	Aggiornamento dello stack di manutenzione AAAA-MM per il sistema operativo server Microsoft, versione 22H2

pacchetti di aggiornamento dinamico successivi di Windows Server 2022

Aggiornare i pacchetti	Title	Prodotto	Descrizione
Aggiornamento dinamico del sistema operativo sicuro	Aggiornamento dinamico AAAA-MM per il sistema operativo server Microsoft, versione 21H2	Windows Safe OS Dynamic Update	ComponentUpdate
Configurare l'aggiornamento dinamico	Aggiornamento dinamico AAAA-MM per il sistema operativo server Microsoft, versione 21H2	aggiornamento dinamico Windows 10 e versioni successive	SetupUpdate
Aggiornamento cumulativo più recente	Aggiornamento cumulativo AAAA-MM per il sistema operativo server Microsoft, versione 21H2
Aggiornamento dinamico dello stack di manutenzione	Aggiornamento dello stack di manutenzione AAAA-MM per il sistema operativo server Microsoft, versione 21H2

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 versione 24H2 hanno un formato simile:

Aggiornare i pacchetti	Title
Aggiornamento dinamico del sistema operativo sicuro	Aggiornamento dinamico del sistema operativo sicuro AAAA-MM per Windows 11 versione 22H2
Configurare l'aggiornamento dinamico	Aggiornamento dinamico configurazione AAAA-MM per Windows 11 versione 22H2
Aggiornamento cumulativo più recente	Aggiornamento cumulativo AAAA-MM per Windows 11 versione 22H2
Aggiornamento dinamico dello stack di manutenzione	Aggiornamento dello stack di manutenzione AAAA-MM per Windows 11 versione 22H2

pacchetti di aggiornamento dinamico di Windows 11 versione 21H2

Aggiornare i pacchetti	Title	Prodotto	Descrizione
Aggiornamento dinamico del sistema operativo sicuro	Aggiornamento dinamico AAAA-MM per Windows 11	Windows Safe OS Dynamic Update	ComponentUpdate
Configurare l'aggiornamento dinamico	Aggiornamento dinamico AAAA-MM per Windows 11	aggiornamento dinamico Windows 10 e versioni successive	SetupUpdate
Aggiornamento cumulativo più recente	Aggiornamento cumulativo AAAA-MM per Windows 11
Aggiornamento dinamico dello stack di manutenzione	Aggiornamento dello stack di manutenzione AAAA-MM per Windows 11 versione 21H2

pacchetti di aggiornamento dinamico di Windows 10 versione 22H2

Aggiornare i pacchetti	Title	Prodotto	Descrizione
Aggiornamento dinamico del sistema operativo sicuro	Aggiornamento dinamico AAAA-MM per Windows 10 versione 22H2	Windows Safe OS Dynamic Update	ComponentUpdate
Configurare l'aggiornamento dinamico	Aggiornamento dinamico AAAA-MM per Windows 10 versione 22H2	aggiornamento dinamico Windows 10 e versioni successive	SetupUpdate
Aggiornamento cumulativo più recente	Aggiornamento cumulativo AAAA-MM per Windows 10 versione 22H2
Aggiornamento dinamico dello stack di manutenzione	Aggiornamento dello stack di manutenzione AAAA-MM per Windows 10 versione 22H2

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).

Attività	WinRE (winre.wim)	Sistema operativo (install.wim)	WinPE (boot.wim)	Nuovi supporti
Aggiungere l'aggiornamento dello stack di manutenzione tramite l'aggiornamento cumulativo più recente	1	9	17
Aggiungere language pack	2	10	18
Aggiungere pacchetti facoltativi localizzati	3		19
Aggiungere il supporto per i tipi di carattere	4		20
Aggiungere sintesi vocale	5		21
Aggiornare Lang.ini			22
Aggiungere funzionalità su richiesta		11
Aggiungere componenti facoltativi		12
Aggiungere l'aggiornamento dinamico del sistema operativo sicuro	6
Aggiungere l'aggiornamento dinamico dell'installazione				26
Aggiungere Setup.exe e setuphost.exe da WinPE				27
Aggiungere gestione avvio da WinPE				28
Aggiungere l'aggiornamento cumulativo più recente		13	23
Pulire l'immagine	7	14	24
Aggiungere aggiornamenti cumulativi di .NET e .NET		15
Esportare l'immagine	8	16	25

Nota

A partire da febbraio 2021, l'aggiornamento cumulativo più recente e l'aggiornamento dello stack di manutenzione vengono combinati e distribuiti in Microsoft Update Catalog come nuovo aggiornamento cumulativo combinato. Per i passaggi 1, 9 e 17 che richiedono l'aggiornamento dello stack di manutenzione per l'aggiornamento del supporto di installazione, è consigliabile usare l'aggiornamento cumulativo combinato. Per altre informazioni sull'aggiornamento cumulativo combinato, vedere Aggiornamenti dello stack di manutenzione.

Nota

Microsoft rimuove il componente Flash da Windows tramite KB4577586: Aggiornamento per la rimozione di Adobe Flash Player. È anche possibile rimuovere Flash in qualsiasi momento distribuendo l'aggiornamento in KB4577586 (disponibile nel catalogo) tra i passaggi 20 e 21. A partire da luglio 2021, KB4577586, "Aggiornamento per la rimozione di Adobe Flash Player" sarà incluso nell'aggiornamento cumulativo più recente per Windows 10, versioni 1607 e 1507. L'aggiornamento sarà incluso anche nell'aggiornamento cumulativo mensile e nell'aggiornamento solo sicurezza per Windows 8.1, Windows Server 2012 e Windows Embedded 8 Standard. Per altre informazioni, vedere Aggiornamento sulla fine del supporto di Adobe Flash Player.

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. In questo modo, tuttavia, 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 aggiornamenti 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 sono disponibili dal pulsante di download. Inoltre, l'articolo knowledge base per l'aggiornamento cumulativo fornisce 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 viene 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 viene 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:

Cartella	Descrizione
C:\mediaRefresh	Cartella padre che contiene lo script di PowerShell
C:\mediaRefresh\oldMedia	Cartella che contiene il supporto originale che verrà aggiornato. Ad esempio, contiene Setup.exe e la cartella \sources.
C:\mediaRefresh\newMedia	Cartella che conterrà il supporto aggiornato. Viene copiato da \oldMedia, quindi usato come destinazione per tutte le operazioni di aggiornamento e pulizia.

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. Lo script include anche l'aggiunta di linguaggi aggiuntivi, Funzionalità su richiesta e Componenti facoltativi. Questi non sono obbligatori, ma aggiunti per evidenziare quando devono essere aggiunti nella sequenza. A partire da Windows 11 versione 21H2, l'ISO del Language Pack (LANGPACK) viene sostituito dall'ISO Funzionalità su richiesta. I Language Pack e i pacchetti \Windows Preinstallation Environment fanno parte dell'ISO Funzionalità su richiesta. Inoltre, il percorso per la lingua principale del sistema operativo e le funzionalità facoltative è stato spostato in \LanguagesAndOptionalFeatures anziché nella radice. Se si usa questo script per Windows 10, modificare per montare e usare il Language Pack (LANGPACK) ISO.

#Requires -RunAsAdministrator

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

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

# 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"
$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 media for FOD and LPs
$FOD_ISO_PATH    = "C:\mediaRefresh\packages\CLIENT_LOF_PACKAGES_OEM.iso"

# Array of Features On Demand for main OS
# This is optional to showcase where these are added
$FOD = @(
'XPS.Viewer~~~~0.0.1.0'
)

# Array of Legacy Features for main OS
# This is optional to showcase where these are added
$OC = @(
'MediaPlayback'
'WindowsMediaPlayer'
)

# 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
$FOD_PATH = $FOD_ISO_DRIVE_LETTER + ":\LanguagesAndOptionalFeatures"

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

# 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"

# Declare folders for mounted images and temp files
$MEDIA_OLD_PATH  = "C:\mediaRefresh\oldMedia\Ge\client_professional_en-us"
$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"

# 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 aggiorna 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 tramite l'aggiornamento cumulativo più recente, poiché i relativi componenti vengono usati per l'aggiornamento di altri componenti. A seconda della versione di Windows che si sta aggiornando, esistono due approcci diversi per l'aggiornamento dello stack di manutenzione. Il primo approccio consiste nell'usare l'aggiornamento cumulativo combinato. Questo vale per le versioni di Windows che spediscono un aggiornamento cumulativo combinato che include gli aggiornamenti dello stack di manutenzione (ovvero, vengono combinati SSU + LCU). Windows 11, versione 21H2 e Windows 11 versione 22H2 sono esempi. In questi casi, l'aggiornamento dello stack di manutenzione non viene pubblicato separatamente. L'aggiornamento cumulativo combinato deve essere usato per questo passaggio. Tuttavia, in rari casi, potrebbe essere presente una modifica di rilievo nella modifica combinata del formato dell'aggiornamento cumulativo, che richiede la pubblicazione di un aggiornamento autonomo dello stack di manutenzione e l'installazione prima dell'installazione dell'aggiornamento cumulativo combinato. 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 tramite l'aggiornamento cumulativo più recente. 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 tenta quindi di pulire l'immagine, quindi un passaggio finale per applicare l'aggiornamento cumulativo più recente. È importante applicare l'ultimo aggiornamento cumulativo più recente per garantire che le funzionalità su richiesta, i componenti facoltativi e le lingue vengano aggiornati dallo stato di rilascio iniziale. La funzionalità .NET è un'eccezione aggiunta insieme al successivo aggiornamento cumulativo. Infine, lo script esporta l'immagine.

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)
        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-Warning "$(Get-TS): Failed with error 0x8007007e. This failure is a known issue with combined cumulative update, we can ignore."
            }
            else 
            {
                throw
            }
        }

        #
        # 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
        if ($LastExitCode -ne 0) 
        {
            throw "Error: Failed to perform image cleanup on WinRE. Exit code: $LastExitCode"
        }

        # 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 17 from the table). 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


    # Optional: Add language to main OS and corresponding language experience Features on Demand
    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

    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

    # Optional: Add additional Features On Demand
	For ( $index = 0; $index -lt $FOD.count; $index++)#
	{
        Write-Output "$(Get-TS): Adding $($FOD[$index]) to main OS, index $($IMAGE.ImageIndex)"
        Add-WindowsCapability -Name $($FOD[$index]) -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null
	}    
    
    # Optional: Add Legacy Features
    For ( $index = 0; $index -lt $OC.count; $index++)
    {
        Write-Output "$(Get-TS): Adding $($OC[$index]) to main OS, index $($IMAGE.ImageIndex)"
        DISM /Image:$MAIN_OS_MOUNT /Enable-Feature /FeatureName:$($OC[$index]) /All | Out-Null
        if ($LastExitCode -ne 0) 
        {
            throw "Error: Failed to add $($OC[$index]) to main OS, index $($IMAGE.ImageIndex). Exit code: $LastExitCode"
        }
    }

    # 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. Some Optional Components might require the image to be booted, and thus 
    # image cleanup may fail. We'll catch and handle as a warning.
    Write-Output "$(Get-TS): Performing image cleanup on main OS, index $($IMAGE.ImageIndex)"
    DISM /image:$MAIN_OS_MOUNT /cleanup-image /StartComponentCleanup | Out-Null
    if ($LastExitCode -ne 0) 
    {
        if ($LastExitCode -eq -2146498554)  
        {       
            # We hit 0x800F0806 CBS_E_PENDING. We will ignore this with a warning
            # This is likely due to legacy components being added that require online operations.
            Write-Warning "$(Get-TS): Failed to perform image cleanup on main OS, index $($IMAGE.ImageIndex). Exit code: $LastExitCode. The operation cannot be performed until pending servicing operations are completed. The image must be booted to complete the pending servicing operation."
        }
        else
        {
            throw "Error: Failed to perform image cleanup on main OS, index $($IMAGE.ImageIndex). Exit code: $LastExitCode"
        }
    }

    # Finally, we'll add .NET 3.5 and the .NET cumulative update
    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, si salvano 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)
    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-Warning "$(Get-TS): Failed with error 0x8007007e. This failure is a known issue with combined cumulative update, we can ignore."
        }
        else 
        {
            throw
        }
    }

    # 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
        if ($LastExitCode -ne 0) 
        {
            throw "Error: Failed to update lang.ini. Exit code: $LastExitCode"
        }
    }

    # 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 ($LastExitCode -ne 0) 
    {
        throw "Error: Failed to perform image cleanup on WinPE, image index $($IMAGE.ImageIndex). Exit code: $LastExitCode"
    }

    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 gestione di setup.exe, setuphost.exe e 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
if ($LastExitCode -ne 0) 
{
    throw "Error: Failed to expand $SETUP_DU_PATH. Exit code: $LastExitCode"
}

# 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!"

Condividi tramite