Atualize a mídia de instalação do Windows com o Dynamic Update

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

A mídia licenciada por volume está disponível para cada versão do Windows no Centro de Serviços de Licenciamento por Volume (VLSC) e em outros canais relevantes, como políticas de cliente do Windows Update, Windows Server Update Services (WSUS) e Assinaturas do Visual Studio. Você pode usar a Atualização Dinâmica para garantir que os dispositivos Windows tenham os pacotes de atualização de recursos mais recentes como parte de uma atualização in-loco, preservando o pacote de idiomas e os FODs (Recursos sob Demanda) que possam ter sido instalados 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 in-loco.

Atualização Dinâmica

Sempre que a instalação de uma atualização de recurso é iniciada (seja por meio da mídia ou de um ambiente conectado ao Windows Update), a Atualização Dinâmica é uma das primeiras etapas. A Instalação do Windows contata um ponto de extremidade da Microsoft para buscar pacotes de Atualização Dinâmica e aplica essas atualizações à mídia de instalação do sistema operacional. Os pacotes de atualização incluem os seguintes tipos de atualizações:

• Atualizações para Setup.exe binários ou outros arquivos que a Instalação usa para atualizações de recursos
• Atualizações para o "sistema operacional seguro" (SafeOS) usado para o ambiente de recuperação do Windows
• Atualizações na pilha de manutenção necessárias para concluir a atualização de recursos Para obter mais informações, consulte Atualizações da pilha de manutenção.
• A atualização cumulativa (qualidade) mais recente
• Atualizações para os drivers aplicáveis já publicadas pelos fabricantes especificamente destinados à Atualização Dinâmica

A Atualização Dinâmica preserva o pacote de idiomas e os pacotes de Recursos sob Demanda readquirindo-os.

Os dispositivos devem ser capazes de se conectar à Internet para obter Atualizações Dinâmicas. Em alguns ambientes, não é uma opção obter Atualizações Dinâmicas. Você ainda pode fazer uma atualização de recursos baseada em mídia adquirindo pacotes de Atualização Dinâmica e aplicando-os à imagem antes de iniciar a Instalação no dispositivo.

Adquirir pacotes de Atualização Dinâmica

Você pode obter pacotes de Atualização Dinâmica no Catálogo do Microsoft Update. Nesse site, use a barra de pesquisa no canto superior direito para encontrar os pacotes de Atualização Dinâmica de 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, portanto, você pode ter que pesquisar com palavras-chave diferentes para encontrar todas as atualizações. Verifique várias partes dos resultados para ter certeza de que identificou os arquivos necessários. As tabelas a seguir mostram os valores de chave a serem pesquisados ou procurados nos resultados.

Pacotes de Atualização Dinâmica do Windows Server 2025

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 será publicada somente se necessário para uma determinada atualização cumulativa.

Pacotes de Atualização Dinâmica do Windows Server, versão 23H2

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 será publicada somente se necessário para uma determinada atualização cumulativa. O Azure Stack HCI, versão 23H2, tem um formato semelhante.

Pacotes de Atualização Dinâmica do Azure Stack HCI, versão 22H2

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

Pacotes de Atualização Dinâmica do Windows Server 2022 posterior

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

Pacotes de Atualização Dinâmica do Windows 11, versão 22H2 e 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 será publicada somente se necessário para uma determinada atualização cumulativa. Os títulos a seguir são para o Windows 11, versão 22H2. O Windows 11, versão 23H2 e 24H2 têm um formato semelhante:

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

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

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

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

Se você quiser personalizar a imagem com idiomas ou recursos sob demanda adicionais, baixe arquivos ISO de mídia suplementar do Centro de Serviços de Licenciamento por Volume. Por exemplo, se a Atualização Dinâmica for desabilitada para seus dispositivos e se os usuários precisarem de recursos específicos sob demanda, você poderá pré-instalá-los na imagem.

Atualizar a mídia de instalação do Windows

A atualização adequada da mídia de instalação envolve muitas ações que operam em vários destinos diferentes (arquivos de imagem). Algumas ações são repetidas em alvos diferentes. Os arquivos de imagens de destino incluem:

• Ambiente de Pré-Instalação do Windows (WinPE): um pequeno sistema operacional usado para instalar, implantar e reparar sistemas operacionais Windows
• Ambiente de Recuperação do Windows (WinRE): repara causas comuns de sistemas operacionais não inicializáveis. O WinRE é baseado no WinPE e pode ser personalizado com drivers adicionais, idiomas, pacotes opcionais e outras ferramentas de solução de problemas ou diagnóstico.
• Sistema operacional Windows: uma ou mais edições do Windows armazenadas em \sources\install.wim
• Mídia de instalação do Windows: a coleção completa de arquivos e pastas na mídia de instalação do Windows. Por exemplo, pasta \sources, pasta \boot, Setup.exe e assim por diante.

