Mettre à jour le support d’installation Windows avec la mise à jour dynamique

Cet article explique comment acquérir et appliquer des packages de mise à jour dynamique à des images Windows existantes avant le déploiement, et inclut Windows PowerShell scripts que vous pouvez utiliser pour automatiser ce processus.

Les supports sous licence en volume sont disponibles pour chaque version de Windows dans le Centre de gestion des licences en volume (VLSC) et d’autres canaux pertinents tels que Windows Update entreprise, Windows Server Update Services (WSUS) et Abonnements Visual Studio. Vous pouvez utiliser la mise à jour dynamique pour vous assurer que les appareils Windows disposent des derniers packages de mise à jour des fonctionnalités dans le cadre d’une mise à niveau sur place tout en préservant les modules linguistiques et les fonctionnalités à la demande (FOD) qui ont peut-être été installés précédemment. La mise à jour dynamique élimine également la nécessité d’installer une mise à jour qualité distincte dans le cadre du processus de mise à niveau sur place.

Mise à jour dynamique

Chaque fois que l’installation d’une mise à jour de fonctionnalité démarre (à partir d’un support ou d’un environnement connecté à Windows Update), la mise à jour dynamique est l’une des premières étapes. Le programme d’installation de Windows contacte un point de terminaison Microsoft pour récupérer les packages de mise à jour dynamique, puis applique ces mises à jour au support d’installation de votre système d’exploitation. Les packages de mise à jour incluent les types de mises à jour suivants :

• Mises à jour à Setup.exe des fichiers binaires ou d’autres fichiers utilisés par le programme d’installation pour les mises à jour des fonctionnalités
• Mises à jour pour le « système d’exploitation sécurisé » (SafeOS) utilisé pour l’environnement de récupération Windows
• Mises à jour à la pile de maintenance nécessaire pour terminer la mise à jour des fonctionnalités Pour plus d’informations, consultez Mises à jour de la pile de maintenance.
• Dernière mise à jour cumulative (qualité)
• Mises à jour aux pilotes applicables déjà publiés par les fabricants spécifiquement destinés à la mise à jour dynamique

La mise à jour dynamique conserve les modules linguistiques et les packages de fonctionnalités à la demande en les réacquistant.

Les appareils doivent être en mesure de se connecter à Internet pour obtenir des Mises à jour dynamiques. Dans certains environnements, il n’est pas possible d’obtenir des Mises à jour dynamiques. Vous pouvez toujours effectuer une mise à jour des fonctionnalités basées sur le média en acquérant des packages de mise à jour dynamique et en l’appliquant à l’image avant de démarrer le programme d’installation sur l’appareil.

Acquérir des packages de mise à jour dynamique

Vous pouvez obtenir des packages de mise à jour dynamique à partir du catalogue Microsoft Update. Sur ce site, utilisez la barre de recherche en haut à droite pour rechercher les packages de mise à jour dynamique pour une version particulière. Les différents packages de mise à jour dynamique peuvent ne pas tous être présents dans les résultats d’une seule recherche, vous devrez peut-être effectuer une recherche avec des mots clés différents pour rechercher toutes les mises à jour. Vérifiez les différentes parties des résultats pour vous assurer que vous avez identifié les fichiers nécessaires. Les tableaux suivants indiquent les valeurs clés à rechercher ou à rechercher dans les résultats.

Packages de mise à jour dynamique Windows Server 2025

Le titre peut distinguer chaque package dynamique. La pile de maintenance est incorporée aux dernières mises à jour cumulatives. La pile de maintenance est publiée uniquement si nécessaire pour une mise à jour cumulative donnée.

Windows Server, version 23H2 Packages de mise à jour dynamique

Le titre peut distinguer chaque package dynamique. La pile de maintenance est incorporée aux dernières mises à jour cumulatives. La pile de maintenance est publiée uniquement si nécessaire pour une mise à jour cumulative donnée. Azure Stack HCI, version 23H2 a un format similaire.

Packages de mise à jour dynamique Azure Stack HCI, version 22H2

