jeudi 17 novembre 2011

Get-Job

NOM
    Get-Job

RÉSUMÉ
    Obtient les tâches en arrière-plan Windows PowerShell qui s'exécutent dans la session active.

SYNTAXE
    Get-Job [-Command <string[]>] [<CommonParameters>]

    Get-Job [[-InstanceId] <Guid[]>] [<CommonParameters>]

    Get-Job [[-Name] <string[]>] [<CommonParameters>]

    Get-Job [[-Id] <Int32[]>] [<CommonParameters>]

    Get-Job [-State {NotStarted | Running | Completed | Failed | Stopped | Blocked}] [<CommonParameters>]


DESCRIPTION
    L'applet de commande Get-Job obtient des objets qui représentent les tâches en arrière-plan démarrées dans la session active. Vous pouvez utiliser Get-Job pour obtenir des tâches démarrées à l'aide de Start-Job ou du paramètre AsJob de n'importe quelle applet de commande.

    Sans paramètres, une commande « Get-Job » obtient toutes les tâches de la session active. Vous pouvez utiliser les paramètres de Get-Job pour obtenir des tâches particulières.

    L'objet de traitement que Get-Job retourne contient des informations utiles sur la tâche, mais il ne contient pas les résultats de la tâche. Pour obtenir ces résultats, utilisez l'applet de commande Receive-Job.

    Une tâche en arrière-plan Windows PowerShell est une commande qui s'exécute « en arrière-plan » sans interagir avec la session active. En général, vous utilisez une tâche en arrière-plan pour exécuter une commande complexe qui prend beaucoup de temps. Pour plus d'informations sur les tâches en arrière-plan dans Windows PowerShell, consultez about_Jobs.


PARAMÈTRES
    -Command <string[]>
        Obtient les tâches qui incluent la commande spécifiée. La valeur par défaut est toutes les tâches. Entrez une commande (en tant que chaîne). Vous pouvez utiliser des caractères génériques pour spécifier un modèle de commande.

        Obligatoire ?                false
        Position ?                   named
        Valeur par défaut                     Toutes les tâches
        Accepter l'entrée de pipeline ?       true (ByPropertyName)
        Accepter les caractères génériques ?  true

    -Id <Int32[]>
        Obtient uniquement les tâches correspondant aux ID spécifiés.

        L'ID est un entier qui identifie de manière unique la tâche dans la session active. Il est plus facile à mémoriser et à taper que l'ID d'instance, mais est unique seulement dans la session active. Vous pouvez taper un ou plusieurs ID (séparés par des virgules). Pour rechercher l'ID d'une tâche, tapez « Get-Job » sans paramètres.

        Obligatoire ?                false
        Position ?                   1
        Valeur par défaut
        Accepter l'entrée de pipeline ?       true (ByPropertyName)
        Accepter les caractères génériques ?  false

    -InstanceId <Guid[]>
        Obtient des tâches correspondant aux ID d'instance spécifiés. La valeur par défaut est toutes les tâches.

        Un ID d'instance est un GUID qui identifie de manière unique la tâche sur l'ordinateur. Pour rechercher l'ID d'instance d'une tâche, utilisez Get-Job.

        Obligatoire ?                false
        Position ?                   1
        Valeur par défaut
        Accepter l'entrée de pipeline ?       true (ByPropertyName)
        Accepter les caractères génériques ?  true

    -Name <string[]>
        Obtient la tâche comportant les noms conviviaux spécifiés. Entrez un nom de tâche ou utilisez des caractères génériques pour entrer un modèle de nom de tâche. Par défaut, Get-Job obtient toutes les tâches de la session active.

        Obligatoire ?                false
        Position ?                   1
        Valeur par défaut
        Accepter l'entrée de pipeline ?       true (ByPropertyName)
        Accepter les caractères génériques ?  true

    -State <JobState>
        Obtient uniquement les tâches dans l'état spécifié. Les valeurs valides sont NotStarted, Running, Completed, Stopped, Failed et Blocked. Par défaut, Get-Job obtient toutes les tâches de la session active.

        Obligatoire ?                false
        Position ?                   named
        Valeur par défaut
        Accepter l'entrée de pipeline ?       true (ByPropertyName)
        Accepter les caractères génériques ?  false

    <CommonParameters>
        Cette applet de commande prend en charge les paramètres courants : Verbose, Debug,
        ErrorAction, ErrorVariable, WarningAction, WarningVariable,
        OutBuffer et OutVariable. Pour plus d'informations, tapez
        « get-help about_commonparameters ».

