Linux Command Line & Bash Scripting Mastery · Pelajaran

Pipeline Streaming dan Named Pipe untuk Throughput

Gunakan FIFO dan substitusi proses untuk mengalirkan data antar tahap tanpa file perantara.

Pipeline Streaming dan Named Pipe untuk Throughput adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 4 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.

Mengapa Berkas Perantara Mengurangi Laju Pemrosesan

Saat Anda merangkai perintah seperti sort file.txt > tmp.txt && uniq tmp.txt > result.txt, Anda menanggung biaya tersembunyi: penulisan ke disk, pembacaan dari disk, dan alur pemrosesan terhenti hingga tahap pertama selesai sepenuhnya sebelum tahap berikutnya dimulai.

Alur pemrosesan streaming menghilangkan biaya tersebut. Data mengalir langsung dari produsen ke konsumen di memori, tahap demi tahap, secara bersamaan. Inilah gagasan inti di balik pipe Unix — dan named pipe (FIFO) mengembangkannya lebih jauh.

Pipe anonim (|): menghubungkan dua perintah yang bersebelahan pada baris shell yang sama.
Pipe bernama (FIFO): berkas khusus dalam sistem berkas yang memungkinkan proses-proses yang tidak saling terkait mengalirkan data satu sama lain.
Substitusi proses: memungkinkan suatu perintah memperlakukan keluaran perintah lain seolah-olah keluaran tersebut adalah sebuah berkas.

Pelajaran ini menunjukkan cara menerapkan ketiganya untuk memaksimalkan laju pemrosesan dalam alur kerja Bash di dunia nyata.

Anatomi Alur Pemrosesan Streaming

Pipe anonim menghubungkan stdout dari satu proses ke stdin proses berikutnya. Kernel membuat kedua proses tetap berjalan secara bersamaan dalam penyangga di memori berukuran tetap (biasanya 64 KB di Linux).

Inti pemahamannya: kecepatan alur pemrosesan sama dengan tahapnya yang paling lambat. Jika produsen lebih cepat, produsen akan terblokir saat penyangga penuh. Jika konsumen lebih cepat, konsumen akan terblokir saat penyangga kosong. Tekanan balik ini merupakan pengendalian aliran yang otomatis dan tidak memerlukan biaya tambahan.

Contoh di bawah menghitung alamat IP unik dalam log akses besar tanpa pernah menulis berkas sementara. Setiap tahap berjalan secara bersamaan:

#!/usr/bin/env bash
# Stream a 2 GB access log — all stages run in parallel
grep '"GET' /var/log/nginx/access.log \
  | awk '{print $1}' \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -20

Membuat Pipe Bernama dengan mkfifo

Pipe bernama (FIFO — First In, First Out) dibuat dengan mkfifo. Pipe ini muncul dalam sistem berkas seperti berkas biasa, tetapi data yang ditulis ke dalamnya tidak pernah disimpan di disk — data mengalir langsung ke proses pembaca.

Perilaku penting yang perlu diingat:

Penulisan ke FIFO akan terblokir hingga pembaca membukanya, begitu pula sebaliknya.
Entri FIFO tetap ada dalam sistem berkas; Anda harus menghapusnya dengan rm setelah selesai.
Beberapa penulis diperbolehkan, tetapi urutan di antara mereka tidak dijamin.

Di bawah ini: produsen memampatkan data ke dalam FIFO sementara konsumen mengunggahnya ke S3 secara bersamaan — tidak memerlukan berkas sementara.

#!/usr/bin/env bash
mkfifo /tmp/stream_pipe

# Producer: compress in background
gzip -c /var/log/syslog > /tmp/stream_pipe &

# Consumer: read from FIFO (runs in foreground)
wc -l < /tmp/stream_pipe

wait
rm /tmp/stream_pipe

Substitusi Proses: Memperlakukan Perintah sebagai Berkas

Substitusi proses menggunakan sintaks <(command) atau >(command). Bash membuat FIFO (atau deskriptor berkas /dev/fd/N) di balik layar dan meneruskan jalurnya ke perintah luar.

Fitur ini sangat berguna saat suatu alat mengharapkan argumen nama berkas, bukan stdin. Tanpa substitusi proses, Anda perlu menggunakan berkas sementara; dengan substitusi proses, Anda dapat mengalirkan data secara langsung.

<(cmd) — perintah luar membaca keluaran cmd.
>(cmd) — perintah luar menulis ke masukan cmd.

#!/usr/bin/env bash
# diff two sorted streams without creating temp files
diff <(sort /etc/passwd) <(sort /etc/group)

# Compare live command output against a baseline
diff <(ls /usr/bin | sort) <(cat ~/bin_baseline.txt | sort)

Tee: Membagi Aliran ke Beberapa Konsumen

tee membaca stdin dan menulisnya ke stdout serta satu atau beberapa berkas. Jika digabungkan dengan substitusi proses, Anda dapat membagi satu aliran ke beberapa alur pemrosesan secara bersamaan — semuanya tanpa menyentuh disk.

Pola ini berguna ketika Anda ingin, misalnya, mencatat data mentah dan memprosesnya pada saat yang sama.

#!/usr/bin/env bash
# Generate 100000 random numbers, then simultaneously:
#  1. compute the sum
#  2. find the maximum
#  3. count lines (saved to a variable)
seq 1 100000 \
  | tee >(awk '{s+=$1} END{print "Sum:", s}') \
        >(awk 'BEGIN{m=0} $1>m{m=$1} END{print "Max:", m}') \
  | wc -l | xargs echo "Count:"

Pola Fan-Out: Satu Produsen, Banyak Konsumen

Saat satu sumber data harus memasok beberapa konsumen independen, gabungkan tee dengan beberapa substitusi proses >(). Setiap konsumen menerima seluruh aliran dan berjalan secara bersamaan.

Dengan cara ini, Anda tidak perlu membaca berkas sumber berkali-kali. Untuk berkas berukuran 10 GB, perbedaannya sangat besar — cukup satu pembacaan disk, bukan N pembacaan.

#!/usr/bin/env bash
# Read a large CSV once; simultaneously:
#  - count rows
#  - extract column 2 to a file
#  - pass column 3 to a stats script
cat large_data.csv \
  | tee \
      >(wc -l > /tmp/row_count.txt) \
      >(cut -d',' -f2 > /tmp/col2.txt) \
      >(cut -d',' -f3 | awk '{sum+=$1} END{print sum}' > /tmp/col3_sum.txt) \
  > /dev/null

echo "Rows:" $(cat /tmp/row_count.txt)
echo "Col3 sum:" $(cat /tmp/col3_sum.txt)

Pola Fan-In: Banyak Produsen, Satu Konsumen

Kebalikan dari fan-out adalah fan-in: beberapa sumber independen mengalirkan data ke satu konsumen. FIFO bernama membuatnya mudah dilakukan.

Salah satu penggunaan umum: menggabungkan aliran log dari beberapa server secara waktu nyata, atau mengagregasikan hasil sebagian dari pekerja paralel.

Perhatikan bahwa dengan beberapa penulis, konsumen akan melihat keluaran yang tersisip — ini tidak masalah untuk data berorientasi baris yang setiap barisnya berdiri sendiri, tetapi Anda harus menangani pengurutan sendiri jika urutan penting.

#!/usr/bin/env bash
mkfifo /tmp/fanin_pipe

# Three producers write concurrently into the same FIFO
for host in web1 web2 web3; do
  ssh "$host" 'tail -n 500 /var/log/app.log' > /tmp/fanin_pipe &
done

# Single consumer reads all merged output
grep 'ERROR' /tmp/fanin_pipe | sort | uniq -c | sort -rn

wait
rm /tmp/fanin_pipe

Menggunakan mkfifo untuk Kompresi Paralel

Salah satu penggunaan FIFO yang paling praktis adalah kompresi paralel. Alat seperti pigz (gzip paralel) atau pbzip2 membaca aliran; Anda dapat menyalurkan data mentah secara langsung tanpa membuat berkas yang belum dikompresi terlebih dahulu.

Pola di bawah mengarsipkan sebuah direktori, memampatkannya dengan seluruh inti CPU, dan mengalirkan hasilnya ke host jarak jauh — semuanya secara bersamaan:

#!/usr/bin/env bash
# Tar + parallel compress + stream to remote — no temp files
# Requires: pigz (parallel gzip)
tar cf - /data/large_dir \
  | pigz -p 4 \
  | ssh backup-host 'cat > /backups/large_dir.tar.gz'

# Verify the remote file exists
ssh backup-host 'ls -lh /backups/large_dir.tar.gz'

Mengendalikan Ukuran Penyangga dan Pemblokiran

Pipe memiliki penyangga kernel (biasanya 64 KB). Saat penyangga penuh, penulis akan terblokir; saat kosong, pembaca akan terblokir. Biasanya inilah yang Anda inginkan, tetapi dalam beberapa kasus pemblokiran dapat menyebabkan kebuntuan.

Risiko kebuntuan: jika proses A menulis ke FIFO1 dan membaca dari FIFO2, sementara proses B menulis ke FIFO2 dan membaca dari FIFO1, keduanya dapat terblokir sambil menunggu proses lainnya membaca terlebih dahulu.

Solusi:

Jalankan setidaknya satu sisi di latar belakang (&) agar tidak memblokir shell.
Gunakan mbuffer atau pv untuk menambahkan penyangga dalam memori yang lebih besar di antara tahap-tahap.
Gunakan pv -q -B 128m untuk menyisipkan penyangga 128 MB sehingga lonjakan laju pemrosesan menjadi lebih lancar.

#!/usr/bin/env bash
# pv adds a 64 MB buffer and shows throughput
# Useful when producer and consumer have bursty speeds
dd if=/dev/urandom bs=1M count=200 \
  | pv -B 64m \
  | gzip \
  | wc -c

