PowerShell Remoting: Voer Op Afstand Commando’s Uit Als Een Pro – techsyncer

Stel dat je hebt geleerd om commando’s lokaal uit te voeren; dat is al een opstapje naar het beheersen van externe uitvoering. PowerShell Remoting stelt beheerders in staat om commando’s en scripts uit te voeren op externe systemen.

Deze handleiding toont het instellen en gebruiken van PowerShell Remoting in een Active Directory (AD) omgeving. Stel je voor dat je bestanden maakt, scripts uitvoert of configuraties controleert op afstand zonder je bureau te verlaten.

Stel PowerShell Remoting in en gebruik het vol vertrouwen om scripts uit te voeren op externe systemen!

Instellen van PowerShell Remoting voor een standaardgebruiker

Voordat je volledig gebruik kunt maken van PowerShell Remoting, moet je ervoor zorgen dat de benodigde rechten aanwezig zijn. Het op afstand uitvoeren van commando’s of scripts is afhankelijk van een juiste configuratie, vooral in Active Directory omgevingen waar beveiliging een prioriteit is.

Begin met het proberen verbinding te maken met een externe server (SRV2) met behulp van Invoke-Command. Het volgende commando voert een scriptblock uit op de externe computer:

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

Als de verificatie mislukt, betekent dit meestal dat de gebruiker niet over de benodigde rechten beschikt.

Standaard moeten niet-beheerders lid zijn van de lokale Remote Management Users groep op de externe computer.

Controleer de groepslidmaatschap:

Get-LocalGroupMember -Group 'Remote Management Users'

Als de gebruiker niet vermeld staat, voeg ze dan toe:

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

Probeer nu opnieuw het Invoke-Command commando om de connectiviteit te bevestigen.

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

Het op afstand uitvoeren van een basis script

Zodra PowerShell Remoting is geconfigureerd, kunt u opdrachten uitvoeren op de externe computer. Deze mogelijkheid ontsluit het potentieel om taken te automatiseren, gegevens te verzamelen en problemen op afstand op te lossen.

Om te zien hoe PowerShell Remoting werkt, maakt u een tekstbestand op de externe machine en controleert u vervolgens of de actie succesvol is.

Definieer en voer het scriptblok uit:

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

Controleer of het bestand is aangemaakt met de volgende opdracht:

Deze opdracht maakt verbinding met de externe computer SRV2, haalt informatie op over het bestand somefile.txt en geeft alleen de naam en creatietijd weer.

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

Lokale scripts uitvoeren op externe computers

Misschien is een enkele opdracht niet voldoende en moet u een volledig script uitvoeren dat lokaal op uw machine is opgeslagen. Als dat het geval is, stelt PowerShell Remoting u in staat om snel een lokaal script naar een externe computer te sturen en het uit te voeren alsof u fysiek aanwezig was.

Om scripts uit te voeren op een externe computer, maakt u lokaal een kort script en voert u het uit op een externe machine om acties te automatiseren of opschoningstaken uit te voeren.

Maak lokaal een script met deze opdracht waarbij:

$scriptContents het script opslaat in een meertekststring met behulp van een here-string (@' ... '@), wat handig is om het script leesbaar en georganiseerd te houden.
Set-Content schrijft de inhoud van $scriptContents naar een bestand genaamd *RunThisRemotely.ps1* in de huidige map.

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

Bevestig de scriptinhoud:

Get-Content RunThisRemotely.ps1

Voer het script op afstand uit:

Invoke-Command -ComputerName SRV2 -FilePath RunThisRemotely.ps1

Controleer nu of het testbestand is verwijderd:

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

Het controleren van lokale registervermeldingen met een Scripblock

PowerShell Remoting ondersteunt het doorgeven van variabelen tussen lokale en externe sessies, waardoor flexibele en herbruikbare scripts mogelijk zijn. Maar laten we beginnen met het controleren van registervermeldingen lokaal.

Sla meerdere registerpaden op die later gecontroleerd kunnen worden om te zien of ze op het systeem bestaan:

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

Voeg dit toe aan het script om een scriptblok ****($localScriptBlock) te definiëren dat lokaal op de computer wordt uitgevoerd. Het scriptblok controleert of specifieke registerpaden bestaan op de lokale machine en geeft feedback voor elk pad.

# 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)."
        }
    }
}

Voer het scriptblok uit en kijk wat er gebeurt.

Invoke-Command -ScriptBlock $localScriptBlock

Het doorgeven van lokale variabelen aan externe sessies

Of u nu werkt met arrays, strings of objecten, u kunt gegevens doorgeven aan externe opdrachten op twee manieren:

$using – Integreert lokale variabelen rechtstreeks in het scriptblok.
ArgumentList – Geeft variabelen expliciet door aan het blok voor gebruik.

Lees verder om de twee methoden ($using of ArgumentList) te verkennen om dit doel te bereiken.

Het gebruik van het `$using`-keyword (Voorkeursbenadering)

Na het bevestigen dat de registervermeldingen bestaan, is de volgende stap om die array lokaal te lezen en deze te gebruiken in het script op een externe computer. Een manier om dit voor elkaar te krijgen is door het $using-sleutelwoord te gebruiken om lokale variabelen te verwijzen in externe sessies.

Maak dit script om uit te voeren op de externe computer en controleer de opgegeven registerpaden. Dit script geeft feedback over of elk pad al dan niet bestaat.

Met deze benadering voeg je eenvoudig het $using-voorvoegsel toe aan een lokale variabele. Deze actie vertelt PowerShell om de lokale variabele registryKeyPaths te raadplegen voordat de code op de externe computer wordt uitgevoerd.

$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)."
        }
    }
}

Vervolgens kun je het externe commando oproepen om de code op de externe machine uit te voeren:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2

Het lijkt erop dat de registervermeldingen daar ook bestaan.

Het gebruik van de `ArgumentList`-parameter

Naast het $using-sleutelwoord is een andere optie de ArgumentList-parameter om variabelen naar de externe sessie te sturen.

Maak een script (vergelijkbaar met een met het $using-sleutelwoord) dat de $args-array gebruikt om toegang te krijgen tot de waarden die via de ArgumentList-parameter zijn doorgegeven.

In deze methode specificeer je één of meer variabelen die naar de externe sessie moeten worden verzonden via de ArgumentList-parameter. Vervang in het scriptblok de lokale variabele door $args, die PowerShell automatisch zal invullen met de waarden die zijn doorgegeven via ArgumentList.

$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)."
        }
    }
}

Voer nu het script uit met het volgende commando:

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

Beide methoden zullen dezelfde output produceren, wat bevestigt dat de registervermeldingen bestaan op de externe computer.

Door deze stappen te volgen, kunt u effectief PowerShell Remoting instellen en gebruiken om commando’s en scripts uit te voeren op externe systemen.

Conclusie

In deze zelfstudie hebt u geleerd hoe u PowerShell Remoting instelt in een Active Directory-omgeving, commando’s en scripts uitvoert op externe systemen en variabelen effectief doorgeeft. Deze basisvaardigheden zijn essentieel voor het automatiseren van beheertaken en het efficiënt beheren van systemen.

Nu u de basisbeginselen onder de knie hebt, overweeg om meer geavanceerde onderwerpen te verkennen. Kijk naar persistente PowerShell-sessies, het omgaan met externe fouten of het maken van herbruikbare scripts voor bulkbewerkingen.

De mogelijkheden met PowerShell Remoting zijn eindeloos, dus begin met experimenteren en maak uw workflows efficiënter!