Atualizar o suporte de dados de instalação do Windows com a Atualização Dinâmica

Artigo
11/06/2024
Aplica-se a:

✅ Windows 11, ✅ Windows 10, ✅ Windows Server

Este artigo explica como adquirir e aplicar pacotes de Atualização Dinâmica a imagens existentes do Windows antes da implementação e inclui scripts Windows PowerShell que pode utilizar para automatizar este processo.

Os suportes de dados licenciados em volume estão disponíveis para cada versão do Windows no Centro de Serviços de Licenciamento em Volume (VLSC) e noutros canais relevantes, como Windows Update para Empresas, Windows Server Update Services (WSUS) e Assinaturas do Visual Studio. Pode utilizar a Atualização Dinâmica para garantir que os dispositivos Windows têm os pacotes de atualização de funcionalidades mais recentes como parte de uma atualização no local, preservando o pacote de idiomas e as Funcionalidades a Pedido (FODs) que possam ter sido instaladas anteriormente. A Atualização Dinâmica também elimina a necessidade de instalar uma atualização de qualidade separada como parte do processo de atualização no local.

Atualização Dinâmica

Sempre que a instalação de uma atualização de funcionalidades é iniciada (seja a partir de um suporte de dados ou de um ambiente ligado ao Windows Update), a Atualização Dinâmica é um dos primeiros passos. A Configuração do Windows contacta um ponto final da Microsoft para obter pacotes de Atualização Dinâmica e, em seguida, aplica essas atualizações ao suporte de dados de instalação do sistema operativo. Os pacotes de atualização incluem os seguintes tipos de atualizações:

Atualizações para Setup.exe binários ou outros ficheiros que a Configuração utiliza para atualizações de funcionalidades
Atualizações para o "sistema operativo seguro" (SafeOS) utilizado para o ambiente de recuperação do Windows
Atualizações à pilha de manutenção necessária para concluir a atualização de funcionalidades Para obter mais informações, veja Atualizações da pilha de manutenção.
A atualização cumulativa mais recente (qualidade)
Atualizações a controladores aplicáveis já publicados pelos fabricantes especificamente destinados à Atualização Dinâmica

A Atualização Dinâmica preserva o pacote de idiomas e os pacotes de Funcionalidades a Pedido ao reaquissá-los.

Os dispositivos têm de conseguir ligar à Internet para obter Atualizações Dinâmicos. Em alguns ambientes, não é uma opção para obter Atualizações Dinâmicos. Ainda pode fazer uma atualização de funcionalidades baseada em multimédia ao adquirir pacotes de Atualização Dinâmica e aplicá-la à imagem antes de iniciar a Configuração no dispositivo.

Adquirir pacotes de Atualização Dinâmica

Pode obter pacotes de Atualização Dinâmica a partir do Catálogo Microsoft Update. Nesse site, utilize a barra de pesquisa no canto superior direito para localizar os pacotes de Atualização Dinâmica para uma versão específica. Os vários pacotes de Atualização Dinâmica podem não estar todos presentes nos resultados de uma única pesquisa, pelo que poderá ter de procurar com palavras-chave diferentes para encontrar todas as atualizações. Verifique várias partes dos resultados para se certificar de que identificou os ficheiros necessários. As tabelas seguintes mostram os valores de chave a procurar ou procurar nos resultados.

Windows 11, versão 22H2 e pacotes de Atualização Dinâmica posteriores

O título pode distinguir cada Pacote Dinâmico. As atualizações cumulativas mais recentes têm a pilha de manutenção incorporada. A pilha de manutenção só é publicada se for necessário para uma determinada atualização cumulativa. Os títulos abaixo destinam-se a Windows 11, versão 22H2. Windows 11, as versões 23H2 e 24H2 têm um formato semelhante.

Atualizar pacotes	Title
Atualização Dinâmica do SO Seguro	Atualização Dinâmica do SO Seguro YYYY-MM para Windows 11 Versão 22H2
Configurar Atualização Dinâmica	Atualização Dinâmica de Configuração YYYY-MM para Windows 11 Versão 22H2
Atualização cumulativa mais recente	Atualização Cumulativa YYYY-MM para Windows 11 Versão 22H2
Atualização Dinâmica da pilha de manutenção	Atualização da Pilha de Manutenção YYYY-MM para Windows 11 Versão 22H2

Windows 11, versão 21H2 Pacotes de Atualização Dinâmica

Título, Produto e Descrição são necessários para distinguir cada Pacote Dinâmico. A atualização cumulativa mais recente tem a pilha de manutenção incorporada. Pilha de manutenção publicada separadamente apenas se necessário como pré-requisito para uma determinada atualização cumulativa.

