Quick Learn – Keep PowerShell Cmdlets Powerful

I’ve seen what I’m about to show you done repeatedly in Windows PowerShell. With that thought in my mind, I’ve decided it’s time to officially write about it. The first time I noticed someone doing it,… ugh, it was me. I did, however, write a correction to my team so they knew I was aware of my error, and as a hope they wouldn’t repeat it.

Those doing this are typically new to PowerShell, but if you aren’t careful and don’t fully understand the capabilities of the cmdlets you use, then it’s possible you might make this mistake, too. What am I talking about? I’m talking about Invoke-Command (alias: icm) and an improper way that it’s sometimes used.

Invoke-Command’s purpose is to run a command, or commands, on remote computers and return the results back to the local computer. That said, it can be used on the local computer, as well; however, this is usually only necessary to check if PowerShell Remoting is working on the local computer. While I don’t normally do this in my examples, I’m piping my result of this example to Format-Table -AutoSize, once they’re returned from the remote computer. This is so it’ll display better on this webpage.

PS> Invoke-Command -Computer DC01 -ScriptBlock {Get-PSDrive -PSProvider FileSystem} | Format-Table -AutoSize

Name Used (GB) Free (GB) Provider Root              CurrentLocation PSComputerName
---- --------- --------- -------- ----              --------------- --------------
A                                 A:\                               DC01
C        12.91     26.75          C:\  Users\tommymaynard\Documents DC01
D                                 D:\                               DC01

This example of Invoke-Command connected to the remote computer DC01, ran a filtered Get-PSDrive command, returned the results to my computer, and then were formatted by the Format-Table cmdlet.

Now, let’s say we have… 23 computer names stored in the variable $Comps and we want to run the command we used above, against each computer. What so many people seem to do is wrap Invoke-Command in a Foreach construct (think: loop). I’m guessing, because I’ve made the error myself, that it’s because someone learned Foreach first. I want to note that I discovered my error on my own, and only moments later. It didn’t wake me at 2 a.m. in a cold sweat after two months.

Here’s how not to do this, and again, $Comps is holding the names of 23 computers.

PS> Foreach ($Computer in $Comps) {
>>> Invoke-Command -ComputerName $Computer -ScriptBlock {Get-PSDrive -PSProvider FileSystem}
>>> }

Name           Used (GB)     Free (GB) Provider      Root                                CurrentLocation PSComputerName
----           ---------     --------- --------      ----                                --------------- --------------
C                  20.47         59.18               C:\                                 ...rd\Documents DC02
D                                                    D:\                                                 DC02
A                                                    A:\                                                 WEB01
C                  50.36         29.30               C:\                                 ...rd\Documents WEB01
D                                                    D:\                                                 WEB01
A                                                    A:\                                                 SQL01
C                  53.59         26.06               C:\                                 ...rd\Documents SQL01
D                                                    D:\                                                 SQL01
... # Not all results included.

What we’ve done here is forced Invoke-Command to run against only one computer at a time. During each iteration of the Foreach loop, Invoke-Command runs against the computer name currently stored in $Computer. This variable is updated to the next computer name in the variable at the start of each loop. It’s like this: connect to DC02 and run the command. Now, connect to WEB01 and run the command. Are you done, Invoke-Command? Okay then, now Foreach says to run the same command against the computer SQL01. That’s not how this cmdlet was designed to be used.

Before we go any further, I wrapped this command inside the Measure-Command cmdlet to determine how long it took my system to run this against the computers in $Comps. It took nearly 30 seconds. While that’s not an eternity, we’re only talking about 23 computers, and we’re only talking about a single command.

PS> Measure-Command -Expression {Foreach ($Computer in $Comps) {
>>> Invoke-Command -ComputerName $Computer -ScriptBlock {Get-PSDrive -PSProvider FileSystem}
>>> }
>>> }

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 27
Milliseconds      : 513
Ticks             : 275132689
TotalDays         : 0.000318440612268519
TotalHours        : 0.00764257469444444
TotalMinutes      : 0.458554481666667
TotalSeconds      : 27.5132689
TotalMilliseconds : 27513.2689

Now, let’s set this command up the proper way. The -ComputerName parameter of Invoke-Command can take a collection of computers. It should be said that many cmdlets can take more than one computer as a value to their -ComputerName parameter. The difference, is that Invoke-Command can run against all of the 23 computers at the same time. In fact, the default throttle limit — the number of computers in which the command will run against simultaneously — is 32. It can be changed by including the -ThrottleLimit parameter, such as -ThrottleLimit 50 or -ThrottleLimit 15.

Now, here’s how this command should’ve been written.

PS> Invoke-Command -ComputerName $Comps -ScriptBlock {Get-PSDrive -PSProvider FileSystem}

Name           Used (GB)     Free (GB) Provider      Root                                CurrentLocation PSComputerName
----           ---------     --------- --------      ----                                --------------- --------------
A                                                    A:\                                                 DC02
A                                                    A:\                                                 WEB01
C                  41.72         37.93               C:\                                 ...rd\Documents WEB01
C                  41.13         38.52               C:\                                 ...rd\Documents DC02
D                                                    D:\                                                 DC02
D                                                    D:\                                                 WEB01
A                                                    A:\                                                 SQL01
C                  46.75         32.91               C:\                                 ...rd\Documents SQL01
D                                                    D:\                                                 SQL01
... # Not all results included.

I measured this command five times, and the average of those five runs was only 2.8 seconds. Remember, the Foreach loop took almost 30 seconds to get the same results. This is due to the fact that, again, Invoke-Command will work with the remote computers simultaneously (when it’s not inside a Foreach). There’s never any waiting to run the command on any additional computers unless there’s more computers than the value of the ThrottleLimit.

Please keep the topic in this post in mind, as it’s possible to momentarily forget this feature just long enough to wrap the Invoke-Command cmdlet in a Foreach, or looping, construct.

2 thoughts on “Quick Learn – Keep PowerShell Cmdlets Powerful

  1. Akos Batorfi

    Hi Tommy, great post. It made me rethink a post I made on my own blog in reference to a forumtopic on powershell.org. Someone wanted an overview of reboots from the eventlog, and I reworked his script with invoke-command in a foreach loop, using the -AsJob parameter. But then of course you need to check whether all jobs have been received, so that takes a bit more code to write.

    I was curious to see which one was faster, but I just used 5 VM’s to test, but feeding the serverlist to invoke-command seemed a bit faster with the tiny sample size I had. It’s certainly quicker to type, that’s for sure 😉

    Reply
  2. tommymaynard Post author

    Thanks for your comments, Akos. I appreciate that it was helpful; that’s great to know.

    Reply

Leave a Reply

Your email address will not be published.