about_Remote_Jobs

Artikel
04/13/2023

Kort beskrivning

Beskriver hur du kör bakgrundsjobb på fjärrdatorer.

Detaljerad beskrivning

PowerShell kör samtidigt kommandon och skript via jobb. Det finns tre jobbtyper som tillhandahålls av PowerShell för att stödja samtidighet.

RemoteJob – Kommandon och skript körs i en fjärrsession.
BackgroundJob – Kommandon och skript körs i en separat process på den lokala datorn. Mer information finns i artikeln om jobb.
PSTaskJob eller ThreadJob – Kommandon och skript körs i en separat tråd i samma process på den lokala datorn. Mer information finns i about_Thread_Jobs.

Om du kör skript via fjärranslutning, på en separat dator eller i en separat process, får du bra isolering. Eventuella fel som uppstår i fjärrjobbet påverkar inte andra jobb som körs eller den överordnade sessionen som startade jobbet. Dock lägger fjärrkommunikationsskiktet till omkostnader, inklusive objektserialisering. Alla objekt serialiseras och deserialiseras när de skickas mellan den överordnade sessionen och fjärrsessionen (jobbet). Serialisering av stora komplexa dataobjekt kan förbruka stora mängder beräknings- och minnesresurser och överföra stora mängder data i nätverket.

Viktigt!

Den överordnade sessionen som skapade jobbet övervakar också jobbstatusen och samlar in pipelinedata. Den underordnade jobbprocessen avslutas av den överordnade processen när jobbet når ett slutfört tillstånd. Om den överordnade sessionen avslutas avslutas alla underordnade jobb som körs tillsammans med deras underordnade processer.

Det finns två sätt att kringgå den här situationen:

Använd Invoke-Command för att skapa jobb som körs i frånkopplade sessioner. Se avsnittet frånkopplade processer i den här artikeln.
Använd Start-Process för att skapa en ny process i stället för ett jobb. Mer information finns i Startprocess.

Fjärrjobb

Du kan köra jobb på fjärrdatorer med hjälp av tre olika metoder.

Starta en interaktiv session på en fjärrdator. Starta sedan ett jobb i den interaktiva sessionen. Procedurerna är desamma som när du kör ett lokalt jobb, även om alla åtgärder utförs på fjärrdatorn.
Kör ett jobb på en fjärrdator som returnerar resultatet till den lokala datorn. Använd den här metoden när du vill samla in resultatet av jobb och underhålla dem på en central plats på den lokala datorn.
Kör ett jobb på en fjärrdator som underhåller sina resultat på fjärrdatorn. Använd den här metoden när jobbdata underhålls säkrare på den ursprungliga datorn.

Starta ett jobb i en interaktiv session

Du kan starta en interaktiv session med en fjärrdator och sedan starta ett jobb under den interaktiva sessionen. Mer information om interaktiva sessioner finns i about_Remote och se Enter-PSSession.

Proceduren för att starta ett jobb i en interaktiv session är nästan identisk med proceduren för att starta ett bakgrundsjobb på den lokala datorn. Alla åtgärder sker dock på fjärrdatorn, inte på den lokala datorn.

Använd cmdleten Enter-PSSession för att starta en interaktiv session med en fjärrdator. Du kan använda parametern Enter-PSSession ComputerName för för att upprätta en tillfällig anslutning för den interaktiva sessionen. Du kan också använda sessionsparametern för att köra den interaktiva sessionen i en PowerShell-session (PSSession).

Följande kommando startar en interaktiv session på Server01-datorn.
```
C:\PS> Enter-PSSession -computername Server01
```
Kommandotolken ändras för att visa att du nu är ansluten till Server01-datorn.
```
Server01\C:>
```
Om du vill starta ett fjärrjobb i sessionen använder du cmdleten Start-Job . Följande kommando kör ett fjärrjobb som hämtar händelserna i Windows PowerShell-händelseloggen på Server01-datorn. Cmdleten Start-Job returnerar ett objekt som representerar jobbet.

