# PowerShell-Befehle: Die 40 wichtigsten Commands auf einen Blick

Mit den passenden PowerShell-Befehlen nutzen Sie Module deutlich zielgerichteter. Die unterschiedlichen Cmdlets sind logisch aufgebaut und können optional um Parameter erweitert werden. Wir zeigen Ihnen die 40 wichtigsten PowerShell-Commands, damit Sie in Ihrem System oder Netzwerk optimal arbeiten können.

## Was sind PowerShell-Commands?

Die PowerShell, die seit Windows 7 vorinstalliert ist, erlaubt es Ihnen, PowerShell-Befehle einzugeben, die dann von Windows ausgeführt werden. Neben den cmd-Befehlen der Kommandozeile gibt es zahlreiche weitere Commands oder Cmdlets, die nur von der PowerShell selbst verstanden werden können. Diese Cmdlets **bestehen aus einem Verb und einem Substantiv**, welche durch einen Bindestrich getrennt sind. Außerdem können **optionale Parameter** die PowerShell-Commands spezifizieren. Diese Parameter werden durch ein Leerzeichen abgetrennt. Die PowerShell wird längst nicht mehr nur von Administratoren oder Administratorinnen genutzt, sondern leistet gerade auch im Bereich der Entwicklung wertvolle Dienste. Es gibt Hunderte vorinstallierter PowerShell-Befehle. Wir stellen Ihnen die wichtigsten vor.

## Die wichtigsten PowerShell-Befehle

PowerShell-Befehle erlauben Ihnen die Ausführung teils sehr umfangreicher Administrationsaufgaben mit nur wenigen Eingaben. Zu den Befehlen, die Sie vermutlich am häufigsten benötigen werden, gehören die folgenden Basisbefehle. Diese liefern eine erste Übersicht über die gesamte Struktur eines Netzwerks, listen andere PowerShell-Commands auf, helfen bei notwendigen Sicherheitskonfigurationen oder erstellen nützliche Analysen. Zu den wichtigsten PowerShell-Befehlen gehören insbesondere diese:

### 1. Get-Module -All

Möchten Sie sich einen ersten Überblick über alle importierten PowerShell-Module verschaffen, nutzen Sie dafür den Command **Get-Module -All**.

```shell
Get-Module -All
```

### 2. Get-Command

Es gibt zahlreiche vordefinierte PowerShell-Befehle. Brauchen Sie eine Übersicht über die PowerShell-Commands, die Ihnen aktuell zur Verfügung stehen, nutzen Sie dafür den Befehl **Get-Command**. Dieser listet sämtliche möglichen Aktionen übersichtlich auf und liefert eine kurze Erklärung zum jeweiligen Cmdlet. Dies gilt auch, wenn Sie zusätzliche Module installiert haben.

```shell
Get-Command
```

### 3. Get-Help

Die oben beschriebene Auflistung durch Get-Command gibt Ihnen zwar einen ersten Überblick, benötigen Sie allerdings weiterführende Informationen über einen Befehl und seine Möglichkeiten, verwenden Sie den Cmdlet **Get-Help**. Dieser Befehl greift auf die Hilfedateien auf Ihrem PC zurück und liefert Ihnen dann alle verfügbaren Informationen. Um diese Hilfe zu aktivieren, kombinieren Sie Get-Help mit dem Befehl, dessen Syntax Sie einsehen möchten.

```shell
Get-Help [[-Name] <String>] [-Path <String>] [-Category <String[]>] [-Component <String[]>] [-Functionality <String[]>] [-Role <String[]>] [-Examples] [<CommonParameters>]
```

### 4. Get-Process

In vielen Fällen ist es hilfreich, wenn Sie schnellstmöglich eine Übersicht über alle aktiven Anwendungen, Programme und Prozesse bekommen, die aktuell auf Ihrem System ausgeführt werden. Eine Übersicht erhalten Sie mit dem Command **Get-Process**. Spezifizieren Sie ihn mit einer bestimmten Anwendung, so erhalten Sie weiterführende Informationen zu dieser.

```shell
Get-Process
```

### 5. Get-Service

Der Befehl **Get-Service** funktioniert ähnlich wie der Cmdlet Get-Process. Der Unterschied ist, dass Get-Service Ihnen Informationen zu allen aktiven Diensten ausspielt. Möchten Sie nur Informationen zu einem bestimmten Dienst oder einer bestimmten Art unterschiedlicher Dienste erhalten, so präzisieren Sie Ihre Anfrage einfach.

```shell
Get-Service
```

### 6. Stop-Process

Sie können auch unterschiedliche PowerShell-Befehle nutzen, um Prozesse über die Shell zu stoppen. Eine Option dafür ist der Befehl **Stop-Process**. Den entsprechenden Prozess hinterlegen Sie per Name, ID oder mit anderen Attributen. Das sieht beispielhaft so aus:

```shell
Stop-Process -Name "prozessname"
```

```shell
Stop-Process -Id 3582 -Confirm -PassThru
```

Mit -Confirm wird eine Bestätigung des Befehls gefordert. Der Command -PassThru fordert eine Bestätigung des angehaltenen Prozesses an. Diese erfolgt nicht automatisch.

### 7. ConvertTo-HTML

Um Probleme oder mögliche Komplikationen schnellstmöglich identifizieren zu können, ist eine übersichtliche Darstellung sehr hilfreich. Mit dem Befehl **ConvertTo-HTML** wird die Ausgabe der jeweiligen PowerShell-Commands in eine HTML-Datei übertragen. Dadurch werden sämtliche Informationen in einem gut lesbaren Spaltenformat angezeigt. Der Befehl sieht zum Beispiel so aus:

```shell
Get-Command | ConvertTo-Html > c:\temp\AllCommands.html
```

### 8. ConvertTo-Xml

Ähnlich können Sie auch vorgehen, wenn Sie eine XML-basierte Darstellung eines bestimmten Objekts benötigen. Dies gelingt mit dem Befehl **ConvertTo-Xml**. Im folgenden Beispiel konvertieren Sie das aktuelle Datum in das Format XML:

```shell
Get-Date | ConvertTo-Xml
```

### 9. Where-Object

Mit dem Befehl **Where-Object** können Sie das Ergebnis eines Cmdlets filtern. Führen Sie einen Command aus, erhalten Sie häufig viele Objekte, die Sie jedoch nicht vollständig benötigen. Where-Object leitet den Output über eine Pipe weiter und spielt Ihnen damit nur die gesuchten Informationen aus. Wenn Sie zum Beispiel lediglich Dienste einsehen möchten, die in diesem Jahr erstellt oder aktualisiert wurden, funktioniert dies folgendermaßen:

```shell
Get-Service | Where-Object { $_.LastWriteTime -gt "01.01.2023" }
```

### 10. Get-History

Möchten Sie sämtliche PowerShell-Befehle, die Sie während einer Sitzung eingegeben haben, auflisten, ist **Get-History** der passende Cmdlet. So listen Sie alle PowerShell-Commands auf:

```shell
Get-History
```

Mit dieser Spezifikation rufen Sie nur die letzten zehn PowerShell-Befehle auf:

```shell
Get-History -Count 10
```

### 11. Clear-History

Natürlich haben Sie auch die Möglichkeit, die Auflistung der genutzten PowerShell-Commands zu löschen. Möchten Sie alle Einträge entfernen, nutzen Sie den Cmdlet **Clear-History**:

```shell
Clear-History
```

Wollen Sie nur bestimmte PowerShell-Befehle löschen, fügen Sie einfach die entsprechenden Parameter hinzu. Die folgende Eingabe entfernt sämtliche PowerShell-Commands, die „Help“ enthalten oder mit „Syntax“ enden.

```shell
Clear-History -Command *Help*, *Syntax
```

### 12. Add-History

Es ist auch möglich, PowerShell-Befehle zu einer Sitzung hinzuzufügen. So können Sie diese beim nächsten Mal wieder direkt aufrufen. Der passende Cmdlet lautet **Add-History**.

```shell
Add-History
```

### 13. Out-File

Möchten Sie die Ausgabe Ihrer PowerShell-Befehle auf Ihrem Rechner speichern, verwenden Sie den Cmdlet **Out-File**. Dieser hinterlegt die PowerShell-Commands in einer Rohtextdatei unter dem angegebenen Pfad.

```shell
Get-Process | Out-File -FilePath .\Process.txt
```

### 14. Copy-Item

Auch in der PowerShell haben Sie die Option, Elemente zu kopieren und die Kopie an einem anderen Speicherort zu hinterlegen. Dafür nutzen Sie den Befehl **Copy-Item** und geben außerdem das Verzeichnis an, in dem die Kopie gespeichert werden soll. Dies funktioniert folgendermaßen:

```shell
Copy-Item "C:\Ordner1\Datei.txt" -Destination "C:\Ordner2"
```

### 15. Get-ChildItem

Mit dem Befehl **Get-ChildItem** rufen Sie Elemente an einem oder mehreren Speicherorten ab. Gibt es untergeordnete Elemente, so werden auch diese angezeigt. Ihnen werden mit diesem Befehl standardmäßig die Attribute, der Zeitpunkt der letzten Änderung, die Größe der Datei sowie der Name des Elements aufgelistet. Ist ein Speicherort leer, entfällt die Ausgabe.

```shell
Get-ChildItem -Path C:\Beispiel
```

Die Attribute werden unter der Zeile „Mode“ ausgewiesen. Folgende Eigenschaften sind dabei gängig:

- a (Archiv)
- d (Verzeichnis)
- h (ausgeblendet)
- l (Link)
- r (schreibgeschützt)
- s (System)

### 16. Set-AuthenticodeSignature

Um Ihre Dateien zu schützen, können Sie sie mit dem Befehl **Set-AuthenticodeSignature** mit einer Authenticode-Signatur ausstatten. Dies funktioniert allerdings ausschließlich für Dateien, die das Subject Interface Package (SIP) unterstützen.

```shell
$cert=Get-ChildItem -Path Cert:\CurrentUser\My -CodeSigningCert
Set-AuthenticodeSignature -FilePath PsTestInternet2.ps1 -Certificate $cert
```

### 17. Invoke-Item

Möchten Sie die Standardaktion für eine bestimmte Datei ausführen, ist **Invoke-Item** der einfachste Weg. Der Command sorgt zum Beispiel dafür, dass eine ausführbare Datei direkt ausgeführt oder eine Dokumentdatei in der zugeordneten Anwendung geöffnet wird. In diesem Beispiel wird die Datei standardmäßig in Microsoft Word aufgerufen:

```shell
Invoke-Item "C:\Test\Beispiel.doc"
```

### 18. Start-Job

Auch wenn Sie einen Hintergrundauftrag auf Ihrem lokalen Rechner initiieren möchten, gibt es dafür den passenden Befehl. Mit **Start-Job** führen Sie einen spezifischen Command im Hintergrund aus, der nicht mit der aktuellen Sitzung interagiert.

```shell
Start-Job -ScriptBlock { Get-Process -Name pwsh }
```

## Aktionen durchführen mit diesen PowerShell-Commands

Während die bisherigen PowerShell-Befehle vor allem der Übersicht dienten, können Sie mit den passenden Cmdlets auch viele Aktionen durchführen und so Ihr System produktiv nutzen. Die folgenden PowerShell-Commands erleichtern Ihnen die Arbeit.

### 19. Clear-Content

Wenn Sie den Inhalt eines Elements löschen möchten, das Element selbst allerdings intakt bleiben soll, ist der Befehl **Clear-Content** die richtige Wahl. Ein Beispiel für den Einsatz wäre ein Dokument, dessen Text Sie entfernen, während die eigentliche Datei unberührt bleibt. Dieser Vorgang sieht so aus:

```shell
Clear-Content C:\Temp\Beispiel.txt
```

### 20. ForEach-Object

Der Befehl **ForEach-Object** erlaubt es Ihnen, einen Vorgang für alle Elemente in einer Auflistung von Eingabeobjekten auszuführen. In diesem Beispiel dividieren wir drei ganze Zahlen in einem Array durch 10:

```shell
10000, 1000, 100 | ForEach-Object -Process {$_/10}
1000
100
10
```

### 21. Compare-Object

Damit Sie unterschiedliche Sätze von Objekten nicht manuell abgleichen müssen, können Sie den Cmdlet **Compare-Object** nutzen. Der Befehl fertigt dann einen Bericht an, wo die Unterschiede zwischen den Sätzen liegen. Der erste Satz wird dabei als Verweisobjekt verwendet und der zweite Satz als Differenzobjekt. Welche Faktoren verglichen werden sollen, können Sie bestimmen. Verzichten Sie auf diese Information, werden lediglich die Zeichenfolgenergebnisse miteinander verglichen. Dabei unterteilt die Ausgabe in Eigenschaften, die lediglich im Verweisobjekt vorkommen (&lt;==), und Eigenschaften, die nur im Differenzobjekt erscheinen (==&gt;). In diesem Beispiel enthält Dokument1.txt die Werte Berlin, London und Paris. Dokument2.txt enthält Berlin, Wien und Amsterdam.

```shell
Compare-Object -ReferenceObject (Get-Content -Path C:\Test\Dokument1.txt) -DifferenceObject (Get-Content -Path C:\Test\Dokument2.txt)
InputObject	SideIndicator
---------------	-----------------
Wien		==>
Amsterdam	==>
London		<==
Paris		<==
```

Inhalte, die in beiden Dokumenten vorkommen (in diesem Fall „Berlin“), werden standardmäßig nicht angezeigt.

### 22. New-Object

