PowerShell 5 E-Book

Tobias Weltner

• Herausgeber: O'Reilly
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Deutsch
• Veröffentlichungsjahr: 2016

Seitenzahl: 1419

Beschreibung

In diesem Standardwerk zu PowerShell finden Einsteiger und Profis fundiertes Hintergrundwissen kombiniert mit praxisnahen und sofort einsetzbaren Codebeispielen. Der klare Aufbau und das umfassende Themenspektrum des Buchs vermitteln, 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. Aus dem Inhalt: ■ Schnelleinstieg: PowerShell-Grundlagen und rasche Erfolge mit interaktiven Kommandos ■ PowerShell-Skripte, Sicherheitseinstellungen und digitale Signaturen ■ Durchdachter Einsatz der objektorientierten Pipeline ■ Textoperationen, Parsing und Reguläre Ausdrücke ■ Mit Objekten und Typen direkt auf das .NET Framework zugreifen ■ Wiederkehrende Aufgaben als eigene Befehle in Modulen verfügbar machen ■ Mit PowerShellGet Module und Skripte zentral verwalten ■ Prozessübergreifendes Debugging, Fehlerbehandlung und Logging ■ Abgesicherte Fernzugriffe und Sicherheitsstrategien (JEA) ■ Hintergrundjobs, Multithreading und Performancesteigerung ■ Workflows und Desired State Configuration (DSC) ■ Benutzeroberflächen mit WPF gestalten ■ Professionelles Test-Driven Development (TDD) mit Pester

Leseprobe

PowerShell 5.0 – Windows-Automation für Einsteiger und Profis

Dr. Tobias Weltner

Dr. Tobias Weltner

Lektorat: Ariane Hesse

Korrektorat: Sibylle Feldmann

Satz: mediaService, www.mediaservice.tv

Herstellung: Susanne Bröckelmann

Umschlaggestaltung: Michael Oreal, www.oreal.de, unter Verwendung eines Fotos von                                   Valerie Loiseleux / iStock. by Getty Images

Druck und Bindung: Druckerei C.H. Beck, www.becksche.de

Bibliografische Information der Deutschen Nationalbibliothek

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der

Deutschen Nationalbibliografie; detaillierte bibliografische Datensind im Internet über http://dnb.d-nb.de abrufbar.

ISBN:

Print    978-3-96009-009-0

PDF    978-3-96010-033-1

ePub    978-3-96010-034-8

mobi    978-3-96010-035-5

1. Auflage 2016

Dieses Buch erscheint in Kooperation mit O’Reilly Media, Inc. unter dem Imprint »O’REILLY«. O’REILLY ist ein Markenzeichen und eine eingetragene Marke von O’Reilly Media, Inc. und wird mit Einwilligung des Eigentümers verwendet.

Copyright © 2016 dpunkt.verlag GmbH

Wieblinger Weg 17

69123 Heidelberg

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.

Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.

Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen.

5 4 3 2 1 0

Inhalt

Einführung

Wer braucht eigentlich PowerShell?

Wie Sie dieses Buch nutzen

Noch mehr Unterstützung

1     PowerShell kennenlernen

Die PowerShell-Konsole einrichten

PowerShell-Konsole starten

PowerShell-Version kontrollieren

Symbol an Taskleiste heften

Bessere Schrift für die Konsole

Neue Konsolenfunktionen bei Windows 10 aktivieren

Sprungliste: Administratorrechte und ISE

32-Bit- und 64-Bit-Versionen

PowerShell ISE einsetzen

Erste Schritte mit PowerShell

Wichtige Vorsichtsmaßnahmen

Befehle eingeben

Ergebnisse empfangen

Farbcodierungen verstehen

Rechnen mit PowerShell

Umwandlungen

Zahlenreihen

Unvollständige und mehrzeilige Eingaben

Skriptausführung erlauben

Tippfehler vermeiden und Eingaben erleichtern

Autovervollständigung

Pfadnamen vervollständigen

Befehlszeilen erneut verwenden

Befehlsnamen autovervollständigen

Parameter-Autovervollständigung

Argument-Autovervollständigung

PowerShell-Hilfe aus dem Internet nachladen

Hilfe ohne Internetzugang installieren

Hilfe bei PowerShell 3

Klassische Konsole oder moderner ISE-Editor?

Einschränkungen des ISE-Editors

Einschränkungen der klassischen Konsole

PowerShell-2.0-Testumgebung

Testen Sie Ihr Wissen!

Teil A   Interaktive Befehlskonsole

2     Cmdlets – die PowerShell-Befehle

Alles, was Sie über Cmdlets wissen müssen

Cmdlets für eine Aufgabe finden

Suche nach Tätigkeit oder Tätigkeitsbereich

Mit ISE nach Cmdlets suchen

Mit der Hilfe nach Cmdlets suchen

Mit Parametern Wünsche formulieren

Parameter wecken das volle Potenzial der Cmdlets

Drei universelle Parametertypen

Common Parameter – allgemeine Parameter für alle Cmdlets

Fehlermeldungen unterdrücken

Unvollständige Parameternamen

Parameter-Binding sichtbar machen

Neue Cmdlets aus Modulen nachladen

Neue Module automatisch nachladen

Auslaufmodell: Snap-Ins

Alias: Zweitname für Cmdlets

Aliase sind keine neuen Befehle

Befehlstypen ermitteln

Klassische cmd.exe-Interpreterbefehle sind Cmdlets

Eigene Aliase anlegen

Testaufgaben

3     PowerShell-Laufwerke

Dateisystemaufgaben meistern

Ordner anlegen

Dateien anlegen und Informationen speichern

Dateien finden

Dateien und Ordner kopieren

Dateien umbenennen

Dateien und Ordner löschen

Größe eines Laufwerks ermitteln

Größe eines Ordners ermitteln

Umgebungsvariablen

Alle Umgebungsvariablen auflisten

Auf einzelne Umgebungsvariablen zugreifen

Umgebungsvariablen ändern

Windows-Registrierungsdatenbank

Schlüssel suchen

Werte lesen

Neue Registry-Schlüssel anlegen

Werte hinzufügen, ändern und löschen

Virtuelle Laufwerke und Provider

Neue PowerShell-Laufwerke

Mit Pfadnamen arbeiten

Unterstützte Platzhalterzeichen in Pfadnamen

-Path oder -LiteralPath?

Existenz eines Pfads prüfen

Pfadnamen auflösen

Testaufgaben

4     Anwendungen und Konsolenbefehle

Programme starten

Optionen für den Programmstart festlegen

Nicht unterstützte Konsolenbefehle im ISE-Editor

Argumente an Anwendungen übergeben

Hilfe für Konsolenbefehle anzeigen

Beispiel: Lizenzstatus von Windows überprüfen

Argumentübergabe kann scheitern

Texteingaben an Konsolenbefehle senden

Ergebnisse von Anwendungen weiterverarbeiten

Error Level auswerten

Fragen an Benutzer stellen mit choice.exe

Rückgabetext auswerten

Rückgabetexte in Objekte verwandeln

Rückgabetext analysieren

Laufende Programme steuern

Feststellen, ob ein Prozess läuft

Auf einen Prozess warten

Einstellungen laufender Prozesse ändern

Prozesse vorzeitig abbrechen

Testaufgaben

5     Skripte einsetzen

PowerShell-Skripte verfassen

Skriptcode eingeben

Eingabehilfen spüren Tippfehler auf

Skript ausführen

Sicherheitseinstellungen und Ausführungsrichtlinien

Profilskripte – die Autostartskripte

Vier verschiedene Profilskripte – pro Host

Profilskript anlegen und öffnen

Typische Profilskriptaufgaben durchführen

Skripte außerhalb von PowerShell starten

PowerShell-Startoptionen

Befehlsfolgen extern ausführen

PowerShell-Code als geplante Aufgabe ausführen

Nicht-PowerShell-Skripte öffnen

Stapeldateien (Batchdateien)

VBScript-Dateien ausführen

Skripte digital signieren

Digitales Zertifikat beschaffen

Zertifikat aus PFX-Datei laden

Zertifikat aus Zertifikatspeicher laden

Skript digital signieren

Digitale Signaturen überprüfen

Signaturen mit einem Zeitstempel versehen

6     Die PowerShell-Pipeline

Aufbau der PowerShell-Pipeline

Prinzipieller Aufbau der Pipeline

Die sechs wichtigsten Pipeline-Befehle

Select-Object

Selbst festlegen, welche Informationen wichtig sind

Platzhalterzeichen verwenden

Weitere Informationen anfügen

-First, -Last und -Skip

Unsichtbare Eigenschaften sichtbar machen

Sonderfall -ExpandProperty

Wie ETS Objekte in Text verwandelt

Where-Object

Where-Object: stets nur zweite Wahl

Clientseitiger Universalfilter

Leere Elemente aussortieren

Fortgeschrittene Syntax bietet noch mehr Möglichkeiten

Dateiinhalte filtern

IP-Adressen bestimmen

Alternativen zu Where-Object

Sort-Object

Cmdlet-Ergebnisse sortieren

Nach mehreren Spalten sortieren

Sortierung mit anderen Cmdlets kombinieren

ForEach-Object

Grundprinzip: eine Schleife

Group-Object

Häufigkeiten feststellen

Gruppen bilden

Measure-Object

Statistische Berechnungen

Ordnergrößen berechnen

Mit »berechneten« Eigenschaften arbeiten

Datentyp der Sortierung ändern

Gruppierung nach bestimmten Textteilen

Umwandlung von Byte in Megabyte

Hashtables: mehrere Werte übergeben

Mehrere Spalten in umgekehrter Sortierung

Mehrspaltige Anzeigen

Berechnete Spalten hinzufügen

Spaltenbreite, Bündigkeit und Gruppenüberschriften

Frei wählbare Gruppierungskriterien

Pipeline und Performance: Optimierungen

Flaschenhals Pipeline

Klassische Schleifen sind wesentlich schneller

Die Pipeline ist wesentlich reaktionsfreudiger

Weniger Speicherbedarf oder mehr Geschwindigkeit?

Testaufgaben

7     Ergebnisse ausgeben und formatieren

Ergebnisse als Text darstellen

Ergebnisse in Textdateien schreiben

Textformatierung ändern

Automatische Textformatierung verstehen

Mehrspaltige Anzeige

Out-Printer: Ergebnisse zu Papier bringen

Out-WinWord: Ergebnisse direkt an Microsoft Word senden

Out-PDF: mit Microsoft Word PDF-Reports erstellen

Ergebnisse als Objekte exportieren

Export-CSV: Export an Microsoft Excel und andere Programme

Ergebnisse serialisieren mit XML und JSON

HTML-Reports erstellen

Objekteigenschaften in HTML-Spalten umwandeln

HTML im Webbrowser anzeigen

HTML-Reports ansprechend und farbig gestalten

Testaufgaben

Teil B   Objektorientierte Shell

8     Mit Objekten arbeiten

Eigenschaften und Methoden

Eigenschaften

Methoden

Eigenschaften und Methoden anzeigen

Hilfe für Objekteigenschaften und -methoden finden

Ergebnisse eines Befehls untersuchen

Unterschiedliche Objekttypen

Nach Objekttypen filtern

Änderbare Eigenschaften finden

Primitive Datentypen sind auch Objekte

Eigenschaften lesen

Eigenschaften von vielen Objekten gleichzeitig abrufen

Eigenschaften ändern

Änderungen wirksam werden lassen

Methoden aufrufen

Eine Methode mit mehreren Signaturen

Testaufgaben

9     Operatoren und Bedingungen

Operatoren – Aufbau und Namensgebung

Wie Operatornamen aufgebaut sind

Unäre Operatoren

Zuweisungsoperatoren

Vergleichsoperatoren

Unterscheidung zwischen Groß- und Kleinschreibung

Unterschiedliche Datentypen vergleichen

Vergleiche umkehren

Vergleiche kombinieren

Vergleiche auf Arrays anwenden

Bedingungen

if-Bedingung

Switch-Bedingung

Where-Object

10   Textoperationen und reguläre Ausdrücke

