Windows PowerShell im Einsatz (eBook)

Inhaltsverzeichnis 6
Geleitwort 16
Vorwort 18
Danksagung 20
Über dieses Buch 22
Teil I: PowerShell lernen 28
Willkommen bei PowerShell 30
1.1 Was ist PowerShell? 32
1.1.1 Shells, Befehlszeilen und Skriptsprachen 33
1.1.2 Warum eine neue Shell? Warum gerade jetzt? 34
1.1.3 Das Problem der letzten Meile 35
1.2 Seele einer neuen Sprache 35
1.2.1 Aus der Geschichte lernen 36
1.2.2 Unterstützung von .NET 36
1.3 OOP-Auffrischungskurs 38
1.3.1 Objektorientiertes Programmieren 38
1.3.2 Objekte in PowerShell 40
1.4 Heh! Wo bleibt der Code? 40
1.4.1 Installieren und starten von PowerShell 41
1.4.2 Editieren von Befehlen 43
1.4.3 Befehlsvervollständigung 44
1.4.4 Auswerten von elementaren Ausdrücken 45
1.4.5 Verarbeiten von Daten 46
1.5 Zusammenfassung 52
Grundlagen 54
2.1 Befehlskonzepte und Terminologie 55
2.1.1 Befehle und Commandlets 56
2.1.2 Befehlstypen 59
2.1.3 Aliase und flexible Syntax 63
2.2 Parsing und PowerShell 65
2.2.1 Wie PowerShell ein Skript zerlegt 66
2.2.2 Quoting 67
2.2.3 Parsing im Ausdrucks- und im Befehlsmodus 70
2.2.4 Terminieren von Statements 72
2.3 Pipelines und Befehle 74
2.3.1 Pipelines und Streamingverhalten 75
2.3.2 Parameter und Parameterbindung 76
2.4 Formatierung und Ausgabe 78
2.4.1 Die Format-Commandlets 79
2.4.2 Die Output-Commandlets 81
2.5 Zusammenfassung 84
Arbeiten mit Typen 86
3.1 Typenmanagement wie im wilden Westen 86
3.1.1 PowerShell: eine typ-promiskuitive Sprache 87
3.1.2 Typ-System und Typ-Adaption 89
3.2 Basistypen und Literale 91
3.2.1 Strings 91
3.2.2 Zahlen und numerische Literale 96
3.2.3 Collections: Dictionaries und Hashtabellen 98
3.2.4 Collections: Arrays und Sequenzen 103
3.2.5 Typliterale 108
3.3 Typumwandlungen 111
3.3.1 Wie die Typumwandlung funktioniert 112
3.3.2 PowerShells-Algorithmus zur Typumwandlung 114
3.3.3 Spezielle Typumwandlungen beim Binden von Parametern 117
3.4 Zusammenfassung 119
Operatoren und Ausdrücke 120
4.1 Arithmetische Operatoren 122
4.1.1 Der Additions-Operator 122
4.1.2 Der Multiplikations-Operator 125
4.1.3 Subtraktion, Division und der Modulo-Operator 127
4.2 Die Zuweisungsoperatoren 129
4.2.1 Mehrfache Zuweisungen 130
4.2.2 Mehrfache Zuweisungen mit Typqualifizierern 131
4.2.3 Zuweisungsoperationen als Wertausdrücke 133
4.3 Vergleichsoperatoren 134
4.3.1 Skalare Vergleiche 135
4.3.2 Vergleichsoperatoren und Auflistungen 139
4.4 Operatoren zum Musterabgleich 141
4.4.1 Wildcard Pattern 141
4.4.2 Reguläre Ausdrücke 142
4.5 Logische und Bit-Operatoren 147
4.6 Zusammenfassung 148
Erweiterte Operatoren und Variablen 150
5.1 Operatoren für die Arbeit mit Typen 150
5.2 Die unären Operatoren 153
5.3 Gruppieren, Unterausdrücke und Array-Unterausdrücke 154
5.4 Array-Operatoren 159
5.4.1 Der Komma-Operator "," 159
5.4.2 Der Bereichsoperator 162
5.4.3 Indizieren von Arrays 163
5.5 Operatoren für Eigenschaften und Methoden 169
5.5.1 Der "."-Operator 170
5.5.2 Statische Methoden und der "::"-Operator 172
5.6 Der PowerShell Format-Operator -F 173
5.7 Umleitung und Umleitungsoperatoren 175
5.8 Variablen 178
5.9 Zusammenfassung 183
Flusskontrolle in Skripten 184
6.1 Das if/elseif/else-Statement 185
6.2 Die while-Schleife 188
6.3 Die do/while-Schleife 189
6.4 Die for-Schleife 190
6.5 Die foreach-Schleife 192
6.6 Labels, break und continue 196
6.7 Das switch- Statement 198
6.7.1 Grundlegendes zum switch-Statement 199
6.7.2 Wildcard Pattern und switch-Statement 200
6.7.3 Reguläre Ausdrücke mit dem switch- Statement 201
6.7.4 Dateiverarbeitung mit dem switch- Statement 205
6.7.5 Der $switch-Schleifenenumerator im switch-Statement 206
6.8 Ablaufsteuerung mit Commandlets 207
6.8.1 Das Foreach-Object-Commandlet 208
6.8.2 Das Where-Object-Commandlet 211
6.9 Der Wert von Statements 213
6.10 Zusammenfassung 214
Funktionen und Skripte 216
7.1 Grundlagen von Funktionen 217
7.2 Formale Parameter und das param-Statement 220
7.2.1 Spezifizieren von Parametertypen 222
7.2.2 Umgang mit einer variablen Anzahl von Argumenten 224
7.2.3 Initialisieren von Funktionsparametern 225
7.2.4 Verwendung von switch-Parametern zum Definieren von Flags 227
7.2.5 Lebenszeit von Variablen und Sichtbarkeits-Regeln 229
7.2.6 Bereichsmodifizierer 232
7.3 Rückgabewerte von Funktionen 232
7.3.1 Debugging des Funktionsoutputs 235
7.3.2 Das return-Statement 237
7.4 Funktionen in einer Pipeline 239
7.4.1 Filter und Funktionen 240
7.4.2 Funktionen als Commandlets 242
7.5 Verwalten von Funktionen 243
7.6 Zu guter Letzt – Skripte 245
7.6.1 Übergabe von Argumenten an Skripte 246
7.6.2 Das param-Statement 247
7.6.3 Bereiche und Skripte 248
7.6.4 Skripte beenden und exit-Statement 249
7.6.5 Dotting von Skripten und Funktionen 251
7.7 Zusammenfassung 253
Skriptblöcke und Objekte 254
8.1 Skriptblock-Grundlagen 255
8.1.1 Aufruf von Befehlen 256
8.1.2 Zugriff auf CommandInfo- Objekte 256
8.1.3 Das Skriptblock Literal 259
8.1.4 Funktionen zur Laufzeit definieren 260
8.2 Erzeugen und Manipulieren von Objekten 262
8.2.1 Blick auf die Mitglieder 262
8.2.2 Synthetische Mitglieder 263
8.2.3 Objekte mit Add-Member erweitern 265
8.2.4 Das Select-Object-Commandlet 271
8.3 Arbeiten am Typsystem 274
8.3.1 Hinzufügen einer Eigenschaft 276
8.3.2 Shadowing vorhandener Eigenschaften 277
8.4 Die PowerShell-Sprache erweitern 278
8.4.1 Kleine Sprachen 278
8.4.2 Hinzufügen eines CustomClass-Schlüsselworts 279
8.5 Typerweiterung 284
8.6 Code zur Laufzeit generieren 286
8.6.1 Das Invoke-Expression-Commandlet 287
8.6.2 Die ExecutionContext-Variable 287
8.6.3 Erzeugen von Funktionen über das function: Laufwerk 290
8.7 Zusammenfassung 291
Fehler, Ausnahmen und Skript- Debugging 294
9.1 Fehlerbehandlung 295
9.1.1 ErrorRecords und ErrorStream 296
9.1.2 Die $error-Variable und der -ErrorVariable-Parameter 299
9.1.3 Die Variablen $? und $LASTEXITCODE 302
9.1.4 $ErrorActionPreference und der -ErrorAction-Parameter 305
9.2 Umgang mit Fehlern die die Ausführung beenden 308
9.2.1 Das trap-Statement 308
9.2.2 Das throw-Statement 311
9.3 Skript-Debugging 313
9.3.1 Debugging mit den Host-APIs 313
9.3.2 Das Set-PSDebug-Commandlet 315
9.3.3 Überwachen der Befehlsausführung 315
9.3.4 Schrittweise Überwachung der Ausführung von Anweisungen 318
9.3.5 Überwachen undefinierter Variablen im Strict-Modus 320
9.4 Eingebettete Prompts und Breakpoints 321
9.4.1 Abbrechen eines Skripts während des Schritt-Modus 321
9.4.2 Erstellen eines breakpoint-Befehls 323
9.4.3 Skript ruft Stack oder "Wie kam ich hierher?" 325
9.5 Low-Level- Überwachung 327
9.5.1 Das Trace-Command-Commandlet 328
9.5.2 Verfolgen von Typkonvertierungen 329
9.5.3 Überwachen der Parameterbindung 331
9.6 Das Ereignisprotokoll von PowerShell 335
9.6.1 Das Ereignisprotokoll untersuchen 335
9.6.2 Exchange 2007 und das PowerShell-Ereignisprotokoll 337
9.7 Zusammenfassung 338
Teil II: PowerShell anwenden 340
Verarbeitung von Texten, Dateien und XML 342
10.1 Verarbeiten von unstrukturiertem Text 342
10.1.1 Verwenden von System.String für das Arbeiten mit Text 342
10.1.2 Verwendung regulärer Ausdrücke zur Textmanipulation 349
10.2 Dateiverarbeitung 350
10.2.1 Arbeiten mit PSDrives 352
10.2.2 Arbeiten mit Pfaden die Wildcards enthalten 354
10.2.3 Lesen und Schreiben von Dateien 358
10.2.4 Suche in Dateien mit dem Select-String-Commandlet 365
10.3 XML-Verarbeitung 367
10.3.1 Verwendung von XML-Objekten 368
10.3.2 Laden und Speichern von XML-Dateien 372
10.3.3 XML-Dokumente in einer Pipeline verarbeiten 379
10.3.4 XPath verwenden 380
10.3.5 Die Import-Clixml- und Export-Clixml-Commandlets 385
10.4 Zusammenfassung 388
.NET und WinForms 390
11.1 .NET in PowerShell verwenden 390
11.1.1 .NET-Grundlagen 391
11.1.2 Arbeiten mit Assemblies 391
11.1.3 Auffinden von Typen 394
11.1.4 Instanzen von Typen erzeugen 396
11.1.5 PowerShell ist nicht C# – eine Moralgeschichte 399
11.1.6 Arbeiten mit generischen Typen 403
11.2 PowerShell und das Internet 407
11.2.1 Beispiel: Herunterladen einer Webseite 407
11.2.2 Beispiel: Ein RSS-Feed verarbeiten 408
11.2.3 Beispiel: Einen Webserver mit PowerShell schreiben 410
11.3 PowerShell und grafische Benutzerschnittstellen 417
11.3.1 WinForms-Grundlagen 418
11.3.2 Beispiel: "Mein erstes Formular" 419
11.3.3 Beispiel: Einfacher Dialog 421
11.3.4 Beispiel: Eine WinForms-Bibliothek 424
11.3.5 Beispiel: Ein einfacher Rechner 427
11.3.6 Beispiel: Daten anzeigen 432
11.3.7 Beispiel: Verwendung von GDI+ zur Grafikausgabe 435
11.4 Zusammenfassung 439
Windows Objekte: COM und WMI 440
12.1 COM in PowerShell verwenden 441
12.1.1 Windows-Automatisierung mit COM 443
12.1.2 Netzwerkzugriff, Office- Applikationen und Spielzeuge 455
12.1.3 Einsatz des ScriptControl-Objekts 466
12.1.4 Probleme mit COM 468
12.2 WMI und PowerShell 472
12.2.1 Was sind die WMI und was müssen wir beachten? 472
12.2.2 Das Get-WmiObject-Commandlet 473
12.2.3 Der WMI-Objektadapter 474
12.2.4 WMI-Elfmeterschießen – VBScript versus PowerShell 475
12.2.5 Die Shortcuts für WMI-Typen 480
12.2.6 Arbeiten mit WMI-Methoden 482
12.2.7 Arbeiten mit WMI-Events 484
12.2.8 Modifizierte WMI-Objekte zurückgeben 485
12.3 Welches Objektmodell sollte man verwenden? 487
12.4 Zusammenfassung 488
Sicherheit, Sicherheit, Sicherheit 490
13.1 Einführung in die Sicherheit 491
13.1.1 Was Sicherheit ist 491
13.1.2 Was Sicherheit nicht ist 491
13.1.3 Sicherheitsempfinden 491
13.2 Sicherheitsmodellierung 493
13.2.1 Einführung in das Modellieren von Bedrohungen 493
13.2.2 Klassifizieren von Bedrohungen mit dem STRIDE-Modell 494
13.2.3 Bedrohungen, Angriffsobjekte und Risiko-Minimierung 495
13.3 Absichern der PowerShell- Umgebung 499
13.3.1 Standardmäßige Sicherheit 499
13.3.2 Befehlspfad verwalten 500
13.3.3 Wahl der Ausführungs-Richtlinie für Skripte 501
13.4 Signieren von Skripten 503
13.4.1 Wie Public Key-Verschlüsselung und Hashing funktionieren 503
13.4.2 Signierende Autoritäten und Zertifikate 504
13.4.3 Erstellen eines selbst-signierten Zertifikats 505
13.4.4 Skripte mit einem Zertifikat signieren 509
13.4.5 Freigabe des Strong Private Key-Schutzes für Ihr Zertifikat 513
13.5 Sichere Skripte schreiben 516
13.5.1 Verwenden der SecureString-Klasse 517
13.5.2 Arbeiten mit Credentials 519
13.5.3 Vermeiden Sie Invoke-Expression 522
13.6 Zusammenfassung 525
PowerShell im Vergleich mit anderen Sprachen 528
A.1 PowerShell und CMD.EXE 528
A.1.1 Grundlegendes Navigieren und Dateioperationen 528
A.1.2 Variablen und Substitution 530
A.1.3 Befehle ausführen 532
A.1.4 Syntaktische Unterschiede 533
A.1.5 Textsuche: findstr und Select- String 534
A.1.6 Äquivalente für die For-Schleife 534
A.1.7 Batchdateien und Subroutinen 535
A.1.8 Den Prompt einstellen 537
A.1.9 Verwenden von doskey in PowerShell 538
A.1.10 Verwenden von cmd.exe in PowerShell 540
A.2 PowerShell und UNIX-Shells 541
A.2.1 Beispiel: Alle Prozesse anhalten 541
A.2.2 Beispiel: Stoppen einer gefilterten Prozessliste 542
A.2.3 Beispiel: Berechnen der Größe eines Verzeichnisses 542
A.2.4 Beispiel: Arbeiten mit dynamischen Werten 543
A.2.5 Beispiel: Die Lebenszeit eines Prozesses überwachen 544
A.2.6 Beispiel: Prüfen auf Pre-Release-Binärcode 544
A.2.7 Beispiel: Einen String in Großbuchstaben verwandeln 545
A.2.8 Beispiel: Text in einen String einfügen 545
A.3 PowerShell und Perl 546
A.4 PowerShell und C# 547
A.4.1 Aufruf von Funktionen und Befehlen 547
A.4.2 Methodenaufrufe 548
A.4.3 Rückgabe von Werten 548
A.4.4 Sichtbarkeit von Variablen 549
A.5 PowerShell und VBScript 549
Anhang B 552
Beispiele zum Administrieren 552
B.1 Active Directory-Infos abrufen 552
B.2 Installierte Software anzeigen 553
B.3 Terminal Server-Einstellungen bestimmen 554
B.4 Auflisten aller Hotfixes des aktuellen Computers 555
B.5 Computer mit fehlenden Hotfixes suchen 556
B.6 Ereignisprotokoll verwenden 559
B.6.1 Ein spezifisches EventLog-Objekt ermitteln 560
B.6.2 Das Ereignisprotokoll als Live-Objekt 560
B.6.3 Remote-Zugriff auf Ereignisprotokolle 561
B.6.4 Speichern von Ereignisprotokollen 562
B.6.5 Ereignisse schreiben 563
B.7 Arbeiten mit vorhandenen Dienstprogrammen 564
B.8 Arbeiten mit Active Directory und ADSI 566
B.8.1 Zugriff auf den Active Directory-Service 566
B.8.2 Benutzer hinzufügen 567
B.8.3 Benutzergruppe hinzufügen 568
B.8.4 User-Eigenschaften aktualisieren 570
B.8.5 User entfernen 571
B.9 Zusammenführen von zwei Datenmengen 572
Anhang C 574
Die PowerShell- Grammatik 574
C.1 Statement-Liste 574
C.2 Statement 575
C.2.1 Pipeline 575
C.2.2 Das if Statement 576
C.2.3 Das switch-Statement 577
C.2.4 Das foreach-Statement 577
C.2.5 Die for- und while-Statements 578
C.2.6 Die do/while- und do/until- Statements 578
C.2.7 Das trap-Statement 579
C.2.8 Das finally- Statement 579
C.2.9 Anweisungen zur Flusskontrolle 579
C.2.10 Funktionsdeklarationen 580
C.2.11 Parameterdeklarationen 580
C.3 Ausdruck 581
C.4 Wert 582
C.5 Tokenizer- Regeln 583
Index 586

Skriptblöcke und Objekte (S. 253-254)

"Habe nun, ach Philosophie, Juristerei und Medizin und leider auch Theologie durchaus studiert mit heißem Bemühn. Da steh ich nun, ich armer Tor! Und bin so klug als wie zuvor."
– Johann Wolfgang Goethe, Faust

Griechische Buchstaben sind cool …
– Zitat von Beavis und Butthead

Das vorangegangene Kapitel 7 hat die Basiselemente der Programmierung mit PowerShell behandelt: Funktionen und Skripte. Im vorliegenden Kapitel 8 begeben wir uns auf das nächsthöhere Niveau und werden über Metaprogrammierung diskutieren. Mit diesem Begriff beschreibt man das Entwickeln von Programmen die wiederum andere Programme schreiben oder manipulieren. Falls Sie noch nicht mit diesem Konzept vertraut sind werden Sie sich fragen, was Sie das überhaupt angeht. In Kapitel 1 sprachen wir über den Entwurf von Klassen und wie schwierig es ist, diese Aufgabe optimal zu bewältigen. In den meisten Umgebungen passiert es, dass der Entwickler einen Fehler macht und der User dann mit dem Resultat irgendwo steckenbleibt. Das gibt es in Power- Shell nicht. Metaprogrammierung erlaubt uns das Eindringen in die Tiefen des Systems. Dadurch können wir die Dinge so für uns arbeiten zu lassen wie wir das für richtig halten. Hier eine Analogie, die das verdeutlicht:

Stellen Sie sich vor Sie kaufen einen versiegelten Computer dessen Gehäuse Sie unter keinen Umständen öffnen dürfen. Sie können damit eine Menge tun – alle vorhandenen Programme laufen lassen und sogar neue Programme installieren. Aber es gibt viele Dinge die Sie damit nicht tun können. Falls der Computer über keine USB-Ports verfügt, können Sie auch keine hinzufügen. Wenn keine Hardware zur Videowiedergabe vorhanden ist, so können Sie das nicht ändern, denn das Gehäuse lässt sich nicht öffnen. Auch wenn die meisten Leute Ihren Computer mit der benötigten Grundausstattung kaufen und niemals neue Hardware hinzufügen, ein Gehäuse das Sie nicht öffnen können erlaubt auch keinerlei Eingriffe bzw. Reparaturen an der vorhandenen Hardware. Traditionelle Programmiersprachen ähneln einem versiegelten Computer, sie haben eine Grundausstattung mit verschiedenen Features und während Sie den Einsatzbereich durch Hinzufügen verschiedener Bibliotheken ausdehnen können, ist es Ihnen nicht möglich, die Kernfunktionalitäten der Sprache zu erweitern. So können Sie zum Beispiel nicht den neuen Typ einer Schleifenanwei- sung hinzufügen. In einer Sprache, die Metaprogrammierung unterstützt, können Sie allerdings solche Aktivitäten unternehmen und z.B. neue Kontrollstrukturen hinzufügen. Auf diese Weise wurden z.B. auch die Where-Object- und Foreach-Object-Commandlets implementiert. Diese benutzen die Features der Metaprogrammierung um neue Sprachelemente hinzuzufügen. Sie können sogar Ihre eigenen Befehlsversionen kreieren. Metaprogrammierung ist eines der Features die eine dynamische Sprache wie PowerShell extrem leistungsfähig machen. Dies schlägt sich in dramatischen Verbesserungen nieder, die sich in vereinfachten Konzepten und elegantem Code ausdrücken. Investieren Sie die Zeit um die Metaprogrammierung mit PowerShell zu erlernen und Sie erhöhen Ihre Produktivität beim Anwenden von PowerShell gewaltig! Nun lasst uns damit beginnen das "Gehäuse" von PowerShell zu knacken.

