PowerShell-Remoting: Führen Sie Remote-Befehle wie ein Profi aus

Angenommen, Sie haben gelernt, Befehle lokal auszuführen; das ist bereits ein Schritt in Richtung der Beherrschung der Remote-Ausführung. PowerShell Remoting ermöglicht es Administratoren, Befehle und Skripte auf entfernten Systemen auszuführen.

In diesem Leitfaden wird gezeigt, wie PowerShell Remoting in einer Active Directory (AD)-Umgebung eingerichtet und verwendet wird. Stellen Sie sich vor, Dateien zu erstellen, Skripte auszuführen oder Konfigurationen remote zu überprüfen, ohne Ihren Schreibtisch zu verlassen.

Richten Sie PowerShell Remoting ein und verwenden Sie es, um Skripte auf entfernten Systemen sicher auszuführen!

Einrichten von PowerShell Remoting für einen Standardbenutzer

Bevor Sie die volle Leistungsfähigkeit von PowerShell Remoting nutzen können, müssen Sie sicherstellen, dass die erforderlichen Berechtigungen vorhanden sind. Das Ausführen von Befehlen oder Skripten remote hängt von einer ordnungsgemäßen Konfiguration ab, insbesondere in Active Directory-Umgebungen, wo Sicherheit oberste Priorität hat.

Beginnen Sie damit, zu versuchen, eine Verbindung zu einem Remote-Server (SRV2) unter Verwendung von Invoke-Command herzustellen. Der folgende Befehl führt einen Skriptblock auf dem Remote-Computer aus:

Invoke-Command -ComputerName SRV2 -ScriptBlock {Write-Host "Hi, I'm running code on the $(hostname) remote computer!"}

Wenn die Authentifizierung fehlschlägt, bedeutet dies in der Regel, dass der Benutzer über die erforderlichen Berechtigungen verfügt.

Standardmäßig müssen nicht-administrative Benutzer Mitglieder der lokalen Remote Management Users-Gruppe des Remote-Computers sein.

Überprüfen Sie die Gruppenmitgliedschaft:

Get-LocalGroupMember -Group 'Remote Management Users'

Wenn der Benutzer nicht aufgeführt ist, fügen Sie ihn hinzu:

Add-LocalGroupMember -Group 'Remote Management Users' -Member user
Get-LocalGroupMember -Group 'Remote Management Users'

Versuchen Sie nun erneut, den Invoke-Command-Befehl auszuführen, um die Konnektivität zu bestätigen.

Invoke-Command -ComputerName SRV2 -ScriptBlock {Write-Host "Hi, I'm running code on the $(hostname) remote computer!"}

Ausführen eines grundlegenden Skripts remote

Sobald die PowerShell-Remotefreigabe konfiguriert ist, können Befehle auf dem Remote-Computer ausgeführt werden. Diese Funktion entsperrt das Potenzial zur Automatisierung von Aufgaben, Datensammlung und Fehlerbehebung aus der Ferne.

Um zu sehen, wie PowerShell-Remoting funktioniert, erstellen Sie eine Textdatei auf dem Remote-Computer und überprüfen dann, ob die Aktion erfolgreich war.

Definieren und führen Sie den Skriptblock aus:

$scriptblock = { Set-Content -Path 'somefile.txt' -Value '' }
Invoke-Command -Scriptblock $scriptblock -ComputerName SRV2

Überprüfen Sie, ob die Datei mit folgendem Befehl erstellt wurde:

Dieser Befehl stellt eine Verbindung zum Remote-Computer SRV2 her, ruft Informationen über die Datei somefile.txt ab und gibt nur deren Namen und Erstellungszeit aus.

icm -ComputerName SRV2 -ScriptBlock {Get-Item somefile.txt} | Select-Object Name, CreationTime

Ausführen lokaler Skripte auf Remote-Computern

