.bashrc ile Çevre Profili Dosyalarını Yönetmek

yazar

Linux dünyasında günlük işlerin büyük bir kısmı terminal üzerinden yürür. Her terminal açtığında aynı alias’ları tekrar yazmak, aynı ortam değişkenlerini export etmek, aynı PATH ayarlarını yapmak… Bunların hepsini otomatik hale getiren sihirli dosya: .bashrc. Yeni başlayan sysadmin arkadaşlar çoğu zaman bu dosyayı görmezden gelir ya da ne işe yaradığını tam anlamaz. Ama deneyimli bir sistem yöneticisi için .bashrc, kişisel araç kutusunun en temel parçasıdır. Bu yazıda .bashrc dosyasını her açıdan ele alacağız, gerçek dünya senaryolarıyla nasıl kullanılacağını göstereceğiz.

.bashrc Nedir ve Ne Zaman Çalışır?

.bashrc, kullanıcının home dizininde bulunan gizli bir shell konfigürasyon dosyasıdır. Bash shell’i her interaktif, non-login oturum açıldığında bu dosyayı okur ve içindeki komutları çalıştırır. Yani terminal emülatöründe yeni bir sekme açtığında, bir script içinden bash çağırdığında veya bash komutunu doğrudan çalıştırdığında .bashrc devreye girer.

Burada kritik bir ayrım var: login shell ile non-login shell farkı. Login shell, sisteme ilk girişte başlatılan shell’dir, SSH ile bağlandığında veya konsola direkt giriş yaptığında bu tür shell çalışır. Login shell’de .bash_profile veya .profile dosyaları okunur. Non-login interactive shell ise zaten oturum açmışken yeni bir terminal penceresi açtığında devreye girer, işte burada .bashrc çalışır.

Pek çok sistemde .bash_profile dosyası içinde şu satırları görürsün:

# .bash_profile icerigi
if [ -f ~/.bashrc ]; then
    source ~/.bashrc
fi

Bu sayede login shell açılışlarında da .bashrc okunur ve ayarlar tutarlı kalır. Özellikle SSH ile sunucuya bağlandığında bu birleştirme kritik önem taşır.

Dosya Yapısı ve Temel Anatomisi

Sistemi ilk kurduğunda veya yeni bir kullanıcı oluşturduğunda, /etc/skel/.bashrc dosyasından kopyalanan varsayılan bir .bashrc seni karşılar. Mevcut .bashrc dosyana şöyle bakabilirsin:

cat ~/.bashrc

Genellikle şunları görürsün:

# Varsayilan .bashrc icerigi
# Interactive shell degilse cik
case $- in
    *i*) ;;
      *) return;;
esac

# Gecmis ayarlari
HISTCONTROL=ignoreboth
HISTSIZE=1000
HISTFILESIZE=2000

# Renk destegi
force_color_prompt=yes

# Temel alias'lar
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'

Bu yapı sana bir başlangıç noktası verir. Ama gerçek özelleştirme senin eklediklerinle başlar.

Ortam Değişkenleri Ayarlamak

Ortam değişkenleri, shell ve çalıştırdığın programların davranışını kontrol eden temel yapı taşlarıdır. .bashrc içinde bu değişkenleri kalıcı hale getirebilirsin.

# Temel ortam degiskenleri
export EDITOR=vim
export VISUAL=vim
export PAGER=less
export LANG=tr_TR.UTF-8
export LC_ALL=tr_TR.UTF-8

# Java ortami icin ornek
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH

# Python sanal ortam yolu
export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3

# Ozel uygulama dizinleri
export MYAPP_CONFIG=/etc/myapp/config.yml
export MYAPP_LOG_DIR=/var/log/myapp

export anahtar kelimesi değişkeni alt süreçlere de taşır. Eğer sadece mevcut shell için tanımlamak istersen export kullanmana gerek yok, ama sysadmin işlerinde genellikle export ile tanımlamak daha mantıklıdır.

PATH Yönetimi

PATH değişkeni, shell’in komutları aradığı dizinlerin listesidir. Özel araçlarını veya scriptlerini standart yerlere koymak istemiyorsan PATH’e eklemen gerekir:

# PATH yonetimi - mevcut PATH'i koruyarak ekle
export PATH="$HOME/bin:$HOME/.local/bin:$PATH"
export PATH="/opt/custom-tools/bin:$PATH"
export PATH="/usr/local/sbin:/usr/local/bin:$PATH"

# Duplicate olmamasi icin kontrol ederek ekleme
add_to_path() {
    if [[ ":$PATH:" != *":$1:"* ]]; then
        export PATH="$1:$PATH"
    fi
}

add_to_path "$HOME/scripts"
add_to_path "/opt/terraform/bin"

Özellikle birden fazla sistemde çalışıyorsan ve farklı tool versiyonlarını yönetiyorsan bu add_to_path fonksiyonu çok işe yarar. Aynı dizini birden fazla eklemek PATH’i şişirir ve komut aramayı yavaşlatır.

Alias Tanımlamak: Verimlilik Sanatı

Alias’lar, uzun komutları kısa kısayollara dönüştürmenin en pratik yoludur. Günde onlarca kez yazdığın komutlar için alias tanımlamak zamanını ciddi ölçüde kurtarır.

# Sistem navigasyonu
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias ~='cd ~'
alias -- -='cd -'

# ls alternatifleri
alias ll='ls -alFh --color=auto'
alias la='ls -A --color=auto'
alias lt='ls -alFht --color=auto'  # zamana gore sirali
alias lsize='ls -alFhS --color=auto'  # boyuta gore sirali

# Guvenli silme ve kopyalama
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'

# Grep renklendirme
alias grep='grep --color=auto'
alias fgrep='fgrep --color=auto'
alias egrep='egrep --color=auto'

# Sistem bilgisi
alias meminfo='free -m -l -t'
alias cpuinfo='lscpu'
alias diskinfo='df -hT'
alias ports='ss -tulpn'
alias myip='curl -s https://ipinfo.io/ip'

# Servis yonetimi kisayollari
alias sstart='sudo systemctl start'
alias sstop='sudo systemctl stop'
alias srestart='sudo systemctl restart'
alias sstatus='sudo systemctl status'
alias senable='sudo systemctl enable'

# Log takibi
alias syslog='sudo tail -f /var/log/syslog'
alias authlog='sudo tail -f /var/log/auth.log'
alias nginxlog='sudo tail -f /var/log/nginx/access.log'

Alias tanımlarken dikkat etmen gereken nokta: alias içinde tek tırnak kullanıyorsan değişkenler tanımlama anında değil, çalışma anında genişletilir. Çift tırnak kullanırsan tam tersi olur. Çoğu durumda tek tırnak tercih edilir.

Shell Fonksiyonları: Alias’ın Ötesi

Alias’lar parametre alamaz ve karmaşık mantık içeremez. Bu noktada shell fonksiyonları devreye girer. Fonksiyonlar gerçek anlamda küçük scriptler gibi davranır ve .bashrc içinde tanımlanabilir.

# Dizin olustur ve icine gir
mkcd() {
    mkdir -p "$1" && cd "$1"
}

# Bir prosesi ada gore bul ve oldur
killbyname() {
    if [ -z "$1" ]; then
        echo "Kullanim: killbyname <proses_adi>"
        return 1
    fi
    pkill -f "$1" && echo "$1 prosesleri sonlandirildi." || echo "Proses bulunamadi."
}

# Arsiv dosyasini otomatik acma - formati algilayarak
extract() {
    if [ -f "$1" ]; then
        case "$1" in
            *.tar.bz2)   tar xjf "$1"     ;;
            *.tar.gz)    tar xzf "$1"     ;;
            *.bz2)       bunzip2 "$1"     ;;
            *.gz)        gunzip "$1"      ;;
            *.tar)       tar xf "$1"      ;;
            *.tbz2)      tar xjf "$1"     ;;
            *.tgz)       tar xzf "$1"     ;;
            *.zip)       unzip "$1"       ;;
            *.7z)        7z x "$1"        ;;
            *)           echo "'$1' dosyasi tanimli format degil" ;;
        esac
    else
        echo "'$1' dosyasi mevcut degil"
    fi
}

# Port dinleyip dinlemedigini kontrol et
checkport() {
    if [ -z "$1" ]; then
        echo "Kullanim: checkport <port_numarasi>"
        return 1
    fi
    ss -tulpn | grep ":$1 " && echo "Port $1 aktif." || echo "Port $1 kullanilmiyor."
}

Bu fonksiyonlar sayesinde tekrar eden manuel işlemleri otomatikleştirirsin. mkcd fonksiyonu basit görünse de günde belki 10-15 kez yaptığın mkdir + cd ikilisini tek komuta indirger.

Prompt Özelleştirmesi (PS1)

Prompt, terminalin sol tarafında gördüğün ifadedir. Varsayılan prompt genellikle bilgi açısından yetersizdir. Özelleştirilmiş bir prompt, hangi sunucuda, hangi dizinde ve hangi kullanıcıyla çalıştığını bir bakışta gösterir:

# Renk kodlari
RED='[33[0;31m]'
GREEN='[33[0;32m]'
YELLOW='[33[1;33m]'
BLUE='[33[0;34m]'
CYAN='[33[0;36m]'
WHITE='[33[1;37m]'
RESET='[33[0m]'

# Root icin kirmizi, normal kullanici icin yesil prompt
if [ "$EUID" -eq 0 ]; then
    USER_COLOR=$RED
    SYMBOL="#"
else
    USER_COLOR=$GREEN
    SYMBOL="$"
fi

# Git branch bilgisini goster
parse_git_branch() {
    git branch 2>/dev/null | grep "^*" | sed 's/* //'
}

# Prompt tanimlama
PS1="${USER_COLOR}u${RESET}@${CYAN}h${RESET}:${BLUE}w${RESET}"
PS1+='$(branch=$(parse_git_branch); [ -n "$branch" ] && echo " '"${YELLOW}"'('"$branch"')'"${RESET}"'")'
PS1+="${WHITE}${SYMBOL}${RESET} "

export PS1

Bu yapılandırmada kullanıcı adı renklidir, hostname siyanla yazılır, mevcut dizin mavi görünür ve eğer bir git reposundaysan branch adı sarı renkle parantez içinde görünür. Root kullanıcısıyla çalışıyorsan kırmızı renk uyarısı görerek yanlışlıkla tehlikeli komut çalıştırma riskini azaltırsın.

Geçmiş (History) Yönetimi

Bash geçmişi verimli kullanmak, terminal verimliliğini önemli ölçüde artırır. .bashrc içinde geçmişi daha kullanışlı hale getiren ayarlar ekleyebilirsin:

# Gecmis boyutu
HISTSIZE=10000
HISTFILESIZE=20000

# Tekrar eden komutlari ve boslukla baslayanlari kaydetme
HISTCONTROL=ignoreboth:erasedups

# Gecmis dosyasini her komut sonrasi guncelle
PROMPT_COMMAND='history -a'

# Birden fazla terminal oturumunu senkronize et
PROMPT_COMMAND='history -a; history -c; history -r'

# Gecmisten hariç tutulacak komutlar
HISTIGNORE="ls:ll:la:cd:pwd:exit:clear:history"

# Gecmis komutlarinda zaman damgasi
HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S "

HISTTIMEFORMAT ayarı sayesinde geçmişe bakışta ne zaman ne yaptığını görebilirsin. Özellikle birden fazla kişinin ortak kullandığı sunucularda veya sorun giderme sırasında bu bilgi altın değerinde olabilir.

Gerçek Dünya Senaryoları

Senaryo 1: Çok Sunuculu Ortamda SSH Yönetimi

Onlarca sunucuyu yönetiyorsan SSH alias’ları ve fonksiyonlar hayat kurtarır:

# SSH alias'lari - sunucu adlariyla kolayca baglan
alias web01='ssh -i ~/.ssh/prod_key [email protected]'
alias web02='ssh -i ~/.ssh/prod_key [email protected]'
alias db01='ssh -i ~/.ssh/prod_key [email protected]'
alias bastion='ssh -i ~/.ssh/bastion_key [email protected]'

# Tum sunuculara paralel komut gonderme
run_all_web() {
    for host in 192.168.1.101 192.168.1.102 192.168.1.103; do
        echo "--- $host ---"
        ssh -i ~/.ssh/prod_key user@$host "$@"
    done
}

# SSH agent kontrolu ve otomatik anahtar yukleme
if [ -z "$SSH_AUTH_SOCK" ]; then
    eval "$(ssh-agent -s)" > /dev/null
    ssh-add ~/.ssh/prod_key 2>/dev/null
    ssh-add ~/.ssh/bastion_key 2>/dev/null
fi

Senaryo 2: Docker ve Container Yönetimi

# Docker kisayollari
alias dk='docker'
alias dkc='docker-compose'
alias dkps='docker ps --format "table {{.ID}}t{{.Names}}t{{.Status}}t{{.Ports}}"'
alias dkimg='docker images --format "table {{.Repository}}t{{.Tag}}t{{.Size}}"'

# Durmus container'lari temizle
dkclean() {
    echo "Durmus container'lar temizleniyor..."
    docker container prune -f
    echo "Kullanilmayan image'lar temizleniyor..."
    docker image prune -f
    echo "Kullanilmayan volume'ler temizleniyor..."
    docker volume prune -f
    echo "Temizlik tamamlandi."
}

# Container'a interaktif gir
dkexec() {
    docker exec -it "$1" /bin/bash 2>/dev/null || docker exec -it "$1" /bin/sh
}

Senaryo 3: Log Analizi Hızlandırma

# Log analizi fonksiyonlari
logerrors() {
    local logfile=${1:-/var/log/syslog}
    grep -iE "error|critical|fatal|panic" "$logfile" | tail -50
}

logwarn() {
    local logfile=${1:-/var/log/syslog}
    grep -iE "warn|warning" "$logfile" | tail -50
}

# Belirli bir IP adresinin log kayitlarini filtrele
logip() {
    if [ -z "$1" ]; then
        echo "Kullanim: logip <ip_adresi> [log_dosyasi]"
        return 1
    fi
    local logfile=${2:-/var/log/nginx/access.log}
    grep "$1" "$logfile"
}

.bashrc Organizasyonu: Dosyayı Yönetilebilir Tutmak

Zamanla .bashrc dosyası şişer ve karmaşık hale gelir. Bunun önüne geçmek için modüler bir yapı kurabilirsin:

# .bashrc sonuna ekle - harici dosyalari yukle
if [ -d ~/.bashrc.d ]; then
    for file in ~/.bashrc.d/*.bash; do
        [ -r "$file" ] && source "$file"
    done
fi

Sonra ~/.bashrc.d/ dizininde ayrı dosyalar oluşturursun:

  • ~/.bashrc.d/aliases.bash – tüm alias’lar
  • ~/.bashrc.d/functions.bash – tüm fonksiyonlar
  • ~/.bashrc.d/docker.bash – docker özel ayarlar
  • ~/.bashrc.d/git.bash – git yardımcıları
  • ~/.bashrc.d/env.bash – ortam değişkenleri

Bu yaklaşım sayesinde .bashrc temiz kalır, farklı konulardaki ayarlar ayrı dosyalarda yönetilir ve ihtiyaç duyulmayan dosyaları kolayca devre dışı bırakabilirsin.

Değişiklikleri Uygulamak

.bashrc dosyasını düzenledikten sonra değişikliklerin aktif olması için ya yeni terminal açman ya da dosyayı source etmen gerekir:

# Degisiklikleri mevcut terminale uygula
source ~/.bashrc

# Veya kisaca
. ~/.bashrc

Bazı sysadminler .bashrc içine şu alias’ı ekler:

alias reload='source ~/.bashrc && echo "Yapilandirma yeniden yuklendi."'

Sık Yapılan Hatalar ve Dikkat Edilecekler

Sonsuz döngü tuzağı: .bashrc içinde yanlışlıkla bash komutunu çalıştırmak sonsuz döngüye yol açar. Her .bashrc çalıştığında yeni bash açılır ve tekrar .bashrc çalışır. Eğer non-interactive shell kontrolü yapmıyorsan bu hataya düşebilirsin.

Performans sorunları: .bashrc her terminal açılışında çalışır. Uzun süren komutlar (ağ sorguları, büyük dosya okuma gibi) terminal açılışını yavaşlatır. Gerekli değilse bu tür işlemleri .bashrc içine koyma.

rm -rf alias’ı tehlikesi: alias rm='rm -i' gibi güvenli alias’lar günlük kullanımda iyidir ama scriptlerde sorun yaratabilir. Scriptlerde her zaman /bin/rm ile tam path kullan.

Hassas bilgileri .bashrc‘ye yazma: API anahtarları, parolalar veya token’ları direkt .bashrc içine yazma. Bunun yerine .env dosyaları veya ayrı gizli dosyalar kullan ve onları source et. O dosyalara da uygun izinleri (600) vermeyi unutma.

.bashrc ile İlgili Diğer Önemli Dosyalar

  • .bash_logout: Oturum kapandığında çalışır. Geçici dosyaları temizlemek veya oturum kapatma logları tutmak için kullanılabilir.
  • .inputrc: Readline kütüphanesi ayarları. Klavye kısayollarını özelleştirmek için kullanılır.
  • /etc/bash.bashrc: Sistem genelinde tüm kullanıcılar için geçerli bash ayarları.
  • /etc/profile.d/*.sh: Login shell’de tüm kullanıcılar için çalışan sistem genelindeki scriptler.

Sonuç

.bashrc, bir sysadmin’in dijital çalışma ortamının temel taşıdır. İlk kurulumda üzerine fazla düşünmeyebilirsin ama zamanla kendi iş akışına uygun alias’lar, fonksiyonlar ve ortam değişkenleri biriktirdikçe ne kadar değerli bir araç olduğunu anlarsın. Önemli olan noktaları özetleyecek olursam:

  • .bashrc‘yi modüler tut, tek dev dosya yerine ~/.bashrc.d/ yapısını tercih et.
  • Her değişikliği mantıklı yorumlarla belgele, 6 ay sonra neden o ayarı yaptığını hatırlamak isteyeceksin.
  • Performansı göz önünde bulundur, ağır işlemleri buraya koyma.
  • Hassas bilgileri direkt yazma, ayrı ve izinli dosyalara koy.
  • Yeni sistemlere kurulum yaparken .bashrc‘ni kolayca taşıyabilmek için bir dotfiles git reposu oluştur.

Kendi .bashrc dosyan zamanla senin terminal alışkanlıklarının, sık kullandığın araçların ve sistem yönetim tarzının bir yansıması haline gelir. Onu ihmal etme, bakımını yap ve sürekli geliştir. Terminalde geçirdiğin her saat biraz daha verimli olacak.

Yorum yapın