Suponga que ha aprendido a ejecutar comandos localmente; eso ya es un trampolín hacia el dominio de la ejecución remota. PowerShell Remoting permite a los administradores ejecutar comandos y scripts en sistemas remotos.

Esta guía demuestra la configuración y el uso de PowerShell Remoting en un entorno de Active Directory (AD). Imagínese crear archivos, ejecutar scripts o verificar configuraciones de forma remota sin moverse de su escritorio.

¡Configure y use PowerShell Remoting para ejecutar scripts con confianza en sistemas remotos!

Configuración de la comunicación remota de PowerShell para un usuario estándar

Antes de aprovechar al máximo PowerShell Remoting, debe asegurarse de contar con los permisos necesarios. La ejecución de comandos o scripts de forma remota depende de una configuración adecuada, especialmente en entornos de Active Directory donde la seguridad es una prioridad.

Comience intentando conectarse a un servidor remoto (SRV2) usando Invoke-Command. El siguiente comando ejecuta un bloque de script en la computadora remota:

Invoke-Command -ComputerName SRV2 -ScriptBlock {Write-Host "Hi, I'm running code on the $(hostname) remote computer!"}

Si la autenticación falla, normalmente significa que el usuario carece de los permisos necesarios.

De forma predeterminada, los usuarios no administrativos deben ser miembros del grupo local de la computadora remota. Usuarios de gestión remota grupo.

Consulta la membresía del grupo:

Get-LocalGroupMember -Group 'Remote Management Users'

Si el usuario no aparece en la lista, agréguelo:

Add-LocalGroupMember -Group 'Remote Management Users' -Member user
Get-LocalGroupMember -Group 'Remote Management Users'

Ahora, reintente el Invoke-Command comando para confirmar la conectividad.

Invoke-Command -ComputerName SRV2 -ScriptBlock {Write-Host "Hi, I'm running code on the $(hostname) remote computer!"}

Ejecutar un script básico de forma remota

Una vez configurado PowerShell Remoting, puede ejecutar comandos en la computadora remota. Esta capacidad desbloquea el potencial para automatizar tareas, recopilar datos y solucionar problemas de forma remota.

Para ver cómo funciona la comunicación remota de PowerShell, cree un archivo de texto en la máquina remota y luego verifique que la acción sea exitosa.

Defina y ejecute el bloque de script:

$scriptblock = { Set-Content -Path 'somefile.txt' -Value '' }
Invoke-Command -Scriptblock $scriptblock -ComputerName SRV2

Verifique que el archivo se haya creado con el siguiente comando:

Este comando se conecta a la computadora remota. SRV2recupera información sobre el archivo somefile.txty muestra solo su nombre y hora de creación.

icm -ComputerName SRV2 -ScriptBlock {Get-Item somefile.txt} | Select-Object Name, CreationTime

Ejecución de scripts locales en computadoras remotas

Quizás un solo comando no sea suficiente y es posible que necesite ejecutar un script completo almacenado localmente en su máquina. Si es así, PowerShell Remoting le permite enviar rápidamente un script local a una computadora remota y ejecutarlo como si estuviera físicamente allí.

Para demostrar la ejecución de scripts en una computadora remota, cree un script corto localmente y ejecútelo en una máquina remota para automatizar acciones o tareas de limpieza.

Cree un script localmente con este comando donde:

• $scriptContents almacena el script en una cadena de varias líneas usando una cadena aquí (@' ... '@), que es útil para mantener el guión legible y organizado.
• Set-Content escribe el contenido de $scriptContents a un archivo llamado *RunThisRemotely.ps1* en el directorio actual.

$scriptContents =
@'
Write-Host "Deleting the file just created..."
Remove-Item -Path somefile.txt
'@
Set-Content -Path 'RunThisRemotely.ps1' -Value $scriptContents

Confirme el contenido del script:

Get-Content RunThisRemotely.ps1

Ejecute el script de forma remota:

Invoke-Command -ComputerName SRV2 -FilePath RunThisRemotely.ps1

Ahora, verifique que el archivo de prueba haya sido eliminado:

icm -ComputerName SRV2 -ScriptBlock {Test-Path somefile.txt}

Verificación de claves de registro local con un Scripblock

PowerShell Remoting admite el paso de variables entre sesiones locales y remotas, lo que permite scripts flexibles y reutilizables. Pero para empezar, centrémonos en comprobar las claves de registro localmente.

Almacene varias rutas de registro que se puedan verificar más adelante para ver si existen en el sistema:

