Remoting und Automatisierung

PowerShell-Remoting bedeutet: Befehle oder Skripte auf anderen Rechnern ausführen, als säßest du davor. Das skaliert von „eine Maschine“ bis „ganze Server-Listen“. Du sparst Laufwege, tippst weniger und automatisierst Routinearbeit sicher und reproduzierbar.

Überblick: Werkzeuge im Vergleich

Aufgabe	Cmdlet	Kurzbeschreibung
Interaktive Remote-Shell	`Enter-PSSession`	Eine Live-Sitzung auf genau einen Zielhost öffnen, mit `Exit-PSSession` beenden
Einmalige Remote-Ausführung	`Invoke-Command`	Beliebigen Codeblock auf einem oder vielen Zielsystemen ausführen
Sitzungen verwalten	`New-PSSession`, `Get-PSSession`, `Remove-PSSession`	Wiederverwendbare Verbindungen, schneller und kontrollierbarer
Dateien übertragen	`Copy-Item -ToSession / -FromSession`	Dateien zwischen lokalem System und Remotesystem kopieren
Variablen übergeben	`$using:`	Lokale Variablen in den Remote-ScriptBlock injizieren

Zwei Transportwege: WinRM und SSH

Transport	Typisch	Hinweis
WinRM (HTTP/HTTPS)	Windows PowerShell 5.1, Domänenumfeld	Standard in Windows; Kerberos in Domänen, HTTPS empfohlen
SSH	PowerShell 7 (cross-platform)	Läuft auf Windows, Linux, macOS; nutzt gewohnte SSH-Keys/Ports

Start: Remoting auf Windows aktivieren (WinRM)

Auf dem Zielrechner einmalig Remoting einschalten (als Administrator):

Enable-PSRemoting -Force

Was dabei passiert: WinRM-Dienst wird konfiguriert, Listener erstellt, Firewallregel gesetzt. In Domänen funktioniert Authentifizierung i. d. R. „out-of-the-box“ via Kerberos.

Workgroup-Szenario (ohne Domäne): Falls nötig Zielhost freigeben (nur testweise so weit öffnen, wie wirklich nötig):

# Vertrauenswürdige Hosts gezielt setzen (Beispiel: einzelner Host)
Set-Item WSMan:\localhost\Client\TrustedHosts -Value "SRV-01"
# Hinzufügen ohne Überschreiben:
Set-Item WSMan:\localhost\Client\TrustedHosts -Concatenate -Value "SRV-02"

Für produktiv: besser HTTPS-Listener mit Zertifikat nutzen als breite TrustedHosts-Einträge.

Interaktive Remote-Shell

Enter-PSSession -ComputerName SRV-01 -Credential (Get-Credential)
# ... du arbeitest nun "auf" SRV-01 ...
Get-ComputerInfo | Select-Object OsName, CsName
Exit-PSSession

Gedankliches Bild:

[Dein Terminal]  ——(Session)——>  [SRV-01: PS-Konsole]

Einmalige Remote-Ausführung (Fan-out)

$server = @('SRV-01','SRV-02','SRV-03')
Invoke-Command -ComputerName $server -ScriptBlock {
  Get-Service | Where-Object Status -eq 'Running' | Measure-Object | Select-Object Count
}

Das gleiche Muster mit einem Ergebnis je Zielhost: PowerShell liefert Objekte inkl. PSComputerName, damit du sofort siehst, woher welcher Datensatz stammt.

ScriptBlocks und Argumente

Ein ScriptBlock ist der Remote-Code in geschweiften Klammern. Parameter übergibst du mit -ArgumentList oder per $using: für lokale Variablen.

$minCpu = 100
Invoke-Command -ComputerName SRV-01 -ScriptBlock {
  param($limit)
  Get-Process | Where-Object CPU -gt $limit | Select-Object Name, CPU
} -ArgumentList $minCpu

# Alternative mit $using:
Invoke-Command -ComputerName SRV-01 -ScriptBlock {
  Get-Process | Where-Object CPU -gt $using:minCpu
}

Sitzungen wiederverwenden (schneller, stabiler)

# Einmal aufbauen
$s = New-PSSession -ComputerName SRV-01, SRV-02
# Mehrfach nutzen
Invoke-Command -Session $s -ScriptBlock { Get-Uptime }
Invoke-Command -Session $s -ScriptBlock { Get-Service bits }
# Am Ende aufräumen
Remove-PSSession $s

Vorteile: geringere Latenz, konsistenter Kontext (z. B. Pfade, Module bleiben geladen).

Dateien kopieren über Remoting

$s = New-PSSession -ComputerName SRV-01
Copy-Item "C:\Temp\tool.exe" -ToSession $s -Destination "C:\Tools\tool.exe"
Copy-Item -FromSession $s -Path "C:\Logs\server.log" -Destination "$HOME\Downloads\server.log"
Remove-PSSession $s

Ergebnisse sauber einsammeln

Invoke-Command liefert Objekte zurück. Du kannst direkt filtern, gruppieren, exportieren:

$servers = @('SRV-01','SRV-02','SRV-03')
$result  = Invoke-Command -ComputerName $servers -ScriptBlock {
  Get-Volume | Select-Object DriveLetter, SizeRemaining, Size
}
$result |
  Select-Object PSComputerName, DriveLetter,
    @{n='Free%';e={[math]::Round( $_.SizeRemaining / $_.Size * 100, 1)}} |
  Sort-Object Free% |
  Export-Csv "$HOME\disk_report.csv" -NoTypeInformation

Parallelisieren und drosseln

Bei vielen Zielsystemen:

Invoke-Command -ComputerName $servers -ScriptBlock { Get-Service spooler } -ThrottleLimit 20

-ThrottleLimit begrenzt gleichzeitige Verbindungen. Für sehr große Flotten lohnt sich -AsJob plus Receive-Job.

$job = Invoke-Command -ComputerName $servers -ScriptBlock { Get-HotFix } -AsJob
Wait-Job $job
Receive-Job $job

Fehlerbehandlung im Remoting-Kontext

Die gleichen Prinzipien wie in der Fehlerlektion, aber mit zusätzlichem Auge auf Remote-Grenzen:

try {
  Invoke-Command -ComputerName SRV-01 -ScriptBlock {
    Get-Item 'C:\NichtDa.txt' -ErrorAction Stop
  } -ErrorAction Stop
}
catch {
  # Lokal abfangen, Meldung enthält Remote-Kontext
  Write-Warning "Remote-Fehler: $($_.Exception.Message)"
}

Praktisch ist auch das Einsammeln je Host:

$servers | ForEach-Object {
  try {
    Invoke-Command -ComputerName $_ -ScriptBlock { test-path 'C:\Wichtig' } -ErrorAction Stop |
      Select-Object @{n='Host';e={$env:COMPUTERNAME}}, @{n='Exists';e={$_}}
  }
  catch {
    [pscustomobject]@{ Host = $_; Exists = $false; Error = $PSItem.Exception.Message }
  }
}

Remoting mit PowerShell 7 über SSH

Vorteil: funktioniert identisch auf Windows, Linux und macOS, nutzt vorhandene SSH-Infrastruktur.

# Interaktiv
Enter-PSSession -HostName admin@server01 -KeyFile ~/.ssh/id_ed25519
# Einmalige Ausführung
Invoke-Command  -HostName admin@server01 -ScriptBlock { hostname; pwsh --version }

Voraussetzungen: OpenSSH-Server auf dem Ziel, PowerShell 7 (pwsh) installiert und in der SSH-Subsystem-Konfiguration hinterlegt. Auth über Key oder Passwort möglich.

Sicherheits-Gedanken

Bevorzugt Kerberos in Domänen oder SSH mit Keys.
Für Workgroups: wenn möglich WinRM über HTTPS, nicht breit gefächerte TrustedHosts.
Prinzip der geringsten Rechte: dedizierte Service-Konten, keine Domain-Admins „auf Verdacht“.
JEA (Just Enough Administration): rollenbasierte, begrenzte Remoting-Endpunkte für bestimmte Aufgaben (Advanced-Thema, lohnt sich später als eigenes Kapitel).

Mini-Visual: Fan-out in einem Bild

           [Dein Admin-Rechner]
                    |
     +--------------+---------------+
     |              |               |
  [SRV-01]       [SRV-02]        [SRV-03]
  ScriptBlock    ScriptBlock     ScriptBlock
  Ergebnis A     Ergebnis B      Ergebnis C
         \            |               /
          +-----------+--------------+
                      |
                [Gesamtreport]

Praxisbeispiel: Dienstzustände prüfen und reparieren

$targets = @('SRV-01','SRV-02','SRV-03')
Invoke-Command -ComputerName $targets -ScriptBlock {
  $svc = Get-Service -Name 'Spooler' -ErrorAction SilentlyContinue
  if (-not $svc) {
    [pscustomobject]@{ Host=$env:COMPUTERNAME; Status='Missing' }
  }
  elseif ($svc.Status -ne 'Running') {
    try {
      Start-Service -Name 'Spooler' -ErrorAction Stop
      [pscustomobject]@{ Host=$env:COMPUTERNAME; Status='Started' }
    }
    catch {
      [pscustomobject]@{ Host=$env:COMPUTERNAME; Status='Failed'; Error=$_.Exception.Message }
    }
  }
  else {
    [pscustomobject]@{ Host=$env:COMPUTERNAME; Status='OK' }
  }
} | Sort-Object Status | Format-Table -AutoSize

Praxisbeispiel: Patch-Level sammeln und als CSV sichern

$servers = Get-Content "$HOME\serverliste.txt"
Invoke-Command -ComputerName $servers -ScriptBlock {
  Get-HotFix | Sort-Object InstalledOn -Descending | Select-Object -First 1 @{
    n='Host'; e={$env:COMPUTERNAME}
  }, HotFixID, InstalledOn
} | Export-Csv "$HOME\patchstand.csv" -NoTypeInformation