PowerShell Remoting: Exécutez des commandes à distance comme un pro

Tutoriels
PowerShell

Supposons que vous ayez appris à exécuter des commandes localement ; c’est déjà une étape vers la maîtrise de l’exécution à distance. PowerShell Remoting permet aux administrateurs d’exécuter des commandes et des scripts sur des systèmes distants.

Ce guide démontre la configuration et l’utilisation de PowerShell Remoting dans un environnement Active Directory (AD). Imaginez créer des fichiers, exécuter des scripts ou vérifier des configurations à distance sans quitter votre bureau.

Configurez et utilisez PowerShell Remoting pour exécuter des scripts en toute confiance sur des systèmes distants !

Configuration de PowerShell Remoting pour un utilisateur standard

Avant de tirer pleinement parti de PowerShell Remoting, vous devez vous assurer que les autorisations nécessaires sont en place. L’exécution de commandes ou de scripts à distance dépend d’une configuration appropriée, en particulier dans les environnements Active Directory où la sécurité est une priorité.

Commencez par tenter de vous connecter à un serveur distant (SRV2) en utilisant Invoke-Command. La commande suivante exécute un bloc de script sur l’ordinateur distant :

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

Si l’authentification échoue, cela signifie généralement que l’utilisateur n’a pas les autorisations nécessaires.

Par défaut, les utilisateurs non administrateurs doivent être membres du groupe local Utilisateurs de gestion à distance de l’ordinateur distant.

Vérifiez l’appartenance au groupe :

Get-LocalGroupMember -Group 'Remote Management Users'

Si l’utilisateur n’est pas listé, ajoutez-le :

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

Maintenant, réessayez la commande Invoke-Command pour confirmer la connectivité.

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

Exécution d’un script de base à distance

Une fois que le Remoting PowerShell est configuré, vous pouvez exécuter des commandes sur l’ordinateur distant. Cette capacité débloque le potentiel d’automatiser des tâches, de recueillir des données et de dépanner des problèmes à distance.

Pour voir comment fonctionne le remoting PowerShell, créez un fichier texte sur la machine distante, puis vérifiez que l’action est réussie.

Définissez et exécutez le scriptblock :

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

Vérifiez que le fichier a été créé avec la commande suivante :

Cette commande se connecte à l’ordinateur distant SRV2, récupère des informations sur le fichier somefile.txt et affiche uniquement son nom et l’heure de création.

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

Exécution de scripts locaux sur des ordinateurs distants

Parfois, une seule commande ne suffit pas et vous pourriez avoir besoin d’exécuter un script complet stocké localement sur votre machine. Si tel est le cas, le Remoting PowerShell vous permet d’envoyer rapidement un script local à un ordinateur distant et de l’exécuter comme si vous étiez physiquement présent.

Pour démontrer l’exécution de scripts sur un ordinateur distant, créez un petit script localement et exécutez-le sur une machine distante pour automatiser des actions ou des tâches de nettoyage.

Créez un script localement avec cette commande où :

  • $scriptContents stocke le script dans une chaîne multiligne en utilisant une chaîne de type « here-string » (@' ... '@), ce qui est utile pour garder le script lisible et organisé.
  • Set-Content écrit le contenu de $scriptContents dans un fichier appelé *RunThisRemotely.ps1* dans le répertoire actuel.
$scriptContents =
@'
Write-Host "Deleting the file just created..."
Remove-Item -Path somefile.txt
'@
Set-Content -Path 'RunThisRemotely.ps1' -Value $scriptContents

Confirmez le contenu du script :

Get-Content RunThisRemotely.ps1

Exécutez le script à distance :

Invoke-Command -ComputerName SRV2 -FilePath RunThisRemotely.ps1

Maintenant, vérifiez que le fichier de test a été supprimé :

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

Vérification des clés de registre locales avec un bloc de script

La télécommande PowerShell prend en charge le passage de variables entre les sessions locales et distantes, ce qui permet des scripts flexibles et réutilisables. Mais pour commencer, concentrons-nous sur la vérification des clés de registre localement.

Stockez plusieurs chemins de registre qui peuvent être vérifiés plus tard pour voir s’ils existent sur le système :

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

Ajoutez ceci au script pour définir un bloc de script ****($localScriptBlock) qui s’exécute localement sur l’ordinateur. Le bloc de script vérifie si des chemins de registre spécifiques existent sur la machine locale et fournit des retours pour chaque chemin.

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

Exécutez le bloc de script et voyez ce qui se passe.

Invoke-Command -ScriptBlock $localScriptBlock

Passage de variables locales aux sessions distantes

Que vous travailliez avec des tableaux, des chaînes ou des objets, vous pouvez passer des données aux commandes distantes de deux manières :

  • $using – Intègre directement les variables locales dans le bloc de script.
  • ArgumentList – Passe explicitement des variables au bloc pour utilisation.

Lisez la suite pour explorer les deux méthodes ($using ou ArgumentList) pour atteindre cet objectif.

Utilisation du mot-clé $using (approche préférée)

Après avoir confirmé que les clés de registre existent, l’étape suivante consiste à lire ce tableau localement et à l’utiliser dans le script sur un ordinateur distant. Une façon d’accomplir cet exploit est d’utiliser le mot-clé $using pour faire référence aux variables locales dans les sessions à distance.

Créez ce script pour s’exécuter sur l’ordinateur distant et vérifiez les chemins de registre spécifiés. Ce script fournit des retours d’informations sur chaque chemin existe ou non.

Avec cette approche, vous ajoutez simplement le préfixe $using à une variable locale. Cette action indique à PowerShell de faire référence à la variable locale registryKeyPaths avant d’exécuter le code sur l’ordinateur distant.

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

Vous pouvez ensuite invoquer la commande à distance pour exécuter le code sur la machine distante:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2

Il semble que les clés de registre existent là aussi.

Utilisation du paramètre ArgumentList

Outre le mot-clé $using, une autre option est le paramètre ArgumentList pour envoyer des variables à la session à distance.

Créez un script (similaire à celui avec le mot-clé $using) qui utilise le tableau $args pour accéder aux valeurs passées via le paramètre ArgumentList.

Dans cette méthode, vous spécifiez une ou plusieurs variables à envoyer à la session à distance via le paramètre ArgumentList. À l’intérieur du bloc de script, remplacez la variable locale par $args, que PowerShell remplira automatiquement avec les valeurs passées 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)."
        }
    }
}

Maintenant, exécutez le script avec la commande suivante:

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

Les deux méthodes produiront le même résultat, confirmant que les clés de registre existent sur l’ordinateur distant.

En suivant ces étapes, vous pouvez mettre en place et utiliser efficacement PowerShell Remoting pour exécuter des commandes et des scripts sur des systèmes distants.

Conclusion

Dans ce tutoriel, vous avez appris à configurer PowerShell Remoting dans un environnement Active Directory, à exécuter des commandes et des scripts sur des systèmes distants, et à transmettre des variables efficacement. Ces compétences fondamentales sont essentielles pour automatiser les tâches administratives et gérer les systèmes efficacement.

Maintenant que vous avez couvert les bases, envisagez d’explorer des sujets plus avancés. Renseignez-vous sur les sessions PowerShell persistantes, la gestion des erreurs à distance, ou la création de scripts réutilisables pour gérer des opérations en masse.

Les possibilités avec PowerShell Remoting sont infinies—alors commencez à expérimenter et rendez vos flux de travail plus efficaces !

Source:
https://adamtheautomator.com/powershell-remoting-guide/