Evgenij Smirnov – IT Pro aus Berlin …because IT matters :)

Ich habe ja schon des öfteren über Eigenarten von Sammlungen aller Art in PowerShell berichtet. Heute ein Beispiel aus der Active Directory-Administration.

Nehmen wir einfach mal an, wir haben ein mehrwertiges Attribut und wollen zu diesem einen zusätzlichen Wert hinzufügen. Für diese Beispiel nehme ich msExchExtensionCustomAttribute1, da kann man nichts kaputt machen.

Set-ADUser john.doe -Replace @{msExchExtensionCustomAttribute1=@("A","B","C")}
$user = Get-ADUser john.doe -Properties msExchExtensionCustomAttribute1
$a1 = $user.msExchExtensionCustomAttribute1
Write-Host "Unser Attribut msExchExtensionCustomAttribute1:"
$a1.GetType()
$a1

Nun wollen wir zu $a1 ein viertes Element hinzufügen. IntelliSense in ISE bietet folgendes an:

Auch wenn’s bei nativen PowerShell-Arrays nicht funktioniert, ist Add doch vielversprechend. Probieren wir’s aus:

$a1.Add("D")
Write-Host "`r`nNach dem Add:"
$a1.GetType()
$a1

liefert

Sieht doch super aus, richtig? Der Typ ist derselbe, alle vier Elemente sind wie erwartet da. Nun bleibt also die neue Sammlung zurück in das Attribut zu schreiben und das Ergebnis zu überprüfen:

Set-ADUser john.doe -Replace @{msExchExtensionCustomAttribute1=$a1}
Get-ADUser john.doe -Properties msExchExtensionCustomAttribute1

Doch das Ergebnis ist leider nicht ganz das, was wir erwartet haben:

Das soeben beschriebene Attribut ist leer. Hmmm.

Machen wir das gleiche Spiel und nehmen statt der Methode .Add das PowerShell-eigene Anfügen:

$a1 += "D"

so ist das Ergebnis wie erwartet:

Der alles entscheidende Unterschied ist anscheinend, dass die Operation += die ADPropertyValueCollection in ein System.Array konvertiert. Und dieses wird offenbar von Set-ADUser korrekt interpretiert, sein nativer Datentyp hingegen nicht!

Happy updating!

Das nächste Treffen (Q2/2018) der WSUG-B findet am Donnerstag, dem 24.05.2018 bei der COMPAREX AG in Berlin-Adlershof. Details und Anmeldung über Meetup.com: https://www.meetup.com/de-DE/Windows-Server-User-Group-Berlin/events/250092212/

Haben wir uns das nicht alle schon mal gewünscht – eine ordneltiche Hilfe zu den zahlreichen Kommandozeilen-Befehlen? Jetzt, wo man schon dachte, nun ist PowerShell da und es kommt keine CMD-Doku mehr, hat Microsoft sich einen Ruck gegeben und die folgende coole PDF rausgebracht: https://www.microsoft.com/en-us/download/details.aspx?id=56846

Happy commandlining!

Das erste Treffen der Windows Server User Group Berlin wird am Donnerstag, dem 25.01.2018 um 18 Uhr bei der Jaemacom GmbH in der Friedenstr. 91 stattfinden. Auf dem Programm stehen Vorträge zu künstlicher Intelligenz und zu Security in Windows-Landschaften.

Für das leibliche Wohl wird auch gesorgt sein.

Um die Organisation zu unterstützen, bitten wir um Anmeldung unter https://winsvr.events/event.php?vnr=11-106 .

Bis bald bei der WSUGB!

…zumindest so ein bißchen, nur in einem Szenario und nur in Bezug auf die Funktion, nicht auf die Performance. Das ist einer aus der Rubrik „wieder was gelernt“. Enjoy: https://support.microsoft.com/en-us/help/297019/limits-to-using-personal-folders–pst-files-over-lan-and-wan-links

P-L-E-A-S-E don’t do this at homework! (hier ist, warum: https://blogs.technet.microsoft.com/askperf/2007/01/21/network-stored-pst-files-dont-do-it/) Wenn jemand Hilfe bei der Abschaffung von PSTs braucht, fragt mich 😉

Als Host und Sponsor beherbergt uns diesmal die Jaemacom GmbH.

Agenda und Anmeldung: [ KLICK ]

Hier ein Quickie, das habe ich offenbar bisher übersehen und bin heute zufällig darauf gestoßen: In https://blogs.technet.microsoft.com/volume-licensing/2014/03/10/licensing-how-to-when-do-i-need-a-client-access-license-cal/ findet sich der folgende Passus:

RDS CALs are required only when accessing the Windows Server GUI, or if any of the RDS components listed are used (e.g. Remote Desktop Web Access, Remote Desktop Gateway, Remote Desktop Connection Broker, Remote Desktop Session Host, or the Remote Desktop Virtualization Host.)  If you are using a third party VDI solution, and it does not use any of the RDS components, then RDS CALs are not required.

Übersetzt bedeutet das für den Fall einer reinen VDI, d.h. mit 100% Client-Betriebssystemen als Workern:

• Ich baue eine Citrix XenDesktop- oder VMware View-VDI: Die Worker brauchen SA und, je nach Beschaffenheit der Benutzer-Endgeräte, VDA. Das ist blöd genug, aber erst mal nicht zu ändern.
• Ich baue eine VDI mit Microsoft-Mitteln: Man braucht alles oben Genannte und zusätzlich noch RDS CALs für die ganze Chose!

Wo ist denn hier die Logik? Und da soll mir noch jemand erzählen, Microsoft würde eigene Produkte auf Kosten des Wettbewerbs pushen…

Happy Year of Desktop Virtualization (as proclaimed by Gartner every year since 2007 for the following year so we’re apparently having a 10th coming up…)

Die Herausforderung

Neulich im TechNet Forum: Jemand hat eine Liste, die sehr viele Einträge enthält, die sich oft wiederholen. In diesem Fall ging es um IP-Adressen. Wenn er versucht, die eindeutigen Werte mit

$list | select -Unique

zu generieren, dauert das sehr lange. Da er das normale PowerShell-Array verwendet hat, war es wenig überraschend. Im Forum-Thread kam natürlich sofort der (berechtigte) Hinweis auf den ArrayList-Typ, aber auch ein paar ausgefallenere Sachen. Da wollte ich natürlich genau wissen, wie sich das tatsächlich auswirkt.

Die Testmethodik

Da ich auf die Schnelle keine Quelle mit vielen IP-Adressen zur Hand hatte, habe ich beschlossen, einfach mit Strings zu arbeiten. Um die ursprüngliche Herausforderung zu simulieren, generieren wir einige (viele) Male eine Zufallszahl. Wenn der Bereich der Zufallszahlen deutlich kürzer ist als die Anzahl der Versuche, werden garantiert viele Dubletten auftreten.

Für die Generierung der Listen verwenden wir die folgende Logik:

$passes = 100000 # Anzahl der Durchläufe
$maxval = 10000 # Länge des Zufallszahlen-Bereiches
$a = <Initialisierung des jeweiligen Listentyps>
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    <$r wird an $a angefügt, evtl. mit Prüfung>
}
$s1 = $timer.Elapsed.TotalMilliseconds # das ist die Zeit der Listen-Erstellung
$a = $a | select -Unique
$s2 = $timer.Elapsed.TotalMilliseconds # das ist die Gesamtzeit

Bei den Methoden, wo von vornherein nur eindeutige Elemente auf die Liste kommen, entfällt natürlich der Teil mit Select und die „Zwischenzeit“. Diese Methodik führt zu den folgenden Skripten:

Methode 0: PowerShell-Array mit Select

Das ist die primitivste Methode. Das komplette Skript dieht wie folgt aus:

$passes = 100000
$maxval = 10000
$a = @()
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    $a += $r
}
$s1 = $timer.Elapsed.TotalMilliseconds
$a = $a | select -Unique
$s2 = $timer.Elapsed.TotalMilliseconds
"Zeit zum erstellen: $s1, Gesamtzeit: $s2"

Methode 1: ArrayList mit Select

Wie wir alle wissen, kann man die Bestückung von Arrays deutlich beschleunigen, wenn man statt des PowerShell-Array den .Net-Typ System.Collections.ArrayList verwendet. Nicht nur erweitert sich solch ein Array dynamisch, sondern man kann Elemente auch nachträglich löschen. Und schneller ist es obendrein. Das folgende Skript wird uns zeigen, wie sehr:

$passes = 100000
$maxval = 10000
$a = New-Object System.Collections.ArrayList
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    $a.Add($r) > $null
}
$s1 = $timer.Elapsed.TotalMilliseconds 
$a = $a | select -Unique 
$s2 = $timer.Elapsed.TotalMilliseconds 
"Zeit zum erstellen: $s1, Gesamtzeit: $s2"

Methode 2: ArrayList mit -notcontains

Ich nehme ein Ergebnis schon mal vorweg: der Teil mit Select dauert eine Weile. Das war auch das, was den ursprünglichen Thread ausgelöst hat. Es liegt daher natürlich nahe, vor dem Hinzufügen von Elementen zu checken, ob sie nicht schon drin sind, statt hinterher zu filtern. PowerShell hatt dafür den Operator -notcontains im Angebot:

$passes = 100000
$maxval = 10000
$a = New-Object System.Collections.ArrayList
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    if ($a -notcontains $r) { $a.Add($r) > $null }
}
$s2 = $timer.Elapsed.TotalMilliseconds 
"Gesamtzeit: $s2"

Methode 3: ArrayList mit .Contains()

Wir haben schon oft gehört, dass .Net-Methoden von Klassen schneller sein können als PowerShell-Äquivalente. Und da wir mit ArrayList arbeiten, können wir zur Prüfung auch auf die .Contains()-Methode zurückgreifen:

$passes = 100000
$maxval = 10000
$a = New-Object System.Collections.ArrayList
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    if (!($a.Contains($r))) { $a.Add($r) > $null }
}
$s2 = $timer.Elapsed.TotalMilliseconds 
"Gesamtzeit: $s2"

Methode 4: Hashtable

