Import-PSSession

Módulo:

Microsoft.PowerShell.Utility

Importa comandos de otra sesión a la sesión actual.

Sintaxis

Import-PSSession
      [-Prefix <String>]
      [-DisableNameChecking]
      [[-CommandName] <String[]>]
      [-AllowClobber]
      [-ArgumentList <Object[]>]
      [-CommandType <CommandTypes>]
      [-Module <String[]>]
      [-FullyQualifiedModule <ModuleSpecification[]>]
      [[-FormatTypeName] <String[]>]
      [-Certificate <X509Certificate2>]
      [-Session] <PSSession>
      [<CommonParameters>]

Description

El cmdlet Import-PSSession importa comandos , como cmdlets, funciones y alias, desde una PSSession en un equipo local o remoto en la sesión actual. Puede importar cualquier comando que el cmdlet Get-Command pueda encontrar en PSSession.

Use un comando Import-PSSession para importar comandos desde un shell personalizado, como un shell de Microsoft Exchange Server, o desde una sesión que incluya módulos y complementos de Windows PowerShell u otros elementos que no estén en la sesión actual.

Para importar comandos, use primero el cmdlet New-PSSession para crear una PSSession. A continuación, use el cmdlet Import-PSSession para importar los comandos. De forma predeterminada, Import-PSSession importa todos los comandos, excepto los comandos que tienen los mismos nombres que los comandos de la sesión actual. Para importar todos los comandos, use el parámetro AllowClobber.

Puede usar comandos importados igual que usaría cualquier comando en la sesión. Cuando se usa un comando importado, la parte importada del comando se ejecuta implícitamente en la sesión desde la que se importó. Sin embargo, Windows PowerShell controla completamente las operaciones remotas. Ni siquiera es necesario tener en cuentalos, excepto que debe mantener abierta la conexión a la otra sesión (PSSession). Si lo cierra, los comandos importados ya no están disponibles.

Dado que los comandos importados pueden tardar más tiempo en ejecutarse que los comandos locales, Import-PSSession agrega un parámetro AsJob a todos los comandos importados. Este parámetro permite ejecutar el comando como un trabajo en segundo plano de Windows PowerShell. Para obtener más información, vea about_Jobs.

Cuando se usa Import-PSSession, Windows PowerShell agrega los comandos importados a un módulo temporal que solo existe en la sesión y devuelve un objeto que representa el módulo. Para crear un módulo persistente que puede usar en sesiones futuras, use el cmdlet Export-PSSession.

El cmdlet Import-PSSession usa la característica de comunicación remota implícita de Windows PowerShell. Al importar comandos en la sesión actual, se ejecutan implícitamente en la sesión original o en una sesión similar en el equipo de origen.

A partir de Windows PowerShell 3.0, puede usar el cmdlet Import-Module para importar módulos desde una sesión remota a la sesión actual. Esta característica usa la comunicación remota implícita. Equivale a usar Import-PSSession para importar módulos seleccionados desde una sesión remota a la sesión actual.

Ejemplos

Ejemplo 1: Importación de todos los comandos desde una PSSession

$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $S

Este comando importa todos los comandos de una PSSession en el equipo Server01 a la sesión actual, excepto los comandos que tienen los mismos nombres que los comandos de la sesión actual.

Dado que este comando no usa el parámetro CommandName, también importa todos los datos de formato necesarios para los comandos importados.

Ejemplo 2: Importación de comandos que terminan con una cadena específica

$S = New-PSSession https://ps.testlabs.com/powershell
Import-PSSession -Session $S -CommandName *-test -FormatTypeName *
New-Test -Name Test1
Get-Test test1 | Run-Test

Estos comandos importan los comandos con nombres que terminan en "-test" de una PSSession en la sesión local y después muestran cómo usar un cmdlet importado.

El primer comando usa el cmdlet New-PSSession para crear una PSSession. Guarda la PSSession en la variable $S.

El segundo comando usa el cmdlet Import-PSSession para importar comandos de PSSession en $S a la sesión actual. Usa el parámetro commandName de para especificar comandos con el nombre Test y el parámetro FormatTypeName para importar los datos de formato para los comandos Test.

Los comandos tercero y cuarto usan los comandos importados en la sesión actual. Dado que los comandos importados se agregan realmente a la sesión actual, se usa la sintaxis local para ejecutarlos. No es necesario usar el cmdlet Invoke-Command para ejecutar un comando importado.

Ejemplo 3: Importación de cmdlets desde una PSSession

$S1 = New-PSSession -ComputerName s1
$S2 = New-PSSession -ComputerName s2
Import-PSSession -Session s1 -Type Cmdlet -Name New-Test, Get-Test -FormatTypeName *
Import-PSSession -Session s2 -Type Cmdlet -Name Set-Test -FormatTypeName *
New-Test Test1 | Set-Test -RunType Full

En este ejemplo se muestra que puede usar cmdlets importados como usaría cmdlets locales.

Estos comandos importan los cmdlets New-Test y Get-Test desde una PSSession en el equipo Server01 y el cmdlet Set-Test desde una PSSession en el equipo Server02.

Aunque los cmdlets se importaron desde diferentes PSSessions, puede canalizar un objeto de un cmdlet a otro sin errores.

Ejemplo 4: Ejecución de un comando importado como trabajo en segundo plano

$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $S -CommandName *-test* -FormatTypeName *
$batch = New-Test -Name Batch -AsJob
Receive-Job $batch

En este ejemplo se muestra cómo ejecutar un comando importado como un trabajo en segundo plano.

Dado que los comandos importados pueden tardar más tiempo en ejecutarse que los comandos locales, Import-PSSession agrega un parámetro AsJob a todos los comandos importados. El parámetro AsJob le permite ejecutar el comando como un trabajo en segundo plano.

El primer comando crea una PSSession en el equipo Server01 y guarda el objeto PSSession en la variable $S.

El segundo comando usa Import-PSSession para importar los cmdlets test de PSSession en $S a la sesión actual.

El tercer comando usa el parámetro AsJob del cmdlet New-Test importado para ejecutar un comando New-Test como un trabajo en segundo plano. El comando guarda el objeto de trabajo que New-Test devuelve en la variable $batch.

El cuarto comando usa el cmdlet Receive-Job para obtener los resultados del trabajo en la variable $batch.

Ejemplo 5: Importación de cmdlets y funciones desde un módulo de Windows PowerShell

$S = New-PSSession -ComputerName Server01
Invoke-Command -Session $S {Import-Module TestManagement}
Import-PSSession -Session $S -Module TestManagement

En este ejemplo se muestra cómo importar los cmdlets y funciones desde un módulo de Windows PowerShell en un equipo remoto a la sesión actual.

El primer comando crea una PSSession en el equipo Server01 y la guarda en la variable $S.

El segundo comando usa el cmdlet Invoke-Command para ejecutar un comando de Import-Module en PSSession en $S.

Normalmente, el módulo se agregaría a todas las sesiones mediante un comando Import-Module en un perfil de Windows PowerShell, pero los perfiles no se ejecutan en PSSessions.

El tercer comando usa el parámetro Module de Import-PSSession para importar los cmdlets y funciones del módulo en la sesión actual.

Ejemplo 6: Creación de un módulo en un archivo temporal

PS C:\> 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_tcw1
zunz.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_tcw1
zunz.ttf
ModuleType        : Script
PrivateData       : {ImplicitRemoting}
AccessMode        : ReadWrite
ExportedAliases   : {}
ExportedCmdlets   : {}
ExportedFunctions : {[Get-Date, Get-Date], [SearchHelp, SearchHelp]}
ExportedVariables : {}
NestedModules     : {}

En este ejemplo se muestra que Import-PSSession crea un módulo en un archivo temporal en el disco. También muestra que todos los comandos se convierten en funciones antes de importarlos en la sesión actual.

