PowerShell Remoting: Esegui Comandi Remoti Come un Professionista

Supponiamo che tu abbia imparato ad eseguire comandi localmente; questo è già un passo avanti verso il dominio dell’esecuzione remota. PowerShell Remoting consente agli amministratori di eseguire comandi e script su sistemi remoti.

Questa guida dimostra come configurare e utilizzare PowerShell Remoting in un ambiente Active Directory (AD). Immagina di creare file, eseguire script o controllare configurazioni da remoto senza lasciare la tua scrivania.

Configura e utilizza PowerShell Remoting per eseguire con sicurezza script su sistemi remoti!

Configurazione di PowerShell Remoting per un Utente Standard

Prima di sfruttare appieno PowerShell Remoting, devi assicurarti che siano in atto le autorizzazioni necessarie. L’esecuzione di comandi o script da remoto dipende da una configurazione corretta, specialmente negli ambienti Active Directory dove la sicurezza è una priorità.

Inizia tentando di connetterti a un server remoto (SRV2) utilizzando Invoke-Command. Il seguente comando esegue un blocco di script sul computer remoto:

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

Se l’autenticazione fallisce, di solito significa che l’utente non ha le autorizzazioni necessarie.

Per impostazione predefinita, gli utenti non amministrativi devono essere membri del gruppo locale Remote Management Users del computer remoto.

Controlla i membri del gruppo:

Get-LocalGroupMember -Group 'Remote Management Users'

Se l’utente non è elencato, aggiungilo:

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

Ora, riprova il comando Invoke-Command per confermare la connettività.

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

Esecuzione di uno Script di Base da Remoto

Una volta configurato il PowerShell Remoting, è possibile eseguire comandi sul computer remoto. Questa capacità sblocca il potenziale per automatizzare compiti, raccogliere dati e risolvere problemi a distanza.

Per vedere come funziona il remoting di PowerShell, crea un file di testo sulla macchina remota, quindi verifica che l’azione sia riuscita.

Definisci ed esegui lo scriptblock:

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

Verifica che il file sia stato creato con il seguente comando:

Questo comando si connette al computer remoto SRV2, recupera informazioni sul file somefile.txt e ne visualizza solo il nome e l’orario di creazione.

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

Esecuzione di script locali su computer remoti

Forse un singolo comando non è sufficiente e potresti aver bisogno di eseguire uno script completo memorizzato localmente sulla tua macchina. In tal caso, il PowerShell Remoting ti consente di inviare rapidamente uno script locale a un computer remoto ed eseguirlo come se fossi fisicamente presente.

Per dimostrare l’esecuzione di script su un computer remoto, crea uno script breve localmente ed eseguilo su una macchina remota per automatizzare azioni o compiti di pulizia.

Crea uno script localmente con questo comando dove:

• $scriptContents memorizza lo script in una stringa su più righe utilizzando una here-string (@' ... '@), utile per mantenere lo script leggibile e organizzato.
• Set-Content scrive i contenuti di $scriptContents in un file chiamato *RunThisRemotely.ps1* nella directory corrente.

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

Conferma i contenuti dello script:

Get-Content RunThisRemotely.ps1

Esegui lo script a distanza:

Invoke-Command -ComputerName SRV2 -FilePath RunThisRemotely.ps1

Ora, verifica che il file di test sia stato eliminato:

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

Verifica delle chiavi di registro locali con uno ScriptBlock

Il PowerShell Remoting supporta il passaggio di variabili tra sessioni locali e remote, consentendo script flessibili e riutilizzabili. Ma per cominciare, concentriamoci sul controllo delle chiavi di registro localmente.

Memorizza più percorsi di registro che possono essere controllati in seguito per vedere se esistono sul sistema:

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

Aggiungi questo allo script per definire uno script block ****($localScriptBlock) che viene eseguito localmente sul computer. Lo script block verifica se percorsi di registro specifici esistono sulla macchina locale e fornisce un feedback per ogni percorso.

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

Esegui lo script block e guarda cosa succede.

Invoke-Command -ScriptBlock $localScriptBlock

Passaggio di variabili locali a sessioni remote

Che tu stia lavorando con array, stringhe o oggetti, puoi passare dati ai comandi remoti in due modi:

• $using – Integra variabili locali direttamente nello script block.
• ArgumentList – Passa esplicitamente variabili al block per l’uso.

Continua a leggere per esplorare i due metodi ($using o ArgumentList) per raggiungere questo obiettivo.

Utilizzo della parola chiave $using (Approccio preferito)

Dopo aver confermato che le chiavi di registro esistono, il passo successivo è leggere quell’array localmente e utilizzarlo nello script su un computer remoto. Un modo per realizzare questa operazione è utilizzare la parola chiave $using per fare riferimento a variabili locali nelle sessioni remote.

Creare questo script da eseguire sul computer remoto e controllare i percorsi di registro specificati. Questo script fornisce feedback su se ciascun percorso esista o meno.

Con questo approccio, è sufficiente aggiungere il prefisso $using a una variabile locale. Questa azione dice a PowerShell di fare riferimento alla variabile locale registryKeyPaths prima di eseguire il codice sul computer remoto.

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

È quindi possibile invocare il comando remoto per eseguire il codice sulla macchina remota:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2

Sembra che le chiavi di registro esistano anche lì.

Utilizzando il parametro ArgumentList

Oltre alla parola chiave $user, un’altra opzione è il parametro ArgumentList per inviare variabili alla sessione remota.

Creare uno script (simile a quello con la parola chiave $using) che utilizza l’array $args per accedere ai valori passati tramite il parametro ArgumentList.

In questo metodo, si specificano una o più variabili da inviare alla sessione remota tramite il parametro ArgumentList. All’interno del blocco di script, sostituire la variabile locale con $args, che PowerShell popolerà automaticamente con i valori passati tramite 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)."
        }
    }
}

Ora, eseguire lo script con il seguente comando:

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

Entrambi i metodi produrranno lo stesso output, confermando che le chiavi di registro esistono sul computer remoto.

Seguendo questi passaggi, puoi impostare e utilizzare efficacemente PowerShell Remoting per eseguire comandi e script sui sistemi remoti.

Conclusione

In questo tutorial, hai imparato come configurare PowerShell Remoting in un ambiente Active Directory, eseguire comandi e script su sistemi remoti e passare variabili in modo efficace. Queste competenze fondamentali sono essenziali per automatizzare compiti amministrativi e gestire i sistemi in modo efficiente.

Ora che hai coperto le basi, considera di esplorare argomenti più avanzati. Dai un’occhiata alle sessioni PowerShell persistenti, alla gestione degli errori remoti o alla creazione di script riutilizzabili per gestire operazioni di massa.

Le possibilità con PowerShell Remoting sono infinite: inizia a sperimentare e rendi i tuoi flussi di lavoro più efficienti!