Condividi tramite

Get-Module

  • Riferimento
Modulo:
Microsoft.PowerShell.Core

Ottiene i moduli che sono stati importati o che possono essere importati nella sessione corrente.

Sintassi

Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-All]
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-ListAvailable]
   [-Refresh]
   -CimSession <CimSession>
   [-CimResourceUri <Uri>]
   [-CimNamespace <String>]
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-ListAvailable]
   [-Refresh]
   -PSSession <PSSession>
   [<CommonParameters>]
Get-Module
   [[-Name] <String[]>]
   [-FullyQualifiedName <ModuleSpecification[]>]
   [-All]
   [-ListAvailable]
   [-Refresh]
   [<CommonParameters>]

Descrizione

Il Get-Module cmdlet ottiene i moduli di PowerShell importati o che possono essere importati in una sessione di PowerShell. L'oggetto modulo che Get-Module restituisce contiene informazioni preziose sul modulo. È anche possibile inviare tramite pipe gli oggetti modulo ad altri cmdlet, ad esempio i Import-Module cmdlet e Remove-Module .

Senza parametri, Get-Module ottiene i moduli importati nella sessione corrente. Per ottenere tutti i moduli installati, specificare il parametro ListAvailable .

Get-Module ottiene moduli, ma non li importa. A partire da Windows PowerShell 3.0, i moduli vengono importati automaticamente quando si usa un comando nel modulo, ma un Get-Module comando non attiva un'importazione automatica. È anche possibile importare i moduli nella sessione usando il Import-Module cmdlet .

A partire da Windows PowerShell 3.0, è possibile ottenere e quindi importare moduli da sessioni remote nella sessione locale. Questa strategia usa la funzionalità di comunicazione remota implicita di PowerShell ed è equivalente all'uso del Import-PSSession cmdlet. Quando si usano comandi nei moduli importati da un'altra sessione, i comandi vengono eseguiti in modo implicito nella sessione remota. Questa funzionalità consente di gestire il computer remoto dalla sessione locale.

Inoltre, a partire da Windows PowerShell 3.0, è possibile usare Get-Module e importare i Import-Module moduli CIM (Common Information Model), in cui i cmdlet sono definiti nei file CDXML (Cmdlet Definition XML). Questa funzionalità consente di usare i cmdlet implementati negli assembly di codice non gestiti, ad esempio quelli scritti in C++.

Con queste nuove funzionalità, i Get-Module cmdlet e Import-Module diventano strumenti primari per la gestione di aziende eterogenee che includono computer che eseguono il sistema operativo Windows e i computer che eseguono altri sistemi operativi.

Per gestire i computer remoti che eseguono il sistema operativo Windows con PowerShell e PowerShell remoting abilitato, creare una sessione PSSession nel computer remoto e quindi usare il parametro PSSession di Get-Module per ottenere i moduli di PowerShell in PSSession. Quando si importano i moduli e quindi si usano i comandi importati nella sessione corrente, i comandi vengono eseguiti in modo implicito nel computer remoto. È possibile usare questa strategia per gestire il computer remoto.

È possibile usare una strategia simile per gestire i computer che non dispongono della comunicazione remota di PowerShell abilitata. Questi includono computer che non eseguono il sistema operativo Windows e computer con PowerShell, ma non sono abilitati per la comunicazione remota di PowerShell.

Iniziare creando una sessione CIM nel computer remoto. Una sessione CIM è una connessione a Strumentazione gestione Windows (WMI) nel computer remoto. Usare quindi il parametro CIMSession di Get-Module per ottenere moduli CIM dalla sessione CIM. Quando si importa un modulo CIM usando il Import-Module cmdlet e quindi si eseguono i comandi importati, i comandi vengono eseguiti in modo implicito nel computer remoto. È possibile usare questa strategia WMI e CIM per gestire il computer remoto.

Esempio

Esempio 1: Ottenere moduli importati nella sessione corrente

Get-Module

Questo comando ottiene i moduli che sono stati importati nella sessione corrente.

Esempio 2: Ottenere moduli installati e moduli disponibili

Get-Module -ListAvailable

Questo comando ottiene i moduli installati nel computer che possono essere importati nella sessione corrente.

Get-Module cerca i moduli disponibili nel percorso specificato dalla variabile di ambiente $env:PSModulePath . Per altre informazioni su PSModulePath, vedere about_Modules e about_Environment_Variables.