Contoh Praktis: Pengagregasi Log Waktu Nyata

Berikut pola lengkap yang realistis: pantau beberapa berkas log, gabungkan alirannya melalui pipe bernama, saring kesalahan, dan tulis ringkasan langsung — semuanya tanpa berkas perantara dan dengan semua tahap berjalan secara paralel.

Alur pemrosesan seperti inilah yang biasanya dijalankan sebagai skrip pemantauan latar belakang pada server produksi.

#!/usr/bin/env bash
FIFO=/tmp/log_aggregator
mkfifo "$FIFO"

cleanup() { rm -f "$FIFO"; }
trap cleanup EXIT INT TERM

# Fan-in: tail multiple logs into the FIFO
tail -F /var/log/syslog /var/log/auth.log > "$FIFO" &
TAIL_PID=$!

# Consumer: filter and timestamp errors in real time
grep --line-buffered -i 'error\|fail\|crit' "$FIFO" \
  | while IFS= read -r line; do
      printf '[%s] %s\n' "$(date '+%H:%M:%S')" "$line"
    done

kill "$TAIL_PID" 2>/dev/null

Membandingkan Kinerja Alur Pemrosesan dengan Berkas Sementara

Anda dapat mengukur perbedaan laju pemrosesan yang sebenarnya antara pendekatan streaming dan berkas sementara menggunakan time. Pendekatan alur pemrosesan lebih unggul pada kumpulan data besar karena:

Tahap-tahap berjalan secara bersamaan — CPU dan I/O berlangsung tumpang tindih.
Tidak ada I/O disk untuk data perantara — hanya keluaran akhir yang ditulis ke disk.
Jejak memori tetap konstan terlepas dari ukuran masukan (data dialirkan, bukan disangga seluruhnya).

Uji kinerja sederhana untuk membandingkan kedua pendekatan:

#!/usr/bin/env bash
# Approach 1: Temp file (sequential)
time bash -c '
  seq 1 5000000 > /tmp/nums.txt
  sort -n /tmp/nums.txt > /tmp/sorted.txt
  uniq /tmp/sorted.txt | wc -l
  rm /tmp/nums.txt /tmp/sorted.txt
'

echo '---'

# Approach 2: Streaming pipeline (concurrent)
time bash -c 'seq 1 5000000 | sort -n | uniq | wc -l'

Uji Pemahaman: Perilaku Pemblokiran Pipe Bernama

Perhatikan skrip berikut:

mkfifo /tmp/mypipe
echo 'hello' > /tmp/mypipe
echo 'done'

Apa yang terjadi saat skrip ini dijalankan tanpa proses latar belakang atau pembaca?

Ringkasan: Alur Streaming dan Pipa Bernama

Dalam pelajaran ini, Anda mempelajari cara memindahkan data secara efisien antarproses tanpa berkas perantara:

Pipa anonim (|) menghubungkan perintah yang berdekatan dan menjalankan semua tahap secara bersamaan dengan pengaturan tekanan balik otomatis.
Pipa bernama (mkfifo) membuat entri sistem berkas FIFO yang memungkinkan proses yang tidak saling terkait atau berjalan di latar belakang melakukan streaming satu sama lain — penulisan akan terblokir hingga tersedia pembaca.
Substitusi proses (<(cmd), >(cmd)) memungkinkan perintah yang mengharapkan nama berkas menggunakan atau menghasilkan aliran secara transparan.
tee + >() membagi satu aliran ke beberapa konsumen secara bersamaan tanpa membaca ulang sumbernya.
Penggabungan masuk menggabungkan beberapa produsen menjadi satu konsumen melalui FIFO bersama.
Tekanan balik dan pemblokiran adalah fitur, bukan kutu — tetapi selalu jalankan setidaknya satu sisi pasangan FIFO di latar belakang untuk menghindari kebuntuan.
Gunakan pv atau mbuffer untuk menambahkan penyangga yang lebih besar dan memantau laju keluaran ketika tahap-tahapnya menghasilkan data secara berkelompok.

Teknik-teknik ini merupakan dasar rekayasa data Bash berthroughput tinggi: proses data berskala GB dengan memori konstan serta paralelisme CPU/IO maksimum.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pipeline Streaming dan Named Pipe untuk Throughput” gratis?

Ya — teks lengkap “Pipeline Streaming dan Named Pipe untuk Throughput” 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 “Pipeline Streaming dan Named Pipe untuk Throughput”?

Gunakan FIFO dan substitusi proses untuk mengalirkan data antar tahap tanpa file perantara. 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 4 dari 4.

Berapa lama pelajaran “Pipeline Streaming dan Named Pipe untuk Throughput” 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

Membuat Profil Skrip dan Menghindari Subshell yang Tidak Berguna
Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang
Mengorkestrasi Beban Kerja dengan GNU parallel
Pipeline Streaming dan Named Pipe untuk Throughput

← Kembali ke Linux Command Line & Bash Scripting Mastery