# Define an array of registry paths to check
$registryKeyPaths = @(
    'HKLM:\SOFTWARE\Microsoft\AppV\', 
    'HKLM:\SOFTWARE\Microsoft\AccountsControl\'
)

Agregue esto al script para definir un bloque de script ****($localScriptBlock) que se ejecuta localmente en la computadora. El bloque de script comprueba si existen rutas de registro específicas en la máquina local y proporciona comentarios para cada ruta.

# Define the script block that will run locally on the computer
$localScriptBlock = {
    ## Iterate through each registry path in the $registryKeyPaths array
    foreach ($path in $registryKeyPaths) {
        # Check if the current registry path exists on the local machine
        if (Test-Path -Path $path) {
            # If the path exists, output a message confirming its existence
            Write-Host -Object "The registry path [$path] exists on the computer $(hostname)."
        } else {
            # If the path does not exist, output a message stating its absence
            Write-Host -Object "The registry path [$path] does not exist on the computer $(hostname)."
        }
    }
}

Ejecute el bloque de script y vea qué sucede.

Invoke-Command -ScriptBlock $localScriptBlock

Pasar variables locales a sesiones remotas

Ya sea que esté trabajando con matrices, cadenas u objetos, puede pasar datos a comandos remotos de dos maneras:

• $using – Integra variables locales en el bloque de script directamente.
• ArgumentList – Pasa explícitamente variables al bloque para su uso.

Siga leyendo para explorar los dos métodos ($using o ArgumentList) para lograr este objetivo.

Usando el $using Palabra clave (enfoque preferido)

Después de confirmar que existen las claves de registro, el siguiente paso es leer esa matriz localmente y usarla en el script en una computadora remota. Una forma de lograr esta hazaña es utilizando el $using palabra clave para hacer referencia a variables locales en sesiones remotas.

Cree este script para ejecutarlo en la computadora remota y verifique las rutas de registro especificadas. Este script proporciona información sobre si cada ruta existe o no.

Con este enfoque, simplemente agrega el $using prefijo a una variable local. Esta acción le dice a PowerShell que haga referencia a la variable local registryKeyPaths antes de ejecutar el código en la computadora remota.

$remoteScriptBlock = {
    ## Check to see if the registry keys exist on the computer
    foreach ($path in $using:registryKeyPaths) {
        if (Test-Path -Path $path) {
            Write-Host -Object "The registry path [$path] exists on the computer $(hostname)."
        } else {
            Write-Host -Object "The registry path [$path] does not exist on the computer $(hostname)."
        }
    }
}

Luego puede invocar el comando remoto para ejecutar el código en la máquina remota:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2

Parece que las claves de registro también existen allí.

Usando el ArgumentList Parámetro

además del $user palabra clave, otra opción es la ArgumentList parámetro para enviar variables a la sesión remota.

Cree un script (similar a uno con el $using palabra clave) que utiliza la $args matriz para acceder a los valores pasados ​​a través del ArgumentList parámetro.

En este método, usted especifica una o más variables que se enviarán a la sesión remota a través del ArgumentList parámetro. Dentro del bloque de script, reemplace la variable local con $argsque PowerShell completará automáticamente con los valores pasados ArgumentList.

$remoteScriptBlock = {
    ## Check to see if the registry keys exist on the computer
    foreach ($path in $args) {
        if (Test-Path -Path $path) {
            Write-Host -Object "The registry path [$path] exists on the computer $(hostname)."
        } else {
            Write-Host -Object "The registry path [$path] does not exist on the computer $(hostname)."
        }
    }
}

Ahora, ejecute el script con el siguiente comando:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2 -ArgumentList $registryKeyPaths

Ambos métodos producirán el mismo resultado, confirmando que las claves de registro existen en la computadora remota.

Si sigue estos pasos, podrá configurar y utilizar PowerShell Remoting de forma eficaz para ejecutar comandos y scripts en sistemas remotos.

Conclusión

En este tutorial, aprendió cómo configurar PowerShell Remoting en un entorno de Active Directory, ejecutar comandos y scripts en sistemas remotos y pasar variables de manera efectiva. Estas habilidades fundamentales son esenciales para automatizar tareas administrativas y gestionar sistemas de manera eficiente.

Ahora que ya tiene los conceptos básicos cubiertos, considere explorar temas más avanzados. Busque sesiones persistentes de PowerShell, cómo manejar errores remotos o crear scripts reutilizables para manejar operaciones masivas.

Las posibilidades con PowerShell Remoting son infinitas, ¡así que comience a experimentar y haga que sus flujos de trabajo sean más eficientes!