0Pricing
DevOps Bootcamp · Ders

GNU parallel ile İş Yüklerini Orkestre Etme

Büyük girdi kümelerini GNU parallel, iş yuvaları ve sonuç sıralamasıyla çekirdekler arasında dağıtın.

GNU parallel ile İş Yüklerini Orkestre Etme, CoddyKit'te ücretsiz bir DevOps Bootcamp dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, DevOps Bootcamp öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. DevOps Bootcamp kursu toplamda 4 dersten oluşur.

GNU parallel Nedir ve Neden Kullanılır?

GNU parallel, işleri bir veya birden fazla makinede paralel olarak çalıştırmanızı sağlayan bir kabuk aracıdır. Büyük bir öğe listesini for döngüsünde tek tek işlemek yerine parallel, işi kullanılabilir tüm CPU çekirdeklerine aynı anda dağıtır.

  • Hız: Sıralı olarak 8 dakika süren bir görev, 8 çekirdekli bir makinede yaklaşık 1 dakikada tamamlanabilir.
  • Basitlik: Girdiyi standart girdiden, dosyalardan veya bağımsız değişken listelerinden kabul eder — elle süreç yönetimi gerekmez.
  • Güvenlik: Farklı işlerin çıktıları ayrı tutulur; sonuçlar hiçbir zaman birbirine karışmaz.

sudo apt install parallel (Debian/Ubuntu) veya brew install parallel (macOS) ile yükleyin. parallel --version ile doğrulayın.

İlk parallel Komutunuz

parallel'in en basit biçimi standart girdiden öğeleri okur ve her biri için bir komut çalıştırır. {} yer tutucusu geçerli girdi öğesini temsil eder.

Aşağıdaki örnek, beş günlük dosyasını gzip kullanarak eşzamanlı biçimde sıkıştırır. parallel olmadan her dosya birbiri ardına sıkıştırılırdı. Bununla birlikte, en fazla N dosya (N = CPU çekirdeği sayısı) aynı anda sıkıştırılır.

#!/usr/bin/env bash
# Create sample files first
for i in 1 2 3 4 5; do
  dd if=/dev/urandom bs=1M count=2 of="log_${i}.txt" 2>/dev/null
done

# Compress all of them in parallel
ls log_*.txt | parallel gzip {}

echo "Done. Compressed files:"
ls log_*.txt.gz

-j ile İş Yuvalarını Denetleme

