about_Remote_Jobs

Makale
04/13/2023

Kısa açıklama

Uzak bilgisayarlarda arka plan işlerinin nasıl çalıştırıldığı açıklanır.

Ayrıntılı Açıklama

PowerShell, komutları ve betikleri işler aracılığıyla eşzamanlı olarak çalıştırır. Eşzamanlılığı desteklemek için PowerShell tarafından sağlanan üç iş türü vardır.

RemoteJob - Komutlar ve betikler uzak oturumda çalışır.
BackgroundJob - Komutlar ve betikler yerel makinede ayrı bir işlemde çalıştırılır. Daha fazla bilgi için bkz. İşler hakkında.
PSTaskJob or ThreadJob - Komutlar ve betikler, yerel makinede aynı işlem içinde ayrı bir iş parçacığında çalışır. Daha fazla bilgi için bkz . about_Thread_Jobs.

Betikleri uzaktan, ayrı bir makinede veya ayrı bir işlemde çalıştırmak harika yalıtım sağlar. Uzak işte oluşan hatalar, diğer çalışan işleri veya işi başlatan üst oturumu etkilemez. Ancak uzaktan iletişim katmanı, nesne serileştirme de dahil olmak üzere ek yük ekler. Tüm nesneler, üst oturum ile uzak (iş) oturumu arasında geçirildikçe serileştirilir ve seri durumdan çıkarılır. Büyük karmaşık veri nesnelerinin seri hale getirilmesi büyük miktarda işlem ve bellek kaynağı tüketebilir ve büyük miktarda veriyi ağ üzerinden aktarabilir.

Önemli

İşi oluşturan üst oturum da iş durumunu izler ve işlem hattı verilerini toplar. İş tamamlanmış duruma ulaştığında, iş alt işlemi üst işlem tarafından sonlandırılır. Üst oturum sonlandırılırsa, çalışan tüm alt işler kendi alt işlemleriyle birlikte sonlandırılır.

Bu durumu geçici olarak gidermenin iki yolu vardır:

Bağlantısız oturumlarda çalışan işler oluşturmak için kullanın Invoke-Command . Bu makalenin ayrılmış işlemler bölümüne bakın.
İş yerine yeni bir işlem oluşturmak için kullanın Start-Process . Daha fazla bilgi için bkz . Start-Process.

Uzak İşler

Üç farklı yöntem kullanarak uzak bilgisayarlarda iş çalıştırabilirsiniz.

Uzak bilgisayarda etkileşimli bir oturum başlatın. Ardından etkileşimli oturumda bir iş başlatın. Tüm eylemler uzak bilgisayarda gerçekleştirilse de yordamlar yerel bir işi çalıştırmayla aynıdır.
Sonuçlarını yerel bilgisayara döndüren uzak bir bilgisayarda bir iş çalıştırın. İşlerin sonuçlarını toplamak ve yerel bilgisayarda merkezi bir konumda tutmak istediğinizde bu yöntemi kullanın.
Uzak bilgisayarda, sonuçlarını uzak bilgisayarda tutan bir işi çalıştırın. İş verileri kaynak bilgisayarda daha güvenli bir şekilde korunduğunda bu yöntemi kullanın.

Etkileşimli oturumda iş başlatma

Uzak bir bilgisayarla etkileşimli bir oturum başlatabilir ve ardından etkileşimli oturum sırasında bir iş başlatabilirsiniz. Etkileşimli oturumlar hakkında daha fazla bilgi için bkz . about_Remote ve bkz Enter-PSSession. .

Etkileşimli bir oturumda iş başlatma yordamı, yerel bilgisayarda arka plan işi başlatma yordamıyla neredeyse aynıdır. Ancak, tüm işlemler yerel bilgisayarda değil uzak bilgisayarda gerçekleşir.

Enter-PSSession Uzak bir bilgisayarla etkileşimli oturum başlatmak için cmdlet'ini kullanın. Etkileşimli oturum için geçici bir bağlantı kurmak için computername parametresini Enter-PSSession kullanabilirsiniz. Alternatif olarak, etkileşimli oturumu bir PowerShell oturumunda (PSSession) çalıştırmak için Session parametresini de kullanabilirsiniz.

Aşağıdaki komut, Server01 bilgisayarında etkileşimli bir oturum başlatır.
```
C:\PS> Enter-PSSession -computername Server01
```
Komut istemi, artık Server01 bilgisayarına bağlı olduğunuzu gösterecek şekilde değişir.
```
Server01\C:>
```
Oturumda uzak bir iş başlatmak için cmdlet'ini Start-Job kullanın. Aşağıdaki komut, Server01 bilgisayarındaki Windows PowerShell olay günlüğündeki olayları alan uzak bir iş çalıştırır. Cmdlet, Start-Job işi temsil eden bir nesne döndürür.

Bu komut, iş nesnesini değişkene $job kaydeder.
```
Server01\C:> $job = Start-Job -scriptblock {
  Get-Eventlog "Windows PowerShell"
}
```
İş çalışırken, diğer işler de dahil olmak üzere diğer komutları çalıştırmak için etkileşimli oturumu kullanabilirsiniz. Ancak, iş tamamlanana kadar etkileşimli oturumu açık tutmanız gerekir. Oturumu sona erdirdiğinizde iş kesintiye uğrar ve sonuçlar kaybolur.
İşin tamam olup olmadığını öğrenmek için değişkenin $job değerini görüntüleyin veya işi almak için cmdlet'ini kullanın Get-Job . Aşağıdaki komut, işi görüntülemek için cmdlet'ini kullanır Get-Job .
```
Server01\C:> Get-Job $job

SessionId  Name  State      HasMoreData  Location   Command
---------  ----  -----      -----------  --------   -------
1          Job1  Complete   True         localhost  Get-Eventlog "Windows...
```
Çıktı, Get-Job işin "localhost" bilgisayarda çalıştığını çünkü işin aynı bilgisayarda (bu durumda, Server01) başlatıldığını ve çalıştığını gösterir.
İşin sonuçlarını almak için cmdlet'ini Receive-Job kullanın. Sonuçları etkileşimli oturumda görüntüleyebilir veya uzak bilgisayardaki bir dosyaya kaydedebilirsiniz. Aşağıdaki komut, $job değişkenindeki işin sonuçlarını alır. Komut, işin sonuçlarını Server01 bilgisayarındaki PsLog.txt dosyasına kaydetmek için yeniden yönlendirme işlecini (>) kullanır.
```
Server01\C:> Receive-Job $job > c:\logs\PsLog.txt
```
Etkileşimli oturumu sonlandırmak için cmdlet'ini Exit-PSSession kullanın. Komut istemi, yerel bilgisayarda özgün oturumda olduğunuzu gösterecek şekilde değişir.
```
Server01\C:> Exit-PSSession
C:\PS>
```
Server01 bilgisayarında dosyanın içeriğini PsLog.txt istediğiniz zaman görüntülemek için başka bir etkileşimli oturum başlatın veya uzak bir komut çalıştırın. Dosyadaki verileri araştırmak ve yönetmek için çeşitli komutlar kullanmak istemeniz durumunda bu tür bir komut en iyi şekilde PSSession'da PsLog.txt (kalıcı bir bağlantı) çalıştırılır. PSSessions hakkında daha fazla bilgi için bkz . about_PSSessions.

Aşağıdaki komutlar cmdlet'ini New-PSSession kullanarak Server01 bilgisayarına bağlı bir PSSession oluşturur ve cmdlet'ini kullanarak Invoke-Command PSSession'da dosyanın içeriğini görüntülemek üzere bir Get-Content komut çalıştırır.
```
$s = New-PSSession -computername Server01
Invoke-Command -session $s -scriptblock {
  Get-Content c:\logs\pslog.txt}
```

Sonuçları yerel bilgisayara döndüren uzak bir iş başlatma (AsJob)

Komut sonuçlarını yerel bilgisayara döndüren uzak bir bilgisayarda iş başlatmak için cmdlet gibi bir cmdlet'in AsJob parametresini Invoke-Command kullanın.

AsJob parametresini kullandığınızda, iş uzak bilgisayarda çalıştırılıyor olsa bile iş nesnesi aslında yerel bilgisayarda oluşturulur. İş tamamlandığında sonuçlar yerel bilgisayara döndürülür.