Texte zusammenfügen

Variableninhalte mit doppelten Anführungszeichen integrieren

Der Formatierungsoperator »-f«

Textstellen finden und extrahieren

Texte splitten

Informationen in Texten finden

Reguläre Ausdrücke: Textmustererkennung

Erste Schritte: Mit Textmustern arbeiten

Bestandteile eines regulären Ausdrucks

Längste oder kürzeste Fassung?

Textstellen ersetzen

Ersetzungen ohne Zeichenverlust

Bezug auf den Originaltext nehmen

Delegatfunktionen

Rückverweise im Muster

Split und Join: eine mächtige Strategie

Nach verschiedenen Zeichen splitten

Splitten ohne Trennzeichen(verlust): LookBehind und LookAround

Mehrere Treffer in einem Text finden

[Regex]::Matches einsetzen

Ein- und Mehrzeilenmodus

Testaufgaben

11   Typen verwenden

Typumwandlungen

Automatische Typzuweisung durch PowerShell

Explizite Umwandlung in einen anderen Typ

Testumwandlungen zum Validieren

Verkettete Umwandlungen

Umwandlungen bei Cmdlets

Neue Objekte durch Typumwandlungen

Implizite Umwandlung und typisierte Variablen

Typisierte Variablen

Typisierte Parameter

Typisierte Eigenschaften und Argumente

Vergleichsoperationen

Verborgene Befehle in Typen

Statische Methoden verwenden

Eindeutige GUIDs generieren

Dateiextension ermitteln

Mathematische Funktionen

Zahlenformate konvertieren

DNS-Auflösung

Umgebungsvariablen

Pfade zu Systemordnern finden

Konsoleneinstellungen

Spezielle Datumsformate lesen

Statische Eigenschaften verwenden

Neue Objekte herstellen

Konstruktoren verstehen

Ein Credential-Object zur automatischen Anmeldung

Umgang mit XML-Daten

WMI-Remotezugriffe mit Anmeldung

COM-Objekte verwenden

Dialogfeld öffnen

Sprachausgabe

Office-Automation

Zugriff auf Datenbanken

Automatische Updates

Verknüpfungen anlegen und ändern

Netzwerkmanagement

Welche COM-Objekte gibt es sonst noch?

Webdienste ansprechen

SOAP-basierte Webdienste

RESTful-Webdienste

Neue .NET-Typen finden

Type Accelerators untersuchen

.NET-Assemblies durchsuchen

Typen nach Stichwort suchen

Typen mit bestimmten Befehlen finden

Typen nachladen

Assembly-Namen feststellen

Aktuell geladene Assemblies auflisten

Zusätzliche Assembly nachladen

Assembly aus Datei nachladen

Testaufgaben

Teil C   Automationssprache

12   Einfache Funktionen

Alles Wichtige: ein Überblick

Eigene Funktionen herstellen

Parameter definieren

Parameter implementieren

Funktionen per Modul überall verfügbar machen

Hilfe – Bedienungsanleitung hinzufügen

Eine bessere Prompt-Funktion

Zwingend erforderliche Parameter

Eine Funktion mit zwingend erforderlichen Parametern

Automatische Nachfrage

Argumente ohne Parameter

Rückgabewerte festlegen

Mehrere Rückgabewerte werden zum Array

Return-Anweisung

Write-Output

Unerwünschte Rückgabewerte unterdrücken

13   Skriptblöcke

Skriptblöcke: Transportcontainer für Code

Einsatzbereiche für Skriptblöcke

Skripte sind dateibasierte Skriptblöcke

Code in separater PowerShell ausführen

Code remote ausführen

Rückgabewerte

Pipeline-Fähigkeit

Schleifen und Bedingungen

Gültigkeitsbereiche

Zeitkapsel: Closures

Delegates

Zugriff auf AST und Parser

Codesicherheit

14   Pipeline-fähige Funktionen

Anonyme Pipeline-Funktion

Prototyping

Pipeline-fähige Funktion erstellen

Benannte Parameter

Where-Object durch eine Funktion ersetzen

Kurzes Resümee

Parameter und Pipeline-Kontrakt

»ISA«-Kontrakt: Pipeline-Eingaben direkt binden

»HASA«-Kontrakt: Objekteigenschaften lesen

»HASA« und »ISA« kombinieren

CSV-Dateien direkt an Funktionen übergeben

Aliasnamen für Parameter

Modularer Code mit Pipeline-fähigen Funktionen

Ausgangspunkt: ein unleserliches Skript

Teil 1: Get-NewFilenameIfPresent

Teil 2: ConvertTo-AbsoluteURL

Teil 3: Get-ImageFromWebsite

Teil 4: Download-File

15   Objektorientierte Rückgabewerte

Mehrere Informationen zurückgeben

Objekte speichern mehrere Informationen strukturiert

Eigene Objekte mit Ordered Hashtables anlegen

Primär sichtbare Eigenschaften festlegen

16   Fortgeschrittene Parameter

Argumentvervollständigung

Statische Autovervollständigung für Parameter

Autovervollständigung über Enumerationsdatentyp

Autovervollständigung über ValidateSet

Vordefinierte Enumerationsdatentypen finden

Eigene Enumerationsdatentypen erstellen

Dynamische Argumentvervollständigung

Zuweisungen mit Validierern überprüfen

ValidateSet

ValidateRange

ValidateLength

ValidatePattern

ValidateCount

ValidateScript

Nullwerte und andere Validierer

Parameter in ParameterSets einteilen

Gegenseitig ausschließende Parameter

Binding über Datentyp

Parameter in mehreren Parametersätzen

Simulationsmodus (-WhatIf) und Sicherheitsabfrage (-Confirm)

Festlegen, welche Codeteile übersprungen werden sollen

Weiterleitung verhindern

Praxisbeispiel: Automatische Auslagerungsdateien aktivieren

Gefährlichkeit einer Funktion festlegen

Dynamische Parameter

Dynamische Parameter selbst definieren

Auf die Argumente dynamischer Parameter zugreifen

»Clevere« dynamische Parameter

Performance und Caching

Parameter mit dynamischen Vorschlagslisten

Dynamische Währungslisten anzeigen

Objektgenerator mit dynamischen Parametern

Dynamische Parameter mit dynamischen ValidateSets

Splatting: mehrere Parameter gleichzeitig ansprechen

Splatting im Alltag einsetzen

Übergebene Parameter als Hashtable empfangen

Mit Splatting Parameter weiterreichen

17   Eigene Module erstellen

Module sind Ordner

Funktion erstellen und testen

Funktion in Modul aufnehmen

Modul manuell importieren

Module automatisch importieren

Manifestdatei für ein Modul

Neue Manifestdatei anlegen

Wirkung einer Manifestdatei

ETS-Anweisungen zu Modul hinzufügen

Eindeutige Typnamen zuweisen

Neue Formatierungsangaben in ETS einfügen

Formatdefinition in Modul integrieren

ETS-Formatierung testen

Aufbau von FormatData-Definitionen

Module entfernen

18   PowerShellGet – Module verteilen und nachladen

PowerShell Gallery nutzen

NuGet-Provider installieren

Repository

Module finden und installieren

Modul herunterladen

Modul testweise ausführen

Modul dauerhaft installieren

Module aktualisieren

Side-by-Side-Versionierung

Eigene Module veröffentlichen

Privates Repository einrichten

Freigaben zum Lesen und Schreiben

Repository anlegen

Modul in Repository übertragen

Modul aus Repository installieren

19   Gültigkeitsbereiche

Gültigkeitsbereiche verstehen

Unterschied zwischen Lesen und Schreiben

Aufpassen bei Objekten und Referenzen

Parameter liefern Referenzen

Gemeinsam genutzte Variablen

Skriptglobale »Shared« Variable

Globale Variable

Direkter Zugriff auf Gültigkeitsbereiche

Dot-Sourcing: Skripte im Aufruferkontext

»Dot-Sourcing« verstehen

Aufruftyp eines Skripts testen

Gültigkeitsbereiche in Modulen

Modulcode greift auf Aufruferkontext zu

Aufruferkontext greift auf Modulkontext zu

20   Debugging – Fehler finden

Syntaxfehler erkennen und beheben

Folgefehler und der Blick auf das Wesentliche

Formale Regeln missachten

Laufzeit- und Logikfehler aufspüren

Falsche Verwendung von Operatoren

Tippfehler ändern den Code

Nicht initialisierte Variablen

Versehentliche Verwendung von Arrays

Fehlendes Verständnis für Objektreferenzen

Falsche Verwendung von Klammern

Falsche Zuordnung von Skriptblöcken

Schrittweise Ausführung mit dem Debugger

Haltepunkte setzen und Code schrittweise ausführen

Codeausführung fortsetzen

Ad-hoc-Debugging

Dynamische Haltepunkte setzen

Anhalten, wenn Variablen sich ändern

Anhalten, wenn Cmdlets oder Funktionen aufgerufen werden

Anhalten, wenn Variablen bestimmte Werte enthalten

Debugging-Meldungen ausgeben

Ein Skript mit Write-Debug testen

Write-Debug in echte Haltepunkte umwandeln

Tracing einsetzen

Fremde Prozesse debuggen

Testszenario: PowerShell-Code in fremdem Prozess

Testskript in fremdem Host starten

Verbindung mit fremdem Host aufnehmen

Runspace auswählen und debuggen

Debug-Sitzung beenden

Remote-Debugging

Mit Remotecomputer verbinden

Remoteskript laden und debuggen

21   Fehlerhandling

Fehlermeldungen unterdrücken

Bestimmen, wie Cmdlets auf Fehler reagieren

Fehler nachträglich analysieren

Fehler mitprotokollieren lassen

Erfolg eines Befehlsaufrufs prüfen

Fehlerhandler einsetzen

Lokaler Fehlerhandler: try...catch

Globaler Fehlerhandler: Trap

Spezifische Fehlerhandler

Exception-Namen ermitteln

Spezifische Fehlerhandler nutzen

Spezifische Fehlerhandler in Traps

Spezifizität des Fehlerhandlers justieren

Eigene Fehler auslösen

Mit Throw einen Fehler auslösen

Spezifische Fehler auslösen

Upstream-Kommunikation in der Pipeline

Pipeline vorzeitig abbrechen

Pipeline mit Select-Object abbrechen

Pipeline manuell abbrechen

Testaufgaben

Teil D   Remoting und Parallelverarbeitung

22   Fernzugriff und Netzwerk-Troubleshooting

Klassische Fernzugriffe

Dateisystem

Konsolenbefehle

Remotefähige Cmdlets

Troubleshooting für Fernzugriffe

Firewall für DCOM einrichten

Namensauflösung überprüfen

Remote-Registrierungszugriff erlauben

Access Denied: mit passenden Rechten anmelden

LocalAccountTokenFilterPolicy

Ports überprüfen

23   Windows PowerShell-Remoting

PowerShell-Remoting aktivieren

Ohne Kerberos und Domäne

TrustedHosts-Liste

PowerShell-Remoting überprüfen

Erste Schritte mit PowerShell-Remoting

Remoting-Unterstützung im ISE-Editor

Befehle und Skripte remote ausführen

Kontrolle: Wer besucht »meinen« Computer?

Remotefähigen Code entwickeln

Argumente an Remotecode übergeben

Ergebnisse vom Remotecode an den Aufrufer übertragen

Fan-Out: integrierte Parallelverarbeitung

ThrottleLimit: Parallelverarbeitung begrenzen

Double-Hop und CredSSP: Anmeldeinfos weiterreichen

Eigene Sitzungen verwenden

Eigene Sitzungen anlegen

Parallelverarbeitung mit PSSessions

Sitzungen trennen und wiederverbinden

Aktive PSSessions trennen

Beispiel: Invoke-Command -InDisconnectedSession

Endpunkte verwalten

Vorhandene Endpunkte anzeigen

Standardendpunkt festlegen

Remote auf Endpunkte zugreifen

Neue Endpunkte anlegen

Zugriffsberechtigungen für Endpunkt festlegen

Benutzerkontext ändern

Eingeschränkte Endpunkte anlegen

