Remotação PowerShell: Execute Comandos Remotos Como um Profissional

Suponha que você tenha aprendido a executar comandos localmente; isso já é um passo importante para dominar a execução remota. O PowerShell Remoting permite que administradores executem comandos e scripts em sistemas remotos.

Este guia demonstra como configurar e usar o PowerShell Remoting em um ambiente Active Directory (AD). Imagine criar arquivos, executar scripts ou verificar configurações remotamente sem sair da sua mesa.

Configure e use o PowerShell Remoting para executar scripts em sistemas remotos com confiança!

Configurando o PowerShell Remoting para um Usuário Padrão

Antes de aproveitar ao máximo o PowerShell Remoting, você deve garantir que as permissões necessárias estão em vigor. Executar comandos ou scripts remotamente depende da configuração adequada, especialmente em ambientes Active Directory onde a segurança é uma prioridade.

Comece tentando se conectar a um servidor remoto (SRV2) usando Invoke-Command. O seguinte comando executa um bloco de script no computador remoto:

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

Se a autenticação falhar, isso geralmente significa que o usuário não possui as permissões necessárias.

Por padrão, usuários não administrativos devem ser membros do grupo Remote Management Users do computador remoto.

Verifique a filiação ao grupo:

Get-LocalGroupMember -Group 'Remote Management Users'

Se o usuário não estiver listado, adicione-o:

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

Agora, tente novamente o comando Invoke-Command para confirmar a conectividade.

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

Executando um Script Básico Remotamente

Uma vez configurado o PowerShell Remoting, você pode executar comandos no computador remoto. Essa capacidade desbloqueia o potencial para automatizar tarefas, coletar dados e solucionar problemas remotamente.

Para ver como o PowerShell remoting funciona, crie um arquivo de texto na máquina remota e depois verifique se a ação foi bem-sucedida.

Defina e execute o scriptblock:

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

Verifique se o arquivo foi criado com o seguinte comando:

Este comando conecta ao computador remoto SRV2, obtém informações sobre o arquivo somefile.txt e exibe apenas o nome e horário de criação.

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

Executando Scripts Locais em Computadores Remotos

Talvez um único comando não seja suficiente e você precise executar um script completo armazenado localmente em sua máquina. Se for o caso, o PowerShell Remoting permite enviar rapidamente um script local para um computador remoto e executá-lo como se estivesse fisicamente presente.

Para demonstrar a execução de scripts em um computador remoto, crie um script curto localmente e execute-o em uma máquina remota para automatizar ações ou tarefas de limpeza.

Crie um script localmente com este comando onde:

• $scriptContents armazena o script em uma string de várias linhas usando uma aqui-string (@' ... '@), que é útil para manter o script legível e organizado.
• Set-Content escreve o conteúdo de $scriptContents em um arquivo chamado *RunThisRemotely.ps1* no diretório atual.

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

Confirme o conteúdo do script:

Get-Content RunThisRemotely.ps1

Execute o script remotamente:

Invoke-Command -ComputerName SRV2 -FilePath RunThisRemotely.ps1

Agora, verifique se o arquivo de teste foi excluído:

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

Verificando Chaves do Registro Local com um Bloco de Script

O PowerShell Remoting suporta a passagem de variáveis entre sessões locais e remotas, permitindo scripts flexíveis e reutilizáveis. Mas para começar, vamos nos concentrar em verificar chaves do registro localmente.

Armazene vários caminhos do registro que podem ser verificados mais tarde para ver se existem no sistema:

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

Adicione isso ao script para definir um bloco de script ****($localScriptBlock) que é executado localmente no computador. O bloco de script verifica se caminhos específicos do registro existem na máquina local e fornece feedback para cada caminho.

# 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)."
        }
    }
}

Execute o bloco de script e veja o que acontece.

Invoke-Command -ScriptBlock $localScriptBlock

Passando Variáveis Locais para Sessões Remotas

Seja trabalhando com arrays, strings ou objetos, você pode passar dados para comandos remotos de duas maneiras:

• $using – Integra variáveis locais diretamente no bloco de script.
• ArgumentList – Passa explicitamente variáveis para o bloco para uso.

Continue lendo para explorar os dois métodos ($using ou ArgumentList) para alcançar esse objetivo.

Usando a Palavra-chave $using (Abordagem Preferida)

Depois de confirmar que as chaves do registro existem, o próximo passo é ler esse array localmente e usá-lo no script em um computador remoto. Uma maneira de conseguir isso é usando a palavra-chave $using para referenciar variáveis locais em sessões remotas.

Crie este script para ser executado no computador remoto e verificar os caminhos do registro especificados. Este script fornece feedback sobre se cada caminho existe ou não.

Com essa abordagem, basta adicionar o prefixo $using a uma variável local. Essa ação diz ao PowerShell para referenciar a variável local registryKeyPaths antes de executar o código no computador remoto.

$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)."
        }
    }
}

Em seguida, você pode invocar o comando remoto para executar o código na máquina remota:

Invoke-Command -ScriptBlock $remoteScriptBlock -ComputerName SRV2

Parece que as chaves do registro também existem lá.

Usando o Parâmetro ArgumentList

Além da palavra-chave $using, outra opção é o parâmetro ArgumentList para enviar variáveis para a sessão remota.

Crie um script (semelhante a um com a palavra-chave $using) que usa o array $args para acessar os valores passados via o parâmetro ArgumentList.

Neste método, você especifica uma ou mais variáveis a serem enviadas para a sessão remota através do parâmetro ArgumentList. Dentro do bloco de script, substitua a variável local por $args, que o PowerShell preencherá automaticamente com os valores passados atravé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)."
        }
    }
}

Agora, execute o script com o seguinte comando:

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

Ambos os métodos produzirão a mesma saída, confirmando que as chaves de registro existem no computador remoto.

Seguindo estes passos, você pode configurar e utilizar efetivamente o PowerShell Remoting para executar comandos e scripts em sistemas remotos.

Conclusão

Neste tutorial, você aprendeu como configurar o PowerShell Remoting em um ambiente do Active Directory, executar comandos e scripts em sistemas remotos e passar variáveis de forma eficaz. Essas habilidades fundamentais são essenciais para automatizar tarefas administrativas e gerenciar sistemas de maneira eficiente.

Agora que você cobriu o básico, considere explorar tópicos mais avançados. Pesquise sobre sessões persistentes do PowerShell, tratamento de erros remotos ou criação de scripts reutilizáveis para lidar com operações em massa.

As possibilidades com o PowerShell Remoting são infinitas—então comece a experimentar e torne seus fluxos de trabalho mais eficientes!