Esempio 3: Ottenere tutti i file esportati

Get-Module -ListAvailable -All

Questo comando ottiene tutti i file esportati per tutti i moduli disponibili.

Esempio 4: Ottenere un modulo con il nome completo

$FullyQualifedName = @{ModuleName="Microsoft.PowerShell.Management";ModuleVersion="3.1.0.0"}
Get-Module -FullyQualifiedName $FullyQualifedName | Format-Table -Property Name,Version

Name                             Version
----                             -------
Microsoft.PowerShell.Management  3.1.0.0

Questo comando ottiene il modulo Microsoft.PowerShell.Management specificando il nome completo del modulo usando il parametro FullyQualifiedName . Il comando invia quindi i risultati nel Format-Table cmdlet per formattare i risultati come tabella con Nome e Versione come intestazioni di colonna.

Esempio 5: Ottenere proprietà di un modulo

Get-Module | Get-Member -MemberType Property | Format-Table Name

Name
----
AccessMode
Author
ClrVersion
CompanyName
Copyright
Definition
Description
DotNetFrameworkVersion
ExportedAliases
ExportedCmdlets
ExportedCommands
ExportedFormatFiles
ExportedFunctions
ExportedTypeFiles
ExportedVariables
ExportedWorkflows
FileList
Guid
HelpInfoUri
LogPipelineExecutionDetails
ModuleBase
ModuleList
ModuleType
Name
NestedModules
OnRemove
Path
PowerShellHostName
PowerShellHostVersion
PowerShellVersion
PrivateData
ProcessorArchitecture
RequiredAssemblies
RequiredModules
RootModule
Scripts
SessionState
Version

Questo comando ottiene le proprietà dell'oggetto PSModuleInfo che Get-Module restituisce. Esiste un oggetto per ogni file di modulo.

È possibile usare le proprietà per formattare e filtrare gli oggetti del modulo. Per altre informazioni sulle proprietà, vedere PROPRIETÀ PSModuleInfo.

L'output include le nuove proprietà, ad esempio Author e CompanyName, introdotte in Windows PowerShell 3.0.

Esempio 6: Raggruppare tutti i moduli in base al nome

Get-Module -ListAvailable -All | Format-Table -Property Name, Moduletype, Path -Groupby Name

Name: AppLocker

Name      ModuleType Path
----      ---------- ----
AppLocker   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\AppLocker\AppLocker.psd1


   Name: Appx

Name ModuleType Path
---- ---------- ----
Appx   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\en-US\Appx.psd1
Appx   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\Appx.psd1
Appx     Script C:\Windows\system32\WindowsPowerShell\v1.0\Modules\Appx\Appx.psm1


   Name: BestPractices

Name          ModuleType Path
----          ---------- ----
BestPractices   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\BestPractices\BestPractices.psd1


   Name: BitsTransfer

Name         ModuleType Path
----         ---------- ----
BitsTransfer   Manifest C:\Windows\system32\WindowsPowerShell\v1.0\Modules\BitsTransfer\BitsTransfer.psd1

Questo comando ottiene tutti i file di modulo, sia importati che disponibili, quindi raggrupparli in base al nome del modulo. In questo modo è possibile visualizzare i file di modulo esportati da ogni script.

Esempio 7: Visualizzare il contenuto di un manifesto del modulo

Questi comandi visualizzano il contenuto del manifesto del modulo per il modulo Windows PowerShell Modulo BitsTransfer.

I moduli non sono necessari per avere file manifesto. Quando hanno un file manifesto, il file manifesto è necessario solo per includere un numero di versione. Tuttavia, i file manifesto forniscono spesso informazioni utili su un modulo, i requisiti e il relativo contenuto.

# First command
$m = Get-Module -list -Name BitsTransfer

# Second command
Get-Content $m.Path

@ {
    GUID               = "{8FA5064B-8479-4c5c-86EA-0D311FE48875}"
    Author             = "Microsoft Corporation"
    CompanyName        = "Microsoft Corporation"
    Copyright          = "Microsoft Corporation. All rights reserved."
    ModuleVersion      = "1.0.0.0"
    Description        = "Windows PowerShell File Transfer Module"
    PowerShellVersion  = "2.0"
    CLRVersion         = "2.0"
    NestedModules      = "Microsoft.BackgroundIntelligentTransfer.Management"
    FormatsToProcess   = "FileTransfer.Format.ps1xml"
    RequiredAssemblies = Join-Path $psScriptRoot "Microsoft.BackgroundIntelligentTransfer.Management.Interop.dll"
}

