Conexión a otra computadora a través de powershell. Powershell: uso del cmdlet Invoke-Command. Gestión uno a muchos

• Tutorial

Aquí hay un mínimo de teoría, sobre todo una parte práctica. Describe cómo configurar WinRM, cómo cambiar el perfil del adaptador de red, proporciona un script para agregar a TrustedHosts con filtrado, explica por qué se necesitan hosts confiables y analiza conexiones superficialmente remotas para que pueda sentarse y administrar inmediatamente máquinas remotas.

La forma más sencilla de configurar el control remoto es ejecutar Habilitar-PSRemoting en Powershell con derechos de administrador. Sucederá lo siguiente:

• se iniciará el servicio WinRM (si se está ejecutando, se reiniciará)
• El servicio WinRM cambiará al estado: inicio automático al inicio
• Se creará un oyente WinRM para HTTP tráfico en el puerto 5985 para todas las direcciones IP locales
• Se creará una regla de firewall para el oyente WinRM. Atención, este paso fallará con un error si alguna de las tarjetas de red tiene el tipo de red “pública”, porque abrir un puerto en una tarjeta de este tipo no es bueno. Si recibe este error al configurar, cambie el perfil de este cmdlet de red Establecer perfil de conexión de red y luego ejecute Enable-PSRemoting nuevamente. Si necesita una tarjeta de red con el perfil "Red pública", ejecute Enable-PSRemoting con el parámetro -Omitir verificación de perfil de red en este caso, las reglas de firewall se crearán únicamente desde la red local.

Después de esto, debe permitir la conexión a la máquina remota desde la máquina desde la que se realizará el control. Esto se hizo por motivos de seguridad para reducir el riesgo de piratear una sesión de control remoto o DNS sustituyéndote a ti mismo en lugar de una máquina remota y para evitar la ejecución de scripts en máquinas que no permitiste por la fuerza.

Para comprobar dónde puede conectarse, utilice:
obtener elemento wsman:\localhost\Client\TrustedHosts
para obtener permiso para conectarse con todos
set-item wsman:localhost\client\trustedhosts -valor *
Si abre el acceso a todos especificando *, WinRM se conectará a TODAS las máquinas sin verificación. Recuerde que se está abriendo a posibles ataques desde su red local. Es mejor especificar las direcciones de host a las que necesita conectarse, luego WinRM rechazará todas las demás direcciones o nombres. Si la máquina que se controla está en un dominio, confiará en todas las máquinas de ese dominio. Si no está en el dominio, o en otro dominio, entonces debemos especificar en TrustedHosts la dirección o nombre de la máquina a la que nos conectaremos. No es necesario que se agregue a la máquina a la que nos estamos conectando.

La ayuda contiene comandos, los modifiqué ligeramente en un script.
################################################## ################################### # agrega NewHost a la lista TrustedHost con filtrado si dicha línea ya existe # Puede extraerlo desde la línea de comando especificando el parámetro directamente, por ejemplo # .\Add-TrustedHost.ps1 192.168.2.1 ####################### ######## ########################################## ######## ###### param ($NewHost = "192.168.2.89") Write-Host "agregando host: $NewHost" $prev = (get-item WSMan:\localhost\Client\TrustedHosts ).value if (($prev .Contains($NewHost)) -eq $false) ( if ($prev -eq "") ( set-item WSMan:\localhost\Client\TrustedHosts -Value "$ Nuevo anfitrión" } else { set-item WSMan:\localhost\Client\TrustedHosts -Value "$anterior, $NuevoHost" } } Write-Host "" Write-Host "Now TrustedHosts contains:" (get-item WSMan:\localhost\Client\TrustedHosts).value !}
comprueba si existe dicha entrada; en caso contrario, la agrega a la lista. Puede llamarlo desde la línea de comando especificando la dirección o el nombre.

Existe una diferencia entre especificar un nombre o una dirección. Si solo hay una dirección en TrustedHosts, no será posible abrir una sesión por nombre y viceversa; si especifica un nombre, no será posible adjuntarla a la dirección. Toma esto en cuenta.

cual es la diferencia

