Import-PSSession

Import-PSSession [-Session] <PSSession> [[-CommandName] <string[]>] [[-FormatTypeName] <string[]>] [-AllowClobber] [-ArgumentList <Object[]>] [-CommandType {<Alias> | <Function> | <Filter> | <Cmdlet> | <ExternalScript> | <Application> | <Script> | <All>}] [-Module <string[]>] [-Prefix <string>] [<CommonParameters>]

C:\PS>$s = new-pssession -computername Server01

C:\PS> import-pssession -session $s

Descrição
-----------
Esse comando importa todos os comandos de uma PSSession no computador Server01 para a sessão atual, salvo os comandos com nome idêntico ao de comandos da sessão atual. 

Como esse comando não usa o parâmetro CommandName, ele também importa todos os dados de formatação necessários para os comandos importados.

C:\PS>$s = new-pssession https://ps.testlabs.com/powershell

C:\PS> import-pssession -session $s -commandname *-test -formatTypeName *

C:\PS> new-test -name test1

C:\PS> get-test test1 | run-test

Descrição
-----------
Esses comandos importam os comandos com nomes que terminam em "-test" de uma PSSession na sessão local e, depois, mostram como usar um cmdlet importado.

O primeiro comando usa o cmdlet New-PSSession para criar uma PSSession. Ele salva a PSSession na variável $s.

O segundo comando usa o cmdlet Import-PSSession para importar comandos da PSSession em $s para a sessão atual. Ele usa o parâmetro CommandName para especificar comandos com o substantivo Test e o parâmetro FormatTypeName para importar os dados de formatação para os comandos Test.

O terceiro e quarto comandos usam os comandos importados na sessão atual. Como os comandos importados são de fato adicionados à sessão atual, você usa a sintaxe local para executá-los. Você não precisa usar o cmdlet Invoke-Command to executar um comando importado.

C:\PS>$s1 = new-pssession -computername s1 

C:\PS> $s2 = new-pssession -computername s2

C:\PS> import-pssession -session s1 -type cmdlet -name New-Test, Get-Test -FormatTypeName *

C:\PS> import-pssession -session s2 -type cmdlet -name Set-Test -FormatTypeName *

C:\PS> new-test Test1 | set-test -runtype full

Descrição
-----------
Esse exemplo mostra que você pode usar cmdlets importados da mesma maneira que usaria cmdlets locais. 

Esses comandos importam os cmdlets New-Test e Get-Test de uma PSSession no computador Server01 e o cmdlet Set-Test de uma PSSession no computador Server02. 

Embora os cmdlets sejam importados de PSSessions diferentes, você pode canalizar um objeto de um cmdlet para outro sem erro.

C:\PS>$s = new-pssession -computername Server01

C:\PS> import-pssession -session $s -commandname *-test* -formattypename *

C:\PS> $batch = new-test -name Batch -asjob

C:\PS> receive-job $batch

Descrição
-----------
Esse exemplo mostra como executar um comando importado como trabalho em segundo plano. 

Como os comandos importados podem levar mais tempo para serem executados que comandos locais, Import-PSSession acrescenta um parâmetro AsJob a cada comando importado. O parâmetro AsJob permite que você execute o comando como um trabalho em segundo plano.

O primeiro comando cria uma PSSession no computador Server01 e salva o objeto PSSession na variável $s.

O segundo comando usa Import-PSSession para importar os cmdlets Test da PSSession em $s para a sessão atual.

O terceiro comando usa o parâmetro AsJob do cmdlet New-Test importado para executar um comando New-Test como um trabalho em segundo plano. O comando salva o objeto de trabalho que New-Test retornou na variável $batch.

O quarto comando utiliza o cmdlet Receive-Job para obter os resultados do trabalho na variável $batch.

C:\PS>$s = new-pssession -comp Server01

C:\PS> invoke-command -session $s {import-module TestManagement}

C:\PS> import-pssession -session $s -module TestManagement

Descrição
-----------
Esse exemplo mostra como importar os cmdlets e as funções de um módulo do Windows PowerShell em um computador remoto na sessão atual.

O primeiro comando cria uma PSSession no computador Server01 e salva-a na variável $s. 

O segundo comando usa o cmdlet Invoke-Command para executar um comando Import-Module na PSSession em $s.

Normalmente, o módulo seria acrescentado a todas as sessões por um comando Import-Module em um perfil do Windows PowerShell, mas perfis não são executados em PSSessions.

O terceiro comando usa o parâmetro Module de Import-PSSession para importar os cmdlets e as funções no módulo para a sessão atual.

C:\PS>import-pssession $s -CommandName Get-Date, SearchHelp  -formatTypeName * -AllowClobber


Name              : tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1zunz.ttf
Path              : C:\Users\User01\AppData\Local\Temp\tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1zunz.ttf\tmp_79468106-4e1d-4d90-af97-1154f9317239_
                    tcw1zunz.ttf.psm1
