Importa comandi da un'altra sessione nella sessione corrente.
Sintassi
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>]
Descrizione
Il cmdlet Import-PSSession importa comandi (cmdlet, funzioni e alias) da una sessione PSSession in un computer locale o remoto nella sessione corrente. È possibile importare qualsiasi comando trovato da Get-Command nella sessione PSSession.
Utilizzare un comando Import-PSSession per importare comandi da una shell personalizzata, ad esempio una shell di Microsoft Exchange Server, o da una sessione che include moduli e snap-in di Windows PowerShell o altri elementi che non presenti nella sessione corrente.
Per importare comandi, utilizzare per prima cosa il cmdlet New-PSSession per creare una sessione PSSession. Utilizzare quindi il cmdlet Import-PSSession per importare i comandi. Per impostazione predefinita, Import-PSSession importa tutti i comandi, ad eccezione di quelli con gli stessi nomi dei comandi nella sessione corrente. Per importare tutti i comandi, utilizzare il parametro AllowClobber.
È possibile utilizzare i comandi importati come qualsiasi comando della sessione. Quando si utilizza un comando importato, la parte importata del comando viene eseguita in modo implicito nella sessione da cui è stata importata. Tuttavia, le operazioni remote sono gestite totalmente da Windows PowerShell. Non è necessario conoscerle, ad eccezione del fatto che è necessario mantenere aperta la connessione all'altra sessione (PSSession). Se la si chiude, non sono più disponibili i comandi importati.
Poiché l'esecuzione dei comandi importati può richiedere più tempo rispetto a quella dei comandi locali, Import-PSSession aggiunge un parametro AsJob a ogni comando importato. Questo parametro consente di eseguire il comando come processo in background di Windows PowerShell. Per ulteriori informazioni, vedere about_Jobs.
Quando si utilizza Import-PSSession, Windows PowerShell aggiunge i comandi importati a un modulo temporaneo che esiste solo nella sessione dell'utente e restituisce un oggetto che rappresenta il modulo. Per creare un modulo permanente che può essere utilizzato nelle sessioni future, utilizzare il cmdlet Export-PSSession.
Il cmdlet Import-PSSession utilizza la funzionalità di comunicazione remota implicita di Windows PowerShell. Quando si importano comandi nella sessione corrente, essi vengono eseguiti in modo implicito nella sessione originale o in una sessione simile nel computer di origine.
Parametri
-AllowClobber
Importa i comandi specificati anche se hanno gli stessi nomi dei comandi della sessione corrente.
Se si importa un comando con lo stesso nome di un comando nella sessione corrente, il comando importato nasconde o sostituisce i comandi originali. Per ulteriori informazioni, vedere about_Command_Precedence.
Per impostazione predefinita, Import-PSSession non importa comandi con lo stesso nome dei comandi della sessione corrente.
|
Obbligatorio? |
false |
|
Posizione? |
named |
|
Valore predefinito |
False |
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
false |
-ArgumentList <Object[]>
Importa la variante del comando risultante dall'utilizzo degli argomenti specificati (valori di parametro).
Ad esempio, per importare la variante del comando Get-Item nell'unità del certificato (Cert:) in PSSession in $s, digitare "import-pssession -session $s -command Get-Item -argumentlist cert:".
|
Obbligatorio? |
false |
|
Posizione? |
named |
|
Valore predefinito |
All command in the PSSession, except for commands with the same names as commands in the current session. |
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
false |
-CommandName <string[]>
Importa solo i comandi con i modelli di nome o i nomi specificati. È consentito l'utilizzo di caratteri jolly. Utilizzare "CommandName" o il relativo alias, "Name".
Per impostazione predefinita, Import-PSSession importa tutti i comandi dalla sessione, ad eccezione di quelli con gli stessi nomi dei comandi nella sessione corrente. In questo modo si evita che i comandi importati nascondano o sostituiscano comandi nella sessione. Per importare tutti i comandi, anche quelli che ne nascondono o sostituiscono altri, utilizzare il parametro AllowClobber.
Se si utilizza il parametro CommandName, i file di formattazione per i comandi non vengono importati a meno che non si utilizzi il parametro FormatTypeName. Analogamente, se si utilizza il parametro FormatTypeName, non viene importato alcun comando a meno che non si utilizzi il parametro CommandName.
|
Obbligatorio? |
false |
|
Posizione? |
3 |
|
Valore predefinito |
All commands in the PSSession, except for commands with the same names as commands in the current session. |
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
true |
-CommandType <CommandTypes>
Per ogni oggetto del comando importa solo i tipi specificati. Il valore predefinito è Cmdlet. Utilizzare "CommandType" o il relativo alias, "Type".
I valori validi sono:
-- Alias: alias Windows PowerShell della sessione remota.
-- All: cmdlet e funzioni della sessione remota.
-- Application: tutti i file non di Windows PowerShell nei percorsi elencati nella variabile di ambiente Path ($env:path) nella sessione remota, inclusi i file con estensione txt, exe e dll.
-- Cmdlet: cmdlet della sessione remota. Il valore predefinito è "Cmdlet".
-- ExternalScript: file con estensione ps1 nei percorsi elencati nella variabile di ambiente Path ($env:path) nella sessione remota.
-- Filter e Function: funzioni di Windows PowerShell della sessione remota.
-- Script: blocchi di script della sessione remota.
|
Obbligatorio? |
false |
|
Posizione? |
named |
|
Valore predefinito |
All command in the PSSession, except for commands with the same names as commands in the current session. |
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
false |
-FormatTypeName <string[]>
Importa le istruzioni di formattazione per i tipi Microsoft .NET Framework specificati. Immettere i nomi dei tipi. È consentito l'utilizzo di caratteri jolly.
Il valore di questo parametro deve essere il nome di un tipo restituito da un comando Get-FormatData nella sessione da cui vengono importati i comandi. Per ottenere tutti i dati di formattazione della sessione remota, digitare *.
Se il comando non include i parametri CommandName o FormatTypeName, Import-PSSession
importa le istruzioni di formattazione per tutti i tipi .NET Framework restituiti da un comando Get-FormatData nella sessione remota.
Se si utilizza il parametro FormatTypeName, non viene importato alcun comando a meno che non si utilizzi il parametro CommandName.
Analogamente, se si utilizza il parametro CommandName, i file di formattazione per i comandi non vengono importati a meno che non si utilizzi il parametro FormatTypeName.
|
Obbligatorio? |
false |
|
Posizione? |
4 |
|
Valore predefinito |
Types in the System.Management.Automation namespace |
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
true |
-Module <string[]>
Importa solo i comandi negli snap-in e nei moduli di Windows PowerShell specificati. Immettere i nomi degli snap-in e dei moduli. Non è consentito l'utilizzo di caratteri jolly.
Per ulteriori informazioni, vedere about_Pssnapins e Import-Module.
|
Obbligatorio? |
false |
|
Posizione? |
named |
|
Valore predefinito |
All command in the PSSession, except for commands with the same names as commands in the current session. |
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
false |
-Prefix <string>
Aggiunge il prefisso specificato ai sostantivi nei nomi dei comandi importati.
Utilizzare questo parametro per evitare conflitti di nomi che possono verificarsi quando comandi diversi della sessione hanno lo stesso nome.
Ad esempio, se si specifica il prefisso "Remote" e si importa un cmdlet Get-Date, nella sessione il cmdlet viene indicato come Get-RemoteDate e non viene confuso con il cmdlet Get-Date originale.
|
Obbligatorio? |
false |
|
Posizione? |
named |
|
Valore predefinito |
|
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
false |
-Session <PSSession>
Specifica la sessione PSSession da cui vengono importati i cmdlet. Immettere una variabile che contiene un oggetto sessione o un comando che ottiene un oggetto sessione, ad esempio New-PSSession o Get-PSSession. È possibile specificare solo una sessione. Questo parametro è obbligatorio.
|
Obbligatorio? |
true |
|
Posizione? |
1 |
|
Valore predefinito |
nessuno |
|
Accettare input da pipeline? |
false |
|
Accettare caratteri jolly? |
false |
<CommonParameters>
Questo cmdlet supporta i parametri comuni -Verbose, -Debug, -ErrorAction, -ErrorVariable, -OutBuffer e -OutVariable. Per ulteriori informazioni, vedere about_Commonparameters.
Input e output
Il tipo di input è il tipo degli oggetti che è possibile reindirizzare al cmdlet. Il tipo restituito è il tipo degli oggetti restituiti dal cmdlet.
|
Input |
Nessuno Non è possibile reindirizzare oggetti a questo cmdlet. |
|
Output |
System.Management.Automation.PSModuleInfo Import-PSSession restituisce lo stesso oggetto modulo restituito da New-Module e Get-Module. Tuttavia, il modulo importato è temporaneo ed esiste solo nella sessione corrente. Per creare un modulo permanente su disco, utilizzare il cmdlet Export-PSSession. |
Note
Import-PSSession si basa sull'infrastruttura remota di Windows PowerShell. Per utilizzare questo cmdlet, è necessario configurare il computer per la comunicazione remota WS-Management. Per ulteriori informazioni, vedere about_Remote e about_Remote_Requirements.
Non è possibile utilizzare Import-PSSession per importare variabili o provider di Windows PowerShell.
Quando si importano comandi con gli stessi nomi dei comandi nella sessione corrente, i comandi importati possono nascondere alias, funzioni e cmdlet e sostituire funzioni e variabili nella sessione. Per ulteriori informazioni, vedere about_Command_Precedence.
Import-PSSession converte tutti i comandi in funzioni prima di importarli. Di conseguenza, i comandi importati hanno un comportamento leggermente diverso da quello che avrebbero se fosse stato mantenuto il tipo di comando originale. Ad esempio, se si importano un cmdlet da una sessione PSSession e un cmdlet con lo stesso nome da un modulo o uno snap-in, il cmdlet importato dalla sessione PSSession viene sempre eseguito per impostazione predefinita perché le funzioni hanno la precedenza sui cmdlet. Viceversa, se si importa un alias in una sessione che dispone di un alias con lo stesso nome, viene sempre utilizzato l'alias originale perché gli alias hanno la precedenza sulle funzioni. Per ulteriori informazioni, vedere about_Command_Precedence.
Import-PSSession utilizza il cmdlet Write-Progress per visualizzare l'avanzamento del comando. Durante l'esecuzione del comando, è possibile osservare l'indicatore di stato.
Per trovare i comandi da importare, Import-PSSession utilizza il cmdlet Invoke-Command per eseguire un comando Get-Command nella sessione PSSession. Per ottenere dati di formattazione per i comandi, utilizza il cmdlet Get-FormatData. Quando si esegue un comando Import-PSSession, è possibile che vengano visualizzati messaggi di errore da Invoke-Command, Get-Command e Get-FormatData. Inoltre, Import-PSSession non può importare comandi da una sessione PSSession che non include i cmdlet Get-Command, Get-FormatData, Select-Object e Get-Help.
I comandi importati sono soggetti alle stesse limitazioni degli altri comandi remoti, inclusa l'impossibilità di avviare un programma con interfaccia utente, ad esempio Blocco note.
Poiché i profili di Windows PowerShell non vengono eseguiti nelle sessioni PSSession, i comandi aggiunti da un profilo a una sessione non sono disponibili per Import-PSSession. Per importare comandi da un profilo, utilizzare un comando Invoke-Command per eseguire manualmente il profilo nella sessione PSSession prima di importare i comandi.
Il modulo temporaneo creato da Import-PSSession potrebbe includere un file di formattazione, anche se il comando non importa dati di formattazione. Se il comando non importa dati di formattazione, qualsiasi file di formattazione creato non conterrà dati di formattazione.
Per utilizzare Import-PSSession, il criterio di esecuzione nella sessione corrente non può essere Restricted o AllSigned, poiché il modulo creato da Import-PSSession contiene file di script non firmati non consentiti da tali criteri. Per utilizzare Import-PSSession senza modificare il criterio di esecuzione per il computer locale, utilizzare il parametro Scope di Set-ExecutionPolicy per impostare un criterio di esecuzione meno restrittivo per un singolo processo.
Esempio 1
C:\PS>$s = new-pssession -computername Server01 C:\PS> import-pssession -session $s Descrizione ----------- Con questo comando vengono importati nella sessione corrente tutti i comandi da una sessione PSSession del computer Server01, ad eccezione dei comandi con gli stessi nomi dei comandi nella sessione corrente. Poiché questo comando non utilizza il parametro CommandName, importa anche tutti i dati di formattazione obbligatori per i comandi importati.
Esempio 2
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 Descrizione ----------- Con questi comandi vengono importati i comandi il cui nome termina con "-test" da una sessione PSSession nella sessione locale, quindi viene illustrato come utilizzare un cmdlet importato. Il primo comando utilizza il cmdlet New-PSSession per creare una sessione PSSession. La sessione PSSession viene quindi salvata nella variabile $s. Il secondo comando utilizza il cmdlet Import-PSSession per importare comandi dalla sessione PSSession in $s nella sessione corrente. Utilizza il parametro CommandName per specificare comandi con il sostantivo Test e il parametro FormatTypeName per importare i dati di formattazione per i comandi Test. Il terzo e il quarto comando utilizzando i comandi importati nella sessione corrente. Poiché i comandi importati vengono realmente aggiunti alla sessione corrente, si utilizza la sintassi locale per la loro esecuzione. Non è necessario utilizzare il cmdlet Invoke-Command per eseguire un comando importato.
Esempio 3
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 Descrizione ----------- In questo esempio viene illustrato che è possibile utilizzare i cmdlet importati come quelli locali. Con questi comandi vengono importati i cmdlet New-Test e Get-Test da una sessione PSSession del computer Server01 e il cmdlet Set-Test da una sessione PSSession del computer Server02. Anche se i cmdlet sono stati importati da sessioni PSSession diverse, è possibile reindirizzare un oggetto da un cmdlet a un altro senza errori.
Esempio 4
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 Descrizione ----------- In questo esempio viene illustrato come eseguire un comando importato come processo in background. Poiché l'esecuzione dei comandi importati può richiedere più tempo rispetto a quella dei comandi locali, Import-PSSession aggiunge un parametro AsJob a ogni comando importato. Il parametro AsJob consente di eseguire il comando come processo in background. Con il primo comando viene creata una sessione PSSession nel computer Server01 e l'oggetto PSSession viene salvato nella variabile $s. Nel secondo comando viene utilizzato Import-PSSession per importare i cmdlet Test dalla sessione PSSession in $s nella sessione corrente. Nel terzo comando viene utilizzato il parametro AsJob del cmdlet New-Test importato per eseguire un comando New-Test come processo in background. Il comando salva l'oggetto processo restituito da New-Test nella variabile $batch. Nel quarto comando viene utilizzato il cmdlet Receive-Job per ottenere i risultati del processo nella variabile $batch.
Esempio 5
C:\PS>$s = new-pssession -comp Server01
C:\PS> invoke-command -session $s {import-module TestManagement}
C:\PS> import-pssession -session $s -module TestManagement
Descrizione
-----------
In questo esempio viene illustrato come importare i cmdlet e le funzioni da un modulo di Windows PowerShell in un computer remoto nella sessione corrente.
Con il primo comando una sessione PSSession viene creata nel computer Server01 e salvata nella variabile $s.
Nel secondo comando viene utilizzato il cmdlet Invoke-Command per eseguire un comando Import-Module nella sessione PSSession in $s.
In genere, il modulo verrebbe aggiunto a tutte le sessioni da un comando Import-Module in un profilo di Windows PowerShell, ma nelle sessioni PSSession non sono in esecuzione i profili.
Nel terzo comando viene utilizzato il parametro Module di Import-PSSession per importare i cmdlet e le funzioni del modulo nella sessione corrente.
Esempio 6
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 : {}
Descrizione
-----------
In questo esempio viene illustrato che Import-PSSession crea un modulo in un file temporaneo su disco. Viene inoltre illustrato che tutti i comandi vengono convertiti in funzioni prima di essere importati nella sessione corrente.
Il comando utilizza il cmdlet Import-PSSession per importare un cmdlet Get-Date e una funzione SearchHelp nella sessione corrente.
Il cmdlet Import-PSSession restituisce un oggetto PSModuleInfo che rappresenta il modulo temporaneo. Il valore della proprietà Path indica che Import-PSSession ha creato un file di modulo script (con estensione psm1) in un percorso temporaneo. La proprietà ExportedFunctions indica che il cmdlet Get-Date e la funzione SearchHelp sono stati entrambi importati come funzioni.
Esempio 7
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 Descrizione ----------- In questo esempio viene illustrato come eseguire un comando nascosto da un comando importato. Il primo comando importa un cmdlet Get-Date dalla sessione PSSession nella variabile $s. Poiché la sessione corrente include un cmdlet Get-Date, il parametro AllowClobber è obbligatorio nel comando. Il secondo comando utilizza il cmdlet Get-Command per ottenere i comandi Get-Date nella sessione corrente. Nell'output viene illustrato che la sessione include il cmdlet Get-Date originale e una funzione Get-Date. La funzione Get-Date esegue il cmdlet Get-Date importato nella sessione PSSession in $s. Il terzo comando esegue un comando Get-Date. Poiché le funzioni hanno la precedenza sui cmdlet, in Windows PowerShell viene eseguita la funzione Get-Date importata che restituisce una data giuliana. Il quarto e il quinto comando mostrano come utilizzare un nome completo per eseguire un comando nascosto da un comando importato. Il quarto comando ottiene il nome dello snap-in di Windows PowerShell che ha aggiunto il cmdlet Get-Date alla sessione corrente. Il quinto comando utilizza il nome completo dello snap-in del cmdlet Get-Date per eseguire un comando Get-Date. Per ulteriori informazioni sulla precedenza dei comandi e sui comandi nascosti, vedere about_Command_Precedence.
Esempio 8
C:\PS>import-pssession -session $s -commandName *Item* -AllowClobber Descrizione ----------- Questo comando importa comandi i cui nomi includono "Item" dalla sessione PSSession in $s. Poiché il comando include il parametro CommandName ma non il parametro FormatTypeData, viene importato solo il comando. Utilizzare questo comando quando si utilizza Import-PSSession per eseguire un comando in un computer remoto e si dispone già dei dati di formattazione per il comando nella sessione corrente.
Esempio 9
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 Descrizione ----------- Questo comando illustra come utilizzare il parametro Module di Get-Command per individuare i comandi importati nella sessione da un comando Import-PSSession. Il primo comando utilizza il cmdlet Import-PSSession per importare comandi il cui nome include "bits" dalla sessione PSSession nella variabile $s. Il comando Import-PSSession restituisce un modulo temporaneo e salva il modulo nella variabile $m. Il secondo comando utilizza il cmdlet Get-Command per ottenere i comandi esportati dal modulo nella variabile $m. Il parametro Module accetta un valore stringa, progettato per il nome del modulo. Quando si invia un oggetto modulo, tuttavia, su di esso in Windows PowerShell viene utilizzato il metodo ToString che restituisce il nome del modulo. Il comando Get-Command equivale a "get-command $m.name".
Vedere anche