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 11, version 22H2
Le titre peut distinguer chaque package dynamique. La pile de maintenance est incorporée pour les mises à jour cumulatives. La pile de maintenance est publiée uniquement si nécessaire pour une mise à jour cumulative donnée.
| Mettre à jour les packages | Title |
|---|---|
| Mise à jour dynamique du système d’exploitation sécurisé | Mise à jour dynamique du système d’exploitation sécurisé AAAA-MM pour Windows 11 version 22H2 |
| Configurer la mise à jour dynamique | Mise à jour dynamique de l’installation AAAA-MM pour Windows 11 version 22H2 |
| Dernière mise à jour cumulative | Mise à jour cumulative AAAA-MM pour Windows 11 version 22H2 |
| Mise à jour dynamique de la pile de maintenance | Mise à jour de la pile de maintenance AAAA-MM pour Windows 11 version 22H2 |
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.
| Mettre à jour les packages | Title | Produit | Description |
|---|---|---|---|
| Mise à jour dynamique du système d’exploitation sécurisé | Mise à jour dynamique AAAA-MM pour Windows 11 | Mise à jour dynamique du système d’exploitation sécurisé Windows | ComponentUpdate |
| Configurer la mise à jour dynamique | Mise à jour dynamique AAAA-MM pour Windows 11 | mise à jour dynamique Windows 10 et ultérieure | SetupUpdate |
| Dernière mise à jour cumulative | Mise à jour cumulative AAAA-MM pour Windows 11 | ||
| Mise à jour dynamique de la pile de maintenance | Mise à jour de la pile de maintenance AAAA-MM pour Windows 11 version 21H2 |
Pour Windows 10, packages de mise à jour dynamique 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.
| Mettre à jour les packages | Title | Produit | Description |
|---|---|---|---|
| Mise à jour dynamique du système d’exploitation sécurisé | Mise à jour dynamique AAAA-MM pour Windows 10 version 22H2 | Mise à jour dynamique du système d’exploitation sécurisé Windows | ComponentUpdate |
| Configurer la mise à jour dynamique | Mise à jour dynamique AAAA-MM pour Windows 10 version 22H2 | mise à jour dynamique Windows 10 et ultérieure | SetupUpdate |
| Dernière mise à jour cumulative | Mise à jour cumulative AAAA-MM pour Windows 10 version 22H2 | ||
| Mise à jour dynamique de la pile de maintenance | Mise à jour de la pile de maintenance AAAA-MM pour Windows 10 version 22H2 |
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 un grand nombre d’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).
| Tâche | WinRE (winre.wim) | Système d’exploitation (install.wim) | WinPE (boot.wim) | Nouveaux médias |
|---|---|---|---|---|
| Ajouter une mise à jour dynamique de la pile de maintenance | 1 | 9 | 17 | |
| Ajouter un module linguistique | 2 | 10 | 18 | |
| Ajouter des packages facultatifs localisés | 3 | 19 | ||
| Ajout de la prise en charge des polices | 4 | 20 | ||
| Ajouter de la synthèse vocale | 5 | 21 | ||
| Mettre à jour Lang.ini | 22 | |||
| Ajouter des fonctionnalités à la demande | 11 | |||
| Ajouter une mise à jour dynamique du système d’exploitation sécurisé | 6 | |||
| Ajouter la mise à jour dynamique de l’installation | 26 | |||
| Ajouter setup.exe à partir de WinPE | 27 | |||
| Ajouter un gestionnaire de démarrage à partir de WinPE | 28 | |||
| Ajouter la dernière mise à jour cumulative | 12 | 23 | ||
| Nettoyer l’image | 7 | 13 | 24 | |
| Ajouter des composants facultatifs | 14 | |||
| Ajouter des mises à jour cumulatives .NET et .NET | 15 | |||
| Exporter l’image | 8 | 16 | 25 |
Remarque
À compter de février 2021, la dernière mise à jour cumulative et la dernière mise à jour de la pile de maintenance seront combinées et distribuées dans le catalogue Microsoft Update en tant que nouvelle mise à jour cumulative combinée. Pour les étapes 1, 9 et 18 qui nécessitent la mise à jour de la pile de maintenance pour la mise à jour du support d’installation, vous devez utiliser la mise à jour cumulative combinée. Pour plus d’informations sur la mise à jour cumulative combinée, consultez Mises à jour de la pile de maintenance.
Remarque
Microsoft supprimera le composant Flash de Windows via KB4577586, « Mise à jour pour la suppression d’Adobe Flash Player ». Vous pouvez également supprimer Flash à tout moment en déployant la mise à jour dans KB4577586 (disponible dans le catalogue) entre les étapes 20 et 21. À compter de juillet 2021, KB4577586, « Mise à jour pour suppression d’Adobe Flash Player » sera incluse dans la dernière mise à jour cumulative pour Windows 10, versions 1607 et 1507. La mise à jour sera également incluse dans le correctif cumulatif mensuel et la mise à jour de sécurité uniquement pour Windows 8.1, Windows Server 2012 et Windows Embedded 8 Standard. Pour plus d’informations, consultez Mettre à jour la fin du support d’Adobe Flash Player.
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).
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 :
| Dossier | Description |
|---|---|
| C :\mediaRefresh | Dossier parent qui contient le script PowerShell |
| C :\mediaRefresh\oldMedia | Dossier qui contient le média d’origine qui sera actualisé. Par exemple, contient Setup.exe et le dossier \sources. |
| C :\mediaRefresh\newMedia | Dossier qui contiendra le média mis à jour. Il est copié à partir de \oldMedia, puis utilisé comme cible pour toutes les opérations de mise à jour et de nettoyage. |
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
$LCU_PATH = "C:\mediaRefresh\packages\LCU.msu"
$SSU_PATH = "C:\mediaRefresh\packages\SSU_DU.msu"
$SETUP_DU_PATH = "C:\mediaRefresh\packages\Setup_DU.cab"
$SAFE_OS_DU_PATH = "C:\mediaRefresh\packages\SafeOS_DU.cab"
$DOTNET_CU_PATH = "C:\mediaRefresh\packages\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 WinPE
$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.
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"
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"
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"
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"
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"
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"
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"
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"
# 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"
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"
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"
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"
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"
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"
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"
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"
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"
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~~~~"
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"
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 pour une utilisation ultérieure, afin de nous assurer que cette version correspond à la version \sources\setup.exe 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
{
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"
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"
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"
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"
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"
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"
Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $LCU_PATH -ErrorAction stop | Out-Null
# Perform image cleanup
Write-Output "$(Get-TS): Performing image cleanup on WinPE"
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 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 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 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
}
}
Terminer
À 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!"
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour