Açık Kaynak İşletim Sistemleri

10 - Kabuk Programlama

Emre Can Yılmaz

emrecan@omu.edu.tr

Ondokuz Mayıs Üniversitesi

2026

Komutları Dosyaya Yazmak

Şimdiye kadar terminalde birçok komutu tek tek çalıştırdık.

Örneğin:

mkdir yedekler
cp notlar.txt yedekler/
ls yedekler

Bu komutları her seferinde elle yazmak yerine bir dosyaya yazabiliriz.

Dosya çalıştırıldığında komutlar sırayla çalışır.

Yani artık tek tek komut çalıştırmak yerine, hazırlanmış bir komut listesini çalıştırmış oluruz.

Kabuk Betiği Nedir?

Kabuk betiği, kabuk komutlarını içeren düz metin dosyasıdır.

Örnek:

#!/bin/bash

mkdir yedekler
cp notlar.txt yedekler/
ls yedekler

Bu dosya çalıştırıldığında:

1. yedekler klasörü oluşturulur.
2. notlar.txt dosyası bu klasöre kopyalanır.
3. yedekler klasörünün içeriği listelenir.

Burada yeni olan şey komutlar değil, komutların bir dosya içinde sıraya konulmasıdır.

Betik Okumak Ne Demektir?

Bir betiği okumak, her satırın sistemde ne yapacağını tahmin edebilmektir.

Örneğin şu betiğe bakalım:

#!/bin/bash

DOSYA="notlar.txt"

cp "$DOSYA" yedekler/

Bu betiği okurken şunları sorarız:

• DOSYA değişkeninin değeri nedir?
• cp komutu hangi dosyayı kopyalıyor?
• Dosya nereye kopyalanıyor?
• Betik dosya siliyor mu, sadece kopyalıyor mu?

Bu derste uzun betikler yazmaktan çok, bu tür soruları cevaplamaya odaklanacağız.

Kabuk Programlama Neden Bilinmeli?

Kabuk betikleri sistem yönetiminde, dosya işlemlerinde ve otomasyon görevlerinde sık karşımıza çıkar.

Bugün bu betikleri sıfırdan yazmak çoğu zaman zorunlu değildir.

AI araçları basit betikler üretebilir.

Ama yine de şu becerilere ihtiyaç vardır:

• Betiğin ne yaptığını anlayabilmek
• Hangi dosya ve klasörlere dokunduğunu görebilmek
• Silme, taşıma veya yetki değiştirme gibi riskleri fark edebilmek
• AI tarafından yazılmış bir betiği doğrudan çalıştırmadan önce kontrol edebilmek
• AI’a daha açık ve güvenli istek yazabilmek

Amaç, kabuk betiği okuryazarlığı kazanmaktır.

İlk Betiği Okuyalım

#!/bin/bash

echo "Merhaba Dünya!"

Bu betikte iki temel satır vardır.

#!/bin/bash satırı, betiğin bash ile çalıştırılacağını belirtir.

echo komutu ekrana metin yazdırır.

Bu betik çalıştırıldığında ekranda şu çıktı görülür:

Merhaba Dünya!

Shebang Satırı Neden Var?

Betiğin ilk satırında genellikle şu ifade görülür:

#!/bin/bash

Bu satıra shebang denir.

Sisteme şu bilgiyi verir:

Bu dosyayı bash kabuğu ile çalıştır.

Bu satır yoksa betik yine çalışabilir.

Fakat sistem farklı bir kabukla çalıştırmayı deneyebilir.

Bu durumda bazı bash özellikleri beklenenden farklı davranabilir.

Yorum Satırları

# ile başlayan satırlar açıklama satırıdır.

#!/bin/bash

# Bu betik ekrana kısa bir mesaj yazar.
echo "Sistem kontrolü başlıyor..."

Yorum satırları çalıştırılmaz.

Kodun ne yapmak istediğini anlatmak için kullanılır.

AI tarafından üretilen betiklerde yorum satırları faydalı olabilir.

Fakat yorum doğru görünse bile kod ayrıca kontrol edilmelidir.

