WindowsTipps

Das Skript von Teil 6 gibt separate Dateien für jeden PC und für die Monitore vom Typ CSV aus. Diese Textdateien beinhalten genau eine Zeile.
Für den PC beispielsweise EURITX.csv mit folgendem Inhalt:
EURITX HP Compaq 8000 Elite SFF PC CZC01234567 Intel Core2 Quad CPU Q8400 @ 2.66GHz 2.67 GHz 8196 256 Microsoft Windows 10 Enterprise 172.22.3.111 OU=WIN10Pilot,OU=TEST,OU=DE,DC=europe,DC=hanjin,DC=com 04912345 (Engelke, Olaf) IT 09-28-2016 17:04 Inventory Script 1 176.31

Im Zielverzeichnis für die Logdateien befinden sich zahlreiche dieser Dateien, die so noch nicht besonders gut lesbar sind. Damit wir besser damit umgehen können und eine einfache Verarbeitung mit Access oder Excel möglich wird, ziehen wir diese Dateien mit folgendem PowerShell-Skript zusammen:

#Erzeugt eine einzelne Logdatei aus den durch das Asset WMI-Skript generierten Dateien, getrennt für PC und Monitore unter T:\Asset\logfile.csv and monitors.csv
#Archiviert erfasste Einzeldateien durch Verschieben
$ErrorActionPreference = 'SilentlyContinue'


#Festlegen der Pfade
$pcsource = "\\server\assetLog$\Computer*.csv"
$pclog = "t:\asset_db\logfile.csv"
$dspsource = "\\server\assetLog$\Monitor*.csv"
$dsplog = "t:\asset_db\monitors.csv"
$pcarchive = "\\server\assetlog$\oldlog\computer\"
$dsparchive = "\\server\assetlog$\oldlog\monitor\"

#Löschen der alten Logdateien
del $pclog
del $dsplog

#Überschriftszeile generieren
$pcinfo="SystemName"+"`t"+"ModelName"+"`t"+"SerialNbr"+"`t"+"Property1"+"`t"+"Property2"+"`t"+"Property3"+"`t"+"Property4"+"`t"+"Property5"+"`t"+"Property6"+"`t"+"SystemADOU"+"`t"+"LastUser"+"`t"+"Team"+"`t"+"LastModified"+"`t"+"LastModifiedBy"+"`t"+"StatusID"

#Überschrift in neue Gesamtlogdatei übertragen und die Inhalte der Dateien an diese anhängen
write-output $pcinfo | format-table | out-file $pclog
cat $pcsource >> $pclog

#Verschieben der alten Einzellogs für Computer
move-item $pcsource $pcarchive -force

#Wiederholung für Monitore, gefiltert für die Hersteller der Monitore, um virtuelle und sonstige Displays auszuklammern sowie Entfernen störender Inhalte
$dspinfo="ModelName"+"`t"+"SerialNbr"+"`t"+"PCSerial"+"`t"+"LastModified"+"`t"+"LastModifiedBy"+"`t"+"StatusID"
write-output $dspinfo | format-table | out-file $dsplog
cat $dspsource | select-string -pattern "Dell","HP" | foreach-object {$_ -replace "`0",""} >> $dsplog

#Verschieben der alten Einzellogs für Displays
move-item $dspsource $dsparchive -force

Im Ergebnis erhalten wir zwei CSV-Dateien, in denen die wichtigsten Daten aller geloggten PCs und Monitore tabellarisch abgelegt sind.

An dieser Stelle das vollständige Skript, wie es sich im Einsatz bewährt hat. Nicht alle Befehlssequenzen und Abläufe mögen optimal sein, da dieses historisch gewachsen ist, mit der einen oder anderen Anleihe aus Fundstellen im Internet.

Dieses Skript wird beim Herunterfahren des Rechners über entsprechende Gruppenrichtlinien im Active Directory ausgeführt.
Falls das Skript unter Windows 10 beim Herunterfahren nicht ausgeführt wird, muss der Schnellstart deaktiviert werden.
Auf die Freigabe für die Logdateien brauchen die Domänenrechner Schreibzugriff, ebenso jener Anwender, der die Auswertung ggf. manuell im weiteren Verlauf vornimmt. PowerShell-Scripting auf den PCs muss aktiviert sein, ggf. sollte das Skript nach Anpassung an die eigene Umgebung signiert werden.

