Compartilhar via

Import-Module

  • Referência
Módulo:
Microsoft.PowerShell.Core

Adiciona módulos à sessão atual.

Sintaxe

Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -PSSession <PSSession>
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Name] <String[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-MinimumVersion <Version>]
      [-MaximumVersion <String>]
      [-RequiredVersion <Version>]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -CimSession <CimSession>
      [-CimResourceUri <Uri>]
      [-CimNamespace <String>]
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-FullyQualifiedName] <ModuleSpecification[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-FullyQualifiedName] <ModuleSpecification[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      -PSSession <PSSession>
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Assembly] <Assembly[]>
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      [<CommonParameters>]
Import-Module
      [-Global]
      [-Prefix <String>]
      [-Function <String[]>]
      [-Cmdlet <String[]>]
      [-Variable <String[]>]
      [-Alias <String[]>]
      [-Force]
      [-PassThru]
      [-AsCustomObject]
      [-ModuleInfo] <PSModuleInfo[]>
      [-ArgumentList <Object[]>]
      [-DisableNameChecking]
      [-NoClobber]
      [-Scope <String>]
      [<CommonParameters>]

Description

O cmdlet Import-Module adiciona um ou mais módulos à sessão atual. Os módulos importados devem ser instalados no computador local ou em um computador remoto.

A partir do PowerShell 3.0, os módulos instalados são automaticamente importados para a sessão quando você usa comandos ou provedores no módulo. No entanto, você ainda pode usar o comando Import-Module para importar um módulo e habilitar e desabilitar a importação automática de módulo usando a variável de preferência $PSModuleAutoloadingPreference. Para obter mais informações sobre módulos, consulte about_Modules. Para obter mais informações sobre a variável $PSModuleAutoloadingPreference, consulte about_Preference_Variables.

Um módulo é um pacote que contém membros que podem ser usados no PowerShell. Os membros incluem cmdlets, provedores, scripts, funções, variáveis e outras ferramentas e arquivos. Depois que um módulo é importado, você pode usar os membros do módulo em sua sessão.

Para importar um módulo, use os parâmetros Name, Assembly, ModuleInfo, MinimumVersion e RequiredVersion para identificar o módulo a ser importado. Por padrão, importa todos os membros exportados pelo módulo, mas você pode usar os parâmetrosdo Alias , Function, Cmdlete Variable para restringir os membros importados. Você também pode usar o parâmetro NoClobber para impedir que Import-Module importem membros que tenham os mesmos nomes que os membros na sessão atual.

Import-Module importa um módulo apenas para a sessão atual. Para importar o módulo para todas as sessões, adicione um comando Import-Module ao seu perfil do PowerShell. Para obter mais informações sobre perfis, consulte about_Profiles.

A partir do Windows PowerShell 3.0, você pode usar Import-Module para importar módulos do CIM (Common Information Model), nos quais os cmdlets são definidos em arquivos CDXML (Cmdlet Definition XML). Esse recurso permite que você use cmdlets implementados em assemblies de código não gerenciados, como aqueles escritos em C++.

Com esses novos recursos, Import-Module cmdlet se torna uma ferramenta primária para gerenciar empresas heterogêneas que incluem computadores que executam o sistema operacional Windows e computadores que executam outros sistemas operacionais.

Para gerenciar computadores remotos que executam o sistema operacional Windows que têm a comunicação remota do PowerShell e do PowerShell habilitadas, crie um de PSSession no computador remoto e use o parâmetro PSSession para obter os módulos do PowerShell node PSSession . Quando você importa os módulos e usa os comandos importados na sessão atual, os comandos são executados implicitamente no PSSession no computador remoto. Você pode usar essa estratégia para gerenciar o computador remoto.

Você pode usar uma estratégia semelhante para gerenciar computadores que não têm a comunicação remota do PowerShell habilitada, incluindo computadores que não executam o sistema operacional Windows e computadores Windows que têm o PowerShell, mas não têm a comunicação remota do PowerShell habilitada.

Comece criando uma sessão CIM no computador remoto, que é uma conexão com a Instrumentação de Gerenciamento do Windows (WMI) no computador remoto. Em seguida, use o parâmetro CIMSession de Import-Module para importar módulos CIM do computador remoto. Quando você importa um módulo CIM e executa os comandos importados, os comandos são executados implicitamente no computador remoto. Você pode usar essa estratégia de WMI e CIM para gerenciar o computador remoto.

Exemplos

Exemplo 1: importar os membros de um módulo para a sessão atual

Este exemplo importa os membros do módulo PSDiagnostics para a sessão atual. O nome do parâmetro Name é opcional e pode ser omitido.

Import-Module -Name PSDiagnostics