Det här kommandot sparar jobbobjektet i variabeln $job .
```
Server01\C:> $job = Start-Job -scriptblock {
  Get-Eventlog "Windows PowerShell"
}
```
När jobbet körs kan du använda den interaktiva sessionen för att köra andra kommandon, inklusive andra jobb. Du måste dock hålla den interaktiva sessionen öppen tills jobbet har slutförts. Om du avslutar sessionen avbryts jobbet och resultatet går förlorat.
Om du vill ta reda på om jobbet är klart visar du värdet för variabeln $job eller använder cmdleten Get-Job för att hämta jobbet. Följande kommando använder cmdleten Get-Job för att visa jobbet.
```
Server01\C:> Get-Job $job

SessionId  Name  State      HasMoreData  Location   Command
---------  ----  -----      -----------  --------   -------
1          Job1  Complete   True         localhost  Get-Eventlog "Windows...
```
Utdata Get-Job visar att jobbet körs på datorn "localhost" eftersom jobbet startades och körs på samma dator (i det här fallet Server01).
Om du vill få resultatet av jobbet använder du cmdleten Receive-Job . Du kan visa resultatet i den interaktiva sessionen eller spara dem i en fil på fjärrdatorn. Följande kommando hämtar resultatet av jobbet i variabeln $job. Kommandot använder omdirigeringsoperatorn (>) för att spara resultatet av jobbet i filen PsLog.txt på Server01-datorn.
```
Server01\C:> Receive-Job $job > c:\logs\PsLog.txt
```
Om du vill avsluta den interaktiva sessionen använder du cmdleten Exit-PSSession . Kommandotolken ändras för att visa att du är tillbaka i den ursprungliga sessionen på den lokala datorn.
```
Server01\C:> Exit-PSSession
C:\PS>
```
Om du vill visa innehållet i PsLog.txt filen på Server01-datorn när som helst startar du en annan interaktiv session eller kör ett fjärrkommando. Den här typen av kommando körs bäst i en PSSession (en beständig anslutning) om du vill använda flera kommandon för att undersöka och hantera data i PsLog.txt filen. Mer information om PSSessioner finns i about_PSSessions.

Följande kommandon använder cmdleten New-PSSession för att skapa en PSSession som är ansluten till Server01-datorn, och de använder cmdleten Invoke-Command för att köra ett Get-Content kommando i PSSession för att visa innehållet i filen.
```
$s = New-PSSession -computername Server01
Invoke-Command -session $s -scriptblock {
  Get-Content c:\logs\pslog.txt}
```

Starta ett fjärrjobb som returnerar resultatet till den lokala datorn (AsJob)

Om du vill starta ett jobb på en fjärrdator som returnerar kommandoresultatet till den lokala datorn använder du asjob-parametern för en cmdlet, till exempel cmdletenInvoke-Command.

När du använder asjob-parametern skapas jobbobjektet faktiskt på den lokala datorn trots att jobbet körs på fjärrdatorn. När jobbet har slutförts returneras resultatet till den lokala datorn.

Du kan använda de cmdletar som innehåller jobbets substantiv (jobb-cmdletarna) för att hantera alla jobb som skapats av valfri cmdlet. Många av de cmdletar som har AsJob-parametrar använder inte PowerShell-fjärrkommunikation, så du kan använda dem även på datorer som inte har konfigurerats för fjärrkommunikation och som inte uppfyller kraven för fjärrkommunikation.

Följande kommando använder asjob-parametern Invoke-Command för för att starta ett jobb på Server01-datorn. Jobbet kör ett Get-Eventlog kommando som hämtar händelserna i systemloggen. Du kan använda parametern JobName för att tilldela ett visningsnamn till jobbet.
```
Invoke-Command -computername Server01 -scriptblock {
  Get-Eventlog system} -AsJob
```
Resultatet av kommandot liknar följande exempelutdata.
```
SessionId   Name   State    HasMoreData   Location   Command
---------   ----   -----    -----------   --------   -------
1           Job1   Running  True          Server01   Get-Eventlog system
```
När parametern AsJob används Invoke-Command returnerar samma typ av jobbobjekt som Start-Job returneras. Du kan spara jobbobjektet i en variabel eller använda ett Get-Job kommando för att hämta jobbet.