Atualizar pacotes	Title	Produto	Descrição
Atualização Dinâmica do SO Seguro	Atualização Dinâmica AAAA-MM para Windows 11	Atualização Dinâmica do SO Seguro do Windows	ComponentUpdate
Configurar Atualização Dinâmica	Atualização Dinâmica AAAA-MM para Windows 11	atualização dinâmica Windows 10 e posterior	SetupUpdate
Atualização cumulativa mais recente	Atualização Cumulativa AAAA-MM para Windows 11
Atualização Dinâmica da pilha de manutenção	Atualização da Pilha de Manutenção YYYY-MM para Windows 11 Versão 21H2

Windows 10, versão 22H2 Pacotes de Atualização Dinâmica

Atualizar pacotes	Title	Produto	Descrição
Atualização Dinâmica do SO Seguro	Atualização Dinâmica AAAA-MM para Windows 10 Versão 22H2	Atualização Dinâmica do SO Seguro do Windows	ComponentUpdate
Configurar Atualização Dinâmica	Atualização Dinâmica AAAA-MM para Windows 10 Versão 22H2	atualização dinâmica Windows 10 e posterior	SetupUpdate
Atualização cumulativa mais recente	Atualização Cumulativa YYYY-MM para Windows 10 Versão 22H2
Atualização Dinâmica da pilha de manutenção	Atualização da Pilha de Manutenção YYYY-MM para Windows 10 Versão 22H2

Se quiser personalizar a imagem com idiomas adicionais ou Funcionalidades a Pedido, transfira ficheiros ISO de multimédia suplementares a partir do Centro de Serviços de Licenciamento em Volume. Por exemplo, se a Atualização Dinâmica estiver desativada para os seus dispositivos e se os utilizadores precisarem de Funcionalidades a Pedido específicas, pode pré-instalá-las na imagem.

Atualizar o suporte de dados de instalação do Windows

A atualização correta do suporte de dados de instalação envolve muitas ações que operam em vários destinos diferentes (ficheiros de imagem). Algumas ações são repetidas em destinos diferentes. Os ficheiros de imagens de destino incluem:

Ambiente de Pré-instalação do Windows (WinPE): um pequeno sistema operativo utilizado para instalar, implementar e reparar sistemas operativos Windows
Ambiente de Recuperação do Windows (WinRE): repara causas comuns de sistemas operativos inotáveis. O WinRE baseia-se no WinPE e pode ser personalizado com controladores adicionais, idiomas, pacotes opcionais e outras ferramentas de resolução de problemas ou diagnóstico.
Sistema operativo Windows: uma ou mais edições do Windows armazenadas em \sources\install.wim
Suporte de dados de instalação do Windows: a coleção completa de ficheiros e pastas no suporte de dados de instalação do Windows. Por exemplo, \sources folder, \boot folder, Setup.exe, etc.

Esta tabela mostra a sequência correta para aplicar as várias tarefas aos ficheiros. Por exemplo, a sequência completa começa com a adição da atualização da pilha de manutenção ao WinRE (1) e termina com a adição do gestor de arranque do WinPE ao novo suporte de dados (28).

Tarefa	WinRE (winre.wim)	Sistema operativo (install.wim)	WinPE (boot.wim)	Novos suportes de dados
Adicionar Atualização Dinâmica da pilha de manutenção	1	9	17
Adicionar pacote de idiomas	2	10	18
Adicionar pacotes opcionais localizados	3		19
Adicionar suporte de tipos de letra	4		20
Adicionar conversão de texto em voz	5		21
Atualizar Lang.ini			22
Adicionar Funcionalidades a Pedido		11
Adicionar Atualização Dinâmica do SO Seguro	6
Adicionar Atualização Dinâmica de Configuração				26
Adicionar setup.exe e setuphost.exe a partir do WinPE				27
Adicionar o gestor de arranque do WinPE				28
Adicionar a atualização cumulativa mais recente		12	23
Limpar a imagem	7	13	24
Adicionar Componentes Opcionais		14
Adicionar atualizações cumulativas .NET e .NET		15
Exportar imagem	8	16	25

Observação

A partir de fevereiro de 2021, a mais recente atualização cumulativa e a atualização da pilha de manutenção serão combinadas e distribuídas no Catálogo Microsoft Update como uma nova atualização cumulativa combinada. Para os Passos 1, 9 e 18 que requerem a atualização da pilha de manutenção para atualizar o suporte de dados de instalação, deve utilizar a atualização cumulativa combinada. Para obter mais informações sobre a atualização cumulativa combinada, veja Atualizações da pilha de manutenção.

Observação