Schon bald im Thread kam der Einwurf, man könnte doch eine Hashtable verwenden, wenn die Werte eindeutig sein sollen. Das wäre ein Stück weit „mißbräuchliche Nutzung“, da wir nur den Key verwenden würden, aber nicht den Value. Aber sei’s drum, wenn es ans Ziel führt, ist jedes Mittel recht. Beim Versuch, einen bereits vorhandenen Key-Wert einzufügen, generiert die Hashtable eine Ausnahme. Diese fangen wir ab und… machen nichts weiter:

$passes = 100000
$maxval = 10000
$a = @{}
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    try {$a.Add($r,"") > $null} catch {}
}
$s2 = $timer.Elapsed.TotalMilliseconds 
"Gesamtzeit: $s2"

Methode 5: Hashtable mit Prüfung

Ausnahmen sind natürlich häßlich und in ordentlicher Programmierung zu vermeiden. Zum Glück kann man in einer Hashtable bestimmen, ob ein Key bereits vorhanden ist, nämlich mit der Methode .ContainsKey(). Ob es schneller ist als Ausnahme, wird der Test zeigen:

$passes = 100000
$maxval = 10000
$a = @{}
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    if (!($a.ContainsKey($r))) { $a.Add($r,"") > $null }
}
$s2 = $timer.Elapsed.TotalMilliseconds 
"Gesamtzeit: $s2"

Methode 6: Hashset

Zum Schluss hatte Denniver Reining noch das Hashset ins Gespräch gebracht. Das ist eine eindimensionale Liste, deren Mitglieder stets eindeutig sind, ohne das Ausnahmen generiert werden – vorhandene Werte werden einfach nicht hinzugefügt:

$passes = 100000
$maxval = 10000
$a = New-Object System.Collections.Generic.HashSet[object]
$timer = [System.Diagnostics.Stopwatch]::StartNew()
(1..$passes) | foreach {
    $r = (Get-Random -Minimum 1 -Maximum $maxval).ToString().PadLeft(15,'0')
    $a.Add($r) > $null
}
$s2 = $timer.Elapsed.TotalMilliseconds 
"Gesamtzeit: $s2"

Die Ergebnisse

Die obigen Skripte könnt ihr euch hier herunterladen und selbst Messungen vornehmen. Bei $passes = 100000 und $maxval = 10000 (also im Schnitt 10 Dubletten pro Eintrag) erhalten wir folgende Ergebnisse:

Erhöhen wir die Werte auf $passes = 400000 und $maxval = 20000 (damit verdoppelt sich sowohl die Länge der eindeutigen Liste als auch die durchschnittliche Anzahl der Dubletten), ändern sich die Ergebnisse wie folgt:

Man sieht also sehr deutlich, dass die Bestückung eines Hashset auch bei einer größeren Menge an Ergebnissen kaum Zeit in Anspruch nimmt!

Das Fazit

Die „Ausbeute“ aus diesen Zahlen ist wie folgt:

1. Das Erweitern eines PowerShell-Array mit $array += $item ist extrem langsam
2. Die .Contains()-Methode ist viel schneller als der Operator -contains
3. Beim Hinzufügen zu einer Hashtable ist es deutlisch schneller, vorher die Existenz des Key abzuprüfen als eine Ausnahme zu generieren.
4. Will man von vorhnherein eindeutige Werte auf der Liste haben, ist ein Hashset optimal. Der Geschwindigkeitsgewinn gegenüber Hashtable mit Prüfung ist zwar nicht mehr weltbewegend, aber er ist da, man benutzt die Typen richtig und mißbraucht den Key nicht als Datenspeicher…

Also: Wenn lange Listen generiert und verarbeitet werden müssen, lohnt es sich auf jeden Fall, das bequeme Konstrukt des PowerShell-Arrays zu verlassen und sich fortgeschritteneren Typen von Sammlungen zuzuwenden.

Happy listing!

Wenn man in einer PowerShell-Sitzung mit

New-PSDrive -Name Z -Root "\\SERVER\SHARE" -PSProvider FileSystem

ein Netzlaufwerk mappt, stellt man fest, dass die Spalten „Used Space“ und „Free Space“ leer sind:

Möchte man die Werte haben, funktioniert es mit dem Argument -Persist:

Ich hätte sogar eine theoretische Erklärung dafür, aber Gernot Meyer hat im TechNet-Forum eine Beobachtung zitiert, die diese Erklärung widerlegt, daher halte ich mich mal zurück und recherchiere weiter.

Happy drive mapping!

Heute mal ein Quickie, nur als Merker für den Hinterkopf:

Auch wenn es im Internet von Anleitungen nur so wimmelt, die den Befehl

Move-ADDirectoryServerOperationMasterRole <DomainController> -OperationMasterRole SchemaMaster

zeigen, gibt es dazu ein Wort zu sagen: Das funktioniert nur, wenn man

• entweder den Befehl auf dem DC aufruft, zu dem die Rolle transferiert werden soll
• oder den Parameter -Force mit angibt.

Alle anderen Rollen lassen sich auch ohne -Force beliebig hin und her transferieren.

Happy FSMOing!