Powershell: Exécuter plusieurs tâches dans Parralel et afficher les résultats de streaming à partir des jobs d'arrière-plan

Aperçu

À la recherche d'appeler un script Powershell qui prend un argument, chaque tâche s'exécute en arrière-plan, et me montre la sortie détaillée.

Problème, je suis en cours d'exécution dans

Le script semble fonctionner, mais je veux vérifier à coup sûr en streaming les résultats des travaux en arrière-plan, car ils sont en cours d'exécution.

Code

###StartServerUpdates.ps1 Script###

#get list of servers to update from text file and store in array
$servers=get-content c:\serverstoupdate.txt

#run all jobs, using multi-threading, in background
ForEach($server in $servers){
  Start-Job -FilePath c:\cefcu_it\psscripts\PSPatch.ps1 -ArgumentList $server
}

#Wait for all jobs
Get-Job | Wait-Job

#Get all job results
Get-Job | Receive-Job

Ce que je suis actuellement en train de voir:

Id              Name            State      HasMoreData     Location             Command                  
--              ----            -----      -----------     --------             -------                  
23              Job23           Running    True            localhost            #patch server ...        
25              Job25           Running    True            localhost            #patch server ...

Ce que je veux voir:

Searching for approved updates ...

Update Found:  Security Update for Windows Server 2003 (KB2807986)
Update Found:  Windows Malicious Software Removal Tool - March 2013 (KB890830)

Download complete.  Installing updates ...

The system must be rebooted to complete installation.
cscript exited on "myServer" with error code 3.
Reboot required...
Waiting for server to reboot (35)

Searching for approved updates ...

There are no updates to install.
cscript exited on "myServer" with error code 2.
Servername "myServer" is fully patched after 2 loops

Je veux être en mesure de voir la sortie ou le magasin que quelque part afin que je puisse consulter pour être sûr que le script s'est exécuté et de voir quels sont les serveurs redémarré, etc.

Conclusion:

Dans le passé, j'ai exécuté le script et il est allé par le biais de la mise à jour des serveurs un par un et m'a donné la sortie que je voulais, mais quand j'ai commencé à faire plus de serveurs - cette tâche a pris trop de temps, c'est pourquoi je suis en train d'utiliser les travaux de fond avec "Start-Job".

Quelqu'un peut m'aider à comprendre cela, s'il vous plaît?

source d'informationauteur talbert.houle

  1. 4

    Vous pouvez prendre un coup d'oeil au module SplitPipeline.
    Il il est spécifiquement conçu pour de telles tâches. Le travail de démonstration code est:

    # import the module (not necessary in PS V3)
Import-Module SplitPipeline

# some servers (from 1 to 10 for the test)
$servers = 1..10

# process servers by parallel pipelines and output results immediately
$servers | Split-Pipeline {process{"processing server $_"; sleep 1}} -Load 1, 1

    Pour votre tâche de remplacer "processing server $_"; sleep 1 (simule un travail lent) avec un appel à votre script et utiliser la variable $_ en entrée, le serveur actuel.

    Si chaque travail n'est pas intensive du processeur puis augmenter le paramètre Count (la valeur par défaut est le nombre de processeurs) afin d'améliorer les performances.

  2. 3

    Pas une nouvelle question mais je pense qu'il manque une réponse, y compris Powershell à l'aide de flux de travail et de ses parallèles possibilités, à partir de powershell version 3. Ce qui est moins de code et peut-être plus compréhensible que de commencer et d'attente pour les emplois, ce qui, bien sûr, les bonnes œuvres.

    J'ai deux fichiers: TheScript.ps1 qui coordonne les serveurs et BackgroundJob.ps1 qui fait ce genre de vérification. Ils doivent être dans le même répertoire.

    La Write-Output dans la tâche en arrière-plan fichier écrit sur le même flux que vous voir lors du démarrage de TheScript.ps1.

    TheScript.ps1:

    workflow parallelCheckServer {
    param ($Servers)
    foreach -parallel($Server in $Servers)
    {
        Invoke-Expression -Command ".\BackgroundJob.ps1 -Server $Server"
    }
}

parallelCheckServer -Servers @("host1.com", "host2.com", "host3.com")

Write-Output "Done with all servers."

    BackgroundJob.ps1 (par exemple):

    param (
    [Parameter(Mandatory=$true)] [string] $server
)

Write-Host "[$server]`t Processing server $server"
Start-Sleep -Seconds 5

    Donc quand commencer la TheScript.ps1 il écrit "serveur de Traitement" 3 fois, mais il ne va pas attendre 15 secondes, mais au lieu de 5 car ils sont exécutés en parallèle.

    [host3.com]  Processing server host3.com
[host2.com]  Processing server host2.com
[host1.com]  Processing server host1.com
Done with all servers.
  3. 1

    Dans votre ForEach boucle, vous aurez envie de prendre la sortie générée par les Travaux déjà en cours d'exécution.

    Exemple Pas Testé

    $sb = {
     "Starting Job on $($args[0])"
     #Do something
     "$($args[0]) => Do something completed successfully"
     "$($args[0]) => Now for something completely different"
     "Ending Job on $($args[0])"
}
Foreach($computer in $computers){
    Start-Job -ScriptBlock $sb -Args $computer | Out-Null
    Get-Job | Receive-Job
}

    Maintenant, si vous faites cela, vos résultats seront mélangés. Vous pourriez mettre un timbre sur votre sortie commentée à dire à la sortie qui vient.

    Ou

    Foreach($computer in $computers){
    Start-Job -ScriptBlock $sb -Args $computer | Out-Null
    Get-Job | ? {$_.State -eq 'Complete' -and $_.HasMoreData} | % {Receive-Job $_}
}
while((Get-Job -State Running).count){
    Get-Job | ? {$_.State -eq 'Complete' -and $_.HasMoreData} | % {Receive-Job $_}
    start-sleep -seconds 1
}

    Il indiquera toutes les dès qu'un travail est terminé. Sans être mélangés.

  4. 1

    Si vous êtes désireux de multiples travaux en cours, vous aurez probablement envie de masser la sortie pour aider à garder de sortie va de pair avec le travail directement sur la console.

    $BGList = 'Black','Green','DarkBlue','DarkCyan','Red','DarkGreen'
$JobHash = @{};$ColorHash = @{};$i=0


ForEach($server in $servers)
{
  Start-Job -FilePath c:\cefcu_it\psscripts\PSPatch.ps1 -ArgumentList $server |
   foreach {
            $ColorHash[$_.ID] = $BGList[$i++]
            $JobHash[$_.ID] = $Server
           }
}
  While ((Get-Job).State -match 'Running')
   {
     foreach ($Job in  Get-Job | where {$_.HasMoreData})
       {
         [System.Console]::BackgroundColor = $ColorHash[$Job.ID]
         Write-Host $JobHash[$Job.ID] -ForegroundColor Black -BackgroundColor White
         Receive-Job $Job
       }
    Start-Sleep -Seconds 5
   } 
 [System.Console]::BackgroundColor = 'Black'
  5. 0

    Vous pouvez obtenir les résultats en faisant quelque chose comme cela, après que tous les travaux ont été reçues:

    $array=@()
    Get-Job -Nom * | where{$tableau+=$_.ChildJobs.sortie}

    .ChildJobs.sortie de tout ce qui a été retourné dans tous les postes.