Vielleicht reicht ein einzelner Befehl nicht aus, und Sie müssen möglicherweise ein vollständiges Skript ausführen, das lokal auf Ihrem Computer gespeichert ist. In diesem Fall ermöglicht Ihnen das PowerShell-Remoting das schnelle Senden eines lokalen Skripts an einen Remote-Computer und dessen Ausführung, als wären Sie physisch dort.

Zur Demonstration des Ausführens von Skripten auf einem Remote-Computer erstellen Sie ein kurzes Skript lokal und führen es auf einem Remote-Computer aus, um Aktionen zu automatisieren oder Bereinigungsaufgaben durchzuführen.

Erstellen Sie ein Skript lokal mit diesem Befehl, bei dem:

• $scriptContents das Skript in einem mehrzeiligen String unter Verwendung eines Here-Strings (@' ... '@) speichert, was nützlich ist, um das Skript lesbar und organisiert zu halten.
• Set-Content schreibt den Inhalt von $scriptContents in eine Datei namens *RunThisRemotely.ps1* im aktuellen Verzeichnis.

$scriptContents =
@'
Write-Host "Deleting the file just created..."
Remove-Item -Path somefile.txt
'@
Set-Content -Path 'RunThisRemotely.ps1' -Value $scriptContents

Bestätigen Sie den Skriptinhalt:

Get-Content RunThisRemotely.ps1

Führen Sie das Skript remote aus:

Invoke-Command -ComputerName SRV2 -FilePath RunThisRemotely.ps1

Überprüfen Sie nun, ob die Testdatei gelöscht wurde:

icm -ComputerName SRV2 -ScriptBlock {Test-Path somefile.txt}

Überprüfen von lokalen Registrierungsschlüsseln mit einem Skriptblock

PowerShell Remoting unterstützt das Übergeben von Variablen zwischen lokalen und Remote-Sitzungen, was flexible und wiederverwendbare Skripte ermöglicht. Aber zuerst konzentrieren wir uns darauf, die Registrierungsschlüssel lokal zu überprüfen.

Speichern Sie mehrere Registrierungspfade, die später überprüft werden können, um zu sehen, ob sie auf dem System vorhanden sind:

# Define an array of registry paths to check
$registryKeyPaths = @(
    'HKLM:\SOFTWARE\Microsoft\AppV\', 
    'HKLM:\SOFTWARE\Microsoft\AccountsControl\'
)

Fügen Sie dieses Skript hinzu, um einen Skriptblock ****($localScriptBlock) zu definieren, der lokal auf dem Computer ausgeführt wird. Der Skriptblock überprüft, ob bestimmte Registrierungspfade auf dem lokalen Rechner vorhanden sind und liefert Feedback für jeden Pfad.

# Define the script block that will run locally on the computer
$localScriptBlock = {
    ## Iterate through each registry path in the $registryKeyPaths array
    foreach ($path in $registryKeyPaths) {
        # Check if the current registry path exists on the local machine
        if (Test-Path -Path $path) {
            # If the path exists, output a message confirming its existence
            Write-Host -Object "The registry path [$path] exists on the computer $(hostname)."
        } else {
            # If the path does not exist, output a message stating its absence
            Write-Host -Object "The registry path [$path] does not exist on the computer $(hostname)."
        }
    }
}

Führen Sie den Skriptblock aus und sehen Sie, was passiert.

Invoke-Command -ScriptBlock $localScriptBlock

Übergeben von lokalen Variablen an Remote-Sitzungen

Unabhängig davon, ob Sie mit Arrays, Zeichenfolgen oder Objekten arbeiten, können Sie Daten auf zwei Arten an Remote-Befehle übergeben:

• $using – Integriert lokale Variablen direkt in den Skriptblock.
• ArgumentList – Überträgt Variablen explizit an den Block zur Verwendung.

Lesen Sie weiter, um die beiden Methoden ($using oder ArgumentList) zur Erreichung dieses Ziels zu erkunden.

Verwendung des Schlüsselworts $using (bevorzugter Ansatz)