Por padrão, Import-Module não gera nenhuma saída quando importa um módulo. Para solicitar a saída, use o parâmetro PassThru ou AsCustomObject ou o parâmetro Detalhado comum.

Exemplo 2: importar todos os módulos especificados pelo caminho do módulo

Este exemplo importa todos os módulos disponíveis no caminho especificado pela variável de ambiente $env:PSModulePath para a sessão atual.

Get-Module -ListAvailable | Import-Module

Exemplo 3: Importar os membros de vários módulos para a sessão atual

Este exemplo importa os membros dos módulos PSDiagnostics e Dism para a sessão atual.

$m = Get-Module -ListAvailable PSDiagnostics, Dism
Import-Module -ModuleInfo $m

O cmdlet obtém os módulos PSDiagnostics e Dism e salva os objetos na variável . O parâmetro ListAvailable é necessário quando você está recebendo módulos que ainda não foram importados para a sessão.

O parâmetro ModuleInfo de Import-Module é usado para importar os módulos para a sessão atual.

Esses comandos são equivalentes ao uso de um operador de pipeline (|) para enviar a saída de um comando Get-Module para Import-Module.

Exemplo 4: Importar todos os módulos especificados por um caminho

Este exemplo usa um caminho explícito para identificar o módulo a ser importado.

Import-Module -Name c:\ps-test\modules\test -Verbose

VERBOSE: Loading module from path 'C:\ps-test\modules\Test\Test.psm1'.
VERBOSE: Exporting function 'my-parm'.
VERBOSE: Exporting function 'Get-Parameter'.
VERBOSE: Exporting function 'Get-Specification'.
VERBOSE: Exporting function 'Get-SpecDetails'.

Usar o parâmetro Verbose faz com que Import-Module relate o progresso à medida que carrega o módulo. Sem o Detalhado, PassThru ou parâmetro AsCustomObject, Import-Module não gera nenhuma saída quando importa um módulo.

Exemplo 5: restringir os membros do módulo importados para uma sessão

Este exemplo mostra como restringir quais membros do módulo são importados para a sessão e o efeito desse comando na sessão.

Import-Module PSDiagnostics -Function Disable-PSTrace, Enable-PSTrace
(Get-Module PSDiagnostics).ExportedCommands

Key                          Value
---                          -----
Disable-PSTrace              Disable-PSTrace
Disable-PSWSManCombinedTrace Disable-PSWSManCombinedTrace
Disable-WSManTrace           Disable-WSManTrace
Enable-PSTrace               Enable-PSTrace
Enable-PSWSManCombinedTrace  Enable-PSWSManCombinedTrace
Enable-WSManTrace            Enable-WSManTrace
Get-LogProperties            Get-LogProperties
Set-LogProperties            Set-LogProperties
Start-Trace                  Start-Trace
Stop-Trace                   Stop-Trace

Get-Command -Module PSDiagnostics

CommandType     Name                 Version    Source
-----------     ----                 -------    ------
Function        Disable-PSTrace      6.1.0.0    PSDiagnostics
Function        Enable-PSTrace       6.1.0.0    PSDiagnostics

O primeiro comando importa apenas os cmdlets e do módulo PSDiagnostics . O parâmetro da Função limita os membros importados do módulo. Você também pode usar os parâmetros Alias, Variablee Cmdlet para restringir outros membros importados por um módulo.

O cmdlet obtém o objeto que representa o módulo PSDiagnostics . A propriedade ExportedCmdlets lista todos os cmdlets exportados pelo módulo, embora nem todos tenham sido importados.

No terceiro comando, o parâmetro módulo do cmdlet obtém os comandos importados do módulo PSDiagnostics . Os resultados confirmam que somente os cmdlets Disable-PSTrace e Enable-PSTrace foram importados.

Exemplo 6: importar os membros de um módulo e adicionar um prefixo

Este exemplo importa o módulo PSDiagnostics para a sessão atual, adiciona um prefixo aos nomes de membro e exibe os nomes de membro prefixados. O prefixo se aplica somente aos membros na sessão atual. Ele não altera o módulo.

Import-Module PSDiagnostics -Prefix x -PassThru