A Microsoft removerá o componente Flash do Windows através de KB4577586 "Atualização para Remoção do Adobe Flash Player". Também pode remover o Flash em qualquer altura ao implementar a atualização no KB4577586 (disponível no Catálogo) entre os passos 20 e 21. A partir de julho de 2021, KB4577586, a "Atualização para Remoção do Adobe Flash Player" será incluída na atualização cumulativa mais recente para Windows 10, versões 1607 e 1507. A atualização também será incluída no Rollup Mensal e na Atualização Apenas de Segurança para Windows 8.1, Windows Server 2012 e Windows Embedded 8 Standard. Para obter mais informações, consulte Atualizar o Fim do Suporte do Adobe Flash Player.

Várias edições do Windows

O main ficheiro do sistema operativo (install.wim) pode conter várias edições do Windows. É possível que apenas seja necessária uma atualização para uma determinada edição para a implementar, com base no índice. Em alternativa, pode ser que todas as edições precisem de uma atualização. Além disso, certifique-se de que os idiomas são instalados antes das Funcionalidades a Pedido e que a atualização cumulativa mais recente é sempre aplicada em último lugar.

Idiomas e funcionalidades adicionais

Não tem de adicionar mais idiomas e funcionalidades à imagem para realizar as atualizações, mas é uma oportunidade para personalizar a imagem com mais idiomas, Componentes Opcionais e Funcionalidades a Pedido para além do que está na sua imagem inicial. Quando adiciona mais idiomas e funcionalidades, é importante efetuar estas alterações pela ordem correta: aplique primeiro atualizações da pilha de manutenção, seguidas de adições de idioma, depois por adições de funcionalidades e, por fim, pela atualização cumulativa mais recente. O script de exemplo fornecido instala um segundo idioma (neste caso, japonês (ja-JP)). Uma vez que este idioma é apoiado por um lp.cab, não é necessário adicionar um Language Experience Pack. O japonês é adicionado ao sistema operativo main e ao ambiente de recuperação para permitir que o utilizador veja os ecrãs de recuperação em japonês. Isto inclui a adição de versões localizadas dos pacotes atualmente instalados na imagem de recuperação.

Os Componentes Opcionais, juntamente com a funcionalidade .NET, podem ser instalados offline. No entanto, fazê-lo cria operações pendentes que exigem que o dispositivo seja reiniciado. Como resultado, a chamada para efetuar a limpeza da imagem falharia. Existem duas opções para evitar a falha de limpeza. Uma opção é ignorar o passo de limpeza da imagem, embora isso resulte num install.wim maior. Outra opção é instalar os Componentes .NET e Opcionais num passo após a limpeza, mas antes da exportação. Esta é a opção no script de exemplo. Ao fazê-lo, terá de começar com o install.wim original (sem ações pendentes) quando mantiver ou atualizar a imagem da próxima vez (por exemplo, no mês seguinte).

Atualizações cumulativas do ponto de verificação

A partir de Windows 11, versão 24H2 e Windows Server 2025, a atualização cumulativa mais recente pode ter uma atualização cumulativa de pré-requisitos que tem de ser instalada primeiro. Estas são conhecidas como atualizações cumulativas de ponto de verificação. Nestes casos, os diferenciais ao nível do ficheiro de atualização cumulativa baseiam-se numa atualização cumulativa anterior em vez da versão do Windows RTM. O benefício é um pacote de atualização mais pequeno e uma instalação mais rápida. Quando obtiver a atualização cumulativa mais recente a partir do Catálogo Microsoft Update, as atualizações cumulativas do ponto de verificação estarão disponíveis no botão de transferência. Além disso, o artigo base de dados de conhecimento para a atualização cumulativa fornecerá informações adicionais.

Para instalar os pontos de verificação ao servir o SO Windows (passos 9 & 12) e WinPE (passos 17 & 23), chame Add-WindowsPackage com a atualização cumulativa de destino. A pasta de -PackagePath será utilizada para detetar e instalar um ou mais pontos de verificação, conforme necessário. Apenas a atualização cumulativa de destino e as atualizações cumulativas do ponto de verificação devem estar na -PackagePath pasta. Pacotes de atualização cumulativos com uma revisão <= a atualização cumulativa de destino será processada. Se não estiver a personalizar a imagem com idiomas adicionais e/ou funcionalidades opcionais, as chamadas separadas para Add-WindowsPackage (atualizações cumulativas do ponto de verificação) podem ser utilizadas nos passos 9 & 17 acima. Não é possível utilizar chamadas separadas para os passos 12 e 23.

Windows PowerShell scripts para aplicar a Atualizações Dinâmica a uma imagem existente

Estes exemplos são apenas para ilustração e, portanto, não têm processamento de erros. O script pressupõe que os seguintes pacotes são armazenados localmente nesta estrutura de pastas:

Pasta	Descrição
C:\mediaRefresh	Pasta principal que contém o script do PowerShell
C:\mediaRefresh\oldMedia	Pasta que contém o suporte de dados original que será atualizado. Por exemplo, contém Setup.exe e a pasta \sources.
C:\mediaRefresh\newMedia	Pasta que irá conter o suporte de dados atualizado. É copiado de \oldMedia e, em seguida, utilizado como destino para todas as operações de atualização e limpeza.