Zu den besonders nützlichen PowerShell-Befehlen gehört auch **New-Object**. Mit diesem Cmdlet erstellen Sie eine Instanz eines .NET Frameworks oder eines Component Object Models (COM). Wenn Sie beispielsweise ein System.Version.Objekt mit 1.2.3.4 als Zeichenfolge für den Konstruktor kreieren möchten, funktioniert der Command wie folgt:

```shell
New-Object -TypeName System.Version -ArgumentList "1.2.3.4"
```

### 23. Select-Object

Mit dem Befehl **Select-Object** wählen Sie ein Objekt oder eine Gruppe von Objekten aus, welche über die von Ihnen definierten Eigenschaften verfügen. Die Parameter, die Sie dafür festlegen können, sind diese:

- First
- Last
- Unique
- Skip
- Index

Im folgenden Beispiel nutzen wir die PowerShell-Commands Get-Process und Sort-Object, um die drei Prozesse anzuzeigen, die zum Zeitpunkt der Eingabe den höchsten Arbeitsspeicherverbrauch aufweisen.

```shell
Get-Process | Sort-Object -Property WS | Select-Object -Last 3
```

### 24. Set-Alias

Windows-Shortcuts sind eine gute Möglichkeit, um Aktionen noch schneller auszuführen. Grundsätzlich bietet auch PowerShell diese Option. Im System können Sie mit dem Cmdlet **Set-Alias** eine Abkürzung für unterschiedliche PowerShell-Befehle definieren. Im folgenden Beispiel erstellen wir für die aktuelle Sitzung den Alias „ci“ für den Command Get-ChildItem.

```shell
PS> Set-Alias -Name ci -Value Get-ChildItem
PS> Get-Alias -Name ci
```

### 25. Set-Location

Möchten Sie den Arbeitsspeicherort wechseln, nutzen Sie dafür den Befehl **Set-Location**. Mögliche neue Speicherorte sind Verzeichnisse, Unterverzeichnisse, Registrierungsspeicherorte oder Anbieterpfade. Im folgenden Beispiel bestimmen wir das Laufwerk C: zum aktuellen Speicherort:

```shell
PS C:\Windows\> Set-Location HKLM:\
PS HKLM:\> Set-Location C:
PS C:\Windows\>
```

### 26. Set-Service

Mit dem Cmdlet **Set-Service** können Sie mit einem Dienst interagieren und diesen starten, beenden oder anhalten. Auch eine Änderung der Eigenschaften dieses Dienstes ist so möglich. Im folgenden Beispiel ändern wir den Anzeigenamen eines Dienstes von „Neue Workstation“ in „Alte Workstation“.

```shell
Set-Service -Name Neue Workstation -DisplayName "Alte Workstation"
```

### 27. Set-TimeZone

Wenn Sie die Zeitzone Ihres Systems verändern möchten, ist der Command **Set-TimeZone** die richtige Wahl. Wollen Sie die koordinierte Weltzeit als neue Systemzeit einstellen, ist dies der passende Befehl:

```shell
Set-TimeZone -Id "UTC"
```

### 28. Restart-Computer

Sie haben die Möglichkeit, das Betriebssystem auf Ihrem lokalen Rechner oder einem Remote Computer neu zu starten. Die passenden PowerShell-Befehle namens **Restart-Computer** sehen folgendermaßen aus:

Für Ihren lokalen Rechner:

```shell
Restart-Computer
```

Für bestimmte andere Computer in Ihrem Netzwerk:

```shell
Restart-Computer -ComputerName Server01, Server03
```

### 29. Restart-Service

Wenn Sie einen Dienst über PowerShell-Befehle beenden und neustarten möchten, ist **Restart-Service** der passende Cmdlet. So starten Sie zum Beispiel alle Dienste neu, die mit „Net“ beginnen:

```shell
PS C:\> Restart-Service -DisplayName "net*"
```

### 30. Clear-RecycleBin

Der Papierkorb sollte regelmäßig geleert werden. Die Leerung ist auch über die PowerShell möglich. Der Befehl lautet **Clear-RecycleBin**.

```shell
Clear-RecycleBin
```

### 31. Get-ComputerInfo

Der Befehl **Get-ComputerInfo** wird verwendet, um System- und Betriebssystemeigenschaften abzurufen.

```shell
Get-ComputerInfo
```

### 32. Move-Item

Es gibt verschiedene PowerShell-Befehle, wenn Sie ein Element von einem an einen anderen Speicherort verschieben möchten. Die gängigste Möglichkeit ist allerdings **Move-Item**. In diesem Beispiel verlegen wir die Datei alt.txt vom Laufwerk C: in das Verzeichnis D:\\Temp und benennen sie zusätzlich um in neu.txt.