Betik Nasıl Çalıştırılır?

Bir betiği çalıştırmak için dosyaya çalıştırma izni verilir.

chmod +x kontrol.sh

Sonra betik çalıştırılır.

./kontrol.sh

Buradaki ./, mevcut dizindeki dosyayı çalıştırmak istediğimizi belirtir.

Linux, güvenlik nedeniyle bulunduğumuz klasördeki dosyaları her zaman sadece adını yazarak çalıştırmaz.

Bu nedenle kontrol.sh yerine çoğu zaman ./kontrol.sh yazarız.

Kalıcı Değişiklik Yapan Komutlar

Bazı komutlar sistemde kalıcı değişiklik yapar.

Örnek:

chmod +x kontrol.sh

Bu komut dosyaya çalıştırma izni verir.

Aşağıdaki türde komutlar ise daha dikkatli incelenmelidir:

chmod -R 777 .
sudo chmod -R 777 /

Özellikle şu ifadeler görüldüğünde durup düşünmek gerekir:

• sudo
• -R
• /
• *
• rm
• chmod
• chown

Değişkenleri Okumak

Değişkenler geçici bilgi saklamak için kullanılır.

AD="Ayşe"
DOSYA="notlar.txt"

echo "$AD"
echo "$DOSYA"

Bu kodda:

• AD değişkeninin değeri Ayşe
• DOSYA değişkeninin değeri notlar.txt

olur.

Değişkenin değerini kullanmak için başına $ işareti konur.

Kod Okuma: Değişkenler

Aşağıdaki kodun çıktısını tahmin edelim.

AD="Mehmet"
DERS="Açık Kaynak İşletim Sistemleri"

echo "$AD"
echo "$DERS"

Beklenen çıktı:

Mehmet
Açık Kaynak İşletim Sistemleri

Bu betik herhangi bir dosyayı değiştirmez.

Sadece iki değişken tanımlar ve ekrana yazdırır.

Tırnak İşaretleri

Kabuk betiklerinde tırnak işaretleri sonucu değiştirebilir.

Çift tırnak içinde değişkenin değeri kullanılır.

AD="Ayşe"
echo "Merhaba $AD"

Çıktı:

Merhaba Ayşe

Tek tırnak içinde metin olduğu gibi yazılır.

AD="Ayşe"
echo 'Merhaba $AD'

Çıktı:

Merhaba $AD

Bu farkı bilmek, betiğin çıktısını tahmin etmek için yeterlidir.

Dosya Adlarında Boşluk Sorunu

Dosya ve klasör adlarında boşluk olabilir.

DOSYA="ders notları.txt"

Daha güvenli kullanım:

cat "$DOSYA"

Sorun çıkarabilecek kullanım:

cat $DOSYA

Çünkü kabuk bu ifadeyi iki ayrı parça gibi yorumlayabilir:

ders
notları.txt

Bu nedenle değişkenleri çoğu durumda çift tırnak içinde görmek isteriz.

Komut Çıktısını Değişkene Alma

Bir komutun çıktısı değişkene atanabilir.

BUGUN=$(date)
DIZIN=$(pwd)

echo "$BUGUN"
echo "$DIZIN"

Bu kodda:

• date komutu tarih bilgisini üretir.
• pwd komutu mevcut dizini verir.
• $(...) yapısı komutun çıktısını alır.

Bu kullanım AI’ın yazdığı betiklerde sık görülür.

Kullanıcıdan Girdi Alma

read komutu kullanıcıdan bilgi almak için kullanılır.

read -p "Adınızı giriniz: " AD

echo "Merhaba $AD"

Bu betik çalıştığında kullanıcıdan bir değer ister.

Kullanıcı Ali yazarsa çıktı şu olur:

Merhaba Ali

Bu tür betikler etkileşimlidir.

Otomatik çalışacak betiklerde her zaman uygun olmayabilir.

Argümanları Okumak

Betiğe çalıştırma sırasında değer verilebilir.

./kontrol.sh notlar.txt

Burada notlar.txt bir argümandır.

Betik içinde bu değer şöyle okunur:

echo "$1"

Yaygın özel değişkenler:

Değişken	Anlamı
$0	betiğin adı
$1	birinci argüman
$2	ikinci argüman
$#	argüman sayısı

Kod Okuma: Argümanlar

#!/bin/bash

echo "Betiğin adı: $0"
echo "Kontrol edilen dosya: $1"
echo "Argüman sayısı: $#"

Çalıştırma:

./kontrol.sh notlar.txt

Örnek çıktı:

Betiğin adı: ./kontrol.sh
Kontrol edilen dosya: notlar.txt
Argüman sayısı: 1

Bu kod dosya üzerinde işlem yapmaz.

Sadece kendisine verilen argümanı ekrana yazar.

Kısa Soru: Argüman

Aşağıdaki komutla betik çalıştırılıyor:

./kontrol.sh rapor.pdf

Betik içinde şu satır var:

DOSYA="$1"

Bu durumda DOSYA değişkeninin değeri nedir?

1. kontrol.sh
   
2. rapor.pdf
   
3. $1
   
4. DOSYA
   
5. Boş değer

Cevap: B

Argüman Kontrolü

AI’ın yazdığı betiklerde argüman kontrolü olup olmadığına bakılmalıdır.

if [ "$#" -eq 0 ]; then
    echo "Kullanım: $0 dosya_adi"
    exit 1
fi

Bu kod şu anlama gelir:

• Hiç argüman verilmemişse kullanıcıya açıklama göster.
• Betiği hata kodu ile sonlandır.

Bu kontrol yoksa betik eksik bilgiyle çalışmaya devam edebilir.

Aritmetik İfadeleri Okumak

Kabukta aritmetik işlem için $((...)) yapısı kullanılır.

SAYI1=10
SAYI2=5

TOPLAM=$((SAYI1 + SAYI2))

echo "$TOPLAM"

Çıktı:

15

Bu kullanım sayaç, basit hesaplama ve koşul kontrollerinde karşımıza çıkar.

Detaylı hesaplama yapmak bu dersin ana konusu değildir.

Koşullu İfadeler

Koşullu ifadeler, betiğin belirli durumlara göre karar vermesini sağlar.

if [ "$1" = "başlat" ]; then
    echo "İşlem başlatılıyor."
else
    echo "Bilinmeyen komut."
fi

Bu kodda:

• $1 değeri başlat ise ilk mesaj yazılır.
• Değilse ikinci mesaj yazılır.

Koşullu ifadeler betiklerin karar noktalarıdır.

Sayısal Karşılaştırmalar

İfade	Anlamı
-eq	eşit
-ne	eşit değil
-gt	büyük
-ge	büyük veya eşit
-lt	küçük
-le	küçük veya eşit

Örnek:

SAYI=10

if [ "$SAYI" -gt 5 ]; then
    echo "Sayı 5'ten büyüktür."
fi

Bu kodda koşul doğrudur.

Dosya ve Dizin Kontrolleri

Kabuk betiklerinde dosya kontrolü çok yaygındır.

Test	Anlamı
-e	var mı?
-f	normal dosya mı?
-d	dizin mi?
-r	okunabilir mi?
-w	yazılabilir mi?
-x	çalıştırılabilir mi?
-s	boş değil mi?

Örnek:

if [ -f "$1" ]; then
    echo "Bu bir dosyadır."
fi

Kod Okuma: Dosya Kontrolü

#!/bin/bash

if [ "$#" -eq 0 ]; then
    echo "Kullanım: $0 dosya_adi"
    exit 1
fi

DOSYA="$1"

if [ -f "$DOSYA" ]; then
    echo "Dosya bulundu: $DOSYA"
else
    echo "Dosya bulunamadı: $DOSYA"
fi

Bu betik:

1. Argüman verilmiş mi kontrol eder.
2. İlk argümanı DOSYA değişkenine atar.
3. Bu değerin normal dosya olup olmadığını kontrol eder.
4. Sonuca göre mesaj yazar.

Döngüler

Döngüler aynı işlemi birden fazla öğe için yapar.

for DOSYA in *.txt; do
    echo "$DOSYA"
done

Bu kod mevcut dizindeki .txt dosyalarını listeler.

Döngüleri okurken şu sorular sorulur:

• Hangi liste üzerinde dönüyor?
• Her adımda hangi değişken değişiyor?
• Döngü içinde hangi komutlar çalışıyor?

Tehlikeli Döngülere Dikkat

Aşağıdaki kod .tmp dosyalarını siler.

for DOSYA in *.tmp; do
    rm "$DOSYA"
done

Bu kodun etkisi sınırlı görünür.

Ama şu kod daha risklidir:

for DOSYA in *; do
    rm "$DOSYA"
done

Çünkü mevcut dizindeki birçok dosyayı silmeye çalışır.

AI’ın yazdığı betiklerde rm, mv, cp, chmod, chown komutları dikkatle incelenmelidir.

while Döngüsünü Okumak

while döngüsü, koşul doğru olduğu sürece çalışır.

SAYAC=1

while [ "$SAYAC" -le 3 ]; do
    echo "$SAYAC"
    SAYAC=$((SAYAC + 1))
done

Çıktı:

1
2
3

Döngüde sayaç artırılmazsa betik sonsuz döngüye girebilir.

Fonksiyonları Tanımak

Fonksiyonlar, komutları bir isim altında toplar.

selamla() {
    echo "Merhaba $1"
}

selamla "Ayşe"

Bu kodda:

• selamla bir fonksiyondur.
• "Ayşe" fonksiyona gönderilen değerdir.
• Fonksiyon içinde bu değer $1 olarak okunur.

Bu derste fonksiyon yazma ayrıntısına girmiyoruz.

Çünkü temel hedef, AI’ın veya başka bir kişinin yazdığı betikte fonksiyonun nerede tanımlandığını ve nerede çağrıldığını anlayabilmektir.

Fonksiyon Okurken Sorulacak Sorular

Bir fonksiyon gördüğümüzde şu sorular yeterlidir:

• Fonksiyonun adı ne?
• Fonksiyon nerede çağrılıyor?
• Fonksiyona hangi değer gönderiliyor?
• Fonksiyon içinde dosya silme veya değiştirme var mı?
• Fonksiyon hata durumunda exit kullanıyor mu?

Örnek:

yedekle "$KAYNAK" "$HEDEF"

Bu satır, yedekle adlı fonksiyona iki değer gönderildiğini gösterir.

Çıkış Durumu

Her komut çalıştıktan sonra bir çıkış durumu üretir.

Değer	Anlamı
0	başarılı
0 dışı	hata

Örnek:

if [ -f "$DOSYA" ]; then
    exit 0
else
    exit 1
fi

Bu kodda dosya varsa betik başarılı biter.

Dosya yoksa hata kodu ile biter.

AI Çıktısını İnceleme Mantığı

AI’ın yazdığı bir kabuk betiği doğrudan çalıştırılmamalıdır.

Önce şu üç soru sorulmalıdır:

1. Bu betik neyi okuyor?
2. Bu betik neyi değiştiriyor?
3. Bu betik neyi siliyor veya taşıyor?

Özellikle dosya sistemiyle ilgili komutlar dikkat ister.

Bir betiğin kısa olması güvenli olduğu anlamına gelmez.

Bazen tek satırlık bir komut bile geniş etki oluşturabilir.

Kod İnceleme Kontrol Listesi

AI tarafından yazılmış bir kabuk betiğini incelerken şu noktalara bakılmalıdır:

• Betik hangi dosya ve dizinlere dokunuyor?
• rm, mv, cp, chmod, chown, sudo var mı?
• Değişkenler çift tırnak içinde kullanılmış mı?
• Argüman sayısı kontrol edilmiş mi?
• Dosya veya dizin varlığı kontrol edilmiş mi?
• Hata durumunda anlamlı mesaj veriyor mu?
• Gerekirse exit 1 ile duruyor mu?

Bu liste, betiği tamamen ezbere bilmeden de temel riskleri yakalamayı sağlar.

AI Komut Parametresi Uydurabilir

AI araçları bazen doğru komutu seçer ama yanlış parametre önerebilir.

Örneğin:

tar -zqxvf arsiv.tar.gz

Bu tür karmaşık seçenekler her sistemde beklenen biçimde çalışmayabilir.

Ayrıca bazı komutların GNU/Linux ve macOS sürümleri farklı seçeneklere sahip olabilir.

Bu nedenle emin olunmayan komutlar için yardım çıktısına bakılmalıdır:

tar --help
man tar

AI’ın verdiği komut çalışıyor gibi görünse bile ne yaptığını anlamadan kullanılmamalıdır.

AI’a Belirsiz İstek

Bana Linux için yedekleme scripti yaz.

Bu istek çok belirsizdir.

Eksik noktalar:

• Hangi klasör yedeklenecek?
• Yedek nereye yazılacak?
• Eski yedekler silinecek mi?
• Var olan dosyanın üzerine yazılacak mı?
• Hata durumunda ne yapılacak?
• Silme işlemi olacak mı?

Belirsiz istekler, riskli betiklerin üretilmesine neden olabilir.

AI’a Daha İyi İstek

Bash ile okunabilir bir yedekleme betiği yaz.

İstekler:
- İki argüman alsın: kaynak_klasor ve hedef_klasor.
- Kaynak klasör yoksa hata mesajı verip çıksın.
- Hedef klasör yoksa oluştursun.
- Kaynak klasörü .tar.gz olarak sıkıştırsın.
- Dosya adında tarih bilgisi olsun.
- Silme işlemi yapmasın.
- sudo kullanmasın.
- Değişkenleri çift tırnak içinde kullansın.
- Dry-run seçeneği eklesin.
- Her önemli satıra kısa açıklama yorumu eklesin.

Bu istek, AI’ın daha güvenli ve okunabilir bir çıktı üretmesini sağlar.

AI Çıktısını Kontrol Etme

AI’dan gelen betiği doğrudan çalıştırmak yerine önce okumak gerekir.

Özellikle şu komutları arayın:

rm
mv
cp
chmod
chown
sudo
curl
wget
tar
find

Bu komutların hepsi kötü değildir.

Fakat dosya sistemi, yetkiler veya dış kaynaklarla ilgili işlem yaptıkları için dikkat gerektirir.

Komutu görmek tek başına yeterli değildir; hangi değişkenlerle ve hangi klasörde çalıştığı da incelenmelidir.

Dry-Run Nedir?

Dry-run, işlemi gerçekten yapmadan önce ne yapılacağını göstermektir.

Örnek:

echo "Silinecek dosya: $DOSYA"

Bu satır dosyayı silmez.

Sadece hangi dosyanın silineceğini gösterir.

Riskli betiklerde dry-run modu istemek iyi bir alışkanlıktır.

Kod Okuma Uygulaması 1

Aşağıdaki betik ne yapar?

#!/bin/bash

KLASOR="$1"

if [ -d "$KLASOR" ]; then
    echo "Klasör bulundu."
else
    echo "Klasör bulunamadı."
fi

Sorular:

1. Betik kaç argüman bekliyor?
2. $1 hangi değişkene atanıyor?
3. -d testi neyi kontrol ediyor?
4. Betik herhangi bir dosya siliyor mu?

Kod Okuma Uygulaması 2

Aşağıdaki betikte riskli olabilecek satır hangisidir?

#!/bin/bash

HEDEF="$1"

echo "Geçici dosyalar temizleniyor..."
rm -rf "$HEDEF"/*
echo "İşlem tamamlandı."

Tartışma soruları:

1. rm -rf ne yapar?
2. HEDEF boş gelirse ne olabilir?
3. Argüman kontrolü var mı?
4. Hedef klasör kontrolü var mı?
5. Betiği daha güvenli hale getirmek için hangi kontroller gerekir?

Uygulama 2: Cevap ve Risk

Riskli satır şudur:

rm -rf "$HEDEF"/*

Bu satır, HEDEF değişkeninin gösterdiği klasörün içeriğini siler.

Sorunlar:

• Argüman kontrolü yok.
• HEDEF boş mu kontrol edilmiyor.
• HEDEF gerçekten klasör mü kontrol edilmiyor.
• Kullanıcıya silmeden önce liste gösterilmiyor.

Uygulama 2: Daha Okunur Kontrol

Silme işleminden önce şu kontroller yapılmalıdır.

if [ -z "$HEDEF" ]; then
    echo "Hedef klasör belirtilmedi."
    exit 1
fi

Bu kontrol, HEDEF değişkeninin boş olup olmadığını denetler.

if [ ! -d "$HEDEF" ]; then
    echo "Hedef geçerli bir klasör değil."
    exit 1
fi

Bu kontrol, verilen hedefin gerçekten bir klasör olup olmadığını denetler.

Kod Okuma Uygulaması 3

Aşağıdaki betik hangi durumda hata mesajı verir?

#!/bin/bash

DOSYA="$1"

if [ ! -f "$DOSYA" ]; then
    echo "Dosya bulunamadı."
    exit 1
fi

echo "Dosya bulundu."

Seçenekler:

1. Dosya varsa
   
2. Dosya yoksa
   
3. Dosya adı DOSYA ise
   
4. Betik çalıştırılamazsa
   
5. Her zaman

Cevap: B

Senaryo: Yanlış Dizinde Çalıştırma

AI size şu betiği verdi:

#!/bin/bash

for DOSYA in *.log; do
    rm "$DOSYA"
done

Bu betik mevcut dizindeki .log dosyalarını siler.

Asıl risk yalnızca rm komutu değildir.

Asıl risklerden biri betiğin hangi dizinde çalıştırıldığıdır.

Yanlış dizindeyseniz beklediğinizden farklı log dosyalarını silebilirsiniz.

Bu nedenle silme işlemlerinden önce mevcut dizin kontrol edilmelidir.

pwd

Daha Güvenli Yaklaşım

Önceki örnekte .log dosyaları siliniyordu.

Böyle bir betiği doğrudan çalıştırmak yerine önce hangi dizinde olduğumuzu kontrol etmek gerekir:

pwd

Sonra silinecek dosyaları gerçekten silmeden listelemek daha güvenlidir:

for DOSYA in *.log; do
    echo "Silinecek dosya: $DOSYA"
done

Bu betik dosya silmez.

Sadece hangi dosyaların etkileneceğini gösterir.

AI’dan betik isterken şu ifade eklenebilir:

Önce dry-run modu ekle; silmeden önce hangi dosyaların etkileneceğini göstersin.

3 Dakikalık Kontrol

1. "$1" neyi ifade eder?
2. -f testi neyi kontrol eder?
3. -d testi neyi kontrol eder?
4. rm -rf neden dikkatle incelenmelidir?
5. exit 1 genellikle ne anlama gelir?
6. Değişkenleri neden çift tırnak içinde kullanmak gerekir?
7. Dry-run modu ne işe yarar?
8. AI’dan betik isterken “silme işlemi yapmasın” demek neden önemlidir?

Ders Sonu Özeti

Bu dersten sonra şu sorulara cevap verebilmeniz beklenir:

• Bu betik ne yapıyor?
• Hangi değişkenler kullanılıyor?
• Hangi argümanlar bekleniyor?
• Dosya veya dizin kontrolü var mı?
• Silme, taşıma veya yetki değiştirme işlemi var mı?
• Hata durumunda betik nasıl davranıyor?
• AI’a daha güvenli bir betik yazdırmak için istek nasıl netleştirilir?

Amaç, uzun betikler ezberlemek değil; temel yapıları tanıyıp riskleri görebilmektir.

Son Not

Kabuk betiklerini tamamen yazmak zorunda olmayabilirsiniz.

Ancak bir betiği çalıştırmadan önce ne yaptığını anlamak gerekir.

Özellikle AI tarafından üretilen komutlarda şu yaklaşım güvenlidir:

Önce oku.
Etkilenecek dosyaları kontrol et.
Gerekirse dry-run çalıştır.
Daha sonra gerçek işlemi yap.

Komut satırında küçük bir hata, beklenenden büyük sonuçlar doğurabilir.