0Pricing
Linux Command Line & Bash Scripting Mastery · Pelajaran

Mengorkestrasi Beban Kerja dengan GNU parallel

Distribusikan kumpulan input besar ke berbagai core dengan GNU parallel, slot pekerjaan, dan pengurutan hasil.

Mengorkestrasi Beban Kerja dengan GNU parallel adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa Itu GNU parallel dan Mengapa Menggunakannya?

GNU parallel adalah alat shell yang memungkinkan Anda menjalankan pekerjaan secara paralel pada satu atau beberapa mesin. Alih-alih memproses daftar item yang besar satu per satu dalam perulangan for, parallel membagi pekerjaan tersebut ke seluruh inti CPU yang tersedia secara bersamaan.

  • Kecepatan: Tugas yang memerlukan 8 menit jika dijalankan berurutan dapat selesai dalam sekitar 1 menit pada mesin dengan 8 inti.
  • Kesederhanaan: Alat ini menerima input dari stdin, file, atau daftar argumen — tanpa pengelolaan proses secara manual.
  • Keamanan: Output dari pekerjaan yang berbeda tetap terpisah; hasil tidak pernah tercampur.

Pasang dengan sudo apt install parallel (Debian/Ubuntu) atau brew install parallel (macOS). Verifikasi dengan parallel --version.

Perintah parallel Pertama Anda

Bentuk paling sederhana dari parallel membaca item dari stdin dan menjalankan sebuah perintah untuk setiap item. Placeholder {} mewakili item input saat ini.

Contoh di bawah mengompresi lima file catatan secara bersamaan menggunakan gzip. Tanpa parallel, setiap file akan dikompresi satu per satu. Dengan alat ini, hingga N file (dengan N = jumlah inti CPU) dikompresi pada saat yang sama.

#!/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

Mengontrol Slot Pekerjaan dengan -j

Secara bawaan, parallel menjalankan satu pekerjaan untuk setiap inti CPU. Anda dapat mengubahnya dengan flag -j (atau --jobs).

  • -j 4 — menjalankan tepat 4 pekerjaan sekaligus
  • -j 0 — menjalankan pekerjaan sebanyak jumlah input (gunakan dengan hati-hati!)
  • -j 200% — menjalankan pekerjaan dua kali lebih banyak daripada jumlah inti CPU (berguna untuk pekerjaan yang dibatasi I/O)
  • -j 50% — hanya menggunakan setengah inti yang tersedia

Untuk tugas yang dibatasi CPU, -j $(nproc) sering kali optimal. Untuk tugas I/O jaringan atau disk, Anda dapat melampaui jumlah inti dengan aman karena pekerjaan menghabiskan sebagian besar waktunya untuk menunggu.

#!/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."

Membaca Input dari File dan Argumen

parallel fleksibel dalam menentukan sumber daftar input. Anda tidak terbatas pada pipe dari stdin.

  • Dari sebuah file: parallel -a urls.txt wget {}
  • Daftar argumen sebaris: parallel echo ::: apple banana cherry
  • Beberapa sumber argumen (produk Kartesius): parallel echo {1}-{2} ::: a b c ::: 1 2 — menghasilkan a-1, a-2, b-1, b-2, c-1, c-2
  • Secara eksplisit dari stdin: cat list.txt | parallel -j4 process {}

Pemisah ::: memberi tahu parallel untuk menggunakan nilai-nilai berikutnya sebagai sumber argumen, bukan membaca dari stdin.

#!/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

Placeholder: Memanipulasi Token Input

