Ich installiere immer mal Windows: bei Freunden, Testsysteme, meine produktiven
System neu machen usw. So oft, damit sich dass komplett lohnt was ich hier
beschreibe ist es auch nicht. Aber ich bin nun mal Fan von solchen Dingen.
Ab Windows 7 kann man alle Versionen in ein Setup verpacken, auch 32 bit und 64
bit Versionen kann man mischen, was jedoch schon etwas anspruchsvoller
ist.
Es gibt viele "Kochanleitungen" dafür, ich habe mir eine Art Framework mit
Powershell dafür gebaut und mache es ausschließlich mit Bordmitteln. Das
Powershell Script läuft nicht automatisch, ich arbeite immer nur entsprechende
Zeilen ab, setze mal Kommentare und modifiziere bei Bedarf.
Wenn man sich alles in eine Script schreibt und dieses mit dem Standard ps1
benennt, sollte man unbedingt diese erste Zeile einfügen:
Die einfachste Art sich einen Windows Setup Stick zu bauen funktioniert nur für
eine Windows Version. Dazu braucht man
Wir stecken den Stick in eine freie USB Schnittstelle und starten eine cmd shell
als Administrator: z.B. mit Windows + x und dann Eingabeaufforderung
(Administrator) und legen los:
Nun ist der Stick für immer vorbereitet, diesen Vorgang brauchen wir nur
einmalig zu machen. Der Stick ist bewusst im FAT32 Format formatiert, da EFI
(das moderne BIOS) nur von diesem Dateisystem booten kann. Der einmal so
vorbereitete Stick kann jederzeit mit einem neuen Windows als Setup Stick
ausgestattet werden. Dazu wird einfach der komplette Inhalt der DVD (ISO) auf
diesen Stick kopiert, mit dem Explorer, xcopy oder was auch immer. Die
Wurzelverzeichnisse der Laufwerke müssen anschließen identisch aussehen,, also
keine Unterverzeichnisse anlegen oder einfach die ISO Datei kopieren! Wer nur
schnell einen Setup Stick braucht ist jetzt fertig. Wer alle Windows Versionen
auf einen Stick haben will muss noch ein bisschen weiter machen.
Hinweis: Mittlerweile (2024) ist die Datei install.wim viel zu groß für FAT Dateisysteme, man muss diese in mehrere swm Dateien zerteilen. Weiter unten ist gezeigt wie das mit Powershell oder dism funktioniert.
Die Basisarbeit
Wir brauchen etwas an "Umgebung", performanten Speicherplatz, Tools usw. Ich
arbeite alles in einer Powershell ab und habe dafür jeweils ein paar Zeilen
Script vorbereitet. Diese passe ich dann gegebenenfalls einfach an.
Ich habe kein perfektes Script, was alles alleine tut.
Ich warne davor den hier vorgestellten Code einfach auszuführen ohne, dass
man verstanden hat was passiert!
Die Powershell starten wir am Besten in der ISE Version (Entwicklungsumgebung)
im Administrator Kontext (also ausführen als...)
Zunächst ein paar Definitionen und Pfade erzeugen:
########### Basis Arbeit - unbedingt ausführen
########### Erzeuge Struktur zur Image Erstellung
$WorkDir = "D:\WindowsSetupDir" # Arbeitsverzeichniss, Laufwerk spielt für Performance eine Rolle
$Source = "E:" # Hier liegt die Quell DVD des aktuell zu bearbeitenden Windows
$USBStick = "F:\" # Laufwerk für den Ziel USB Stick
# Die Pfade werden als Basis gesetzt und können für Performance auch verändert werden
$DistDir = "$WorkDir\" + "distribution"
$bootDir = "$WorkDir\mount" + "\" + "boot"
$windowsDir = "$WorkDir\mount" + "\" + "windows"
# Erzeuge Pfadstruktur falls nicht vorhanden
if( -not (Test-Path $WorkDir) ) { New-Item $WorkDir -type directory }
if( -not (Test-Path $DistDir) ) { New-Item $DistDir -type directory }
if( -not (Test-Path $bootDir) ) { New-Item $bootDir -type directory }
if( -not (Test-Path $windowsDir) ) { New-Item $windowsDir -type directory }
Als Basisversion für unseren Setupstick verwenden wir immer die neueste Windows
Version die wir einsetzen wollen, falls Serverversionen eine Rolle spielen, die
neueste Serverversion. Diese DVD kommt ins Laufwerk (E: in meinem Beispiel) und
das Arbeitsverzeichnis wird vorbereitet.
########### Basis DVD kopieren
#Prüfe ob Setup DVD im Laufwerk
if( -not (Test-Path $Source\) )
{Write-Host Setup DVD nicht vorhanden. Prüfe ob eine DVD in Laufwerk $Source eingelegt
Exit 1
}
# Kopiere den Inhalt der Basis DVD ins Arbeitsverzeichnis falls es leer ist
if( (Get-ChildItem $DistDir | Measure-Object).Count -eq 0)
{
xcopy $Source\ $DistDir /s/e
}
##########
Klar geht das auch einfacher, aber so gibt es ein bisschen Komfort. In meinem
konkreten Beispiel habe ich Windows 10 Version 1511 vom November 2015 verwendet.
Da muss man jetzt noch einen Zwischenschritt einlegen: Die Datei
e:\sources\install.esd muss umgewandelt werden.
Falls eine andere Version vorliegt:
Prüfen ob die Datei e:\sources\install.wim existiert - wenn ja kann der nächste
Schritt übersprungen werden.
Windows 10 MediaCreationTool
Von Windows 10 werden keine ISO Images mehr zum download angeboten, vielmehr
kann man sich mit dem
MediaCreationTool herunterladen "was man braucht". Ich bevorzuge dabei immer ein ISO Image, das
ist universell einsetzbar. Je nach Zeitpunkt des download ändert Microsoft schon
mal den Inhalt der dabei heruntergeladen wird. Die für uns wichtigste Datei ist
die install.wim. Neben der Endung und Form "
WIM" kann die Datei auch install.esd heißen (aktuell bei der Version 1511 ist das
der Fall). ESD ist eine speziell gepackte Version des WIM Formates und kann
nicht so direkt weiter verarbeitet werden. Wir müssen diese Datei erst
konvertieren. Ich bin ein Freund von Boardmitteln, dass geht zwar etwas
umständlich, aber ich habe alles in ein paar Zeilen Script für Powershell
gepackt.
Was passiert?
- Wir erzeugen ein temporäres virtuelles Laufwerk,
- Das Image install.esd wird darin ausgepackt
-
Das Image install.wim wird aus dem virtuellen Laufwerk wieder erzeugt.
Alle Vorgänge für Windows Images (WIM) müssen immer pro enthaltener Windows
Version durchgeführt werden.
In der Datei install.esd sind zwei Versionen enthalten. Dies können wir mit
dism anzeigen lassen:
dism /Get-WimInfo /WimFile:$DistDir\sources\install.esd
Das cmdlet von Powershell kann dafür leider nicht verwendet werden, es kann
offenbar mit esd Dateien derzeit nicht umgehen, von unsere fertigen wim Datei
können wir uns das aber jederzeit anzeigen lassen:
Get-WindowsImage -ImagePath $DistDir\sources\install.wim
Dieser Vorgang braucht jetzt etwas Zeit.
########## Windows 10 Image vorbeiten - aus esd wim Datei machen
#
# VHD kann später einfach formatiert werden, ist besser als Pfad da Rechte auf Trusted Installer gesetzt werden
# VHD auf anderes physisches Laufwerk legen als $DistDir
$VHDFile = "c:\temp.vhd"
$VHDDrive = "V:"
NEW-ITEM -Path bootemup.txt -ItemType file -force | OUT-NULL
ADD-CONTENT -Path bootemup.txt -Value “create vdisk file=$VHDFile maximum=25000 type=expandable”
ADD-CONTENT -Path bootemup.txt -Value “select vdisk file=$VHDFile”
ADD-CONTENT -Path bootemup.txt -Value “attach vdisk”
ADD-CONTENT -Path bootemup.txt -Value “create partition primary”
ADD-CONTENT -Path bootemup.txt -Value “assign letter=$VHDDrive”
ADD-CONTENT -Path bootemup.txt -Value “format quick label=vhd”
DISKPART /S .\bootemup.txt
# VHD erzeugt kann später ausgeworfen und gelöscht werden
dism /apply-image /imagefile:$DistDir\sources\install.esd /index:1 /applydir:$VHDDrive\
dism /capture-image /imagefile:$DistDir\sources\install.wim /capturedir:$VHDDrive\ /Compress:max /Name:"Windows 10 Pro" /Description:"Windows 10 Pro" # Die Description darf nicht fehlen!
format $VHDDrive /Q /y
dism /apply-image /imagefile:$DistDir\sources\install.esd /index:2 /applydir:$VHDDrive\
dism /capture-image /imagefile:$DistDir\sources\install2.wim /capturedir:$VHDDrive\ /Compress:max /Name:"Windows 10" /Description:"Windows 10"
# Jetzt beide Images wieder vereinigen
Export-WindowsImage -SourceImagePath $DistDir\sources\install2.wim -SourceIndex 1 -DestinationImagePath $distDir\sources\install.wim # -DestinationName "Windows 10"
# esd Datei und temporäre wim Datei löschen
del $DistDir\sources\install.esd
del $DistDir\sources\install2.wim
Das erzeugte virtuelle Laufwerk können wir später auswerfen und die VHD Datei
löschen. Die erzeugte install.wim von Windows 10 sollte man sich für weitere
Experimente eventuell separat sichern, da die Erzeugung doch einiges an Zeit
beansprucht.
Mehrere Windows Versionen
Da Microsoft seit Windows 7 beim Setup vereinfacht gesagt nur noch von einem
Image (boot.wim) bootet um dann anschließen ein anderes Image (install.wim) auf
den Datenträger zu kopieren, ist dieser Vorgang relativ Versionsunabhängig. Das
WIM (Windows Image) Format ist zudem noch Platzsparend, da es identische Dateien
nur einmal speichert. Somit belegen z.B. Windows 8.1 in 2 Varianten sowie Server
2012 R2 in 4 Varianten in einer install.wim kaum mehr Speicherplatz als ein
einzelne Version, da der Code ja weitestgehend identisch ist.
Mehrere Windows Versionen in eine install.wim packen ist simpel und schnell
gemacht. (wenn man nur eine Sprache (DE) und nur eine Prozessorarchitektur (64
bit) verwendet)
Genau wie bei der Vorbereitung von Windows 10 beschrieben, wird einfach pro
Version (nicht pro Installationsmedium) ein "Export" des Windows Images in die
Basis install.wim durchgeführt.
Es ist jetzt eine Kombination aus Handarbeit und Scriptzeilen ausführen:
- DVD auswerfen
- Neue Windows DVD einlegen (wieder Laufwerk E:)
- Anzeigen lassen welche Versionen vorhanden sind
- Die Versionen exportieren die man haben möchte
######## Weitere Images exportieren
# Neue DVD in Laufwerk $Source
Get-WindowsImage -ImagePath $Source\sources\install.wim
# Abfrage Index Nummer
$a = read-host "Welches Windows Image exportieren? -a- für Abruch"
If ($a -eq "a") {Exit 1}
Export-WindowsImage -SourceImagePath $Source\sources\install.wim -SourceIndex $a -DestinationImagePath $distDir\sources\install.wim
Damit wir alle Versionen bei der Installation auswählen können ohne einen
Windows Setup Key eingeben zu müssen, brauchen wir die Datei ei.cfg im Setup
Verzeichnis. Diese wird wieder einfach mit einem kurzen Script erzeugt:
########## Windows ohne Seriennummer installieren
# Windows 10 fragt nach dem Key und diese Frage könnte man überspringen
# mit ei.cfg kommt die Frage nach dem Key nicht
"[EditionID]
[Channel]
Retail
[VL]
0"| out-file -filepath "$DistDir\sources\ei.cfg"
USB Stick
Für einen USB Setup Stick könnten wir jetzt wieder einfach alle Dateien aus dem
$DistDir auf den Stick kopieren. Aber die install.wim Datei ist je nach Anzahl
der integrierten Windows Versionen jetzt größer als 4 GB - die magische Grenze
für FAT32. Wir müssen die install.wim also in handliche Teile splitten und es
ensteht eine Gruppe aus install.swm + install<n>.swm Dateien.
Leider ist die Exclude Funktion und die
Fehlerbehandlung von Copy-Item etwas grottig und ich habe es nicht besser hinbekommen:
Die erste Zeile kopiert alle Dateien auf den Stick, wenn dabei ein Fehler
auftritt (WriteError: (install.wim:FileInfo)) kann man mit der zweiten Zeile,
die zu große install.wim direkt gesplittet auf den Stick kopieren.
In der Powershellkonsole:
# Alles auf USB Stick kopieren
Copy-Item -Path $DistDir\* -Destination $UsbStick -Recurse
# Image aufteilen für FAT32
Split-WindowsImage -ImagePath $DistDir\sources\install.wim -SplitImagePath $USBStick\sources\install.swm -FileSize 4096 -CheckIntegrity
oder direkt in der cmd geht es mit dism (es gibt keine Ausgabe mit Fortschritt):
dism /Split-Image /ImageFile:F:\sources\install.wim /SWMFile:e:\sources\install.swm /FileSize:4096
ISO Image
Je nach Größe der install.wim wird ein jetzt erstelltes ISO Image allerdings
nicht mehr auf eine DVD passen. Ich verwende es bevorzugt für Tests mit
VirtualBox oder PCs die Probleme mit dem Start von USB Sticks haben.
Wir brauchen ein zusätzliches Tool: oscdimg. Das bekommen wir aus dem
aktuellsten ADK (Access und Deployment Toolkit) von
Microsoft.
Die Installation des ADK können wir auf zwei Punkte einschränken: Installation
Windows PE (bräuchten wir für weitere Modifikationen) und Bereitstellungstools
(dism).
Die Aufrufzeile ist etwas komplexer um das ISO Image wieder bootfähig zu
machen.
######## ISO erzeugen
$Platform = "amd64"
$ADKDir = "D:\Program Files (x86)\Windows Kits\8.1\Assessment and Deployment Kit"
$ISOFile="d:\test.iso"
del $ISOFile # falls schon vorhanden
$PathToOscdimg = "$ADKDir\Deployment Tools\$Platform\Oscdimg\"
$BootData='2#p0,e,b"{0}"#pEF,e,b"{1}"' -f "$distDir\boot\etfsboot.com","$distDir\efi\Microsoft\boot\efisys.bin"
& "$PathToOscdimg\oscdimg.exe" @("-bootdata:$BootData",'-u2','-udfver102',"$distDir","$ISOFile") 2>$null
Im Gegensatz zu anderen Tools (z.B. dism) lässt sich oscdimg nicht
ohne weiteres aus Powershell aufrufen, deshalb der Umweg über & und das Array mit Parametern. Außerdem liefert
oscdimg einen Fehler der ignoriert werden kann, dies erledigt die Umleitung am
Ende der Zeile.
Installation von zusätzlichen Dingen in das Image
Sowohl Updates als auch zusätzliche Sprachen können direkt in die Images
installiert werden. Eigentlich kann man das Setup komplett individualisieren.
Ich möchte das hier nur an Hand von Updates und Sprachen zeigen.
Alles was wir bisher getan haben, passierte direkt in der Image Datei, wir haben
immer nur die install.wim "gesehen".
Ab jetzt arbeiten wir innerhalb der Image Datei, dazu müssen wir mounten.
Dabei die Struktur innerhalb der Image Datei in einem definierten Verzeichnis
zur Verfügung gestellt. Die Basisstruktur haben wir am Anfang schon erzeugt.
Um ein bestimmtes Image zu mounten hilft uns folgendes Script:
########## Bestimmtes Image mounten, dass Image muss ich mounten wenn ich den Inhalt des Image ändern will, z.B. Updates einspielen
# Jetzt Windows Image Indizies anzeigen
Get-WindowsImage -ImagePath $DistDir\sources\install.wim
# Abfrage Index Nummer
$a = read-host "Welches Windows Image mounten? -a- für Abruch"
If ($a -eq "a") {Exit 1}
Mount-WindowsImage -ImagePath $DistDir\sources\install.wim -Index $a -Path $windowsDir
Das Mounten des Images funktioniert noch mit jeder Version von dism, wollen
wir aber innerhalb der Images manipulieren braucht man eine dism Version
mindestens so aktuell wie die Windows Version die wir gemountet haben.
Theoretisch könnte man auch unter Windows 8.1 das ADK von Windows 10
installieren und müsste dism dann im ADK Pfad ausführen. Wie die cmdlets von
Powershell damit zurecht kommen?
Hinweis:
Bei allen Add Package Kommandos können "0x800f081e" Fehler auftreten. Das
angegebene Package ist dann nicht exakt für diese Version und wird ignoriert,
das ist nicht weiter schlimm.
Updates
Updates einspielen ist relativ simpel aber Zeitaufwendig. Die Updates können
z.B. mit dem Tool
wsusoffline heruntergeladen wurden.
Beim Aufruf der Scriptzeile muss die
Version
beachtet werden. (w6.3 --> Windows 8.1)
Eingespielt werden können Updates im cab und msu Format.
########## Updates dazu Dazu ist die aktuelle DISM Version notwendig geht also nur unter Windows 10?
# Update Verzeichnis wsusoffline
$Wsus = "E:\wsusoffline"
Add-WindowsPackage –Path $windowsDir –PackagePath $Wsus\client\w63-x64\glb
Add-WindowsPackage –Path $windowsDir –PackagePath $Wsus\client\w100-x64\glb
Je nach Anzahl der Updates kann das ganz schön dauern.
Sprache
Die Systeme sind auch weitestgehend sprachunabhängig aufgebaut, zusätzliche
Sprachen werden einfach über Language Packs (LP) dazu installiert. Zum
Verständnis warum es jetzt doch nicht ganz so einfach ist:
-
Wir brauchen ein boot System welches eventuell mehrere Sprachen
(auswählen) kann und alle Systemversionen installieren (auswählen) kann.
-
Leider hat MS immer wieder die Bereitstellung und Integration der
Sprachpakete verändert, für Windows 10 kann man aktuell die Sprachen nur
noch über die Systemsteuerung installieren.
-
Für die Änderung der Startumgebung brauchen wir Teile aus den Windows PE
Images. Diese haben wir mit dem ADK schon installiert.
Die folgenden Zeilen integrieren Language Packs in die Setup Images
########## Sprachumgebung deutsch und englisch
$PathToWinPE_OCs = "$ADKDir\Windows Preinstallation Environment\$Platform\WinPE_OCs"
$PackageBoot = @("$PathToWinPE_OCs\WinPE-Setup-Client.cab", "$PathToWinPE_OCs\WinPE-Setup-Server.cab")
# Zeige Index des Boot Images
Get-WindowsImage -ImagePath $DistDir\sources\boot.wim
# Boot Image mounten - nur einmal für Setup Sprache
Mount-WindowsImage -ImagePath $DistDir\sources\boot.wim -Index 2 -Path $bootDir
#Add Packages - es können 0x800f081e Fehler auftreten
#boot
$PackageBoot | foreach {Add-WindowsPackage –Path $bootDir –PackagePath $_ }
$AddPath = $PathToWinPE_OCs + "\en-us"
gci $AddPath | foreach {Add-WindowsPackage –Path $bootDir –PackagePath $_.FullName }
$AddPath = $PathToWinPE_OCs + "\de-de"
gci $AddPath | foreach {Add-WindowsPackage –Path $bootDir –PackagePath $_.FullName }
#Add Language zu Windows
#install
New-Item $DistDir\langpacks -type directory
New-Item $DistDir\langpacks\de-de -type directory
Copy-Item $SourceLang\langpacks\de-de\lp.cab $DistDir\langpacks\de-de
Add-WindowsPackage –Path $windowsDir –PackagePath $DistDir\langpacks\de-de\lp.cab
#Test ob Sprache korrekt
& 'DISM.exe' @("/image:$windowsDir", "/distribution:$DistDir", "/Get-Intl")
#Defaults Sprache Zeitzone usw. setzen
& 'DISM.exe' @("/image:$windowsDir", "/Set-TimeZone:W. Europe Standard Time")
& 'DISM.exe' @("/image:$windowsDir", "/Set-AllIntl:de-DE")
#Lang-Ini neu machen
& 'Dism.exe' @("/image:$bootDir", '/gen-langINI', "/distribution:$DistDir")
#& 'Dism.exe' @("/image:$windowsDir", '/gen-langINI', "/distribution:$DistDir")
#Die Datei wird in der Quelle erzeugt muss aber auch ins boot.wim
Copy-Item $DistDir\sources\lang.ini $bootDir\sources
WIM Datei schließen
Zum Schluss muss die gemountete Image Datei wieder geschlossen werden. Dabei
kann man die gemachten Änderungen speichern oder verwerfen:
########## Gemountetes Image schließen
#Variante commit Image
Dismount-WindowsImage -Save -Path $windowsDir
Dismount-WindowsImage -Save -Path $bootDir
#Variante Discard Image
#Dismount-WindowsImage -Discard -Path $windowsDir
#Dismount-WindowsImage -Discard -Path $bootDir
Zwei Architekturen x86 und amd64
Zwei Architekturen in ein install.wim Image zu packen ist relativ einfach, um
dann aber wirklich installieren zu können brauchen wir eine Dual Boot Umgebung.
Gestartet wird die Installation mittels WindowsPE - wir müssen also eine
WindowsPE Dualboot Umgebung
bauen. Das wiederum von der neuesten Version. Ich nehme als Ausgangspunkt eine
x64 Umgebung und addiere eine x86 Umgebung dazu. Man braucht dazu noch die x86
boot.wim entweder von der x86 DVD (ISO) oder aus dem ADK. Der folgende Script
Code ist Beispielhaft und muss der konkreten Situation angepasst werden.
############# Für zwei Architekturen x86 und amd64
#Dual Boot Image erstellen, Originaleintrag lassen, boot.wim x64 so lassen, boot.wim x86 umbenennen in boot_x86.wim und ins sources verzeichnis kopieren
& 'bcdedit' @("/store", "$DistDir\boot\bcd", "/enum") | select-string "osdevice" #Die GUID ermitteln vom Standard
#-->{7619dcc8-fafe-11d9-b411-000476eba25f}
& 'bcdedit' @("/store", "$DistDir\boot\bcd", "/copy", "{default}", "/d", "Windows Boot X86") # Guid merken
#-->{d9b3b7ea-cb40-11e4-8323-000461814078}
# Den kopierten Eintrag editieren/ändern
& 'bcdedit' @("/store", "$DistDir\boot\bcd", "/set", "{d9b3b7ea-cb40-11e4-8323-000461814078}", "device", "ramdisk=[boot]\sources\boot_x86.wim,{7619dcc8-fafe-11d9-b411-000476eba25f}")
& 'bcdedit' @("/store", "$DistDir\boot\bcd", "/set", "{d9b3b7ea-cb40-11e4-8323-000461814078}", "osdevice", "ramdisk=[boot]\sources\boot_x86.wim,{7619dcc8-fafe-11d9-b411-000476eba25f}")
# Auswahl bei Win PE aktivieren, braucht man bei Win Setup nicht?
#& 'bcdedit' @("/store", "$DistDir\boot\bcd", "/deletevalue", "{default}", "bootmenupolicy")
############# Ende Dualboot
Empfehlung
Der USB Stick zum Setup ist schnell erzeugt und man braucht keine speziellen
Tools. Mehrere Windows Versionen (7, 8, 8.1 und 10 oder auch Server 2008 und
2012) in einer Sprache und einer Prozessor Architektur lassen sich leicht auf
einen Stick vereinen. Man hat damit ein universelles Setup Medium an der
Hand.
Von Zeit zu Zeit kann man mal Updates integrieren, vor allem wenn Service Packs
erschienen sind. Ansonsten ist der Zeitaufwand hierfür relativ groß.
Die Mischung von Sprachversionen und Prozessor Architekturen auf einem Setup
Medium ist aufwendig und kompliziert. Lohnt sich meines Erachtens nicht!