Observera att värdet för egenskapen Plats visar att jobbet kördes på Server01-datorn.
Om du vill hantera ett jobb som startats med hjälp av parametern AsJob för cmdleten Invoke-Command använder du cmdletarna Jobb. Eftersom jobbobjektet som representerar fjärrjobbet finns på den lokala datorn behöver du inte köra fjärrkommandon för att hantera jobbet.

Om du vill ta reda på om jobbet är klart använder du ett Get-Job kommando. Följande kommando hämtar alla jobb som startades i den aktuella sessionen.
```
Get-Job
```
Eftersom fjärrjobbet startades i den aktuella sessionen hämtar ett lokalt Get-Job kommando jobbet. Jobbobjektets tillståndsegenskap visar att kommandot har slutförts.
```
SessionId   Name   State      HasMoreData   Location   Command
---------   ----   -----      -----------   --------   -------
1           Job1   Completed  True          Server01   Get-Eventlog system
```
Om du vill få resultatet av jobbet använder du cmdleten Receive-Job . Eftersom jobbresultatet automatiskt returneras till den dator där jobbobjektet finns kan du få resultatet med ett lokalt Receive-Job kommando.

Följande kommando använder cmdleten Receive-Job för att hämta resultatet av jobbet. Den använder sessions-ID:t för att identifiera jobbet. Det här kommandot sparar jobbresultatet i variabeln $results. Du kan också omdirigera resultatet till en fil.
```
$results = Receive-Job -id 1
```

Starta ett fjärrjobb som behåller resultatet på fjärrdatorn

Om du vill starta ett jobb på en fjärrdator som behåller kommandoresultatet på fjärrdatorn använder du cmdleten Invoke-Command för att köra ett Start-Job kommando på en fjärrdator. Du kan använda den här metoden för att köra jobb på flera datorer.

När du kör ett Start-Job kommando via fjärranslutning skapas jobbobjektet på fjärrdatorn och jobbresultaten underhålls på fjärrdatorn. Ur jobbets perspektiv är alla åtgärder lokala. Du kör bara kommandon via fjärranslutning för att hantera ett lokalt jobb på fjärrdatorn.

Använd cmdleten Invoke-Command för att köra ett Start-Job kommando på en fjärrdator.

Det här kommandot kräver en PSSession (en beständig anslutning). Om du använder parametern Invoke-Command ComputerName för för att upprätta en tillfällig anslutning Invoke-Command anses kommandot vara slutfört när jobbobjektet returneras. Det innebär att den tillfälliga anslutningen stängs och jobbet avbryts.

Följande kommando använder cmdleten New-PSSession för att skapa en PSSession som är ansluten till Server01-datorn. Kommandot sparar PSSession i variabeln $s .
```
$s = New-PSSession -computername Server01
```
Nästa kommando använder cmdleten Invoke-Command för att köra ett Start-Job kommando i PSSession. Kommandot Start-Job och Get-Eventlog kommandot omges av klammerparenteser.
```
Invoke-Command -session $s -scriptblock {
  Start-Job -scriptblock {Get-Eventlog system}}
```
Resultatet liknar följande exempelutdata.
```
Id       Name    State      HasMoreData     Location   Command
--       ----    -----      -----------     --------   -------
2        Job2    Running    True            Localhost  Get-Eventlog system
```
När du kör ett Start-Job kommando via fjärranslutning Invoke-Command returnerar samma typ av jobbobjekt som Start-Job returneras. Du kan spara jobbobjektet i en variabel eller använda ett Get-Job kommando för att hämta jobbet.

Observera att värdet för egenskapen Plats visar att jobbet kördes på den lokala datorn, som kallas "LocalHost", även om jobbet kördes på Server01-datorn. Eftersom jobbobjektet skapas på Server01-datorn och jobbet körs på samma dator anses det vara ett lokalt bakgrundsjobb.
Om du vill hantera ett fjärrjobb använder du cmdletarna Jobb . Eftersom jobbobjektet finns på fjärrdatorn måste du köra fjärrkommandon för att hämta, stoppa, vänta på eller hämta jobbresultatet.