Enable-PSRemoting hace más que "winrm quickconfig". El cmdlet Set-WSManQuickConfig hace exactamente lo mismo que "winrm quickconfig". Enable-PSRemoting ejecuta Set-WSManQuickConfig al configurar el sistema

Conexiones remotas
1. Sesiones 1 a 1
abrir por comando
Enter-PSSession -Prueba de nombre de computadora
Obtendrá un shell en la máquina remota. Puede conectarse consigo mismo especificando localhost. Los créditos alternativos se especifican con el parámetro -Credencial, la salida se produce con el cmdlet Salir de PSSession

Las restricciones son las siguientes:

• no puedes hacer un segundo salto - solo 1 sesión, no puedes conectarte más dentro de una sesión
• no puede utilizar comandos GUI. Si haces esto el shell se colgará, presiona Ctrl+C para colgar
• no puede ejecutar comandos que tengan su propio shell, por ejemplo nslookup, netsh
• puede ejecutar scripts si la política de inicio en la máquina remota permite ejecutarlos
• no puede conectarse a una sesión interactiva, inicias sesión como “iniciar sesión en la red”, como si estuvieran conectados a una unidad de red. Por lo tanto, los scripts de inicio de sesión no se ejecutarán y es posible que no obtenga la carpeta de inicio en la máquina remota (otra razón para no asignar carpetas de inicio con los scripts de inicio de sesión).
• no podrá interactuar con el usuario en la máquina remota incluso si ha iniciado sesión allí. No podrás mostrarle la ventana ni imprimirle nada.

Este método es mejor para operaciones simples: inicié sesión, accedí al servidor y me desconecté. Si necesita mantener las variables juntas, necesita una operación prolongada (muchas horas o días), necesita más capacidades de administración y entonces necesita utilizar tecnología más avanzada.

Un comentario.
Los objetos transmitidos a través de la red se cortan y dejan de estar vivos. Se eliminan sus métodos, pero sus propiedades permanecen. No podrás sacar un objeto de tu auto, hacer algo de magia y volver a colocarlo. Si necesitas más, escribe, lo agregaré por separado.

2. Sesiones de 1 a muchos
Comando de invocación
Definimos lo que haremos así:
$sb = (comandos para la máquina remota separados por punto y coma)
transmitir Test1 y Test2 a máquinas remotas
Invocar comando -ComputerName Prueba1, Prueba2 -ScriptBlock $sb
Puedes lanzarlo a 32 autos a la vez. Si hay créditos alternativos, utilice el parámetro -Credencial

Para transferir el script completo en lugar del parámetro -ScriptBlock escribimos -FilePath, la máquina remota NO necesita tener acceso al archivo, se desmontará en partes, se transmitirá a través de HTTP y se ejecutará en el otro lado.

Recuerde que habrá un nuevo alcance en ese lado, por lo que su script no recibirá valores de su consola y las variables del script pueden estar vacías en ese lado. Por lo tanto, transfiera instrucciones y scripts completamente preparados con parámetros a la vez.

Para utilizar Invoke-Command por completo, debe poder convertir líneas en bloques de script. Por ejemplo, tienes comandos que dependen de alguna lista, necesitas generar una línea, convertirla en un ScriptBlock y enviarla a una computadora remota:
$sb = ::Crear($AlgunaCadena)

kuda78
El artículo omitió un punto muy importante: pasar parámetros a un script en una máquina remota.

$ implementarRemoto = (
parámetro(
$ nombreEnvDestino,
$objetivoNombre de usuario)
$Global:ErrorActionPreference = "Detener"
#…
}

Invocar-Comando -Session $sesión -ScriptBlock $deployRemote -ArgumentList ($targetEnvName, $targetUsername)

Sí, efectivamente, se perdió. Hice esto deliberadamente para no saturar la revisión con parámetros y descripciones. Gracias. El parámetro -ArgumentList funciona tanto con bloques de script como con scripts