Esta tabela mostra a sequência correta para aplicar as várias tarefas aos arquivos. Por exemplo, a sequência completa começa com a adição da atualização da pilha de manutenção ao WinRE (1) e conclui com a adição do gerenciador de inicialização do WinPE à nova mídia (28). Resolva todas as falhas da tarefa antes de prosseguir para a próxima tarefa, a menos que indicado de outra forma. Não distribua imagens de destino associadas a tarefas com falha.

Várias edições do Windows

O arquivo principal do sistema operacional (install.wim) pode conter várias edições do Windows. É possível que apenas uma atualização para uma determinada edição seja necessária para implantá-la, com base no índice. Ou pode ser que todas as edições precisem de uma atualização. Além disso, verifique se os idiomas são instalados antes dos Recursos sob Demanda e se a atualização cumulativa mais recente é sempre aplicada por último.

Idiomas e recursos adicionais

Você não precisa adicionar mais idiomas e recursos à imagem para realizar as atualizações, mas é uma oportunidade de personalizar a imagem com mais idiomas, componentes opcionais e recursos sob demanda além do que está na sua imagem inicial. Ao adicionar mais idiomas e recursos, é importante fazer essas alterações na ordem correta: primeiro, aplique as atualizações da pilha de manutenção, seguidas pelas adições de idiomas, depois pelas adições de recursos e, por fim, pela atualização cumulativa mais recente. O script de exemplo fornecido instala um segundo idioma (nesse caso, japonês (ja-JP)). Como esse idioma tem o suporte de um lp.cab, não é necessário adicionar um Pacote de Experiência de Idioma. O japonês é adicionado ao sistema operacional principal e ao ambiente de recuperação para permitir que o usuário veja as telas de recuperação em japonês. Isso inclui a adição de versões localizadas dos pacotes atualmente instalados na imagem de recuperação.

Os componentes opcionais, juntamente com o recurso .NET, podem ser instalados offline. No entanto, isso cria operações pendentes que exigem que o dispositivo seja reiniciado. Como resultado, a chamada para executar a limpeza de imagem falharia. Há duas opções para evitar a falha de limpeza. Uma opção é ignorar a etapa de limpeza de imagem, embora isso resulte em um install.wim maior. Outra opção é instalar o .NET e os componentes opcionais em uma etapa após a limpeza, mas antes da exportação. Essa é a opção no script de exemplo. Ao fazer isso, você terá que começar com o install.wim original (sem ações pendentes) ao manter ou atualizar a imagem na próxima vez (por exemplo, no próximo mês).

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

A partir do Windows 11, versão 24H2, e do Windows Server 2025, a atualização cumulativa mais recente pode ter uma atualização cumulativa de pré-requisito que precisa ser instalada primeiro. Essas atualizações são conhecidas como atualizações cumulativas de ponto de verificação. Nesses casos, os diferenciais de nível de arquivo de atualização cumulativa são baseados em uma atualização cumulativa anterior em vez da versão Windows RTM. O benefício é um pacote de atualização menor e uma instalação mais rápida. Quando você obtém a atualização cumulativa mais recente do Catálogo do Microsoft Update, as atualizações cumulativas de ponto de verificação estão disponíveis no botão de download. Além disso, o artigo da base de dados de conhecimento para a atualização cumulativa fornece informações adicionais.

Para instalar os pontos de verificação ao fazer a manutenção do sistema operacional Windows (etapas 9 & 12) e do WinPE (etapas 17 & 23), ligue Add-WindowsPackage com a atualização cumulativa de destino. A pasta de é usada para descobrir e instalar um ou mais pontos de -PackagePath verificação, conforme necessário. Somente a atualização cumulativa de destino e as atualizações cumulativas de ponto de verificação devem estar na -PackagePath pasta. Pacotes de atualização cumulativa com uma revisão <= a atualização cumulativa de destino são processados. Se você não estiver personalizando a imagem com idiomas adicionais e/ou recursos opcionais, chamadas separadas para Add-WindowsPackage (atualizações cumulativas de ponto de verificação primeiro) poderão ser usadas para as etapas 9 & 17 acima. Chamadas separadas não podem ser usadas para as etapas 12 e 23.

Dependendo da revisão da imagem que você está atendendo, bem como de sua tarefa específica de custimização de imagem, você pode ou não precisar de um ou de todos os pontos de verificação anteriores. Vejamos três exemplos:

Exemplo 1: Adicionar um idioma ou recurso: Se você estiver adicionando um idioma ou recurso a uma imagem existente, a atualização cumulativa de destino e todos os pontos de verificação anteriores devem ser instalados. Isso é necessário, pois os idiomas e os recursos são publicados apenas uma vez quando um novo sistema operacional Windows foi lançado para fabricação (RTM) e, portanto, exigem todas as alterações de manutenção desde o RTM para evitar o estado interrompido.

Exemplo 2: atualizando uma imagem no ponto de verificação mais recente: Se você não estiver adicionando um idioma ou recurso e sua imagem existente estiver no ponto de verificação mais recente, somente a atualização cumulativa de destino será necessária para se tornar atual.

Exemplo 3: atualizar uma imagem que não está no ponto de verificação mais recente: Se você não estiver adicionando um idioma ou recurso e sua imagem existente não estiver no ponto de verificação mais recente, um ou mais pontos de verificação anteriores serão necessários, juntamente com a atualização cumulativa de destino, para se tornar atual.

Para obter mais informações, consulte Atualizações cumulativas do ponto de verificação e uso do Catálogo do Microsoft Update.

Scripts do Windows PowerShell para aplicar Atualizações Dinâmicas a uma imagem existente

Esses exemplos são apenas para fins ilustrativos e, portanto, não têm tratamento de erros. O script pressupõe que os seguintes pacotes estejam armazenados localmente nesta estrutura de pastas:

Introdução

O script começa declarando variáveis globais e criando pastas a serem usadas para montar imagens. Em seguida, faça uma cópia da mídia original, de \oldMedia para \newMedia, mantendo a mídia original caso haja um erro de script e seja necessário recomeçar a partir de um estado conhecido. Além disso, ele fornece uma comparação entre mídias antigas e novas para avaliar as alterações. Para garantir que as novas mídias sejam atualizadas, verifique se elas não são somente leitura. O script também mostra a adição de idiomas adicionais, Recursos sob Demanda e Componentes Opcionais. Eles não são obrigatórios, mas adicionados para realçar quando na sequência eles devem ser adicionados. A partir do Windows 11, versão 21H2, o ISO do pacote de idiomas (LANGPACK) é substituído pelo ISO Recursos sob Demanda. Pacotes de idiomas e os pacotes \Ambiente de Pré-instalação do Windows fazem parte do ISO Recursos sob Demanda. Além disso, o caminho para o idioma principal do sistema operacional e recursos opcionais foi movido para \LanguagesAndOptionalFeatures em vez da raiz. Se você estiver usando este script para o Windows 10, modifique para montar e usar o ISO do pacote de idiomas (LANGPACK).

#Requires -RunAsAdministrator

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

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

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

# Declare media for FOD and LPs
$FOD_ISO_PATH    = "C:\mediaRefresh\packages\CLIENT_LOF_PACKAGES_OEM.iso"

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

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

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

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

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

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

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

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

Atualize o WinRE e cada edição do Windows do sistema operacional principal

O script atualiza cada edição do Windows no arquivo principal do sistema operacional (install.wim). Para cada edição, a imagem principal do sistema operacional é montada.

Para a primeira imagem, Winre.wim é copiado para a pasta de trabalho e montado. Em seguida, ele aplica a pilha de manutenção por meio da atualização cumulativa mais recente, uma vez que seus componentes são usados para atualizar outros componentes. Dependendo da versão do Windows que você está atualizando, há duas abordagens diferentes para atualizar a pilha de manutenção. A primeira abordagem é usar a atualização cumulativa combinada. Isso é para versões do Windows que estão enviando uma atualização cumulativa combinada que inclui as atualizações da pilha de manutenção (ou seja, SSU + LCU são combinadas). Windows 11, versão 21H2 e Windows 11, versão 22H2 são exemplos. Nesses casos, a atualização da pilha de manutenção não é publicada separadamente; A atualização cumulativa combinada deve ser usada para esta etapa. No entanto, em casos raros, pode haver uma alteração significativa na alteração de formato da atualização cumulativa combinada, que exige que uma atualização de pilha de manutenção autônoma seja publicada e instalada primeiro antes que a atualização cumulativa combinada possa ser instalada. Como o script adiciona opcionalmente o japonês, ele adiciona o pacote de idiomas à imagem e instala as versões em japonês de todos os pacotes opcionais já instalados no Winre.wim. Em seguida, ele aplica o pacote de Atualização Dinâmica do Sistema Operacional Seguro. Ele termina limpando e exportando a imagem para reduzir o tamanho da imagem.