El comando usa el cmdlet Import-PSSession para importar un cmdlet Get-Date y una función SearchHelp en la sesión actual.

El cmdlet Import-PSSession devuelve un PSModuleInfo objeto que representa el módulo temporal. El valor de propiedad Path muestra que Import-PSSession creó un archivo de módulo de script (.psm1) en una ubicación temporal. La propiedad ExportedFunctions muestra que el cmdlet Get-Date y la función SearchHelp se importaron como funciones.

Ejemplo 7: Ejecutar un comando oculto por un comando importado

PS C:\> Import-PSSession $S -CommandName Get-Date -FormatTypeName * -AllowClobber

PS C:\> Get-Command Get-Date -All

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

PS C:\> Get-Date
09074

PS C:\> (Get-Command -Type Cmdlet -Name Get-Date).PSSnapin.Name
Microsoft.PowerShell.Utility

PS C:\> Microsoft.PowerShell.Utility\Get-Date
Sunday, March 15, 2009 2:08:26 PM

En este ejemplo se muestra cómo ejecutar un comando oculto por un comando importado.

El primer comando importa un cmdlet de Get-Date desde PSSession en la variable $S. Dado que la sesión actual incluye un cmdlet de Get-Date, el parámetro AllowClobber es necesario en el comando .

El segundo comando usa el parámetro All del cmdlet Get-Command para obtener todos los comandos de Get-Date en la sesión actual. La salida muestra que la sesión incluye el cmdlet Get-Date original y una función Get-Date. La función Get-Date ejecuta el cmdlet Get-Date importado en PSSession en $S.

El tercer comando ejecuta un comando Get-Date. Dado que las funciones tienen prioridad sobre los cmdlets, Windows PowerShell ejecuta la función Get-Date importada, que devuelve una fecha juliana.

Los comandos cuarto y quinto muestran cómo usar un nombre completo para ejecutar un comando oculto por un comando importado.

El cuarto comando obtiene el nombre del complemento de Windows PowerShell que agregó el cmdlet de Get-Date original a la sesión actual.

El quinto comando usa el nombre completo del complemento del cmdlet Get-Date para ejecutar un comando Get-Date.

Para obtener más información sobre la precedencia de comandos y los comandos ocultos, vea about_Command_Precedence.

Ejemplo 8: Importación de comandos que tienen una cadena específica en sus nombres

PS C:\> Import-PSSession -Session $S -CommandName **Item** -AllowClobber

Este comando importa comandos cuyos nombres incluyen Item de PSSession en $S. Dado que el comando incluye el parámetro CommandName, pero no el parámetro FormatTypeData, solo se importa el comando.

Use este comando cuando use Import-PSSession para ejecutar un comando en un equipo remoto y ya tiene los datos de formato del comando en la sesión actual.

Ejemplo 9: Uso del parámetro Module para detectar qué comandos se importaron en la sesión

PS C:\> $M = Import-PSSession -Session $S -CommandName *bits* -FormatTypeName *bits*
PS C:\> 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

Este comando muestra cómo usar el parámetro Module de Get-Command para averiguar qué comandos se importaron en la sesión mediante un comando Import-PSSession.

El primer comando usa el cmdlet Import-PSSession para importar comandos cuyos nombres incluyen "bits" de PSSession en la variable $S. El comando Import-PSSession devuelve un módulo temporal y el comando guarda el módulo en la variable $m.

El segundo comando usa el cmdlet Get-Command para obtener los comandos exportados por el módulo en la variable $M.

El parámetro module toma un valor de cadena, que está diseñado para el nombre del módulo. Sin embargo, al enviar un objeto de módulo, Windows PowerShell usa el método ToString en el objeto module, que devuelve el nombre del módulo.

El comando Get-Command es el equivalente de Get-Command $M.Name".

Parámetros

-AllowClobber

Indica que este cmdlet importa los comandos especificados, incluso si tienen los mismos nombres que los comandos de la sesión actual.

Si importa un comando con el mismo nombre que un comando en la sesión actual, el comando importado oculta o reemplaza los comandos originales. Para obtener más información, vea about_Command_Precedence.

De forma predeterminada, Import-PSSession no importa comandos que tengan el mismo nombre que los comandos de la sesión actual.

Tipo:	SwitchParameter
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-ArgumentList

Especifica una matriz de comandos resultantes del uso de los argumentos especificados (valores de parámetro).

Por ejemplo, para importar la variante del comando Get-Item en la unidad de certificado (Cert:) de PSSession en $S, escriba Import-PSSession -Session $S -Command Get-Item -ArgumentList Cert:.

Tipo:	Object[]
Alias:	Args
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-Certificate

Especifica el certificado de cliente que se usa para firmar los archivos de formato (*. Format.ps1xml) o archivos de módulo de script (.psm1) en el módulo temporal que Import-PSSession crea.

Escriba una variable que contenga un certificado o un comando o expresión que obtenga el certificado.

Para buscar un certificado, use el cmdlet Get-PfxCertificate o use el cmdlet Get-ChildItem en la unidad Certificado (Cert:). Si el certificado no es válido o no tiene suficiente autoridad, se produce un error en el comando.

Tipo:	X509Certificate2
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-CommandName

Especifica comandos con los nombres o patrones de nombre especificados. Se permiten caracteres comodín. Use CommandName o su alias, Nombre.

De forma predeterminada, Import-PSSession importa todos los comandos de la sesión, excepto los comandos que tienen los mismos nombres que los comandos de la sesión actual. Esto impide que los comandos importados o se oculten o reemplacen comandos en la sesión. Para importar todos los comandos, incluso aquellos que ocultan o reemplazan otros comandos, use el parámetro AllowClobber.

Si usa el parámetro CommandName, los archivos de formato de los comandos no se importan a menos que use el parámetro FormatTypeName. Del mismo modo, si usa el parámetro FormatTypeName, no se importa ningún comando a menos que use el parámetro CommandName.

Tipo:	String[]
Alias:	Name
Posición:	2
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-CommandType

Especifica el tipo de objetos de comando. El valor predeterminado es Cmdlet. Use CommandType o su alias, Type. Los valores aceptables para este parámetro son:

• Alias: alias de Windows PowerShell en la sesión remota.
• All: los cmdlets y funciones de la sesión remota.
• Application: todos los archivos que no sean Windows-PowerShell archivos de las rutas de acceso que aparecen en la variable de entorno PATH ($Env:PATH) en la sesión remota, incluidos los archivos .txt, .exey .dll.
• Cmdlet: los cmdlets de la sesión remota. "Cmdlet" es el valor predeterminado.
• ExternalScript: los archivos .ps1 de las rutas de acceso enumeradas en la variable de entorno PATH ($Env:PATH) en la sesión remota.
• Filter y Function: las funciones de Windows PowerShell en la sesión remota.
• Script: el script se bloquea en la sesión remota.

Estos valores se definen como una enumeración basada en marcas. Puede combinar varios valores para establecer varias marcas mediante este parámetro. Los valores se pueden pasar al parámetro CommandType como una matriz de valores o como una cadena separada por comas de esos valores. El cmdlet combinará los valores mediante una operación binary-OR. Pasar valores como una matriz es la opción más sencilla y también permite usar la finalización de tabulación en los valores.

Tipo:	CommandTypes
Alias:	Type
Valores aceptados:	Alias, Function, Filter, Cmdlet, ExternalScript, Application, Script, Workflow, Configuration, All
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-DisableNameChecking

Indica que este cmdlet suprime el mensaje que le advierte al importar un cmdlet o una función cuyo nombre incluye un verbo no aprobado o un carácter prohibido.

De forma predeterminada, cuando un módulo que importa exporta cmdlets o funciones que tienen verbos no aprobados en sus nombres, Windows PowerShell muestra el siguiente mensaje de advertencia:

"ADVERTENCIA: algunos nombres de comandos importados incluyen verbos no aprobados que podrían hacer que sean menos reconocibles. Use el parámetro Verbose para obtener más detalles o escriba Get-Verb para ver la lista de verbos aprobados".

Este mensaje es solo una advertencia. El módulo completo se sigue importando, incluidos los comandos no conformes. Aunque el mensaje se muestra a los usuarios del módulo, el autor del módulo debe corregir el problema de nomenclatura.

Tipo:	SwitchParameter
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-FormatTypeName

Especifica instrucciones de formato para los tipos de Microsoft .NET Framework especificados. Escriba los nombres de tipo. Se permiten caracteres comodín.

El valor de este parámetro debe ser el nombre de un tipo devuelto por un comando Get-FormatData en la sesión desde la que se importan los comandos. Para obtener todos los datos de formato en la sesión remota, escriba *.

Si el comando no incluye el parámetro CommandName o FormatTypeName, Import-PSSession importa instrucciones de formato para todos los tipos de .NET Framework devueltos por un comando Get-FormatData en la sesión remota.

Si usa el parámetro FormatTypeName, no se importa ningún comando a menos que use el parámetro CommandName.

Del mismo modo, si usa el parámetro CommandName, los archivos de formato de los comandos no se importan a menos que use el parámetro FormatTypeName.

Tipo:	String[]
Posición:	3
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-FullyQualifiedModule

El valor puede ser un nombre de módulo, una especificación de módulo completa o una ruta de acceso a un archivo de módulo.

Cuando el valor es una ruta de acceso, la ruta de acceso puede ser completa o relativa. Se resuelve una ruta de acceso relativa con respecto al script que contiene la instrucción using.

Cuando el valor es un nombre o especificación de módulo, PowerShell busca en el psModulePath para el módulo especificado.

Una especificación de módulo es una tabla hash que tiene las siguientes claves.

• ModuleName - Required Especifica el nombre del módulo.
• GUID - opcional Especifica el GUID del módulo.
• También es obligatorio especificar al menos una de las tres claves siguientes.
  • ModuleVersion: especifica una versión mínima aceptable del módulo.
  • MaximumVersion: especifica la versión máxima aceptable del módulo.
  • RequiredVersion: especifica una versión exacta y necesaria del módulo. Esto no se puede usar con las otras claves de versión.

No se puede especificar el parámetro FullyQualifiedModule en el mismo comando que un parámetro Module. Los dos parámetros son mutuamente excluyentes.

Tipo:	ModuleSpecification[]
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-Module

Especifica y matriz de comandos en los complementos y módulos de Windows PowerShell. Escriba los nombres del complemento y del módulo. No se permiten caracteres comodín.

Import-PSSession no puede importar proveedores de un complemento.

Para obtener más información, vea about_PSSnapins y about_Modules.

Tipo:	String[]
Alias:	PSSnapin
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-Prefix

Especifica un prefijo para los nombres de los nombres de los comandos importados.

Use este parámetro para evitar conflictos de nombres que puedan producirse cuando distintos comandos de la sesión tengan el mismo nombre.

Por ejemplo, si especifica el prefijo Remote y, a continuación, importa un cmdlet de Get-Date, el cmdlet se conoce en la sesión como Get-RemoteDatey no se confunde con el cmdlet Get-Date original.

Tipo:	String
Posición:	Named
Valor predeterminado:	None
Requerido:	False
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

-Session

Especifica el de PSSession de desde el que se importan los cmdlets. Escriba una variable que contenga un objeto de sesión o un comando que obtenga un objeto de sesión, como un comando New-PSSession o Get-PSSession. Solo puede especificar una sesión. Este parámetro es obligatorio.

Tipo:	PSSession
Posición:	0
Valor predeterminado:	None
Requerido:	True
Aceptar entrada de canalización:	False
Aceptar caracteres comodín:	False

Entradas

None

No se pueden canalizar objetos a este cmdlet.

Salidas

PSModuleInfo

Este cmdlet devuelve el mismo objeto de módulo que devuelve New-Module y Get-Module cmdlets. Sin embargo, el módulo importado es temporal y solo existe en la sesión actual. Para crear un módulo permanente en el disco, use el cmdlet Export-PSSession.

Notas

• Import-PSSession se basa en la infraestructura de comunicación remota de PowerShell. Para usar este cmdlet, el equipo debe configurarse para WS-Management comunicación remota. Para obtener más información, vea about_Remote y about_Remote_Requirements.
• Import-PSSession no importa variables ni proveedores de PowerShell.
• Al importar comandos que tienen los mismos nombres que los comandos de la sesión actual, los comandos importados pueden ocultar alias, funciones y cmdlets en la sesión y pueden reemplazar funciones y variables en la sesión. Para evitar conflictos de nombres, use el parámetro prefijo. Para obtener más información, vea about_Command_Precedence.
• Import-PSSession convierte todos los comandos en funciones antes de importarlos. Como resultado, los comandos importados se comportan de forma un poco diferente de lo que harían si conservaran su tipo de comando original. Por ejemplo, si importa un cmdlet desde una PSSession y, a continuación, importa un cmdlet con el mismo nombre de un módulo o complemento, el cmdlet que se importa desde PSSession siempre se ejecuta de forma predeterminada porque las funciones tienen prioridad sobre los cmdlets. Por el contrario, si importa un alias en una sesión que tiene un alias con el mismo nombre, siempre se usa el alias original, ya que los alias tienen prioridad sobre las funciones. Para obtener más información, vea about_Command_Precedence.
• Import-PSSession usa el cmdlet Write-Progress para mostrar el progreso del comando. Es posible que vea la barra de progreso mientras se ejecuta el comando.
• Para buscar los comandos que se van a importar, Import-PSSession usa el cmdlet Invoke-Command para ejecutar un comando Get-Command en PSSession. Para obtener datos de formato para los comandos, usa el cmdlet Get-FormatData. Es posible que vea mensajes de error de estos cmdlets al ejecutar un comando Import-PSSession. Además, Import-PSSession no puede importar comandos de una PSSession que no incluya los cmdlets Get-Command, Get-FormatData, Select-Objecty Get-Help.
• Los comandos importados tienen las mismas limitaciones que otros comandos remotos, incluida la incapacidad de iniciar un programa con una interfaz de usuario, como el Bloc de notas.
• Dado que los perfiles de Windows PowerShell no se ejecutan en PSSessions, los comandos que agrega un perfil a una sesión no están disponibles para Import-PSSession. Para importar comandos desde un perfil, use un comando Invoke-Command para ejecutar el perfil en PSSession manualmente antes de importar comandos.
• El módulo temporal que Import-PSSession crea podría incluir un archivo de formato, incluso si el comando no importa datos de formato. Si el comando no importa datos de formato, los archivos de formato creados no contendrán datos de formato.
• Para usar Import-PSSession, la directiva de ejecución de la sesión actual no puede ser Restringida o AllSigned, ya que el módulo temporal que Import-PSSession crea contiene archivos de script sin firmar prohibidos por estas directivas. Para usar Import-PSSession sin cambiar la directiva de ejecución del equipo local, use el parámetro Scope de Set-ExecutionPolicy para establecer una directiva de ejecución menos restrictiva para un único proceso.
• En Windows PowerShell 2.0, los temas de ayuda de los comandos que se importan desde otra sesión no incluyen el prefijo que se asigna mediante el parámetro Prefix. Para obtener ayuda para un comando importado en Windows PowerShell 2.0, use el nombre del comando original (sin prefijo).

Vínculos relacionados

• Export-PSSession