Remoting and Automation

Managing 200 Servers from My Desk

Five years ago, applying a configuration change meant: RDP to each server, open PowerShell, run commands, document results, repeat 200 times. A full day's work for a simple change.

Today, with PowerShell remoting:

Invoke-Command -ComputerName (Get-Content servers.txt) -ScriptBlock {
    Set-Service -Name "wuauserv" -StartupType Automatic
    Start-Service -Name "wuauserv"
} | Select-Object PSComputerName, Status

Five minutes. Same change. 200 servers. That's the power of remoting.

PowerShell Remoting Basics

PowerShell remoting uses WinRM (Windows Remote Management) or SSH to execute commands on remote computers.

Enabling WinRM

On Windows Server, WinRM is usually enabled. On client:

# Run as Administrator
Enable-PSRemoting -Force

# Check WinRM service
Get-Service WinRM

# Test remoting (to itself)
Test-WSMan localhost

One-to-One Remoting: Enter-PSSession

Interactive session with remote computer:

# Connect to remote computer
Enter-PSSession -ComputerName SERVER01

# You're now on SERVER01
[SERVER01]: PS C:\> Get-Service
[SERVER01]: PS C:\> Get-Process

# Exit remote session
[SERVER01]: PS C:\> Exit-PSSession

One-to-Many Remoting: Invoke-Command

Execute commands on multiple computers:

# Single computer
Invoke-Command -ComputerName SERVER01 -ScriptBlock {
    Get-Service -Name "wuauserv"
}

# Multiple computers
$servers = @("SERVER01", "SERVER02", "SERVER03")
Invoke-Command -ComputerName $servers -ScriptBlock {
    Get-Service | Where-Object {$_.Status -eq 'Running'}
} | Select-Object PSComputerName, Name, Status

Using Credentials

# Prompt for credentials
$cred = Get-Credential

# Use credentials
Invoke-Command -ComputerName SERVER01 -Credential $cred -ScriptBlock {
    Get-Process
}

# Save credentials securely
$cred | Export-Clixml -Path credentials.xml

# Import credentials
$cred = Import-Clixml -Path credentials.xml

PowerShell Sessions

Persistent connections for multiple commands.

Creating Sessions

# Create session
$session = New-PSSession -ComputerName SERVER01

# Use session
Invoke-Command -Session $session -ScriptBlock { Get-Service }
Invoke-Command -Session $session -ScriptBlock { Get-Process }

# Close session
Remove-PSSession $session

Multiple Sessions

# Create sessions to multiple servers
$servers = @("SERVER01", "SERVER02", "SERVER03")
$sessions = New-PSSession -ComputerName $servers

# Run command on all sessions
Invoke-Command -Session $sessions -ScriptBlock {
    Get-Service -Name "wuauserv"
}

# Close all sessions
$sessions | Remove-PSSession

Session Benefits

• Faster: Reuse connection

• State preservation: Variables persist between commands

• Efficiency: One connection, multiple commands

SSH Remoting (PowerShell 7+)

Cross-platform remoting using SSH.

Setup SSH

# Connect via SSH
Enter-PSSession -HostName user@linux-server -SSHTransport

# Invoke command via SSH
Invoke-Command -HostName user@linux-server -ScriptBlock {
    Get-Process
} -SSHTransport

Passing Arguments

Using -ArgumentList

$serviceName = "wuauserv"

Invoke-Command -ComputerName SERVER01 -ScriptBlock {
    param($Name)
    Get-Service -Name $Name
} -ArgumentList $serviceName

Multiple Arguments

Invoke-Command -ComputerName SERVER01 -ScriptBlock {
    param($ServiceName, $Action)
    
    if ($Action -eq "Start") {
        Start-Service -Name $ServiceName
    } elseif ($Action -eq "Stop") {
        Stop-Service -Name $ServiceName
    }
} -ArgumentList "wuauserv", "Start"

Using $using:

$serviceName = "wuauserv"

Invoke-Command -ComputerName SERVER01 -ScriptBlock {
    Get-Service -Name $using:serviceName
}

Background Jobs

Run commands asynchronously.

Starting Jobs

# Start job
$job = Start-Job -ScriptBlock {
    Get-Service | Where-Object {$_.Status -eq 'Running'}
}

# Check job status
Get-Job

# Wait for job
$job | Wait-Job

# Get results
$results = $job | Receive-Job

# Remove job
$job | Remove-Job

Remote Jobs

# Start remote job
$job = Invoke-Command -ComputerName SERVER01 -ScriptBlock {
    Start-Sleep -Seconds 30
    Get-Service
} -AsJob

# Multiple remote jobs
$servers = @("SERVER01", "SERVER02", "SERVER03")
$jobs = Invoke-Command -ComputerName $servers -ScriptBlock {
    Test-Connection -ComputerName "google.com" -Count 5
} -AsJob

