Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Breve descrizione
Viene illustrato come installare, importare e usare i moduli di PowerShell.
Descrizione lunga
PowerShell è un linguaggio di scripting e una shell dei comandi. Il linguaggio è composto da parole chiave, che forniscono la struttura e la logica dell'elaborazione, e da comandi che eseguono il lavoro. I comandi in PowerShell vengono implementati come script, funzioni o cmdlet.
Un modulo è un'unità riutilizzabile autonoma che può contenere cmdlet, provider, funzioni, variabili e altri tipi di risorse che possono essere importati come una singola unità.
PowerShell viene fornito con un set di moduli di base. È inoltre possibile installare più moduli in base alle esigenze. Per impostazione predefinita, i moduli installati vengono caricati automaticamente la prima volta che si utilizza un comando da un modulo. Utilizzare la variabile per abilitare, disabilitare e configurare il $PSModuleAutoloadingPreference caricamento automatico dei moduli. Per altre informazioni, vedere about_Preference_Variables.
È possibile scaricare o ricaricare durante una sessione. Usare il Remove-Module cmdlet per scaricare un modulo dalla sessione. Utilizzare il Import-Module cmdlet per caricare un modulo.
I moduli possono essere creati come assembly .NET compilati scritti in C# o moduli basati su script scritti in PowerShell. Questo argomento illustra come usare i moduli di PowerShell. Per informazioni su come scrivere moduli di PowerShell, vedere Scrittura di un modulo di PowerShell.
Annotazioni
Prima di PowerShell 3.0, i cmdlet e i provider sono stati inseriti in pacchetti negli snap-in di PowerShell. A partire da PowerShell 3.0, lo snap-in Microsoft.PowerShell.Core viene aggiunto a ogni sessione per impostazione predefinita. Questo è l'unico snap-in rimanente in PowerShell. Tutti gli altri snap-in sono stati convertiti in moduli. La creazione di nuovi snap-in non è più supportata.
Installare un modulo pubblicato
Un modulo pubblicato è un modulo disponibile in un repository registrato, ad esempio PowerShell Gallery. I moduli PowerShellGet
Il modulo PowerShellGet Install-Module o Install-PSResource per installare moduli da PowerShell Gallery.
Get-Command Install-Module, Install-PSResource
CommandType Name Version Source
----------- ---- ------- ------
Function Install-Module 2.9.0 PowerShellGet
Cmdlet Install-PSResource 1.0.0 Microsoft.PowerShell.PSResourceGet
Per altre informazioni, vedere panoramica di PowerShellGet.
Installare manualmente un modulo
Se ricevi un modulo come cartella contenente file, devi installarlo sul tuo computer prima di poterlo utilizzare in PowerShell.
PowerShell viene fornito con diversi moduli preinstallati. Nei computer basati su Windows, molte funzionalità di Windows includono moduli per la gestione della funzionalità. Questi moduli vengono installati quando viene installata la funzione. Altri moduli possono essere forniti in un programma di installazione o di installazione che installa il modulo.
Per impostazione predefinita, la cartella Modules per l'utente corrente non esiste. Se è stato installato un modulo nell'ambito CurrentUser usando Install-Module o Install-PSResource, questi cmdlet creano la cartella Modules per l'utente corrente. Se la cartella non esiste, è possibile crearla manualmente.
Usare il comando seguente per creare una cartella Modules per l'utente corrente:
$folder = New-Item -Type Directory -Path $HOME\Documents\PowerShell\Modules
Copiare l'intera cartella del modulo nella nuova cartella creata. In PowerShell usare il cmdlet Copy-Item. Ad esempio, esegui il seguente comando per copiare la MyModule cartella da C:\PSTest alla cartella appena creata:
Copy-Item -Path C:\PSTest\MyModule -Destination $folder
È possibile installare un modulo in qualsiasi posizione, ma l'installazione dei moduli in un percorso predefinito del modulo semplifica la gestione. Per altre informazioni sui percorsi predefiniti dei moduli, vedere about_PSModulePath.
Caricamento automatico dei moduli
La prima volta che si esegue un comando da un modulo installato, PowerShell importa automaticamente (carica) tale modulo. Il modulo deve essere archiviato nei percorsi specificati nella variabile di ambiente $env:PSModulePath. I moduli in altre posizioni devono essere importati utilizzando il Import-Module cmdlet.
Il caricamento automatico dei moduli consente di usare i comandi in un modulo senza alcuna configurazione di installazione o profilo. Non è necessario gestire i moduli dopo averli installati sul computer.
Ognuno degli esempi seguenti causa l'importazione del modulo CimCmdlets , che contiene Get-CimInstance, nella sessione.
Eseguire il comando
Get-CimInstance Win32_OperatingSystemOttenere il comando
Get-Command Get-CimInstanceOttenere la Guida per il comando
Get-Help Get-CimInstance
È possibile usare il Get-Command cmdlet che elenca i comandi in tutti i moduli installati, anche se non sono ancora nella sessione. Quando si usa Get-Command con un carattere jolly (*), PowerShell non importa alcun modulo. È possibile utilizzare i caratteri jolly per l'individuazione dei comandi senza caricare moduli che potrebbero non essere necessari nella sessione.
Inoltre, i comandi che usano i provider di PowerShell non importano automaticamente un modulo. Ad esempio, se si usa un comando che richiede l'unità WSMan:, ad esempio il cmdlet Get-PSSessionConfiguration, potrebbe essere necessario eseguire il cmdlet Import-Module per importare il modulo Microsoft.WSMan.Management che include l'unità WSMan:.
Importare manualmente un modulo
L'importazione manuale di un modulo è necessaria quando un modulo non viene installato nei percorsi specificati dalla variabile di ambiente $env:PSModulePath oppure quando il modulo viene fornito come file autonomo .dll o .psm1 anziché come modulo in pacchetto.
È anche possibile modificare la modalità di importazione del modulo nella sessione. Ad esempio, il parametro Prefisso di Import-Module aggiunge un prefisso distintivo alla parte del sostantivo dei cmdlet importati dal modulo. Il parametro NoClobber impedisce al modulo di aggiungere comandi che nasconderebbero o sostituirebbero i comandi esistenti nella sessione. Per altre informazioni, vedere Gestire i conflitti di nomi.
È possibile importare un modulo installato nel proprio $env:PSModulePath specificando il nome del modulo. Ad esempio, il comando seguente importa il modulo BitsTransfer nella sessione corrente.
Import-Module BitsTransfer
Per importare un modulo che non si trova nel $env:PSModulePath, utilizzare il percorso completo della cartella del modulo. Ad esempio, per aggiungere il modulo
Import-Module C:\ps-test\TestCmdlets
Per importare un file di modulo non contenuto in una cartella del modulo, usare il percorso completo del file di modulo nel comando . Ad esempio, per aggiungere il modulo TestCmdlets.dll nella directory C:\ps-test alla sessione, digitare:
Import-Module C:\ps-test\TestCmdlets.dll
Per altre informazioni sull'aggiunta di moduli alla sessione, vedere Import-Module.
Importare un modulo all'inizio di ogni sessione
Il comando Import-Module importa i moduli nella sessione di PowerShell corrente. Per importare un modulo in ogni sessione di PowerShell avviata, aggiungere il comando Import-Module al profilo di PowerShell.
Per altre informazioni sui profili, vedere about_Profiles.
Trova i moduli installati
Il Get-Module cmdlet ottiene i moduli di PowerShell che sono stati importati nella sessione.
Get-Module
I moduli elencati possono includere moduli importati da qualsiasi posizione, non solo da $env:PSModulePath.
Usare il comando seguente per elencare i moduli installati nel $env:PSModulePath:
Get-Module -ListAvailable
Questo comando ottiene tutti i moduli installati in $env:PSModulePath, non solo i moduli importati nella sessione corrente. Questo comando non elenca i moduli installati in altri percorsi.
Per altre informazioni, vedere Get-Module.
Elencare i comandi in un modulo
Usare il cmdlet Get-Command per trovare tutti i comandi disponibili. È possibile usare i parametri del cmdlet Get-Command per filtrare i comandi, ad esempio per modulo, nome e sostantivo.
Per trovare tutti i comandi in un modulo, digitare:
Get-Command -Module <module-name>
Ad esempio, per trovare i comandi nel modulo BitsTransfer digitare:
Get-Command -Module BitsTransfer
Per altre informazioni sul cmdlet Get-Command, vedere Get-Command.
Rimuovere un modulo
Quando si rimuove un modulo, i comandi aggiunti dal modulo vengono eliminati dalla sessione. Ad esempio, il comando seguente rimuove il modulo BitsTransfer
Remove-Module BitsTransfer
La rimozione di un modulo inverte l'operazione di importazione di un modulo. La rimozione di un modulo non disinstalla il modulo. Per altre informazioni, vedere Remove-Module.
I comandi possono essere aggiunti alla sessione da moduli e snap-in. I moduli possono aggiungere tutti i tipi di comandi, inclusi cmdlet, provider, e funzioni, così come elementi, ad esempio variabili, alias e drive di PowerShell. Gli snap-in possono aggiungere solo cmdlet e provider.
Prima di rimuovere un modulo dalla sessione, usare i comandi seguenti per determinare il modulo da rimuovere.
Ad esempio, usare il comando seguente per trovare l'origine dei cmdlet Get-Date e Get-Help:
Get-Command Get-Date, Get-Help -All |
Select-Object -Property Name, CommandType, Module ,PSSnapIn
L'output seguente mostra che il cmdlet Get-Help si trova nello snap-in Microsoft.PowerShell.Core. Questo snap-in non può essere rimosso dalla sessione.
Name CommandType Module PSSnapIn
---- ----------- ------ --------
Get-Date Function
Get-Date Cmdlet Microsoft.PowerShell.Utility
Get-Help Cmdlet Microsoft.PowerShell.Core
Esistono due origini per Get-Date. Uno è una funzione e l'altro è un cmdlet nel modulo Microsoft.PowerShell.Utility. È possibile rimuovere il modulo usando Remove-Module. Per rimuovere la funzione, è possibile eliminarla dall'unità Function:.
Remove-Item Function:Get-Date
Per ulteriori informazioni sull'unità Function:, consultare la sezione su about_Function_Provider.
Gestire i conflitti di nomi
I conflitti di nome si verificano quando più comandi della sessione hanno lo stesso nome. L'importazione di un modulo causa un conflitto di nomi quando i comandi nel modulo hanno gli stessi nomi dei comandi o degli elementi nella sessione.
Import-Module potrebbero aggiungere comandi che nascondono e sostituiscono i comandi nella sessione corrente. I conflitti di nome possono avere come risultato l'occultamento o la sostituzione dei comandi. La sostituzione dei comandi si verifica quando il modulo importato contiene un comando con lo stesso nome di un comando esistente nella sessione. Il comando appena importato sostituisce ha la precedenza sul comando esistente.
Ad esempio, quando una sessione include una funzione e un cmdlet con lo stesso nome, PowerShell esegue la funzione per impostazione predefinita. Quando la sessione include comandi dello stesso tipo con lo stesso nome, ad esempio due cmdlet con lo stesso nome, per impostazione predefinita, esegue il comando aggiunto più di recente.
Per altre informazioni, inclusa una spiegazione delle regole di precedenza e delle istruzioni per l'esecuzione di comandi nascosti, vedere about_Command_Precedence.
È possibile eseguire un comando che è stato nascosto o sostituito qualificando il nome del comando. Per qualificare il nome del comando, aggiungere il nome del modulo che contiene la versione del comando desiderata. Per esempio:
Microsoft.PowerShell.Utility\Get-Date
L'esecuzione di Get-Date con il prefisso del nome del modulo assicura che venga eseguita la versione dal modulo Microsoft.PowerShell.Utility.
Per rilevare i conflitti di nomi, usare il parametro All del cmdlet Get-Command. Per impostazione predefinita, Get-Command ottiene solo i comandi eseguiti quando si digita il nome del comando. Il parametro All ottiene tutti i comandi con il nome specifico nella sessione.
Per evitare conflitti di nomi, usare i parametri NoClobber o prefisso del cmdlet Import-Module. Il prefisso parametro aggiunge un prefisso ai nomi dei comandi importati in modo che siano univoci nella sessione. Il parametro NoClobber
È anche possibile usare ilalias
Gli autori di moduli possono impedire conflitti di nomi usando la proprietà DefaultCommandPrefix