Windows PowerShell 5.0

1 - Vorwort zur fünften Auflage Januar 2016 [Seite 20]
1.1 - Wer bin ich? [Seite 20]
1.2 - Wer sind Sie? [Seite 21]
1.3 - Was ist neu in diesem Buch? [Seite 21]
1.4 - Sind in diesem Buch alle Features der PowerShell beschrieben? [Seite 22]
1.5 - Wem ist zu danken? [Seite 22]
1.6 - Woher bekommen Sie die Beispiele aus diesem Buch? [Seite 22]
1.7 - Wo kann ich mich schulen oder beraten lassen? [Seite 23]
1.8 - Zum Schluss des Vorworts .?.?. [Seite 23]
2 - Über den Autor Dr. Holger Schwichtenberg [Seite 24]
3 - Über den Co-Autor Peter Monadjemi [Seite 25]
4 - Teil A: PowerShell-Basiswissen [Seite 26]
5 - 1 Erste Schritte mit der Windows PowerShell [Seite 28]
5.1 - 1.1 Was ist die Windows PowerShell? [Seite 28]
5.2 - 1.2 Geschichte der Windows PowerShell [Seite 29]
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 und Linux [Seite 34]
5.6 - 1.6 PowerShell herunterladen und auf anderen Betriebssystemen installieren [Seite 35]
5.7 - 1.7 Die Windows PowerShell testen [Seite 38]
5.8 - 1.8 Woher kommen die Commandlets? [Seite 47]
5.9 - 1.9 PowerShell Community Extensions (PSCX) herunterladen und installieren [Seite 47]
5.10 - 1.10 Den PowerShell-Editor "ISE" verwenden [Seite 49]
6 - Architektur der Windows PowerShell [Seite 54]
7 - 3 Einzelbefehle der PowerShell [Seite 58]
7.1 - 3.1 Commandlets [Seite 58]
7.2 - 3.2 Aliase [Seite 67]
7.3 - 3.3 Ausdrücke [Seite 74]
7.4 - 3.4 Externe Befehle [Seite 75]
7.5 - 3.5 Dateinamen [Seite 76]
8 - 4 Hilfefunktionen [Seite 78]
8.1 - 4.1 Auflisten der verfügbaren Befehle [Seite 78]
8.2 - 4.2 Erläuterungen zu den Befehlen [Seite 81]
8.3 - 4.3 Hilfe zu Parametern [Seite 82]
8.4 - 4.4 Hilfe mit Show-Command [Seite 82]
8.5 - 4.5 Hilfefenster [Seite 83]
8.6 - 4.6 Aktualisieren der Hilfedateien [Seite 85]
8.7 - 4.7 Online-Hilfe [Seite 86]
8.8 - 4.8 Dokumentation der .NET?Klassen [Seite 87]
9 - 5 Objektorientiertes Pipelining [Seite 90]
9.1 - 5.1 Pipeline-Operator [Seite 90]
9.2 - 5.2 .NET-Objekte in der Pipeline [Seite 91]
9.3 - 5.3 Pipeline Processor [Seite 93]
9.4 - 5.4 Pipelining von Parametern [Seite 94]
9.5 - 5.5 Pipelining von klassischen Befehlen [Seite 96]
9.6 - 5.6 Anzahl der Objekte in der Pipeline [Seite 97]
9.7 - 5.7 Zugriff auf einzelne Objekte aus einer Menge [Seite 97]
9.8 - 5.8 Zugriff auf einzelne Werte in einem Objekt [Seite 99]
9.9 - 5.9 Methoden ausführen [Seite 100]
9.10 - 5.10 Analyse des Pipeline-Inhalts [Seite 102]
9.11 - 5.11 Filtern [Seite 113]
9.12 - 5.12 Zusammenfassung von Pipeline-Inhalten [Seite 116]
9.13 - 5.13 "Kastrierung" von Objekten in der Pipeline [Seite 117]
9.14 - 5.14 Sortieren [Seite 118]
9.15 - 5.15 Duplikate entfernen [Seite 118]
9.16 - 5.16 Gruppierung [Seite 119]
9.17 - 5.17 Berechnungen [Seite 121]
9.18 - 5.18 Zwischenschritte in der Pipeline mit Variablen [Seite 121]
9.19 - 5.19 Verzweigungen in der Pipeline [Seite 122]
9.20 - 5.20 Vergleiche zwischen Objekten [Seite 124]
9.21 - 5.21 Zusammenfassung [Seite 125]
9.22 - 5.22 Praxisbeispiele [Seite 125]
10 - 6 PowerShell-Skripte [Seite 128]
10.1 - 6.1 Skriptdateien [Seite 128]
10.2 - 6.2 Start eines Skripts [Seite 130]
10.3 - 6.3 Aliase für Skripte verwenden [Seite 131]
10.4 - 6.4 Parameter für Skripte [Seite 132]
10.5 - 6.5 Skripte dauerhaft einbinden (Dot Sourcing) [Seite 133]
10.6 - 6.6 Sicherheitsfunktionen für PowerShell-Skripte [Seite 134]
10.7 - 6.7 Skripte anhalten [Seite 138]
11 - 7 PowerShell-Skriptsprache [Seite 140]
11.1 - 7.1 Hilfe zur PowerShell-Skriptsprache [Seite 140]
11.2 - 7.2 Befehlstrennung [Seite 141]
11.3 - 7.3 Kommentare [Seite 141]
11.4 - 7.4 Variablen [Seite 142]
11.5 - 7.5 Variablenbedingungen [Seite 149]
11.6 - 7.6 Zahlen [Seite 150]
11.7 - 7.7 Zeichenketten [Seite 152]
11.8 - 7.8 Reguläre Ausdrücke [Seite 158]
11.9 - 7.9 Datum und Uhrzeit [Seite 165]
11.10 - 7.10 Arrays [Seite 166]
11.11 - 7.11 Assoziative Arrays (Hash-Tabellen) [Seite 169]
11.12 - 7.12 Operatoren [Seite 170]
11.13 - 7.13 Überblick über die Kontrollkonstrukte [Seite 171]
11.14 - 7.14 Schleifen [Seite 172]
11.15 - 7.15 Bedingungen [Seite 177]
11.16 - 7.16 Unterroutinen (Prozedur/Funktionen) [Seite 179]
11.17 - 7.17 Eingebaute Funktionen [Seite 185]
11.18 - 7.18 Fehlerbehandlung [Seite 185]
11.19 - 7.19 Objektorientiertes Programmieren mit Klassen [Seite 192]
12 - 8 Ausgaben [Seite 196]
12.1 - 8.1 Ausgabe-Commandlets [Seite 196]
12.2 - 8.2 Out-GridView [Seite 199]
12.3 - 8.3 Standardausgabe [Seite 200]
12.4 - 8.4 Einschränkung der Ausgabe [Seite 203]
12.5 - 8.5 Seitenweise Ausgabe [Seite 203]
12.6 - 8.6 Ausgabe einzelner Werte [Seite 204]
12.7 - 8.7 Details zum Ausgabeoperator [Seite 206]
12.8 - 8.8 Benutzerdefinierte Tabellenformatierung [Seite 209]
12.9 - 8.9 Ausgabe von Methodenergebnissen und Unterobjekten in Pipelines [Seite 210]
12.10 - 8.10 Ausgabe von Methodenergebnissen und Unterobjekten in Zeichenketten [Seite 211]
12.11 - 8.11 Unterdrückung der Ausgabe [Seite 211]
12.12 - 8.12 Ausgaben an Drucker [Seite 212]
12.13 - 8.13 Ausgaben in Dateien [Seite 212]
12.14 - 8.14 Umleitungen (Redirection) [Seite 213]
12.15 - 8.15 Sprachausgabe [Seite 214]
13 - 9 Benutzereingaben [Seite 216]
13.1 - 9.1 Read-Host [Seite 216]
13.2 - 9.2 Grafischer Eingabedialog [Seite 217]
13.3 - 9.3 Dialogfenster [Seite 217]
13.4 - 9.4 Authentifizierungsdialog [Seite 218]
14 - 10 Das PowerShell-Navigationsmodell [Seite 220]
14.1 - 10.1 Einführungsbeispiel: Navigation in der Registrierungsdatenbank [Seite 220]
14.2 - 10.2 Provider und Laufwerke [Seite 221]
14.3 - 10.3 Navigationsbefehle [Seite 223]
14.4 - 10.4 Pfadangaben [Seite 224]
14.5 - 10.5 Beispiel [Seite 226]
14.6 - 10.6 Eigene Laufwerke definieren [Seite 227]
15 - 11 PowerShell-Werkzeuge [Seite 228]
15.1 - 11.1 PowerShell-Standardkonsole [Seite 228]
15.2 - 11.2 PowerShell Integrated Scripting Environment (ISE) [Seite 235]
15.3 - 11.3 PowerShell Script Analyzer [Seite 241]
15.4 - 11.4 CIM Explorer for PowerShell ISE [Seite 247]
15.5 - 11.5 PowerShell Web Access (PSWA) [Seite 248]
15.6 - 11.6 ISE Steroids [Seite 254]
15.7 - 11.7 PowerShellPlus [Seite 255]
15.8 - 11.8 PoshConsole [Seite 258]
15.9 - 11.9 PowerGUI [Seite 259]
15.10 - 11.10 PowerShell Analyzer [Seite 260]
15.11 - 11.11 PrimalScript [Seite 261]
15.12 - 11.12 PowerShell Help [Seite 263]
15.13 - 11.13 PowerShell Help Reader [Seite 264]
15.14 - 11.14 PowerTab [Seite 264]
15.15 - 11.15 NuGet Package Manager [Seite 264]
15.16 - 11.16 PowerShell Tools for Visual Studio [Seite 265]
15.17 - 11.17 PowerShell Remoting [Seite 266]
15.18 - 11.18 Vergleich der Skripteditoren [Seite 266]
16 - Teil B: PowerShell-Aufbauwissen [Seite 268]
17 - 12 Fernausführung (Remoting) [Seite 270]
17.1 - 12.1 RPC-Fernabfrage ohne WS?Management [Seite 271]
17.2 - 12.2 Anforderungen an PowerShell Remoting [Seite 272]
17.3 - 12.3 Rechte für PowerShell-Remoting [Seite 273]
17.4 - 12.4 Einrichten von PowerShell Remoting [Seite 274]
17.5 - 12.5 Überblick über die Fernausführungs-Commandlets [Seite 276]
17.6 - 12.6 Interaktive Fernverbindungen im Telnet-Stil [Seite 277]
17.7 - 12.7 Fernausführung von Befehlen [Seite 278]
17.8 - 12.8 Parameterübergabe an die Fernausführung [Seite 282]
17.9 - 12.9 Fernausführung von Skripten [Seite 283]
17.10 - 12.10 Ausführung auf mehreren Computern [Seite 284]
17.11 - 12.11 Sitzungen [Seite 285]
17.12 - 12.12 Implizites Remoting [Seite 289]
17.13 - 12.13 Zugriff auf entfernte Computer außerhalb der eigenen Domäne [Seite 290]
17.14 - 12.14 Verwaltung des WS-Management-Dienstes [Seite 293]
17.15 - 12.15 PowerShell Direct für HyperV [Seite 295]
17.16 - 12.16 Praxisbeispiel zu PowerShell Direct [Seite 297]
18 - 13 Verwendung von .NET-Klassen [Seite 300]
18.1 - 13.1 Microsoft Developer Network (MSDN) [Seite 300]
18.2 - 13.2 Erzeugen von Instanzen [Seite 301]
18.3 - 13.3 Parameterbehaftete Konstruktoren [Seite 303]
18.4 - 13.4 Initialisierung von Objekten [Seite 304]
18.5 - 13.5 Nutzung von Attributen und Methoden [Seite 305]
18.6 - 13.6 Statische Mitglieder in .NET-Klassen und statische .NET-Klassen [Seite 307]
18.7 - 13.7 Generische Klassen nutzen [Seite 309]
18.8 - 13.8 Zugriff auf bestehende Objekte [Seite 310]
18.9 - 13.9 Laden von Assemblies [Seite 311]
18.10 - 13.10 Objektanalyse [Seite 312]
18.11 - 13.11 Auflistungen (Enumerationen) [Seite 313]
18.12 - 13.12 Verknüpfen von Aufzählungswerten [Seite 314]
19 - 14 Verwendung von COM-Klassen [Seite 316]
19.1 - 14.1 Erzeugen von Instanzen [Seite 316]
19.2 - 14.2 Nutzung von Attributen und Methoden [Seite 317]
19.3 - 14.3 Holen bestehender Instanzen [Seite 318]
20 - 15 Zugriff auf die Windows Management Instrumentation (WMI) [Seite 320]
20.1 - 15.1 Einführung in WMI [Seite 320]
20.2 - 15.2 WMI in der Windows PowerShell [Seite 346]
20.3 - 15.3 Abruf von WMI-Objektmengen [Seite 347]
20.4 - 15.4 Fernzugriffe [Seite 348]
20.5 - 15.5 Filtern und Abfragen [Seite 348]
20.6 - 15.6 Liste aller WMI-Klassen [Seite 353]
20.7 - 15.7 Hintergrundwissen: WMI-Klassenprojektion mit dem PowerShell-WMI-Objektadapter [Seite 353]
20.8 - 15.8 Beschränkung der Ausgabeliste bei WMI-Objekten [Seite 357]
20.9 - 15.9 Zugriff auf einzelne Mitglieder von WMI-Klassen [Seite 358]
20.10 - 15.10 Werte setzen in WMI-Objekten [Seite 359]
20.11 - 15.11 Umgang mit WMI-Datumsangaben [Seite 361]
20.12 - 15.12 Methodenaufrufe [Seite 362]
20.13 - 15.13 Neue WMI-Instanzen erzeugen [Seite 363]
20.14 - 15.14 Instanzen entfernen [Seite 364]
20.15 - 15.15 Commandlet Definition XML-Datei (CDXML) [Seite 365]
21 - 16 Dynamische Objekte [Seite 368]
21.1 - 16.1 Erweitern bestehender Objekte [Seite 368]
21.2 - 16.2 Komplett dynamische Objekte [Seite 370]
22 - 17 Einbinden von C# und VB.NET [Seite 372]
23 - 18 Win32-API-Aufrufe [Seite 374]
24 - 19 Fehlersuche [Seite 378]
24.1 - 19.1 Detailinformationen [Seite 378]
24.2 - 19.2 Einzelschrittmodus [Seite 379]
24.3 - 19.3 Zeitmessung [Seite 380]
24.4 - 19.4 Ablaufverfolgung [Seite 381]
24.5 - 19.5 Kommandozeilenbasiertes Script-Debugging [Seite 381]
25 - 20 Transaktionen [Seite 384]
25.1 - 20.1 Commandlets für Transaktionen [Seite 384]
25.2 - 20.2 Start und Ende einer Transaktion [Seite 385]
25.3 - 20.3 Zurücksetzen der Transaktion [Seite 386]
25.4 - 20.4 Mehrere Transaktionen [Seite 387]
26 - 21 Hintergrundaufträge ("Jobs") [Seite 388]
26.1 - 21.1 Voraussetzungen [Seite 388]
26.2 - 21.2 Architektur [Seite 389]
26.3 - 21.3 Starten eines Hintergrundauftrags [Seite 389]
26.4 - 21.4 Hintergrundaufträge abfragen [Seite 390]
26.5 - 21.5 Warten auf einen Hintergrundauftrag [Seite 391]
26.6 - 21.6 Abbrechen und Löschen von Aufträgen [Seite 391]
26.7 - 21.7 Analyse von Fehlermeldungen [Seite 392]
26.8 - 21.8 Fernausführung von Hintergrundaufträgen [Seite 392]
26.9 - 21.9 Praxisbeispiel [Seite 392]
27 - 22 Geplante Aufgaben und zeitgesteuerte Jobs [Seite 394]
27.1 - 22.1 Geplante Aufgaben (Scheduled Tasks) [Seite 394]
27.2 - 22.2 Zeitgesteuerte Jobs [Seite 398]
28 - 23 PowerShell-Workflows [Seite 404]
28.1 - 23.1 Ein erstes Beispiel [Seite 404]
28.2 - 23.2 Unterschiede zu einer Function bzw. einem Skript [Seite 409]
28.3 - 23.3 Einschränkungen bei Workflows [Seite 409]
28.4 - 23.4 Workflows in der Praxis [Seite 411]
28.5 - 23.5 Workflows in Visual Studio erstellen [Seite 418]
29 - 24 Ereignissystem [Seite 436]
29.1 - 24.1 WMI-Ereignisse [Seite 436]
29.2 - 24.2 WMI-Ereignisabfragen [Seite 436]
29.3 - 24.3 WMI-Ereignisse seit PowerShell 1.0 [Seite 438]
29.4 - 24.4 Registrieren von WMI?Ereignisquellen seit PowerShell 2.0 [Seite 439]
29.5 - 24.5 Auslesen der Ereignisliste [Seite 440]
29.6 - 24.6 Reagieren auf Ereignisse [Seite 442]
29.7 - 24.7 WMI-Ereignisse ab PowerShell-Version 3.0 [Seite 444]
29.8 - 24.8 Registrieren von .NET?Ereignissen [Seite 444]
29.9 - 24.9 Erzeugen von Ereignissen [Seite 445]
30 - 25 Datenbereiche und Datendateien [Seite 448]
30.1 - 25.1 Datenbereiche [Seite 448]
30.2 - 25.2 Datendateien [Seite 450]
30.3 - 25.3 Mehrsprachigkeit/Lokalisierung [Seite 451]
31 - 26 Desired State Configuration (DSC) [Seite 454]
31.1 - 26.1 Grundprinzipien [Seite 455]
31.2 - 26.2 DSC für Linux [Seite 455]
31.3 - 26.3 Ressourcen [Seite 456]
31.4 - 26.4 Verfügbare DSC-Ressourcen [Seite 456]
31.5 - 26.5 Eigenschaften einer Ressource [Seite 459]
31.6 - 26.6 Aufbau eines DSC-Dokuments [Seite 459]
31.7 - 26.7 Commandlets für die Arbeit mit DSC [Seite 460]
31.8 - 26.8 Ein erstes DSC-Beispiel [Seite 460]
31.9 - 26.9 Kompilieren und Anwendung eines DSC-Dokuments [Seite 461]
31.10 - 26.10 Variablen in DSC-Dateien [Seite 463]
31.11 - 26.11 Parameter für DSC-Dateien [Seite 464]
31.12 - 26.12 Konfigurationsdaten [Seite 465]
31.13 - 26.13 Entfernen einer DSC-Konfiguration [Seite 468]
31.14 - 26.14 DSC Pull Server [Seite 471]
31.15 - 26.15 DSC-Praxisbeispiel 1: IIS installieren [Seite 478]
31.16 - 26.16 DSC-Praxisbeispiel 2: Software installieren [Seite 479]
31.17 - 26.17 DSC-Praxisbeispiel 3: Software deinstallieren [Seite 482]
31.18 - 26.18 Realisierung einer DSC-Ressource [Seite 482]
31.19 - 26.19 Weitere Möglichkeiten [Seite 483]
32 - 27 PowerShell-Snap-Ins [Seite 484]
32.1 - 27.1 Einbinden von Snap-Ins [Seite 484]
32.2 - 27.2 Liste der Commandlets [Seite 488]
32.3 - 27.3 Doppeldeutige Namen [Seite 489]
33 - 28 PowerShell-Module [Seite 490]
33.1 - 28.1 Überblick über die Commandlets [Seite 490]
33.2 - 28.2 Modularchitektur [Seite 491]
33.3 - 28.3 Module aus dem Netz herunterladen und installieren mit PowerShellGet [Seite 492]
33.4 - 28.4 Module manuell installieren [Seite 497]
33.5 - 28.5 Auflisten der verfügbaren Module [Seite 498]
33.6 - 28.6 Importieren von Modulen [Seite 499]
33.7 - 28.7 Entfernen von Modulen [Seite 502]
34 - 29 Ausgewählte PowerShell-Erweiterungen [Seite 504]
34.1 - 29.1 PowerShell-Module in Windows 7 und Windows Server 2008 R2 [Seite 504]
34.2 - 29.2 PowerShell-Module in Windows 8.0 und Windows Server 2012 [Seite 506]
34.3 - 29.3 PowerShell-Module in Windows 8.1 und Windows Server 2012 R2 [Seite 508]
34.4 - 29.4 PowerShell-Module in Windows 10 und Windows Server 2016 [Seite 510]
34.5 - 29.5 Windows PowerShell Community Extensions (PSCX) [Seite 515]
34.6 - 29.6 PowerShellPack [Seite 518]
34.7 - 29.7 www.IT-Visions.de PowerShell Extensions [Seite 520]
34.8 - 29.8 Quest Management Shell for Active Directory [Seite 521]
34.9 - 29.9 Microsoft Exchange Server [Seite 522]
34.10 - 29.10 System Center Virtual Machine Manager [Seite 523]
34.11 - 29.11 PowerShell Management Library for Hyper-V (pshyperv) [Seite 524]
34.12 - 29.12 Powershell Outlook Account Manager [Seite 525]
34.13 - 29.13 PowerShell Configurator (PSConfig) [Seite 525]
34.14 - 29.14 Weitere Erweiterungen [Seite 526]
35 - 30 Tipps und Tricks zur PowerShell [Seite 528]
35.1 - 30.1 Befehlsgeschichte [Seite 528]
35.2 - 30.2 System- und Hostinformationen [Seite 529]
35.3 - 30.3 Alle Anzeigen löschen [Seite 530]
35.4 - 30.4 Anpassen der Eingabeaufforderung (Prompt) [Seite 530]
35.5 - 30.5 Standardeinstellungen ändern mit Profilskripten [Seite 531]
35.6 - 30.6 ISE erweitern [Seite 536]
35.7 - 30.7 PowerShell für Gruppenrichtlinienskripte [Seite 537]
35.8 - 30.8 Einblicke in die Interna der Pipeline-Verarbeitung [Seite 539]
36 - C [Seite 542]
37 - 31 Dateisystem [Seite 544]
37.1 - 31.1 Laufwerke [Seite 545]
37.2 - 31.2 Ordnerinhalte [Seite 550]
37.3 - 31.3 Kurznamen [Seite 551]
37.4 - 31.4 Dateisystemoperationen [Seite 552]
37.5 - 31.5 Praxisbeispiel: Leere Ordner löschen [Seite 553]
37.6 - 31.6 Papierkorb leeren [Seite 554]
37.7 - 31.7 Dateieigenschaften lesen [Seite 554]
37.8 - 31.8 Praxisbeispiel: Fotos nach Aufnahmedatum sortieren [Seite 555]
37.9 - 31.9 Datei-Hash [Seite 556]
37.10 - 31.10 Finden von Duplikaten [Seite 557]
37.11 - 31.11 Dateieigenschaften verändern [Seite 559]
37.12 - 31.12 Verknüpfungen im Dateisystem [Seite 561]
37.13 - 31.13 Komprimierung [Seite 566]
37.14 - 31.14 Dateisystemfreigaben [Seite 569]
37.15 - 31.15 Überwachung des Dateisystems [Seite 580]
37.16 - 31.16 Dateiversionsverlauf [Seite 581]
37.17 - 31.17 Windows Server Backup [Seite 582]
38 - 32 Festplattenverschlüsselung mit BitLocker [Seite 584]
38.1 - 32.1 Übersicht über das BitLocker-Modul [Seite 585]
38.2 - 32.2 Verschlüsseln eines Laufwerks [Seite 586]
39 - 33 Dokumente [Seite 588]
39.1 - 33.1 Textdateien [Seite 588]
39.2 - 33.2 CSV-Dateien [Seite 589]
39.3 - 33.3 Analysieren von Textdateien [Seite 592]
39.4 - 33.4 INI-Dateien [Seite 595]
39.5 - 33.5 XML-Dateien [Seite 595]
39.6 - 33.6 HTML-Dateien [Seite 604]
39.7 - 33.7 Binärdateien [Seite 604]
40 - 34 Datenbanken [Seite 606]
40.1 - 34.1 ADO.NET-Grundlagen [Seite 606]
40.2 - 34.2 Beispieldatenbank [Seite 612]
40.3 - 34.3 Datenzugriff mit den Bordmitteln der PowerShell [Seite 613]
40.4 - 34.4 Datenzugriff mit den PowerShell-Erweiterungen [Seite 624]
40.5 - 34.5 Datenbankzugriff mit SQLPS [Seite 627]
40.6 - 34.6 Datenbankzugriff mit SQLPSX [Seite 627]
41 - 35 Microsoft-SQL-Server-Administration [Seite 628]
41.1 - 35.1 PowerShell-Integration im SQL Server Management Studio [Seite 629]
41.2 - 35.2 SQL-Server-Laufwerk "SQLSERVER:" [Seite 630]
41.3 - 35.3 Die SQLPS-Commandlets [Seite 633]
41.4 - 35.4 Die SQL Server Management Objects (SMO) [Seite 635]
41.5 - 35.5 SQLPSX [Seite 638]
41.6 - 35.6 Microsoft-SQL-Server-Administration mit der PowerShell in der Praxis [Seite 646]
42 - 36 ODBC-Datenquellen [Seite 652]
42.1 - ODBC-Treiber und -Datenquellen auflisten [Seite 653]
42.2 - Anlegen einer ODBC-Datenquelle [Seite 654]
42.3 - Zugriff auf eine ODBC-Datenquelle [Seite 655]
43 - 37 Registrierungsdatenbank (Registry) [Seite 658]
43.1 - 37.1 Schlüssel auslesen [Seite 658]
43.2 - 37.2 Schlüssel anlegen und löschen [Seite 659]
43.3 - 37.3 Laufwerke definieren [Seite 659]
43.4 - 37.4 Werte anlegen und löschen [Seite 660]
43.5 - 37.5 Werte auslesen [Seite 661]
43.6 - 37.6 Praxisbeispiel: Windows-Explorer-Einstellungen [Seite 661]
43.7 - 37.7 Praxisbeispiel: Massenanlegen von Registry-Schlüsseln [Seite 662]
44 - 38 Computerverwaltung [Seite 664]
44.1 - 38.1 Computerinformationen [Seite 664]
44.2 - 38.2 Computername und Domäne [Seite 666]
44.3 - 38.3 Herunterfahren und Neustarten [Seite 667]
44.4 - 38.4 Wiederherstellungspunkte verwalten [Seite 668]
45 - 39 Hardwareverwaltung [Seite 670]
45.1 - 39.1 Hardwarebausteine [Seite 670]
45.2 - 39.2 Plug-and-Play-Geräte [Seite 672]
45.3 - 39.3 Druckerverwaltung (ältere Betriebssysteme) [Seite 672]
45.4 - 39.4 Druckerverwaltung (seit Windows 8 und Windows Server 2012) [Seite 673]
46 - 40 Softwareverwaltung [Seite 676]
46.1 - 40.1 Softwareinventarisierung [Seite 676]
46.2 - 40.2 Installation von Anwendungen [Seite 679]
46.3 - 40.3 Deinstallation von Anwendungen [Seite 680]
46.4 - 40.4 Praxisbeispiel: Installationstest [Seite 680]
46.5 - 40.5 Installationen mit PowerShell Package Management ("OneGet") [Seite 681]
46.6 - 40.6 Versionsnummer ermitteln [Seite 684]
46.7 - 40.7 Servermanager [Seite 685]
46.8 - 40.8 Softwareeinschränkungen mit dem PowerShell-Modul "AppLocker" [Seite 696]
47 - 41 Prozessverwaltung [Seite 702]
47.1 - 41.1 Prozesse auflisten [Seite 702]
47.2 - 41.2 Prozesse starten [Seite 703]
47.3 - 41.3 Prozesse beenden [Seite 705]
47.4 - 41.4 Warten auf das Beenden einer Anwendung [Seite 705]
48 - 42 Systemdienste [Seite 706]
48.1 - 42.1 Dienste auflisten [Seite 706]
48.2 - 42.2 Dienstzustand ändern [Seite 708]
48.3 - 42.3 Diensteigenschaften ändern [Seite 709]
49 - 43 Netzwerk [Seite 710]
49.1 - 43.1 Netzwerkkonfiguration (ältere Betriebssysteme) [Seite 710]
49.2 - 43.2 Netzwerkkonfiguration (ab Windows 8 und Windows Server 2012) [Seite 712]
49.3 - 43.3 DNS-Client-Konfiguration [Seite 715]
49.4 - 43.4 DNS-Namensauflösung [Seite 718]
49.5 - 43.5 Erreichbarkeit prüfen (Ping) [Seite 720]
49.6 - 43.6 Windows Firewall [Seite 721]
49.7 - 43.7 Remote Desktop (RDP) einrichten [Seite 727]
49.8 - 43.8 E-Mails senden (SMTP) [Seite 728]
49.9 - 43.9 Abruf von Daten von einem HTTP-Server [Seite 730]
49.10 - 43.10 Aufrufe von SOAP-Webdiensten [Seite 731]
49.11 - 43.11 Aufrufe von OData-Diensten [Seite 734]
49.12 - 43.12 BITSTransfer [Seite 734]
50 - 44 Ereignisprotokolle [Seite 736]
50.1 - 14.1 Protokolleinträge auslesen [Seite 736]
50.2 - 14.2 Ereignisprotokolle erzeugen [Seite 738]
50.3 - 14.3 Protokolleinträge erzeugen [Seite 738]
50.4 - 14.4 Protokollgröße festlegen [Seite 738]
50.5 - 14.5 Protokolleinträge löschen [Seite 738]
51 - 45 Leistungsdaten [Seite 740]
51.1 - 45.1 Zugriff auf Leistungsindikatoren über WMI [Seite 740]
51.2 - 45.2 Get-Counter [Seite 741]
52 - 46 Sicherheitseinstellungen [Seite 744]
52.1 - 46.1 Grundlagen [Seite 744]
52.2 - 46.2 Zugriffsrechtelisten auslesen [Seite 749]
52.3 - 46.3 Einzelne Rechteeinträge auslesen [Seite 751]
52.4 - 46.4 Besitzer auslesen [Seite 752]
52.5 - 46.5 Benutzer und SID [Seite 752]
52.6 - 46.6 Hinzufügen eines Rechteeintrags zu einer Zugriffsrechteliste [Seite 756]
52.7 - 46.7 Entfernen eines Rechteeintrags aus einer Zugriffsrechteliste [Seite 758]
52.8 - 46.8 Zugriffsrechteliste übertragen [Seite 760]
52.9 - 46.9 Zugriffsrechteliste über SDDL setzen [Seite 760]
53 - 47 Active Directory [Seite 762]
53.1 - 47.1 Benutzer- und Gruppenverwaltung mit WMI [Seite 763]
53.2 - 47.2 Einführung in System.DirectoryServices [Seite 764]
53.3 - 47.3 Basiseigenschaften [Seite 775]
53.4 - 47.4 Benutzer- und Gruppenverwaltung im Active Directory [Seite 777]
53.5 - 47.5 Verwaltung der Organisationseinheiten [Seite 785]
53.6 - 47.6 Suche im Active Directory [Seite 786]
53.7 - 47.7 Navigation im Active Directory mit den PowerShell Extensions [Seite 793]
53.8 - 47.8 Verwendung der Active-Directory-Erweiterungen von www.IT-Visions.de [Seite 794]
53.9 - 47.9 PowerShell-Modul "Active Directory" (ADPowerShell) [Seite 796]
53.10 - 47.10 PowerShell-Modul "ADDSDeployment" [Seite 819]
53.11 - 47.11 Informationen über die Active?Directory-Struktur [Seite 821]
54 - 48 Gruppenrichtlinien [Seite 824]
54.1 - 48.1 Verwaltung der Gruppenrichtlinien [Seite 825]
54.2 - 48.2 Verknüpfung der Gruppenrichtlinien [Seite 826]
54.3 - 48.3 Gruppenrichtlinienberichte [Seite 828]
54.4 - 48.4 Gruppenrichtlinienvererbung [Seite 829]
54.5 - 48.5 Weitere Möglichkeiten [Seite 830]
55 - 49 Virtuelle Systeme mit Hyper-V [Seite 832]
55.1 - 49.1 Das Hyper-V-Modul von Microsoft [Seite 833]
55.2 - 49.2 Die ersten Schritte mit dem Hyper-V-Modul [Seite 835]
55.3 - 49.3 Virtuelle Maschinen anlegen [Seite 839]
55.4 - 49.4 Umgang mit virtuellen Festplatten [Seite 845]
55.5 - 49.5 Konfiguration virtueller Maschinen [Seite 848]
55.6 - 49.6 Dateien kopieren in virtuelle Systeme [Seite 852]
55.7 - 49.7 PowerShell Management Library for Hyper-V (für ältere Betriebssysteme) [Seite 853]
56 - 50 Internet Information Server (IIS) [Seite 858]
56.1 - 50.1 Überblick [Seite 858]
56.2 - 50.2 Navigationsprovider [Seite 860]
56.3 - 50.3 Anlegen von Websites [Seite 862]
56.4 - 50.4 Praxisbeispiel: Massenanlegen von Websites [Seite 863]
56.5 - 50.5 Ändern von Eigenschaften von Websites [Seite 866]
56.6 - 50.6 Anwendungspool anlegen [Seite 866]
56.7 - 50.7 Virtuelle Verzeichnisse und IIS?Anwendungen [Seite 867]
56.8 - 50.8 Website-Zustand ändern [Seite 868]
56.9 - 50.9 Anwendungspools starten und stoppen [Seite 868]
56.10 - 50.10 Löschen von Websites [Seite 869]
57 - 51 Microsoft Exchange Server [Seite 870]
57.1 - 51.1 Daten abrufen [Seite 870]
57.2 - 51.2 Postfächer verwalten [Seite 871]
57.3 - 51.3 Öffentliche Ordner verwalten [Seite 872]
58 - 52 Optimierungen und Problemlösungen [Seite 874]
58.1 - 52.1 PowerShell-Modul "TroubleshootingPack" [Seite 874]
58.2 - 52.2 PowerShell-Modul "Best Practices" [Seite 878]
59 - 53 Grafische Benutzeroberflächen [Seite 880]
59.1 - 53.1 Eingabemasken [Seite 880]
59.2 - 53.2 Universelle Objektdarstellung [Seite 882]
59.3 - 53.3 Zwischenablage [Seite 884]
59.4 - 53.4 WPF PowerShell Kit (WPK) [Seite 885]
60 - D [Seite 896]
61 - 54 Entwicklung von Commandlets in der PowerShell-Sprache [Seite 898]
61.1 - 54.1 Aufbau eines skriptbasierten Commandlets [Seite 898]
61.2 - 54.2 Parameterfestlegung [Seite 901]
61.3 - 54.3 Auszeichnung der Parameterdefinitionen [Seite 906]
61.4 - 54.4 Dokumentation [Seite 909]
62 - 55 Entwicklung eigener Commandlets mit C# [Seite 912]
62.1 - 55.1 Technische Voraussetzungen [Seite 912]
62.2 - 55.2 Grundkonzept der .NET-basierten Commandlets [Seite 914]
62.3 - 55.3 Schrittweise Erstellung eines minimalen Commandlets [Seite 915]
62.4 - 55.4 Erstellung eines Commandlets mit einem Rückgabeobjekt [Seite 923]
62.5 - 55.5 Erstellung eines Commandlets mit mehreren Rückgabeobjekten [Seite 925]
62.6 - 55.6 Erstellen eines Commandlets mit Parametern [Seite 929]
62.7 - 55.7 Verarbeiten von Pipeline-Eingaben [Seite 931]
62.8 - 55.8 Verkettung von Commandlets [Seite 934]
62.9 - 55.9 Fehlersuche in Commandlets [Seite 938]
62.10 - 55.10 Statusinformationen [Seite 941]
62.11 - 55.11 Unterstützung für Sicherheitsabfragen [Seite 946]
62.12 - 55.12 Festlegung der Hilfeinformationen [Seite 948]
62.13 - 55.13 Erstellung von Commandlets für den Zugriff auf eine Geschäftsanwendung [Seite 952]
62.14 - 55.14 Konventionen für Commandlets [Seite 953]
62.15 - 55.15 Weitere Möglichkeiten [Seite 955]
63 - 56 Hosting der Windows PowerShell [Seite 956]
63.1 - 56.1 Voraussetzungen für das Hosting [Seite 957]
63.2 - 56.2 Hosting mit PSHost [Seite 958]
63.3 - 56.3 Vereinfachtes Hosting seit PowerShell 2.0 [Seite 961]
64 - 57 PowerShell-Module erstellen [Seite 964]
64.1 - 57.1 Erstellen eines Skriptmoduls [Seite 964]
64.2 - 57.2 Erstellen eines Moduls mit Binärdateien [Seite 966]
64.3 - 57.3 Erstellen eines Moduls mit Manifest [Seite 966]
65 - Anhang [Seite 974]
66 - A [Seite 976]
67 - Crashkurs "Objektorientierung" [Seite 976]
68 - B [Seite 984]
69 - Crashkurs ".NET Framework" [Seite 984]
70 - C Literatur [Seite 994]
71 - D [Seite 998]
72 - Weitere Informationen im Internet [Seite 998]