ENTRÉES
    Aucun
        Vous ne pouvez pas diriger d'entrée vers cette applet de commande.


SORTIES
    System.Management.Automation.RemotingJob
        Get-Job retourne des objets qui représentent les tâches dans la session.


NOTES





    -------------------------- EXEMPLE 1 --------------------------

    C:\PS>get-job


    Description
    -----------
    Cette commande obtient toutes les tâches en arrière-plan démarrées dans la session active. Elle n'inclut pas les tâches créées dans d'autres sessions, même si elles s'exécutent sur l'ordinateur local.





    -------------------------- EXEMPLE 2 --------------------------

    C:\PS>$j = get-job -name Job1

    C:\PS> $ID = $j.InstanceID

    C:\PS> $ID

    Guid
    ----
    03c3232e-1d23-453b-a6f4-ed73c9e29d55

    C:\PS> stop-job -instanceid $ID


    Description
    -----------
    Ces commandes montrent comment obtenir l'ID d'instance d'une tâche, puis l'utiliser pour arrêter une tâche. Contrairement au nom de la tâche, l'ID d'instance est unique.

    La première commande utilise l'applet de commande Get-Job pour obtenir une tâche. Elle utilise le paramètre Name pour identifier la tâche. Cette commande stocke l'objet de traitement que Get-Job retourne dans la variable $j. Dans cet exemple, une seule tâche porte le nom spécifié.

    La deuxième commande obtient la propriété InstanceId de l'objet dans la variable $j et la stocke dans la variable $ID.

    La troisième commande affiche la valeur de la variable $ID.

    La quatrième commande fait appel à l'applet de commande Stop-Job pour arrêter la tâche. Elle utilise le paramètre InstanceId pour identifier la tâche et la variable $ID pour représenter l'ID d'instance de la tâche.





    -------------------------- EXEMPLE 3 --------------------------

    C:\PS>get-job -command "*get-process*"


    Description
    -----------
    Cette commande obtient les tâches du système qui incluent une commande Get-Process. Elle utilise le paramètre Command de Get-Job pour limiter le nombre de tâches récupérées. Elle utilise des caractères génériques (*) pour obtenir les tâches qui incluent une commande Get-Process à n'importe quel emplacement de la chaîne de commande.





    -------------------------- EXEMPLE 4 --------------------------

    C:\PS>"*get-process*" | get-job


    Description
    -----------
    Comme celle de l'exemple précédent, cette commande obtient les tâches du système qui incluent une commande Get-Process. Elle utilise un opérateur de pipeline (|) pour envoyer une chaîne (entre guillemets doubles) à l'applet de commande Get-Job. Il s'agit de l'équivalent de la commande précédente.





    -------------------------- EXEMPLE 5 --------------------------

    C:\PS>get-job -state NotStarted


    Description
    -----------
    Cette commande obtient uniquement les tâches qui ont été créées, mais qui n'ont pas encore été démarrées. La liste inclut les tâches planifiées pour s'exécuter ultérieurement et celles qui ne sont pas encore planifiées.





    -------------------------- EXEMPLE 6 --------------------------

    C:\PS>get-job -name job*


    Description
    -----------
    Cette commande obtient tous les tâches dont le nom commence par « job ». Parce que « job<nombre> » est le nom par défaut d'une tâche, cette commande obtient toutes les tâches auxquelles un nom n'a pas été attribué explicitement.





    -------------------------- EXEMPLE 7 --------------------------

    C:\PS>start-job -scriptblock {get-process} -name MyJob

    C:\PS> $j = get-job -name MyJob

    C:\PS> $j

    Id       Name      State      HasMoreData     Location    Command
    --       ----      -----      -----------     --------    -------
    1        myjob     Completed  True            localhost   get-process

    C:\PS> receive-job -job $j

    Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
    -------  ------    -----      ----- -----   ------     -- -----------
        124       4    13572      12080    59            1140 audiodg
        783      16    11428      13636   100             548 CcmExec
         96       4     4252       3764    59            3856 ccmsetup
    ...


    Description
    -----------
    Cet exemple montre comment utiliser Get-Job pour obtenir un objet de traitement, puis il indique comment employer cet objet pour représenter la tâche dans une commande.

    La première commande utilise l'applet de commande Start-Job pour démarrer une tâche en arrière-plan qui exécute une commande Get-Process sur l'ordinateur local. Elle utilise le paramètre Name de Start-Job pour attribuer un nom convivial à la tâche.

    La deuxième commande utilise Get-Job pour obtenir la tâche. Elle utilise le paramètre Name de Get-Job pour identifier la tâche. Elle enregistre l'objet de traitement résultant dans la variable $j.

    La troisième commande affiche la valeur de l'objet de traitement dans la variable $j. La valeur de la propriété State indique que la tâche est terminée. La valeur de la propriété HasMoreData montre que certains résultats de la tâche qui sont disponibles n'ont pas encore été récupérés.

    La quatrième commande utilise l'applet de commande Receive-Job pour obtenir les résultats de la tâche. Elle utilise l'objet de traitement de la variable $j pour représenter la tâche. Vous pouvez également utiliser un opérateur de pipeline pour envoyer un objet de traitement à Receive-Job.





    -------------------------- EXEMPLE 8 --------------------------

    C:\PS>start-job -scriptblock {get-eventlog system}

    C:\PS> invoke-command -computername S1 -scriptblock {get-eventlog system} -AsJob

    C:\PS> invoke-command -computername S2 -scriptblock {start-job -scriptblock {get-eventlog system}}

    C:\PS> get-job

    Id    Name     State      HasMoreData   Location   Command
    --    ----     -----      -----------   --------   -------
    1     Job1     Running    True          localhost  get-eventlog system
    2     Job2     Running    True          S1         get-eventlog system

    C:\PS> invoke-command -computername S2 -scriptblock {get-job}

    Id    Name     State      HasMoreData   Location   Command
    --    ----     -----      -----------   --------   -------
    4     Job4     Running    True          localhost  get-eventlog system


    Description
    -----------
    Cet exemple montre que l'applet de commande Get-Job peut obtenir toutes les tâches démarrées dans la session active, même en employant des méthodes différentes.

    La première commande utilise l'applet de commande Start-Job pour démarrer une tâche sur l'ordinateur local.

    La deuxième commande utilise le paramètre AsJob de Invoke-Command pour démarrer une tâche sur l'ordinateur S1. Bien que les commandes de la tâche s'exécutent sur l'ordinateur distant, l'objet de traitement est créé sur l'ordinateur local, ce qui vous permet d'utiliser des commandes locales pour gérer la tâche.

    La troisième commande utilise l'applet de commande Invoke-Command pour exécuter une commande Start-Job sur l'ordinateur S2. Avec cette méthode, l'objet de traitement est créé sur l'ordinateur distant, ce qui vous permet d'utiliser des commandes distantes pour gérer la tâche.

    La quatrième commande utilise Get-Job pour obtenir les tâches stockées sur l'ordinateur local.

    La cinquième commande utilise Invoke-Command pour exécuter une commande Get-Job sur l'ordinateur S2.

    L'exemple de sortie présente les résultats des commandes Get-Job.

    Pour plus d'informations sur l'exécution de tâches en arrière-plan sur des ordinateurs distants, consultez about_Remote_Jobs.





    -------------------------- EXEMPLE 9 --------------------------

    C:\PS>start-job -scriptblock {get-process}

    Id       Name            State      HasMoreData     Location             Command
    --       ----            -----      -----------     --------             -------
    1        Job1            Failed     False           localhost            get-process

    C:\PS> (get-job).jobstateinfo | format-list -property *

    State  : Failed
    Reason :


    C:\PS> get-job | format-list *

    HasMoreData   : False
    StatusMessage :
    Location      : localhost
    Command       : get-process
    JobStateInfo  : Failed
    Finished      : System.Threading.ManualResetEvent
    InstanceId    : fb792295-1318-4f5d-8ac8-8a89c5261507
    Id            : 1
    Name          : Job1
    ChildJobs     : {Job2}
    Output        : {}
    Error         : {}
    Progress      : {}
    Verbose       : {}
    Debug         : {}
    Warning       : {}
    StateChanged  :


    C:\PS> (get-job -name job2).jobstateinfo.reason
    Connecting to remote server using WSManCreateShellEx api failed. The async callback gave the following error messag
    e :
    Access is denied.


    Description
    -----------
    Cette commande montre comment utiliser l'objet de traitement que Get-Job retourne pour chercher pourquoi une tâche a échoué. Elle montre également comment obtenir les tâches enfants de chaque tâche.

    La première commande utilise l'applet de commande Start-Job pour démarrer une tâche sur l'ordinateur local. L'objet de traitement que Start-Job retourne montre que la tâche a échoué. La valeur de la propriété State est « Failed ».

    La deuxième commande utilise Get-Job pour obtenir l'objet tâche. Elle fait appel à la méthode de point pour obtenir la valeur de la propriété JobStateInfo de l'objet. Elle utilise un opérateur de pipeline pour envoyer l'objet de la propriété JobStateInfo à l'applet de commande Format-List, qui met en forme toutes les propriétés de l'objet (*)
    dans une liste.

    Le résultat de la commande Format-List montre que la valeur de la propriété Reason de la tâche est vierge.

    La troisième commande effectue un examen plus approfondi. Elle utilise une commande Get-Job pour obtenir la tâche, puis se sert d'un opérateur de pipeline pour envoyer l'objet de traitement entier à l'applet de commande Format-List, qui affiche toutes les propriétés de la tâche dans une liste.

    L'affichage de toutes les propriétés de l'objet de traitement montre que la tâche contient une tâche enfant nommée « Job2 ».

    La quatrième commande utilise Get-Job pour obtenir l'objet de traitement qui représente la tâche enfant Job2. C'est précisément la tâche dans laquelle la commande s'était exécutée. Elle utilise la méthode de point pour obtenir la propriété Reason de la propriété JobStateInfo.

    Le résultat montre que la tâche a échoué à cause d'une erreur de type « accès refusé ». Dans ce cas, l'utilisateur a oublié d'employer l'option Exécuter en tant qu'administrateur lors de l'ouverture de Windows PowerShell.

    Parce que les tâches en arrière-plan utilisent les fonctionnalités de communication à distance de Windows PowerShell, l'ordinateur doit être configuré à cet effet afin d'exécuter une tâche, même quand la tâche s'exécute sur l'ordinateur local.

    Pour plus d'informations sur les exigences relatives à la communication à distance dans Windows PowerShell, consultez about_Remote_Requirements. Pour obtenir des conseils de dépannage, consultez about_Remote_Troubleshooting.






LIENS CONNEXES
    Online version: http://go.microsoft.com/fwlink/?LinkID=113328
    about_Jobs
    about_Job_details
    about_Remote_Jobs
    Start-Job
    Receive-Job
    Wait-Job
    Stop-Job
    Remove-Job
    Invoke-Command

Aucun commentaire:

Enregistrer un commentaire