Il primo comando ottiene l'oggetto PSModuleInfo che rappresenta il modulo BitsTransfer. Salva l'oggetto nella $m variabile.

Il secondo comando usa il Get-Content cmdlet per ottenere il contenuto del file manifesto nel percorso specificato. Usa la notazione del punto per ottenere il percorso del file manifesto, archiviato nella proprietà Path dell'oggetto. L'output mostra il contenuto del manifesto del modulo.

Esempio 8: Elencare i file nella directory del modulo

dir (Get-Module -ListAvailable FileTransfer).ModuleBase

Directory: C:\Windows\system32\WindowsPowerShell\v1.0\Modules\FileTransfer
Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        12/16/2008  12:36 PM            en-US
-a---        11/19/2008  11:30 PM      16184 FileTransfer.Format.ps1xml
-a---        11/20/2008  11:30 PM       1044 FileTransfer.psd1
-a---        12/16/2008  12:20 AM     108544 Microsoft.BackgroundIntelligentTransfer.Management.Interop.dll

Questo comando elenca i file nella directory del modulo. Si tratta di un altro modo per determinare il contenuto di un modulo prima di importarlo. Alcuni moduli potrebbero contenere file della Guida o file Leggimi che descrivono il modulo.

Esempio 9: Ottenere moduli installati in un computer

$s = New-PSSession -ComputerName Server01

Get-Module -PSSession $s -ListAvailable

Questi comandi ottengono i moduli installati nel computer Server01.

Il primo comando usa il New-PSSession cmdlet per creare una sessione PSSession nel computer Server01. Il comando salva la sessione PSSession nella variabile $s.

Il secondo comando usa i parametri PSSession e ListAvailable di Get-Module per ottenere i moduli nella variabile PSSession nella variabile $s.

Se si esegue la pipe dei moduli da altre sessioni al Import-Module cmdlet, Import-Module importa il modulo nella sessione corrente usando la funzionalità di comunicazione remota implicita. Equivale all'uso del Import-PSSession cmdlet. È possibile usare i cmdlet del modulo nella sessione corrente, tuttavia i comandi che usano questi cmdlet vengono eseguiti effettivamente nella sessione remota. Per altre informazioni, vedere Import-Module e Import-PSSession.

Esempio 10: Gestire un computer che non esegue il sistema operativo Windows

I comandi in questo esempio consentono di gestire i sistemi di archiviazione di un computer remoto che non esegue il sistema operativo Windows. In questo esempio, poiché l'amministratore del computer ha installato il provider WMI di individuazione del modulo, i comandi CIM possono usare i valori predefiniti progettati per il provider.

$cs = New-CimSession -ComputerName RSDGF03
Get-Module -CimSession $cs -Name Storage | Import-Module
Get-Command Get-Disk

CommandType     Name                  ModuleName
-----------     ----                  ----------
Function        Get-Disk              Storage

Get-Disk

Number Friendly Name              OperationalStatus          Total Size Partition Style
------ -------------              -----------------          ---------- ---------------
0      Virtual HD ATA Device      Online                          40 GB MBR

Il primo comando usa il New-CimSession cmdlet per creare una sessione nel RSDGF03 computer remoto. La sessione si connette a WMI nel computer remoto. Il comando salva la sessione CIM nella $cs variabile.

Il secondo comando usa la sessione CIM nella $cs variabile per eseguire un Get-Module comando nel computer RSDGF03. Il comando usa il parametro Name per specificare il modulo di archiviazione. Il comando usa un operatore pipeline (|) per inviare il modulo di archiviazione al Import-Module cmdlet, che lo importa nella sessione locale.

Il terzo comando esegue il Get-Command cmdlet nel Get-Disk comando nel modulo Di archiviazione. Quando si importa un modulo CIM nella sessione locale, PowerShell converte i file CDXML che rappresentano il modulo CIM negli script di PowerShell, che vengono visualizzati come funzioni nella sessione locale.

Il quarto comando esegue il Get-Disk comando. Sebbene il comando venga digitato nella sessione locale, viene eseguito in modo implicito nel computer remoto da cui è stato importato. Il comando ottiene gli oggetti dal computer remoto e li restituisce alla sessione locale.

Parametri

-All