Variablen und Einträge, die angepasst werden müssen:
$strRelevantGroups - sollte die jeweilige primäre Gruppe der Benutzer beinhalten, um die logischen PC-Zuweisungen auswerten zu können
$logfile - muss auf eine beschreibbare Freigabe verweisen

Der Name der Datei wird mittels des Computernamens gebildet (und selbige überschrieben), das Dateidatum hilft dabei, den letzten erfolgreichen Vorgang direkt im Dateisystem zu erkennen.


#PC-Information sammeln
Function Get-FreeDiskSpace($drive)
{
$driveData = Get-WmiObject -class win32_LogicalDisk -filter "Name = '$drive'"
"{0:n2}" -f ($driveData.FreeSpace/1GB)# + " GB"
}

$ErrorActionPreference = 'SilentlyContinue'
$strCompName = ($env:Computername)
$CompNameLength = ($env:Computername).length
$logfile = "\\server\assetLog$\Computer\$strCompName.csv"

#Benutzerinfos des letzten angemeldeten Benutzers ermitteln und Variablen zuweisen
$objDomain = New-Object System.DirectoryServices.DirectoryEntry
$objSearcher = New-Object System.DirectoryServices.DirectorySearcher
$objSearcher.SearchRoot = $objDomain
$objSearcher.SearchScope = "Subtree"
$objSearcher.Filter = "(&(objectClass=computer)(cn=$strCompName))"
$system = $objSearcher.FindOne()
$dn = $system.properties["distinguishedname"]
$dn = $dn[0].toString()
$ou = $dn.substring(4+$CompNameLength)
$lastuser = (Get-ItemProperty HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Authentication\LogonUI).LastLoggedOnSAMUser
$lastuser = $lastuser.split("\")
$lastuser = $lastuser[1]
$objSearcher.Filter = "(&(objectClass=user)(cn=$lastuser))"
$userinfo = $objSearcher.FindOne()
$userdn = [adsi]$userinfo.path
$username = $userdn.displayname
$lastuser = $lastuser + " (" + $username + ")"

$strRelevantGroups = "Domain Users" #durch kommaseparierte reale Benutzergruppen ersetzen!
$groups = $userdn.memberof
$strGroups = ""
foreach($group in $groups)
{
$strGroup = $group.split(',')[0]
$strGroup = $strGroup.split('=')[1]
if($strRelevantGroups.contains($strGroup))
{
$strGroups = $strGroups + "," + $strGroup
}
}
if($strGroups.Length -gt 0){
$strGroups = $strGroups.split(",")
$team = [string]$strGroups[1]
} else {
$team = "N/A"
}

#Seriennummer des PCs auslesen
$computer = gwmi win32_computersystem
$bios = gwmi win32_bios
$os = (gwmi win32_operatingsystem).caption
$serial = $bios.serialnumber

#Prozessoren ermitteln
$colCPUs = gwmi win32_processor
$n = 0
foreach ($cpu in $colCPUs)
{
$n = $n + 1
$processor = ((($cpu.name -replace ' {2,}',' ') -replace "\(TM\)") -replace '\(R\)')
}
$cpuspeed = "{0:0.00 GHz}" -f($cpu.maxclockspeed/1000)

#Größe des physischen Arbeitsspeichers ermitteln
$totalmem = 0
$memsticks = gwmi -Class win32_physicalmemory
foreach ($stick in $memsticks) { $totalmem += $stick.capacity }
$physmem = ([int] ($($totalmem) / 1MB))

#Größe der Datenträger ermitteln
$disk = gwmi win32_diskdrive -filter "InterfaceType <> 'USB'"
$disksize=""
foreach ($objitem in $disk) {$disksize=$disksize+";"+[Convert]::ToString(([int]($objitem.size/1000000000)))}
$disksize = $disksize.substring(1)
$diskfree = ""
$diskfree = Get-FreeDiskSpace -drive "C:"

#Ermitteln der IP-Adresse(n)
# new (Test): $ip = Get-WmiObject Win32_NetworkAdapterConfiguration -filter 'IPEnabled="True"' | Select -expand IPAddress | ?{$_ -notmatch ':'}
$lan = get-wmiobject win32_networkadapterconfiguration -filter "ipenabled=true"
$lancount = get-wmiobject win32_networkadapterconfiguration -filter "ipenabled=true"
$ip=""
foreach($lan in $lancount){$ip = $ip + ";" + [string]($lan.ipaddress[0])}
$ip = $ip.substring(1)

#Erzeugen der Logdatei mit Zeitstempel im Logeintrag
$timestamp = get-date -format "M/d/yyyy HH:mm"

#Testausgabe am Bildschirm
#write-host $computer.name $computer.model $serial $processor $cpuspeed $physmem $disksize $os $ip $ou $lastuser $team $timestamp $diskfree -separator ";"

#Zusammenfassung für CSV-tauglichen String, separiert mit Tabulatoren
$allinfo=[string]$computer.name+"`t"+[string]$computer.model+"`t"+[string]$serial+"`t"+[string]$processor+"`t"+[string]$cpuspeed+"`t"+[string]$physmem+"`t"+[string]$disksize+"`t"+[string]$os+"`t"+[string]$ip+"`t"+[string]$ou+"`t"+[string]$lastuser+"`t"+$team+"`t"+[string]$timestamp+"`t Inventory Script`t1"+"`t"+[string]$diskfree

#Ausgabe in Logdatei
write-output $allinfo | format-table | out-file $logfile -encoding ASCII

#Informationen zu angeschlossenen Monitoren sammeln (ab Windows 7/2008R2)
try {
$ActiveMonitors = Get-WmiObject -Namespace root\wmi -Class wmiMonitorID
}
catch {
break
$computer.name
}
$monitorInfo = @()
$pcserial = $serial
$i = 1
foreach ($monitor in $ActiveMonitors)
{
$mon = New-Object PSObject
$manufacturer = $null
$dspserial = $null
$name = $null
$week = $null
$year = $null

$monitor.ManufacturerName | foreach {$manufacturer += [char]$_}
$monitor.SerialNumberID | foreach {$dspserial += [char]$_}
$monitor.UserFriendlyName | foreach {$name += [char]$_}

$mon | Add-Member NoteProperty Manufacturer $manufacturer
$mon | Add-Member NoteProperty PCSerial $serial
$mon | Add-Member NoteProperty SerialNumber $dspserial
$mon | Add-Member NoteProperty Name $name
$mon | Add-Member NoteProperty Week $monitor.WeekOfManufacture
$mon | Add-Member NoteProperty Year $monitor.YearOfManufacture
$mon.SerialNumber = $dspserial.trim()
$monitorInfo += $mon

#Erzeugen eines Strings für Datei, Name wird aus DSP und Computername erzeugt, um die relevante Datei schnell im Dateisystem zu finden
$displayinfo = [string]$name+"`t"+[string]$dspserial+"`t"+$pcserial+"`t"+[string]$timestamp+"`t Inventory Script`t1"
$dsplogfile = "DSP" + $i + "_" + $computer.name
$dsplogfile = "\\server\assetLog$\Monitor\$dsplogfile.csv"
$i++
$displayinfo | format-table | out-file $dsplogfile -encoding ASCII
}

Eine besondere Schwierigkeit stellt oft die Ermittlung des Verbleibs eines Monitors dar, da diese nicht aktiv abgefragt werden können, sondern nur über den angeschlossenen PC. Daher ist es sinnvoll, die ermittelten Daten mit jenen des PCs zu verknüpfen, an dem der Monitor angeschlossen ist. Nicht jeder Monitor kann über WMI abgefragt werden, aber fast alle moderneren Monitore liefern entsprechende Werte zurück.

Verwendete Variablen:
$ActiveMonitors: die am PC angeschlossenen und eingeschalteten Monitore
$monitor: der gerade ausgewertete Monitor im Fall von mehreren
$monitorInfo: die ausgelesenen Informationen der Monitore aus der Variable $mon als Array
$mon: ein neues PowerShell-Objekt, welches Herstellername, PC-Seriennummer, Monitorseriennummer, Modellname, Herstellungswoche und -jahr des Monitors aufnimmt
$pcserial: die Seriennummer des PCs, ist in einem anderen Teil des vollständigen Skripts zu ermitteln
$i: Zähler für die erkannten Monitore

Falls kein Monitor angeschlossen ist, beispielsweise bei Servern oder VMs, sollte diese Fehlerquelle von vornherein abgefangen werden.

try {
$ActiveMonitors = Get-WmiObject -Namespace root\wmi -Class wmiMonitorID
}
catch {
break
$computer.name
}

Die gesammelte Information wird im Array $monitorInfo abgelegt.
$monitorInfo = @()
$pcserial = $serial
$i = 1
foreach ($monitor in $ActiveMonitors)
{
$mon = New-Object PSObject
$manufacturer = $null
$dspserial = $null
$name = $null
$week = $null
$year = $null

Da die Werte codiert hinterlegt sind, müssen sie zunächst in eine lesbare Zeichenkette umgewandelt werden.
Ursprünglich wird beispielsweise die Modellbezeichnung ausgelesen über $monitor.userfriendlyname | foreach { $_ } wie folgt dargestellt:
72
80
32
76
49
57
52
53
119
0
0
0
0

Zu Zeichen umgewandelt mittels [char] $monitor.userfriendlyname | foreach { [char]$_ } lässt die Lesbarkeit immer noch ein wenig zu wünschen übrig:
H
P

L
1
9
4
5
w

Daher erzeugen wir neue Strings, denen wir die einzelnen Zeichen dann hinzufügen:

$monitor.ManufacturerName | foreach {$manufacturer += [char]$_}
$monitor.SerialNumberID | foreach {$dspserial += [char]$_}
$monitor.UserFriendlyName | foreach {$name += [char]$_}

$mon | Add-Member NoteProperty Manufacturer $manufacturer
$mon | Add-Member NoteProperty PCSerial $serial
$mon | Add-Member NoteProperty SerialNumber $dspserial
$mon | Add-Member NoteProperty Name $name
$mon | Add-Member NoteProperty Week $monitor.WeekOfManufacture
$mon | Add-Member NoteProperty Year $monitor.YearOfManufacture

Unnütze Leerzeichen werden eliminiert:
$mon.SerialNumber = $dspserial.trim()
$monitorInfo += $mon

Auf geht's zum nächsten Monitor:
$i++
}

Die fertige Ausgabe ohne Formatierung und Export stellt sich wie folgt dar:
>$monitorInfo

Manufacturer : HWP
PCSerial : ABCDEFG
SerialNumber : CNN8xxxxxx
Name : HP L1945w
Week : 21
Year : 2008

Die zuletzt verwendete IP-Adresse ist hilfreich, wenn es darum geht, einen PC im Netzwerk ausfindig zu machen. DNS, DHCP und WINS-Einträge können verschwinden, so dass der letzte Standort eines ausgeschalteten PCs nur schlecht zu ermitteln ist. Also erfassen wir diese ebenfalls im Rahmen der Auffrischung der Inventarinformationen.

Verwendete Variablen:
$lan: Netzwerkadapterobjekte, bei denen das TCP/IP-Protokoll aktiv ist
$lancount: Gesamtheit der entsprechenden Netzwerkadapter bei multihomed PC
$ip: Ein String mit allen IP-v4-Adressen des PCs

$lancount = get-wmiobject win32_networkadapterconfiguration -filter "ipenabled=true"
$ip=""
foreach($lan in $lancount){$ip = $ip + ";" + [string]($lan.ipaddress[0])}
$ip = $ip.substring(1)

Der performanteste PC geht in die Knie, wenn die Festplatte oder SSD überfüllt ist. Daher gehört deren Größe mit in die Inventarisierung.

Verwendete Variablen:
$disk: die erfassten Datenträger
$disksize: die Kapazität der Laufwerke, lesbar gemacht durch Herunterbrechen der Zahl auf GByte

Die Abfrage der Datenträger erfolgt mittels des Befehls get-wmiobject win32_diskdrive. Um die Ergebnisse auf die fest erbauten Datenträger zu beschränken, werden USB-Laufwerke ausgefiltert. (Da die Filterung über WMI erfolgt, wird der Vergleich nicht mit dem PowerShell-Operator -neq vorgenommen.) Mit dem Stringformat wird an dieser Stelle gearbeitet, um gegebenenfalls auch die Größe mehrerer eingebauter Datenträger in einem Feld erfassen zu können, die mit Semikolon voneinander getrennt werden.

$disk = gwmi win32_diskdrive -filter "InterfaceType <> 'USB'"
$disksize=""
foreach ($objitem in $disk) {$disksize=$disksize+";"+[Convert]::ToString(([int]($objitem.size/1000000000)))}
$disksize = $disksize.substring(1)

Auch der Arbeitsspeicher spielt eine wesentliche Rolle für die Performance eines PCs, daher ist die korrekte Anzeige des vorhandenen RAM Bestandteil einer informativen Inventarisierung.

Verwendete Variablen:
$totalmem: Gesamter installierter RAM
$memsticks: die eingebauten physischen Module
$physmem: lesbar formatierte Größe des RAM

Mittels get-wmiobject win32_physicalmemory lassen sich die Eigenschaften der einzelnen Speichermodule auslesen. Aus der umfangreichen Liste interessiert uns im Beispiel lediglich die Kapazität. Diese steckt für die einzelnen Module in der Eigenschaft capacity. Diese wird für alle Module zusammenaddiert und dann auf MByte heruntergebrochen.

$totalmem = 0
$memsticks = gwmi -Class win32_physicalmemory
foreach ($stick in $memsticks) { $totalmem += $stick.capacity }
$physmem = ([int] ($($totalmem) / 1MB))

Die Ausgabe erscheint dann als einfache Zahl, die für Sortier- und Vergleichsoperationen weiter verwendet werden kann:
8196

Die folgende Beitragsserie hilft bei der Erfassung von PC-Inventar nur mit PowerShell und MS Office in Active Directory-Umgebungen, ohne dass eine spezielle Softwarelösung vorhanden sein muss.

Beginnen wir mit der Erkennung des Prozessors:
Angaben zu den installierten Prozessoren lassen sich mit get-wmiobject Win32_Processor ermitteln.
Die Ausgabe des Befehls sieht beispielsweise so aus:
Caption : Intel64 Family 6 Model 23 Stepping 10
DeviceID : CPU0
Manufacturer : GenuineIntel
MaxClockSpeed : 2667
Name : Intel(R) Core(TM)2 Quad CPU Q8400 @ 2.66GHz
SocketDesignation : XU1 PROCESSOR

Innerhalb des Inventarisierungsskripts legen wir diese Information in die Variable $colCPUs:

$colCPUs = gwmi win32_processor

Da wir bei Servern oder Workstations auch einmal auf mehrere Prozessoren stoßen können, sollten wir auch alle erfassen.
Interessant sind für uns der Prozessorname (hinterlegt in der neuen Variable $processor) und die Geschwindigkeit (hinterlegt in $cpuspeed).

$n = 0
foreach ($cpu in $colCPUs)
{
$n = $n + 1
$processor = ((($cpu.name -replace ' {2,}',' ') -replace "\(TM\)") -replace '\(R\)')
}

In diesem Beispiel ersetzen wir einige aus technischer Sicht uninteressante Zeichenfolgen und Leerzeichen entweder durch Leerzeichen oder durch gar nichts, um die Lesbarkeit zu erhöhen.
Das Ergebnis liest sich dann:
Intel Core2 Quad CPU Q8400 @ 2.66GHz

Die Geschwindigkeit wird in der Eigenschaft maxclockspeed standardmäßig in KHz ausgegeben, die folgende Zeile konvertiert diese Information zu GHz und formatiert sie entsprechend:
$cpuspeed = "{0:0.00 GHz}" -f($cpu.maxclockspeed/1000)

hinterlegt in der Variable $cpuspeed den Eintrag
2.67 GHz