3. Sesiones
Esto es cuando se crea una copia del código en el otro lado, que permanece constantemente en la memoria y se le envían comandos. Como resultado, puede volver a conectarse a él, tomar mucho tiempo para ejecutarlo o conectarse desde diferentes scripts o diferentes usuarios. Por ejemplo, tiene un conjunto de scripts que resuelven un problema en partes, cada uno de ellos a su vez puede conectarse a una sesión remota, ver los resultados de comandos anteriores, tener los mismos módulos cargados, variables comunes, un entorno común, hasta que el La sesión se cierra por la fuerza.

La sesión se crea usando el cmdlet New-PSSession, el resultado se puede colocar en una variable
$DC01 = Nueva-PSSession -ComputerName DC01 $Controladores = Nueva-PSSession DC01, DC02, DC03
Puede utilizar los mismos parámetros de conexión que en Invoke-Command

Cómo utilizar:
si 1 a 1
Ingrese-PSSession -Session $DC01
si 1 a muchos
Invocar-Comando -Sesiones $Controladores -ScriptBlock (get-eventlog -logname seguridad -más reciente 50)
Puede ver qué sesiones están abiertas usando Get-PSSession, cierre Remove-PSSession
cerrar todas las sesiones por completo
Obtener-PSSession | Eliminar-PSSession
Puede conectarse a una sesión usando Connect-PSSession, desconectarse usando Disconnect-PSSession

Invoke-Command puede crear inmediatamente una sesión desconectada, envía comandos para su ejecución y luego se desconecta, puede conectarse y descargar los resultados del trabajo; Esto se hace con el parámetro -Desconectado. Recibir resultados mediante el cmdlet Recieve-PSSession.

Las sesiones tienen muchas configuraciones, incluso es posible crear sesiones con un conjunto recortado de comandos, módulos, etc. Puntos finales personalizados llamados

No hace mucho tuve que dedicar un poco de tiempo a configurar el acceso remoto a través de Powershell. Este enfoque me parece una muy buena alternativa a los Servicios de Escritorio remoto en varios casos (reiniciar el servicio en un alojamiento VDS remoto, realizar copias de seguridad, ver el estado del sistema, etc.).

La capacidad de crear sesiones remotas de Powershell se introdujo en la versión 2. Para hacer esto, use el cmdlet Enter-PSSession / Invoke-Command. Sin embargo, se debe preparar el ambiente antes de utilizarlos.

que hacemos en el servidor:

Paso 1: Abra la consola de Powershell y habilite las sesiones remotas utilizando el cmdlet Enable-PSRemoting con la tecla Forzar.

Habilitar-PSRemoting-Forzar

Paso 2: Asegúrese de que el servicio WinRM se esté ejecutando.

Servicio de inicio WinRM

Paso 3: Configuramos reglas en el firewall para que las conexiones entrantes sean posibles.

En el ordenador que se utilizará como cliente También es necesario realizar varios pasos:

Paso 1: Permitir conexiones a hosts remotos. Para acceder a cualquier nodo, puede utilizar la siguiente construcción:

Establecer elemento wsman:\localhost\client\trustedhosts * -Force

Paso 2: Asegúrese de que su firewall no esté bloqueando las conexiones salientes.

Ahora, para conectarse a un nodo remoto a través de Powershell, puede hacer esto:

Ingrese-PSSession 192.168.1.160 -Credencial VMNAME\Usuario

Los valores 192.168.1.160 y VMNAME\User deben reemplazarse con la dirección del host remoto y el nombre de usuario de Windows en el servidor.

Ahora funciona el acceso remoto a través de Powershell. Sin embargo, hay un matiz más. Quizás algunos de ustedes usen perfiles en Powershell. Los perfiles son scripts especiales que se inician cuando se inicia la consola. Aquí, por ejemplo, puede definir todos los alias necesarios y realizar los pasos previos.

El problema es que los perfiles no se inician cuando se utilizan sesiones remotas. Esto se puede solucionar utilizando diferentes configuraciones de conexión. Para hacer esto, primero debe registrar la configuración en el servidor remoto. Puede hacerlo ejecutando el cmdlet Register-PSSessionConfiguration. En este caso, a cada configuración se le asigna un nombre. Para cada configuración, puede establecer la ruta al script, que se ejecutará cuando comience la sesión.

Registro-PSSessionConfiguration -nombre Config1 -startupScript c:\scripts\Startup.ps1

Luego, al conectarse a un host remoto, debe especificar el nombre de configuración cuando utilice el cmdlet Enter-PSSession.

Ingrese-PSSession 192.168.1.160 -Nombre de configuración Config1 -Credencial VMNAME\Usuario

Ahora puede evitar desperdiciar recursos del servidor al crear una sesión de conexión a través de Servicios de Escritorio remoto y administrar el servidor de forma remota mediante Powershell.

inicio remoto de la aplicación powershell

Iniciar una sesión interactiva

Para iniciar una sesión interactiva con una única computadora remota, use el cmdlet Enter-PSSession. Por ejemplo, para iniciar una sesión interactiva con la computadora remota Server01, ingrese:
entrar-pssession Server01
El símbolo del sistema mostrará el nombre de la computadora a la que está conectado. En el futuro, todos los comandos ingresados ​​en la línea de comando se ejecutarán en la computadora remota y los resultados se mostrarán en la computadora local.
Para finalizar la sesión interactiva, ingrese:
pasión-salida

Ejecutar un comando remoto

Para ejecutar cualquier comando en una o más computadoras remotas, use el cmdlet Invoke-Command. Por ejemplo, para ejecutar el comando Get-UICulture en las computadoras remotas Server01 y Server02, ingrese:

Invocar comando -nombre de computadora Servidor01, Servidor02 (get-UICulture)
El resultado será devuelto a su computadora.
Para ejecutar el script en una o más computadoras remotas, use el parámetro FilePath del cmdlet Invoke-Command. El script debe estar habilitado o disponible en la computadora local. Los resultados se devolverán a su computadora local.
Por ejemplo, el siguiente comando ejecuta el script DiskCollect.ps1 en las computadoras remotas Server01 y Server02.
invocar-comando -nombre de computadora Server01, Server02 -ruta de archivo c:\Scripts\DiskCollect.ps1

Configurar una conexión permanente
Para ejecutar una serie de comandos relacionados con datos compartidos, cree una sesión en la computadora remota y luego use el cmdlet Invoke-Command para ejecutar los comandos en la sesión creada. Para crear una sesión remota, utilice el cmdlet New-PSSession.
Por ejemplo, el siguiente comando crea una sesión remota en la computadora Server01 y otra sesión remota en la computadora Server02. Almacena los objetos de sesión en la variable $s.
$s = nueva-pssession -nombredecomputadora Servidor01, Servidor02
Una vez establecidas las sesiones, puede ejecutar cualquier comando en ellas. Debido a que las sesiones son persistentes, puede recopilar datos en un comando y usarlos en uno posterior.
Por ejemplo, el siguiente comando ejecuta el comando Get-Hotfix en todas las sesiones en la variable $s y almacena los resultados en la variable $h. La variable $h se crea en cada sesión en $s, pero no existe en la sesión local.
invocar-comando -session $s ($h = get-hotfix)
Los datos en $h ahora se pueden usar en comandos posteriores, como los siguientes. Los resultados se mostrarán en su computadora local.

