A Systems Engineer’s Tale: Simplifying Remote Commands with PowerShell

As a systems engineer, one of your daily challenges is running commands across a network of machines. Maybe it’s updating Group Policy with gpupdate /force, restarting a service, or pushing out a quick configuration tweak. Whatever the task, the prospect of executing it one machine at a time can make your to-do list feel insurmountable.

Enter PowerShell, the Swiss Army knife for IT professionals. With the right script, you can execute commands remotely across all systems in your network with ease. Today, let’s explore how to take a task like updating Group Policy—or any other repetitive command—and turn it into a quick, automated process.

The Problem: Running Commands on Multiple Systems

Suppose you’ve been asked to ensure all systems in your network update their Group Policy settings immediately. This means executing gpupdate /force on every machine, from desktops to servers. Doing this manually is not just tedious—it’s an open invitation for errors.

But what if the task wasn’t limited to gpupdate /force? What if it were something like:

• Restarting a specific service across all machines?
• Running a quick diagnostic command?

The underlying challenge is the same: running a command on multiple remote systems in an efficient, consistent, and error-proof way.

The PowerShell Solution

PowerShell’s ability to execute remote commands is a game-changer. Here’s a simple yet powerful script that lets you run any command—like gpupdate /force—across multiple systems with minimal effort. We’ve also included enhanced error handling to make troubleshooting easier.

---

The Script

#!/usr/bin/env pwsh
# A simple PowerShell script to run any command on multiple remote systems.

# List of computer names
$computers = @(
    "Workstation01",
    "Server02",
    "HRLaptop03",
    "MarketingPC04",
    "FinanceServer05"
)

# Command to execute on each system
$remoteCommand = {
    param($customCommand)
    try {
        # Run the command with error handling
        Invoke-Expression -Command $customCommand -ErrorAction Stop
        Write-Output "Command executed successfully on $($env:COMPUTERNAME)"
    } catch {
        Write-Error "Failed to execute the command on $($env:COMPUTERNAME): $_"
    }
}

# Specify the command you want to run
$commandToRun = "gpupdate /force"

# Run the command on each system
$jobs = @()
foreach ($computer in $computers) {
    $jobs += Invoke-Command -ComputerName $computer -ScriptBlock $remoteCommand -ArgumentList $commandToRun -AsJob -JobName "RemoteCommand_$computer"
}

Write-Host "Waiting for all jobs to complete..."
$jobs | Wait-Job

# Collect results
$successes = @()
$errors = @()

foreach ($job in $jobs) {
    try {
        $result = Receive-Job -Job $job -ErrorAction Stop
        $successes += $result
    } catch {
        $errors += $_
    }
}

# Display results
if ($successes.Count -gt 0) {
    Write-Host "Successfully executed on the following systems:" -ForegroundColor Green
    $successes | ForEach-Object { Write-Host $_ -ForegroundColor Green }
}

if ($errors.Count -gt 0) {
    Write-Host "Errors occurred on the following systems:" -ForegroundColor Red
    $errors | ForEach-Object { Write-Host $_ -ForegroundColor Red }
}

How It Works

1. Define the Systems

   • Start with a list of system names in the $computers array. These can be workstations, servers, or any other devices you need to manage.

2. Specify the Command

   • Replace gpupdate /force in $commandToRun with any command you need to execute. The script dynamically passes this command to each system in the list.

3. Enhanced Error Handling

   • The script now includes the -ErrorAction Stop flag in the Invoke-Expression statement. This ensures that non-terminating errors—like those generated by certain commands—are caught and handled properly in the catch block.

4. Remote Execution

   • The Invoke-Command cmdlet runs the specified command on each remote system using PowerShell’s remoting capabilities. By adding the -AsJob parameter, the script processes all systems in parallel, saving time.

5. Collect Results

   • The script collects success and error messages, giving you a clear summary of which systems completed the task and which encountered issues.

A Versatile Tool for Any Command

This script isn’t limited to Group Policy updates. Here are a few more use cases:

• Restarting a Service: Replace gpupdate /force with Restart-Service -Name SomeService.
• Checking System Uptime: Use Get-CimInstance -ClassName Win32_OperatingSystem | Select-Object LastBootUpTime.

Why It Matters

As a systems engineer, your time is valuable. Automating repetitive tasks like running remote commands doesn’t just save time—it also reduces errors and ensures consistency. PowerShell’s versatility allows you to adapt scripts for almost any scenario, turning even the most tedious tasks into efficient processes.

By using this script, you’re not just running commands—you’re scaling your efforts across an entire network with precision and speed.

Final Thoughts

Managing a large network can feel overwhelming, but tools like PowerShell empower systems engineers to work smarter, not harder. Whether it’s updating Group Policy, restarting services, or running diagnostics, automation is your secret weapon.

So, the next time you’re faced with a list of machines and a repetitive task, don’t reach for caffeine—reach for PowerShell. With the right script, you’ll tackle the challenge like a pro and still have time to enjoy your favorite caffeinated beverage while it’s cold. 🥤