Herhangi bir cmdlet tarafından oluşturulan herhangi bir işi yönetmek için İş adlarını (İş cmdlet'leri) içeren cmdlet'leri kullanabilirsiniz. AsJob parametrelerine sahip cmdlet'lerin çoğu PowerShell uzaktan iletişimini kullanmaz, bu nedenle uzaktan iletişim için yapılandırılmamış ve uzaktan iletişim gereksinimlerini karşılamayan bilgisayarlarda bile kullanabilirsiniz.

Aşağıdaki komut, Server01 bilgisayarında bir iş başlatmak için AsJob parametresini Invoke-Command kullanır. İş, Sistem günlüğündeki olayları alan bir Get-Eventlog komut çalıştırır. jobName parametresini kullanarak işe bir görünen ad atayabilirsiniz.
```
Invoke-Command -computername Server01 -scriptblock {
  Get-Eventlog system} -AsJob
```
Komutun sonuçları aşağıdaki örnek çıkışa benzer.
```
SessionId   Name   State    HasMoreData   Location   Command
---------   ----   -----    -----------   --------   -------
1           Job1   Running  True          Server01   Get-Eventlog system
```
AsJob parametresi kullanıldığında, Invoke-Command döndüren Start-Job aynı iş nesnesi türünü döndürür. İş nesnesini bir değişkene kaydedebilir veya işi almak için bir Get-Job komut kullanabilirsiniz.

Location özelliğinin değerinin işin Server01 bilgisayarında çalıştığını gösterdiğini unutmayın.
Cmdlet'in AsJob parametresini Invoke-Command kullanarak başlatılan bir işi yönetmek için İş cmdlet'lerini kullanın. Uzak işi temsil eden iş nesnesi yerel bilgisayarda olduğundan, işi yönetmek için uzak komutları çalıştırmanız gerekmez.

İşin tamamlanıp tamamlanmadığını belirlemek için bir Get-Job komut kullanın. Aşağıdaki komut geçerli oturumda başlatılan tüm işleri alır.
```
Get-Job
```
Uzak iş geçerli oturumda başlatıldığından, işi yerel Get-Job bir komut alır. İş nesnesinin State özelliği komutun başarıyla tamamlandığını gösterir.
```
SessionId   Name   State      HasMoreData   Location   Command
---------   ----   -----      -----------   --------   -------
1           Job1   Completed  True          Server01   Get-Eventlog system
```
İşin sonuçlarını almak için cmdlet'ini Receive-Job kullanın. İş sonuçları, iş nesnesinin bulunduğu bilgisayara otomatik olarak döndürüldüğünden, sonuçları yerel Receive-Job bir komutla alabilirsiniz.

Aşağıdaki komut, Receive-Job işin sonuçlarını almak için cmdlet'ini kullanır. İşi tanımlamak için oturum kimliğini kullanır. Bu komut, iş sonuçlarını $results değişkenine kaydeder. Sonuçları bir dosyaya da yönlendirebilirsiniz.
```
$results = Receive-Job -id 1
```

Sonuçları uzak bilgisayarda tutan bir uzak iş başlatma

Uzak bilgisayarda komut sonuçlarını saklayan bir işi başlatmak için cmdlet'ini Invoke-Command kullanarak uzak bilgisayarda bir Start-Job komut çalıştırın. Birden çok bilgisayarda iş çalıştırmak için bu yöntemi kullanabilirsiniz.

Bir Start-Job komutu uzaktan çalıştırdığınızda, iş nesnesi uzak bilgisayarda oluşturulur ve iş sonuçları uzak bilgisayarda tutulur. İşin perspektifinden bakıldığında, tüm işlemler yereldir. Uzak bilgisayardaki yerel bir işi yönetmek için komutları uzaktan çalıştıracaksınız.

Cmdlet'ini Invoke-Command kullanarak uzak bilgisayarda bir Start-Job komut çalıştırın.

Bu komut pssession (kalıcı bir bağlantı) gerektirir. Geçici bir bağlantı kurmak için computername parametresini Invoke-Command kullanırsanız, Invoke-Command iş nesnesi döndürüldüğünde komutun tamamlanmış olduğu kabul edilir. Sonuç olarak, geçici bağlantı kapatılır ve iş iptal edilir.

Aşağıdaki komut, Server01 bilgisayarına bağlı bir PSSession oluşturmak için cmdlet'ini kullanır New-PSSession . komutu PSSession'ı değişkene $s kaydeder.
```
$s = New-PSSession -computername Server01
```
Sonraki komut, PSSession'da bir Start-Job komut çalıştırmak için cmdlet'ini kullanırInvoke-Command. Start-Job komutu ve Get-Eventlog komutu ayraç içine alınır.
```
Invoke-Command -session $s -scriptblock {
  Start-Job -scriptblock {Get-Eventlog system}}
```
Sonuçlar aşağıdaki örnek çıktıya benzer.
```
Id       Name    State      HasMoreData     Location   Command
--       ----    -----      -----------     --------   -------
2        Job2    Running    True            Localhost  Get-Eventlog system
```
Bir Start-Job komutu uzaktan çalıştırdığınızda, Invoke-Command döndüren Start-Job aynı iş nesnesi türünü döndürür. İş nesnesini bir değişkene kaydedebilir veya işi almak için bir Get-Job komut kullanabilirsiniz.

Location özelliğinin değerinin, iş Server01 bilgisayarında çalıştırılsa bile işin "LocalHost" olarak bilinen yerel bilgisayarda çalıştığını gösterdiğini unutmayın. İş nesnesi Server01 bilgisayarında oluşturulduğundan ve iş aynı bilgisayarda çalıştığından, yerel bir arka plan işi olarak kabul edilir.
Uzak bir işi yönetmek için İş cmdlet'lerini kullanın. İş nesnesi uzak bilgisayarda olduğundan, iş sonuçlarını almak, durdurmak, beklemek veya almak için uzak komutları çalıştırmanız gerekir.

İşin tamamlandığını görmek için bir Invoke-Command komut kullanarak Server01 bilgisayarına bağlı PSSession'da bir Get-Job komut çalıştırın.
```
Invoke-Command -session $s -scriptblock {Get-Job}
```
komutu bir iş nesnesi döndürür. İş nesnesinin State özelliği komutun başarıyla tamamlandığını gösterir.
```
SessionId   Name  State      HasMoreData   Location   Command
---------   ----  -----      -----------   --------   -------
2           Job2  Completed  True          LocalHost   Get-Eventlog system
```
İşin sonuçlarını almak için cmdlet'ini Invoke-Command kullanarak Server01 bilgisayarına bağlı PSSession'da bir Receive-Job komut çalıştırın.

Aşağıdaki komut, Receive-Job işin sonuçlarını almak için cmdlet'ini kullanır. İşi tanımlamak için oturum kimliğini kullanır. Bu komut, iş sonuçlarını değişkene $results kaydeder. Uzak bilgisayardaki iş önbelleğinde sonucu tutmak için Keep parametresini Receive-Job kullanır.
```
$results = Invoke-Command -session $s -scriptblock {
  Receive-Job -SessionId 2 -Keep
}
```
Ayrıca sonuçları yerel veya uzak bilgisayardaki bir dosyaya yeniden yönlendirebilirsiniz. Aşağıdaki komut, sonuçları Server01 bilgisayarındaki bir dosyaya kaydetmek için yeniden yönlendirme işlecini kullanır.
```
Invoke-Command -session $s -command {
  Receive-Job -SessionId 2 > c:\logs\pslog.txt
}
```

Ayrılmış işlem olarak çalıştırma

Daha önce belirtildiği gibi, üst oturum sonlandırıldığında, çalışan tüm alt işler kendi alt işlemleriyle birlikte sonlandırılır. Geçerli PowerShell oturumuna bağlı olmayan işleri çalıştırmak için yerel makinede uzaktan iletişim özelliğini kullanabilirsiniz.

Yerel makinede yeni bir PowerShell oturumu oluşturun. Bu oturumda bir iş başlatmak için kullanılır Invoke-Command . Invoke-Command uzak oturumun bağlantısını kesmenize ve üst oturumu sonlandırmanıza olanak tanır. Daha sonra yeni bir PowerShell oturumu başlatabilir ve işi izlemeye devam etmek için daha önce bağlantısı kesilmiş olan oturuma bağlanabilirsiniz. Ancak, özgün PowerShell oturumuna döndürülen tüm veriler, bu oturum sonlandırıldığında kaybolur. Yalnızca bağlantı kesildikten sonra oluşturulan yeni veri nesneleri yeniden bağlandığında döndürülür.

# 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
...

Bu örnekte işler yine de bir üst PowerShell oturumuna eklenmiştir. Ancak üst oturum, çalıştırıldığı Invoke-Command özgün PowerShell oturumu değildir.