Windows PowerShell 5.0

Das Praxisbuch
 
 
Hanser (Verlag)
  • 1. Auflage
  • |
  • erschienen am 9. Mai 2016
  • |
  • 1015 Seiten
 
E-Book | ePUB mit Wasserzeichen-DRM | Systemvoraussetzungen
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-446-44815-5 (ISBN)
 
Das PowerShell-Praxisbuch für Einsteiger und Profis - jetzt in der 5. Auflage

Administratoren bietet dieses Buch eine kompakte Darstellung der vielfältigen Einsatzmöglichkeiten der PowerShell 5.0 sowie ergänzender Commandlet- und Klassenbibliotheken. Es enthält über 2.000 Code-Beispiele und beschreibt 640 Commandlets für die kommandozeilenbasierte Administration und das Scripting in Windows.

Profitieren Sie vom Know-how des .NET- und Scripting-Experten Dr. Holger Schwichtenberg
In Teil 1 und 2 des Buches erhalten Sie eine strukturierte Einführung in die Konzepte der PowerShell und lernen dann in Teil 3, wie Sie PowerShell in zahlreichen Anwendungsgebieten praktisch einsetzen. Fortgeschrittene Administratoren erfahren schließlich in Teil 4, wie Sie die PowerShell erweitern können, u. a. durch die Entwicklung eigener Commandlets.

Das Buch behandelt PowerShell 5.0, kann aber auch für die Vorgängerversionen verwendet werden; die Unterschiede sind im Buch beschrieben.
Berücksichtigt werden alle Windows-Versionen ab Windows XP bzw. Windows Server 2003 einschließlich der neusten Versionen Windows 10 und Windows Server 2016
Codebeispiele, PowerShell-Kurzreferenz, Feedbackmöglichkeiten und Forum finden Sie auf der Website zum Buch.

AUS DEM INHALT
Konzepte: Commandlets, Pipelining, PowerShell-Navigationsmodell, Sprachsyntax und Skripte, PowerShell-Werkzeuge, Module, Zugriff auf .NET, COM und WMI, Fernzugriffe, Jobs, Workflows, Desired State Configuration, Fehlersuche Tipps und Tricks
Einsatzbeispiele: Dateisystem, Backup, Bitlocker, Dokumente, XML, Relationale Datenbanken, Registry, Computerverwaltung, Hardwareverwaltung, Softwareverwaltung, Prozessverwaltung, Systemdienste, Netzwerk, Sicherheit, Ereignisprotokolle, Leistungsdaten, Active Directory, Gruppenrichtlinien, Hyper-V, IIS, Benutzeroberflächen
Erweiterungen: Erweiterungen installieren, Entwickeln von eigenen Commandlets, Erstellen von Modulen, Hosting der PowerShell
  • Deutsch
  • München
  • |
  • Deutschland
  • 32,99 MB
978-3-446-44815-5 (9783446448155)
3446448152 (3446448152)
http://dx.doi.org/10.3139/9783446448155
weitere Ausgaben werden ermittelt
Dr. Holger Schwichtenberg ist Leiter des .NET-Expertennetzwerks www.IT-Visions.de (http://www.IT-Visions.de), das zahlreiche Unternehmen in Europa durch Beratung, Schulung, Coaching, Support und die Übernahme von Entwicklungsleistungen unterstützt. Er selbst arbeitet bei www.IT-Visions.de als Softwarearchitekt und Berater für .NET mit dem Schwerpunkt auf Webanwendungen, verteilten Systemen und Datenbankzugriffen.
Dr. Holger Schwichtenberg gehört durch seine Auftritte auf nationalen und internationalen Fachkonferenzen sowie zahlreiche Fachbücher für Addison-Wesley, Microsoft Press und den Hanser-Verlag zu den bekanntesten .NET-Experten in Deutschland. Darüber hinaus ist er ständiger Mitarbeiter der Fachzeitschriften dotnet magazin, dotnetpro und iX sowie bei heise.de. Von Microsoft ist er für sein .NET-Fachwissen ausgezeichnet als Microsoft Most Valuable Professional (MVP) für ASP.NET/IIS. Sein Weblog finden Sie unter http://www.dotnet-doktor.de. Bei Twitter folgen Sie ihm unter http://www.twitter.com/DOTNETDOKTOR.
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]

Dateiformat: EPUB
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie eine Lese-Software, die das Dateiformat EPUB verarbeiten kann: z.B. Adobe Digital Editions oder FBReader - beide kostenlos (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nicht Kindle)

Das Dateiformat EPUB ist sehr gut für Romane und Sachbücher geeignet - also für "fließenden" Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.

Inhalt (1) (PDF)
Inhalt (2) (PDF)

Download (sofort verfügbar)

39,99 €
inkl. 19% MwSt.
Download / Einzel-Lizenz
ePUB mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
Hinweis: Die Auswahl des von Ihnen gewünschten Dateiformats und des Kopierschutzes erfolgt erst im System des E-Book Anbieters
E-Book bestellen

Unsere Web-Seiten verwenden Cookies. Mit der Nutzung dieser Web-Seiten erklären Sie sich damit einverstanden. Mehr Informationen finden Sie in unserem Datenschutzhinweis. Ok