PowerShell lernen: vom Befehl zum Automatisieren

PowerShell wirkt auf den ersten Blick wie eine weitere Kommandozeile. Sobald du damit arbeitest, merkst du schnell: Hier geht es nicht um einzelne Befehle, sondern um Objekte, Pipelines und Automatisierung. Genau das macht PowerShell für Admins so stark, ob im kleinen Büro oder im Münchner Konzern.

Was PowerShell von der klassischen Konsole unterscheidet

Die wichtigste Idee: PowerShell arbeitet mit Objekten, nicht mit Text. Das klingt theoretisch, ist aber praktisch extrem hilfreich.

Ein klassischer Konsolenbefehl gibt Textzeilen aus. Wenn sich das Format ändert, bricht dein Skript. PowerShell-Cmdlets liefern dagegen .NET-Objekte mit klaren Eigenschaften.

Beispiel:

Get-Process

Du siehst eine Tabelle. Intern sind das aber Objektlisten, zum Beispiel mit Eigenschaften wie Name, Id, CPU, StartTime. Du kannst damit direkt weiterarbeiten:

Get-Process | Where-Object CPU -gt 100

Kein Textparsen, kein Gebastel mit findstr. Du filterst auf Basis von Eigenschaften.

Wichtige Unterschiede im Überblick:

Thema	Klassische Konsole	PowerShell
Ausgabe	Text	Objekte
Weiterverarbeitung	String-Parsing	Arbeiten mit Eigenschaften
Fehler	Meist Text, schwer auswertbar	Strukturiert, per Try/Catch abfangbar
Erweiterung	Exe-Sammlung	Integriertes Cmdlet- und Modul-System

Wenn du das verstanden hast, lohnt sich der Einstieg in Cmdlets und Pipeline. Ohne das wird PowerShell frustrierend.

Cmdlets verstehen: Verb-Noun und Hilfe nutzen

Cmdlets sind die Bausteine in PowerShell. Sie folgen fast immer dem Muster „Verb-Substantiv“:

• Get-Process
• Set-ExecutionPolicy
• New-LocalUser
• Remove-Item

Das wirkt banal, ist aber Gold wert. Du kannst dir viele Befehle herleiten.

Wichtige Werkzeuge für den Einstieg

Nutze am Anfang konsequent die integrierte Hilfe:

• Get-Command zeigt dir, was es gibt:

Get-Command -Noun Service
Get-Command -Verb Get

• Get-Help erklärt dir ein Cmdlet:

Get-Help Get-Service
Get-Help Get-Service -Examples

Installiere dir die aktuelle Hilfe mit:

Update-Help

Das kostet einmalig etwas Zeit, zahlt sich aber schnell aus.

Ein kleiner Lernschritt: Dateisystem-Cmdlets

Starte mit dem Dateisystem. Hier siehst du schnell Ergebnisse, ohne etwas kaputt zu machen:

• Get-ChildItem statt dir
• Copy-Item statt copy
• Move-Item statt move
• Remove-Item statt del
• Get-Content statt type

Übungsidee:

1. Wechsle in ein Testverzeichnis.
2. Liste Dateien nach Größe sortiert.
3. Filtere nur Log-Dateien.
4. Lösche testweise ein paar Dummy-Dateien mit bestimmtem Muster.

Beispiel:

Get-ChildItem -Path C:\Temp -Filter *.log |
 Where-Object Length -gt 1MB |
 Sort-Object Length -Descending

So gewöhnst du dich an Cmdlets und den Pipeline-Gedanken.

Die Pipeline: vom einfachen Filter zur flexiblen Auswertung

Die Pipeline verbindet Cmdlets. Sie übergibt nicht Text, sondern Objekte. Das ist der Kern von PowerShell-Automatisierung.

Grundmuster:

Befehl 1 | Befehl 2 | Befehl 3

Jeder Schritt bekommt Objekte rein, bearbeitet sie und gibt sie wieder aus.

Typische Bausteine:

• Where-Object zum Filtern
• Select-Object zum Auswählen von Eigenschaften
• Sort-Object zum Sortieren
• Measure-Object zum Auswerten

Beispiel: Dienste mit Status „Stopped“ anzeigen, sortiert nach Name:

Get-Service |
 Where-Object Status -eq 'Stopped' |
 Sort-Object Name

Oder: Prozesse nach CPU-Verbrauch, nur die wichtigsten Infos:

Get-Process |
 Sort-Object CPU -Descending |
 Select-Object -First 10 Name, CPU, Id

Wichtige Lernschritte mit der Pipeline:

1. Erst mit einfachen Pipelines üben: Get-... | Where-Object ....
2. Danach Ausgaben mit Select-Object und Sort-Object formen.
3. Später Objekte in Dateien oder CSV exportieren (Export-Csv).

Beispiel CSV-Export:

