O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

PowerShell 5.0

Book Description

In diesem Standardwerk zu PowerShell finden Einsteiger und Profis fundiertes Hintergrundwissen kombiniert mit praxisnahen und sofort einsetzbaren Codebeispielen. Der klare und umfassende Aufbau des Buches vermittelt, wie die vielfältigen Funktionen der PowerShell zusammenhängen und aufeinander aufbauen.Einsteiger finden sofort Zugang zur PowerShell. Autodidaktisch erworbene Vorkenntnisse werden komplettiert und vertieft. Profis entdecken unzählige wertvolle Hinweise, Praxistipps und "Best Practices" für professionelles und sicheres Skripten.Dr. Tobias Weltner ist Autor von über 120 IT-Büchern und arbeitet als Trainer und Consultant mit dem Schwerpunkt PowerShell und Automation in ganz Europa. Er erhielt 11 MVP-Auszeichnungen der Firma Microsoft (Microsoft Most Valuable Professionals) und zählt zu den erfahrensten PowerShell-Experten weltweit.

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Inhalt
  5. Einführung
    1. Wer braucht eigentlich PowerShell?
      1. Handwerkszeug für Windows-Admins
      2. Moderne Lernkurve
      3. Computer – ich/ich – Computer: PowerShell als Fremdsprache
      4. PowerShell als Ersatz für VBScript und Batch
      5. Grenzenloses PowerShell – über Computergrenzen hinweg
      6. Strategische Plattform und Orchestrierung
      7. Anwendungsentwicklung
      8. Persönliche Entwicklung
    2. Wie Sie dieses Buch nutzen
    3. Noch mehr Unterstützung
  6. Kapitel 1: PowerShell kennenlernen
    1. Die PowerShell-Konsole einrichten
      1. PowerShell-Konsole starten
      2. PowerShell-Version kontrollieren
      3. Symbol an Taskleiste heften
      4. Bessere Schrift für die Konsole
      5. Neue Konsolenfunktionen bei Windows 10 aktivieren
      6. Sprungliste: Administratorrechte und ISE
      7. 32-Bit- und 64-Bit-Versionen
    2. PowerShell ISE einsetzen
    3. Erste Schritte mit PowerShell
      1. Wichtige Vorsichtsmaßnahmen
      2. Befehle eingeben
      3. Ergebnisse empfangen
      4. Farbcodierungen verstehen
      5. Rechnen mit PowerShell
      6. Umwandlungen
      7. Zahlenreihen
      8. Unvollständige und mehrzeilige Eingaben
    4. Skriptausführung erlauben
    5. Tippfehler vermeiden und Eingaben erleichtern
      1. Autovervollständigung
      2. Pfadnamen vervollständigen
      3. Befehlszeilen erneut verwenden
      4. Befehlsnamen autovervollständigen
      5. Parameter-Autovervollständigung
      6. Argument-Autovervollständigung
    6. PowerShell-Hilfe aus dem Internet nachladen
      1. Hilfe ohne Internetzugang installieren
      2. Hilfe bei PowerShell 3
    7. Klassische Konsole oder moderner ISE-Editor?
      1. Einschränkungen des ISE-Editors
      2. Einschränkungen der klassischen Konsole
      3. PowerShell-2.0-Testumgebung
    8. Testen Sie Ihr Wissen!
  7. Teil A: Interaktive Befehlskonsole
    1. Kapitel 2: Cmdlets – die PowerShell-Befehle
      1. Alles, was Sie über Cmdlets wissen müssen
      2. Cmdlets für eine Aufgabe finden
        1. Suche nach Tätigkeit oder Tätigkeitsbereich
        2. Mit ISE nach Cmdlets suchen
        3. Mit der Hilfe nach Cmdlets suchen
      3. Mit Parametern Wünsche formulieren
        1. Parameter wecken das volle Potenzial der Cmdlets
        2. Drei universelle Parametertypen
        3. Common Parameter – allgemeine Parameter für alle Cmdlets
        4. Fehlermeldungen unterdrücken
        5. Unvollständige Parameternamen
        6. Parameter-Binding sichtbar machen
      4. Neue Cmdlets aus Modulen nachladen
        1. Neue Module automatisch nachladen
        2. Auslaufmodell: Snap-Ins
      5. Alias: Zweitname für Cmdlets
        1. Aliase sind keine neuen Befehle
        2. Befehlstypen ermitteln
        3. Klassische cmd.exe-Interpreterbefehle sind Cmdlets
        4. Eigene Aliase anlegen
      6. Testaufgaben
    2. Kapitel 3: PowerShell-Laufwerke
      1. Dateisystemaufgaben meistern
        1. Ordner anlegen
        2. Dateien anlegen und Informationen speichern
        3. Dateien finden
        4. Dateien und Ordner kopieren
        5. Dateien umbenennen
        6. Dateien und Ordner löschen
        7. Größe eines Laufwerks ermitteln
        8. Größe eines Ordners ermitteln
      2. Umgebungsvariablen
        1. Alle Umgebungsvariablen auflisten
        2. Auf einzelne Umgebungsvariablen zugreifen
        3. Umgebungsvariablen ändern
      3. Windows-Registrierungsdatenbank
        1. Schlüssel suchen
        2. Werte lesen
        3. Neue Registry-Schlüssel anlegen
        4. Werte hinzufügen, ändern und löschen
      4. Virtuelle Laufwerke und Provider
        1. Neue PowerShell-Laufwerke
        2. Mit Pfadnamen arbeiten
        3. Unterstützte Platzhalterzeichen in Pfadnamen
        4. -Path oder -LiteralPath?
        5. Existenz eines Pfads prüfen
        6. Pfadnamen auflösen
      5. Testaufgaben
    3. Kapitel 4: Anwendungen und Konsolenbefehle
      1. Programme starten
        1. Optionen für den Programmstart festlegen
        2. Nicht unterstützte Konsolenbefehle im ISE-Editor
      2. Argumente an Anwendungen übergeben
        1. Hilfe für Konsolenbefehle anzeigen
        2. Beispiel: Lizenzstatus von Windows überprüfen
        3. Argumentübergabe kann scheitern
        4. Texteingaben an Konsolenbefehle senden
      3. Ergebnisse von Anwendungen weiterverarbeiten
        1. Error Level auswerten
        2. Fragen an Benutzer stellen mit choice.exe
        3. Rückgabetext auswerten
        4. Rückgabetexte in Objekte verwandeln
        5. Rückgabetext analysieren
      4. Laufende Programme steuern
        1. Feststellen, ob ein Prozess läuft
        2. Auf einen Prozess warten
        3. Einstellungen laufender Prozesse ändern
        4. Prozesse vorzeitig abbrechen
      5. Testaufgaben
    4. Kapitel 5: Skripte einsetzen
      1. PowerShell-Skripte verfassen
        1. Skriptcode eingeben
        2. Eingabehilfen spüren Tippfehler auf
        3. Skript ausführen
        4. Sicherheitseinstellungen und Ausführungsrichtlinien
      2. Profilskripte – die Autostartskripte
        1. Vier verschiedene Profilskripte – pro Host
        2. Profilskript anlegen und öffnen
        3. Typische Profilskriptaufgaben durchführen
      3. Skripte außerhalb von PowerShell starten
        1. PowerShell-Startoptionen
        2. Befehlsfolgen extern ausführen
        3. PowerShell-Code als geplante Aufgabe ausführen
      4. Nicht-PowerShell-Skripte öffnen
        1. Stapeldateien (Batchdateien)
        2. VBScript-Dateien ausführen
      5. Skripte digital signieren
        1. Digitales Zertifikat beschaffen
        2. Zertifikat aus PFX-Datei laden
        3. Zertifikat aus Zertifikatspeicher laden
        4. Skript digital signieren
        5. Digitale Signaturen überprüfen
        6. Signaturen mit einem Zeitstempel versehen
    5. Kapitel 6: Die PowerShell-Pipeline
      1. Aufbau der PowerShell-Pipeline
        1. Prinzipieller Aufbau der Pipeline
        2. Die sechs wichtigsten Pipeline-Befehle
      2. Select-Object
        1. Selbst festlegen, welche Informationen wichtig sind
        2. Platzhalterzeichen verwenden
        3. Weitere Informationen anfügen
        4. -First, -Last und -Skip
        5. Unsichtbare Eigenschaften sichtbar machen
        6. Sonderfall -ExpandProperty
        7. Wie ETS Objekte in Text verwandelt
      3. Where-Object
        1. Where-Object: stets nur zweite Wahl
        2. Clientseitiger Universalfilter
        3. Leere Elemente aussortieren
        4. Fortgeschrittene Syntax bietet noch mehr Möglichkeiten
        5. Dateiinhalte filtern
        6. IP-Adressen bestimmen
        7. Alternativen zu Where-Object
      4. Sort-Object
        1. Cmdlet-Ergebnisse sortieren
        2. Nach mehreren Spalten sortieren
        3. Sortierung mit anderen Cmdlets kombinieren
      5. ForEach-Object
        1. Grundprinzip: eine Schleife
      6. Group-Object
        1. Häufigkeiten feststellen
        2. Gruppen bilden
      7. Measure-Object
        1. Statistische Berechnungen
        2. Ordnergrößen berechnen
      8. Mit »berechneten« Eigenschaften arbeiten
        1. Datentyp der Sortierung ändern
        2. Gruppierung nach bestimmten Textteilen
        3. Umwandlung von Byte in Megabyte
        4. Hashtables: mehrere Werte übergeben
        5. Mehrere Spalten in umgekehrter Sortierung
        6. Mehrspaltige Anzeigen
        7. Berechnete Spalten hinzufügen
        8. Spaltenbreite, Bündigkeit und Gruppenüberschriften
        9. Frei wählbare Gruppierungskriterien
      9. Pipeline und Performance: Optimierungen
        1. Flaschenhals Pipeline
        2. Klassische Schleifen sind wesentlich schneller
        3. Die Pipeline ist wesentlich reaktionsfreudiger
        4. Weniger Speicherbedarf oder mehr Geschwindigkeit?
      10. Testaufgaben
    6. Kapitel 7: Ergebnisse ausgeben und formatieren
      1. Ergebnisse als Text darstellen
        1. Ergebnisse in Textdateien schreiben
        2. Textformatierung ändern
        3. Automatische Textformatierung verstehen
        4. Mehrspaltige Anzeige
        5. Out-Printer: Ergebnisse zu Papier bringen
        6. Out-WinWord: Ergebnisse direkt an Microsoft Word senden
        7. Out-PDF: mit Microsoft Word PDF-Reports erstellen
      2. Ergebnisse als Objekte exportieren
        1. Export-CSV: Export an Microsoft Excel und andere Programme
        2. Ergebnisse serialisieren mit XML und JSON
      3. HTML-Reports erstellen
        1. Objekteigenschaften in HTML-Spalten umwandeln
        2. HTML im Webbrowser anzeigen
        3. HTML-Reports ansprechend und farbig gestalten
      4. Testaufgaben
  8. Teil B: Objektorientierte Shell
    1. Kapitel 8: Mit Objekten arbeiten
      1. Eigenschaften und Methoden
        1. Eigenschaften
        2. Methoden
      2. Eigenschaften und Methoden anzeigen
        1. Hilfe für Objekteigenschaften und -methoden finden
      3. Ergebnisse eines Befehls untersuchen
        1. Unterschiedliche Objekttypen
        2. Nach Objekttypen filtern
        3. Änderbare Eigenschaften finden
        4. Primitive Datentypen sind auch Objekte
      4. Eigenschaften lesen
        1. Eigenschaften von vielen Objekten gleichzeitig abrufen
      5. Eigenschaften ändern
        1. Änderungen wirksam werden lassen
      6. Methoden aufrufen
        1. Eine Methode mit mehreren Signaturen
      7. Testaufgaben
    2. Kapitel 9: Operatoren und Bedingungen
      1. Operatoren – Aufbau und Namensgebung
        1. Wie Operatornamen aufgebaut sind
        2. Unäre Operatoren
      2. Zuweisungsoperatoren
      3. Vergleichsoperatoren
        1. Unterscheidung zwischen Groß- und Kleinschreibung
        2. Unterschiedliche Datentypen vergleichen
        3. Vergleiche umkehren
        4. Vergleiche kombinieren
        5. Vergleiche auf Arrays anwenden
      4. Bedingungen
        1. if-Bedingung
        2. Switch-Bedingung
        3. Where-Object
    3. Kapitel 10: Textoperationen und reguläre Ausdrücke
      1. Texte zusammenfügen
        1. Variableninhalte mit doppelten Anführungszeichen integrieren
        2. Der Formatierungsoperator »-f«
      2. Textstellen finden und extrahieren
        1. Texte splitten
        2. Informationen in Texten finden
      3. Reguläre Ausdrücke: Textmustererkennung
        1. Erste Schritte: Mit Textmustern arbeiten
        2. Bestandteile eines regulären Ausdrucks
        3. Längste oder kürzeste Fassung?
      4. Textstellen ersetzen
        1. Ersetzungen ohne Zeichenverlust
        2. Bezug auf den Originaltext nehmen
        3. Delegatfunktionen
        4. Rückverweise im Muster
      5. Split und Join: eine mächtige Strategie
        1. Nach verschiedenen Zeichen splitten
        2. Splitten ohne Trennzeichen(verlust): LookBehind und LookAround
      6. Mehrere Treffer in einem Text finden
        1. [Regex]::Matches einsetzen
        2. Ein- und Mehrzeilenmodus
      7. Testaufgaben
    4. Kapitel 11: Typen verwenden
      1. Typumwandlungen
        1. Automatische Typzuweisung durch PowerShell
        2. Explizite Umwandlung in einen anderen Typ
        3. Testumwandlungen zum Validieren
        4. Verkettete Umwandlungen
        5. Umwandlungen bei Cmdlets
      2. Neue Objekte durch Typumwandlungen
      3. Implizite Umwandlung und typisierte Variablen
        1. Typisierte Variablen
        2. Typisierte Parameter
        3. Typisierte Eigenschaften und Argumente
        4. Vergleichsoperationen
      4. Verborgene Befehle in Typen
      5. Statische Methoden verwenden
        1. Eindeutige GUIDs generieren
        2. Dateiextension ermitteln
        3. Mathematische Funktionen
        4. Zahlenformate konvertieren
        5. DNS-Auflösung
        6. Umgebungsvariablen
        7. Pfade zu Systemordnern finden
        8. Konsoleneinstellungen
        9. Spezielle Datumsformate lesen
        10. Statische Eigenschaften verwenden
      6. Neue Objekte herstellen
        1. Konstruktoren verstehen
        2. Ein Credential-Object zur automatischen Anmeldung
        3. Umgang mit XML-Daten
        4. WMI-Remotezugriffe mit Anmeldung
      7. COM-Objekte verwenden
        1. Dialogfeld öffnen
        2. Sprachausgabe
        3. Office-Automation
        4. Zugriff auf Datenbanken
        5. Automatische Updates
        6. Verknüpfungen anlegen und ändern
        7. Netzwerkmanagement
        8. Welche COM-Objekte gibt es sonst noch?
      8. Webdienste ansprechen
        1. SOAP-basierte Webdienste
        2. RESTful-Webdienste
      9. Neue .NET-Typen finden
        1. Type Accelerators untersuchen
        2. .NET-Assemblies durchsuchen
        3. Typen nach Stichwort suchen
        4. Typen mit bestimmten Befehlen finden
      10. Typen nachladen
        1. Assembly-Namen feststellen
        2. Aktuell geladene Assemblies auflisten
        3. Zusätzliche Assembly nachladen
        4. Assembly aus Datei nachladen
      11. Testaufgaben
  9. Teil C: Automationssprache
    1. Kapitel 12: Einfache Funktionen
      1. Alles Wichtige: ein Überblick
        1. Eigene Funktionen herstellen
        2. Parameter definieren
        3. Parameter implementieren
        4. Funktionen per Modul überall verfügbar machen
        5. Hilfe – Bedienungsanleitung hinzufügen
      2. Eine bessere Prompt-Funktion
      3. Zwingend erforderliche Parameter
        1. Eine Funktion mit zwingend erforderlichen Parametern
        2. Automatische Nachfrage
      4. Argumente ohne Parameter
      5. Rückgabewerte festlegen
        1. Mehrere Rückgabewerte werden zum Array
        2. Return-Anweisung
        3. Write-Output
        4. Unerwünschte Rückgabewerte unterdrücken
    2. Kapitel 13: Skriptblöcke
      1. Skriptblöcke: Transportcontainer für Code
      2. Einsatzbereiche für Skriptblöcke
        1. Skripte sind dateibasierte Skriptblöcke
        2. Code in separater PowerShell ausführen
        3. Code remote ausführen
        4. Rückgabewerte
        5. Pipeline-Fähigkeit
        6. Schleifen und Bedingungen
      3. Gültigkeitsbereiche
      4. Zeitkapsel: Closures
      5. Delegates
      6. Zugriff auf AST und Parser
      7. Codesicherheit
    3. Kapitel 14: Pipeline-fähige Funktionen
      1. Anonyme Pipeline-Funktion
        1. Prototyping
        2. Pipeline-fähige Funktion erstellen
        3. Benannte Parameter
        4. Where-Object durch eine Funktion ersetzen
        5. Kurzes Resümee
      2. Parameter und Pipeline-Kontrakt
        1. »ISA«-Kontrakt: Pipeline-Eingaben direkt binden
      3. »HASA«-Kontrakt: Objekteigenschaften lesen
        1. »HASA« und »ISA« kombinieren
        2. CSV-Dateien direkt an Funktionen übergeben
        3. Aliasnamen für Parameter
      4. Modularer Code mit Pipeline-fähigen Funktionen
        1. Ausgangspunkt: ein unleserliches Skript
        2. Teil 1: Get-NewFilenameIfPresent
        3. Teil 2: ConvertTo-AbsoluteURL
        4. Teil 3: Get-ImageFromWebsite
        5. Teil 4: Download-File
    4. Kapitel 15: Objektorientierte Rückgabewerte
      1. Mehrere Informationen zurückgeben
        1. Objekte speichern mehrere Informationen strukturiert
        2. Eigene Objekte mit Ordered Hashtables anlegen
      2. Primär sichtbare Eigenschaften festlegen
    5. Kapitel 16: Fortgeschrittene Parameter
      1. Argumentvervollständigung
        1. Statische Autovervollständigung für Parameter
        2. Autovervollständigung über Enumerationsdatentyp
        3. Autovervollständigung über ValidateSet
        4. Vordefinierte Enumerationsdatentypen finden
        5. Eigene Enumerationsdatentypen erstellen
        6. Dynamische Argumentvervollständigung
      2. Zuweisungen mit Validierern überprüfen
        1. ValidateSet
        2. ValidateRange
        3. ValidateLength
        4. ValidatePattern
        5. ValidateCount
        6. ValidateScript
        7. Nullwerte und andere Validierer
      3. Parameter in ParameterSets einteilen
        1. Gegenseitig ausschließende Parameter
        2. Binding über Datentyp
        3. Parameter in mehreren Parametersätzen
      4. Simulationsmodus (-WhatIf) und Sicherheitsabfrage (-Confirm)
        1. Festlegen, welche Codeteile übersprungen werden sollen
        2. Weiterleitung verhindern
        3. Praxisbeispiel: Automatische Auslagerungsdateien aktivieren
        4. Gefährlichkeit einer Funktion festlegen
      5. Dynamische Parameter
        1. Dynamische Parameter selbst definieren
        2. Auf die Argumente dynamischer Parameter zugreifen
        3. »Clevere« dynamische Parameter
        4. Performance und Caching
      6. Parameter mit dynamischen Vorschlagslisten
        1. Dynamische Währungslisten anzeigen
        2. Objektgenerator mit dynamischen Parametern
        3. Dynamische Parameter mit dynamischen ValidateSets
      7. Splatting: mehrere Parameter gleichzeitig ansprechen
        1. Splatting im Alltag einsetzen
        2. Übergebene Parameter als Hashtable empfangen
        3. Mit Splatting Parameter weiterreichen
    6. Kapitel 17: Eigene Module erstellen
      1. Module sind Ordner
        1. Funktion erstellen und testen
        2. Funktion in Modul aufnehmen
        3. Modul manuell importieren
        4. Module automatisch importieren
      2. Manifestdatei für ein Modul
        1. Neue Manifestdatei anlegen
        2. Wirkung einer Manifestdatei
      3. ETS-Anweisungen zu Modul hinzufügen
        1. Eindeutige Typnamen zuweisen
        2. Neue Formatierungsangaben in ETS einfügen
        3. Formatdefinition in Modul integrieren
        4. ETS-Formatierung testen
        5. Aufbau von FormatData-Definitionen
      4. Module entfernen
    7. Kapitel 18: PowerShellGet – Module verteilen und nachladen
      1. PowerShell Gallery nutzen
        1. NuGet-Provider installieren
        2. Repository
        3. Module finden und installieren
        4. Modul herunterladen
        5. Modul testweise ausführen
        6. Modul dauerhaft installieren
        7. Module aktualisieren
        8. Side-by-Side-Versionierung
        9. Eigene Module veröffentlichen
      2. Privates Repository einrichten
        1. Freigaben zum Lesen und Schreiben
        2. Repository anlegen
        3. Modul in Repository übertragen
        4. Modul aus Repository installieren
    8. Kapitel 19: Gültigkeitsbereiche
      1. Gültigkeitsbereiche verstehen
        1. Unterschied zwischen Lesen und Schreiben
        2. Aufpassen bei Objekten und Referenzen
        3. Parameter liefern Referenzen
      2. Gemeinsam genutzte Variablen
        1. Skriptglobale »Shared« Variable
        2. Globale Variable
      3. Direkter Zugriff auf Gültigkeitsbereiche
      4. Dot-Sourcing: Skripte im Aufruferkontext
        1. »Dot-Sourcing« verstehen
        2. Aufruftyp eines Skripts testen
      5. Gültigkeitsbereiche in Modulen
        1. Modulcode greift auf Aufruferkontext zu
        2. Aufruferkontext greift auf Modulkontext zu
    9. Kapitel 20: Debugging – Fehler finden
      1. Syntaxfehler erkennen und beheben
        1. Folgefehler und der Blick auf das Wesentliche
        2. Formale Regeln missachten
      2. Laufzeit- und Logikfehler aufspüren
        1. Falsche Verwendung von Operatoren
        2. Tippfehler ändern den Code
        3. Nicht initialisierte Variablen
        4. Versehentliche Verwendung von Arrays
        5. Fehlendes Verständnis für Objektreferenzen
        6. Falsche Verwendung von Klammern
        7. Falsche Zuordnung von Skriptblöcken
      3. Schrittweise Ausführung mit dem Debugger
        1. Haltepunkte setzen und Code schrittweise ausführen
        2. Codeausführung fortsetzen
        3. Ad-hoc-Debugging
      4. Dynamische Haltepunkte setzen
        1. Anhalten, wenn Variablen sich ändern
        2. Anhalten, wenn Cmdlets oder Funktionen aufgerufen werden
        3. Anhalten, wenn Variablen bestimmte Werte enthalten
      5. Debugging-Meldungen ausgeben
        1. Ein Skript mit Write-Debug testen
        2. Write-Debug in echte Haltepunkte umwandeln
      6. Tracing einsetzen
      7. Fremde Prozesse debuggen
        1. Testszenario: PowerShell-Code in fremdem Prozess
        2. Testskript in fremdem Host starten
        3. Verbindung mit fremdem Host aufnehmen
        4. Runspace auswählen und debuggen
        5. Debug-Sitzung beenden
      8. Remote-Debugging
        1. Mit Remotecomputer verbinden
        2. Remoteskript laden und debuggen
    10. Kapitel 21: Fehlerhandling
      1. Fehlermeldungen unterdrücken
        1. Bestimmen, wie Cmdlets auf Fehler reagieren
        2. Fehler nachträglich analysieren
        3. Fehler mitprotokollieren lassen
        4. Erfolg eines Befehlsaufrufs prüfen
      2. Fehlerhandler einsetzen
        1. Lokaler Fehlerhandler: try...catch
        2. Globaler Fehlerhandler: Trap
      3. Spezifische Fehlerhandler
        1. Exception-Namen ermitteln
        2. Spezifische Fehlerhandler nutzen
        3. Spezifische Fehlerhandler in Traps
        4. Spezifizität des Fehlerhandlers justieren
      4. Eigene Fehler auslösen
        1. Mit Throw einen Fehler auslösen
        2. Spezifische Fehler auslösen
      5. Upstream-Kommunikation in der Pipeline
        1. Pipeline vorzeitig abbrechen
        2. Pipeline mit Select-Object abbrechen
        3. Pipeline manuell abbrechen
      6. Testaufgaben
  10. Teil D: Remoting und Parallelverarbeitung
    1. Kapitel 22: Fernzugriff und Netzwerk-Troubleshooting
      1. Klassische Fernzugriffe
        1. Dateisystem
        2. Konsolenbefehle
        3. Remotefähige Cmdlets
      2. Troubleshooting für Fernzugriffe
        1. Firewall für DCOM einrichten
        2. Namensauflösung überprüfen
        3. Remote-Registrierungszugriff erlauben
        4. Access Denied: mit passenden Rechten anmelden
        5. LocalAccountTokenFilterPolicy
        6. Ports überprüfen
    2. Kapitel 23: Windows PowerShell-Remoting
      1. PowerShell-Remoting aktivieren
        1. Ohne Kerberos und Domäne
        2. TrustedHosts-Liste
        3. PowerShell-Remoting überprüfen
      2. Erste Schritte mit PowerShell-Remoting
        1. Remoting-Unterstützung im ISE-Editor
        2. Befehle und Skripte remote ausführen
        3. Kontrolle: Wer besucht »meinen« Computer?
      3. Remotefähigen Code entwickeln
        1. Argumente an Remotecode übergeben
        2. Ergebnisse vom Remotecode an den Aufrufer übertragen
        3. Fan-Out: integrierte Parallelverarbeitung
        4. ThrottleLimit: Parallelverarbeitung begrenzen
        5. Double-Hop und CredSSP: Anmeldeinfos weiterreichen
      4. Eigene Sitzungen verwenden
        1. Eigene Sitzungen anlegen
        2. Parallelverarbeitung mit PSSessions
        3. Sitzungen trennen und wiederverbinden
        4. Aktive PSSessions trennen
        5. Beispiel: Invoke-Command -InDisconnectedSession
      5. Endpunkte verwalten
        1. Vorhandene Endpunkte anzeigen
        2. Standardendpunkt festlegen
        3. Remote auf Endpunkte zugreifen
      6. Neue Endpunkte anlegen
        1. Zugriffsberechtigungen für Endpunkt festlegen
        2. Benutzerkontext ändern
        3. Eingeschränkte Endpunkte anlegen
        4. Bereitgestellte Befehle weiter einschränken
        5. Eigene Funktionen definieren und bereitstellen
      7. Reguläre PowerShell-Sitzungen einschränken
        1. Limit-Runspace: Befehlsumfang und Sprachmodus bestimmen
        2. Endpunkte per Skript absichern
        3. Eigene Funktionen einsetzen
      8. Sitzungsinhalte importieren
        1. Cmdlets eines Remotesystems importieren
        2. Remotesitzungen als Modul exportieren
      9. Datentransfer und Optimierung
        1. Deserialisierte Objekte
        2. Serialisierungsvorgang
        3. Performanceoptimierung
        4. Datentransfer mit PowerShell-Remoting
      10. Weitere Remoting-Einstellungen
        1. Clientseitige Sitzungsoptionen
        2. Zugriff auf Remoting-Einstellungen
        3. Einstellungen ändern
      11. Fehler finden und beheben
        1. RPC-Server nicht verfügbar
        2. Zugriff verweigert
        3. Kerberos-Fehlermeldung
        4. Öffentliche Netzwerke entdeckt
        5. Andere Fehler
    3. Kapitel 24: Just Enough Admin (JEA)
      1. Just Enough Admin (JEA)
        1. Virtuelle Administratorkonten
        2. Rollenmodell
      2. Virtuelle Administratorkonten
        1. Voraussetzungen
        2. PowerShell-Remoting überprüfen
        3. JEA-Endpunkt einrichten
        4. JEA-Endpunkt verwenden
      3. Gefahren bei der Elevation
        1. Unterschieben bösartiger Module und Befehle
        2. Angriffsszenario mit Administratorrechten
        3. Angriffsszenario ohne Administratorrechte
        4. Best Practices für JEA-Endpunkte
      4. Rollenbasierte Rechtevergabe
        1. Rollen anlegen
        2. Befehlsumfang der Rollen definieren
      5. Praxisbeispiel: Verwaltung im Active Directory
        1. Endpunkt für die Verwaltung des Active Directory
        2. Modul für die Verwaltung des Active Directory
        3. Rollenbasierte Verwaltung
    4. Kapitel 25: Hintergrundjobs und Parallelverarbeitung
      1. Hintergrundjobs
        1. Mehrere Aufgaben parallelisieren
        2. Integrierte Hintergrundjobs
        3. Hintergrundjobs auf Remotecomputern
      2. Multithreading
        1. Einen separaten Thread erzeugen
        2. Hintergrundüberwachungen einrichten
      3. Foreach-Schleife mit Parallelbearbeitung
        1. Foreach-Parallel nachrüsten
        2. Maximale Thread-Anzahl festlegen
        3. Maximale Ausführungszeit festlegen
        4. Lokale Variablen einblenden
      4. Hintergrundjobs auf Thread-Basis
  11. Teil E: DevOps und Enterprise
    1. Kapitel 26: Workflows
      1. Brauche ich Workflows?
        1. Wie relevant sind Workflows wirklich?
      2. Aufgaben orchestrieren
        1. Orchestrierung in klassischer Funktion
        2. Orchestrierung mit Workflow: sequence und parallel
        3. Workflows sind kein PowerShell-Code
        4. Syntaktische Unterschiede und Kompatibilitätsprobleme
        5. InlineScript: echten PowerShell-Code ausführen
      3. Variablen und Gültigkeitsbereiche
        1. Zugriff auf »fremde« Variablen
        2. Workflow-globale Variablen
        3. Variablen in InlineScript
        4. Informationen mit Parametern übergeben
        5. Ergebnisse über Rückgabewerte zurückliefern
        6. Funktionen verwenden
        7. Verschachtelte Workflows
      4. Remotezugriff
      5. Parallelverarbeitung
        1. Globale Variablen synchronisieren parallele Aufgaben
        2. Parallelbearbeitung in einer Schleife
        3. Throttling für Parallelschleifen
      6. Unterbrechung und Wiederaufnahme
        1. Manuelle Unterbrechung
        2. Automatische Unterbrechung
        3. Persistierende Hintergrundjobs
        4. Prüfpunkte für eine kontrollierte Wiederaufnahme
        5. Workflow-Server: Schutz vor unkontrollierten Abstürzen
      7. Workflows optimieren
    2. Kapitel 27: Desired State Configuration (DSC)
      1. Workflows und DSC – eine Reise ins DevOps-Land
      2. Voraussetzungen für DSC
      3. Architektur
      4. Was sind Ressourcen?
        1. Mitgelieferte Ressourcen untersuchen
        2. Integrierte Testfunktion in Ressourcen
        3. Aktuellen Zustand ermitteln
        4. Änderung durchführen
      5. Was sind Konfigurationen?
        1. Eine einfache DSC-Konfiguration erstellen
        2. Konfiguration als MOF-Datei speichern
        3. Konfiguration auf Computer anwenden
      6. Was ist der Local Configuration Manager?
        1. Die Master-Konfiguration
        2. Reset: LCM zurücksetzen
        3. Konfiguration überprüfen
        4. Konfigurationshistorie abrufen
      7. Das »Was?« vom »Wo?« abgrenzen
        1. Schlecht: Umgebungsinformationen in Konfigurationen
        2. Umgebungsinformationen ausgliedern
        3. Umgebungsinformationen als ConfigurationData übergeben
        4. Komplexere Umgebungen definieren
      8. Identität und Umgang mit Geheimnissen
        1. Konfigurationen im Benutzerkontext ausführen
        2. Sensible Informationen verschlüsseln
        3. Kennwörter in DSC-Konfigurationen verschlüsseln
      9. Mitgelieferte Ressourcen
        1. Verfügbare Ressourcen auflisten
        2. Ressource »Archive«
        3. Ressource »Environment«
        4. Ressource »Group«
      10. Zusätzliche Ressourcen
        1. Ressourcen aus der PowerShell Gallery beziehen
        2. Eigene DSC-Ressourcen schreiben
        3. ResourceDesigner installieren
        4. Ressource konzipieren
        5. Ressource anlegen
        6. Get-TargetResource entwerfen
        7. Test-TargetResource
        8. Set-TargetResource
        9. Neue Ressource testen
        10. Neue Ressource in DSC-Konfiguration nutzen
      11. Orchestrierung
        1. Abhängigkeiten definieren
        2. Systemübergreifende Abhängigkeiten
        3. Partielle Konfigurationen
      12. LCM konfigurieren
        1. Letzte Konfiguration wiederherstellen
        2. Konfigurationen automatisch überwachen und anwenden
  12. Teil F: Spezielle Techniken
    1. Kapitel 28: Ereignisverarbeitung mit Events
      1. Ereignisse verwenden
        1. Ein Ereignis asynchron überwachen
        2. Ein Ereignis synchron überwachen
      2. Hintergrundjobs überwachen
        1. Manuelle Überwachung
        2. Automatische Überwachung
      3. Ordner überwachen
      4. Aufgaben regelmäßig durchführen
      5. WMI-Ereignisse empfangen
        1. Details zum Event erfahren
        2. Systemänderungen erkennen
      6. Eigene Ereignisse auslösen
        1. Automatische Variablenüberwachung einrichten
    2. Kapitel 29: Extended Type System (ETS)
      1. PowerShell-Objekte verstehen
        1. Erweiterte PowerShell-Objekte
        2. Objekte mit Add-Member erweitern
        3. Dauerhafte Erweiterungen
      2. AliasProperty: Eigenschaften »umbenennen«
      3. NoteProperty: Objekte »taggen«
      4. ScriptProperty: »berechnete« Eigenschaften
        1. Lesbare Eigenschaften
        2. Lesbare und schreibbare Eigenschaften
      5. ScriptMethod und ParameterizedProperty
      6. Membertypen für den internen Gebrauch
        1. PropertySet: Gruppen von Eigenschaften
        2. MemberSet: Wie soll PowerShell das Objekt behandeln?
    3. Kapitel 30: Proxyfunktionen verstehen und einsetzen
      1. Eine Proxyfunktion erstellen
        1. Bestehende Cmdlets erweitern
      2. Automatische Protokollfunktion
      3. Get-ChildItem mit neuen Parametern
        1. Proxyfunktion anlegen
        2. Logik implementieren
      4. Proxyfunktionen für Remoting
        1. Eine Remotesitzung erstellen
        2. Einen Remotebefehl in lokale Sitzung importieren
    4. Kapitel 31: Benutzeroberflächen gestalten
      1. Eigene Fenster mit WPF erzeugen
        1. Ein Fenster gestalten – allein mit Code
        2. Ein Fenster gestalten – mit XAML
        3. Auf Elemente des Fensters zugreifen
        4. Auf Ereignisse reagieren
      2. Werkzeuge für das WPF-Design
        1. Mit dem WPF-Designer von Visual Studio arbeiten
        2. Neue grafische Elemente einfügen
      3. Elemente im Fenster anordnen
        1. StackPanels
        2. Grids
        3. DockPanels
      4. Datenbindungen
      5. Ereignisse behandeln
        1. Ereignisse mit Werkzeugen erforschen
        2. Ereignisse manuell erforschen
      6. Multithreading
        1. Fenster anzeigen und weiterarbeiten
        2. Oberfläche aktualisieren
        3. Aufgaben im Hintergrund durchführen
        4. Mehrere Threads verwenden
      7. Thread-übergreifende Aktionen
        1. Thread-übergreifendes Databinding
      8. Bilder in WPF einbetten
        1. Bild in Text verwandeln
        2. Text in Bild verwandeln
    5. Kapitel 32: Pester – »Test-Driven Development«
      1. Pester installieren oder aktualisieren
      2. Eine simple Funktion auf TDD-Art entwickeln
        1. Eine neue Funktion entwerfen
        2. Einen Test formulieren
        3. Test ausführen
        4. Funktionalität implementieren
        5. Architektur der Pester-Tests
        6. Gefahren und Vorsichtsmaßnahmen
        7. Funktionen nachträglich erweitern
      3. Assertions – Ergebnisse überprüfen
        1. Die richtige Assertion wählen
        2. Eine Assertion testen
        3. Mehrere Assertions kombinieren
      4. Simulationen und Alltagstests
        1. Befehle vorübergehend außer Kraft setzen
        2. Mock-Funktion über Parameter auswählen
        3. Reale Tests und notwendige Aufräumarbeiten
        4. TestDrive – ein Ort für temporäre Daten
      5. »Test Cases« und Wiederverwertung
      6. »Code Coverage« und Eigenentwicklungen
        1. Testabdeckung überprüfen
        2. Eigene Testtools auf Pester aufsetzen
    6. Kapitel 33: PowerShell-Umgebung anpassen
      1. Profilskripte einsetzen
        1. Vier Profilskripte
        2. Profilskripte öffnen und ändern
        3. Profilskripte bei Bedarf nachladen
      2. Eingabeaufforderung anpassen
      3. Konsolendarstellung verbessern
      4. ISE-Editor erweitern
        1. Auf den Editor zugreifen
        2. Befehle über das Menü anbieten
        3. Add-On-Tools verwenden
      5. Zugriff auf die Skriptstruktur
        1. Zwei Parser: Text in Token verwandeln
        2. Kommentare entfernen
        3. Aliase auflösen
        4. Syntaxfehler finden
      6. Abstract Syntax Tree (AST)
    7. Kapitel 34: .NET Framework und PowerShell
      1. Auf API-Funktionen zugreifen
        1. API-Funktionen in PowerShell einblenden
        2. API-Funktion einsetzen
        3. Wiederverwertbare PowerShell-Funktion herstellen
      2. PowerShell-Klassen einsetzen
        1. Neue Klasse zur besseren Prozesse-Verwaltung
        2. Statische Eigenschaften und Methoden
      3. Vererbung von Klassen
        1. Eine abgeleitete Klasse erstellen
        2. Abgeleitete Klasse einsetzen
        3. Die wesentlichen Aspekte der Vererbung
        4. Eine weitere abgeleitete Klasse
      4. C#-Code verwenden
        1. Klasse mit PowerShell-Mitteln erstellen
        2. Klasse mit C#-Code entwickeln
  13. Index