Em seguida, para a imagem do sistema operacional montado, o script começa aplicando a pilha de manutenção por meio da atualização cumulativa mais recente. Em seguida, ele adiciona suporte ao idioma japonês e, em seguida, os recursos do idioma japonês. Ao contrário dos pacotes de Atualização Dinâmica, ele é usado Add-WindowsCapability para adicionar esses recursos. Para obter uma lista completa desses recursos e o nome do recurso associado, consulte Recursos Disponíveis sob Demanda. Agora é a hora de habilitar outros componentes opcionais ou adicionar outros recursos sob demanda. Se esse recurso tiver uma atualização cumulativa associada (por exemplo, .NET), este será o momento de aplicá-la. Em seguida, o script tenta limpar a imagem e, em seguida, uma etapa final para aplicar a atualização cumulativa mais recente. É importante aplicar a última atualização cumulativa por último, para garantir que os Recursos sob Demanda, os Componentes Opcionais e os Idiomas sejam atualizados a partir do estado de versão inicial. O recurso .NET é uma exceção que é adicionada junto com sua atualização cumulativa em seguida. Por fim, o script exporta a imagem.

Esse processo é repetido para cada edição do Windows dentro do arquivo principal do sistema operacional. Para reduzir o tamanho, o arquivo Winre.wim atendido da primeira imagem é salvo e usado para atualizar cada edição subsequente do Windows. Isso 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)
        Write-Output "$(Get-TS): Adding package $LCU_PATH to WinRE"
        try
        {
            Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $LCU_PATH | Out-Null
        }
        Catch
        {
            $theError = $_
            Write-Output "$(Get-TS): $theError"

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

        #
        # Optional: Add the language to recovery environment
        #

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

        # Install language cabs for each optional package installed
        $WINRE_INSTALLED_OC = Get-WindowsPackage -Path $WINRE_MOUNT
        Foreach ($PACKAGE in $WINRE_INSTALLED_OC)
        {
            if ( ($PACKAGE.PackageState -eq "Installed") -and ($PACKAGE.PackageName.startsWith("WinPE-")) -and ($PACKAGE.ReleaseType -eq "FeaturePack") )
            {
                $INDEX = $PACKAGE.PackageName.IndexOf("-Package")
                if ($INDEX -ge 0)
                {
                    $OC_CAB = $PACKAGE.PackageName.Substring(0, $INDEX) + "_" + $LANG + ".cab"
                    if ($WINPE_OC_LANG_CABS.Contains($OC_CAB))
                    {
                        $OC_CAB_PATH = Join-Path $WINPE_OC_LANG_PATH $OC_CAB
                        Write-Output "$(Get-TS): Adding package $OC_CAB_PATH to WinRE"
                        Add-WindowsPackage -Path $WINRE_MOUNT -PackagePath $OC_CAB_PATH -ErrorAction stop | Out-Null
                    }
                }
            }
        }

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

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

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

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

        # Perform image cleanup
        Write-Output "$(Get-TS): Performing image cleanup on WinRE"
        DISM /image:$WINRE_MOUNT /cleanup-image /StartComponentCleanup /ResetBase /Defer | Out-Null
        if ($LastExitCode -ne 0)
        {
            throw "Error: Failed to perform image cleanup on WinRE. Exit code: $LastExitCode"
        }

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

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

    }

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

    #
    # update Main OS
    #

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


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

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

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

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

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

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

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

    # Optional: Add additional Features On Demand
	For ( $index = 0; $index -lt $FOD.count; $index++)#
	{
        Write-Output "$(Get-TS): Adding $($FOD[$index]) to main OS, index $($IMAGE.ImageIndex)"
        Add-WindowsCapability -Name $($FOD[$index]) -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null
	}

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

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

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

    # Finally, we'll add .NET 3.5 and the .NET cumulative update
    Write-Output "$(Get-TS): Adding NetFX3~~~~ to main OS, index $($IMAGE.ImageIndex)"
    Add-WindowsCapability -Name "NetFX3~~~~" -Path $MAIN_OS_MOUNT -Source $FOD_PATH -ErrorAction stop | Out-Null

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

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

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

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

Atualizar WinPE