Invocar comando -session $s ($h | donde ($_.installedby -ne "NTAUTHORITY\SYSTEM")

Todo tomado de https://technet.microsoft.com/ru-ru/library/dd819505.aspx

Hoy en día, PowerShell Remoting es la principal herramienta para la gestión remota de sistemas operativos Windows. Por lo tanto, todo administrador de sistemas Windows debe conocer sus capacidades y utilizarlas en sus tareas diarias. Para ejecutar comandos en computadoras remotas usando PowerShell Remoting, puede usar el cmdlet de Powershell Comando de invocación(alias icm).

La funcionalidad del cmdlet Invoke-Command se basa en el protocolo de servicios web para administración ( Gestión WS) y el servicio de administración remota de Windows ( WinRM), utilizado para la comunicación. La comunicación entre computadoras se realiza mediante HTTP (predeterminado) o HTTPS. Todo el tráfico entre dos computadoras está cifrado a nivel de protocolo. Se admiten varios métodos de autenticación, incluidos NTLM y Kerberos. La capacidad de crear sesiones remotas se introdujo en Powershell 2.0.

Para conectarse de forma remota a una computadora a través de PowerShell Remoting, debe realizar una serie de configuraciones en ella:

1. Debe permitir conexiones remotas: Enable-PSRemoting -Force
2. Inicie el servicio WinRM: Start-Service WinRM
3. Cree una regla de Firewall de Windows que permita conexiones entrantes utilizando este protocolo.

La computadora desde la cual planea administrar de forma remota otras computadoras/servidores a través de PowerShell Remoting también debe configurarse:

1. Debe permitir conexiones a sistemas remotos. Para proporcionar acceso a todas las computadoras remotas, use el comando: Set-Item wsman:\localhost\client\trustedhosts * -Force
2. Asegúrese de que su firewall no esté bloqueando las conexiones salientes.

Ahora, para ejecutar un comando en una máquina remota a través de Powershell Remoting (por ejemplo, desea reiniciar el servicio de impresión Spooler), debe ejecutar el siguiente comando:

Invocar-Comando -nombre de computadora servidor1 -dominio de credenciales\usuario1 -scriptblock (reiniciar cola de servicio)

Este comando ejecuta el comando Cola de reinicio del servicio en una computadora remota llamada servidor 1. El parámetro Credencial se utiliza para ejecutar el comando en el contexto de seguridad del usuario de dominio dominio\usuario1.

Cuando especifica un nombre de usuario, Windows PowerShell muestra un cuadro de diálogo que le solicita que proporcione la contraseña para la cuenta de usuario1. El comando especificado entre llaves se ejecuta luego en la computadora remota y devuelve los resultados a la consola. Una vez que se ejecuta el comando, la sesión remota de PoSh finaliza.

Para ejecutar una tarea en segundo plano, puede especificar el parámetro -AsJob.

Cuando ejecuta un comando en segundo plano, PowerShell no devuelve sus resultados. Para recibirlos, debe utilizar el cmdlet Recibir-Job.

Obtener-trabajo –id 3 |Recibir-trabajo

Para ejecutar no solo un comando, sino un script de PowerShell completo, el cmdlet Invoke-Command tiene un argumento especial -FilePath, que debe usarse en lugar de -ScriptBlock para especificar la ruta al archivo de script. Por ejemplo, creé un pequeño script PoSh que muestra una lista de servicios detenidos. Ejecutemos este script en una computadora remota:

Invocar comando -nombre de computadora servidor1 -FilePath .\list.ps1

Es importante tener en cuenta aquí que no es necesario que copie usted mismo el archivo de script ps1 en la computadora remota. Los resultados de la ejecución del script se envían a la consola.

Muy a menudo es necesario ejecutar simultáneamente el mismo comando/script en varias computadoras. Usando Invoke-Command esto se implementa de manera bastante simple. Puede enumerar los nombres de las computadoras separados por comas en el argumento. -Nombre de la computadora.

Invocar-Comando -ScriptBlock (reiniciar cola de servicio) -ComputerName servidor1,servidor2,servidor3

O ponerlo en una matriz:

$srv_list = @(″servidor4″,″servidor5″,″servidor6″)
Invocar-Comando -ScriptBlock (Cola de impresión de reinicio-Servicio) -ComputerName $servidores

O cargar desde un archivo de prueba:

Invoke-Command -ScriptBlock (reiniciar cola de servicio) –ComputerName (Get-Content .\servers_list.txt)

El comando se ejecutará en cada computadora y los resultados de su ejecución se mostrarán en la consola.

Nota. El cmdlet Invoke-Command tiene un parámetro Límite del acelerador lo que le permite establecer el número máximo de computadoras en las que se puede ejecutar el mismo comando simultáneamente. De forma predeterminada, la computadora limita el número a dígitos. 32 . Este número se puede aumentar si es necesario, pero tenga en cuenta que aumentar esta configuración aumenta la carga en el procesador y la memoria de su computadora, por lo que esta operación debe realizarse con precaución.

Si está instalado, es posible ejecutar comandos simultáneamente en varias computadoras seleccionadas de AD mediante canalizaciones:

Get-ADComputer -Filter * -properties nombre | seleccione (Nombre="nombre de computadora";Expresión=($_."nombre"))| Invocar-Comando -ScriptBlock (nombre de host)

Cada vez que se ejecuta Invoke-Command, se crea una nueva sesión, lo que consume algo de tiempo y recursos de CPU. Para evitar desperdiciar recursos, puede utilizar una única sesión para ejecutar todos los comandos. Por ejemplo, creemos una nueva sesión sess1 con la computadora computadora1 y asignémosla a la variable $ sesión, y luego ejecutemos nuestra tarea en esta sesión:

$sesión = Nueva-PSSession -ComputerName computadora1 -Nombre sess1
Invocar-Comando -ScriptBlock (Cola de impresión de reinicio-Servicio) -Session $sesión

Esta sesión permanecerá activa hasta que cierre la consola de PowerShell. También puedes cerrar la sesión (Disconnect-PSSession) o eliminarla (Remove-PSSession).

Powershell es tan genial que le permite no solo ejecutar algunos comandos en computadoras remotas, sino también conectarse completamente a la computadora y ejecutar comandos como si estuviera en una computadora local. De forma predeterminada, este placer está desactivado por razones de seguridad. Encenderlo y configurarlo no es nada difícil, pero por alguna razón mucha gente no lo sabe.

Para el control remoto se necesitan dos condiciones: en primer lugar, en ambas computadoras, naturalmente, es necesario que Powershell, .NET Framework y el servicio de administración remota de Windows (todos los componentes a partir de la versión 2.0) estén instalados, y en segundo lugar, que están configurados para control remoto. Para Windows 7 y superior no necesita instalar nada, todo ya está ahí; para Windows XP/2003 necesita instalar .NET Framework y Powershell (el servicio de administración remota de Windows viene incluido con Powershell).

Una vez instalado todo lo necesario, deberá configurar la computadora a la que deberá conectarse para permitir conexiones remotas. Para hacer esto, debe ejecutar el comando winrm quickconfig o winrm qc. Este comando hace varias cosas a la vez:

• Inicia el servicio WinRM
• Cambia el tipo de inicio del servicio WinRM a automático
• Crea un oyente para aceptar solicitudes de cualquier dirección IP.
• Modifica las reglas de firewall para el tráfico de WS-Management (solo HTTP)

Llegados a este punto podemos decir que el ordenador está preparado para conexiones remotas, pero en la práctica también puede ser necesario ejecutar el comando Enable-PSRemoting.

¡Todo! La configuración de la computadora está completa y puede conectarse a ella. Ahora unas palabras sobre cómo conectarse. La forma más sencilla es utilizar el cmdlet. Enter-PSSession , seguido del nombre del ordenador al que desea conectarse, por ejemplo:

Ingrese-PSSession NameOfRemoteComputer

Con este método, podrá conectarse si las computadoras son miembros de un dominio o si hay un usuario en la computadora remota que es miembro del grupo "Administradores" con el mismo nombre de usuario y contraseña que el usuario actual.

Por cierto, de forma predeterminada, sólo los miembros del grupo "Administradores" pueden conectarse a una computadora remota (hablaremos sobre cómo solucionar este problema en otro momento).

Pero, ¿qué pasa si las computadoras no están en un dominio (o en dominios diferentes) y los inicios de sesión y contraseñas del administrador son diferentes?

En este caso, el cmdlet Enter-PSSession debe usarse con el parámetro-Credencial , que le permite ingresar las credenciales necesarias para la conexión. Pero antes de conectarse a su computadora, debe agregarla a la lista de Hosts confiables. Esto se hace con el comando:

Set-Item WSMan:\localhost\Client\TrustedHosts -valor NombreEquipo

donde NombreEquipo — el nombre de la computadora a la que nos conectaremos. Puede especificar tanto el nombre de la computadora como su dirección IP, sin embargo, debe recordar que lo que ingrese aquí deberá usarse más adelante para la conexión, es decir. Si especifica una dirección IP, no podrá conectarse a la computadora especificando su nombre; deberá especificar la dirección IP y viceversa.