Bereitgestellte Befehle weiter einschränken

Eigene Funktionen definieren und bereitstellen

Reguläre PowerShell-Sitzungen einschränken

Limit-Runspace: Befehlsumfang und Sprachmodus bestimmen

Endpunkte per Skript absichern

Eigene Funktionen einsetzen

Sitzungsinhalte importieren

Cmdlets eines Remotesystems importieren

Remotesitzungen als Modul exportieren

Datentransfer und Optimierung

Deserialisierte Objekte

Serialisierungsvorgang

Performanceoptimierung

Datentransfer mit PowerShell-Remoting

Weitere Remoting-Einstellungen

Clientseitige Sitzungsoptionen

Zugriff auf Remoting-Einstellungen

Einstellungen ändern

Fehler finden und beheben

RPC-Server nicht verfügbar

Zugriff verweigert

Kerberos-Fehlermeldung

Öffentliche Netzwerke entdeckt

Andere Fehler

24   Just Enough Admin (JEA)

Just Enough Admin (JEA)

Virtuelle Administratorkonten

Rollenmodell

Virtuelle Administratorkonten

Voraussetzungen

PowerShell-Remoting überprüfen

JEA-Endpunkt einrichten

JEA-Endpunkt verwenden

Gefahren bei der Elevation

Unterschieben bösartiger Module und Befehle

Angriffsszenario mit Administratorrechten

Angriffsszenario ohne Administratorrechte

Best Practices für JEA-Endpunkte

Rollenbasierte Rechtevergabe

Rollen anlegen

Befehlsumfang der Rollen definieren

Praxisbeispiel: Verwaltung im Active Directory

Endpunkt für die Verwaltung des Active Directory

Modul für die Verwaltung des Active Directory

Rollenbasierte Verwaltung

25   Hintergrundjobs und Parallelverarbeitung

Hintergrundjobs

Mehrere Aufgaben parallelisieren

Integrierte Hintergrundjobs

Hintergrundjobs auf Remotecomputern

Multithreading

Einen separaten Thread erzeugen

Hintergrundüberwachungen einrichten

Foreach-Schleife mit Parallelbearbeitung

Foreach-Parallel nachrüsten

Maximale Thread-Anzahl festlegen

Maximale Ausführungszeit festlegen

Lokale Variablen einblenden

Hintergrundjobs auf Thread-Basis

Teil E   DevOps und Enterprise

26   Workflows

Brauche ich Workflows?

Wie relevant sind Workflows wirklich?

Aufgaben orchestrieren

Orchestrierung in klassischer Funktion

Orchestrierung mit Workflow: sequence und parallel

Workflows sind kein PowerShell-Code

Syntaktische Unterschiede und Kompatibilitätsprobleme

InlineScript: echten PowerShell-Code ausführen

Variablen und Gültigkeitsbereiche

Zugriff auf »fremde« Variablen

Workflow-globale Variablen

Variablen in InlineScript

Informationen mit Parametern übergeben

Ergebnisse über Rückgabewerte zurückliefern

Funktionen verwenden

Verschachtelte Workflows

Remotezugriff

Parallelverarbeitung

Globale Variablen synchronisieren parallele Aufgaben

Parallelbearbeitung in einer Schleife

Throttling für Parallelschleifen

Unterbrechung und Wiederaufnahme

Manuelle Unterbrechung

Automatische Unterbrechung

Persistierende Hintergrundjobs

Prüfpunkte für eine kontrollierte Wiederaufnahme

Workflow-Server: Schutz vor unkontrollierten Abstürzen

Workflows optimieren

27   Desired State Configuration (DSC)

Workflows und DSC – eine Reise ins DevOps-Land

Voraussetzungen für DSC

Architektur

Was sind Ressourcen?

Mitgelieferte Ressourcen untersuchen

Integrierte Testfunktion in Ressourcen

Aktuellen Zustand ermitteln

Änderung durchführen

Was sind Konfigurationen?

Eine einfache DSC-Konfiguration erstellen

Konfiguration als MOF-Datei speichern

Konfiguration auf Computer anwenden

Was ist der Local Configuration Manager?

Die Master-Konfiguration

Reset: LCM zurücksetzen

Konfiguration überprüfen

Konfigurationshistorie abrufen

Das »Was?« vom »Wo?« abgrenzen

Schlecht: Umgebungsinformationen in Konfigurationen

Umgebungsinformationen ausgliedern

Umgebungsinformationen als ConfigurationData übergeben

Komplexere Umgebungen definieren

Identität und Umgang mit Geheimnissen

Konfigurationen im Benutzerkontext ausführen

Sensible Informationen verschlüsseln

Kennwörter in DSC-Konfigurationen verschlüsseln

Mitgelieferte Ressourcen

Verfügbare Ressourcen auflisten

Ressource »Archive«

Ressource »Environment«

Ressource »Group«

Zusätzliche Ressourcen

Ressourcen aus der PowerShell Gallery beziehen

Eigene DSC-Ressourcen schreiben

ResourceDesigner installieren

Ressource konzipieren

Ressource anlegen

Get-TargetResource entwerfen

Test-TargetResource

Set-TargetResource

Neue Ressource testen

Neue Ressource in DSC-Konfiguration nutzen

Orchestrierung

Abhängigkeiten definieren

Systemübergreifende Abhängigkeiten

Partielle Konfigurationen

LCM konfigurieren

Letzte Konfiguration wiederherstellen

Konfigurationen automatisch überwachen und anwenden

Teil F   Spezielle Techniken

28   Ereignisverarbeitung mit Events

Ereignisse verwenden

Ein Ereignis asynchron überwachen

Ein Ereignis synchron überwachen

Hintergrundjobs überwachen

Manuelle Überwachung

Automatische Überwachung

Ordner überwachen

Aufgaben regelmäßig durchführen

WMI-Ereignisse empfangen

Details zum Event erfahren

Systemänderungen erkennen

Eigene Ereignisse auslösen

Automatische Variablenüberwachung einrichten

29   Extended Type System (ETS)

PowerShell-Objekte verstehen

Erweiterte PowerShell-Objekte

Objekte mit Add-Member erweitern

Dauerhafte Erweiterungen

AliasProperty: Eigenschaften »umbenennen«

NoteProperty: Objekte »taggen«

ScriptProperty: »berechnete« Eigenschaften

Lesbare Eigenschaften

Lesbare und schreibbare Eigenschaften

ScriptMethod und ParameterizedProperty

Membertypen für den internen Gebrauch

PropertySet: Gruppen von Eigenschaften

MemberSet: Wie soll PowerShell das Objekt behandeln?

30   Proxyfunktionen verstehen und einsetzen

Eine Proxyfunktion erstellen

Bestehende Cmdlets erweitern

Automatische Protokollfunktion

Get-ChildItem mit neuen Parametern

Proxyfunktion anlegen

Logik implementieren

Proxyfunktionen für Remoting

Eine Remotesitzung erstellen

Einen Remotebefehl in lokale Sitzung importieren

31   Benutzeroberflächen gestalten

Eigene Fenster mit WPF erzeugen

Ein Fenster gestalten – allein mit Code

Ein Fenster gestalten – mit XAML

Auf Elemente des Fensters zugreifen

Auf Ereignisse reagieren

Werkzeuge für das WPF-Design

Mit dem WPF-Designer von Visual Studio arbeiten

Neue grafische Elemente einfügen

Elemente im Fenster anordnen

StackPanels

Grids

DockPanels

Datenbindungen

Ereignisse behandeln

Ereignisse mit Werkzeugen erforschen

Ereignisse manuell erforschen

Multithreading

Fenster anzeigen und weiterarbeiten

Oberfläche aktualisieren

Aufgaben im Hintergrund durchführen

Mehrere Threads verwenden

Thread-übergreifende Aktionen

Thread-übergreifendes Databinding

Bilder in WPF einbetten

Bild in Text verwandeln

Text in Bild verwandeln

32   Pester – »Test-Driven Development«

Pester installieren oder aktualisieren

Eine simple Funktion auf TDD-Art entwickeln

Eine neue Funktion entwerfen

Einen Test formulieren

Test ausführen

Funktionalität implementieren

Architektur der Pester-Tests

Gefahren und Vorsichtsmaßnahmen

Funktionen nachträglich erweitern

Assertions – Ergebnisse überprüfen

Die richtige Assertion wählen

Eine Assertion testen

Mehrere Assertions kombinieren

Simulationen und Alltagstests

Befehle vorübergehend außer Kraft setzen

Mock-Funktion über Parameter auswählen

Reale Tests und notwendige Aufräumarbeiten

TestDrive – ein Ort für temporäre Daten

»Test Cases« und Wiederverwertung

»Code Coverage« und Eigenentwicklungen

Testabdeckung überprüfen

Eigene Testtools auf Pester aufsetzen

33   PowerShell-Umgebung anpassen

Profilskripte einsetzen

Vier Profilskripte

Profilskripte öffnen und ändern

Profilskripte bei Bedarf nachladen

Eingabeaufforderung anpassen

Konsolendarstellung verbessern

ISE-Editor erweitern

Auf den Editor zugreifen

Befehle über das Menü anbieten

Add-On-Tools verwenden

Zugriff auf die Skriptstruktur

Zwei Parser: Text in Token verwandeln

Kommentare entfernen

Aliase auflösen

Syntaxfehler finden

Abstract Syntax Tree (AST)

34   .NET Framework und PowerShell

Auf API-Funktionen zugreifen

API-Funktionen in PowerShell einblenden

API-Funktion einsetzen

Wiederverwertbare PowerShell-Funktion herstellen

PowerShell-Klassen einsetzen

Neue Klasse zur besseren Prozesse-Verwaltung

Statische Eigenschaften und Methoden

Vererbung von Klassen

Eine abgeleitete Klasse erstellen

Abgeleitete Klasse einsetzen

Die wesentlichen Aspekte der Vererbung

Eine weitere abgeleitete Klasse

C#-Code verwenden

Klasse mit PowerShell-Mitteln erstellen

Klasse mit C#-Code entwickeln

Index

Einführung

Wer braucht eigentlich PowerShell?

Jeder, der eine Aufgabe zweimal tut, sollte über Automation nachdenken. In der IT müssen viele Aufgaben nicht nur zweimal, sondern hundert- oder tausendfach erledigt werden. Und jeder kennt die wenig geliebten und immer wiederkehrenden Aufgaben: Monatliche Reports müssen erstellt oder Logbuchdaten durchforstet werden.

Was immer es ist und ganz gleich, ob beruflich oder privat motiviert: PowerShell ist die Sprache, mit der Sie solche Aufgaben beschreiben und danach so oft Sie mögen – und wann Sie mögen – von PowerShell ausführen lassen können. Das ist nicht nur bequemer, es kann auch im Not- oder Krisenfall wichtig sein. Wer dann die entsprechenden Notfallskripte zur Hand hat, lässt die in ruhigen Zeiten erarbeiteten Aufgaben blitzschnell abarbeiten.

Während Sie kleinere Aufgaben auf Ihrem eigenen Computer mit PowerShell automatisieren, ist diese Automationssprache auch für flächendeckende und unternehmensweite Automation hervorragend geeignet. Es gibt hier kaum Grenzen, und die PowerShell-Automation kann ganze Unternehmensstrukturen abbilden.

Über das sogenannte »PowerShell Remoting« (Kapitel 23) kommunizieren PowerShells über das Netzwerk miteinander, und dank PowerShell 6 steht PowerShell auch in heterogenen Landschaften zu Beispiel auf Linux und MacOS zur Verfügung.

Was die Frage aufwirft: Warum handelt dieses Buch eigentlich von PowerShell 5, wenn es offenbar auch ein PowerShell 6 gibt?

»Windows PowerShell« 5 vs. »PowerShell« 6

Seit der ersten »Windows PowerShell«-Version in 2006 ist inzwischen »Windows PowerShell« 5 auf allen Windows-Systemen ab Windows 7 und Server 2008R2 der empfohlene Standard. Sie müssen allenfalls noch Ihre »Windows PowerShell«-Version auf die aktuellste Version bringen, wobei Ihnen Kapitel 1 zur Seite steht. »Windows PowerShell« ist nun »fertiggestellt« und wird sich auch nicht mehr wesentlich ändern. Stattdessen arbeitet Microsoft jetzt an »PowerShell« 6 weiter.

Huh? Ist es also doch nicht fertig? Die Wahrheit ist: »PowerShell« 6 ist nicht der Nachfolger von »Windows PowerShell« 5. Lassen Sie uns also kurz ein wenig Klarheit in die PowerShell-Versionen bringen, damit Sie wissen, welche PowerShell für Sie richtig ist.

»Windows PowerShell« …

Die fest in Windows integrierte PowerShell nennt Microsoft »Windows PowerShell«. Sie wird auch künftig in Windows integriert sein und basiert auf dem vollständigen .NET Framework, also den vollständigen Programmierschnittstellen des Windows-Betriebssystems. »Windows PowerShell« kann deshalb alle Aspekte und Funktionen von Windows verwalten und automatisieren.

Diese »Windows PowerShell« gilt nun in Version 5 als ausgereift und fertiggestellt. Sie haben auf Jahre Planungssicherheit.

… und »PowerShell«

»PowerShell« 6 ist eine Neuentwicklung, die auf einem eingeschränkten und portablen .NET Framework basiert (dem sogenannten .NET Core). Es ist auch auf Linux und MacOS lauffähig und steht ausschließlich als optionaler Download von https://github.com/PowerShell/PowerShell zur Verfügung.

Der Vorzug von PowerShell 6 ist nicht etwa ein noch größerer Funktionsumfang. Wegen des eingeschränkten .NET Framework ist eher das Gegenteil der Fall. Der Vorzug von PowerShell 6 ist seine universelle Einsetzbarkeit. Es ist nicht mehr auf Windows beschränkt.

Zwar ist es technisch möglich, aber derzeit nicht besonders sinnvoll, auf Windows-Systemen die »PowerShell« 6 einzusetzen. Greifen Sie besser zur eingebauten »Windows PowerShell«. Sie kann deutlich mehr. Nur wenn Sie Nicht-Windows-Systeme in Ihre Automationspläne integrieren möchten, verwenden Sie dort »PowerShell« 6.

Über das »PowerShell Remoting« aus Kapitel 23 können »Windows PowerShell« und »Power- Shell« 6 quer über das Netzwerk miteinander kommunizieren.

Warum PowerShell lernen?

PowerShell-Analphabetismus konnte man als Windows-Administrator in den ersten Jahren noch gut kaschieren, doch inzwischen lässt sich dieses Defizit kaum noch verbergen. Zu allgegenwärtig ist PowerShell im Betriebssystem und in vielen Softwareprodukten, und wer es nicht beherrscht, kann häufig schlicht einen Teil seines Jobs nicht mehr erledigen.

Umgekehrt wird ein angenehmerer Schuh daraus: Wer sich bislang erfolgreich vor PowerShell »gedrückt« hat, kann sich mit einigen Wochen des Lernens (natürlich verbunden mit den üblichen Frustrationen, die zu jedem Erlernen dazugehören) das gesamte Funktionsspektrum der aktuellsten Windows-PowerShell-Version 5 zu eigen machen. Seit es PowerShell 6 auf Linux und MacOS gibt, können Sie Ihr PowerShell-Wissen sogar ohne großen Aufwand auch auf andere Betriebssysteme übertragen, und wer PowerShell beherrscht, wird für sein Unterneh men ein immer wertvollerer Mitarbeiter.

Moderne Lernkurve

Wer vor der PowerShell-Konsole sitzt, sieht vor allem Befehle – die Cmdlets. Sie funktionieren etwa so wie Befehle in anderen Konsolen (Shells). Allerdings unterstützt PowerShell so viele davon und ist auf so gleichartige Weise erweiterbar, dass man mit ganz geringen (und vor allen Dingen vollkommen einheitlichen und konsistenten) Grundkenntnissen fast alles damit administrieren kann. Weil alle Cmdlets auf denselben Grundregeln basieren, kann man das Wissen auch leicht auf andere Aufgabenbereiche und Cmdlets anwenden.

Die ersten Schritte mit Cmdlets sind einfach und benötigen kaum PowerShell-Kenntnisse. Auch der Umgang mit der PowerShell-Pipeline ist zunächst recht einfach. Dann aber steht man vor einer Steilwand, die autodidaktisch oft nur schwer zu meistern ist. Hier werden viele wichtige Grundlagen gelegt. Man beschäftigt sich mit Operatoren, Objekten und der wahren Natur von PowerShell. Diese Steilwand meistern Sie mit diesem Buch.

Sobald die Grundlagen einmal gelegt sind, flacht die Lernkurve stark ab, und alles wird gut: Ob Sie mit Microsoft Exchange ein Postfach anlegen, mit SharePoint eine Site veröffentlichen oder einfach nur Protokolldateien parsen oder Server verwalten wollen – Ihr PowerShell-Wissen befähigt Sie dazu, über den Tellerrand zu blicken und Ihre PowerShell-Erfahrung auch in ganz anderen IT-Bereichen einzusetzen. Entscheidend ist nun nur noch Ihr Fachwissen im jeweiligen Bereich.

Abbildung E.1: Die PowerShell-Lernkurve ist nicht linear, sondern baut auf gemeinsamen Standards auf.

Sie müssen zwar schon selbst wissen, »warum« Sie ein Exchange-Postfach anlegen oder eine SharePoint-Site umbenennen wollen – »wie« das geschieht, ist aber dank der gemeinsamen PowerShell-Standards nun keine Frage mehr. Get-ADUser, Get-Mailbox, Get-SPSite und Get-VM beschaffen Ihnen mit denselben PowerShell-Grundkenntnissen Active-Directory-Benutzerkonten, Exchange-Server-Mailboxen, SharePoint-Sites oder VMware virtuelle Maschinen. Kennen Sie erst einmal ein Cmdlet, dann kennen Sie alle.

Computer – ich/ich – Computer: PowerShell als Fremdsprache

Entfernt man sich ein wenig von PowerShell und betrachtet die Technik mit mehr Abstand, verschwimmen die einzelnen Befehle zu etwas Neuem: einer Sprache. Tatsächlich benimmt sich PowerShell in vielen Aspekten genau wie eine Fremdsprache, wie Spanisch oder Italienisch etwa, nur dass Sie sich diesmal nicht mit dem Eisverkäufer unterhalten, sondern mit Ihrem Computer. Auch der Lernprozess, den Sie mit diesem Buch vor sich haben, verläuft ganz ähnlich.

Zuerst steht Vokabelpauken auf dem Plan, und schon nach wenigen Minuten werden Sie mit den ersten Vokabeln bereits einfache Aufgaben lösen können. Dieser erste Lernschritt bildet den Teil »Interaktive Befehlskonsole« dieses Buchs (Kapitel 2–7). Hier lernen Sie den Umstieg von der klassischen cmd.exe-Befehlskonsole zur PowerShell, und für viele Administratoren reicht das Wissen aus diesem Teil bereits.

Dass PowerShell indes nicht eine klassische Textkonsole ist, sondern in Wirklichkeit eine hochmoderne objektorientierte Shell, entdecken Sie im Teil »Objektorientierte Shell« (Kapitel 8–11).

PowerShell als Ersatz für VBScript und Batch

Nachdem Sie die Sprache beherrschen, wird bei Ihnen mit einiger Wahrscheinlichkeit der Wunsch aufkommen, PowerShell nicht nur interaktiv zu verwenden, sondern auch als vollwertige Programmier- und Skriptsprache, um damit einfache und auch komplexe Automationsaufgaben zu lösen. Dies erwartet Sie im Teil »Automationssprache« (Kapitel 12–21): Hier geht es zum einen darum, wiederkehrende Aufgaben mit PowerShell-Lösungen ein für alle Mal zu lösen.

Zum anderen geht es aber vor allem darum, wie Sie in PowerShell selbst automatisieren, also dafür sorgen, dass Sie nicht ständig ein Rad neu erfinden müssen. Sie erfahren, wie sich Ihre Automationslösungen in neue eigene PowerShell-Befehle kapseln lassen und wie Sie diese neuen Befehle für sich selbst und Ihre Kollegen bereitstellen können. Mit jeder neuen Lösung, die Sie entwickeln, wächst so Ihr Lösungsspektrum.

Grenzenloses PowerShell

PowerShell wird zwar auf lokalen Computern ausgeführt, kennt aber kaum Grenzen. Es steht inzwischen nicht nur auf Windows-Betriebssystemen zur Verfügung, sondern auch auf Linux und MacOS. Alle PowerShells können über das Netzwerk miteinander sprechen, sich abstimmen und so die Grundlage für übergreifende und unternehmensweite Automationslösungen sein. Lesen Sie dazu mehr im Teil »Remoting und Parallelverarbeitung« (Kapitel 22–25).

Neben der »räumlichen« Unabhängigkeit enthält PowerShell auch Wege, um die Sicherheitskontexte und Identitäten zu wechseln, in denen Befehle ausgeführt werden. Auch diese Technik beruht im Kern auf dem Remoting und bildet die Grundlage für JEA (Just Enough Admin), mit der eine rollenbasierte Administration möglich wird, zum Beispiel für Self-Servicing-Portale.

Strategische Plattform und Orchestrierung

Wer seine Infrastruktur »via Code« definieren und ausrollen möchte, findet in PowerShell auch hierzu machtvolle Lösungen.

Hierbei trennt PowerShell das »Was« vom »Wo«. Das »Was« könnte die Definition eines Webservers oder Active Directory sein. Das »Wo« entspräche den Konfigurationsdaten, also den jeweiligen Server- und Webnamen. Das »Wann« kann wiederum beliebig gewählt werden, denn sobald Infrastruktur als Code definiert ist, kann man die dahinterliegenden Automationsskripte jederzeit und beliebig häufig einsetzen. Mehr dazu zeigt Ihnen »DevOps und Enterprise« (Kapitel 26/27).

Anwendungsentwicklung

Zwar war PowerShell ursprünglich als Automationssprache gedacht, die unbeaufsichtigt Aufgaben durchführt. Inzwischen wird PowerShell allerdings häufig auch zur Anwendungsentwicklung eingesetzt: Administratoren schreiben sich maßgeschneiderte Tools selbst oder stellen Tools dem Helpdesk zur Verfügung.

Wie man solche Oberflächen in PowerShell gestaltet, ist ebenso Thema des Teils »Spezielle Techniken« (Kapitel 28–34) wie innovative neue Wege, um Skripte zuverlässig zu entwickeln und weiterzupflegen. Mit dem Test-Driven Development (TDD), das ebenfalls aus der modernen Softwareentwicklung stammt, lassen sich PowerShell-Skripte äußerst zuverlässig und mit eingebauter Qualitätskontrolle herstellen.

Persönliche Entwicklung

PowerShell kann eine Karriereentscheidung sein. Wann immer Sie eine Aufgabe lösen, stehen dahinter unsichtbare Motivationen. Die offensichtlichste ist natürlich, die Aufgabe gut zu erledigen, denn dafür werden Sie (wahrscheinlich) bezahlt. Ebenso wichtig ist aber, was die Lösung dieser Aufgabe sonst noch für Sie bedeutet und wie sie in Ihre Lebensbilanz einfließt. Wer sich Tag für Tag durch Dialogfelder klickt, kann zwar enorm erfolgreich Aufgaben lösen, entwickelt seine Fähigkeiten aber nicht weiter, und wenn das Dialogfeld eines Tages nicht mehr da ist, gilt das vielleicht auch für den eigenen Arbeitsplatz.

Es mag Sie anfangs etwas mehr Zeit kosten, die Lösung damit zu automatisieren, aber bedenken Sie: Jede Extraminute, die Sie hier investieren, investieren Sie eigentlich in Ihre persönliche Fortbildung. Auch ein Arbeitgeber sollte dies als Chance verstehen und Freiräume dafür gestatten. Denn mit jeder erfolgreich gemeisterten PowerShell-Lösung wächst Ihre Sprachfertigkeit. Wer PowerShell am Ende fließend spricht, ist bestens aufgestellt für moderne IT-Landschaften.

