{"id":2798,"date":"2013-09-29T00:01:00","date_gmt":"2013-09-29T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2013\/09\/29\/weekend-scripter-max-out-powershell-in-a-little-bit-of-timepart-2\/"},"modified":"2013-09-29T00:01:00","modified_gmt":"2013-09-29T00:01:00","slug":"weekend-scripter-max-out-powershell-in-a-little-bit-of-timepart-2","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/weekend-scripter-max-out-powershell-in-a-little-bit-of-timepart-2\/","title":{"rendered":"Weekend Scripter: Max Out PowerShell in a Little Bit of Time—Part 2"},"content":{"rendered":"

Summary<\/strong>: Microsoft PFE, Jason Walker, talks about improving performance of Windows PowerShell by using runspaces.\nMicrosoft Scripting Guy, Ed Wilson, is here. Jason Walker<\/a> is back with us today for the conclusion of his two-part weekend series. Be sure to read yesterday’s post before you read today’s:<\/p>\n

Weekend Scripter: Max Out PowerShell in a Little Bit of Time—Part 1<\/a>\nAnd now, Jason…\nYesterday we explored using Windows PowerShell remoting (Invoke-Command<\/strong>) and Windows PowerShell jobs, and we ended with a teaser about runspaces. Today let’s take a closer look at runspaces.\nGuest blogger, Boe Prox previously wrote about using runspaces: Expert Commentary: 2012 Scripting Games Advanced Event 2<\/a>. In his post, he links to Windows PowerShell MVP, Dr. Tobias Weltner’s, video, which explains some of the advantages of using runspaces. I recommend that you check it out.\nThe basic steps to leverage runspaces are as follows:<\/p>\n

    \n
  1. Create the runspace pool.<\/li>\n
  2. Open the runspace pool.<\/li>\n
  3. Create a Windows PowerShell object to the run commands.<\/li>\n
  4. Specify which runspace the Windows PowerShell object will use.<\/li>\n
  5. Add the commands.<\/li>\n
  6. Invoke the command.<\/li>\n
  7. Get the results from the command.<\/li>\n
  8. Clean up the Windows PowerShell object and runspace pool.<\/li>\n<\/ol>\n

    Here are the steps in Windows PowerShell:<\/p>\n

    #Create the runspace pool<\/p>\n

    $RunspacePool = [RunspaceFactory]::CreateRunspacePool()<\/p>\n

    #Open the runspace pool<\/p>\n

    $RunspacePool.Open()<\/p>\n

    #Create PowerShell object<\/p>\n

    $Powershell = [PowerShell]::Create()<\/p>\n

    #Specify the runspace to use<\/p>\n

    $Powershell.RunspacePool = $RunspacePool<\/p>\n

    #Add the command to run<\/p>\n

    $Powershell.AddCommand(“Get-Process”)<\/p>\n

    #Invoke the command<\/p>\n

    $Runspace= $PowerShell.BeginInvoke()<\/p>\n

    #Get the results of the command<\/p>\n

    $PowerShell.EndInvoke($Runspace)<\/p>\n

    #Clean up<\/p>\n

    $PowerShell.Dispose()<\/p>\n

    $RunspacePool.Close()\nFor us to run this asynchronously against multiple servers, we have to make a few modifications to the example. To demonstrate, I will explain how this is done by using the Get-WinEvent<\/strong> example from yesterday.<\/p>\n

      \n
    1. Define a list of servers to run the cmdlet against:<\/li>\n<\/ol>\n

      $Computers = “mail01”,”mail02”,”mbx01”,”mbx02”,”mbx03”<\/p>\n

        \n
      1. Create an empty array that we will use later in the script:<\/li>\n<\/ol>\n

        $RunspaceCollection = @()<\/p>\n

          \n
        1. Call the CreateRunspacePool <\/strong>method and specify a minimum and maximum amount of runspaces that are allowed to be open. These parameters are explained in the Windows Dev Center: RunspaceFactory.CreateRunspacePool Method (Int32, Int32, PSHost)<\/a>.<\/li>\n<\/ol>\n

          The following example creates a runspace pool with a minimum of 1 runspace and a maximum of 5:<\/p>\n

          $RunspacePool = [RunspaceFactory]::CreateRunspacePool(1,5)<\/p>\n

            \n
          1. Define a script block (the cmdlet and arguments we want to run) that we will supply to the Windows PowerShell object:<\/li>\n<\/ol>\n

            $ScriptBlock = {<\/p>\n

             Param($Computer)<\/p>\n

            Get-Process -ComputerName $Computer -FilterHashtable @{Logname=’System’;Id=1074} -MaxEvents 10 }<\/p>\n

              \n
            1. Because we want to run Get-WinEvent<\/strong> asynchronously across multiple servers, we need to create multiple Windows PowerShell objects. Then we will add the script block that we created and the unique computer name to that Windows PowerShell object. A Foreach<\/strong> loop will make quick work of this task:<\/li>\n<\/ol>\n

              Foreach($Computer in $Computers){<\/p>\n

               #Create a PowerShell object to run add the script and argument.<\/p>\n

                $Powershell = [PowerShell]::Create().AddScript($ScriptBlock).AddArgument($Computer)<\/p>\n

               <\/p>\n

                #Specify runspace to use<\/p>\n

                $Powershell.RunspacePool = $RunspacePool<\/p>\n

               <\/p>\n

                #Create Runspace collection<\/p>\n

                [Collections.Arraylist]$RunspaceCollection += New-Object -TypeName PSObject -Property @{<\/p>\n

                 Runspace = $PowerShell.BeginInvoke()<\/p>\n

                 PowerShell = $PowerShell  <\/p>\n

                }<\/p>\n

               <\/p>\n

              }<\/p>\n

                \n
              1. You’ll notice that we also added the Windows PowerShell object to the runspace pool. We then created a PSObject<\/strong> that contains the Windows PowerShell object, and we defined and invoked the runspace. To get the results of the runspace, we have to call the EndInvoke<\/strong> method from the Windows PowerShell object that contains the runspace. This PSObject<\/strong> acts as a collection that keeps everything nicely packaged.<\/li>\n
              2. The only thing left to do is check for the runspace to be completed. When it is complete, we retrieve the results. I like to use a While<\/strong> loop for this type of task:<\/li>\n<\/ol>\n

                While($RunspaceCollection){<\/p>\n

                 Foreach($Runspace in $RunspaceCollection.ToArray()){<\/p>\n

                  If($Runspace.Runspace.IsCompleted){<\/p>\n

                   $Runspace.PowerShell.EndInvoke($Runspace.Runspace)<\/p>\n

                   $Runspace.PowerShell.Dispose()<\/p>\n

                   $RunspaceCollection.Remove($Runspace)<\/p>\n

                  }<\/p>\n

                 }<\/p>\n

                 <\/p>\n

                }\nThe EndInvoke<\/strong> method is used to retrieve the results from the completed runspace. Finally, we clean up. That’s all there is to multithread commands in Windows PowerShell using runspaces.\nYou can download a more complete solution from the TechNet Gallery: Get-AsyncEvent multi thread Get-WinEvent using runspaces<\/a>.<\/p>\n

                Note<\/strong>   Get-AsyncEvent<\/strong> is written as a function, so you need to dot source the .ps1 file before you can run the function inside it. For more information, see How Do I Use a Windows PowerShell Script Containing Functions?<\/a>\n~Jason\nThank you, Jason, for this weekend’s blog posts and for sharing your time and knowledge.\nI invite you to follow me on Twitter<\/a> and Facebook<\/a>. If you have any questions, send email to me at scripter@microsoft.com<\/a>, or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.\nEd Wilson, Microsoft Scripting Guy<\/strong> <\/p>\n","protected":false},"excerpt":{"rendered":"

                Summary: Microsoft PFE, Jason Walker, talks about improving performance of Windows PowerShell by using runspaces. Microsoft Scripting Guy, Ed Wilson, is here. Jason Walker is back with us today for the conclusion of his two-part weekend series. Be sure to read yesterday’s post before you read today’s: Weekend Scripter: Max Out PowerShell in a Little […]<\/p>\n","protected":false},"author":596,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[56,338,60,3,4,61,45],"class_list":["post-2798","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-guest-blogger","tag-jason-walker","tag-performance","tag-scripting-guy","tag-scripting-techniques","tag-weekend-scripter","tag-windows-powershell"],"acf":[],"blog_post_summary":"

                Summary: Microsoft PFE, Jason Walker, talks about improving performance of Windows PowerShell by using runspaces. Microsoft Scripting Guy, Ed Wilson, is here. Jason Walker is back with us today for the conclusion of his two-part weekend series. Be sure to read yesterday’s post before you read today’s: Weekend Scripter: Max Out PowerShell in a Little […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/2798","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/596"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=2798"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/2798\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=2798"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=2798"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=2798"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}