# Wait for all jobs
$jobs | Wait-Job

# Get all results
$results = $jobs | Receive-Job

# Cleanup
$jobs | Remove-Job

Real-World Examples

Health Check Across Servers

$servers = Get-Content "servers.txt"

$healthCheck = Invoke-Command -ComputerName $servers -ScriptBlock {
    $os = Get-CimInstance -ClassName Win32_OperatingSystem
    $disk = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DeviceID='C:'"
    
    [PSCustomObject]@{
        Server = $env:COMPUTERNAME
        Uptime = ((Get-Date) - $os.LastBootUpTime).ToString("dd\.hh\:mm")
        FreeDiskGB = [math]::Round($disk.FreeSpace / 1GB, 2)
        FreeMemoryGB = [math]::Round($os.FreePhysicalMemory / 1MB, 2)
        RunningServices = (Get-Service | Where-Object {$_.Status -eq 'Running'}).Count
    }
} -ErrorAction SilentlyContinue |
    Select-Object Server, Uptime, FreeDiskGB, FreeMemoryGB, RunningServices

$healthCheck | Export-Csv "health-check.csv" -NoTypeInformation
$healthCheck | Format-Table

Parallel Deployment

function Deploy-Application {
    param(
        [string[]]$ComputerName,
        [string]$PackagePath
    )
    
    $sessions = New-PSSession -ComputerName $ComputerName
    
    try {
        # Copy package to all servers
        foreach ($session in $sessions) {
            Copy-Item -Path $PackagePath -Destination "C:\Deploy\" -ToSession $session -Force
        }
        
        # Install on all servers in parallel
        $results = Invoke-Command -Session $sessions -ScriptBlock {
            param($Package)
            
            try {
                Start-Process -FilePath $Package -ArgumentList "/silent" -Wait
                "Success"
            }
            catch {
                "Failed: $_"
            }
        } -ArgumentList (Split-Path $PackagePath -Leaf)
        
        return $results
    }
    finally {
        $sessions | Remove-PSSession
    }
}

# Usage
$servers = @("WEB01", "WEB02", "WEB03")
Deploy-Application -ComputerName $servers -PackagePath "C:\Packages\app.msi"

Log Collection

$servers = Get-Content "servers.txt"
$outputPath = "C:\CollectedLogs"

New-Item -Path $outputPath -ItemType Directory -Force

Invoke-Command -ComputerName $servers -ScriptBlock {
    Get-EventLog -LogName Application -Newest 100 -EntryType Error
} | ForEach-Object {
    $serverName = $_.PSComputerName
    $logFile = Join-Path $outputPath "$serverName-errors.csv"
    
    $_ | Select-Object TimeGenerated, Source, Message | 
        Export-Csv -Path $logFile -NoTypeInformation -Append
}

Security Considerations

Using CredSSP (Carefully)

# Enable CredSSP (for double-hop scenarios)
Enable-WSManCredSSP -Role Client -DelegateComputer "SERVER01"

# On SERVER01 (as admin):
Enable-WSManCredSSP -Role Server

# Use CredSSP
Invoke-Command -ComputerName SERVER01 -Authentication Credssp -Credential $cred -ScriptBlock {
    # Can now access other resources
}

Just Enough Administration (JEA)

Restrict remote users to specific commands.

Common Pitfalls

1. Firewall Blocking WinRM

Problem: Can't connect remotely Solution: Ensure WinRM ports (5985, 5986) are open

2. The Double-Hop Problem

Problem: Can't access resources from remote session Solution: Use CredSSP or pass credentials explicitly

3. Forgetting to Remove Sessions/Jobs

Problem: Resource leaks Solution: Always cleanup sessions and jobs

try {
    $session = New-PSSession -ComputerName SERVER01
    # Use session
}
finally {
    $session | Remove-PSSession
}

Key Takeaways

• Enter-PSSession: Interactive remote shell

• Invoke-Command: Execute on multiple computers

• New-PSSession: Persistent connections

• Jobs: Asynchronous execution

• SSH: Cross-platform remoting

• Always cleanup: Remove sessions and jobs

What You've Learned

✅ PowerShell remoting with WinRM and SSH ✅ Interactive and batch remote execution ✅ Using sessions for efficiency ✅ Background jobs for async operations ✅ Real-world remote management patterns ✅ Security and troubleshooting

Next Steps

Now you can manage systems remotely. Let's integrate with external services. In Working with APIs and Web Data, you'll learn:

• REST API calls with Invoke-RestMethod

• Authentication and headers

• JSON and XML processing

• Real-world API integrations

Connect PowerShell to the wider world.

---

Ready to work with APIs? Continue to Working with APIs and Web Data →