ModuleType Version    Name               ExportedCommands
---------- -------    ----               ----------------
Script     6.1.0.0    PSDiagnostics      {Disable-xPSTrace, Disable-xPSWSManCombinedTrace, Disable-xW...

Get-Command -Module PSDiagnostics

CommandType     Name                                   Version    Source
-----------     ----                                   -------    ------
Function        Disable-xPSTrace                       6.1.0.0    PSDiagnostics
Function        Disable-xPSWSManCombinedTrace          6.1.0.0    PSDiagnostics
Function        Disable-xWSManTrace                    6.1.0.0    PSDiagnostics
Function        Enable-xPSTrace                        6.1.0.0    PSDiagnostics
Function        Enable-xPSWSManCombinedTrace           6.1.0.0    PSDiagnostics
Function        Enable-xWSManTrace                     6.1.0.0    PSDiagnostics
Function        Get-xLogProperties                     6.1.0.0    PSDiagnostics
Function        Set-xLogProperties                     6.1.0.0    PSDiagnostics
Function        Start-xTrace                           6.1.0.0    PSDiagnostics
Function        Stop-xTrace                            6.1.0.0    PSDiagnostics

Ele usa o parâmetro prefixo de adiciona o prefixo x a todos os membros importados do módulo e o parâmetro PassThru para retornar um objeto de módulo que representa o módulo importado.

O cmdlet Get-Command para obter os membros que foram importados do módulo. A saída mostra que os membros do módulo foram prefixados corretamente.

Exemplo 7: Obter e usar um objeto personalizado

Esses comandos demonstram como obter e usar o objeto personalizado que o Import-Module retorna.

Os objetos personalizados incluem membros sintéticos que representam cada um dos membros do módulo importado. Por exemplo, os cmdlets e as funções em um módulo são convertidos em métodos de script do objeto personalizado.

Objetos personalizados são muito úteis no script. Eles também são úteis quando vários objetos importados têm os mesmos nomes. Usar o método de script de um objeto é equivalente a especificar o nome totalmente qualificado de um membro importado, incluindo o nome do módulo.

O parâmetro AsCustomObject pode ser usado somente ao importar um módulo de script, portanto, a primeira tarefa é determinar qual dos módulos disponíveis é um módulo de script.

Get-Module -List | Format-Table -Property Name, ModuleType -AutoSize

Name          ModuleType
----          ----------
Show-Calendar     Script
BitsTransfer    Manifest
PSDiagnostics   Manifest
TestCmdlets       Script

$a = Import-Module -Name Show-Calendar -AsCustomObject -Passthru
$a | Get-Member

TypeName: System.Management.Automation.PSCustomObject
Name          MemberType   Definition
----          ----------   ----------
Equals        Method       bool Equals(System.Object obj)
GetHashCode   Method       int GetHashCode()
GetType       Method       type GetType()
ToString      Method       string ToString()
Show-Calendar ScriptMethod System.Object Show-Calendar();

$a."Show-Calendar"()

O primeiro comando usa o cmdlet Get-Module para obter os módulos disponíveis. O comando usa um operador de pipeline para passar os objetos do módulo para o cmdlet , que lista o de Nome e ModuleType de cada módulo em uma tabela.

O segundo comando usa o cmdlet para importar o módulo de script Show-Calendar . O comando usa o parâmetro AsCustomObject para solicitar um objeto personalizado e o parâmetro PassThru para retornar o objeto. O comando salva o objeto personalizado resultante na variável $a.

O terceiro comando usa um operador de pipeline para enviar a variável $a para o cmdlet Get-Member, que obtém as propriedades e os métodos do PSCustomObject em $a. A saída mostra um método de script Show-Calendar() .

O último comando usa o método de script Show-Calendar . O nome do método deve estar entre aspas, pois inclui um hífen.

Exemplo 8: importar novamente um módulo para a mesma sessão

Este exemplo mostra como usar o parâmetro Force de Import-Module quando você estiver importando novamente um módulo para a mesma sessão.

Import-Module PSDiagnostics
Import-Module PSDiagnostics -Force -Prefix PS

O primeiro comando importa o módulo PSDiagnostics . O segundo comando importa o módulo novamente, desta vez usando o parâmetro prefixo .

Usando o parâmetro Force, Import-Module remove o módulo e o importa novamente. Sem esse parâmetro, a sessão incluiria duas cópias de cada cmdlet PSDiagnostics, uma com o nome padrão e outra com o nome prefixado.

Exemplo 9: executar comandos que foram ocultos por comandos importados

Este exemplo mostra como executar comandos ocultos por comandos importados. O módulo TestModule. inclui uma função chamada Get-Date que retorna o ano e o dia do ano.

Get-Date

Thursday, August 15, 2019 2:26:12 PM

Import-Module TestModule
Get-Date

19227

Get-Command Get-Date -All | Format-Table -Property CommandType, Name, ModuleName -AutoSize

CommandType     Name         ModuleName
-----------     ----         ----------
Function        Get-Date     TestModule
Cmdlet          Get-Date     Microsoft.PowerShell.Utility

Microsoft.PowerShell.Utility\Get-Date

Thursday, August 15, 2019 2:26:12 PM

O primeiro Get-Datecmdlet returns a **DateTime** object with the current date. After importing the **TestModule** module,Get-Date' retorna o ano e o dia do ano.

Usando o parâmetro Todos os do Get-Command obtemos todos os comandos Get-Date na sessão. Os resultados mostram que há dois comandos Get-Date na sessão, uma função do módulo TestModule e um cmdlet do módulo Microsoft.PowerShell.Utility.

Como as funções têm precedência sobre cmdlets, a função Get-Date do módulo TestModule é executada, em vez do cmdlet Get-Date. Para executar a versão original do Get-Date você deve qualificar o nome do comando com o nome do módulo.

Para obter mais informações sobre a precedência de comando no PowerShell, consulte about_Command_Precedence.

Exemplo 10: Importar uma versão mínima de um módulo

Import-Module -Name PSWorkflow -MinimumVersion 3.0.0.0

Esse comando importa o módulo PSWorkflow . Ele usa o parâmetro MinimumVersion de Import-Module para importar apenas a versão 3.0.0.0 ou superior do módulo.

Você também pode usar o parâmetro RequiredVersion para importar uma versão específica de um módulo ou usar os parâmetros do módulo e versão da palavra-chave para exigir uma versão específica de um módulo em um script.

Exemplo 11: Importar um módulo de um computador remoto

Este exemplo mostra como usar o cmdlet Import-Module para importar um módulo de um computador remoto. Esse comando usa o recurso de Comunicação Remota Implícita do PowerShell.

Ao importar módulos de outra sessão, você pode usar os cmdlets na sessão atual. No entanto, os comandos que usam os cmdlets realmente são executados na sessão remota.

$s = New-PSSession -ComputerName Server01
Get-Module -PSSession $s -ListAvailable -Name NetSecurity

ModuleType Name                                ExportedCommands
---------- ----                                ----------------
Manifest   NetSecurity                         {New-NetIPsecAuthProposal, New-NetIPsecMainModeCryptoProposal, New-Ne...

Import-Module -PSSession $s -Name NetSecurity
Get-Command -Module NetSecurity -Name Get-*Firewall*

CommandType     Name                                               ModuleName
-----------     ----                                               ----------
Function        Get-NetFirewallAddressFilter                       NetSecurity
Function        Get-NetFirewallApplicationFilter                   NetSecurity
Function        Get-NetFirewallInterfaceFilter                     NetSecurity
Function        Get-NetFirewallInterfaceTypeFilter                 NetSecurity
Function        Get-NetFirewallPortFilter                          NetSecurity
Function        Get-NetFirewallProfile                             NetSecurity
Function        Get-NetFirewallRule                                NetSecurity
Function        Get-NetFirewallSecurityFilter                      NetSecurity
Function        Get-NetFirewallServiceFilter                       NetSecurity
Function        Get-NetFirewallSetting                             NetSecurity

Get-NetFirewallRule -DisplayName "Windows Remote Management*" | Format-Table -Property DisplayName, Name -AutoSize

DisplayName                                              Name
-----------                                              ----
Windows Remote Management (HTTP-In)                      WINRM-HTTP-In-TCP
Windows Remote Management (HTTP-In)                      WINRM-HTTP-In-TCP-PUBLIC
Windows Remote Management - Compatibility Mode (HTTP-In) WINRM-HTTP-Compat-In-TCP

O primeiro comando usa o cmdlet New-PSSession para criar uma sessão remota (PSSession) para o computador Server01. O comando salva o PSSession na variável .

O segundo comando usa o parâmetro PSSession do cmdlet para obter o módulo NetSecurity na sessão na variável . Esse comando é equivalente a usar o cmdlet para executar um comando na sessão em (). A saída mostra que o módulo NetSecurity está instalado no computador e está disponível para a sessão na variável .

O terceiro comando usa o parâmetro PSSession do cmdlet para importar o módulo NetSecurity da sessão na variável para a sessão atual.

O quarto comando usa o cmdlet para obter comandos que começam com Obter e incluir firewall do módulo NetSecurity. A saída obtém os comandos e confirma que o módulo e seus cmdlets foram importados para a sessão atual.

O quinto comando usa o cmdlet Get-NetFirewallRule para obter regras de firewall de Gerenciamento Remoto do Windows no computador Server01. Esse comando é equivalente a usar o cmdlet Invoke-Command para executar um comando Get-NetFirewallRule na sessão na variável $s.

Exemplo 12: Gerenciar o armazenamento em um computador remoto sem o sistema operacional Windows

Neste exemplo, como o administrador do computador instalou o provedor WMI de Descoberta de Módulos, os comandos CIM podem usar os valores padrão, que são projetados para o provedor.

Os comandos neste exemplo permitem que você gerencie os sistemas de armazenamento de um computador remoto que não está executando o sistema operacional Windows.

O primeiro comando usa o cmdlet New-CimSession para criar uma sessão no computador remoto RSDGF03. A sessão se conecta ao WMI no computador remoto. O comando salva a sessão CIM na variável $cs.

O segundo comando usa a sessão CIM na variável $cs para executar um comando Import-Module no computador RSDGF03. O comando usa o parâmetro Name para especificar o módulo CIM de Armazenamento .

O terceiro comando executa o comando no comando no módulo de Armazenamento do . Quando você importa um módulo CIM para a sessão local, o PowerShell converte os arquivos CDXML para cada comando em scripts do PowerShell, que aparecem como funções na sessão local.

O quarto comando executa o comando Get-Disk. Embora o comando seja digitado na sessão local, ele é executado implicitamente no computador remoto do qual foi importado. O comando obtém objetos do computador remoto e os retorna para a sessão local.

$cs = New-CimSession -ComputerName RSDGF03
Import-Module -CimSession $cs -Name Storage
# Importing a CIM module, converts the CDXML files for each command into PowerShell scripts.
# These appear as functions in the local session.
Get-Command Get-Disk

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

# Use implicit remoting to query disks on the remote computer from which the module was imported.
Get-Disk

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

Parâmetros

-Alias

Especifica os aliases que esse cmdlet importa do módulo para a sessão atual. Insira uma lista separada por vírgulas de aliases. Caracteres curinga são permitidos.

Alguns módulos exportam automaticamente aliases selecionados para sua sessão quando você importa o módulo. Esse parâmetro permite que você selecione entre os aliases exportados.

Tipo:String[]
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:True

-ArgumentList

Especifica uma matriz de argumentos ou valores de parâmetro que são passados para um módulo de script durante o comando Import-Module. Esse parâmetro é válido somente quando você está importando um módulo de script.

Você também pode consultar o parâmetro ArgumentList por seu alias, args. Para obter mais informações, consulte about_Aliases.

Tipo:Object[]
Aliases:Args
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-AsCustomObject

Indica que esse cmdlet retorna um objeto personalizado com membros que representam os membros do módulo importado. Esse parâmetro é válido apenas para módulos de script.

Quando você usa o parâmetro AsCustomObject, importa os membros do módulo para a sessão e retorna um objeto PSCustomObject em vez de um objeto PSModuleInfo . Você pode salvar o objeto personalizado em uma variável e usar a notação de ponto para invocar os membros.

Tipo:SwitchParameter
Cargo:Named
Valor padrão:False
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Assembly

Especifica uma matriz de objetos de assembly. Esse cmdlet importa os cmdlets e provedores implementados nos objetos de assembly especificados. Insira uma variável que contenha objetos de assembly ou um comando que cria objetos de assembly. Você também pode canalizar um objeto assembly para Import-Module.

Quando você usa esse parâmetro, somente os cmdlets e provedores implementados pelos assemblies especificados são importados. Se o módulo contiver outros arquivos, eles não serão importados e você poderá estar perdendo membros importantes do módulo. Use esse parâmetro para depurar e testar o módulo ou quando for instruído a usá-lo pelo autor do módulo.

Tipo:Assembly[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-CimNamespace

Especifica o namespace de um provedor DE CIM alternativo que expõe módulos CIM. O valor padrão é o namespace do provedor WMI de Descoberta de Módulo.

Use esse parâmetro para importar módulos CIM de computadores e dispositivos que não estão executando um sistema operacional Windows.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:String
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-CimResourceUri

Especifica um local alternativo para módulos CIM. O valor padrão é o URI de recurso do provedor WMI de Descoberta de Módulo no computador remoto.

Use esse parâmetro para importar módulos CIM de computadores e dispositivos que não estão executando um sistema operacional Windows.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:Uri
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-CimSession

Especifica uma sessão CIM no computador remoto. Insira uma variável que contenha a sessão CIM ou um comando que obtém a sessão CIM, como um comando Get-CimSession.

Import-Module usa a conexão de sessão CIM para importar módulos do computador remoto para a sessão atual. Quando você usa os comandos do módulo importado na sessão atual, os comandos realmente são executados no computador remoto.

Você pode usar esse parâmetro para importar módulos de computadores e dispositivos que não estão executando o sistema operacional Windows e computadores Windows que têm o PowerShell, mas não têm a comunicação remota do PowerShell habilitada.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:CimSession
Cargo:Named
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Cmdlet

Especifica uma matriz de cmdlets que esse cmdlet importa do módulo para a sessão atual. Caracteres curinga são permitidos.

Alguns módulos exportam automaticamente cmdlets selecionados para sua sessão quando você importa o módulo. Esse parâmetro permite que você selecione entre os cmdlets exportados.

Tipo:String[]
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:True

-DisableNameChecking

Indica que esse cmdlet suprime a mensagem que avisa quando você importa um cmdlet ou função cujo nome inclui um verbo não aprovado ou um caractere proibido.

Por padrão, quando um módulo que você importa exporta cmdlets ou funções que têm verbos não aprovados em seus nomes, o PowerShell exibe a seguinte mensagem de aviso:

AVISO: Alguns nomes de comando importados incluem verbos não aprovados, o que pode torná-los menos detectáveis. Use o parâmetro Verbose para obter mais detalhes ou digite Get-Verb para ver a lista de verbos aprovados.

Esta mensagem é apenas um aviso. O módulo completo ainda é importado, incluindo os comandos não em conformidade. Embora a mensagem seja exibida aos usuários do módulo, o problema de nomenclatura deve ser corrigido pelo autor do módulo.

Tipo:SwitchParameter
Cargo:Named
Valor padrão:False
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Force

Esse parâmetro faz com que um módulo seja carregado ou recarregado por cima do atual

Tipo:SwitchParameter
Cargo:Named
Valor padrão:False
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-FullyQualifiedName

Especifica o nome totalmente qualificado da especificação do módulo.

Tipo:ModuleSpecification[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-Function

Especifica uma matriz de funções que esse cmdlet importa do módulo para a sessão atual. Caracteres curinga são permitidos.

Alguns módulos exportam automaticamente funções selecionadas para sua sessão quando você importa o módulo. Esse parâmetro permite que você selecione entre as funções exportadas.

Tipo:String[]
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:True

-Global

Indica que esse cmdlet importa módulos para o estado da sessão global para que eles estejam disponíveis para todos os comandos na sessão.

Por padrão, quando Import-Module cmdlet é chamado do prompt de comando, arquivo de script ou scriptblock, todos os comandos são importados para o estado da sessão global.

Quando invocado de outro módulo, Import-Module cmdlet importa os comandos em um módulo, incluindo comandos de módulos aninhados, para o estado de sessão do chamador.

Ponta

Você deve evitar chamar Import-Module de dentro de um módulo. Em vez disso, declare o módulo de destino como um módulo aninhado no manifesto do módulo pai. Declarar módulos aninhados melhora a capacidade de descoberta de dependências.

O parâmetro Global é equivalente ao parâmetro Scope com um valor global.

Para restringir os comandos exportados por um módulo, use um comando Export-ModuleMember no módulo de script.

Tipo:SwitchParameter
Cargo:Named
Valor padrão:False
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-MaximumVersion

Especifica uma versão máxima. Esse cmdlet importa apenas uma versão do módulo menor ou igual ao valor especificado. Se nenhuma versão se qualificar, Import-Module gerará um erro.

Tipo:String
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-MinimumVersion

Especifica uma versão mínima. Esse cmdlet importa apenas uma versão do módulo maior ou igual ao valor especificado. Se nenhuma versão se qualificar, Import-Module gerará um erro.

Por padrão, Import-Module importa o módulo sem verificar o número da versão.

Use o nome do parâmetro MinimumVersion ou seu alias, Version.

Para especificar uma versão exata, use o parâmetro RequiredVersion. Você também pode usar os parâmetros Module e Version da palavra-chave #Requires para exigir uma versão específica de um módulo em um script.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:Version
Aliases:Version
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-ModuleInfo

Especifica uma matriz de objetos de módulo a serem importados. Insira uma variável que contenha os objetos do módulo ou um comando que obtém os objetos do módulo, como o seguinte comando: Get-Module -ListAvailable. Você também pode redirecionar objetos de módulo para Import-Module.

Tipo:PSModuleInfo[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-Name

Especifica os nomes dos módulos a serem importados. Insira o nome do módulo ou o nome de um arquivo no módulo, como um arquivo .psd1, .psm1, .dllou ps1. Caminhos de arquivo são opcionais. Caracteres curinga não são permitidos. Você também pode canalizar nomes de módulo e nomes de arquivo para Import-Module.

Se você omitir um caminho, Import-Module procurará o módulo nos caminhos salvos na variável de ambiente $env:PSModulePath.

Especifique apenas o nome do módulo sempre que possível. Quando você especifica um nome de arquivo, somente os membros implementados nesse arquivo são importados. Se o módulo contiver outros arquivos, eles não serão importados e você poderá estar perdendo membros importantes do módulo.

Tipo:String[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:True

-NoClobber

Indica que esse cmdlet não importa comandos que têm os mesmos nomes que os comandos existentes na sessão atual. Por padrão, Import-Module importa todos os comandos de módulo exportados.

Comandos que têm os mesmos nomes podem ocultar ou substituir comandos na sessão. Para evitar conflitos de nome de comando em uma sessão, use os parâmetros de Prefixo ou NoClobber. Para obter mais informações sobre conflitos de nome e precedência de comando, consulte "Módulos e conflitos de nome" em about_Modules e about_Command_Precedence.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:SwitchParameter
Aliases:NoOverwrite
Cargo:Named
Valor padrão:False
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-PassThru

Retorna um objeto que representa o item com o qual você está trabalhando. Por padrão, esse cmdlet não gera nenhuma saída.

Tipo:SwitchParameter
Cargo:Named
Valor padrão:False
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Prefix

Especifica um prefixo que esse cmdlet adiciona aos substantivos nos nomes dos membros do módulo importados.

Use esse parâmetro para evitar conflitos de nome que podem ocorrer quando membros diferentes na sessão tiverem o mesmo nome. Esse parâmetro não altera o módulo e não afeta os arquivos que o módulo importa para seu próprio uso. Eles são conhecidos como módulos aninhados. Esse cmdlet afeta apenas os nomes dos membros na sessão atual.

Por exemplo, se você especificar o prefixo UTC e importar um cmdlet Get-Date, o cmdlet será conhecido na sessão como Get-UTCDatee não será confundido com o cmdlet de Get-Date original.

O valor desse parâmetro tem precedência sobre a propriedade DefaultCommandPrefix do módulo, que especifica o prefixo padrão.

Tipo:String
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-PSSession

Especifica uma sessão gerenciada pelo usuário do PowerShell (PSSession) da qual esse cmdlet importa módulos para a sessão atual. Insira uma variável que contém um PSSession ou um comando que obtém umde PSSession , como um comando .

Ao importar um módulo de uma sessão diferente para a sessão atual, você pode usar os cmdlets do módulo na sessão atual, assim como usaria cmdlets de um módulo local. Os comandos que usam os cmdlets remotos são realmente executados na sessão remota, mas os detalhes de comunicação remota são gerenciados em segundo plano pelo PowerShell.

Esse parâmetro usa o recurso de Comunicação Remota Implícita do PowerShell. É equivalente a usar o cmdlet Import-PSSession para importar módulos específicos de uma sessão.

Import-Module não pode importar módulos do PowerShell Core de outra sessão. Os módulos do PowerShell Core têm nomes que começam com o Microsoft.PowerShell.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:PSSession
Cargo:Named
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-RequiredVersion

Especifica uma versão do módulo que este cmdlet importa. Se a versão não estiver instalada, Import-Module gerará um erro.

Por padrão, Import-Module importa o módulo sem verificar o número da versão.

Para especificar uma versão mínima, use o parâmetro MinimumVersion. Você também pode usar os parâmetros Module e Version da palavra-chave #Requires para exigir uma versão específica de um módulo em um script.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Os scripts que usam RequiredVersion para importar módulos incluídos com versões existentes do sistema operacional Windows não são executados automaticamente em versões futuras do sistema operacional Windows. Isso ocorre porque os números de versão do módulo do PowerShell em versões futuras do sistema operacional Windows são maiores do que os números de versão do módulo em versões existentes do sistema operacional Windows.

Tipo:Version
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Scope

Especifica um escopo no qual esse cmdlet importa o módulo.

Os valores aceitáveis para este parâmetro são:

  • global. Disponível para todos os comandos na sessão. Equivalente ao parâmetro Global.
  • Local. Disponível somente no escopo atual.

Por padrão, quando Import-Module cmdlet é chamado do prompt de comando, arquivo de script ou scriptblock, todos os comandos são importados para o estado da sessão global. Você pode usar o parâmetro -Escopo com o valor de Local para importar o conteúdo do módulo para o escopo de script ou scriptblock.

Quando invocado de outro módulo, Import-Module cmdlet importa os comandos em um módulo, incluindo comandos de módulos aninhados, para o estado de sessão do chamador. Especificar -Scope Global ou -Global indica que esse cmdlet importa módulos para o estado de sessão global para que eles estejam disponíveis para todos os comandos na sessão.

O parâmetro Global é equivalente ao parâmetro Scope com um valor global.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:String
Valores aceitos:Local, Global
Cargo:Named
Valor padrão:Current scope
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Variable

Especifica uma matriz de variáveis que esse cmdlet importa do módulo para a sessão atual. Insira uma lista de variáveis. Caracteres curinga são permitidos.

Alguns módulos exportam automaticamente variáveis selecionadas para sua sessão quando você importa o módulo. Esse parâmetro permite que você selecione entre as variáveis exportadas.

Tipo:String[]
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:True

Entradas

System.String, System.Management.Automation.PSModuleInfo, System.Reflection.Assembly

Você pode canalizar um nome de módulo, objeto de módulo ou objeto assembly para este cmdlet.

Saídas

None, System.Management.Automation.PSModuleInfo, or System.Management.Automation.PSCustomObject

Este cmdlet retorna um PSModuleInfo ou PSCustomObject . Por padrão, Import-Module não gera nenhuma saída. Se você especificar o parâmetro PassThru, o cmdlet gerará um objeto System.Management.Automation.PSModuleInfo que representa o módulo. Se você especificar o parâmetro AsCustomObject, ele gerará um objeto PSCustomObject .

Observações

  • Antes de importar um módulo, o módulo deve ser instalado no computador local. Ou seja, o diretório do módulo deve ser copiado para um diretório acessível ao computador local. Para obter mais informações, consulte about_Modules.

    Você também pode usar o de PSSession e parâmetros CIMSession para importar módulos instalados em computadores remotos. No entanto, os comandos que usam os cmdlets nesses módulos realmente são executados na sessão remota no computador remoto.

  • Se você importar membros com o mesmo nome e o mesmo tipo para sua sessão, o PowerShell usará o membro importado por último por padrão. Variáveis e aliases são substituídos e os originais não são acessíveis. Funções, cmdlets e provedores são meramente sombreados pelos novos membros. Eles podem ser acessados qualificando o nome do comando com o nome de seu snap-in, módulo ou caminho de função.

  • Para atualizar os dados de formatação para comandos que foram importados de um módulo, use o cmdlet Update-FormatData. Update-FormatData também atualiza os dados de formatação para comandos na sessão que foram importados de módulos. Se o arquivo de formatação de um módulo for alterado, você poderá executar um comando Update-FormatData para atualizar os dados de formatação para comandos importados. Você não precisa importar o módulo novamente.

  • A partir do Windows PowerShell 3.0, os comandos principais instalados com o PowerShell são empacotados em módulos. No Windows PowerShell 2.0 e em programas de host que criam sessões de estilo mais antigo em versões posteriores do PowerShell, os comandos principais são empacotados em snap-ins (PSSnapins). A exceção é Microsoft.PowerShell.Core, que é sempre um snap-in. Além disso, sessões remotas, como as iniciadas pelo cmdlet New-PSSession, são sessões de estilo mais antigo que incluem snap-ins principais.

    Para obter informações sobre o método CreateDefault2 que cria sessões de estilo mais recente com módulos principais, consulte o método CreateDefault2.

  • Import-Module não pode importar módulos do PowerShell Core de outra sessão. Os módulos do PowerShell Core têm nomes que começam com o Microsoft.PowerShell.

  • No Windows PowerShell 2.0, alguns dos valores de propriedade do objeto do módulo, como os ExportedCmdlets e nestedModules valores de propriedade, não foram preenchidos até que o módulo foi importado e não estavam disponíveis no objeto do módulo que o parâmetro PassThru retorna. No Windows PowerShell 3.0, todos os valores de propriedade do módulo são preenchidos.

  • Se você tentar importar um módulo que contenha assemblies de modo misto que não são compatíveis com o Windows PowerShell 3.0, Import-Module retornará uma mensagem de erro como a seguinte.

    Import-Module: o assembly de modo misto é criado com base na versão 'v2.0.50727' do runtime e não pode ser carregado no runtime 4.0 sem informações de configuração adicionais.

    Esse erro ocorre quando um módulo projetado para o Windows PowerShell 2.0 contém pelo menos um assembly de módulo misto, ou seja, um assembly que inclui código gerenciado e não gerenciado, como C++ e C#.

    Para importar um módulo que contém assemblies de modo misto, inicie o Windows PowerShell 2.0 usando o comando a seguir e tente o comando Import-Module novamente.

    PowerShell.exe -Version 2.0

  • Para usar o recurso de sessão CIM, o computador remoto deve ter WS-Management comunicação remota e A WMI (Instrumentação de Gerenciamento do Windows), que é a implementação da Microsoft do padrão CIM (Common Information Model). O computador também deve ter o provedor WMI de Descoberta de Módulo ou um provedor DE CIM alternativo que tenha os mesmos recursos básicos.

    Você pode usar o recurso de sessão CIM em computadores que não estão executando um sistema operacional Windows e em computadores Windows que têm o PowerShell, mas não têm a comunicação remota do PowerShell habilitada.

    Você também pode usar os parâmetros CIM para obter módulos CIM de computadores que têm a comunicação remota do PowerShell habilitada, incluindo o computador local. Quando você cria uma sessão CIM no computador local, o PowerShell usa o DCOM, em vez do WMI, para criar a sessão.