PowerShell
Powershell Remoting

.NET Framework batch-file C# Language Git Java Language Node.js Python Language Regular Expressions SQL Microsoft SQL Server
Recherche…


Remarques

Activation de la communication à distance PowerShell

La communication à distance PowerShell doit d'abord être activée sur le serveur auquel vous souhaitez vous connecter à distance. 

Enable-PSRemoting -Force

Cette commande effectue les opérations suivantes:

  • Exécute la cmdlet Set-WSManQuickConfig, qui effectue les tâches suivantes:
  • Démarre le service WinRM.
  • Définit le type de démarrage du service WinRM sur Automatique.
  • Crée un écouteur pour accepter les demandes sur n'importe quelle adresse IP, s'il n'en existe pas déjà une.
  • Active une exception de pare-feu pour les communications WS-Management.
  • Enregistre les configurations de session Microsoft.PowerShell et Microsoft.PowerShell.Workflow, si elles ne sont pas déjà enregistrées.
  • Enregistre la configuration de session Microsoft.PowerShell32 sur des ordinateurs 64 bits, si elle n'est pas déjà enregistrée.
  • Active toutes les configurations de session.
  • Modifie le descripteur de sécurité de toutes les configurations de session pour autoriser l'accès à distance.
  • Redémarre le service WinRM pour que les modifications précédentes prennent effet.

Uniquement pour les environnements autres que les domaines

Pour les serveurs d'un domaine AD, l'authentification à distance PS s'effectue via Kerberos ('Default') ou NTLM ('Negotiate'). Si vous souhaitez autoriser l'accès distant à un serveur autre qu'un domaine, vous avez deux options.

Configurez la communication WSMan sur HTTPS (qui nécessite la génération de certificats) ou activez l'authentification de base qui envoie vos informations d'identification sur le câble encodé en base64 (ce qui est fondamentalement le même que du texte brut).

Dans les deux cas, vous devrez ajouter les systèmes distants à votre liste d'hôtes sécurisés WSMan.

Activation de l'authentification de base 

Set-Item WSMan:\localhost\Service\AllowUnencrypted $true

Ensuite , sur l'ordinateur que vous souhaitez connecter à partir, vous devez lui dire de faire confiance à l'ordinateur que vous vous connectez. 

Set-Item WSMan:\localhost\Client\TrustedHosts '192.168.1.1,192.168.1.2'

Set-Item WSMan:\localhost\Client\TrustedHosts *.contoso.com

Set-Item WSMan:\localhost\Client\TrustedHosts *

Important : vous devez demander à votre client de faire confiance à l'ordinateur adressé comme vous le souhaitez (par exemple, si vous vous connectez via IP, il doit faire confiance à l'adresse IP et non au nom d'hôte).

Connexion à un serveur distant via PowerShell

Utilisation des informations d'identification de votre ordinateur local: 

Enter-PSSession 192.168.1.1

Demander des informations d'identification sur l'ordinateur distant 

Enter-PSSession 192.168.1.1 -Credential $(Get-Credential)

Exécuter des commandes sur un ordinateur distant

Une fois que la communication à distance Powershell est activée (Enable-PSRemoting) Vous pouvez exécuter des commandes sur l'ordinateur distant comme ceci: 

Invoke-Command -ComputerName "RemoteComputerName" -ScriptBlock {
    Write host "Remote Computer Name: $ENV:ComputerName"
}

La méthode ci-dessus crée une session temporaire et la ferme juste après la fin de la commande ou du scriptblock.

Pour laisser la session ouverte et exécuter d'autres commandes ultérieurement, vous devez d'abord créer une session distante: 

$Session = New-PSSession -ComputerName "RemoteComputerName"

Ensuite, vous pouvez utiliser cette session chaque fois que vous invoquez des commandes sur l'ordinateur distant: 

Invoke-Command -Session $Session -ScriptBlock {
    Write host "Remote Computer Name: $ENV:ComputerName"
}

Invoke-Command -Session $Session -ScriptBlock {
    Get-Date
}

Si vous devez utiliser des informations d'identification différentes, vous pouvez les ajouter avec le paramètre -Credential : 

$Cred = Get-Credential
Invoke-Command -Session $Session -Credential $Cred -ScriptBlock {...}

Avertissement de sérialisation à distance

Remarque:

Il est important de savoir que la communication à distance sérialise les objets PowerShell sur le système distant et les désérialise à la fin de la session à distance, c'est-à-dire qu'ils sont convertis en XML pendant le transport et perdent toutes leurs méthodes. 

$output = Invoke-Command -Session $Session -ScriptBlock {
    Get-WmiObject -Class win32_printer
}

