0Pricing
DevOps Bootcamp · Ders

Veri Akışları ve İş Hacmi için Adlandırılmış Borular

Ara dosyalar kullanmadan aşamalar arasında veri akışı sağlamak için FIFO'ları ve işlem ikamesini kullanın.

Veri Akışları ve İş Hacmi için Adlandırılmış Borular, CoddyKit'te ücretsiz bir DevOps Bootcamp dersidir. Bu, 4 dersinin 4. 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.

Ara Dosyalar İş Hacmini Neden Düşürür

sort file.txt > tmp.txt && uniq tmp.txt > result.txt gibi komutları zincirlediğinizde gizli bir bedel ödersiniz: disk yazma işlemleri, disk okuma işlemleri ve ilk aşama tamamen bitene kadar işlem hattının durması.

Akış işlem hatları bu bedeli ortadan kaldırır. Veriler, aşamadan aşamaya, doğrudan üreticiden tüketiciye bellek üzerinden eşzamanlı olarak akar. Unix kanallarının temel fikri budur; adlandırılmış kanallar (FIFO'lar) bu yaklaşımı daha da ileri taşır.

  • Anonim kanal (|): aynı kabuk satırındaki bitişik iki komutu birbirine bağlar.
  • Adlandırılmış kanal (FIFO): ilgisiz işlemlerin birbirine akış göndermesini sağlayan özel bir dosyadır.
  • İşlem ikamesi: bir komutun, başka bir komutun çıktısını dosyaymış gibi ele almasını sağlar.

Bu derste, gerçek dünyadaki Bash iş akışlarında işlem hacmini en üst düzeye çıkarmak için bu üç yöntemi nasıl uygulayacağınızı göreceksiniz.

Akış İşlem Hattının Anatomisi

Anonim bir kanal, bir işlemin stdout'unu sonraki işlemin stdin'ine bağlar. Çekirdek, her iki işlemi de sabit boyutlu bir bellek içi arabellekte (Linux'ta genellikle 64 KB) aynı anda çalışır durumda tutar.

Temel fikir şudur: işlem hattı en yavaş aşaması kadar hızlıdır. Üretici daha hızlıysa dolu bir arabellekte bekler. Tüketici daha hızlıysa boş bir arabellekte bekler. Bu geri basınç, ücretsiz ve otomatik akış denetimidir.

Aşağıdaki örnek, hiç geçici dosya yazmadan büyük bir erişim günlüğündeki benzersiz IP adreslerini sayar. Her aşama eşzamanlı çalışır:

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

mkfifo ile Adlandırılmış Kanallar Oluşturma

Adlandırılmış kanal (FIFO — First In, First Out), mkfifo ile oluşturulur. Dosya sisteminde normal bir dosya gibi görünür; ancak içine yazılan veriler diskte saklanmaz, doğrudan okuyan işleme akar.

Hatırlamanız gereken temel davranışlar:

  • FIFO'ya yapılan yazma işlemi, bir okuyucu onu açana kadar engellenir; bunun tersi de geçerlidir.
  • FIFO girdisi dosya sisteminde kalıcıdır; işiniz bittiğinde rm ile silmeniz gerekir.
  • Birden çok yazıcıya izin verilir; ancak bunlar arasındaki sıralama garanti edilmez.

Aşağıda bir üretici verileri bir FIFO'ya sıkıştırırken bir tüketicinin bunları aynı anda S3'e yüklediği gösterilmektedir; geçici dosyaya gerek yoktur.

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

İşlem İkamesi: Bir Komutu Dosya Gibi Ele Alma

İşlem ikamesi, <(command) veya >(command) söz dizimini kullanır. Bash arka planda bir FIFO (veya /dev/fd/N dosya tanımlayıcısı) oluşturur ve yolu dış komuta aktarır.

Bu yöntem, stdin yerine dosya adı bağımsız değişkeni bekleyen bir araç için güçlüdür. İşlem ikamesi olmadan geçici bir dosyaya ihtiyaç duyardınız; işlem ikamesiyle verileri doğrudan akıtırsınız.

  • <(cmd) — dış komut, cmd'nin çıktısından okur.
  • >(cmd) — dış komut, cmd'nin girdisine yazar.
#!/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: Bir Akışı Birden Çok Tüketiciye Bölme

tee, stdin'den okur ve verileri hem stdout'a hem de bir veya daha fazla dosyaya yazar. İşlem ikamesiyle birlikte kullanıldığında tek bir akışı, diske hiç dokunmadan birden çok işlem hattına aynı anda dağıtabilirsiniz.

Bu kalıp, örneğin ham verileri günlüğe kaydetmek ve aynı anda işlemek istediğinizde kullanışlıdır.

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

Dağıtma Kalıbı: Bir Üretici, Birçok Tüketici

Tek bir veri kaynağının birden çok bağımsız tüketiciyi beslemesi gerektiğinde, tee komutunu birden çok >() işlem ikamesiyle birleştirin. Her tüketici akışın tamamını alır ve eşzamanlı çalışır.

Bu yöntem, kaynak dosyanın birden çok kez okunmasını önler. 10 GB'lık bir dosyada fark çok büyüktür: N okuma yerine tek bir disk okuması yapılır.

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

Birleştirme Kalıbı: Birçok Üretici, Tek Tüketici

Dağıtmanın tersi birleştirmedir: birden çok bağımsız kaynak tek bir tüketiciye akış gönderir. Adlandırılmış FIFO'lar bunu kolaylaştırır.

Yaygın bir kullanım alanı, birkaç sunucudan gelen günlük akışlarını gerçek zamanlı olarak birleştirmek veya paralel çalışanların kısmi sonuçlarını toplamaktır.

Birden çok yazıcı olduğunda tüketicinin iç içe geçmiş bir çıktı göreceğini unutmayın. Bu, her satırın kendi içinde anlamlı olduğu satır tabanlı veriler için uygundur; ancak sıra önemliyse sıralamayı kendiniz yönetmeniz gerekir.

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

Paralel Sıkıştırma için mkfifo Kullanma

FIFO'ların en pratik kullanım alanlarından biri paralel sıkıştırmadır. pigz (paralel gzip) veya pbzip2 gibi araçlar bir akış okur; sıkıştırılmamış bir dosyayı geçici olarak oluşturmadan ham verileri doğrudan yönlendirebilirsiniz.

Aşağıdaki kalıp bir dizini arşivler, tüm CPU çekirdekleriyle sıkıştırır ve sonucu aynı anda uzak bir ana bilgisayara aktarır:

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

Arabellek Boyutunu ve Engellemeyi Denetleme

Kanalların bir çekirdek arabelleği vardır (genellikle 64 KB). Arabellek dolduğunda yazıcı engellenir; boş olduğunda okuyucu engellenir. Genellikle istediğiniz davranış budur, ancak bazı durumlarda engelleme kilitlenmeye neden olur.

Kilitlenme riski: A işlemi FIFO1'e yazıp FIFO2'den okurken B işlemi FIFO2'ye yazıp FIFO1'den okursa, her ikisi de diğerinin önce tüketmesini beklerken engellenebilir.

Çözümler:

  • Kabuğu engellememesi için en az bir tarafı arka planda (&) çalıştırın.
  • Aşamalar arasına daha büyük bir bellek içi arabellek eklemek için mbuffer veya pv kullanın.
  • İşlem hacmindeki ani artışları yumuşatmak üzere 128 MB'lık bir arabellek eklemek için pv -q -B 128m kullanın.
#!/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

Uygulamalı Örnek: Gerçek Zamanlı Günlük Toplayıcı

Eksiksiz ve gerçekçi bir kalıp şöyledir: birden çok günlük dosyasını izlemek, akışları adlandırılmış bir kanaldan birleştirmek, hataları filtrelemek ve canlı bir özet yazmak; tüm bunları ara dosyalar olmadan ve bütün aşamaları paralel çalıştırarak yapmak.

Bu tür bir işlem hattı, üretim sunucusunda arka planda çalışan bir izleme betiği olarak kullanılabilir.

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

İşlem Hatlarını Geçici Dosyalarla Karşılaştırmalı Ölçme

time kullanarak akış yaklaşımı ile geçici dosya yaklaşımı arasındaki gerçek işlem hacmi farkını ölçebilirsiniz. İşlem hattı yaklaşımı büyük veri kümelerinde daha iyi sonuç verir; çünkü:

  • Aşamalar eşzamanlı çalışır; CPU ve G/Ç işlemleri örtüşür.
  • Ara veriler için disk G/Ç'si yapılmaz; yalnızca nihai çıktı diske yazılır.
  • Bellek kullanımı girdi boyutundan bağımsız olarak sabit kalır (arabelleğe almak yerine akış kullanılır).

Her iki yaklaşımı karşılaştırmak için basit bir ölçüm:

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

Bilgi Kontrolü: Adlandırılmış Kanallarda Engelleme Davranışı

Aşağıdaki betiği düşünün:

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

Bu betik, arka planda çalışan hiçbir işlem veya okuyucu olmadan çalıştırıldığında ne olur?

Özet: Akış İşlem Hatları ve Adlandırılmış Borular

Bu derste, ara dosyalar kullanmadan işlemler arasında verileri verimli bir şekilde nasıl taşıyacağınızı öğrendiniz:

  • Anonim borular (|) bitişik komutları birbirine bağlar ve otomatik geri basınçla tüm aşamaları eşzamanlı olarak çalıştırır.
  • Adlandırılmış borular (mkfifo), ilgisiz veya arka plandaki işlemlerin birbirleriyle veri akışı gerçekleştirmesini sağlayan bir FIFO dosya sistemi girdisi oluşturur — bir okuyucu hazır olana kadar yazma işlemleri bekler.
  • İşlem ikamesi (<(cmd), >(cmd)), dosya adı bekleyen komutların veri akışlarını şeffaf biçimde tüketmesini veya üretmesini sağlar.
  • tee + >(), kaynağı yeniden okumadan tek bir veri akışını birden çok eşzamanlı tüketiciye dağıtır.
  • Birleştirme, paylaşılan bir FIFO aracılığıyla birden çok üreticinin çıktısını tek bir tüketicide birleştirir.
  • Geri basınç ve bloklama hata değil, özelliklerdir — ancak kilitlenmeyi önlemek için bir FIFO çiftinin en az bir tarafını her zaman arka planda çalıştırın.
  • Aşamalar ani veri kümeleri hâlinde çalıştığında daha büyük arabellekler eklemek ve aktarım hızını izlemek için pv veya mbuffer kullanın.

Bu teknikler, yüksek aktarım hızlı Bash veri mühendisliğinin temelini oluşturur: GB ölçeğindeki verileri sabit bellek kullanımıyla ve en yüksek CPU/IO paralelliğiyle işleyin.

Sıkça Sorulan Sorular

“Veri Akışları ve İş Hacmi için Adlandırılmış Borular” dersi ücretsiz mi?

Evet — “Veri Akışları ve İş Hacmi için Adlandırılmış Borular” 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.

“Veri Akışları ve İş Hacmi için Adlandırılmış Borular” dersinde ne öğreneceğim?

Ara dosyalar kullanmadan aşamalar arasında veri akışı sağlamak için FIFO'ları ve işlem ikamesini kullanı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 4. dersidir.

“Veri Akışları ve İş Hacmi için Adlandırılmış Borular” 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