PowerShell Remoting: Ejecuta Comandos Remotos como un Profesional

Supongamos que has aprendido a ejecutar comandos localmente; eso ya es un paso 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 cómo configurar y usar PowerShell Remoting en un entorno de Active Directory (AD). Imagina crear archivos, ejecutar scripts o verificar configuraciones de forma remota sin levantarte de tu escritorio.

¡Configura y utiliza PowerShell Remoting para ejecutar scripts en sistemas remotos con confianza!

Configurando PowerShell Remoting para un Usuario Estándar

Antes de aprovechar al máximo PowerShell Remoting, debes asegurarte de que se cuenten con los permisos necesarios. Ejecutar comandos o scripts de forma remota depende de una configuración adecuada, especialmente en entornos de Active Directory donde la seguridad es una prioridad.

Comienza intentando conectarte a un servidor remoto (SRV2) utilizando 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, generalmente significa que el usuario carece de los permisos necesarios.

Por defecto, los usuarios no administrativos deben ser miembros del grupo local Remote Management Users de la computadora remota.

Verifica la membresía del grupo:

Get-LocalGroupMember -Group 'Remote Management Users'

Si el usuario no está en la lista, agrégalo:

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

Ahora, vuelve a intentar el comando Invoke-Command para confirmar la conectividad.

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

Ejecutando un Script Básico de Forma Remota

Una vez configurado el PowerShell Remoting, puedes 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 el PowerShell remoting, crea un archivo de texto en la máquina remota, luego verifica que la acción sea exitosa.

Define y ejecuta el scriptblock:

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

Verifica que el archivo fue creado con el siguiente comando:

Este comando se conecta a la computadora remota SRV2, obtiene información sobre el archivo somefile.txt y muestra solo su nombre y tiempo de creación.

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

Ejecución de Scripts Locales en Computadoras Remotas

Tal vez un solo comando no sea suficiente y necesites ejecutar un script completo almacenado localmente en tu máquina. Si es así, el PowerShell Remoting te permite enviar rápidamente un script local a una computadora remota y ejecutarlo como si estuvieras físicamente allí.

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

Crea un script localmente con este comando donde:

• $scriptContents almacena el script en una cadena de varias líneas utilizando un here-string (@' ... '@), lo cual es útil para mantener el script legible y organizado.
• Set-Content escribe el contenido de $scriptContents en 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

Confirma el contenido del script:

Get-Content RunThisRemotely.ps1

Ejecuta el script de forma remota:

Invoke-Command -ComputerName SRV2 -FilePath RunThisRemotely.ps1

Ahora, verifica que el archivo de prueba fue eliminado:

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

Verificando Claves del Registro Local con un Bloque de Script

La administración remota de PowerShell admite pasar variables entre sesiones locales y remotas, lo que permite scripts flexibles y reutilizables. Pero para empezar, enfoquémonos en verificar claves del registro localmente.

Almacena múltiples rutas del registro que se pueden verificar más tarde para ver si existen en el sistema:

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

Agrega esto al script para definir un bloque de script ****($localScriptBlock) que se ejecuta localmente en la computadora. El bloque de script verifica si rutas específicas del registro existen en la máquina local y proporciona retroalimentación 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)."
        }
    }
}

Ejecuta el bloque de script y observa qué sucede.

Invoke-Command -ScriptBlock $localScriptBlock

Pasando Variables Locales a Sesiones Remotas

Ya sea que estés trabajando con arreglos, cadenas u objetos, puedes 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.

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

Usando la Palabra Clave $using (Enfoque Preferido)

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

Crear este script para ejecutarse en la computadora remota y verificar las rutas del registro especificadas. Este script proporciona retroalimentación sobre si cada ruta existe o no.

Con este enfoque, simplemente agregas el prefijo $using a una variable local. Esta acción le indica 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, puedes invocar el comando remoto para ejecutar el código en la máquina remota:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2

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

Usando el parámetro ArgumentList

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

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

En este método, especificas una o más variables que se enviarán a la sesión remota a través del parámetro ArgumentList. Dentro del bloque de script, reemplaza la variable local con $args, que PowerShell llenará automáticamente con los valores pasados a través de 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, ejecuta el script con el siguiente comando:

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

Ambos métodos producirán la misma salida, confirmando que las claves del registro existen en la computadora remota.

Siguiendo estos pasos, puedes configurar y utilizar PowerShell Remoting de manera efectiva para ejecutar comandos y scripts en sistemas remotos.

Conclusión

En este tutorial, aprendiste 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 tienes cubiertos los conceptos básicos, considera explorar temas más avanzados. Investiga sesiones persistentes de PowerShell, manejo de errores remotos o la creación de scripts reutilizables para manejar operaciones en masa.

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