Le titre, le produit et la description sont requis pour distinguer chaque package dynamique. La pile de maintenance est incorporée à la dernière mise à jour cumulative. Pile de maintenance publiée séparément uniquement si nécessaire comme prérequis pour une mise à jour cumulative donnée.

Packages de mise à jour dynamique windows Server 2022 ultérieurs

Le titre, le produit et la description sont requis pour distinguer chaque package dynamique. La pile de maintenance est incorporée à la dernière mise à jour cumulative. Pile de maintenance publiée séparément uniquement si nécessaire comme prérequis pour une mise à jour cumulative donnée.

packages de mise à jour dynamique Windows 11, version 22H2 et ultérieures

Le titre peut distinguer chaque package dynamique. La pile de maintenance est incorporée aux dernières mises à jour cumulatives. La pile de maintenance est publiée uniquement si nécessaire pour une mise à jour cumulative donnée. Les titres ci-dessous concernent Windows 11, version 22H2. Windows 11, les versions 23H2 et 24H2 ont un format similaire.

packages de mise à jour dynamique Windows 11, version 21H2

Le titre, le produit et la description sont requis pour distinguer chaque package dynamique. La pile de maintenance est incorporée à la dernière mise à jour cumulative. Pile de maintenance publiée séparément uniquement si nécessaire comme prérequis pour une mise à jour cumulative donnée.

packages de mise à jour dynamique Windows 10, version 22H2

Le titre, le produit et la description sont requis pour distinguer chaque package dynamique. La pile de maintenance est incorporée à la dernière mise à jour cumulative. Pile de maintenance publiée séparément uniquement si nécessaire comme prérequis pour une mise à jour cumulative donnée.

Si vous souhaitez personnaliser l’image avec d’autres langues ou fonctionnalités à la demande, téléchargez des fichiers ISO multimédias supplémentaires à partir du Centre de gestion des licences en volume. Par exemple, si la mise à jour dynamique est désactivée pour vos appareils et si les utilisateurs ont besoin de fonctionnalités spécifiques à la demande, vous pouvez les préinstaller dans l’image.

Mettre à jour le support d’installation de Windows

La mise à jour correcte du support d’installation implique de nombreuses actions fonctionnant sur plusieurs cibles différentes (fichiers image). Certaines actions sont répétées sur différentes cibles. Les fichiers d’images cibles sont les suivants :

• Environnement de préinstallation Windows (WinPE) : petit système d’exploitation utilisé pour installer, déployer et réparer les systèmes d’exploitation Windows
• Windows Recovery Environment (WinRE) : répare les causes courantes des systèmes d’exploitation non démarrables. WinRE est basé sur WinPE et peut être personnalisé avec des pilotes supplémentaires, des langages, des packages facultatifs et d’autres outils de dépannage ou de diagnostic.
• Système d’exploitation Windows : une ou plusieurs éditions de Windows stockées dans \sources\install.wim
• Support d’installation Windows : collection complète de fichiers et de dossiers dans le support d’installation De Windows. Par exemple, le dossier \sources, le dossier \boot, Setup.exe, etc.

Ce tableau montre la séquence correcte pour appliquer les différentes tâches aux fichiers. Par exemple, la séquence complète commence par l’ajout de la mise à jour de la pile de maintenance à WinRE (1) et se termine par l’ajout du gestionnaire de démarrage de WinPE au nouveau média (28).

Plusieurs éditions de Windows

Le fichier de système d’exploitation main (install.wim) peut contenir plusieurs éditions de Windows. Il est possible que seule une mise à jour pour une édition donnée soit nécessaire pour la déployer, en fonction de l’index. Ou bien, il se peut que toutes les éditions nécessitent une mise à jour. En outre, vérifiez que les langues sont installées avant les fonctionnalités à la demande, et que la dernière mise à jour cumulative est toujours appliquée en dernier.

Langages et fonctionnalités supplémentaires