Varsayılan olarak parallel, CPU çekirdeği başına bir iş çalıştırır. Bunu -j (veya --jobs) seçeneğiyle değiştirebilirsiniz.

  • -j 4 — aynı anda tam olarak 4 iş çalıştırır
  • -j 0 — girdi sayısı kadar iş çalıştırır (dikkatli kullanın!)
  • -j 200% — CPU çekirdeği sayısının iki katı kadar iş çalıştırır (G/Ç'ye bağlı işler için kullanışlıdır)
  • -j 50% — kullanılabilir çekirdeklerin yalnızca yarısını kullanır

CPU'ya bağlı görevlerde -j $(nproc) çoğu zaman en uygun değerdir. Ağ veya disk G/Ç'si görevlerinde işlerin çoğu zamanını bekleyerek geçirmesi nedeniyle çekirdek sayısını güvenle aşabilirsiniz.

#!/usr/bin/env bash
# Show how many cores are available
echo "CPU cores: $(nproc)"

# Run 8 sleep jobs but limit to 3 at a time
# -j 3 means at most 3 jobs run simultaneously
seq 1 8 | parallel -j 3 'echo "Starting job {}"; sleep 1; echo "Done job {}"'

echo "All jobs finished."

Dosyalardan ve Bağımsız Değişkenlerden Girdi Okuma

parallel, girdi listesini nereden okuduğu konusunda esnektir. Girdiyi standart girdiden pipe ile aktarmakla sınırlı değilsiniz.

  • Bir dosyadan: parallel -a urls.txt wget {}
  • Satır içi bağımsız değişken listesi: parallel echo ::: apple banana cherry
  • Birden çok bağımsız değişken kaynağı (Kartezyen çarpım): parallel echo {1}-{2} ::: a b c ::: 1 2 — a-1, a-2, b-1, b-2, c-1, c-2 üretir
  • Açıkça standart girdiden: cat list.txt | parallel -j4 process {}

::: ayırıcı, parallel'e aşağıdaki değerleri standart girdiden okumak yerine bir bağımsız değişken kaynağı olarak kullanmasını söyler.

#!/usr/bin/env bash
# Inline list with :::
parallel echo 'Hello from {}' ::: Alice Bob Carol Dave

echo '---'

# Cartesian product: combine two lists
# Generates: dev-v1, dev-v2, prod-v1, prod-v2
parallel echo 'Deploy {1} to env {2}' ::: v1 v2 ::: dev prod

Yer Tutucular: Girdi Belirteçlerini Değiştirme

parallel, girdi dizgesinin bölümlerini otomatik olarak ayıklamanızı sağlayan çeşitli yer tutucu değişimleri sunar — girdiler dosya yolları olduğunda çok kullanışlıdır.

  • {} — girdi öğesinin tamamı
  • {.} — dosya uzantısı olmadan girdi (report.csv → report)
  • {/} — yalnızca temel ad (dizin yolunu kaldırır)
  • {//} — yalnızca dizin yolu
  • {/.} — uzantısı olmayan temel ad

Bunlar iş komutlarının içinde basename / dirname çağrılarına duyulan ihtiyacı ortadan kaldırarak pipeline'ları daha temiz ve hızlı hâle getirir.

#!/usr/bin/env bash
# Demonstrate placeholder substitutions
parallel --dry-run 'convert {} -resize 800x600 {.}_thumb.jpg' \
  ::: /photos/vacation/beach.png /photos/work/team.png

# {.}  strips extension: /photos/vacation/beach
# Result command shown (--dry-run does NOT execute):
#  convert /photos/vacation/beach.png -resize 800x600 /photos/vacation/beach_thumb.jpg
#  convert /photos/work/team.png      -resize 800x600 /photos/work/team_thumb.jpg
echo 'No files were changed (dry run)'

--keep-order ile Çıktıyı Sıralı Tutma

İşler farklı zamanlarda tamamlandığında standart çıktı, tamamlanma sırasına göre görüntülenir. Bu durum günlüklerin okunmasını zorlaştırabilir ve sonraki ayrıştırmayı güvenilmez hâle getirebilir.

Çıktı sıralamasını iki seçenek denetler:

  • --keep-order (-k) — daha sonraki bir iş önce tamamlansa bile her işin çıktısını girdideki sırayla yazdırır. Çıktı, önceki işler tamamlanana kadar arabelleğe alınır.
  • --line-buffer — ara bir yaklaşımdır: işin tamamlanmasını beklemeden, satırlar geldikçe tamamlanmış satırları üretir; ancak yarım yazılmış satırları hiçbir zaman birbirine karıştırmaz.

Sonraki tüketici sonuçları girdi sırasına göre bekliyorsa (ör. sıralı bir rapor oluştururken) -k kullanın. Sıra önemli değilse ve sonuçları mümkün olduğunca çabuk görmek istiyorsanız bu seçeneği kullanmayın.

#!/usr/bin/env bash
# Without -k: output order is unpredictable
echo '--- Without --keep-order ---'
seq 5 1 1 | parallel 'sleep 0.$((RANDOM % 5)); echo "Result for {}"'

echo

# With -k: output always appears as 5, 4, 3, 2, 1
echo '--- With --keep-order (-k) ---'
seq 5 1 1 | parallel -k 'sleep 0.$((RANDOM % 5)); echo "Result for {}"'

Çıktıyı Birleştirerek Satırların İç İçe Geçmesini Önleme

Sıralı çıktı kullanılsa bile bir iş birden çok satır yazdırırsa, bu satırlar aynı anda çalışan başka bir işin satırlarıyla iç içe geçebilir. parallel bunu otomatik olarak çözer: her işin stdout ve stderr çıktısının tamamını arabelleğe alır, ardından iş tamamlandığında bunları tek bir atomik blok olarak yazdırır.

Bu davranış varsayılan olarak açıktır. Canlı akış çıktısına ihtiyacınız varsa (örneğin ilerleme çubukları gösteren uzun süreli işler), --ungroup ile devre dışı bırakabilirsiniz; ancak bu durumda satırların iç içe geçmesi yeniden mümkün olur.

  • Varsayılan: çıktı iş başına gruplanır — ayrıştırma için güvenlidir.
  • --ungroup: çıktı canlı olarak akar — etkileşimli izleme için uygundur.
  • --line-buffer: orta yol — satırlar hiçbir zaman bölünmez, ancak işler satır sınırlarında iç içe geçebilir.

Kabuk İşlevleri İçinde Bağımsız Değişken Aktarma

Bazen paralelleştirmek istediğiniz iş tek bir komuttan fazlasıdır; bu iş, birden çok adım içeren bir kabuk işlevidir. export -f ile env_parallel'ı birlikte kullanarak veya doğrudan bash -c çağırarak bir işlevi parallel'a aktarabilirsiniz.

Karmaşık işler için en güvenli taşınabilir yaklaşım bash -c '...' kalıbıdır. {} yer tutucusu, komutu _ {} ile sonlandırdığınızda $1 olarak aktarılır.

#!/usr/bin/env bash
# Define a multi-step processing function
process_item() {
  local item="$1"
  echo "[START] $item"
  # Simulate two steps
  sleep 0.2
  local result=$(echo "$item" | tr '[:lower:]' '[:upper:]')
  echo "[END]   $item -> $result"
}

export -f process_item

# Run the function in parallel for each input
echo 'alpha beta gamma delta epsilon' | tr ' ' '\n' \
  | parallel -j 3 process_item {}

--delay ve --retries ile Hız Sınırlama ve Yeniden Deneme

Harici hizmetlere (API'lere, uzak sunuculara, veritabanlarına) paralel olarak erişirken genellikle hız sınırlama ve hata toleransı gerekir.

  • --delay N — başlatılan her yeni iş arasında N saniye bekler ( 0.5 gibi kesirli değerlere izin verilir). Bir hizmetin istek yağmuruna tutulmasını önler.
  • --retries N — bir iş sıfır olmayan bir durumla çıkarsa, vazgeçmeden önce işi en fazla N kez yeniden dener. Her yeniden deneme yeni bir iş yuvası sayılır.
  • --timeout N — N saniyeden uzun çalışırsa bir işi sonlandırır. --retries ile birlikte kullanıldığında takılan işleri düzgün biçimde ele alır.

Örnek: en fazla 4 eşzamanlı bağlantıyla 50 URL'yi indirmek; başlatmalar arasında 0.5 saniyelik bir hızlanma gecikmesi kullanmak ve başarısızlık durumunda 3 kez yeniden denemek.

#!/usr/bin/env bash
# Simulate downloading URLs with throttling and retries
# (using echo instead of curl so this is self-contained)

download_url() {
  local url="$1"
  # Randomly fail ~30% of the time to demo --retries
  if (( RANDOM % 10 < 3 )); then
    echo "FAIL: $url" >&2
    return 1
  fi
  echo "OK:   $url downloaded"
}

export -f download_url

printf 'https://example.com/file%d\n' $(seq 1 10) \
  | parallel -j 4 --delay 0.2 --retries 3 download_url {}

echo 'All downloads attempted.'

--sshloginfile ile İşi Uzak Ana Bilgisayarlar Arasında Dağıtma

parallel, işleri SSH üzerinden uzak makinelere şeffaf biçimde dağıtabilir. Böylece özel bir küme yazılımına gerek kalmadan hafif bir küme hesaplama aracı olarak kullanılabilir.

  • --sshlogin user@host — işleri belirli bir uzak ana bilgisayarda çalıştırır.
  • --sshloginfile machines.txt — ana bilgisayar listesini bir dosyadan okur (her satırda bir ana bilgisayar). Yerel makineyi de kullanmak için özel bir girdi olarak : kullanın.
  • --transfer — işlenmeden önce girdi dosyasını uzak ana bilgisayara kopyalar.
  • --return {} — iş tamamlandıktan sonra sonuç dosyasını geri kopyalar.
  • --cleanup — alındıktan sonra aktarılan dosyaları uzak ana bilgisayardan siler.

Uzak ana bilgisayarda parallel kurulu olmalı ve SSH anahtarı tabanlı kimlik doğrulama yapılandırılmalıdır (parola istemleri olmamalıdır).

İlerleme Bildirimi ve Günlükleme

Uzun süre çalışan iş yüklerinde ilerlemeyi izlemek ve başarısızlıkları sonradan tanılamak çok önemlidir.

  • --progress — kaç işin çalıştığını, tamamlandığını ve kaldığını gösteren canlı bir özet satırı yazdırır.
  • --eta — o ana kadarki ortalama iş süresine dayanarak tamamlanmaya kalan süreyi tahmin eder.
  • --joblog results.log — tamamlanan her iş için bir satır içeren, sekmelerle ayrılmış bir günlük dosyası yazar; çıkış kodunu, çalışma süresini ve çalıştırılan komutu da içerir. Başarısızlıkları denetlemek için son derece değerlidir.
  • --resume --joblog results.log — günlük dosyasında zaten görünen (çıkış kodu 0 olan) işleri atlar. Bir toplu iş çalışması kesintiye uğrarsa başarılı işleri yeniden yapmadan kaldığınız yerden devam edebilirsiniz.

--joblog + --resume birleşimi, GNU parallel'ın güvenilir üretim işlem hatları için en güçlü özelliklerinden biridir.

#!/usr/bin/env bash
LOGFILE="/tmp/parallel_demo_$$.log"

# Run jobs and record results to a log
seq 1 12 | parallel \
  --jobs 4 \
  --progress \
  --joblog "$LOGFILE" \
  'sleep 0.1; echo "Processed item {}"'

echo
echo '=== Job Log (first 5 entries) ==='
head -6 "$LOGFILE"

# Show only failed jobs (exit value != 0)
echo '=== Failed jobs ==='
awk 'NR>1 && $7 != 0 { print $0 }' "$LOGFILE" || echo '(none)'

rm -f "$LOGFILE"

Bilgi Kontrolü: İş Yuvası Seçenekleri

parallel'ın eşzamanlılığı nasıl denetlediğini anlayıp anlamadığınızı test edin.

Ders Özeti: GNU parallel ile İş Yüklerini Düzenleme

Büyük girdi kümelerini GNU parallel ile CPU çekirdeklerine dağıtmak için gereken temel araçları öğrendiniz. Hatırlamanız gerekenler şunlardır:

  • Temel kullanım: bir listeyi parallel command {} komutuna yönlendirin; {} her girdi öğesiyle değiştirilir.
  • İş yuvaları (-j): eşzamanlılığı hassas biçimde denetler; CPU'ya bağlı işler için çekirdek sayısını, G/Ç'ye bağlı işler için daha yüksek yüzdeleri kullanın.
  • Yer tutucular ({.}, {/}, {//}, {/.}) ek komutlara gerek kalmadan yol bileşenlerini düzgün biçimde ayıklar.
  • Çıktı denetimi: -k girdi sırasını korur; varsayılan gruplama satırların iç içe geçmesini önler; --ungroup canlı akış sağlar.
  • Dayanıklılık: --retries, --timeout ve --delay, paralel işlem hatlarını güvenilmez işlere ve hız sınırlamalarına karşı dayanıklı hâle getirir.
  • Denetlenebilirlik: --joblog her işin sonucunu kaydeder; --resume bir kesintiden sonra kaldığınız yerden devam etmenizi sağlar.
  • Yatay ölçekleme: --sshloginfile, işleri herhangi bir küme ek yükü olmadan SSH üzerinden uzak makinelere dağıtır.

Bu seçeneklerde ustalaşmak, parallel'ı kabuğunuzun içine yerleşik, üretim kalitesinde bir iş yükü düzenleyicisine dönüştürür.

Sıkça Sorulan Sorular

“GNU parallel ile İş Yüklerini Orkestre Etme” dersi ücretsiz mi?

Evet — “GNU parallel ile İş Yüklerini Orkestre Etme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve DevOps Bootcamp kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. DevOps Bootcamp kursu toplamda 4 dersten oluşur.

“GNU parallel ile İş Yüklerini Orkestre Etme” dersinde ne öğreneceğim?

Büyük girdi kümelerini GNU parallel, iş yuvaları ve sonuç sıralamasıyla çekirdekler arasında dağıtın. DevOps Bootcamp ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

DevOps Bootcamp öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te DevOps Bootcamp, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“GNU parallel ile İş Yüklerini Orkestre Etme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu DevOps Bootcamp dersinde kod yazıp çalıştırabilir miyim?

Evet. Her DevOps Bootcamp dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Betikleri Profilleme ve Gereksiz Alt Kabuklardan Kaçınma
  2. xargs -P ve Arka Plan İşleriyle Paralellik
  3. GNU parallel ile İş Yüklerini Orkestre Etme
  4. Veri Akışları ve İş Hacmi için Adlandırılmış Borular
← DevOps Bootcamp Sayfasına Dön