Indica che questo cmdlet ottiene tutti i moduli in ogni cartella del modulo, inclusi i moduli annidati, i file manifesto (psd1), i file del modulo script (con estensione psm1) e i file binari (.dll). Senza questo parametro, Get-Module ottiene solo il modulo predefinito in ogni cartella del modulo.

Type:SwitchParameter
Position:Named
Default value:False
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-CimNamespace

Specifica lo spazio dei nomi di un provider CIM alternativo che espone i moduli CIM. Il valore predefinito è lo spazio dei nomi del provider WMI di individuazione del modulo.

Usare questo parametro per ottenere moduli CIM dai computer e dai dispositivi che non eseguono il sistema operativo Windows.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Type:String
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-CimResourceUri

Specifica un percorso alternativo per i moduli CIM. Il valore predefinito è l'URI della risorsa del provider WMI di individuazione moduli nel computer remoto.

Usare questo parametro per ottenere moduli CIM dai computer e dai dispositivi che non eseguono il sistema operativo Windows.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Type:Uri
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-CimSession

Specifica una sessione CIM nel computer remoto. Immettere una variabile contenente la sessione CIM o un comando che ottiene la sessione CIM, ad esempio un comando Get-CimSession .

Get-Module usa la connessione sessione CIM per ottenere moduli dal computer remoto. Quando si importa il modulo usando il Import-Module cmdlet e si usano i comandi del modulo importato nella sessione corrente, i comandi vengono effettivamente eseguiti nel computer remoto.

È possibile usare questo parametro per ottenere moduli da computer e dispositivi che non eseguono il sistema operativo Windows e i computer che dispongono di PowerShell, ma non dispongono della comunicazione remota di PowerShell abilitata.

Il parametro CimSession ottiene tutti i moduli della sessione CIMSession. Tuttavia, è possibile importare solo moduli basati su CIM e su CDXML.

Type:CimSession
Position:Named
Default value:None
Required:True
Accept pipeline input:False
Accept wildcard characters:False

-FullyQualifiedName

Specifica i nomi dei moduli sotto forma di oggetti ModuleSpecification . Questi oggetti sono descritti nella sezione Osservazioni del costruttore ModuleSpecification (Hashtable) nella libreria MSDN. Ad esempio, il parametro FullyQualifiedName accetta un nome del modulo specificato nei formati seguenti:

  • @{ModuleName = "modulename"; ModuleVersion = "version_number"}
  • @{ModuleName = "modulename"; ModuleVersion = "version_number"; Guid = "GUID"}

ModuleName e ModuleVersion sono obbligatori, mentre Guid è facoltativo.

Non è possibile specificare il parametro FullyQualifiedName nello stesso comando di un parametro Name .

Type:ModuleSpecification[]
Position:Named
Default value:None
Required:False
Accept pipeline input:True
Accept wildcard characters:False

-ListAvailable

Indica che questo cmdlet ottiene tutti i moduli installati. Get-Module ottiene i moduli nei percorsi elencati nella variabile di ambiente PSModulePath . Senza questo parametro, Get-Module ottiene solo i moduli elencati nella variabile di ambiente PSModulePath e caricati nella sessione corrente. ListAvailable non restituisce informazioni sui moduli non trovati nella variabile di ambiente PSModulePath, anche se questi moduli sono caricati nella sessione corrente.

Type:SwitchParameter
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-Name

Specifica i nomi o i modelli di nomi dei moduli che ottiene questo cmdlet. I caratteri jolly sono consentiti. È anche possibile inviare i nomi a Get-Module. Non è possibile specificare il parametro FullyQualifiedName nello stesso comando di un parametro Name .

Il nome non può accettare un GUID del modulo come valore. Per restituire i moduli specificando un GUID, usare invece FullyQualifiedName .

Type:String[]
Position:0
Default value:None
Required:False
Accept pipeline input:True
Accept wildcard characters:True

-PSSession

Ottiene i moduli nella sessione powerShell gestita dall'utente specificata (PSSession). Immettere una variabile contenente la sessione, un comando che ottiene la sessione, ad esempio un comando o un comando che crea la sessione, ad esempio Get-PSSession un New-PSSession comando.

Quando la sessione è connessa a un computer remoto, è necessario specificare il parametro ListAvailable .