Wir beginnen mit einem zentralen Feature der PowerShell-Sprache, dem Skriptblock. Diese Diskussion nimmt den ersten Teil des Kapitels in Anspruch und legt das Fundament für den Rest des Kapitels. Mit den Basismaterialien ausgestattet machen wir uns auf den Weg und schauen wie und wo das Skriptblock-Feature in PowerShell angewendet wird. Wir betrachten die Rolle von Skriptblöcken beim Erzeugen benutzerdefinierter Objekte und Typen und wie sie zum Erweitern der PowerShell-Sprache eingesetzt werden können. Wir gehen ein Beispiel durch welches weniger als hundert Zeilen Skriptcode braucht um ein neues "Schlüsselwort" hinzuzufügen, welches das Definieren eigener Klassen erlaubt. Wir behandeln ebenfalls verschiedene Commandlets die diese Objekte benutzen und beenden das Thema mit dem Betrachten einiger Programmiermuster welche die Vorteile von Skriptblocks ausnutzen. Programmiermuster (Programming Pattern) beschreiben allgemeine Vorgehensweisen zur Lösung spezieller Problemklassen. Zunächst aber müssen wir das Wesen der Skriptblöcke verstehen.

8.1 Skriptblock-Grundlagen

In diesem Abschnitt unterhalten wir uns darüber wie man Skriptblöcke erzeugt und verwendet. Zunächst schauen wir, wie Befehle aufgerufen werden, sodass wir auch die Möglichkeiten zum Aufrufen von Skriptblöcken verstehen lernen. Als Nächstes wollen wir die die Syntax für Skriptblock- Literale besprechen und die verschiedenen Typen von Skriptblöcken die Sie erzeugen können. Inbegriffen ist auch die Verwendung von Skriptblöcken als Funktionen, als Filter und als Commandlets. Schließlich betrachten wir noch wie man mit Skriptblöcken neue Funktionen zur Laufzeit definieren kann. Lassen Sie uns nun zum Thema kommen und mit den Definitionen beginnen.

In PowerShell ist der Skriptblock der Schlüssel zur Metaprogrammierung (Programme schreiben, die andere Programme schreiben oder manipulieren). Der Skriptblock ist ein Block mit Skriptcode der zwar als Objektreferenz existiert aber keinen Namen erfordert. Die Implementierungen von Where-Object- und Foreach-Object-Commandlets sind von Skriptblöcken abhängig.