Description       : Implicit remoting for http://server01.corp.fabrikam.com/wsman
Guid              : 79468106-4e1d-4d90-af97-1154f9317239
Version           : 1.0
ModuleBase        : C:\Users\User01\AppData\Local\Temp\tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1zunz.ttf
ModuleType        : Script
PrivateData       : {ImplicitRemoting}
AccessMode        : ReadWrite
ExportedAliases   : {}
ExportedCmdlets   : {}
ExportedFunctions : {[Get-Date, Get-Date], [SearchHelp, SearchHelp]}
ExportedVariables : {}
NestedModules     : {}

Descrição
-----------
Esse exemplo mostra que Import-PSSession cria um módulo em um arquivo temporário em disco. Ele também mostra que todos os comandos são convertidos em funções antes de serem importados na sessão atual.

O comando usa o cmdlet Import-PSSession para importar um cmdlet Get-Date e uma função SearchHelp na sessão atual. 

O cmdlet Import-PSSession retorna um objeto PSModuleInfo que representa o módulo temporário. O valor da propriedade Path mostra que Import-PSSession criou um arquivo de módulo de script (.psm1) em um local temporário. A propriedade ExportedFunctions mostra que o cmdlet Get-Date e a função SearchHelp foram importados como funções.

C:\PS>import-pssession $s -CommandName Get-Date -formatTypeName * -AllowClobber

C:\PS> get-command get-date

CommandType   Name       Definition
-----------   ----       ----------
Function      Get-Date   ...
Cmdlet        Get-Date   Get-Date [[-Date] <DateTime>] [-Year <Int32>] [-Month <Int32>]

C:\PS> Get-Date
09074   

C:\PS> (get-command -type cmdlet -name get-date).pssnapin.name
Microsoft.PowerShell.Utility

C:\PS> Microsoft.PowerShell.Utility\get-date

Sunday, March 15, 2009 2:08:26 PM

Descrição
-----------
Esse exemplo mostra como executar um comando ocultado por um comando importado.

O primeiro comando importa um cmdlet Get-Date da PSSession na variável $s. Como a sessão atual inclui um cmdlet Get-Date, o parâmetro AllowClobber é obrigatório no comando.

O segundo comando usa o cmdlet Get-Command para obter os comandos Get-Date na sessão atual. A saída mostra que a sessão inclui o cmdlet Get-Date original e uma função Get-Date. A função Get-Date executa o cmdlet Get-Date importado na PSSession em $s.

O terceiro comando executa um comando Get-Date. Como as funções têm precedência sobre os cmdlets, o Windows PowerShell executa a função Get-Date importada, que retorna uma data no calendário juliano.

O quarto e o quinto comandos mostram como usar um nome qualificado para executar um comando ocultado por um comando importado. 

O quarto comando obtém o nome do snap-in do Windows PowerShell que acrescentou o cmdlet Get-Date original à sessão atual.

O quinto comando usa o nome qualificado de snap-in do cmdlet Get-Date para executar um comando Get-Date.

Para obter mais informações sobre a precedência de comandos e comandos ocultos, consulte about_Command_Precedence.

C:\PS>import-pssession -session $s -commandName *Item* -AllowClobber

Descrição
-----------
Esse comando importa comandos cujos nomes incluam "Item" da PSSession em $s. Como o comando inclui o parâmetro CommandName mas não o parâmetro FormatTypeData, somente o comando é importado.

Use esse comando quando estiver usando Import-PSSession para executar um comando em um computador remoto e já tiver os dados de formatação para o comando na sessão atual.

C:\PS>$m = import-pssession -session $s -CommandName *bits* -formattypename *bits*

C:\PS> get-command -module $m

CommandType     Name
-----------     ----
Function        Add-BitsFile
Function        Complete-BitsTransfer
Function        Get-BitsTransfer
Function        Remove-BitsTransfer
Function        Resume-BitsTransfer
Function        Set-BitsTransfer
Function        Start-BitsTransfer
Function        Suspend-BitsTransfer

Descrição
-----------
Esse comando mostra como usar o parâmetro Module de Get-Command para descobrir quais comandos foram importados na sessão por um comando Import-PSSession.

O primeiro comando usa o cmdlet Import-PSSession para importar comandos cujos nomes incluam "bits" da PSSession na variável $s. O comando Import-PSSession retorna um módulo temporário e salva o módulo na variável $m.

O segundo comando usa o cmdlet Get-Command para obter os comandos que foram exportados pelo módulo na variável $m. 

O parâmetro Module utiliza um valor de cadeia de caracteres, que foi criado para o nome do módulo. Porém, quando você envia um objeto de módulo, o Windows PowerShell usa o método ToString no objeto de módulo, o qual retorna o nome do módulo. 

O comando Get-Command é o equivalente de "get-command $m.name".