Om du vill se om jobbet är klart använder du ett Invoke-Command kommando för att köra ett Get-Job kommando i PSSession som är anslutet till Server01-datorn.
```
Invoke-Command -session $s -scriptblock {Get-Job}
```
Kommandot returnerar ett jobbobjekt. Jobbobjektets tillståndsegenskap visar att kommandot har slutförts.
```
SessionId   Name  State      HasMoreData   Location   Command
---------   ----  -----      -----------   --------   -------
2           Job2  Completed  True          LocalHost   Get-Eventlog system
```
För att få resultatet av jobbet använder du cmdleten Invoke-Command för att köra ett Receive-Job kommando i PSSession som är anslutet till Server01-datorn.

Följande kommando använder cmdleten Receive-Job för att hämta resultatet av jobbet. Den använder sessions-ID:t för att identifiera jobbet. Det här kommandot sparar jobbresultatet i variabeln $results . Den använder parametern Receive-Job Behåll för för att behålla resultatet i jobbcachen på fjärrdatorn.
```
$results = Invoke-Command -session $s -scriptblock {
  Receive-Job -SessionId 2 -Keep
}
```
Du kan också omdirigera resultatet till en fil på den lokala datorn eller fjärrdatorn. Följande kommando använder en omdirigeringsoperator för att spara resultatet i en fil på Server01-datorn.
```
Invoke-Command -session $s -command {
  Receive-Job -SessionId 2 > c:\logs\pslog.txt
}
```

Så här kör du som en frånkopplad process

Som tidigare nämnts avslutas alla underordnade jobb som körs tillsammans med deras underordnade processer när den överordnade sessionen avslutas. Du kan använda fjärrkommunikation på den lokala datorn för att köra jobb som inte är kopplade till den aktuella PowerShell-sessionen.

Skapa en ny PowerShell-session på den lokala datorn. Användning Invoke-Command för att starta ett jobb i den här sessionen. Invoke-Command gör att du kan koppla från en fjärrsession och avsluta den överordnade sessionen. Senare kan du starta en ny PowerShell-session och ansluta till den tidigare frånkopplade sessionen för att återuppta övervakningen av jobbet. Data som returnerades till den ursprungliga PowerShell-sessionen går dock förlorade när sessionen avslutas. Endast nya dataobjekt som genereras efter frånkopplingen returneras när de återansluts.

# Create remote session on local machine
PS> $session = New-PSSession -cn localhost

# Start remote job
PS> $job = Invoke-Command -Session $session -ScriptBlock { 1..60 | % { sleep 1; "Output $_" } } -AsJob
PS> $job

Id     Name     PSJobTypeName   State         HasMoreData     Location      Command
--     ----     -------------   -----         -----------     --------      -------
1      Job1     RemoteJob       Running       True            localhost     1..60 | % { sleep 1; ...

# Disconnect the job session
PS> Disconnect-PSSession $session

Id Name         Transport ComputerName    ComputerType    State         ConfigurationName     Availability
-- ----         --------- ------------    ------------    -----         -----------------     ------------
1 Runspace1     WSMan     localhost       RemoteMachine   Disconnected  Microsoft.PowerShell          None

PS> $job

Id     Name     PSJobTypeName   State         HasMoreData     Location      Command
--     ----     -------------   -----         -----------     --------      -------
1      Job1     RemoteJob       Disconnected  True            localhost     1..60 | % { sleep 1;

# Reconnect the session to a new job object
PS> $jobNew = Receive-PSSession -Session $session -OutTarget Job
PS> $job | Wait-Job | Receive-Job
Output 9
Output 10
Output 11
...

I det här exemplet är jobben fortfarande kopplade till en överordnad PowerShell-session. Den överordnade sessionen är dock inte den ursprungliga PowerShell-sessionen som Invoke-Command kördes.

Dela via