Gerade wenn Sie vorher noch nie geskriptet haben, sehen Sie PowerShell als Chance: Wer den Zug zu VBScript-Zeiten vor zehn Jahren vielleicht verpasst hat, kann heute auf einen neuen Zug aufspringen.

Wie Sie dieses Buch nutzen

Dieses Buch setzt keinerlei Grundkenntnisse voraus, zumindest wenn Sie von vorn zu lesen beginnen. Wer unter Zeitdruck steht, kann auch quer einsteigen, und wer noch weniger Zeit hat, findet am Anfang jedes Kapitels eine Zusammenfassung, in der die jeweils wichtigsten Inhalte für Krisenzeiten zusammengefasst sind.

Die PowerShell-Beispiele im Buch sind jeweils in einer anderen Schriftart formatiert. Damit Sie leichter erkennen, welche Eingaben von Ihnen erwartet werden, wird bei allen Eingaben die PowerShell-Eingabeaufforderung PS> (einschließlich der Leerstelle hinter dem >) vorangestellt. Diese Eingabeaufforderung kann bei Ihnen auch anders aussehen und sollte in den Beispielen natürlich nicht mit eingegeben werden.

Viele PowerShell-Codebeispiele sind sehr kurz und können mit geringem Aufwand schnell eingetippt werden. Umfangreichere Beispiele sind mit einer Listing-Unterschrift gekennzeichnet. Unter dem dort genannten Dateinamen finden Sie die Codebeispiele auch in den Begleitmaterialien, die Sie hier herunterladen können: http://downloads.oreilly.de/9783960090090.

Sollte es zu diesem Buch Errata geben, finden Sie sie ebenfalls hier: http://downloads.oreilly.de/9783960090090 .

Achtung

Bitte verwenden Sie die Begleitmaterialien immer im Kontext des entsprechenden Buchkapitels. Viele der Beispiele funktionieren nur, wenn Sie die entsprechenden Vorarbeiten im Kapitel beachtet haben, oder können auch unerwartete Resultate liefern, wenn man die Beispiele aus dem Zusammenhang des Kapitels reißt.

Noch mehr Unterstützung

Inzwischen gibt es in fast jedem Land eine starke PowerShell-Community. Auch in Ihrer Nähe finden sich »PowerShell User Groups«, in denen man kostenlos viel dazulernen und persönliche Kontakte aufbauen kann. Jährlich finden zudem internationale PowerShell-Konferenzen wie die »PowerShell Conference Europe« (http://www.psconf.eu) statt.

Falls bei der Arbeit mit diesem Buch Fragen auftauchen oder Sie Anregungen haben, besuchen Sie mich: http://www.powertheshell.com. Oder senden Sie mir eine Nachricht an meine Mailadresse [email protected].

Bevor ich Ihnen jetzt viel Spaß mit PowerShell wünsche, geht noch ein großes Dankeschön an meine Lektorin Ariane Hesse und die Korrektorin Sibylle Feldmann, die dieses Buch mit allergrößtem Sachverstand und mit Sorgfalt begleitet haben.

Herzlichst Ihr Dr. Tobias Weltner

Kapitel 1PowerShell kennenlernen

In diesem Kapitel:

Die PowerShell-Konsole einrichten

PowerShell ISE einsetzen

Erste Schritte mit PowerShell

Skriptausführung erlauben

Tippfehler vermeiden und Eingaben erleichtern

PowerShell-Hilfe aus dem Internet nachladen

Klassische Konsole oder moderner ISE-Editor?

Testen Sie Ihr Wissen!

Ausführlich werden in diesem Kapitel die folgenden Aspekte erläutert:

• PowerShell-Host: PowerShell ist Bestandteil von Windows und kein einzelnes Programm. Programme, die den Zugriff auf PowerShell ermöglichen, werden »Host« (»Gastgeber«) genannt. PowerShell liefert zwei Hosts mit: die PowerShell-Konsole (PowerShell.exe) und den komfortableren ISE-Editor (PowerShell_ise.exe).

• Groß- und Kleinschreibung: Die Groß- und Kleinschreibung wird bei Befehlen und Parameternamen nicht unterschieden.

• Farbcodierung während der Eingabe: Ab PowerShell 5 färbt nicht nur der ISE-Editor, sondern nun auch die PowerShell-Konsole Eingaben ein. Die Farben unterscheiden zwischen Befehlen, Parametern und Argumenten. So kann man Eingaben mit einem kurzen Blick auf die Farben auf Richtigkeit überprüfen. Enthält die Eingabe Syntaxfehler, also formale Fehler wie fehlende Anführungszeichen, kennzeichnet ISE diesen Teil mit einer roten Wellenlinie. Die Konsole zeigt eine rote spitze Klammer am Ende des Eingabeprompts an.

• Ausgabebefehle und Umwandlungsabkürzungen: PowerShell gibt Resultate sofort aus. Ein spezieller Ausgabebefehl wie echo ist nicht nötig. Auch unterstützt PowerShell einfache Rechenaufgaben, bei denen die in der IT üblichen Größenordnungen wie KB oder GB direkt (ohne Leerzeichen) an eine Zahl angefügt werden können. Mit dem Präfix 0x werden hexadezimale Zahlen markiert, und .. liefert einen Zahlenbereich, zum Beispiel 1..49.

• Autovervollständigung: Mit und gelangen Sie zurück zu Befehlsfolgen, die Sie schon einmal eingegeben haben. Möchten Sie einen Befehl nachträglich ändern oder erweitern, verwenden Sie die Pfeiltasten, um, anstatt den gesamten Befehl neu einzugeben, zu dem jeweiligen Befehl zurückzukehren und ihn zu ändern. Mit aktivieren Sie die eingebaute Autovervollständigung. Diese kann Befehlsnamen, Pfadnamen und andere Eingaben für Sie vervollständigen. Drücken Sie die Taste mehrmals, zeigt PowerShell bei jedem Druck einen anderen Vorschlag. In ISE steht außerdem das IntelliSense-Menü zur Verfügung, das über Eingabevorschläge nicht sofort einfügt, sondern zuerst in einem Kontextmenü anbietet.

• Zeilen löschen und Befehlsabbruch: Wollen Sie die gesamte aktuelle Zeile löschen, drücken Sie . Möchten Sie im Mehrzeilenmodus die aktuelle Zeile zwar nicht ausführen, aber auch nicht verlieren, drücken Sie .

• Skriptausführung: Anfangs kann PowerShell nur interaktive Befehle ausführen, aber keine Skripte. Mit Set-ExecutionPolicy sollte die Skriptausführung so bald wie möglich aktiviert werden, weil viele interaktive Befehle aus Skriptdateien geladen werden und andernfalls nicht funktionieren.

• Hilfe zu PowerShell-Befehlen: PowerShell-Befehle sind gut dokumentiert, aber die Dokumentation muss zunächst mit Update-Help aus dem Internet heruntergeladen werden.

• Unterschiedliche PowerShell-Versionen: Es gibt aktuell fünf PowerShell-Versionen, die alle aufeinander aufbauen. Die aktuelle PowerShell-Version erfährt man zum Beispiel über den Befehl $host.Version.

Häufig wird PowerShell gleichgesetzt mit der typisch blauen Textkonsole, die kryptische Befehlseingaben von Ihnen erwartet. Dieses Bild wäre aber falsch. PowerShell ist keine Textkonsole.

PowerShell ist eine Automationssprache und vollkommen unabhängig von bestimmten Programmen. Sie ist als Teil des »Windows Management Framework« (WMF) fest in das Betriebssystem Windows integriert. Die PowerShell-Konsole (PowerShell.exe) ist also lediglich ein Programm, mit dem man Kontakt zur PowerShell aufnehmen kann. Andere Programme können das auch, und so ist die PowerShell-Konsole längst nicht das einzige Programm, in dem Ihnen die Sprache »PowerShell« begegnet.

Bettet ein Programm – so wie die PowerShell-Konsole – die PowerShell-Sprache ein, wird es »PowerShell-Host« oder einfach nur »Host« genannt. Dieses englische Wort steht für »Gastgeber«, und so sind PowerShell-Programme Gastgeber für die PowerShell, bieten also die Bühne und Ihnen die Möglichkeit, Befehle an PowerShell zu senden und Ergebnisse zu empfangen. Ein weiterer solcher Host ist ebenfalls Bestandteil von Windows: der modernere »ISE«-Editor (»Integrated Script Environment«, PowerShell_ise.exe).

Softwarehersteller können mit wenigen Zeilen Code PowerShell ebenfalls in ihre Anwendungen einbetten, also eigene Hosts erstellen. Weil alle diese Programme im Hintergrund auf dieselbe PowerShell-Engine zugreifen, gibt es trotz unterschiedlicher Hosts keine verschiedenen PowerShell-Dialekte. PowerShell-Code funktioniert überall gleich.

Die PowerShell-Konsole einrichten

Die PowerShell-Konsole PowerShell.exe wird mitunter liebevoll auch »DOS-Fenster mit anderem Prompt« genannt, was auf eine wichtige Gemeinsamkeit hinweist: Beide, das klassische Kommandozeileninterface cmd.exe und die PowerShell-Konsole PowerShell.exe, nutzen das gleiche primitive Konsolenfenstersystem. Sie sehen deshalb ähnlich aus, auch wenn sich ihr Innenleben vollkommen unterscheidet.

Das primitive Konsolenfenstersystem ist robust, benötigt wenig Speicher, bietet indes auch nur das Allernötigste und kennt kaum Komfort. Genutzt wird es, um einfache und kurze Power-Shell-Befehle abzusetzen oder bereits vorbereitete PowerShell-Skripte auszuführen.

Mehr Unterstützung, insbesondere bei der Entwicklung von komplexeren PowerShell-Skripten und Kommandofolgen, liefert die ISE, ein alternativer PowerShell-Host. ISE steht für »Integrated Script Environment«, in der man wie in der Konsole interaktive Befehle eingeben, aber auch komplexere Skripte entwickeln kann.

PowerShell-Konsole starten

Um die PowerShell-Konsole erstmals zu starten, öffnen Sie mit das Ausführen-Fenster und geben darin ein: PowerShell.

Nutzen Sie Windows 8 und höher, erreichen Sie die PowerShell auch über den Startbildschirm. Ist dieser sichtbar, geben Sie einfach PowerShell ein (auch wenn kein Suchfeld zu sehen ist, können Sie sofort lostippen, das Feld wird dann automatisch eingeblendet). Noch während Sie den Befehlsnamen eingeben, sucht Windows nach Anwendungen und zeigt die Kachel Windows PowerShell. Klicken Sie darauf, um die Konsole zu starten (Abbildung 1.1).

Abbildung 1.1: PowerShell vom Startbildschirm in Windows 8 aus starten.

In Windows 10 erreichen Sie PowerShell wahlweise auch wieder über das Startmenü (Abbildung 1.2).

Abbildung 1.2: PowerShell über das Startmenü in Windows 10 öffnen.

Wenige Sekunden später präsentiert sich die hochmoderne objektorientierte PowerShell-Konsole. Besonders eindrucksvoll ist das Erlebnis anfangs indes nicht, denn es erscheint nur ein hässliches schwarzes oder blaues Konsolenfenster. Darin begrüßt Sie die Eingabeaufforderung, die mit »PS« beginnt und dahinter den Pfadnamen des aktuellen Ordners anzeigt. Außerdem blinkt eine Einfügemarke und ermuntert Sie mit dem Charme der 1980er-Jahre dazu, erste Befehle einzugeben (Abbildung 1.3).

Abbildung 1.3: Die PowerShell-Konsole führt interaktive PowerShell-Befehle aus und benötigt wenig Speicher.

PowerShell-Version kontrollieren

Kontrollieren Sie zuerst, welche PowerShell-Version Sie verwenden. Es gibt fünf Versionen, die aufeinander aufbauen. Dieses Buch handelt von der aktuellsten PowerShell-Version, also 5.0, was Sie inspirieren sollte, Ihre PowerShell-Version ebenfalls auf Versionsstand 5.0 zu aktualisieren, falls Sie eine ältere Version vorfinden. Andernfalls können Sie einige in diesem Buch beschriebene Funktionalitäten nicht nutzen.

Ein besonders einfacher Weg, die Version Ihrer PowerShell zu prüfen, ist ein Blick auf das Copyright, das beim Start der Konsole erscheint:

Copyright-Jahr

PowerShell-Version

2006

Version 1.0. Diese Version ist veraltet und sollte nicht mehr eingesetzt werden.

2009

Version 2.0. Eingeführt mit Windows 7/Windows Server 2008R2. Als Update verfügbar für Windows XP, Vista sowie Windows Server 2003 und 2008.

2012

Version 3.0. Eingeführt mit Windows 8 und Windows Server 2012. Kann auf PowerShell 5.0 aktualisiert werden (außer auf Windows 7-Clients).

2013

Version 4.0. Eingeführt mit Windows 8.1 und Server 2012R2. Kann auf PowerShell 5.0 aktualisiert werden.

2015

Version 5.0. Eingeführt mit Windows 10 und Server 2016.

Tabelle 1.1: PowerShell-Versionen identifizieren.

So finden Sie die aktuell verwendete PowerShell-Version per Befehl heraus:

PS> $PSVersionTable Name                           Value----                           -----PSVersion                      5.0.10240.16384WSManStackVersion              3.0SerializationVersion           1.1.0.1CLRVersion                     4.0.30319.42000BuildVersion                   10.0.10240.16384PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0...}PSRemotingProtocolVersion      2.3