Nach Bestätigung, dass die Registrierungsschlüssel existieren, ist der nächste Schritt, dieses Array lokal zu lesen und es im Skript auf einem Remote-Computer zu verwenden. Eine Möglichkeit, dies zu erreichen, ist die Verwendung des $using-Schlüsselworts, um lokale Variablen in Remote-Sitzungen zu referenzieren.

Erstellen Sie dieses Skript, um auf dem Remote-Computer ausgeführt zu werden und die angegebenen Registrierungspfade zu überprüfen. Dieses Skript gibt Feedback darüber, ob jeder Pfad existiert oder nicht.

Mit diesem Ansatz fügen Sie einfach das $using-Präfix einer lokalen Variablen hinzu. Diese Aktion sagt PowerShell, die lokale Variable registryKeyPaths zu referenzieren, bevor der Code auf dem Remote-Computer ausgeführt wird.

$remoteScriptBlock = {
    ## Check to see if the registry keys exist on the computer
    foreach ($path in $using:registryKeyPaths) {
        if (Test-Path -Path $path) {
            Write-Host -Object "The registry path [$path] exists on the computer $(hostname)."
        } else {
            Write-Host -Object "The registry path [$path] does not exist on the computer $(hostname)."
        }
    }
}

Dann können Sie den Remote-Befehl aufrufen, um den Code auf dem Remote-Computer auszuführen:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2

Es scheint, als ob die Registrierungsschlüssel auch dort existieren.

Verwendung des ArgumentList-Parameters

Abgesehen vom $using-Schlüsselwort gibt es eine weitere Option, den ArgumentList-Parameter zu verwenden, um Variablen an die Remote-Sitzung zu senden.

Erstellen Sie ein Skript (ähnlich dem mit dem $using-Schlüsselwort), das das $args-Array verwendet, um auf die über den ArgumentList-Parameter übergebenen Werte zuzugreifen.

In dieser Methode geben Sie eine oder mehrere Variablen an, die über den ArgumentList-Parameter an die Remote-Sitzung gesendet werden sollen. Im Skriptblock ersetzen Sie die lokale Variable durch $args, die PowerShell automatisch mit den über ArgumentList übergebenen Werten füllt.

$remoteScriptBlock = {
    ## Check to see if the registry keys exist on the computer
    foreach ($path in $args) {
        if (Test-Path -Path $path) {
            Write-Host -Object "The registry path [$path] exists on the computer $(hostname)."
        } else {
            Write-Host -Object "The registry path [$path] does not exist on the computer $(hostname)."
        }
    }
}

Führen Sie jetzt das Skript mit folgendem Befehl aus:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2 -ArgumentList $registryKeyPaths

Beide Methoden erzeugen die gleiche Ausgabe und bestätigen, dass die Registrierungsschlüssel auf dem Remote-Computer vorhanden sind.

Indem Sie diese Schritte befolgen, können Sie PowerShell-Remoting effektiv einrichten und verwenden, um Befehle und Skripte auf Remote-Systemen auszuführen.

Fazit

In diesem Tutorial haben Sie gelernt, wie man PowerShell-Remoting in einer Active Directory-Umgebung einrichtet, Befehle und Skripte auf Remote-Systemen ausführt und Variablen effektiv übergibt. Diese grundlegenden Fähigkeiten sind entscheidend für die Automatisierung administrativer Aufgaben und das effiziente Management von Systemen.

Jetzt, wo Sie die Grundlagen verstanden haben, ziehen Sie in Betracht, fortgeschrittenere Themen zu erkunden. Schauen Sie sich persistente PowerShell-Sitzungen, den Umgang mit Remote-Fehlern oder das Erstellen wiederverwendbarer Skripte für die Durchführung von Großoperationen an.

Die Möglichkeiten mit PowerShell-Remoting sind endlos – also fangen Sie an zu experimentieren und machen Sie Ihre Arbeitsabläufe effizienter!