Introdução

O script começa por declarar variáveis globais e criar pastas a utilizar para montar imagens. Em seguida, faça uma cópia do suporte de dados original, de \oldMedia para \newMedia, mantendo o suporte de dados original no caso de existir um erro de script e ser necessário recomeçar a partir de um estado conhecido. Além disso, fornece uma comparação entre suportes de dados antigos e novos para avaliar as alterações. Para garantir que os novos suportes de dados são atualizados, certifique-se de que não são só de leitura.

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

Atualizar o WinRE e cada main edição windows do SO

O script atualizará cada edição do Windows no main ficheiro do sistema operativo (install.wim). Para cada edição, a imagem do SO main é montada.

Para a primeira imagem, Winre.wim é copiado para a pasta de trabalho e montado. Em seguida, aplica a atualização dinâmica da pilha de manutenção, uma vez que os respetivos componentes são utilizados para atualizar outros componentes. Uma vez que o script está opcionalmente a adicionar japonês, adiciona o pacote de idiomas à imagem e instala as versões japonesas de todos os pacotes opcionais já instalados no Winre.wim. Em seguida, aplica o pacote Atualização Dinâmica do SO Seguro. Termina ao limpar e exportar a imagem para reduzir o tamanho da imagem.

Em seguida, para a imagem montada do SO, o script começa por aplicar a Atualização Dinâmica da pilha de manutenção. Em seguida, adiciona suporte para idioma japonês e, em seguida, as funcionalidades de idioma japonês. Ao contrário dos pacotes de Atualização Dinâmica, utiliza Add-WindowsCapability para adicionar estas funcionalidades. Para obter uma lista completa dessas funcionalidades e o respetivo nome de capacidade associado, veja Funcionalidades Disponíveis a Pedido. Chegou o momento de ativar outros Componentes Opcionais ou adicionar outras Funcionalidades a Pedido. Se essa funcionalidade tiver uma atualização cumulativa associada (por exemplo, .NET), esta é a altura de as aplicar. Em seguida, o script continua com a aplicação da atualização cumulativa mais recente. Por fim, o script limpa e exporta a imagem. Pode instalar Componentes Opcionais, juntamente com a funcionalidade .NET, offline, mas isso requer que o dispositivo seja reiniciado. É por este motivo que o script instala os Componentes .NET e Opcionais após a limpeza e antes da exportação.

Este processo é repetido para cada edição do Windows no main ficheiro do sistema operativo. Para reduzir o tamanho, o ficheiro Winre.wim reparado da primeira imagem é guardado e utilizado para atualizar cada edição do Windows subsequente. Isto reduz o tamanho final 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

Atualizar WinPE

Este script é semelhante ao que atualiza o WinRE, mas em vez disso monta Boot.wim, aplica os pacotes com a última atualização cumulativa mais recente e guarda. Repete-o para todas as imagens dentro de Boot.wim, normalmente duas imagens. Começa por aplicar a pilha de manutenção Atualização Dinâmica. Uma vez que o script está a personalizar este suporte de dados com japonês, instala o pacote de idiomas a partir da pasta WinPE no iso do pacote de idiomas. Além disso, adiciona suporte de tipo de letra e suporte de texto em voz (TTS). Uma vez que o script está a adicionar uma nova linguagem, reconstrói lang.ini, utilizada para identificar idiomas instalados na imagem. Para a segunda imagem, iremos guardar setup.exe e setuphost.exe para utilização posterior, para garantir que estas versões correspondem ao \sources\setup.exe e \sources\setuphost.exe versão do suporte de dados de instalação. Se estes binários não forem idênticos, a Configuração do Windows falhará durante a instalação. Também iremos guardar os ficheiros do gestor de arranque reparados para utilização posterior no script. Por fim, o script limpa e exporta Boot.wim e copia-o novamente para o novo suporte de dados.

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

Atualizar ficheiros de multimédia restantes

Esta parte do script atualiza os ficheiros de Configuração. Simplesmente copia os ficheiros individuais no pacote Configurar Atualização Dinâmica para o novo suporte de dados. Este passo inclui os ficheiros de Configuração atualizados, conforme necessário, juntamente com a base de dados de compatibilidade mais recente e os manifestos de componentes de substituição. Este script também faz uma substituição final de ficheiros setup.exe, setuphost.exe e de gestor de arranque com as versões guardadas anteriormente do 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
    }
}

Concluir

Como último passo, o script remove a pasta de trabalho de ficheiros temporários e desmonta o nosso pacote de idiomas e ISOs de Funcionalidades a Pedido.

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

Compartilhar via