```shell
Move-Item -Path C:\alt.txt -Destination D:\Temp\neu.txt
```

## Monitoring und Debugging mit den passenden PowerShell-Befehlen

Besonders nützlich sind außerdem jene PowerShell-Commands, mit denen Sie Ihr System überwachen und überprüfen können. Dies ist gerade dann von Vorteil, wenn Sie ein neues Netzwerk und dessen Performance unter realistischen Bedingungen testen möchten. Folgende PowerShell-Befehle dürften sich hierbei als nützlich erweisen.

### 33. Debug-Process

Debugging ist ein wichtiger Prozess, um sicherzustellen, dass alle Einstellungen und Prozesse fehlerfrei laufen. Dafür müssen Sie zunächst die passenden Debugger downloaden und konfigurieren. Ist dies geschehen, wenden Sie sie mit dem Befehl **Debug-Process** an. Im folgenden Beispiel nutzen wir einen Debugger für den Explorer:

```shell
PS C:\> Debug-Process -Name "Explorer"
```

Möchten Sie mehrere Prozesse gleichzeitig debuggen, so unterteilen Sie diese einfach per Kommata.

### 34. Enable-PSBreakpoint

Wenn Sie bestimmte Haltepunkte (sogenannte Breakpoints) aktivieren möchten, nutzen Sie den Befehl **Enable-PSBreakpoint**. Dieser setzt den Wert des Cmdlets aus technischer Sicht auf „true“. Mit diesen PowerShell-Befehlen aktiveren Sie alle Haltepunkte der aktuellen Sitzung:

```shell
Get-PSBreakpoint | Enable-PSBreakpoint
```

Diesen Command nutzen Sie, um Haltepunkte mit Hilfe ihrer ID zu aktivieren:

```shell
Enable-PSBreakpoint -ID 0, 3, 4
```

### 35. Disable-PSBreakpoint

Möchten Sie PowerShell Haltepunkte wieder deaktivieren, gibt es auch für diesen Zweck den passenden Cmdlet namens **Disable-PSBreakpoint**. Technisch gesehen, wird dafür der Wert des Befehls Enable-PSBreakpoint auf „false“ gesetzt. Um einen Haltepunkt mit der ID 0 zu deaktivieren, geben Sie Folgendes ein:

```shell
Disable-PSBreakpoint -Id 0
```

### 36. Get-Counter

Verwenden Sie Windows-Geräte, können Sie über die PowerShell deren Leistungsdaten abrufen. Der passende Befehl dafür ist **Get-Counter**. Sie können den Befehl sowohl für Ihren lokalen Rechner als auch für Remote Computer anwenden. Im folgenden Beispiel rufen wir die Daten des lokalen Computers ab:

```shell
Get-Counter -ListSet *
```

### 37. Start-Sleep

Gerade bei einer Überbelastung des Systems kann es sehr wichtig sein, dass Sie ein Skript oder eine Sitzung auch pausieren kann. Die PowerShell bietet dafür den Command **Start-Sleep**. Dabei geben Sie den Zeitraum an, in dem die Aktivitäten unterbunden werden sollen. Im folgenden Beispiel stoppt die Ausführung für zwei Sekunden.

```shell
Start-Sleep -Seconds 2
```

### 38. Test-Path

Mit Hilfe des Befehls **Test-Path** überprüfen Sie, ob alle Elemente eines bestimmten Pfads vorhanden sind. Die möglichen Ergebnisse lauten „True“ oder „False“.

```shell
Test-Path -Path "C:\Documents and Settings\Nutzer"
False
```

### 39. Test-Connection

Auch die Verbindungen innerhalb Ihres Netzwerks können Sie mit der PowerShell testen. Diese sendet über den Befehl **Test-Connection** ein ICMP-Echoanforderungspaket an festgelegte Empfänger und fordert über dieses Internet Control Message Protocol eine Antwort an. In unserem Beispiel senden wir dem Server02 eine Anfrage über das IPv6-Protokoll.

```shell
Test-Connection -TargetName Server02 -IPv6
```

### 40. Get-WinEvent

Benötigen Sie Einsicht in eines oder mehrere Ereignisprotokolle, stehen Ihnen unterschiedliche PowerShell-Befehle zur Verfügung. Der praktischste Cmdlet ist **Get-WinEvent**. Für sämtliche Protokolle von Ihrem lokalen Computer geben Sie folgenden Command ein:

```shell
Get-WinEvent -ListLog *
```


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/server/konfiguration/powershell-befehle/](https://www.ionos.com/de-ch/digitalguide/server/konfiguration/powershell-befehle/) for AI/LLM consumption.