Get-LocalUser |
 Select-Object Name, Enabled, LastLogon |
 Export-Csv -Path C:\Temp\lokale-benutzer.csv -NoTypeInformation -Encoding UTF8

So bekommst du schnell auswertbare Daten, ohne in der GUI herumzuklicken.

Von Einmalbefehlen zu Skripten

Irgendwann merkst du: Du tippst die gleichen Befehle immer wieder ein. Spätestens dann ist es Zeit für Skripte.

Ein PowerShell-Skript ist nur eine Textdatei mit der Endung .ps1. Inhalt sind die gleichen Befehle, die du sonst interaktiv eingibst.

Erster Schritt: Einfache Skripte

Beispiel: Ein Skript, das Logdateien älter als 30 Tage im Temp-Ordner löscht.

$Pfad = 'C:\Temp\Logs'
$Grenze = (Get-Date).AddDays(-30)

Get-ChildItem -Path $Pfad -Filter *.log |
 Where-Object LastWriteTime -lt $Grenze |
 Remove-Item -WhatIf

Wichtige Punkte:

• Verwende Variablen für Pfade und Parameter.
• Nutze -WhatIf, um zu sehen, was passieren würde.
• Kommentiere, was dein Skript tut:

# Löscht Logdateien älter als 30 Tage im angegebenen Verzeichnis

Skriptausführung konfigurieren

Standardmäßig blockt Windows Skripte. Die Ausführungsrichtlinie kannst du anpassen, etwa auf RemoteSigned. Informiere dich dazu in der Hilfe:

Get-Help Set-ExecutionPolicy -Detailed

Ändere die Richtlinie nur bewusst und dokumentiere das in deinem Umfeld. In Unternehmensumgebungen gehört das Thema in die Hände der verantwortlichen Admins.

Funktionen und Module: Wiederverwendbare Bausteine schaffen

Sobald deine Skripte länger werden oder du ähnliche Aufgaben mehrfach löst, sind Funktionen sinnvoll. Sie kapseln Logik unter einem Namen.

Einfache Funktion:

function Get-OldLogFiles {
 param(
 [string]$Path,
 [int]$Days = 30
 )

 $limit = (Get-Date).AddDays(-$Days)

 Get-ChildItem -Path $Path -Filter *.log |
 Where-Object LastWriteTime -lt $limit
}

Aufruf:

Get-OldLogFiles -Path 'C:\Temp\Logs' -Days 14

Vorteile von Funktionen:

• Bessere Struktur in Skripten.
• Wiederverwendbarkeit.
• Einfacheres Testen einzelner Teile.

Nächster Schritt: Eigene Module

Wenn du mehrere Funktionen hast, die zusammengehören, packst du sie in ein Modul. Technisch ist das ein Ordner mit einer .psm1-Datei. Beispielstruktur:

C:\Users\<Du>\Documents\WindowsPowerShell\Modules\
 LogTools\
 LogTools.psm1

In LogTools.psm1 stehen deine Funktionen. Danach kannst du das Modul laden:

Import-Module LogTools
Get-Command -Module LogTools

So baust du dir deine eigene kleine Tool-Sammlung auf. In Teams kannst du Module über ein internes Repository verteilen.

PowerShell für Active Directory: typische Aufgaben automatisieren

In vielen Umgebungen ist Active Directory der Hauptgrund, PowerShell zu lernen. Dafür brauchst du das Modul ActiveDirectory, das mit den RSAT-Tools kommt.

Klassische AD-Aufgaben mit PowerShell

Ein paar typische Szenarien:

• Benutzer suchen:

Get-ADUser -Filter "Surname -like 'Müller'" -Properties mail, department

• Neue Benutzer anlegen (stark vereinfacht):

New-ADUser -Name 'Max Mustermann' `
-GivenName 'Max' `
-Surname 'Mustermann' `
-SamAccountName 'm.mustermann' `
-AccountPassword (Read-Host -AsSecureString 'Passwort') `
-Enabled $true

• Benutzer in Gruppen aufnehmen:

Add-ADGroupMember -Identity 'GG_Fileserver_Marketing_RW' -Members 'm.mustermann'

Übungsidee für den Lernpfad:

1. Testdomäne oder Laborumgebung aufsetzen.
2. Mit Get-ADUser, Get-ADGroup, Get-ADComputer spielen.
3. Listen exportieren, z. B. alle Benutzer einer OU in CSV.
4. Standardaufgaben wie „neuen User anlegen“ erst als Einmalbefehle, dann als Skript und schließlich als Funktion abbilden.

Wichtig: In produktiven Umgebungen immer mit -WhatIf arbeiten, wo möglich, und Skripte zunächst mit Testkonten laufen lassen.

PowerShell für Microsoft 365: Cloud-Administration per Skript

Für Microsoft 365 brauchst du in der Regel zusätzliche Module, etwa:

• ExchangeOnlineManagement für Exchange Online
• Microsoft.Graph für viele M365-Dienste

Die Anmeldung läuft meist per Connect-... Cmdlet, zum Beispiel:

Connect-ExchangeOnline

Typische Aufgaben:

• Postfächer auslesen und auswerten
• Lizenzzuweisungen automatisieren
• Verteilergruppen verwalten
• Audit-Logs abfragen

Beispiel: Alle Shared Mailboxes auflisten:

Get-ExoMailbox -RecipientTypeDetails SharedMailbox |
 Select-Object DisplayName, PrimarySmtpAddress

Oder: Benutzer mit bestimmter Lizenz anzeigen (mit Microsoft Graph oder AzureAD-Modul, je nach Stand deiner Umgebung).

Lernpfad-Idee:

1. Verstehen, wie sich die Module verbinden und authentifizieren.
2. Nur lesende Befehle ausführen, Ausgaben sichten.
3. Kleine Auswertungen bauen, etwa Lizenzberichte.
4. Erst danach schreibende Befehle nutzen, sehr gezielt und mit Tests.

Gerade für gemischte On-Prem-AD- und M365-Umgebungen lohnt sich PowerShell, weil du End-to-End-Prozesse abbilden kannst, vom AD-Benutzer bis zum M365-Postfach.

Vorschlag für einen sinnvollen Lernpfad

Um nicht im Befehl-Dschungel zu landen, hilft ein strukturierter Weg. Ein möglicher Lernpfad:

1. Grundlagen der Shell

• PowerShell-Konsole und ISE/VS Code kennenlernen.
• Navigation im Dateisystem, Basis-Cmdlets (Get-ChildItem, Get-Process).
• Hilfe-System nutzen (Get-Help, Get-Command).

2. Objekte und Pipeline

• Mit Get-Member Objekte untersuchen.
• Filtern, sortieren, selektieren (Where-Object, Sort-Object, Select-Object).
• CSV-Exporte und einfache Auswertungen.

3. Skripte, Variablen und Bedingungen

• Eigene .ps1-Skripte schreiben.
• Variablen, Schleifen (foreach), If-Abfragen.
• Input und Output (Parameter, Dateiausgaben, Logs).

4. Funktionen und Module

• Funktionen mit Parametern bauen.
• Rückgabewerte sauber gestalten.
• Eigenes Mini-Modul mit 2 bis 3 Funktionen erstellen.

5. Praxisfokus AD

• AD-Modul installieren und verbinden.
• Standard-Tasks: Benutzer und Gruppen verwalten.
• Typische Admin-Aufgaben als Skripte und Funktionen kapseln.

6. Praxisfokus M365

• Cloud-Module einrichten.
• Reporting-Skripte für Postfächer, Lizenzen, Gruppen.
• Kleine Automatisierungen für wiederkehrende Aufgaben.

Aktuelle Termine und passende Kurse findest du bei cmt.de.

Konkrete Übungsideen für deinen Alltag

Damit das Gelernte hängen bleibt, brauchst du eigene Mini-Projekte. Ein paar Anregungen, die du lokal oder in einer Testumgebung umsetzen kannst:

• Log-Verwaltung

• Skript, das Logdateien rotiert, archiviert und alte löscht.

• Reporting, wie viele Logs pro Tag anfallen.

• Benutzer-Report

• In AD oder lokal: Liste aller Benutzer mit Status, Gruppen und letztem Logon.

• Ausgabe als CSV und als formatiertes HTML-Report.

• Software-Inventar

• Installierte Software oder laufende Prozesse erfassen.

• Ergebnis nach Abteilungen oder Rechnergruppen filtern.

• M365-Lizenzübersicht

• Alle Benutzer mit zugewiesenen Lizenzen auflisten.

• Benutzer ohne Lizenz oder mit ungewöhnlichen Kombinationen markieren.

• Self-Service-Tools für Admins

• Kleines Skript, das per Menü typische Aufgaben anbietet:

• Benutzer entsperren

• Passwort zurücksetzen

• Gruppenmitgliedschaft anzeigen

Starte klein. Lieber ein Skript, das du verstehst und regelmäßig nutzt, als ein riesiges „Framework“, das nach zwei Wochen niemand mehr anfasst.

Fazit: Vom Befehl zur verlässlichen Automatisierung

PowerShell lohnt sich besonders dann, wenn du wiederkehrende Aufgaben hast, die du heute noch per Hand erledigst. Mit Cmdlets, Pipeline, Objekten und Modulen kannst du diese Aufgaben Schritt für Schritt in zuverlässige Automatisierungen verwandeln.

Wichtig ist, dass du nicht nur liest, sondern konsequent übst: Befehle ausprobieren, Objekte mit Get-Member untersuchen, kleine Skripte schreiben, Funktionen daraus machen und später Module. Mit AD- und M365-Aufgaben hast du genug Stoff, um aus PowerShell ein Werkzeug zu machen, das dir im Alltag wirklich Zeit spart.