Comment puis-je inclure une localement la fonction définie lors de l'utilisation de PowerShell de la Commande Invoke-command pour l'accès distant?

J'ai l'impression que je suis absent quelque chose qui devrait être évident, mais je ne peux pas comprendre comment le faire.

J'ai un script ps1 qui a une fonction définie en elle. Il appelle la fonction, puis essaie de l'utiliser à distance:

function foo
{
    Param([string]$x)

    Write-Output $x
}

foo "Hi!"

Invoke-Command -ScriptBlock { foo "Bye!" } -ComputerName someserver.example.com -Credential someuser@example.com

Ce court exemple de script affiche "Bonjour!" et puis se bloque en disant: "Le terme 'foo' n'est pas reconnu comme nom d'applet de commande, fonction, fichier de script ou d'un programme exécutable."

Je comprends que la fonction n'est pas définie sur le serveur distant, car il n'est pas dans le ScriptBlock. J'ai pu redéfinir là, mais je préfère ne pas. J'aimerais définir la fonction une fois et l'utiliser localement ou à distance. Est-il une bonne façon de le faire?

InformationsquelleAutor David Hogue | 2012-07-06

33

Vous avez besoin pour passer à la fonction elle-même (pas un appel à la fonction dans le ScriptBlock).

J'ai eu le même besoin, la semaine dernière, et a trouvé cette SORTE de discussion

Votre code deviendra donc:
```
Invoke-Command -ScriptBlock ${function:foo} -argumentlist "Bye!" -ComputerName someserver.example.com -Credential someuser@example.com
```
Noter qu'en utilisant cette méthode, vous ne pouvez passer des paramètres en fonction de votre position; vous ne pouvez pas faire usage de paramètres nommés comme vous avez pu lors de l'exécution de la fonction localement.
- Ok, ça ressemble à quelque chose que j'avais lu. Donc, en prenant un peu plus loin: est-il une bonne façon de faire de la fonction et des lignes supplémentaires de script qui utilisent la fonction?
- Je n'ai pas testé encore, mais si vous voulez le format de sortie de la fonction (par exemple), cela devrait fonctionner: -ScriptBlock {$function:foo|format-table -auto}. Fondamentalement, toute ScriptBlock peut y avoir de "gros morceau" de valable code PowerShell, tant et aussi longtemps que vous le formater correctement (ou utiliser des points-virgules à la fin de chaque "ligne"), vous devriez être bon. Plus tôt aujourd'hui, j'ai été curage autour avec " mesure-commande {$x=[xml](get-content file.xml);$x.selectsinglenode("//chose");}, par exemple.
InformationsquelleAutor alroc
25

Vous pouvez passer à la définition de la fonction en tant que paramètre, puis redéfinir la fonction sur le serveur distant par la création d'un scriptblock et puis dot-sourcing il:
```
$fooDef = "function foo { ${function:foo} }"

Invoke-Command -ArgumentList $fooDef -ComputerName someserver.example.com -ScriptBlock {
    Param( $fooDef )

    . ([ScriptBlock]::Create($fooDef))

    Write-Host "You can call the function as often as you like:"
    foo "Bye"
    foo "Adieu!"
}
```
Ceci élimine le besoin d'avoir une copie de votre fonction. Vous pouvez également passer plus d'une fonction de cette manière, si vous êtes si incliné:
```
$allFunctionDefs = "function foo { ${function:foo} }; function bar { ${function:bar} }"
```
- Exactement ce que je cherchais! Votre solution en combinaison avec $Using:Var a fait le tour 🙂 Merci beaucoup!
InformationsquelleAutor JamesQMurphy
5

Vous pouvez aussi mettre les fonction(s) ainsi que le script dans un fichier (foo.ps1) et de l'Appeler-Commande à l'aide du Chemin d'accès du fichier de paramètre:
```
Invoke-Command –ComputerName server –FilePath .\foo.ps1
```
Le fichier sera copié sur les ordinateurs distants et exécuté.
- C'est la meilleure option. Réduit l'encombrement et est facile. Écrire le script comme vous voulez qu'il soit exécuté et le tour est joué!
InformationsquelleAutor Keith Hill

Bien que c'est une vieille question que je voudrais ajouter ma solution.

Assez drôle, le param liste des scriptblock au sein de la fonction test, ne prenez pas un argument de type [scriptblock] et à cet effet, les besoins de conversion.

Function Write-Log 
{
    param(
        [string]$Message
    )

    Write-Host -ForegroundColor Yellow "$($env:computername): $Message"
}

Function Test
{
    $sb = {
        param(
            [String]$FunctionCall
        )

        [Scriptblock]$WriteLog = [Scriptblock]::Create($FunctionCall) 
        $WriteLog.Invoke("There goes my message...")               
    }

    # Get function stack and convert to type scriptblock 
    [scriptblock]$writelog = (Get-Item "Function:Write-Log").ScriptBlock 

    # Invoke command and pass function in scriptblock form as argument 
    Invoke-Command -ComputerName SomeHost -ScriptBlock $sb -ArgumentList $writelog
}

Test

Une autre possibilité est de passer d'une table de hachage pour notre scriptblock contenant toutes les méthodes que vous souhaitez avoir à disposition dans la session à distance:

Function Build-FunctionStack 
{
    param([ref]$dict, [string]$FunctionName)

    ($dict.Value).Add((Get-Item "Function:${FunctionName}").Name, (Get-Item "Function:${FunctionName}").Scriptblock)
}

Function MyFunctionA 
{
    param([string]$SomeValue)

    Write-Host $SomeValue
}

Function MyFunctionB
{
    param([int]$Foo)

    Write-Host $Foo
}

$functionStack = @{}

Build-FunctionStack -dict ([ref]$functionStack) -FunctionName "MyFunctionA"
Build-FunctionStack -dict ([ref]$functionStack) -FunctionName "MyFunctionB" 

Function ExecuteSomethingRemote
{
    $sb = {
        param([Hashtable]$FunctionStack)

        ([Scriptblock]::Create($functionStack["MyFunctionA"])).Invoke("Here goes my message");
        ([Scriptblock]::Create($functionStack["MyFunctionB"])).Invoke(1234);

    }

    Invoke-Command -ComputerName SomeHost -ScriptBlock $sb -ArgumentList $functionStack
}

ExecuteSomethingRemote

InformationsquelleAutor Matze

Vous devez vous connecter pour publier un commentaire.