Hinter PSVersion findet sich die Version Ihrer PowerShell. Die übrigen Angaben betreffen verwandte Subsysteme, die die PowerShell ebenfalls benötigt. Steht hinter PSVersion nicht »5.0«, verwenden Sie eine veraltete Version. Das kostenfreie Update für PowerShell 5.0 ist ein Windows-Updatepaket (mit der Erweiterung .msu), das im Internet kostenfrei bereitsteht und per Doppelklick installiert wird. Bevor Sie PowerShell auf einem Produktionsserver aktualisieren, informieren Sie sich vorsichtshalber über die sonstige Software, die darauf läuft. Es gibt Software, die eng mit PowerShell verzahnt ist und vielleicht eine ganz bestimmte PowerShell-Version erfordert.

Symbol an Taskleiste heften

Als Nächstes sollten Sie die PowerShell-Konsole besser erreichbar machen. Dazu klicken Sie das PowerShell-Symbol in der Taskleiste mit der rechten Maustaste an und wählen im Kontextmenü Dieses Programm an Taskleiste anheften (Abbildung 1.4). Ziehen Sie das Symbol danach in der Taskleiste mit der Maus an den äußersten linken Rand, sodass es das erste Symbol in der Taskleiste ist. Schließen Sie die PowerShell-Konsole und öffnen Sie sie danach erneut mit einem Klick auf das angepinnte Symbol in der Taskleiste.

Abbildung 1.4: PowerShell-Symbol an die Taskleiste anheften.

Sie können PowerShell nun auch über die Tastenkombination öffnen oder in den Vordergrund holen, sofern das PowerShell-Symbol das erste in Ihrer Taskleiste ist. Andernfalls verwenden Sie eine andere Zahl, die der Position des Symbols in der Taskleiste entsprechen muss. Spätestens jetzt sollte sich ein blaues und nicht schwarzes Konsolenfenster öffnen. Windows speichert Einstellungen wie die blaue Hintergrundfarbe oder die Bildschirmpuffergröße der Konsole in Verknüpfungen.

Bessere Schrift für die Konsole

Da PowerShell textorientiert ist und es auf jedes Zeichen ankommt, sollte die Schrift in der Konsole klar, deutlich und ermüdungsfrei zu lesen sein. Ist die Schrift zu winzig, justieren Sie nach.

Dazu klicken Sie auf das Konsolensymbol ganz links in der Titelleiste des geöffneten Konsolenfensters. Im Kontextmenü wählen Sie Eigenschaften (Abbildung 1.5) und können nun Farben, Schriftart und -größe sowie die Einstellungen des Konsolenpuffers (Fensterpuffergröße) festlegen (Abbildung 1.6).

Abbildung 1.5: Einstellungen des Konsolenfensters ändern.

Die Schriftart wählen Sie auf der Registerkarte Schriftart. Empfohlen werden TrueType-Schriftarten, die nahtlos skalierbar sind und auch auf Displays mit hoher Auflösung scharf angezeigt werden.

Abbildung 1.6: Die Konsoleneigenschaften bieten in Windows 10 zahlreiche neue Funktionalitäten.

Allerdings bietet das Schriftartenauswahlfeld anfangs nur wenige TrueType-Schriftarten an, denn die Konsole verfügt über einen zeichenbasierten Puffer, und so dürfen nur Schriftarten verwendet werden, bei denen alle Zeichen genau gleich breit sind. Deshalb regelt ein Eintrag in der Windows-Registrierungsdatenbank, welche Schriftarten in der Konsole zulässig sind.

Möchten Sie weitere TrueType-Schriftarten in der Konsole verwenden und sind sicher, dass diese Schriftarten gleiche Zeichenbreiten verwenden, lassen sich diese Schriften in der Registrierungsdatenbank unter diesem Schlüssel hinzufügen: HKLM\SOFTWARE\Microsoft \Windows NT\CurrentVersion\Console\TrueTypeFont (Abbildung 1.7).

Abbildung 1.7: Weitere Schriftarten für die Konsole verwendbar machen.

Sie werden bald erfahren, wie PowerShell selbst Änderungen an der Registrierungsdatenbank vornehmen kann. Einstweilen hilft aber auch die gute alte REG-Datei. Dazu öffnen Sie den standardmäßigen Windows-Texteditor Notepad (der laut Fenstertitel eigentlich schlicht Editor heißt) zum Beispiel durch Eingabe von notepad in der PowerShell-Konsole. Geben Sie dann den folgenden Text ein:

Windows Registry Editor Version 5.00[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Console\TrueTypeFont]"0"="Consolas""00"="Courier New""000"="Lucida Console""0000"="Lucida Sans Typewriter""00000"="OCR A Extended"

Listing 1.1: Die REG-Datei schaltet weitere Konsolenschriftarten frei.

Speichern Sie die Datei unter dem Namen konsolenschriften.reg. Achten Sie darauf, dass sie anschließend tatsächlich die Erweiterung ».reg« trägt und nicht etwa ».reg.txt«. Das Symbol der Datei muss einen Registrierungseditor darstellen, kein Textdokument. Damit Notepad die Erweiterung ».txt« nicht einfach an Ihren Dateinamen anhängt, wählen Sie im Speichern unter-Dialog im Ausklappfeld Dateityp aus: Alle Dateien. Doppelklicken Sie anschließend auf die Datei, um die Definitionen in die Registrierungsdatenbank einzutragen. Hierzu benötigen Sie Administratorrechte.

Die Änderungen wirken sich erst aus, wenn Sie die PowerShell-Konsole neu öffnen. Danach stehen Ihnen im Schriftartenauswahlfenster alle Schriftarten zur Verfügung, die Sie in die Registrierungsdatenbank eingetragen haben (Abbildung 1.8).

Abbildung 1.8: Futuristische neue Schriftarten für die PowerShell-Konsole nutzbar machen.

Neue Konsolenfunktionen bei Windows 10 aktivieren

Das Konsolenfenstersystem wurde von Microsoft viele Jahre nicht weiterentwickelt, und so herrschten darin Zustände, die man von modernen Windows-Anwendungen nicht mehr gewohnt ist. Markierungen sind beispielsweise nur auf Blockebene möglich, nicht zeilenweise. Das Einfügen und Kopieren von Text geschieht nicht mithilfe der üblichen Tastenkombinationen und , stattdessen kopiert ein Rechtsklick markierten Text und fügt ihn auch wieder ein, und viele weitere Regeln erinnern eher an die 80er-Jahre als an aktuelle Standards.

In Windows 10 wurde das Konsolenfenstersystem endlich modernisiert. Nur eingeschaltet werden muss dieser Luxus möglicherweise noch. Dazu gehen Sie vor wie oben beschrieben und klicken auf das Anwendungssymbol in der Titelleiste der PowerShell-Konsole. Im Kontextmenü wählen Sie Eigenschaften. Klicken Sie dann auf die Registerkarte Optionen. Im unteren Teil muss die Option Legacykonsole verwenden abgeschaltet sein, damit die neuen, moderneren Funktionen aktiviert sind (Abbildung 1.6). Fehlt die Option ganz, verwenden Sie möglicherweise nicht Windows 10, sondern ein älteres Windows.

Eine vollständige Übersicht der vielen neuen Konsolenfeatures und Tastenkombinationen sehen Sie, wenn Sie im unteren Teil auf den Link ... neuen Konsolenfeatures klicken – jedenfalls dann, wenn Sie über eine Internetverbindung verfügen, denn der Link führt Sie zu einer Microsoft-Webseite.

Neu in der modernen Konsole ist auch ein Schieberegler, im Dialogfeld Deckkraft genannt, im unteren Bereich der Registerkarte Farben. Mit ihm kann die Konsolentransparenz gesteuert werden: Die Konsole wird auf Wunsch teilweise durchsichtig, was zumindest dann nützlich ist, wenn man die Konsole geöffnet in Bereitschaft lassen möchte, ohne den Blick auf andere Dinge ganz zu versperren (Abbildung 1.9).

Ebenfalls neu ist auf der Registerkarte Layout die Option Textausgabe bei Größenänderung umbrechen. Wird das Konsolenfenster verkleinert, gehen so keine Ausgaben mehr verloren, sondern werden in die nächste Zeile gesetzt.

Abbildung 1.9: In Windows 10 kann die Deckkraft des Konsolenhintergrunds verändert werden.

Sprungliste: Administratorrechte und ISE

Haben Sie die PowerShell-Konsole wie oben beschrieben an die Taskleiste angeheftet und danach mindestens einmal gestartet, öffnet ein Rechtsklick auf das angeheftete Konsolensymbol nun die PowerShell-Sprungliste: ein Menü mit den wichtigsten PowerShell-Startbefehlen (Abbildung 1.10).

Abbildung 1.10: Sprungliste von PowerShell öffnen.

Über die enthaltenen Befehle können Sie PowerShell bei Bedarf mit vollen Administratorrechten starten (was Sie im Normalfall zum eigenen Schutz eher vermeiden und nur einsetzen sollten, wenn diese Rechte tatsächlich gebraucht werden). Auch die ISE, der integrierte Skripteditor, kann über die Sprungliste wahlweise normal oder mit Administratorrechten geöffnet werden.

Befehl

Beschreibung

Als Administrator ausführen

Öffnet die interaktive PowerShell-Konsole mit allen Rechten.

ISE als Administrator ausführen

Öffnet den PowerShell-Editor mit allen Rechten.

Windows PowerShell ISE

Öffnet den integrierten PowerShell-Skripteditor.

Windows PowerShell

Öffnet die interaktive PowerShell-Konsole ohne besondere Rechte.

Tabelle 1.2: Befehle in der PowerShell-Sprungliste.

32-Bit- und 64-Bit-Versionen

Auf 64-Bit-Versionen von Windows gibt es sowohl die PowerShell-Konsole als auch den ISE-Editor in doppelter Ausführung. Neben der 64-Bit-Version stehen zusätzlich 32-Bit-Versionen bereit. Sie sind daran zu erkennen, dass an den Namen ein »(x86)« angefügt ist.

Die 32-Bit-Versionen der PowerShell-Hosts sind nur für Ausnahmefälle gedacht, in denen ein Skript ausdrücklich im 32-Bit-Subsystem ausgeführt werden muss. Nötig ist das nur selten, zum Beispiel dann, wenn PowerShell auf Komponenten zugreifen soll, die es nur als 32-Bit-Versionen gibt. Im normalen Alltag setzen Sie immer die regulären 64-Bit-Versionen ein und achten darauf, dass hinter dem Programmnamen eben nicht der Zusatz »(x86)« steht.

PowerShell ISE einsetzen

Zwar dient die PowerShell ISE (PowerShell_ise.exe) in erster Linie als Skripteditor, mit dem man PowerShell-Skripte entwickeln und testen kann, doch wird sie auch als vollständiger Ersatz für die PowerShell-Konsole zur täglichen Arbeit eingesetzt. Starten Sie die ISE entweder über die soeben beschriebene Sprungliste mit dem Kontextmenübefehl Windows PowerShell ISE oder direkt aus einer geöffneten klassischen PowerShell-Konsole heraus:

PS> ise

Wenn Sie die ISE über den Konsolenbefehl ise starten, erhält sie die gleichen Rechte wie die Konsole.

Hinweis

Sollte die ISE gänzlich fehlen, verwenden Sie möglicherweise einen Windows Server 2008/2008R2 und eine alte PowerShell-Version. Früher war die ISE auf Servern eine optionale Komponente und das Feature nicht automatisch aktiviert. Sollte die ISE auf einem Server also fehlen, aktivieren Sie das entsprechende Windows-Feature einfach. Das geht mit PowerShell sehr viel schneller als über die grafische Oberfläche. Einzig Administratorrechte sind für solche Aufgaben erforderlich.

Starten Sie daher eine PowerShell-Konsole entweder über die Sprungliste mit Als Administrator ausführen oder halten Sie gedrückt, bevor Sie das PowerShell-Symbol in der Taskleiste anklicken. Danach geben Sie diesen Befehl ein:

PS> Add-WindowsFeature -Name PowerShell-ISE

Der Befehl Add-WindowsFeature steht nur auf Servern zur Verfügung. Er stammt aus der Befehlserweiterung ServerManager, die auf Windows-Clients fehlt.

Nachdem PowerShell ISE erfolgreich nachgerüstet ist, erscheinen die Einträge für den ISE-Editor in der Sprungliste erst, wenn alle geöffneten PowerShell-Fenster geschlossen werden und Sie die PowerShell-Konsole danach erneut öffnen.

Abbildung 1.11: PowerShell ISE als Konsolenersatz.

Weil PowerShell ISE nicht nur ein moderner Ersatz für die interaktive Konsole ist, sondern auch als Skripteditor dient, sieht das Fenster möglicherweise bei Ihnen etwas anders aus als in Abbildung 1.11. Mit der Pfeilschaltfläche in der oberen rechten Ecke blenden Sie den Skriptbereich ein und aus. Im Augenblick sollten Sie den Skriptbereich im versteckten Zustand belassen. Über kann der Skriptbereich gänzlich mauslos sichtbar und wieder unsichtbar gemacht werden.

Hilfreich sind auch die Schaltflächen in der Symbolleiste, mit denen Sie den interaktiven Konsolenteil wahlweise unten oder an der Seite anzeigen oder bei Bedarf eben auch ganz ausblenden, um maximalen Platz zur Eingabe von Skripten zu haben (Abbildung 1.12).

Abbildung 1.12: Über die Werkzeugleiste kann die interaktive PowerShell-Konsole ein- und ausgeblendet werden.

Mit dem Schieberegler am unteren rechten Fensterrand variieren Sie nahtlos die Schriftgröße. Ohne Maus verwenden Sie dazu und .

Möchten Sie auch die Schriftart ändern, rufen Sie Tools/Optionen auf. Im Dialogfeld aktivieren Sie das Kontrollkästchen Nur Festbreitenschriftart, denn PowerShell ISE kommt zwar im Unterschied zur Konsole auch mit Proportionalschriftarten zurecht, aber weil hier die Schriftzeichen unterschiedlich breit sind (einem m wird zum Beispiel mehr Platz eingeräumt als einem i), führt dies zu Problemen bei der Ausgabe, wenn Tabellenspalten verrutschen und nicht mehr bündig erscheinen (Abbildung 1.13).

Im Listenfeld Schriftfamilie sehen Sie jetzt alle Schriftarten mit fester Zeichenbreite. Die Schriftart, die Sie auswählen, gilt sowohl für den interaktiven Konsolenbereich als auch den Skripteditor. Nicht alle Schriftarten, die die Liste anbietet, sind wirklich gut zu gebrauchen. Eine besonders gut lesbare Schriftart heißt »Consolas«. Die »Lucida Console« ist die Standardschriftart.

Abbildung 1.13: Andere Schriftart für ISE auswählen.

Notfalls stellt die Schaltfläche Standard wiederherstellen in der linken unteren Ecke des Dialogfelds die Ausgangseinstellungen wieder her.

Hinweis

Für den ISE-Editor existieren kommerzielle Erweiterungen, mit denen zahlreiche zusätzliche Funktionen nachgerüstet werden können. So wird aus dem einfachen ISE-Editor eine professionelle Entwicklungsumgebung. Die bekannteste Erweiterung heißt »ISESteroids« und kann als Testversion von http://www.powertheshell.com heruntergeladen werden. Am einfachsten gelingt dies über den folgenden Befehl, der den Download und die Installation kombiniert:

PS> Install-Module ISESteroids -Scope CurrentUser