Este script é semelhante ao que atualiza o WinRE, mas em vez disso ele monta o Boot.wim, aplica os pacotes com a última atualização cumulativa por último e salva. Ele repete isso para todas as imagens dentro de Boot.wim, normalmente duas imagens. Ele começa aplicando a Atualização Dinâmica da pilha de manutenção. Como o script está personalizando essa mídia com japonês, ele instala o pacote de idiomas da pasta WinPE no ISO do pacote de idiomas. Além disso, adiciona suporte a fontes e suporte a texto para fala (TTS). Como o script está adicionando um novo idioma, ele recria lang.ini, usado para identificar os idiomas instalados na imagem. Para a segunda imagem, salvamos setup.exe e setuphost.exe para uso posterior, para garantir que essas versões correspondam ao \sources\setup.exe e \sources\setuphost.exe versão da mídia de instalação. Se esses binários não forem idênticos, a Instalação do Windows falhará durante a instalação. Também salvaremos os arquivos do gerenciador de inicialização atendidos para uso posterior no script. Por fim, o script limpa e exporta o Boot.wim e o copia de volta para a nova 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)
    try
    {
        Write-Output "$(Get-TS): Adding package $LCU_PATH to WinPE, image index $($IMAGE.ImageIndex)"
        Add-WindowsPackage -Path $WINPE_MOUNT -PackagePath $LCU_PATH | Out-Null
    }
    Catch
    {
        $theError = $_
        Write-Output "$(Get-TS): $theError"
        if ($theError.Exception -like "*0x8007007e*")
        {
            Write-Warning "$(Get-TS): Failed with error 0x8007007e. This failure is a known issue with combined cumulative update, we can ignore."
        }
        else
        {
            throw
        }
    }

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

    # Install language cabs for each optional package installed
    $WINPE_INSTALLED_OC = Get-WindowsPackage -Path $WINPE_MOUNT
    Foreach ($PACKAGE in $WINPE_INSTALLED_OC)
    {
        if ( ($PACKAGE.PackageState -eq "Installed") -and ($PACKAGE.PackageName.startsWith("WinPE-")) -and ($PACKAGE.ReleaseType -eq "FeaturePack") )
        {
            $INDEX = $PACKAGE.PackageName.IndexOf("-Package")
            if ($INDEX -ge 0)
            {
                $OC_CAB = $PACKAGE.PackageName.Substring(0, $INDEX) + "_" + $LANG + ".cab"
                if ($WINPE_OC_LANG_CABS.Contains($OC_CAB))
                {
                    $OC_CAB_PATH = Join-Path $WINPE_OC_LANG_PATH $OC_CAB

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

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

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

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

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

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

    # Perform image cleanup
    Write-Output "$(Get-TS): Performing image cleanup on WinPE, image index $($IMAGE.ImageIndex)"
    DISM /image:$WINPE_MOUNT /cleanup-image /StartComponentCleanup /ResetBase /Defer | Out-Null
    if ($LastExitCode -ne 0)
    {
        throw "Error: Failed to perform image cleanup on WinPE, image index $($IMAGE.ImageIndex). Exit code: $LastExitCode"
    }

    if ($IMAGE.ImageIndex -eq "2")
    {
        # Save setup.exe for later use. This will address possible binary mismatch with the version in the main OS \sources folder
        Copy-Item -Path $WINPE_MOUNT"\sources\setup.exe" -Destination $WORKING_PATH"\setup.exe" -Force -ErrorAction stop | Out-Null

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

        # Save serviced boot manager files later copy to the new 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
        Copy-Item -Path $WINPE_MOUNT"\Windows\boot\efi\boot.stl" -Destination $WORKING_PATH"\boot.stl" -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 arquivos de mídia restantes

Essa parte do script atualiza os arquivos de Instalação. Ele simplesmente copia os arquivos individuais no pacote de Atualização Dinâmica de Configuração para a nova mídia. Esta etapa traz os arquivos de instalação atualizados conforme necessário, juntamente com o banco de dados de compatibilidade mais recente e os manifestos de componentes de substituição. Esse script também faz uma substituição final dos arquivos do setup.exe, do setuphost.exe e do gerenciador de inicialização usando as versões salvas 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
if ($LastExitCode -ne 0)
{
    throw "Error: Failed to expand $SETUP_DU_PATH. Exit code: $LastExitCode"
}

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

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

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

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


# Copy boot.stl from boot.wim, saved earlier, even if it doesnt exist in the new media.
if (Test-Path -Path $WORKING_PATH"\boot.stl")
{
    Write-Output "$(Get-TS): Copying $WORKING_PATH\boot.stl to $MEDIA_NEW_PATH\efi\microsoft\boot\boot.stl"
    Copy-Item -Path $WORKING_PATH"\boot.stl" -Destination $MEDIA_NEW_PATH"\efi\microsoft\boot\boot.stl" -Force -ErrorAction stop | Out-Null
}

Concluir

Como última etapa, o script remove a pasta de trabalho de arquivos temporários e desmonta nosso pacote de idiomas e ISOs de Recursos sob Demanda.

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