parallel menyediakan beberapa substitusi placeholder yang memungkinkan Anda mengekstrak bagian-bagian string input secara otomatis — sangat berguna ketika input berupa jalur file.

  • {} — item input lengkap
  • {.} — input tanpa ekstensi file (report.csv → report)
  • {/} — hanya nama dasar (menghapus jalur direktori)
  • {//} — hanya jalur direktori
  • {/.} — nama dasar tanpa ekstensi

Dengan demikian, Anda tidak perlu memanggil basename / dirname di dalam perintah pekerjaan, sehingga pipeline menjadi lebih bersih dan cepat.

#!/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)'

Menjaga Urutan Output dengan --keep-order

Ketika pekerjaan selesai pada waktu yang berbeda, output stdout-nya muncul sesuai urutan penyelesaiannya. Hal ini dapat membuat catatan sulit dibaca dan penguraian lanjutan tidak dapat diandalkan.

Dua flag mengatur urutan output:

  • --keep-order (-k) — mencetak output setiap pekerjaan dalam urutan yang sama seperti input, meskipun pekerjaan berikutnya selesai lebih dahulu. Output disimpan dalam buffer hingga pekerjaan sebelumnya selesai.
  • --line-buffer — pilihan tengah: mengeluarkan baris lengkap saat tiba, tanpa menunggu pekerjaan selesai, tetapi tidak pernah mencampur baris yang baru ditulis sebagian.

Gunakan -k ketika penerima downstream mengharapkan hasil dalam urutan input (misalnya, saat membuat laporan terurut). Abaikan flag ini ketika urutan tidak penting dan Anda ingin melihat hasil sesegera mungkin.

#!/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 {}"'

Mengelompokkan Keluaran untuk Mencegah Penyisipan Antarpekerjaan

Meskipun keluaran sudah diurutkan, jika suatu pekerjaan mencetak beberapa baris, baris-baris tersebut dapat tersisip dengan baris dari pekerjaan lain yang berjalan secara bersamaan. parallel mengatasi hal ini secara otomatis dengan menyangga seluruh stdout dan stderr setiap pekerjaan, lalu mencetaknya sebagai satu blok atomik setelah pekerjaan selesai.

Perilaku ini aktif secara bawaan. Anda dapat menonaktifkannya dengan --ungroup jika memerlukan keluaran yang dialirkan secara langsung (misalnya, pekerjaan yang berjalan lama dengan bilah kemajuan), tetapi penyisipan antarpekerjaan dapat terjadi lagi.

  • Bawaan: keluaran dikelompokkan per pekerjaan — aman untuk diurai.
  • --ungroup: keluaran dialirkan secara langsung — cocok untuk pemantauan interaktif.
  • --line-buffer: kompromi — baris tidak pernah terpecah, tetapi pekerjaan dapat tersisip pada batas baris.

Meneruskan Argumen di Dalam Fungsi Shell

Terkadang pekerjaan yang ingin Anda jalankan secara paralel lebih dari sekadar satu perintah — pekerjaan tersebut merupakan fungsi shell yang terdiri dari beberapa langkah. Anda dapat meneruskan fungsi ke parallel menggunakan export -f yang dikombinasikan dengan env_parallel, atau dengan memanggil bash -c secara langsung.

Pendekatan portabel yang paling aman untuk pekerjaan kompleks adalah pola bash -c '...'. Placeholder {} diteruskan sebagai $1 jika perintah diakhiri dengan _ {}.

#!/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 {}

Membatasi Laju dan Mengulangi dengan --delay dan --retries

Saat mengakses layanan eksternal (API, server jarak jauh, basis data) secara paralel, Anda sering memerlukan pembatasan laju dan toleransi terhadap kegagalan.

  • --delay N — tunggu N detik di antara dimulainya setiap pekerjaan baru (nilai pecahan seperti 0.5 diperbolehkan). Mencegah layanan dibanjiri permintaan.
  • --retries N — jika suatu pekerjaan selesai dengan status bukan nol, ulangi hingga N kali sebelum menyerah. Setiap percobaan ulang dihitung sebagai slot pekerjaan baru.
  • --timeout N — hentikan pekerjaan jika berjalan lebih lama dari N detik. Jika digabungkan dengan --retries, opsi ini menangani pekerjaan yang macet dengan baik.

Contoh: mengunduh 50 URL dengan paling banyak 4 koneksi bersamaan, jeda peningkatan 0,5 detik di antara waktu mulai, dan 3 kali percobaan ulang saat gagal.

#!/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.'

Mendistribusikan Pekerjaan ke Host Jarak Jauh dengan --sshloginfile

parallel dapat mendistribusikan pekerjaan secara transparan ke mesin jarak jauh melalui SSH, sehingga menjadi alat komputasi kluster ringan tanpa perangkat lunak kluster khusus.

  • --sshlogin user@host — jalankan pekerjaan pada host jarak jauh tertentu.
  • --sshloginfile machines.txt — baca daftar host dari sebuah berkas (satu host per baris). Gunakan : sebagai entri khusus untuk turut menggunakan mesin lokal.
  • --transfer — salin berkas masukan ke host jarak jauh sebelum diproses.
  • --return {} — salin berkas hasil kembali setelah pekerjaan selesai.
  • --cleanup — hapus berkas yang ditransfer dari host jarak jauh setelah diambil.

Host jarak jauh tersebut harus sudah memasang parallel dan mengonfigurasi autentikasi berbasis kunci SSH (tanpa permintaan kata sandi).

Melaporkan Kemajuan dan Melakukan Pencatatan

Untuk beban kerja yang berjalan lama, pemantauan kemajuan dan diagnosis kegagalan setelah kejadian sangatlah penting.

  • --progress — mencetak baris ringkasan langsung yang menunjukkan jumlah pekerjaan yang sedang berjalan, telah selesai, dan tersisa.
  • --eta — memperkirakan waktu hingga selesai berdasarkan durasi rata-rata pekerjaan sejauh ini.
  • --joblog results.log — menulis berkas log yang dipisahkan tab, dengan satu baris untuk setiap pekerjaan yang selesai, termasuk kode keluar, waktu berjalan, dan perintah yang dijalankan. Sangat berguna untuk mengaudit kegagalan.
  • --resume --joblog results.log — melewati pekerjaan yang sudah tercantum (dengan kode keluar 0) dalam berkas log. Jika proses batch terhenti, Anda dapat melanjutkannya tanpa mengulangi pekerjaan yang berhasil.

Kombinasi --joblog + --resume merupakan salah satu fitur GNU parallel yang paling kuat untuk alur pemrosesan produksi yang andal.

#!/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"

Uji Pemahaman: Opsi Slot Pekerjaan

Uji pemahaman Anda tentang cara parallel mengendalikan konkurensi.

Ringkasan Pelajaran: Mengatur Beban Kerja dengan GNU parallel

Anda telah mempelajari perangkat inti untuk mendistribusikan kumpulan masukan besar ke seluruh inti CPU dengan GNU parallel. Berikut hal-hal penting yang perlu diingat:

  • Penggunaan dasar: salurkan daftar ke parallel command {} — {} digantikan oleh setiap item masukan.
  • Slot pekerjaan (-j): kendalikan konkurensi secara tepat — gunakan jumlah inti untuk pekerjaan yang terikat CPU, dan persentase yang lebih tinggi untuk pekerjaan yang terikat I/O.
  • Placeholder ({.}, {/}, {//}, {/.}) mengekstrak komponen jalur dengan rapi tanpa perintah tambahan.
  • Pengendalian keluaran: -k mempertahankan urutan masukan; pengelompokan bawaan mencegah penyisipan antarbaris; --ungroup menyediakan pengaliran langsung.
  • Ketahanan: --retries, --timeout, dan --delay membuat alur pemrosesan paralel tangguh terhadap pekerjaan yang tidak andal dan batas laju.
  • Kemampuan audit: --joblog mencatat hasil setiap pekerjaan; --resume memungkinkan Anda melanjutkan dari titik terakhir setelah terjadi gangguan.
  • Penskalaan keluar: --sshloginfile mendistribusikan pekerjaan ke mesin jarak jauh melalui SSH tanpa beban kluster tambahan.

Dengan menguasai opsi-opsi ini, parallel berubah menjadi pengatur beban kerja setara produksi yang langsung tersedia di dalam shell Anda.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengorkestrasi Beban Kerja dengan GNU parallel” gratis?

Ya — teks lengkap “Mengorkestrasi Beban Kerja dengan GNU parallel” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengorkestrasi Beban Kerja dengan GNU parallel”?

Distribusikan kumpulan input besar ke berbagai core dengan GNU parallel, slot pekerjaan, dan pengurutan hasil. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Mengorkestrasi Beban Kerja dengan GNU parallel” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Membuat Profil Skrip dan Menghindari Subshell yang Tidak Berguna
  2. Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang
  3. Mengorkestrasi Beban Kerja dengan GNU parallel
  4. Pipeline Streaming dan Named Pipe untuk Throughput
← Kembali ke Linux Command Line & Bash Scripting Mastery