Das Cmdlet Install-Module ist Teil von PowerShell 5.0 und kann für ältere PowerShell-Versionen unter dem Namen »PowerShellGet« beziehungsweise »PackageManagement« kostenfrei heruntergeladen und installiert werden. Bei Drucklegung dieses Buchs stand für ältere PowerShell-Versionen bereits eine Preview-Version zur Verfügung (http://blogs.msdn.com/b/PowerShell/archive/2015/10/09/package-management-preview-for-PowerShell-4-amp-3-is-now-available.aspx).

Nach Download und Installation wird die ISESteroids-Erweiterung mit dem folgenden Befehl bei Bedarf geladen:

PS> Start-Steroids

Die Konsole der ISE unterstützt einige besondere Tastenkombinationen (Tabelle 1.3).

Taste

Bedeutung

Ruft den ersten beziehungsweise letzten Befehl ab, den Sie in dieser Sitzung verwendet haben.

Die eingegebene Zeile zur Ausführung an PowerShell senden.

Einfügemarke an das Ende der Zeile setzen.

Das Zeichen rechts von der Einfügemarke löschen.

Die aktuelle Zeile löschen.

Hilfe zum aktuellen Befehl anfordern.

,

Einfügemarke ein Zeichen nach links oder rechts bewegen.

,

Zuletzt eingegebene Befehle zurückholen.

Einfügemarke an den Anfang der Zeile setzen.

Das Zeichen links von der Einfügemarke löschen.

Schrift verkleinern.

Schrift vergrößern.

Befehlsausführung abbrechen (oder markierten Text in die Zwischenablage kopieren).

Mehrzeilenmodus aktivieren (Fortsetzung der aktuellen Befehlszeile in einer neuen Zeile).

IntelliSense aktivieren (Autovervollständigungsmenü anzeigen).

,

Einfügemarke wortweise nach links oder rechts bewegen.

Skriptbereich ein- und ausblenden.

Markierten Text in Kleinbuchstaben umwandeln.

Inhalt der Zwischenablage einfügen.

Markierten Text in Großbuchstaben umwandeln.

Aktuelle Eingabe automatisch vervollständigen, falls möglich.

Tabelle 1.3: Wichtige Tastenkombinationen der Konsole im ISE-Editor.

Tipp

PowerShell ISE erhält in der Taskleiste ihr eigenes Symbol. Um ISE künftig direkt per Klick zu starten, klicken Sie mit der rechten Maustaste auf das Symbol von ISE in der Taskleiste und wählen Dieses Programm an Taskleiste anheften. Danach schieben Sie es nach links neben das Symbol der PowerShell-Konsole und können nun per Klick entscheiden, ob Sie die klassische Konsole oder lieber ISE öffnen möchten.

Denken Sie aber daran, dass nur das Symbol der PowerShell-Konsole per Rechtsklick die Sprungliste öffnet. Das Symbol der ISE verfügt über keine Sprungliste.

Erste Schritte mit PowerShell

Die Ausführung von Befehlen funktioniert in der klassischen PowerShell-Konsole und in ISE gleich: Sie geben einen Befehl ein, schicken ihn mit einem entschlossenen Druck auf ab und warten dann gespannt, was als Nächstes geschieht. Wie Sie herausfinden, welche Befehle Ihnen zur Verfügung stehen, werden Sie gleich erfahren.

Wichtige Vorsichtsmaßnahmen

Damit das, was dann als Nächstes geschieht, keine unschöne Überraschung wird, sind ein paar vorausschauende Vorsichtsmaßnahmen ratsam. Mit nur zwei simplen Regeln entschärfen Sie das Potenzial karrierelimitierender Fehleingaben erheblich:

Befehle eingeben

Im Fenster sehen Sie die Eingabeaufforderung. Sie beginnt mit PS, und dahinter steht der Pfad-name des Ordners, in dem Sie sich gerade befinden. Eine blinkende Einfügemarke wartet auf Ihre ersten Eingaben. Sie werden gleich erfahren, welche Befehle PowerShell versteht, probieren Sie die Eingabe aber schon einmal aus. Geben Sie zum Beispiel ein:

PS> hallo

Sobald Sie drücken, wird Ihre Eingabe an PowerShell geschickt und verarbeitet. Das Ergebnis folgt postwendend und ist in diesem Fall eine nüchterne rote Fehlermeldung:

hallo : Die Benennung "hallo" wurde nicht als Name eines Cmdlet, einer Funktion, einer Skriptdateioder eines ausführbaren Programms erkannt. Überprüfen Sie die Schreibweise des Namens, oder ob derPfad korrekt ist (sofern enthalten), und wiederholen Sie den Vorgang.In Zeile:1 Zeichen:1+ hallo+ ~~~~~    + CategoryInfo          : ObjectNotFound: (hallo:String) [], CommandNotFoundException    + FullyQualifiedErrorId : CommandNotFoundException

Fehlermeldungen sind zwar üblicherweise eher unerfreulich, doch sollten Sie sich schon einmal daran gewöhnen, sie nicht routinemäßig zu ignorieren. Oft verraten sie bei PowerShell tatsächlich den Grund des Problems, und auch in diesem Beispiel ist das, was die Fehlermeldung zu sagen hat, recht treffend: Die Benennung »hallo«, also das, was Sie als Befehl an PowerShell geschickt haben, war kein ausführbarer Befehl. Ausführbare Befehle sind gemäß Fehlermeldung Cmdlets, Funktionen, Skriptdateien oder ausführbare Programme.

Den kryptischen Teil nach dem Klartext dürfen Sie freundlich ignorieren. Er verrät erfahrenen PowerShell-Skriptentwicklern bei Bedarf noch mehr über die Natur des Fehlers und wo genau er aufgetreten ist. Spannend wird dieser Teil erst, wenn Sie umfangreichere PowerShell-Skripte starten.

Profitipp

Falls es Sie stört, dass PowerShell in epischer Breite den Pfadnamen des aktuellen Ordners im Prompt anzeigt, geben Sie einmal diesen Befehl ein:

PS> cd \

Damit wechseln Sie in den Stammordner des aktuellen Laufwerks, also vermutlich nach C:\, und der Prompttext wird jetzt wesentlich kürzer und vergeudet keinen wertvollen Platz mehr in der Konsole. Später werden Sie bessere Wege kennenlernen, um den Prompt angenehmer zu formatieren, aber einstweilen hilft dieser Kniff schon mal weiter.

Ergebnisse empfangen

Geben Sie einen gültigen Befehl ein, wirft PowerShell fröhlich die erwarteten Ergebnisse aus. Möchten Sie zum Beispiel sehen, welche Dateien und Ordner sich in Ihrem aktuellen Ordner befinden, geben Sie ein: dir.

Sie erhalten eine mehr oder weniger lange Textliste, und es drängt sich das Gefühl auf, dass der Ordnerinhalt in einem normalen Explorer-Fenster mit seinen bunten Symbolen viel einfacher zu erfassen ist. Grundsätzlich kommuniziert PowerShell mit Ihnen auf Textbasis. Dass Power-Shell mehr kann als ein Explorer-Fenster, zeigt der nächste Befehl, der sämtliche laufenden Prozesse auflistet:

PS> Get-Process

Die Stärke von PowerShell ist also nicht unbedingt die Darstellung der Informationen, sondern vielmehr ihre ungeheure Flexibilität. Fast alle Belange und Informationen Ihres Computers lassen sich von hier aus steuern und anzeigen – wenn auch »nur« als Textdarstellung und mithilfe von Textbefehlen.

Hier die wichtigsten weiteren Grundregeln:

• Groß- und Kleinschreibung: Diese spielt bei Befehlen keine Rolle. PowerShell ist also nicht case sensitive. Bei Argumenten, also Informationen, die Sie einem Befehl zusätzlich mit auf den Weg geben, kann die Groß- und Kleinschreibung im Einzelfall dagegen sehr wohl entscheidend sein, zum Beispiel bei Kennwortabfragen.

• Abbrechen und löschen: Möchten Sie einen Befehl vorzeitig abbrechen, drücken Sie . Um die aktuelle Eingabe zu löschen, drücken Sie . Möchten Sie den Inhalt des Konsolenfensters löschen, verwenden Sie den Befehl cls.

Informationen speichern oder umleiten

Alle Befehle der PowerShell liefern »körperlose«, nackte Informationen. Wie diese letzten Endes dargestellt oder verwendet werden, steht auf einem anderen Blatt. Im einfachsten Fall unternehmen Sie nichts weiter mit den Informationen. Sie oxidieren dann automatisch zu Text, den die Konsole anzeigt.

Alternativ könnten Sie die Informationen aber auch in Variablen speichern, die bei PowerShell immer mit einem $ gekennzeichnet werden und wie Aufbewahrungsbehälter funktionieren:

Die Informationen des Befehls liegen jetzt in der Variablen und werden nicht sichtbar ausgegeben. Erst wenn Sie die Variable ausgeben, tauchen die Informationen wieder auf:

PS> $info Windows-IP-KonfigurationDrahtlos-LAN-Adapter Wi-Fi:   Verbindungsspezifisches DNS-Suffix: Speedport_W_921V_1_39_000   IPv6-Adresse. . . . . . . . . . . : 2003:40:e765:5043:7ca6:5208:b378:5c84   Temporäre IPv6-Adresse. . . . . . : 2003:40:e765:5043:6485:6291:7855:a81   Verbindungslokale IPv6-Adresse  . : fe80::7ca6:5208:b378:5c84%11   IPv4-Adresse  . . . . . . . . . . : 192.168.2.119   Subnetzmaske  . . . . . . . . . . : 255.255.255.0   Standardgateway . . . . . . . . . : fe80::1%11                                       192.168.2.1Ethernet-Adapter Bluetooth Network Connection:   Medienstatus. . . . . . . . . . . : Medium getrennt   Verbindungsspezifisches DNS-Suffix:(...)

Mit Operatoren lassen sich die Informationen in Variablen dann zum Beispiel bearbeiten. Der nächste Befehl fischt aus der Variablen nur die Zeilen heraus, die den Begriff »IPv4« enthalten:

PS> $info -like '*IPv4*'    IPv4-Adresse . . . . . . . . . . : 192.168.2.119

Oder die Informationen werden zu einem anderen Befehl weitergeleitet. Out-GridView stellt sie zum Beispiel in einem separaten Fenster dar:

PS> ipconfig.exe | Out-GridView

Richtig gut funktioniert das, wenn Befehle nicht reinen Text zurückliefern, sondern sogenannte »Objekte«. Objekte strukturieren Informationen in einzelnen Spalten, den sogenannten »Eigenschaften« oder »Properties«. Der nächste Befehl liefert beispielsweise alle Dienste und verrät interessante Details zu jedem Dienst:

PS> Get-Service Status   Name               DisplayName------   ----               -----------Running  AdobeARMservice    Adobe Acrobat Update ServiceStopped  AJRouter           AllJoyn-RouterdienstStopped  ALG                Gatewaydienst auf AnwendungsebeneStopped  ANTS Memory Pro... ANTS Memory Profiler 8 ServiceStopped  ANTS Performanc... ANTS Performance Profiler 9 ServiceStopped  AppIDSvc           AnwendungsidentitätRunning  Appinfo            AnwendungsinformationenRunning  Apple Mobile De... Apple Mobile Device Service(...)

Werden solche Informationen weitergeleitet, zum Beispiel an Out-GridView, werden die Einzelinformationen in separaten Spalten angezeigt und lassen sich im GridView beispielsweise per Klick auf die Spaltenüberschrift sortieren (Abbildung 1.14):

PS> Get-Service | Out-GridView

Abbildung 1.14: Befehlsergebnisse in einem Extrafenster anzeigen, dem »GridView«.

Hier erhalten Sie quasi bereits einen Vorgeschmack auf den »objektorientierten« Charakter der PowerShell, der in den folgenden Kapiteln immer wieder aufgegriffen wird. Mit Select-Object lassen sich so beispielsweise die Informationen bestimmen, an denen Sie interessiert sind:

PS> Get-Service | Select-Object -Property Status, DisplayName  Status DisplayName ------ -----------Running Adobe Acrobat Update ServiceStopped AllJoyn-RouterdienstStopped Gatewaydienst auf AnwendungsebeneStopped ANTS Memory Profiler 8 ServiceStopped ANTS Performance Profiler 9 ServiceStopped AnwendungsidentitätRunning Anwendungsinformationen(...)

Dasselbe Cmdlet macht auch deutlich, dass viele Befehle in Wahrheit sehr viel detailliertere Informationen liefern, als von der PowerShell-Konsole zunächst angezeigt werden. Fordern Sie mit dem Jokerzeichen * sämtliche Informationen an, prasseln sehr viel mehr Informationen auf Sie ein als ohne diesen Zusatz:

PS> Get-Service | Select-Object -Property * Name                : AdobeARMserviceRequiredServices    : {}CanPauseAndContinue : FalseCanShutdown         : FalseCanStop             : TrueDisplayName         : Adobe Acrobat Update ServiceDependentServices   : {}MachineName         : .ServiceName         : AdobeARMserviceServicesDependedOn  : {}ServiceHandle       :Status              : RunningServiceType         : Win32OwnProcessSite                :Container           :Name                : AJRouterRequiredServices    : {}CanPauseAndContinue : FalseCanShutdown         : FalseCanStop             : FalseDisplayName         : AllJoyn-RouterdienstDependentServices   : {}MachineName         : .ServiceName         : AJRouterServicesDependedOn  : {}ServiceHandle       :Status              : StoppedServiceType         : Win32ShareProcessSite                :Container           :Name                : ALGRequiredServices    : {}CanPauseAndContinue : FalseCanShutdown         : FalseCanStop             : FalseDisplayName         : Gatewaydienst auf AnwendungsebeneDependentServices   : {}MachineName         : .ServiceName         : ALGServicesDependedOn  : {}ServiceHandle       :Status              : StoppedServiceType         : Win32OwnProcessSite                :Container           :(...)

PowerShell schaltet die Darstellung dabei automatisch vom Tabellen- in den Listenmodus, weil nun zu viele Informationen anzuzeigen sind, als in eine einzige Textzeile passen würden.

IntelliSense-Unterstützung im ISE-Editor

Es ist durchaus beeindruckend, was die PowerShell leisten kann, auch wenn die Beispiele im vorangegangenen Abschnitt wohl mehr Fragen als Antworten aufgeworfen haben.

Störend ist zum Beispiel, dass die PowerShell nur dann etwas für Sie tut, wenn Sie die richtigen Befehle kennen. Es gibt keine praktischen Schaltflächen und Menüs in der textorientierten Befehlswelt der Automationssprachen.

Viel mehr Hilfestellung als in der Konsole erhalten Sie, wenn Sie zum ISE-Editor greifen. Dieser blendet IntelliSense-artige Auswahlmenüs ein, sobald Sie ein Schlüsselzeichen wie den Bindestrich (-) eingeben, und hilft Ihnen schon einmal etwas, auf intuitive Weise Befehle zu finden (Abbildung 1.15).

Abbildung 1.15: Moderne IntelliSense-Vervollständigung im ISE-Editor.

Das IntelliSense-Menü kann auch manuell jederzeit über geöffnet werden.

Tipp

Ob ISE IntelliSense-Menüs anzeigen soll, bestimmen Sie über Tools/Optionen auf der Registerkarte Allgemeine Einstellungen im Bereich IntelliSense.

Autovervollständigung in der PowerShell-Konsole

In der PowerShell-Konsole steht – immerhin – eine Autovervollständigung zur Verfügung. Ein Druck auf genügt, um die aktuelle Eingabe zu vervollständigen. Drücken Sie die Taste mehrmals, um weitere Vorschläge zu erhalten. blättert einen Vorschlag zurück, falls Sie zu schnell waren.

Tipp

Bei der Autovervollständigung über gilt die »Dreier-Regel«: Geben Sie mindestens drei Zeichen ein, bevor Sie drücken. Bei PowerShell-Befehlen geben Sie mindestens den ersten Namensteil, den Bindestrich und dann drei Zeichen ein. Andernfalls gibt es zu viele infrage kommende Möglichkeiten, und muss viel zu oft gedrückt werden, bis das richtige Ergebnis vorgeschlagen wird.

Die Autovervollständigung dient nicht nur der Bequemlichkeit. Sie vermeidet auch Tippfehler und macht sie deutlich. Liefert zum Beispiel gar kein Resultat, liegt der Verdacht nahe, dass Sie sich bei Ihrer vorhandenen Eingabe bereits vertippt haben. Überprüfen Sie in diesem Fall, was Sie bisher eingegeben haben, und korrigieren Sie die Eingabe falls nötig. Danach versuchen Sie noch einmal.

Die Autovervollständigung über steht übrigens auch in ISE bereit und vervollständigt dann sofort, ohne dass sich ein Auswahlmenü einblendet.

Ab PowerShell 5 kann die Konsole sogar mit IntelliSense-artigen Auswahlmenüs aufwarten. Geben Sie den Beginn eines Befehls ein und drücken dann , zeigt die Konsole die noch infrage kommenden Befehle an, die Sie mit den Pfeiltasten auswählen und mit der übernehmen. Geben Sie zum Beispiel Folgendes ein und drücken Sie dann :

PS> Get-Pr

In PowerShell 5 erscheint nun das Auswahlmenü der noch infrage kommenden Befehle, aus denen Sie sich per Pfeiltasten einen aussuchen können (Abbildung 1.16).

Abbildung 1.16: PowerShell 5 bietet auch in der Konsole eine Befehlsauswahl an.

Ist die Eingabe nicht eindeutig genug, fragt PowerShell gegebenenfalls nach, ob Sie wirklich alle infrage kommenden Befehle sehen wollen. Wenn Sie die Frage mit beantworten, ergießt sich eine lange Liste möglicher Vervollständigungen – nicht so praktisch.

Zuständig dafür ist eine PowerShell-Erweiterung namens PSReadLine, die noch eine ganze Reihe weiterer Tricks auf Lager hat, wie Sie etwas später sehen. Möchten Sie diese Erweiterung in der PowerShell-Konsole nicht nutzen, geben Sie ein:

PS> Remove-Module PSReadLine

Farbcodierungen verstehen

Eine wichtige Hilfestellung ist die Farbcodierung der aktuellen Befehlszeile. Sie zeigt sich »bunt«, solange Sie etwas darin eingeben und Ihre Eingabe noch nicht mit an PowerShell geschickt haben. Die Farben dienen nicht bloß der Unterhaltung, Sie verdeutlichen, wie Power-Shell Ihre Eingaben interpretiert. Viele Eingabefehler lassen sich mithilfe der Farbcodierung besser verstehen und vermeiden.

Abbildung 1.17: Farbcodierungen zeigen, wie PowerShell Ihre Eingaben versteht.

Geben Sie in ISE beispielsweise ein:

PS> dir C:\Windows