Windows PowerShell 4.0

1 - Inhalt [Seite 7]
2 - Vorwort zur vierten Auflage 2014 [Seite 21]
2.1 - Wer bin ich? [Seite 21]
2.2 - Wer sind Sie? [Seite 21]
2.3 - Was ist neu in diesem Buch? [Seite 22]
2.4 - Wem ist zu danken? [Seite 22]
2.5 - Woher bekommen Sie die Beispiele aus diesem Buch? [Seite 23]
2.6 - Wo kann ich mich schulen oder beraten lassen? [Seite 23]
2.7 - Zum Schluss des Vorworts ..... [Seite 23]
3 - Über den Autor Dr. Holger Schwichtenberg [Seite 25]
4 - Über den Co-Autor Peter Monadjemi [Seite 26]
5 - 1 Erste Schritte mit der Windows PowerShell [Seite 29]
5.1 - 1.1 Was ist die Windows PowerShell? [Seite 29]
5.2 - 1.2 Geschichte der Windows PowerShell [Seite 30]
5.3 - 1.3 Motivation zur Windows PowerShell [Seite 30]
5.4 - 1.4 Betriebssysteme mit vorinstallierter ­PowerShell [Seite 33]
5.5 - 1.5 PowerShell herunterladen und installieren auf anderen Betriebssystemen [Seite 35]
5.6 - 1.6 Die Windows PowerShell testen [Seite 38]
5.7 - 1.7 Woher kommen die Commandlets? [Seite 43]
5.8 - 1.8 PowerShell Community Extensions (PSCX) herunterladen und installieren [Seite 44]
5.9 - 1.9 Den PowerShell-Editor "ISE" verwenden [Seite 45]
6 - 2 Architektur der Windows PowerShell [Seite 49]
7 - 3 Einzelbefehle der PowerShell [Seite 53]
7.1 - 3.1 Commandlets [Seite 53]
7.2 - 3.2 Aliase [Seite 61]
7.3 - 3.3 Ausdrücke [Seite 68]
7.4 - 3.4 Externe Befehle [Seite 69]
7.5 - 3.5 Dateinamen [Seite 70]
8 - 4 Hilfefunktionen [Seite 73]
8.1 - 4.1 Auflisten der verfügbaren Befehle [Seite 73]
8.2 - 4.2 Erläuterungen zu den Befehlen [Seite 76]
8.3 - 4.3 Hilfe zu Parametern [Seite 77]
8.4 - 4.4 Hilfe mit Show-Command [Seite 77]
8.5 - 4.5 Hilfefenster [Seite 78]
8.6 - 4.6 Aktualisieren der Hilfedateien [Seite 79]
8.7 - 4.7 Online-Hilfe [Seite 81]
8.8 - 4.8 Dokumentation der .NET-Klassen [Seite 81]
9 - 5 Objektorientiertes Pipelining [Seite 85]
9.1 - 5.1 Pipeline-Operator [Seite 85]
9.2 - 5.2 .NET-Objekte in der Pipeline [Seite 86]
9.3 - 5.3 Pipeline Processor [Seite 88]
9.4 - 5.4 Pipelining von Parametern [Seite 89]
9.5 - 5.5 Pipelining von klassischen Befehlen [Seite 91]
9.6 - 5.6 Anzahl der Objekte in der Pipeline [Seite 92]
9.7 - 5.7 Zugriff auf einzelne Objekte aus einer Menge [Seite 92]
9.8 - 5.8 Zugriff auf einzelne Werte in einem Objekt [Seite 94]
9.9 - 5.9 Methoden ausführen [Seite 95]
9.10 - 5.10 Analyse des Pipeline-Inhalts [Seite 97]
9.11 - 5.11 Filtern [Seite 108]
9.12 - 5.12 Zusammenfassung von Pipeline-Inhalten [Seite 111]
9.13 - 5.13 "Kastrierung" von Objekten in der Pipeline [Seite 111]
9.14 - 5.14 Sortieren [Seite 112]
9.15 - 5.15 Duplikate entfernen [Seite 113]
9.16 - 5.16 Gruppierung [Seite 114]
9.17 - 5.17 Berechnungen [Seite 115]
9.18 - 5.18 Zwischenschritte in der Pipeline mit Variablen [Seite 116]
9.19 - 5.19 Verzweigungen in der Pipeline [Seite 117]
9.20 - 5.20 Vergleiche zwischen Objekten [Seite 119]
9.21 - 5.21 Praxisbeispiele [Seite 119]
10 - 6 PowerShell-Skripte [Seite 121]
10.1 - 6.1 Skriptdateien [Seite 121]
10.2 - 6.2 Start eines Skripts [Seite 123]
10.3 - 6.3 Aliase für Skripte verwenden [Seite 124]
10.4 - 6.4 Parameter für Skripte [Seite 125]
10.5 - 6.5 Skripte dauerhaft einbinden (Dot Sourcing) [Seite 126]
10.6 - 6.6 Sicherheitsfunktionen für PowerShell-Skripte [Seite 127]
10.7 - 6.7 Skripte anhalten [Seite 130]
11 - 7 PowerShell-Skriptsprache [Seite 131]
11.1 - 7.1 Hilfe zur PowerShell-Skriptsprache [Seite 131]
11.2 - 7.2 Befehlstrennung [Seite 132]
11.3 - 7.3 Kommentare [Seite 132]
11.4 - 7.4 Variablen [Seite 133]
11.5 - 7.5 Variablenbedingungen [Seite 139]
11.6 - 7.6 Zahlen [Seite 140]
11.7 - 7.7 Zeichenketten [Seite 142]
11.8 - 7.8 Reguläre Ausdrücke [Seite 147]
11.9 - 7.9 Datum und Uhrzeit [Seite 154]
11.10 - 7.10 Arrays und assoziative Arrays (Hash-Tabelle) [Seite 155]
11.11 - 7.11 Operatoren [Seite 158]
11.12 - 7.12 Überblick über die Kontrollkonstrukte [Seite 160]
11.13 - 7.13 Schleifen [Seite 160]
11.14 - 7.14 Bedingungen [Seite 165]
11.15 - 7.15 Unterroutinen (Prozedur/Funktionen) [Seite 167]
11.16 - 7.16 Eingebaute Funktionen [Seite 173]
11.17 - 7.17 Fehlerbehandlung [Seite 173]
12 - 8 Ausgaben [Seite 181]
12.1 - 8.1 Ausgabe-Commandlets [Seite 181]
12.2 - 8.2 Out-GridView [Seite 183]
12.3 - 8.3 Standardausgabe [Seite 185]
12.4 - 8.4 Einschränkung der Ausgabe [Seite 187]
12.5 - 8.5 Seitenweise Ausgabe [Seite 187]
12.6 - 8.6 Ausgabe einzelner Werte [Seite 188]
12.7 - 8.7 Details zum Ausgabeoperator [Seite 190]
12.8 - 8.8 Benutzerdefinierte Tabellenformatierung [Seite 193]
12.9 - 8.9 Ausgabe von Methodenergebnissen und Unterobjekten in Pipelines [Seite 194]
12.10 - 8.10 Ausgabe von Methodenergebnissen und Unterobjekten in Zeichenketten [Seite 194]
12.11 - 8.11 Unterdrückung der Ausgabe [Seite 195]
12.12 - 8.12 Ausgaben an Drucker [Seite 196]
12.13 - 8.13 Ausgaben in Dateien [Seite 196]
12.14 - 8.14 Umleitungen (Redirection) [Seite 197]
13 - 9 Benutzereingaben [Seite 199]
13.1 - 9.1 Read-Host [Seite 199]
13.2 - 9.2 Grafischer Eingabedialog [Seite 200]
13.3 - 9.3 Dialogfenster [Seite 200]
13.4 - 9.4 Authentifizierungsdialog [Seite 201]
14 - 10 Das PowerShell-Navigationsmodell [Seite 203]
14.1 - 10.1 Einführungsbeispiel: Navigation in der Registrierungsdatenbank [Seite 203]
14.2 - 10.2 Provider und Laufwerke [Seite 204]
14.3 - 10.3 Navigationsbefehle [Seite 206]
14.4 - 10.4 Pfadangaben [Seite 207]
14.5 - 10.5 Beispiel [Seite 209]
14.6 - 10.6 Eigene Laufwerke definieren [Seite 210]
15 - 11 PowerShell-Werkzeuge [Seite 211]
15.1 - 11.1 PowerShell-Standardkonsole [Seite 211]
15.2 - 11.2 PowerShell Integrated Scripting ­Environment (ISE) [Seite 216]
15.3 - 11.3 CIM Explorer for PowerShell ISE [Seite 222]
15.4 - 11.4 PowerShell Web Access (PSWA) [Seite 223]
15.5 - 11.5 PowerShellPlus [Seite 229]
15.6 - 11.6 PoshConsole [Seite 232]
15.7 - 11.7 PowerGUI [Seite 233]
15.8 - 11.8 PowerShell Analyzer [Seite 234]
15.9 - 11.9 PrimalScript [Seite 235]
15.10 - 11.10 PowerShell Help [Seite 237]
15.11 - 11.11 PowerShell Help Reader [Seite 237]
15.12 - 11.12 PowerTab [Seite 238]
15.13 - 11.13 NuGet Package Manager [Seite 238]
15.14 - 11.14 PowerShell Tools for Visual Studio [Seite 239]
15.15 - 11.15 PowerShell Remoting [Seite 240]
15.16 - 11.16 Vergleich der Skripteditoren [Seite 240]
16 - 12 Fernausführung (Remoting) [Seite 245]
16.1 - 12.1 Fernabfrage ohne WS-Management [Seite 246]
16.2 - 12.2 Anforderungen [Seite 247]
16.3 - 12.3 Rechte für Fernaufrufe [Seite 248]
16.4 - 12.4 Einrichten von WinRM [Seite 249]
16.5 - 12.5 Überblick über die Fernausführungs-Commandlets [Seite 251]
16.6 - 12.6 Interaktive Fernverbindungen im Telnet-Stil [Seite 251]
16.7 - 12.7 Fernausführung von Befehlen [Seite 252]
16.8 - 12.8 Fernausführung von Skripten [Seite 256]
16.9 - 12.9 Ausführung auf mehreren Computern [Seite 257]
16.10 - 12.10 Sitzungen [Seite 258]
16.11 - 12.11 Zugriff auf entfernte Computer außerhalb der eigenen Domäne [Seite 262]
16.12 - 12.12 Verwaltung des WS-Management-Dienstes [Seite 266]
17 - 13 Verwendung von .NET-Klassen [Seite 269]
17.1 - 13.1 Microsoft Developer Network (MSDN) [Seite 269]
17.2 - 13.2 Erzeugen von Instanzen [Seite 270]
17.3 - 13.3 Parameterbehaftete Konstruktoren [Seite 271]
17.4 - 13.4 Initialisierung von Objekten [Seite 272]
17.5 - 13.5 Nutzung von Attributen und Methoden [Seite 273]
17.6 - 13.6 Statische Mitglieder in .NET-Klassen und statische .NET-Klassen [Seite 275]
17.7 - 13.7 Zugriff auf bestehende Objekte [Seite 277]
17.8 - 13.8 Laden von Assemblies [Seite 278]
17.9 - 13.9 Objektanalyse [Seite 279]
17.10 - 13.10 Auflistungen (Enumerationen) [Seite 280]
17.11 - 13.11 Verknüpfen von Aufzählungswerten [Seite 281]
18 - 14 Verwendung von COM-Klassen [Seite 283]
18.1 - 14.1 Erzeugen von Instanzen [Seite 283]
18.2 - 14.2 Nutzung von Attributen und Methoden [Seite 284]
18.3 - 14.3 Holen bestehender Instanzen [Seite 285]
19 - 15 Zugriff auf die Windows Management Instrumentation (WMI) [Seite 287]
19.1 - 15.1 Einführung in WMI [Seite 287]
19.2 - 15.2 WMI in der Windows PowerShell [Seite 313]
19.3 - 15.3 Abruf von WMI-Objektmengen [Seite 314]
19.4 - 15.4 Fernzugriffe [Seite 315]
19.5 - 15.5 Filtern und Abfragen [Seite 315]
19.6 - 15.6 Liste aller WMI-Klassen [Seite 319]
19.7 - 15.7 Hintergrundwissen: WMI-Klassenprojektion mit dem PowerShell-WMI-Objektadapter [Seite 320]
19.8 - 15.8 Beschränkung der Ausgabeliste bei WMI-Objekten [Seite 323]
19.9 - 15.9 Zugriff auf einzelne Mitglieder von WMI-Klassen [Seite 325]
19.10 - 15.10 Werte setzen in WMI-Objekten [Seite 325]
19.11 - 15.11 Umgang mit WMI-Datumsangaben [Seite 327]
19.12 - 15.12 Methodenaufrufe [Seite 328]
19.13 - 15.13 Neue WMI-Instanzen erzeugen [Seite 329]
19.14 - 15.14 Instanzen entfernen [Seite 330]
19.15 - 15.15 Commandlet Definition XML-Datei (CDXML) [Seite 331]
20 - 16 Dynamische Objekte [Seite 333]
20.1 - 16.1 Erweitern bestehender Objekte [Seite 333]
20.2 - 16.2 Komplett dynamische Objekte [Seite 335]
21 - 17 Einbinden von C# und VB.NET [Seite 337]
22 - 18 Win32-API-Aufrufe [Seite 339]
23 - 19 Fehlersuche [Seite 343]
23.1 - 19.1 Detailinformationen [Seite 343]
23.2 - 19.2 Einzelschrittmodus [Seite 344]
23.3 - 19.3 Zeitmessung [Seite 345]
23.4 - 19.4 Ablaufverfolgung [Seite 346]
23.5 - 19.5 Kommandozeilenbasiertes Script-Debugging [Seite 346]
24 - 20 Transaktionen [Seite 349]
24.1 - 20.1 Commandlets für Transaktionen [Seite 349]
24.2 - 20.2 Start und Ende einer Transaktion [Seite 350]
24.3 - 20.3 Zurücksetzen der Transaktion [Seite 351]
24.4 - 20.4 Mehrere Transaktionen [Seite 352]
25 - 21 Hintergrundaufträge ("Jobs") [Seite 353]
25.1 - 21.1 Voraussetzungen [Seite 353]
25.2 - 21.2 Architektur [Seite 354]
25.3 - 21.3 Starten eines Hintergrundauftrags [Seite 354]
25.4 - 21.4 Hintergrundaufträge abfragen [Seite 355]
25.5 - 21.5 Warten auf einen Hintergrundauftrag [Seite 356]
25.6 - 21.6 Abbrechen und Löschen von Aufträgen [Seite 356]
25.7 - 21.7 Analyse von Fehlermeldungen [Seite 357]
25.8 - 21.8 Fernausführung von Hintergrundaufträgen [Seite 357]
26 - 22 Geplante Aufgaben und zeitgesteuerte Jobs [Seite 359]
26.1 - 22.1 Geplante Aufgaben (Scheduled Tasks) [Seite 359]
26.2 - 22.2 Zeitgesteuerte Jobs [Seite 363]
27 - 23 PowerShell-Workflows [Seite 369]
27.1 - 23.1 Ein erstes Beispiel [Seite 369]
27.2 - 23.2 Unterschiede zu einer Function bzw. einem Skript [Seite 374]
27.3 - 23.3 Einschränkungen bei Workflows [Seite 374]
27.4 - 23.4 Workflows in der Praxis [Seite 376]
27.5 - 23.5 Workflows in Visual Studio erstellen [Seite 383]
28 - 24 Ereignissystem [Seite 401]
28.1 - 24.1 WMI-Ereignisse [Seite 401]
28.2 - 24.2 WMI-Ereignisabfragen [Seite 401]
28.3 - 24.3 WMI-Ereignisse ab PowerShell 1.0 [Seite 403]
28.4 - 24.4 Registrieren von WMI-Ereignisquellen seit PowerShell 2.0 [Seite 404]
28.5 - 24.5 Auslesen der Ereignisliste [Seite 405]
28.6 - 24.6 Reagieren auf Ereignisse [Seite 407]
28.7 - 24.7 WMI-Ereignisse ab PowerShell-Version 3.0 [Seite 409]
28.8 - 24.8 Registrieren von .NET-Ereignissen [Seite 409]
28.9 - 24.9 Erzeugen von Ereignissen [Seite 410]
29 - 25 Datenbereiche und Datendateien [Seite 413]
29.1 - 25.1 Datenbereiche [Seite 413]
29.2 - 25.2 Datendateien [Seite 415]
29.3 - 25.3 Mehrsprachigkeit/Lokalisierung [Seite 416]
30 - 26 Desired State Configuration (DSC) [Seite 419]
30.1 - 26.1 Grundprinzipien [Seite 420]
30.2 - 26.2 Ressourcen [Seite 420]
30.3 - 26.3 Eigenschaften eines Ressourcentyps [Seite 421]
30.4 - 26.4 Aufbau einer DSC-Datei [Seite 421]
30.5 - 26.5 Ein erstes DSC-Beispiel [Seite 422]
30.6 - 26.6 Anwendung einer DSC-Datei [Seite 422]
30.7 - 26.7 Parameter für DSC-Dateien [Seite 424]
30.8 - 26.8 Verfügbare DSC-Ressourcentypen [Seite 425]
30.9 - 26.9 Commandlets für die Arbeit mit DSC [Seite 427]
30.10 - 26.10 DSC-Interna [Seite 427]
30.11 - 26.11 DSC-Praxisbeispiel 1: IIS installieren [Seite 428]
30.12 - 26.12 DSC-Praxisbeispiel 2: Software installieren [Seite 429]
30.13 - 26.13 DSC-Praxisbeispiel 3: Software deinstallieren [Seite 431]
31 - 27 PowerShell-Snap-Ins [Seite 433]
31.1 - 27.1 Einbinden von Snap-Ins [Seite 433]
31.2 - 27.2 Liste der Commandlets [Seite 437]
31.3 - 27.3 Doppeldeutige Namen [Seite 438]
32 - 28 PowerShell-Module [Seite 439]
32.1 - 28.1 Überblick über die Commandlets [Seite 439]
32.2 - 28.2 Modularchitektur [Seite 440]
32.3 - 28.3 Module installieren [Seite 441]
32.4 - 28.4 Auflisten der verfügbaren Module [Seite 441]
32.5 - 28.5 Importieren von Modulen [Seite 443]
32.6 - 28.6 Entfernen von Modulen [Seite 446]
33 - 29 Ausgewählte PowerShell-Erweiterungen [Seite 447]
33.1 - 29.1 PowerShell-Module in Windows 7 und Windows Server 2008 R2 [Seite 447]
33.2 - 29.2 PowerShell-Module in Windows 8.x und Windows Server 2012/2012 R2 [Seite 449]
33.3 - 29.3 BITSTransfer [Seite 453]
33.4 - 29.4 Windows Server Backup [Seite 454]
33.5 - 29.5 PowerShell Diagnostics [Seite 454]
33.6 - 29.6 Windows PowerShell Community-Extensions [Seite 455]
33.7 - 29.7 PowerShellPack [Seite 459]
33.8 - 29.8 www.IT-Visions.de PowerShell­Extensions [Seite 460]
33.9 - 29.9 Quest Management Shell for Active Directory [Seite 461]
33.10 - 29.10 Microsoft Exchange Server [Seite 462]
33.11 - 29.11 System Center Virtual Machine­Manager [Seite 463]
33.12 - 29.12 PowerShell Management Library for Hyper-V (pshyperv) [Seite 464]
33.13 - 29.13 Powershell Outlook Account Manager [Seite 465]
33.14 - 29.14 PowerShell Configurator (PSConfig) [Seite 465]
33.15 - 29.15 Weitere Erweiterungen [Seite 466]
34 - 30 Tipps und Tricks zur PowerShell [Seite 467]
34.1 - 30.1 Befehlsgeschichte [Seite 467]
34.2 - 30.2 System- und Hostinformationen [Seite 468]
34.3 - 30.3 Alle Anzeigen löschen [Seite 469]
34.4 - 30.4 Anpassen der Eingabeaufforderung (Prompt) [Seite 469]
34.5 - 30.5 Profileinstellungen für die PowerShell-Konsole [Seite 470]
34.6 - 30.6 PowerShell als Gruppenrichtlinien-Skripte [Seite 474]
34.7 - 30.7 Einblicke in die Interna der Pipeline-Verarbeitung [Seite 477]
35 - 31 Dateisystem [Seite 481]
35.1 - 31.1 Laufwerke [Seite 482]
35.2 - 31.2 Ordnerinhalte [Seite 486]
35.3 - 31.3 Kurznamen [Seite 488]
35.4 - 31.4 Dateisystemoperationen [Seite 488]
35.5 - 31.5 Dateieigenschaften lesen [Seite 489]
35.6 - 31.6 Datei-Hash [Seite 490]
35.7 - 31.7 Finden von Duplikaten [Seite 490]
35.8 - 31.8 Dateieigenschaften verändern [Seite 493]
35.9 - 31.9 Verknüpfungen im Dateisystem [Seite 495]
35.10 - 31.10 Komprimierung [Seite 498]
35.11 - 31.11 Dateisystemfreigaben [Seite 500]
35.12 - 31.12 Überwachung des Dateisystems [Seite 509]
36 - 32 Festplattenverschlüsselung mit Bitlocker [Seite 511]
36.1 - 32.1 Übersicht über das BitLocker-Modul [Seite 512]
36.2 - 32.2 Verschlüsseln eines Laufwerks [Seite 513]
37 - 33 Dokumente [Seite 515]
37.1 - 33.1 Textdateien [Seite 515]
37.2 - 33.2 Binärdateien [Seite 516]
37.3 - 33.3 CSV-Dateien [Seite 516]
37.4 - 33.4 INI-Dateien [Seite 518]
37.5 - 33.5 XML-Dateien [Seite 519]
37.6 - 33.6 HTML-Dateien [Seite 527]
38 - 34 Datenbanken [Seite 529]
38.1 - 34.1 ADO.NET-Grundlagen [Seite 529]
38.2 - 34.2 Beispieldatenbank [Seite 535]
38.3 - 34.3 Datenzugriff mit den Bordmitteln der PowerShell [Seite 536]
38.4 - 34.4 Datenzugriff mit den PowerShell-Erweiterungen [Seite 547]
38.5 - 34.5 Datenbankzugriff mit SQLPS [Seite 550]
38.6 - 34.6 Datenbankzugriff mit SQLPSX [Seite 550]
39 - 35 Microsoft SQL Server-Administration [Seite 551]
39.1 - 35.1 PowerShell-Integration im SQL Server Management Studio [Seite 552]
39.2 - 35.2 SQL-Server-Laufwerk "SQLSERVER:" [Seite 553]
39.3 - 35.3 Die SQLPS-Commandlets [Seite 556]
39.4 - 35.4 Die SQL Server Management Objects (SMO) [Seite 558]
39.5 - 35.5 SQLPSX [Seite 561]
39.6 - 35.6 Microsoft SQL Server-Administration mit der PowerShell in der Praxis [Seite 569]
40 - 36 ODBC-Datenquellen [Seite 575]
40.1 - 36.1 ODBC-Treiber und -Datenquellen auflisten [Seite 576]
40.2 - 36.2 Anlegen einer ODBC-Datenquelle [Seite 577]
40.3 - 36.3 Zugriff auf eine ODBC-Datenquelle [Seite 578]
41 - 37 Registrierungsdatenbank (Registry) [Seite 581]
41.1 - 37.1 Schlüssel auslesen [Seite 581]
41.2 - 37.2 Schlüssel anlegen und löschen [Seite 582]
41.3 - 37.3 Laufwerke definieren [Seite 582]
41.4 - 37.4 Werte anlegen und löschen [Seite 583]
41.5 - 37.5 Werte auslesen [Seite 584]
41.6 - 37.6 Praxisbeispiel [Seite 584]
42 - 38 Computerverwaltung [Seite 587]
42.1 - 38.1 Computerinformationen [Seite 587]
42.2 - 38.2 Computername und Domäne [Seite 589]
42.3 - 38.3 Herunterfahren und Neustarten [Seite 590]
42.4 - 38.4 Wiederherstellungspunkte verwalten [Seite 590]
43 - 39 Hardwareverwaltung [Seite 593]
43.1 - 39.1 Hardwarebausteine [Seite 593]
43.2 - 39.2 Druckerverwaltung (ältere Betriebssysteme) [Seite 595]
43.3 - 39.3 Druckerverwaltung (Windows 8.x und Windows Server 2012/2012 R2) [Seite 596]
44 - 40 Softwareverwaltung [Seite 599]
44.1 - 40.1 Softwareinventarisierung [Seite 599]
44.2 - 40.2 Installation von Anwendungen [Seite 602]
44.3 - 40.3 Deinstallation von Anwendungen [Seite 603]
44.4 - 40.4 Praxisbeispiel: Installationstest [Seite 603]
44.5 - 40.5 Versionsnummer ermitteln [Seite 604]
44.6 - 40.6 Servermanager [Seite 605]
44.7 - 40.7 Softwareeinschränkungen mit dem PowerShell-Modul "AppLocker" [Seite 616]
45 - 41 Prozessverwaltung [Seite 623]
45.1 - 41.1 Prozesse auflisten [Seite 623]
45.2 - 41.2 Prozesse starten [Seite 624]
45.3 - 41.3 Prozesse beenden [Seite 626]
45.4 - 41.4 Warten auf das Beenden einer Anwendung [Seite 626]
46 - 42 Systemdienste [Seite 629]
46.1 - 42.1 Dienste auflisten [Seite 629]
46.2 - 42.2 Dienstzustand ändern [Seite 631]
46.3 - 42.3 Diensteigenschaften ändern [Seite 632]
47 - 43 Netzwerk [Seite 633]
47.1 - 43.1 Netzwerkkonfiguration (ältere Betriebssysteme) [Seite 633]
47.2 - 43.2 Netzwerkkonfiguration (ab Windows 8.x und Windows Server 2012 (inkl. R2) [Seite 635]
47.3 - 43.3 DNS-Client-Konfiguration [Seite 637]
47.4 - 43.4 DNS-Namensauflösung [Seite 641]
47.5 - 43.5 Erreichbarkeit prüfen (Ping) [Seite 642]
47.6 - 43.6 Windows Firewall [Seite 644]
47.7 - 43.7 E-Mails senden (SMTP) [Seite 650]
47.8 - 43.8 Abruf von Daten von einem HTTP-Server [Seite 652]
47.9 - 43.9 Aufrufe von SOAP-Webdiensten [Seite 653]
48 - 44 Ereignisprotokolle [Seite 657]
48.1 - 44.1 Protokolleinträge auslesen [Seite 657]
48.2 - 44.2 Ereignisprotokolle erzeugen [Seite 659]
48.3 - 44.3 Protokolleinträge erzeugen [Seite 659]
48.4 - 44.4 Protokollgröße festlegen [Seite 659]
48.5 - 44.5 Protokolleinträge löschen [Seite 659]
49 - 45 Leistungsdaten [Seite 661]
49.1 - 45.1 Zugriff auf Leistungsindikatoren über WMI [Seite 661]
49.2 - 45.2 Get-Counter [Seite 662]
50 - 46 Sicherheitseinstellungen [Seite 665]
50.1 - 46.1 Grundlagen [Seite 665]
50.2 - 46.2 Zugriffsrechtelisten auslesen [Seite 670]
50.3 - 46.3 Einzelne Rechteeinträge auslesen [Seite 672]
50.4 - 46.4 Besitzer auslesen [Seite 673]
50.5 - 46.5 Benutzer und SID [Seite 673]
50.6 - 46.6 Hinzufügen eines Rechteeintrags zu einer Zugriffsrechteliste [Seite 677]
50.7 - 46.7 Entfernen eines Rechteeintrags aus einer Zugriffsrechteliste [Seite 679]
50.8 - 46.8 Zugriffsrechteliste übertragen [Seite 681]
50.9 - 46.9 Zugriffsrechteliste über SDDL setzen [Seite 681]
51 - 47 Active Directory [Seite 683]
51.1 - 47.1 Benutzer- und Gruppenverwaltung mit WMI [Seite 684]
51.2 - 47.2 Einführung in System.DirectoryServices [Seite 685]
51.3 - 47.3 Basiseigenschaften [Seite 696]
51.4 - 47.4 Benutzer- und Gruppenverwaltung im Active Directory [Seite 698]
51.5 - 47.5 Verwaltung der Organisationseinheiten [Seite 706]
51.6 - 47.6 Suche im Active Directory [Seite 707]
51.7 - 47.7 Navigation im Active Directory mit den PowerShell Extensions [Seite 714]
51.8 - 47.8 Verwendung der Active-Directory-Erwei­terungen von www.IT-Visions.de [Seite 715]
51.9 - 47.9 PowerShell-Modul "Active Directory" (ADPowerShell) [Seite 717]
51.10 - 47.10 PowerShell-Modul "ADDSDeployment" [Seite 736]
51.11 - 47.11 Informationen über die Active-­Directory-Struktur [Seite 739]
52 - 48 Gruppenrichtlinien [Seite 743]
52.1 - 48.1 Verwaltung der Gruppenrichtlinien [Seite 744]
52.2 - 48.2 Verknüpfung der Gruppenrichtlinien [Seite 745]
52.3 - 48.3 Gruppenrichtlinienberichte [Seite 747]
52.4 - 48.4 Gruppenrichtlinienvererbung [Seite 748]
52.5 - 48.5 Weitere Möglichkeiten [Seite 749]
53 - 49 Virtuelle Systeme mit Hyper-V [Seite 751]
53.1 - 49.1 Das Hyper-V-Modul von Microsoft [Seite 752]
53.2 - 49.2 Die ersten Schritte mit dem Hyper-V-Modul [Seite 754]
53.3 - 49.3 Virtuelle Maschinen anlegen [Seite 758]
53.4 - 49.4 Umgang mit virtuellen Festplatten [Seite 764]
53.5 - 49.5 Konfiguration virtueller Maschinen [Seite 767]
53.6 - 49.6 PowerShell Management Library for Hyper-V (für ältere Betriebssysteme) [Seite 771]
54 - 50 Internet Information Server (IIS) [Seite 775]
54.1 - 50.1 Überblick [Seite 775]
54.2 - 50.2 Navigationsprovider [Seite 777]
54.3 - 50.3 Anlegen von Websites [Seite 779]
54.4 - 50.4 Massenanlegen von Websites [Seite 780]
54.5 - 50.5 Ändern von Eigenschaften von Websites [Seite 782]
54.6 - 50.6 Anwendungspool anlegen [Seite 783]
54.7 - 50.7 Virtuelle Verzeichnisse und IIS-Anwendungen [Seite 784]
54.8 - 50.8 Website-Zustand ändern [Seite 784]
54.9 - 50.9 Anwendungspools starten und stoppen [Seite 785]
54.10 - 50.10 Löschen von Websites [Seite 785]
55 - 51 Microsoft Exchange Server [Seite 787]
55.1 - 51.1 Daten abrufen [Seite 787]
55.2 - 51.2 Postfächer verwalten [Seite 788]
55.3 - 51.3 Öffentliche Ordner verwalten [Seite 789]
56 - 52 Optimierungen und Problemlösungen [Seite 791]
56.1 - 52.1 PowerShell-Modul "TroubleshootingPack" [Seite 791]
56.2 - 52.2 PowerShell-Modul "Best Practices" [Seite 795]
57 - 53 Grafische Benutzeroberflächen [Seite 797]
57.1 - 53.1 Eingabemasken [Seite 797]
57.2 - 53.2 Universelle Objektdarstellung [Seite 799]
57.3 - 53.3 Zwischenablage [Seite 800]
57.4 - 53.4 WPF PowerShell Kit (WPK) [Seite 801]
58 - 54 Entwicklung von Commandlets in der PowerShell-Sprache [Seite 813]
58.1 - 54.1 Aufbau eines skriptbasierten Commandlets [Seite 813]
58.2 - 54.2 Parameterfestlegung [Seite 816]
58.3 - 54.3 Auszeichnung der Parameterdefinitionen [Seite 821]
58.4 - 54.4 Dokumentation [Seite 824]
59 - 55 Entwicklung eigener Commandlets mit C# [Seite 827]
59.1 - 55.1 Technische Voraussetzungen [Seite 827]
59.2 - 55.2 Grundkonzept der .NET-basierten ­Commandlets [Seite 829]
59.3 - 55.3 Schrittweise Erstellung eines minimalen Commandlets [Seite 831]
59.4 - 55.4 Erstellung eines Commandlets mit einem Rückgabeobjekt [Seite 839]
59.5 - 55.5 Erstellung eines Commandlets mit mehreren Rückgabeobjekten [Seite 840]
59.6 - 55.6 Erstellen eines Commandlets mit Parametern [Seite 844]
59.7 - 55.7 Verarbeiten von Pipeline-Eingaben [Seite 846]
59.8 - 55.8 Verkettung von Commandlets [Seite 849]
59.9 - 55.9 Fehlersuche in Commandlets [Seite 853]
59.10 - 55.10 Statusinformationen [Seite 856]
59.11 - 55.11 Unterstützung für Sicherheitsabfragen [Seite 861]
59.12 - 55.12 Festlegung der Hilfeinformationen [Seite 863]
59.13 - 55.13 Erstellung von Commandlets für den Zugriff auf eine Geschäftsanwendung [Seite 867]
59.14 - 55.14 Konventionen für Commandlets [Seite 868]
59.15 - 55.15 Weitere Möglichkeiten [Seite 870]
60 - 56 Hosting der Windows PowerShell [Seite 871]
60.1 - 56.1 Voraussetzungen für das Hosting [Seite 872]
60.2 - 56.2 Hosting mit PSHost [Seite 872]
60.3 - 56.3 Vereinfachtes Hosting seit PowerShell 2.0 [Seite 876]
61 - 57 PowerShell-Module erstellen [Seite 879]
61.1 - 57.1 Erstellen eines Skriptmoduls [Seite 879]
61.2 - 57.2 Erstellen eines Moduls mit Binärdateien [Seite 881]
61.3 - 57.3 Erstellen eines Moduls mit Manifest [Seite 881]
62 - Anhang [Seite 889]
62.1 - A Crashkurs "Objektorientierung" [Seite 891]
62.2 - B Crashkurs ".NET Framework" [Seite 899]
62.3 - C Literatur [Seite 907]
62.4 - D Weitere Informationen im Internet [Seite 911]
63 - Stichwortverzeichnis [Seite 913]