Un Get-Module comando che usa il parametro PSSession equivale all'uso del Invoke-Command cmdlet per eseguire un Get-Module -ListAvailable comando in una sessione PSSession.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Type:PSSession
Position:Named
Default value:None
Required:True
Accept pipeline input:False
Accept wildcard characters:False

-Refresh

Indica che questo cmdlet aggiorna la cache dei comandi installati. La cache dei comandi viene creata all'avvio della sessione. Consente al Get-Command cmdlet di ottenere comandi dai moduli che non vengono importati nella sessione.

Questo parametro è progettato per scenari di sviluppo e testing in cui il contenuto dei moduli è stato modificato dopo l'avvio della sessione.

Quando si specifica il parametro Aggiorna in un comando, è necessario specificare ListAvailable.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Type:SwitchParameter
Position:Named
Default value:False
Required:False
Accept pipeline input:False
Accept wildcard characters:False

Input

String

È possibile inviare i nomi dei moduli tramite pipe a questo cmdlet.

Output

PSModuleInfo

Questo cmdlet restituisce oggetti che rappresentano moduli. Quando si specifica il parametro ListAvailable , Get-Module restituisce un oggetto ModuleInfoGrouping , ovvero un tipo di oggetto PSModuleInfo con le stesse proprietà e metodi.

Note

  • A partire da Windows PowerShell 3.0, i comandi di base inclusi in PowerShell vengono inseriti nei moduli. L'eccezione è Microsoft.PowerShell.Core, che è uno snap-in (PSSnapin). Per impostazione predefinita, solo lo snap-in Microsoft.PowerShell.Core viene aggiunto alla sessione. I moduli vengono importati automaticamente al primo uso e è possibile usare il Import-Module cmdlet per importarli.

  • A partire da Windows PowerShell 3.0, i comandi di base installati con PowerShell vengono inseriti in pacchetti nei moduli. In Windows PowerShell 2.0 e nei programmi host che creano sessioni in stile meno recente in versioni successive di PowerShell, i comandi di base vengono inseriti in pacchetti in snap-in (PSSnapins). L'eccezione è Microsoft.PowerShell.Core, che è sempre uno snap-in. Inoltre, le sessioni remote, ad esempio quelle avviate dal New-PSSession cmdlet, sono sessioni in stile meno recente che includono snap-in core.

    Per informazioni sul metodo CreateDefault2 che crea sessioni di stile più recenti con moduli di base, vedere Metodo CreateDefault2 nella libreria MSDN.

  • Get-Module ottiene solo i moduli nelle posizioni archiviate nel valore della variabile di ambiente PSModulePath ($env:PSModulePath). È possibile usare il parametro Path del Import-Module cmdlet per importare moduli in altre posizioni, ma non è possibile usare il Get-Module cmdlet per ottenerli.

  • Inoltre, a partire da PowerShell 3.0, sono state aggiunte nuove proprietà all'oggetto che restituisce che Get-Module semplificano le informazioni sui moduli anche prima dell'importazione. Tutte le proprietà vengono popolate prima dell'importazione. Includono le proprietà ExportCommands, ExportCmdlets e ExportFunctions che elencano i comandi che il modulo esporta.

  • Il parametro ListAvailable ottiene solo moduli ben formati, ovvero cartelle che contengono almeno un file il cui nome di base è lo stesso del nome della cartella del modulo. Il nome di base è il nome senza l'estensione del nome file. Le cartelle che contengono file con nomi diversi vengono considerati contenitori, ma non moduli.

    Per ottenere i moduli implementati come file di .dll, ma non sono racchiusi in una cartella del modulo, specificare sia i parametri ListAvailable che Tutti .

  • Per usare la funzionalità di sessione CIM, nel computer remoto deve essere abilitata la comunicazione remotadi WS-Management e deve essere installato Strumentazione gestione Windows (WMI), che è l'implementazione Microsoft dello standard Common Information Model (CIM). Il computer deve inoltre disporre del provider WMI di individuazione del modulo o di un provider WMI alternativo con le stesse funzionalità di base.

    È possibile usare la funzionalità sessione CIM nei computer che non eseguono il sistema operativo Windows e nei computer Windows che dispongono di PowerShell, ma non dispongono della comunicazione remota di PowerShell abilitata.

    È anche possibile usare i parametri CIM per ottenere moduli CIM dai computer con abilitata la comunicazione remota di PowerShell. Include il computer locale. Quando si crea una sessione CIM nel computer locale, PowerShell usa DCOM, anziché WMI, per creare la sessione.