Vous n’avez pas besoin d’ajouter d’autres langues et fonctionnalités à l’image pour effectuer les mises à jour, mais c’est une occasion de personnaliser l’image avec davantage de langues, de composants facultatifs et de fonctionnalités à la demande au-delà de ce qui se trouve dans votre image de départ. Lorsque vous ajoutez d’autres langages et fonctionnalités, il est important d’apporter ces modifications dans le bon ordre : appliquez d’abord les mises à jour de la pile de maintenance, puis les ajouts de langues, puis les ajouts de fonctionnalités et enfin la dernière mise à jour cumulative. L’exemple de script fourni installe une deuxième langue (dans ce cas, le japonais (ja-JP)). Étant donné que cette langue est soutenue par un lp.cab, il n’est pas nécessaire d’ajouter un pack d’expérience linguistique. Le japonais est ajouté à la fois au système d’exploitation main et à l’environnement de récupération pour permettre à l’utilisateur de voir les écrans de récupération en japonais. Cela inclut l’ajout de versions localisées des packages actuellement installés dans l’image de récupération.

Les composants facultatifs, ainsi que la fonctionnalité .NET, peuvent être installés hors connexion, mais cela crée des opérations en attente qui nécessitent le redémarrage de l’appareil. Par conséquent, l’appel à effectuer le nettoyage de l’image échoue. Il existe deux options pour éviter l’échec du nettoyage. L’une des options consiste à ignorer l’étape de nettoyage de l’image, mais cela entraîne un fichier install.wim plus volumineux. Une autre option consiste à installer les composants .NET et facultatifs dans une étape après le nettoyage, mais avant l’exportation. Il s’agit de l’option dans l’exemple de script. En procédant ainsi, vous devrez commencer avec le fichier install.wim d’origine (sans aucune action en attente) lorsque vous conservez ou mettez à jour l’image la prochaine fois (par exemple, le mois suivant).

Mises à jour cumulatives des points de contrôle

À compter de Windows 11, version 24H2 et Windows Server 2025, la dernière mise à jour cumulative peut avoir une mise à jour cumulative requise pour être installée en premier. Ces mises à jour sont appelées mises à jour cumulatives de point de contrôle. Dans ces cas, les différentiels de niveau de fichier de mise à jour cumulative sont basés sur une mise à jour cumulative précédente plutôt que sur la version windows RTM. L’avantage est un package de mise à jour plus petit et une installation plus rapide. Lorsque vous obtenez la dernière mise à jour cumulative à partir du catalogue Microsoft Update, les mises à jour cumulatives de point de contrôle sont disponibles à partir du bouton de téléchargement. En outre, l’article base de connaissances pour la mise à jour cumulative fournit des informations supplémentaires.

Pour installer le ou les points de contrôle lors de la maintenance du système d’exploitation Windows (étapes 9 & 12) et WinPE (étapes 17 & 23), appelez Add-WindowsPackage avec la mise à jour cumulative cible. Le dossier de -PackagePath sera utilisé pour découvrir et installer un ou plusieurs points de contrôle en fonction des besoins. Seules les mises à jour cumulatives cibles et les mises à jour cumulatives de point de contrôle doivent se trouver dans le -PackagePath dossier . Packages de mise à jour cumulative avec une révision <= la mise à jour cumulative cible sera traitée. Si vous ne personnalisez pas l’image avec des langues supplémentaires et/ou des fonctionnalités facultatives, des appels distincts à Add-WindowsPackage (mises à jour cumulatives de point de contrôle) peuvent être utilisés pour les étapes 9 & 17 ci-dessus. Les appels distincts ne peuvent pas être utilisés pour les étapes 12 et 23.

Windows PowerShell scripts pour appliquer des Mises à jour dynamiques à une image existante

Ces exemples sont fournis à titre d’illustration uniquement et ne gèrent donc pas les erreurs. Le script suppose que les packages suivants sont stockés localement dans cette structure de dossiers :

Prise en main

Le script commence par déclarer des variables globales et créer des dossiers à utiliser pour le montage d’images. Ensuite, effectuez une copie du média d’origine, de \oldMedia à \newMedia, en conservant le média d’origine en cas d’erreur de script et qu’il soit nécessaire de recommencer à partir d’un état connu. En outre, il fournit une comparaison de l’ancien et du nouveau média pour évaluer les changements. Pour vous assurer que les nouveaux médias sont mis à jour, assurez-vous qu’ils ne sont pas en lecture seule.

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

Mettre à jour WinRE et chaque édition main système d’exploitation Windows

Le script met à jour chaque édition de Windows dans le fichier de système d’exploitation main (install.wim). Pour chaque édition, l’image de système d’exploitation main est montée.

Pour la première image, Winre.wim est copié dans le dossier de travail et monté. Il applique ensuite la mise à jour dynamique de la pile de maintenance, car ses composants sont utilisés pour mettre à jour d’autres composants. Étant donné que le script ajoute éventuellement le japonais, il ajoute le module linguistique à l’image et installe les versions japonaises de tous les packages facultatifs déjà installés dans Winre.wim. Ensuite, il applique le package de mise à jour dynamique du système d’exploitation sécurisé. Il se termine par le nettoyage et l’exportation de l’image pour réduire la taille de l’image.

Ensuite, pour l’image du système d’exploitation monté, le script commence par appliquer la mise à jour dynamique de la pile de maintenance. Ensuite, il ajoute la prise en charge de la langue japonaise, puis les fonctionnalités de langue japonaise. Contrairement aux packages de mise à jour dynamique, il utilise Add-WindowsCapability pour ajouter ces fonctionnalités. Pour obtenir la liste complète de ces fonctionnalités et leur nom de fonctionnalité associée, consultez Fonctionnalités disponibles à la demande. Le moment est venu d’activer d’autres composants facultatifs ou d’ajouter d’autres fonctionnalités à la demande. Si une telle fonctionnalité est associée à une mise à jour cumulative (par exemple, .NET), il est temps de les appliquer. Le script procède ensuite à l’application de la dernière mise à jour cumulative. Enfin, le script nettoie et exporte l’image. Vous pouvez installer des composants facultatifs, ainsi que la fonctionnalité .NET, hors connexion, mais cela nécessite le redémarrage de l’appareil. C’est pourquoi le script installe les composants .NET et facultatifs après le nettoyage et avant l’exportation.

Ce processus est répété pour chaque édition de Windows dans le fichier de système d’exploitation main. Pour réduire la taille, le fichier Winre.wim de la première image est enregistré et utilisé pour mettre à jour chaque édition windows suivante. Cela réduit la taille finale de 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

Mettre à jour WinPE

Ce script est similaire à celui qui met à jour WinRE, mais au lieu de cela, il monte Boot.wim, applique les packages avec la dernière mise à jour cumulative en dernier et enregistre. Il le répète pour toutes les images à l’intérieur de Boot.wim, généralement deux images. Il commence par appliquer la mise à jour dynamique de la pile de maintenance. Étant donné que le script personnalise ce média avec le japonais, il installe le module linguistique à partir du dossier WinPE sur l’ISO du module linguistique. En outre, il ajoute la prise en charge des polices et la prise en charge de la synthèse vocale (TTS). Étant donné que le script ajoute un nouveau langage, il reconstruit lang.ini, utilisé pour identifier les langues installées dans l’image. Pour la deuxième image, nous allons enregistrer setup.exe et setuphost.exe pour une utilisation ultérieure, afin de nous assurer que ces versions correspondent à la version \sources\setup.exe et \sources\setuphost.exe à partir du support d’installation. Si ces fichiers binaires ne sont pas identiques, le programme d’installation de Windows échoue lors de l’installation. Nous allons également enregistrer les fichiers du gestionnaire de démarrage service pour une utilisation ultérieure dans le script. Enfin, le script nettoie et exporte Boot.wim, puis le copie sur le nouveau média.

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

Mettre à jour les fichiers multimédias restants

Cette partie du script met à jour les fichiers d’installation. Il copie simplement les fichiers individuels du package De mise à jour dynamique d’installation sur le nouveau support. Cette étape intègre les fichiers d’installation mis à jour en fonction des besoins, ainsi que la base de données de compatibilité la plus récente et les manifestes des composants de remplacement. Ce script effectue également un remplacement final des fichiers setup.exe, setuphost.exe et du gestionnaire de démarrage à l’aide des versions précédemment enregistrées à partir de 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
    }
}

Finir

À la dernière étape, le script supprime le dossier de travail des fichiers temporaires et démonte notre module linguistique et nos isos de fonctionnalités à la demande.

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