$output | Get-Member -MemberType Method

  TypeName: Deserialized.System.Management.ManagementObject#root\cimv2\Win32_Printer

Name     MemberType Definition
----     ---------- ----------
GetType  Method     type GetType()
ToString Method     string ToString(), string ToString(string format, System.IFormatProvi...

Considérant que vous avez les méthodes sur l'objet PS standard: 

Get-WmiObject -Class win32_printer | Get-Member -MemberType Method

 TypeName: System.Management.ManagementObject#root\cimv2\Win32_Printer

Name                  MemberType Definition                                                                                                                          
----                  ---------- ----------                                                                                                                          
CancelAllJobs         Method     System.Management.ManagementBaseObject CancelAllJobs()                                                                              
GetSecurityDescriptor Method     System.Management.ManagementBaseObject GetSecurityDescriptor()                                                                      
Pause                 Method     System.Management.ManagementBaseObject Pause()                                                                                      
PrintTestPage         Method     System.Management.ManagementBaseObject PrintTestPage()                                                                              
RenamePrinter         Method     System.Management.ManagementBaseObject RenamePrinter(System.String NewPrinterName)                                                  
Reset                 Method     System.Management.ManagementBaseObject Reset()                                                                                      
Resume                Method     System.Management.ManagementBaseObject Resume()                                                                                     
SetDefaultPrinter     Method     System.Management.ManagementBaseObject SetDefaultPrinter()                                                                          
SetPowerState         Method     System.Management.ManagementBaseObject SetPowerState(System.UInt16 PowerState, System.String Time)                                  
SetSecurityDescriptor Method     System.Management.ManagementBaseObject SetSecurityDescriptor(System.Management.ManagementObject#Win32_SecurityDescriptor Descriptor)

Utilisation des arguments

Pour utiliser des arguments comme paramètres du bloc de script distant, vous pouvez utiliser le paramètre ArgumentList d' Invoke-Command ou utiliser la syntaxe $Using: :.

Utiliser ArgumentList avec des paramètres non nommés (c'est-à-dire dans l'ordre dans lequel ils sont passés au scriptblock): 

$servicesToShow = "service1"
$fileName = "C:\temp\servicestatus.csv"
Invoke-Command -Session $session -ArgumentList $servicesToShow,$fileName -ScriptBlock {
    Write-Host "Calling script block remotely with $($Args.Count)"
    Get-Service -Name $args[0]
    Remove-Item -Path $args[1] -ErrorAction SilentlyContinue -Force
}

Utiliser ArgumentList avec les paramètres nommés: 

$servicesToShow = "service1"
$fileName = "C:\temp\servicestatus.csv"
Invoke-Command -Session $session -ArgumentList $servicesToShow,$fileName -ScriptBlock {
    Param($serviceToShowInRemoteSession,$fileToDelete)

    Write-Host "Calling script block remotely with $($Args.Count)"
    Get-Service -Name $serviceToShowInRemoteSession
    Remove-Item -Path $fileToDelete -ErrorAction SilentlyContinue -Force
}

Utiliser la syntaxe $Using: : 

$servicesToShow = "service1"
$fileName = "C:\temp\servicestatus.csv"
Invoke-Command -Session $session -ScriptBlock {
    Get-Service $Using:servicesToShow
    Remove-Item -Path $fileName -ErrorAction SilentlyContinue -Force
}

Une bonne pratique pour nettoyer automatiquement les sessions PSSession

Lorsqu'une session distante est créée via l'applet de New-PSsession , la session PSSession se poursuit jusqu'à la fin de la session PowerShell en cours. Cela signifie que, par défaut, la PSSession et toutes les ressources associées continueront à être utilisées jusqu'à la fin de la session PowerShell en cours.

Des PSSessions actives PSSessions peuvent devenir une charge pour les ressources, en particulier pour les scripts longs ou liés entre eux qui créent des centaines de PSSessions dans une seule session PowerShell.

Il est PSSession supprimer explicitement chaque PSSession après son utilisation. [1]

Le modèle de code suivant utilise try-catch-finally pour obtenir ce qui précède, en combinant la gestion des erreurs avec un moyen sécurisé pour s'assurer que toutes les PSSessions créées sont supprimées lorsqu'elles sont utilisées: 

try
{
    $session = New-PSsession -Computername "RemoteMachineName"
    Invoke-Command -Session $session -ScriptBlock {write-host "This is running on $ENV:ComputerName"}
}
catch
{
    Write-Output "ERROR: $_"
}
finally
{
    if ($session)
    {
        Remove-PSSession $session
    }
}

Références: [1] https://msdn.microsoft.com/en-us/powershell/reference/5.1/microsoft.powershell.core/new-pssession



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow