uname Komutu ile Linux Sistem Bilgisi Öğrenme Teknikleri

yazar

Sistem yöneticiliğinde en temel sorulardan biri şudur: “Bu makine tam olarak ne?” Özellikle onlarca, yüzlerce sunucuyu yönetirken hangi kernelin çalıştığını, mimarinin ne olduğunu veya işletim sisteminin sürümünü hızlıca öğrenmek hayat kurtarır. İşte tam bu noktada uname komutu devreye girer. Basit görünür, ama doğru kullanıldığında inanılmaz derecede faydalı bilgiler sunar. Bu yazıda uname komutunu her açısıyla inceleyeceğiz, gerçek dünya senaryolarında nasıl kullanacağımızı göreceğiz ve sistem bilgisi toplama konusunda pratik teknikler öğreneceğiz.

uname Nedir ve Neden Önemlidir?

uname, “Unix Name” kelimelerinin kısaltmasıdır ve sistem hakkında temel bilgileri terminal üzerinden anında sunar. Kernel versiyonu, işletim sistemi adı, donanım mimarisi gibi bilgilere erişmek için bu komut kullanılır.

Peki neden bu kadar önemli? Düşün bir dakika: Bir uygulamayı derliyorsun ve derleme hatası alıyorsun. İlk yapman gereken şey kernel sürümünü kontrol etmek. Ya da bir güvenlik açığı haberi çıktı, hangi kernellerin etkilendiğini araştırıyorsun ve kendi sunucularının bu aralıkta olup olmadığını hızlıca öğrenmek istiyorsun. Ya da yeni bir sunucuya bağlandın, Ansible playbook çalıştırmadan önce mimarinin ARM mi yoksa x86 mi olduğunu doğrulamak istiyorsun. Tüm bu durumlarda uname ilk başvuru noktandır.

Temel Kullanım

En sade haliyle uname sadece işletim sistemi adını döner:

uname
Linux

Bu kadar. Evet, bu biraz sıkıcı. Asıl güç parametrelerden geliyor.

uname Parametreleri

Her parametrenin ne işe yaradığını tek tek görelim:

  • -s: Kernel adını gösterir (varsayılan davranış)
  • -n: Ağ hostname’ini gösterir
  • -r: Kernel sürümünü (release) gösterir
  • -v: Kernel versiyonunu ve derleme tarihini gösterir
  • -m: Makine donanım mimarisini gösterir (x86_64, aarch64 vb.)
  • -p: İşlemci tipini gösterir
  • -i: Donanım platformunu gösterir
  • -o: İşletim sistemi adını gösterir
  • -a: Tüm bilgileri tek seferde gösterir

En Çok Kullanılan: uname -a

Günlük hayatta en sık kullanacağın parametre -a olacak. Tüm bilgileri tek satırda verir:

uname -a
Linux web-server-01 5.15.0-91-generic #101-Ubuntu SMP Tue Nov 14 13:30:08 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux

Bu çıktıyı soldan sağa okuyalım:

  • Linux: Kernel adı
  • web-server-01: Hostname
  • 5.15.0-91-generic: Kernel sürümü
  • #101-Ubuntu SMP Tue Nov 14 13:30:08 UTC 2023: Kernel derleme bilgisi
  • x86_64 x86_64 x86_64: Sırasıyla makine donanımı, işlemci tipi, platform
  • GNU/Linux: İşletim sistemi

Kernel Sürümünü Öğrenmek

uname -r
5.15.0-91-generic

Bu çıktıyı ayrıştırmak da önemli. 5.15.0-91-generic ifadesinde:

  • 5: Major versiyon
  • 15: Minor versiyon
  • 0: Patch sürümü
  • 91: Ubuntu’nun bu kernele uyguladığı yama numarası
  • generic: Kernel türü (generic, server, lowlatency gibi)

Hostname Bilgisi

uname -n
web-server-01

Bu, hostname komutuyla aynı sonucu verir. Ancak bazı scriptlerde uname -n tercih edilir çünkü tek bir komutla hem kernel hem hostname bilgisi alınabilir.

Mimari Bilgisi

uname -m
x86_64

ARM tabanlı bir sistemde bu şöyle görünür:

aarch64

32 bit bir sistemde ise:

i686

Gerçek Dünya Senaryoları

Senaryo 1: Otomatik Kernel Güncelleme Kontrolü

Bir güvenlik açığı duyurusunda “5.15.0-85 ve önceki kernel sürümleri etkilenmiştir” yazıyor. Elindeki 50 sunucunun hepsini tek tek kontrol etmek yerine şöyle bir script yazabilirsin:

#!/bin/bash
# Kernel versiyon kontrolü - CVE-XXXX-XXXX
AFFECTED_KERNEL="5.15.0-85"
CURRENT_KERNEL=$(uname -r)
HOSTNAME=$(uname -n)

echo "Sunucu: $HOSTNAME"
echo "Mevcut Kernel: $CURRENT_KERNEL"

if [[ "$CURRENT_KERNEL" == *"5.15"* ]]; then
    KERNEL_BUILD=$(echo $CURRENT_KERNEL | grep -oP 'd+(?=-generic)')
    if [ "$KERNEL_BUILD" -le 85 ]; then
        echo "UYARI: Bu sunucu etkilenmiş olabilir! Kernel guncellenmeli."
    else
        echo "OK: Kernel surumu guncel."
    fi
fi

Bu script birden fazla sunucuda for döngüsüyle veya Ansible ile çalıştırılabilir.

Senaryo 2: Mimari Bazlı Binary İndirme

Farklı mimarilere sahip sunucular için doğru binary’yi indirmek sık karşılaşılan bir ihtiyaç. Bunu uname -m ile otomatize edebilirsin:

#!/bin/bash
# Mimari bazli dogru binary indirme

ARCH=$(uname -m)
VERSION="1.25.0"
BASE_URL="https://example-tool.io/releases/v${VERSION}"

case $ARCH in
    x86_64)
        BINARY_URL="${BASE_URL}/tool-linux-amd64"
        ;;
    aarch64|arm64)
        BINARY_URL="${BASE_URL}/tool-linux-arm64"
        ;;
    armv7l)
        BINARY_URL="${BASE_URL}/tool-linux-armv7"
        ;;
    i686)
        BINARY_URL="${BASE_URL}/tool-linux-386"
        ;;
    *)
        echo "Desteklenmeyen mimari: $ARCH"
        exit 1
        ;;
esac

echo "Indiriliyor: $BINARY_URL"
curl -L -o /usr/local/bin/tool "$BINARY_URL"
chmod +x /usr/local/bin/tool

Bu tür scriptler özellikle Ansible rollerinde veya cloud-init konfigürasyonlarında çok kullanışlıdır.

Senaryo 3: Sistem Envanter Scripti

Büyük bir infrastrukturun envanterini çıkarırken uname değerli bir bilgi kaynağıdır. Şu scripti her sunucudan bilgi toplamak için kullanabilirsin:

#!/bin/bash
# Sistem envanter bilgisi toplama

TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
HOSTNAME=$(uname -n)
KERNEL=$(uname -r)
ARCH=$(uname -m)
OS=$(uname -o)
KERNEL_VERSION=$(uname -v)

# Distro bilgisi icin /etc/os-release kullan
if [ -f /etc/os-release ]; then
    DISTRO=$(grep "PRETTY_NAME" /etc/os-release | cut -d'"' -f2)
else
    DISTRO="Bilinmiyor"
fi

cat << EOF
=== SISTEM ENVANTER RAPORU ===
Tarih: $TIMESTAMP
Hostname: $HOSTNAME
Kernel: $KERNEL
Mimari: $ARCH
OS: $OS
Distro: $DISTRO
Kernel Derleme: $KERNEL_VERSION
==============================
EOF

Bu scripti SSH ile tüm sunuculara dağıtıp çıktıları merkezi bir yerde toplayabilirsin:

for server in $(cat sunucu_listesi.txt); do
    echo "=== $server ==="
    ssh $server 'bash -s' < envanter.sh
done

uname ile Birlikte Kullanılan Komutlar

uname tek başına güçlü olsa da diğer komutlarla birlikte kullanıldığında çok daha kapsamlı sistem bilgisi elde edersin.

/etc/os-release ile Birleştirme

# Hem kernel hem distro bilgisini tek seferde al
echo "Kernel: $(uname -r)"
echo "Distro: $(grep PRETTY_NAME /etc/os-release | cut -d'"' -f2)"
echo "Mimari: $(uname -m)"

uname -o GNU/Linux der ama hangi distro olduğunu söylemez. Bunun için /etc/os-release dosyasına bakmak gerekir. Ubuntu, CentOS, Debian, Alpine fark etmez, bu dosya neredeyse her modern Linux dağıtımında mevcuttur.

lsb_release ile Birleştirme

Eğer sistem lsb_release komutunu destekliyorsa:

echo "=== Detayli Sistem Bilgisi ==="
uname -a
echo ""
lsb_release -a 2>/dev/null || cat /etc/os-release

hostnamectl ile Birleştirme

Systemd tabanlı sistemlerde hostnamectl komutu çok daha zengin bilgi sunar:

hostnamectl

Ama bu komut her zaman mevcut olmayabilir. uname ise evrenseldir, eski sistemlerde, minimal Alpine konteynırlarında, hatta BusyBox ortamlarında bile çalışır.

Kernel Sürüm Numarasını Ayrıştırma

Scriptlerde kernel sürümünü sayısal olarak karşılaştırmak için ayrıştırma yapmak gerekebilir:

#!/bin/bash
# Kernel versiyon karsilastirma

KERNEL=$(uname -r)

# Major.Minor.Patch formatini ayristir
MAJOR=$(echo $KERNEL | cut -d. -f1)
MINOR=$(echo $KERNEL | cut -d. -f2)
PATCH=$(echo $KERNEL | cut -d. -f3 | cut -d- -f1)

echo "Major: $MAJOR"
echo "Minor: $MINOR"
echo "Patch: $PATCH"

# Minimum kernel versiyonu kontrolu (ornegin 5.10 veya uzeri gerekli)
MIN_MAJOR=5
MIN_MINOR=10

if [ "$MAJOR" -gt "$MIN_MAJOR" ] || 
   ([ "$MAJOR" -eq "$MIN_MAJOR" ] && [ "$MINOR" -ge "$MIN_MINOR" ]); then
    echo "Kernel versiyonu gereksinimleri karsilıyor: $MAJOR.$MINOR.$PATCH"
else
    echo "HATA: En az kernel $MIN_MAJOR.$MIN_MINOR gerekli. Mevcut: $MAJOR.$MINOR.$PATCH"
    exit 1
fi

Bu tür kontroller, uygulamaların kurulum scriptlerinde veya sistem gereksinim doğrulama adımlarında sıkça kullanılır.

Docker ve Konteyner Ortamlarında uname

Konteyner ortamında uname çalıştırdığında ilginç bir durum ortaya çıkar:

docker run --rm alpine uname -r
5.15.0-91-generic

Konteyner içindeyken bile host sistemin kernel bilgisini görürsün. Çünkü konteynerlar host kernelini paylaşır. Bu, bazı scriptlerde beklenmedik sonuçlara yol açabilir. Konteyner içinde çalışıp çalışmadığını anlamak için farklı yöntemler kullanman gerekir:

# Konteyner icinde miyiz?
if [ -f /.dockerenv ]; then
    echo "Docker konteynerı icindeyim"
    echo "Host Kernel: $(uname -r)"
elif grep -q docker /proc/1/cgroup 2>/dev/null; then
    echo "Konteyner ortamındayım"
else
    echo "Bare metal veya VM uzerindeyim"
    echo "Kernel: $(uname -r)"
fi

Ansible ile uname Kullanımı

Ansible’da sistem faktörlerini toplarken uname değerleri ansible_facts altında zaten hazır gelir, ancak bazen raw komut olarak da kullanabilirsin:

---
- name: Kernel bilgisi topla
  hosts: all
  tasks:
    - name: Kernel surumunu al
      command: uname -r
      register: kernel_version
      changed_when: false

    - name: Mimariyi al
      command: uname -m
      register: system_arch
      changed_when: false

    - name: Kernel bilgisini goster
      debug:
        msg: "{{ inventory_hostname }}: Kernel={{ kernel_version.stdout }}, Arch={{ system_arch.stdout }}"

    - name: Eski kernel uyarisi
      debug:
        msg: "UYARI: Eski kernel tespit edildi!"
      when: kernel_version.stdout is version('5.10', '<')

Ansible’ın gather_facts: true ile topladığı ansible_kernel ve ansible_architecture değişkenleri zaten uname çıktısından türer. Ama custom scriptlerde veya raw connection’larda doğrudan komut kullanmak daha güvenilir olabilir.

Shell Scriptlerde Pratik Kullanım Kalıpları

Deneyimli sysadminlerin scriptlerinde sıkça gördüğüm bazı kalıplar var. Bunları paylaşmadan geçemezdim:

# Tek satirlik sistem ozeti - monitoring dashboard icin ideal
echo "$(uname -n) | $(uname -r) | $(uname -m) | $(date)"

# Sadece major.minor versiyon almak
uname -r | grep -oP '^d+.d+'

# ARM mi x86 mi? Hizlica kontrol
[[ $(uname -m) == "x86_64" ]] && echo "64-bit x86" || echo "Diger mimari: $(uname -m)"

# Kernel build tarihini goster
uname -v | grep -oP 'w{3}s+d+s+d{4}'

Troubleshooting Senaryosu: Kernel Panik Sonrası

Diyelim ki bir sunucu kernel panik sonrası reboot aldı. Sistem tekrar ayağa kalktıktan sonra hangi kernel ile boot ettiğini doğrulamak önemli:

# Hangi kernel ile calisiyoruz?
uname -r

# Yüklü tüm kernellere bak (Debian/Ubuntu)
dpkg --list | grep linux-image

# Ya da GRUB'daki seceneklere bak
grep -E "^menuentry|submenu" /boot/grub/grub.cfg | head -20

Eğer beklenmedik bir kernel ile boot olduysa (eski bir fallback gibi), bunu uname -r çıktısından hemen anlarsın. Bu tür durumlar özellikle otomatik kernel güncellemesi yapılandırılmış sistemlerde ve sonrasında GRUB’da bir sorun yaşandığında ortaya çıkabilir.

SMP ve Diğer Kernel Özelliklerini Okumak

uname -v çıktısındaki bazı kısaltmalar önemli bilgiler içerir:

uname -v
#101-Ubuntu SMP Tue Nov 14 13:30:08 UTC 2023

Bu çıktıda:

  • #101: Bu kernel paketin 101. derlemesi
  • SMP: Symmetric Multi-Processing destekli, yani çoklu işlemci/çekirdek desteği var
  • Tue Nov 14 13:30:08 UTC 2023: Kernelin derlendiği tarih ve saat

Eğer SMP yerine UP (Uniprocessor) yazıyorsa tek işlemci destekli bir kernel üzerinde çalışıyorsun demektir ki bu bugün neredeyse hiç karşılaşılmaz.

Monitoring ve Loglama İçin uname

Merkezi log sistemlerine sistem bilgisi eklemek istediğinde uname verilerini log formatına dahil edebilirsin:

#!/bin/bash
# Sistem bilgisi ile zenginlestirilmis log fonksiyonu

LOG_FILE="/var/log/app-monitor.log"
HOSTNAME=$(uname -n)
KERNEL=$(uname -r)
ARCH=$(uname -m)

log_message() {
    local level=$1
    local message=$2
    local timestamp=$(date +"%Y-%m-%dT%H:%M:%S%z")
    echo "${timestamp} [${level}] host=${HOSTNAME} kernel=${KERNEL} arch=${ARCH} msg=${message}" >> "$LOG_FILE"
}

log_message "INFO" "Monitoring scripti baslatildi"
log_message "INFO" "Sistem kontrolu yapiliyor"
# ... diger islemler

Bu tarz log formatları, ELK stack veya Grafana Loki gibi sistemlere gönderildiğinde host bazında filtreleme yapmayı kolaylaştırır.

uname’in Sınırlılıkları

Dürüst olmak gerekirse uname her şeyi söylemez. Şunları uname ile öğrenemezsin:

  • CPU çekirdek sayısı (bunun için nproc veya lscpu kullanırsın)
  • Toplam RAM miktarı (bunun için free -h veya /proc/meminfo)
  • Disk kapasitesi (bunun için df -h veya lsblk)
  • Hangi distronun kurulu olduğu (bunun için /etc/os-release)
  • Virtualizasyon platformu (bunun için systemd-detect-virt veya dmidecode)
  • BIOS/UEFI bilgisi (bunun için dmidecode veya efibootmgr)

uname kernel ve temel sistem kimliği için mükemmeldir ama kapsamlı sistem bilgisi için lshw, dmidecode, inxi gibi araçlarla desteklenmelidir.

Hızlı Referans: Hangi Durumda Hangi Parametre?

Günlük işlerde hangi durumda hangi parametreyi kullanacağını kafana kazımak için şunları aklında tut:

  • Kernel güvenlik açığı kontrolü yapıyorsun: uname -r
  • Binary veya paket indiriyorsun, mimari lazım: uname -m
  • Log veya rapor yazıyorsun, her şey lazım: uname -a
  • Script içinde hostname lazım, hostname komutu yoksa: uname -n
  • Kernelin ne zaman derlendiğini öğrenmek istiyorsun: uname -v
  • İşletim sistemi adı lazım: uname -o

Sonuç

uname komutu, “işe yaramaz gibi görünen ama aslında her yerde ihtiyaç duyulan” araçların başında gelir. Günde onlarca kez kullanmayabilirsin ama gerektiğinde bilmemen seni ciddi şekilde yavaşlatır. Kernel sürümü kontrolünden mimari bazlı binary seçimine, güvenlik açığı taramasından envanter yönetimine kadar pek çok senaryoda temel yapı taşı olarak işlev görür.

Özellikle scriptler yazarken uname çıktılarını değişkene atıp mantıksal kararlar için kullanmak alışkanlık haline getirmen gereken şeylerden biri. Hem okunabilir hem taşınabilir scriptler elde etmiş olursun.

Son olarak şunu vurgulayayım: uname evrenseldir. Debian, RedHat, Alpine, Arch, eski bir SunOS kalıntısı bile olsa, her POSIX uyumlu sistemde çalışır. Bu portabilite, özellikle heterojen ortamları yönetirken büyük avantaj sağlar. Bir sysadmin olarak araç kutuna eklediğin her evrensel komut, bir gün seni güç bir durumdan kurtarır.

Yorum yapın