Bootfähigen USB-Stick mit PowerShell erstellen

Wie in der Kurzmitteilung Windows 7 SP1 Convenience Rollup integrieren angekündigt, werde ich im Folgenden einen bootfähigen USB-Stick mit PowerShell erstellen. Teile des Scripts habe ich von hier: New-BootableUSB. Damit funktionieren nur ISO-Dateien als Quelle. Ich habe das Script von Anfang an neu geschrieben, Windows-Installationsdateien in einem Ordner hinzugefügt und den Kopiervorgang anders gemacht.

Function New-BootableUSBDevice {

    <# .SYNOPSIS
           Zum Erstellen eines startfähigen USB-Sticks.
       .DESCRIPTION
           Diese Funktion erstellt aus einer ISO-Datei oder eines Ordners einen startfähigen USB-Stick.
       .PARAMETER
           ImagePath
           Pfad zu den Windows-Installationsdateien oder zur ISO-Datei.
       .PARAMETER
           USBDriveLetter
           Laufwerksbuchstabe des USB-Sticks.
       .PARAMETER
           FileSystemType
           Dateisystem für den USB-Stick. Standardeinstellung ist FAT32.
       .EXAMPLE
           New-BootableUSB -ImagePath "C:\Daten\SW_DVD5_WIN_ENT_10_1607_64BIT_German_MLF_X21-07112.ISO" -USBDriveLetter "D" -FileSystemType FAT32
           Erstellt von der angegebenen ISO-Datei einen mit FAT32 formatierten, bootfähigen USB-Stick.
       .NOTES
           Erstellt von Dietmar Haimann, Januar 2017
       .LINK
           https://www.einfaches-netzwerk.at/ #>

    [CmdletBinding()]

    param (
        [Parameter(Mandatory=$True)]
        [ValidateScript({ If (Test-Path $_ -Include *.iso) {$true} Else {Test-Path $_ -PathType Container} })]
        [string]$ImagePath,

        [Parameter(Mandatory=$True)]
        [ValidateLength(1,1)]
        [String]$USBDriveLetter,

        [Parameter(Mandatory=$True)]
        [ValidateSet("FAT32","NTFS")]
        [String]$FileSystemType = "FAT32"
    )

    Begin {
        $USBDriveLetter  = $USBDriveLetter.ToUpper()

        If (!((Get-Volume | Where DriveType -eq Removable | Select -ExpandProperty DriveLetter) -contains $USBDriveLetter)) {
            Write-Host ('{0} ist kein USB-Device.' -f $USBDriveLetter) -ForegroundColor Red
            Break
        }
        Else {
            Write-Host ('{0} ist ein USB-Device.' -f $USBDriveLetter) -ForegroundColor Green
        }#If

        If (!(Test-Path $ImagePath)) {
            Write-Host ('Auf {0} kann nicht zugegriffen werden.' -f $ImagePath) -ForegroundColor Red
            Break
        }
        Else {
            Write-Host ('Auf {0} kann zugegriffen werden.' -f $ImagePath) -ForegroundColor Green
        }#If

        If (Test-Path $ImagePath -Include "*.iso") {
            $IsISO = $true
            Write-Host ('{0} ist eine ISO-Datei.' -f $ImagePath) -ForegroundColor Green
        }
        Else {
            $IsISO = $false
            Write-Host ('{0} ist ein Windows-Ordner.' -f $ImagePath) -ForegroundColor Green
            If (!($ImagePath.EndsWith('\'))) {
                $Source = $ImagePath + "\*"
            }
            Else {
                $Source = $ImagePath + "*"
            }#If
        }#If

    }#Begin

    Process {
        Try {
            $Backup = $ErrorActionPreference
            $ErrorActionPreference = 'Stop'

            $Disk = Get-Disk | Where-Object BusType -EQ "USB"
            $Disk | Clear-Disk -RemoveData -Confirm:$false
            $Disk | New-Partition -UseMaximumSize -IsActive -DriveLetter $USBDriveLetter
            Format-Volume -DriveLetter $USBDriveLetter -FileSystem $FileSystemType -Confirm:$false -Force
        }#Try

        Catch {
            Write-Host "Error: $_" -ForegroundColor Red
            Write-Host "Das Script wird abgebrochen." -ForegroundColor Red
            Break
        }#Catch

        Finally {
            $ErrorActionPreference = $Backup
        }#Finally

        If ($IsISO) {
            If (!(Get-DiskImage -ImagePath $ImagePath | Get-Volume)) {
                $DiskMounted = $false
                Try {
                    $Backup = $ErrorActionPreference
                    $ErrorActionPreference = 'Stop' 

                    Mount-DiskImage -ImagePath $ImagePath
                    $DiskMounted = $true
                    Write-Host ('Das Image {0} konnte geladen werden.' -f $ImagePath) -ForegroundColor Green
                }#Try 

                Catch {
                    Write-Host "Error: $_" -ForegroundColor Red
                    Write-Host "Das Script wird abgebrochen." -ForegroundColor Red
                    Break
                }#Catch

                Finally {
                    $ErrorActionPreference = $Backup
                }#Finally
            }
            Else {
                Write-Host ('Das Image {0} ist bereits geladen.' -f $ImagePath) -ForegroundColor Green
            }#If
            $Source = ((Get-DiskImage -ImagePath $ImagePath | Get-Volume).DriveLetter) + ":\*"
        }#If

        $USBDestination = $USBDriveLetter + ":\" 

        Try {
            $Backup = $ErrorActionPreference
            $ErrorActionPreference = 'Stop' 

            Write-Host ('Dateien werden von {0} nach {1} kopiert. USB-Stick nicht vom Computer trennen!'-f $Source, $USBDestination) -ForegroundColor Yellow
            Copy-Item -Path $Source -Destination $USBDestination -Recurse -Force
            }#Try

        Catch {
            Write-Host "Error: $_" -ForegroundColor Red
            Write-Host "Das Script wird abgebrochen." -ForegroundColor Red
            Break
        }#Catch

        Finally {
            $ErrorActionPreference = $Backup
        }#Finally
    }#Process

    End {
        If($DiskMounted) {
            Dismount-DiskImage -ImagePath $ImagePath
        }#If

        Write-Host ('Erstellung des bootfähigen USB-Sticks abgeschlossen!') -ForegroundColor Green
    }#End
}#Function

Das Script unterstützt ISO-Datenträger und Windows-Installationsdateien in einem Ordner, wie es bei oben genanntem Beitrag der Fall ist.

PowerShell-Script als Modul speichern

Wer öfters Windows von einem USB-Stick starten muss, kann das Powershell-Script als Modul abspeichern und in den PowerShell-Ordner kopieren. Danach steht die Funktion sofort zur Verfügung. Wichtig ist, dass der Ordner und die Datei den gleichen Namen haben.

  1. Windows PowerShell ISE starten
  2. Das Script kopieren und in Windows PowerShell ISE einfügen
  3. File > Save As…
  4. Save As
    1. Zum Pfad C:\Program Files\WindowsPowerShell\Modules\ navigieren
    2. Dort den Ornder New-BootableUSBDevice erstellen und hinein navigieren
    3. File name: New-BootableUSBDevice
    4. Save as type: PowerShell Script Modules (*.psm1) > Save
  5. Windows PowerShell ISE schließen

Einen bootfähigen USB-Stick mit PowerShell erstellen

Als nächstes werde ich die Windows-Installationsdateien vom Beitrag Windows 7 SP1 Convenience Rollup integrieren vom USB-Stick startbar machen.

  1. PowerShell als Administator starten
  2. Mit folgendem Befehl die Funktion New-BootableUSBDevice ausführen
    New-BootableUSBDevice -ImagePath C:\W7SP1 -USBDriveLetter E -FileSystemType FAT32

  3. Der Vorgang dauert nur kurz, je nach Schreibleistung des USB-Sticks

Die manuelle Variante

Die wesentlichen Befehle lassen sich auf fünf Zeilen komprimieren, welche man schnell auswendig eintippen kann. Schritt für Schritt:

  1. USB-Stick anstecken
  2. Optional: ISO-Datei einbinden
  3. PowerShell als Administrator starten
  4. Mit folgendem Befehl die Informationen zum USB-Stick in der Variable $Disk speichern
    $Disk = Get-Disk | Where-Object BusType -EQ "USB"

  5. Mit folgendem Befehl den USB-Stick löschen
    $Disk | Clear-Disk -RemoveData -Confirm:$false
  6. Mit folgendem Befehl eine Partition erstellen
    $Disk | New-Partition -UseMaximumSize -IsActive -DriveLetter E

  7. Mit folgendem Befehl den USB-Stick formatieren
    Format-Volume -DriveLetter E -FileSystem FAT32 -Confirm:$false -Force

  8. Und zum Schluss die Dateien kopieren
    Copy-Item -Path C:\W7SP1\* -Destination E:\ -Recurse -Force

Funktioniert genauso einfach, wenn man es nicht oft braucht.

Vielen Dank für’s Lesen!

Windows 7 SP1 Convenience Rollup mit MDT installieren

Mitte Mai 2016 hat Microsoft das Windows 7 SP1 Convenience Rollup veröffentlicht. Dieses Rollup enthält alle Sicherheitsupdates und Updates bis April 2016. Ab diesem Zeitpunkt werden Updates in monatlichen Rollups, ähnlich wie bei Windows 10, verteilt (z.B.: Mai 2016 update Rollup für Windows 7 SP1 und Windows Server 2008 R2 SP1). Endlich eine gute Sache, wie ich finde. Im folgenden Artikel beschreibe ich die Installation mittels MDT. Voraussetzung sind die Kapitel 7-11 der Reihe „Ein einfaches Netzwerk“.

Vorbereitung

  1. Als Administrator an MDT01 anmelden
  2. Folgende Datei nach D:\Sourcen\Packages\Windows 7 x64 herunterladen
    1. April 2015 servicing stack update for Windows 7 (KB3020369)
  3. Folgende Datei nach D:\Sourcen\Applications\Microsoft\Microsoft Windows 7 SP1 Convenience Rollup x64 herunterladen
    1. Convenience rollup update for Windows 7 SP1 x64 (KB3125574)
  4. Folgendes AutoIt-Script erstellen und in D:\Sourcen\Applications\Microsoft\Microsoft Windows 7 SP1 Convenience Rollup x64 speichern und kompilieren
    #cs ------------------------------------------------------------
    
     AutoIt Version: 3.3.14.1
     Author:         Dietmar's Blog | Noch so ein IT-Blog
     Script Function: Install Software.
    
    #ce ------------------------------------------------------------
    
    ; Script Start - Add your code below here
    
    Opt("TrayIconHide", 1)
    
    RunWait("wusa.exe Windows6.1-KB3125574-v4-x64.msu /quiet /norestart")

Windows 7 SP1 Convenience Rollup zur Deployment Workbench hinzufügen

Hinweis: Alle vorhanden Updates für Internet Explorer 11 usw. dürfen nicht entfernt werden!

  1. Deployment Workbench starten
  2. Applications\Microsoft rechts anklicken > New Application
  3. New Application Wizard
    1. Application Type
      1. Application with source files > Next
    2. Details
      1. Publisher: Microsoft
      2. Application name: Windows 7 SP1 Convenience Rollup x64
      3. Language: Deutsch > Next
        ConvenienceRollup-001
    3. Source: D:\Sourcen\Applications\Microsoft\Microsoft Windows 7 SP1 Convenience Rollup x64 > Next
    4. Destination > Next
    5. Command Details
      1. Command line: install.exe > Next
        ConvenienceRollup-002
    6. Summary > Next
      ConvenienceRollup-003
    7. Confirmation > Finish
      ConvenienceRollup-004
  4. Packages\Windows 7 x64 rechts anklicken > Import OS Packages
  5. Import Package Wizard
    1. Specify Directory
      1. Package source Directory: D:\Sourcen\Packages\Windows 7 x64 > Next
        ConvenienceRollup-005
    2. Summary > Next
    3. Confirmation > Finish
      ConvenienceRollup-006
  6. Advanced Configuration\Selection Profiles anklicken
  7. Folgendes Selection Profile muss vorhanden sein, bei Bedarf erstellen
    1. Windows 7 x64 Updates
      ConvenienceRollup-008

Task Sequence anpassen

  1. Die Task Sequence Build and capture Windows 7 Enterprise x64 zum Bearbeiten öffnen
  2. Den Schritt Preinstall\Apply Patches anklicken
  3. Sicherstellen, dass das Selection Profile Windows 7 x64 Updates ausgewählt ist
    ConvenienceRollup-009
  4. Vor die Gruppe Standard Software die Gruppe Convenience Rollup erstellen
  5. Zur Gruppe Convenience Rollup folgende Schritte hinzufügen:
    1. Type: Install Application
      1. Name: INSTALL – Microsoft Windows 7 SP1 Convenience Rollup x64
      2. Install a single application: Microsoft Windows 7 SP1 Convenience Rollup x64
    2. Type: Restart Computer
      ConvenienceRollup-012
  6. Fenster mit OK schließen

Windows 7 Enterprise x64-Image erstellen

  1. Hyper-V-Rechner (Generation 1) mit OSDBuildPE_x64.iso starten
  2. Task Sequence auswählen
    ConvenienceRollup-010
  3. Das Image wird erstellt
    ConvenienceRollup-011

Nach der Installation des Images waren etwa 90 Windows-Updates installiert. Das ist doch eine große Anzahl weniger als vor dem Windows 7 SP1 Convenience Rollup.