CDN Performans Analizi ve İzleme: Kapsamlı Rehber

Tarafındankomut
0 Yorum

CDN’inizin ne kadar hızlı çalıştığını biliyor musunuz, gerçekten? “Cache hit ratio %85” demek güzel ama bu sayının arkasında ne olduğunu anlamadan CDN yönetimi yapmak, araba kullanırken sadece hız göstergesine bakmak gibi. Bugün CDN performans analizini ve izlemeyi derinlemesine ele alacağız; gerçek dünya senaryoları, çalışan araçlar ve pratik scriptlerle.

CDN Performans Metriklerini Anlamak

Bir CDN’in sağlıklı çalışıp çalışmadığını anlamak için hangi metriklere bakmanız gerektiğini bilmek şart. Yanlış metrikleri izlerseniz, gerçek sorunları kaçırırsınız.

Temel metrikler şunlar:

  • Cache Hit Ratio: İsteklerin CDN cache’inden karşılanma oranı. %90 üzeri genellikle iyi kabul edilir ama içeriğe göre değişir.
  • Origin Shield Efficacy: Origin sunucunuza giden istek sayısının toplam isteğe oranı. Ne kadar az origin isteği, o kadar iyi.
  • TTFB (Time to First Byte): İlk baytın alınma süresi. 200ms altı hedeflenmelidir.
  • Edge Latency: CDN edge node’undan kullanıcıya olan gecikme.
  • Error Rate: 4xx ve 5xx hataların toplam isteklere oranı. %1 üzeri ciddi bir sorun işareti.
  • Bandwidth Savings: CDN sayesinde origin’den ne kadar az bant genişliği tüketildiği.

Şimdi bunları nasıl ölçeceğimize bakalım.

Temel Performans Testleri ile Başlamak

İlk adım olarak curl ile basit ama etkili testler yapabilirsiniz. Bu tek araçla çok fazla bilgi çıkarabilirsiniz.

#!/bin/bash
# cdn_basic_test.sh - Temel CDN performans testi

TARGET_URL="https://cdn.orneksite.com/static/main.js"
LOCATIONS=("Cloudflare" "AWS" "Azure")

curl_test() {
    local url=$1
    curl -o /dev/null -s -w 
        "DNS Lookup: %{time_namelookup}sn
Connect: %{time_connect}sn
TLS Handshake: %{time_appconnect}sn
TTFB: %{time_starttransfer}sn
Total: %{time_total}sn
Download Speed: %{speed_download} bytes/sn
HTTP Status: %{http_code}n
Cache Status: %{header{x-cache}}n" 
        -H "Accept-Encoding: gzip, br" 
        "$url"
}

echo "=== CDN Performans Testi: $(date) ==="
echo "URL: $TARGET_URL"
echo ""

for i in {1..5}; do
    echo "--- Test $i ---"
    curl_test "$TARGET_URL"
    sleep 1
done

Bu scripti çalıştırdığınızda x-cache header’ı size HIT veya MISS dönecek. İlk istekte MISS, sonrakilerde HIT görüyorsanız cache düzgün çalışıyor demektir.

Gerçek Dünya Senaryo: E-ticaret Sitesi CDN Analizi

Geçen ay bir e-ticaret firması için CDN performans analizi yaptım. Site Cloudflare kullanıyordu ama “yavaş” şikayetleri geliyordu. Sorun cache hit ratio’sunda değil, cache policy’deydi.

#!/bin/bash
# cache_header_analyzer.sh - Cache header analizi

analyze_cache_headers() {
    local url=$1
    echo "Analiz ediliyor: $url"
    
    # Tüm response headerlarını al
    headers=$(curl -sI "$url")
    
    # Cache-Control headerını kontrol et
    cache_control=$(echo "$headers" | grep -i "cache-control:" | tr -d 'r')
    age=$(echo "$headers" | grep -i "^age:" | tr -d 'r')
    expires=$(echo "$headers" | grep -i "^expires:" | tr -d 'r')
    etag=$(echo "$headers" | grep -i "^etag:" | tr -d 'r')
    cf_cache=$(echo "$headers" | grep -i "cf-cache-status:" | tr -d 'r')
    
    echo "  Cache-Control: $cache_control"
    echo "  Age: $age"
    echo "  Expires: $expires"
    echo "  ETag: $etag"
    echo "  CF Cache Status: $cf_cache"
    
    # Cache süresi hesapla
    max_age=$(echo "$cache_control" | grep -oP 'max-age=K[0-9]+')
    if [ -n "$max_age" ]; then
        hours=$((max_age / 3600))
        echo "  Cache Süresi: $hours saat ($max_age saniye)"
    fi
    echo ""
}

# Farklı içerik tiplerini test et
URLS=(
    "https://cdn.orneksite.com/static/style.css"
    "https://cdn.orneksite.com/static/main.js"
    "https://cdn.orneksite.com/images/hero.jpg"
    "https://cdn.orneksite.com/api/products"
)

for url in "${URLS[@]}"; do
    analyze_cache_headers "$url"
done

Bu scriptle o e-ticaret sitesinin sorununu bulduk: API endpoint’leri yanlışlıkla CDN cache’ine alınıyordu ve Cache-Control: no-cache headerı eksikti. Ürün fiyatları 24 saat stale kalıyordu!

Çoklu Lokasyon Performans Testi

CDN’in farklı coğrafi konumlarda nasıl performans gösterdiğini anlamak kritik. Bunun için curl ile birkaç farklı DNS resolver ve proxy üzerinden test edebilirsiniz.

#!/bin/bash
# multi_location_test.sh - Çoklu lokasyon CDN testi

URL="https://cdn.orneksite.com/large-asset.js"

# Farklı DNS sunucularını kullanarak simüle et
DNS_SERVERS=(
    "8.8.8.8"       # Google (US)
    "1.1.1.1"       # Cloudflare
    "208.67.222.222" # OpenDNS
    "9.9.9.9"       # Quad9
)

echo "Lokasyon bazlı CDN performans testi"
echo "URL: $URL"
echo "Tarih: $(date)"
echo ""

for dns in "${DNS_SERVERS[@]}"; do
    echo "DNS Server: $dns"
    
    resolved_ip=$(dig @"$dns" +short $(echo $URL | awk -F/ '{print $3}') | head -1)
    echo "  Çözümlenen IP: $resolved_ip"
    
    # IP'nin hangi ülkede olduğunu sorgu
    if [ -n "$resolved_ip" ]; then
        geo_info=$(curl -s "http://ip-api.com/json/$resolved_ip" | python3 -c "
import sys, json
data = json.load(sys.stdin)
print(f'  Lokasyon: {data.get("city", "?")}, {data.get("country", "?")}')
print(f'  ISP: {data.get("isp", "?")}')
")
        echo "$geo_info"
    fi
    
    # Performans testi
    result=$(curl -o /dev/null -s -w "%{time_starttransfer}" 
        --dns-servers "$dns" 
        "$URL" 2>/dev/null)
    
    echo "  TTFB: ${result}s"
    echo ""
done

Prometheus ve Grafana ile CDN Monitoring

Gerçek bir production ortamında tek seferlik testler yetmez. Sürekli izleme için Prometheus exporter yazalım.

#!/bin/bash
# cdn_metrics_exporter.sh
# Bu script Prometheus textfile collector formatında metrik üretir
# /etc/cron.d/cdn-metrics dosyasına: * * * * * root /opt/cdn_metrics_exporter.sh > /var/lib/prometheus/cdn_metrics.prom.tmp && mv /var/lib/prometheus/cdn_metrics.prom.tmp /var/lib/prometheus/cdn_metrics.prom

OUTPUT_FILE="/var/lib/prometheus/cdn_metrics.prom"
URLS_FILE="/etc/cdn_monitor/urls.conf"
TIMESTAMP=$(date +%s)

# Metrik başlıkları
cat > "$OUTPUT_FILE" << 'EOF'
# HELP cdn_ttfb_seconds Time to first byte for CDN requests
# TYPE cdn_ttfb_seconds gauge
# HELP cdn_total_time_seconds Total request time for CDN
# TYPE cdn_total_time_seconds gauge
# HELP cdn_cache_hit CDN cache hit (1) or miss (0)
# TYPE cdn_cache_hit gauge
# HELP cdn_http_status HTTP status code
# TYPE cdn_http_status gauge
EOF

while IFS=',' read -r label url; do
    # Boş satır ve yorum satırlarını atla
    [[ "$label" =~ ^#.*$ || -z "$label" ]] && continue
    
    result=$(curl -o /dev/null -s -w 
        "%{time_starttransfer},%{time_total},%{http_code},%{header{x-cache}},%{header{cf-cache-status}}" 
        -H "User-Agent: CDN-Monitor/1.0" 
        --max-time 10 
        "$url" 2>/dev/null)
    
    ttfb=$(echo "$result" | cut -d',' -f1)
    total=$(echo "$result" | cut -d',' -f2)
    status=$(echo "$result" | cut -d',' -f3)
    xcache=$(echo "$result" | cut -d',' -f4 | tr '[:lower:]' '[:upper:]' | tr -d ' ')
    cfcache=$(echo "$result" | cut -d',' -f5 | tr -d ' ')
    
    # Cache hit tespiti (farklı CDN'ler farklı header kullanır)
    cache_hit=0
    if [[ "$xcache" == *"HIT"* || "$cfcache" == "HIT" ]]; then
        cache_hit=1
    fi
    
    # Prometheus formatında yaz
    echo "cdn_ttfb_seconds{endpoint="$label",url="$url"} $ttfb" >> "$OUTPUT_FILE"
    echo "cdn_total_time_seconds{endpoint="$label",url="$url"} $total" >> "$OUTPUT_FILE"
    echo "cdn_cache_hit{endpoint="$label",url="$url"} $cache_hit" >> "$OUTPUT_FILE"
    echo "cdn_http_status{endpoint="$label",url="$url"} $status" >> "$OUTPUT_FILE"
    
done < "$URLS_FILE"

/etc/cdn_monitor/urls.conf dosyası şu formatta olacak:

# label,url
homepage_css,https://cdn.orneksite.com/static/style.css
app_js,https://cdn.orneksite.com/static/app.js
hero_image,https://cdn.orneksite.com/images/hero.webp
api_health,https://cdn.orneksite.com/api/health

CDN Log Analizi

CDN’ler genellikle log export özelliği sunar. Cloudflare’in Logpush veya AWS CloudFront access log’larını analiz etmek için güçlü bir script:

#!/bin/bash
# cdn_log_analyzer.sh - CDN erişim log analizi
# AWS CloudFront log formatını destekler

LOG_DIR="/var/log/cloudfront"
REPORT_DATE=$(date -d "yesterday" +%Y-%m-%d)
LOG_FILE="$LOG_DIR/access_$REPORT_DATE.log"

if [ ! -f "$LOG_FILE" ]; then
    echo "Log dosyası bulunamadı: $LOG_FILE"
    exit 1
fi

echo "=== CDN Log Analizi: $REPORT_DATE ==="
echo ""

# Toplam istek sayısı
total_requests=$(grep -v "^#" "$LOG_FILE" | wc -l)
echo "Toplam İstek: $total_requests"

# HTTP status dağılımı
echo ""
echo "HTTP Status Dağılımı:"
grep -v "^#" "$LOG_FILE" | awk '{print $9}' | sort | uniq -c | sort -rn | while read count status; do
    percentage=$(echo "scale=2; $count * 100 / $total_requests" | bc)
    echo "  HTTP $status: $count istek ($percentage%)"
done

# Cache hit/miss oranı
echo ""
cache_hits=$(grep -v "^#" "$LOG_FILE" | awk '{print $14}' | grep -c "Hit")
cache_misses=$(grep -v "^#" "$LOG_FILE" | awk '{print $14}' | grep -c "Miss")
hit_ratio=$(echo "scale=2; $cache_hits * 100 / ($cache_hits + $cache_misses)" | bc)
echo "Cache Hit Ratio: $hit_ratio%"
echo "  Hit: $cache_hits"
echo "  Miss: $cache_misses"

# En çok istenen dosyalar
echo ""
echo "En Çok İstenen 10 Dosya:"
grep -v "^#" "$LOG_FILE" | awk '{print $8}' | sort | uniq -c | sort -rn | head -10 | while read count path; do
    echo "  $count x $path"
done

# En yüksek bandwidth tüketen dosyalar
echo ""
echo "En Fazla Bandwidth Tüketen 5 Dosya:"
grep -v "^#" "$LOG_FILE" | awk '{print $8, $4}' | sort -k1,1 | awk '{
    size[$1] += $2
    count[$1]++
} END {
    for (f in size) print size[f], count[f], f
}' | sort -rn | head -5 | while read bytes count path; do
    mb=$(echo "scale=2; $bytes / 1048576" | bc)
    echo "  $mb MB ($count istek): $path"
done

# Origin'e giden istekler (cache miss olan büyük dosyalar)
echo ""
echo "Origin'e En Çok Yük Bindiren İstekler:"
grep -v "^#" "$LOG_FILE" | awk '$14 == "Miss" {print $8, $4}' | sort -k2 -rn | head -5 | while read path bytes; do
    mb=$(echo "scale=2; $bytes / 1048576" | bc)
    echo "  $mb MB: $path"
done

Uyarı Sistemi Kurmak

Monitoring’in en kritik parçası uyarılar. Aşağıdaki script CDN performansı belirli eşiklerin altına düştüğünde Slack’e bildirim gönderir:

#!/bin/bash
# cdn_alerting.sh - CDN performans uyarı sistemi

SLACK_WEBHOOK="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
ALERT_LOG="/var/log/cdn_alerts.log"

# Eşik değerleri
TTFB_THRESHOLD=2.0        # saniye
ERROR_RATE_THRESHOLD=5.0  # yüzde
CACHE_HIT_THRESHOLD=70.0  # yüzde (bu değerin ALTINA düşerse uyarı)

send_slack_alert() {
    local severity=$1
    local message=$2
    local url=$3
    
    color="warning"
    [[ "$severity" == "critical" ]] && color="danger"
    [[ "$severity" == "info" ]] && color="good"
    
    payload=$(cat << EOF
{
    "attachments": [{
        "color": "$color",
        "title": "CDN Performans Uyarisi - $severity",
        "text": "$message",
        "fields": [
            {"title": "URL", "value": "$url", "short": true},
            {"title": "Zaman", "value": "$(date '+%Y-%m-%d %H:%M:%S')", "short": true}
        ],
        "footer": "CDN Monitor"
    }]
}
EOF
)
    
    curl -s -X POST -H 'Content-type: application/json' 
        --data "$payload" "$SLACK_WEBHOOK" > /dev/null
    
    echo "$(date): [$severity] $message - $url" >> "$ALERT_LOG"
}

check_cdn_endpoint() {
    local label=$1
    local url=$2
    local errors=0
    local total_ttfb=0
    local cache_hits=0
    local total_tests=10
    
    echo "Kontrol ediliyor: $label ($url)"
    
    for i in $(seq 1 $total_tests); do
        result=$(curl -o /dev/null -s -w "%{time_starttransfer},%{http_code},%{header{cf-cache-status}}" 
            --max-time 10 "$url" 2>/dev/null)
        
        ttfb=$(echo "$result" | cut -d',' -f1)
        status=$(echo "$result" | cut -d',' -f2)
        cache=$(echo "$result" | cut -d',' -f3 | tr -d ' ')
        
        total_ttfb=$(echo "$total_ttfb + $ttfb" | bc)
        
        [[ "$status" -ge 400 ]] && ((errors++))
        [[ "$cache" == "HIT" ]] && ((cache_hits++))
        
        sleep 0.5
    done
    
    avg_ttfb=$(echo "scale=3; $total_ttfb / $total_tests" | bc)
    error_rate=$(echo "scale=2; $errors * 100 / $total_tests" | bc)
    hit_ratio=$(echo "scale=2; $cache_hits * 100 / $total_tests" | bc)
    
    echo "  Ortalama TTFB: ${avg_ttfb}s"
    echo "  Hata Oranı: ${error_rate}%"
    echo "  Cache Hit Ratio: ${hit_ratio}%"
    
    # TTFB kontrolü
    if (( $(echo "$avg_ttfb > $TTFB_THRESHOLD" | bc -l) )); then
        send_slack_alert "critical" 
            "Yuksek TTFB tespit edildi: ${avg_ttfb}s (esik: ${TTFB_THRESHOLD}s)" 
            "$url"
    fi
    
    # Hata oranı kontrolü
    if (( $(echo "$error_rate > $ERROR_RATE_THRESHOLD" | bc -l) )); then
        send_slack_alert "critical" 
            "Yuksek hata orani: ${error_rate}% (esik: ${ERROR_RATE_THRESHOLD}%)" 
            "$url"
    fi
    
    # Cache hit ratio kontrolü
    if (( $(echo "$hit_ratio < $CACHE_HIT_THRESHOLD" | bc -l) )); then
        send_slack_alert "warning" 
            "Dusuk cache hit ratio: ${hit_ratio}% (esik: ${CACHE_HIT_THRESHOLD}%)" 
            "$url"
    fi
}

# Cron'a ekle: */5 * * * * /opt/cdn_alerting.sh
ENDPOINTS=(
    "Ana Sayfa CSS|https://cdn.orneksite.com/static/style.css"
    "Uygulama JS|https://cdn.orneksite.com/static/app.bundle.js"
    "API Saglik|https://cdn.orneksite.com/health"
)

for endpoint in "${ENDPOINTS[@]}"; do
    label=$(echo "$endpoint" | cut -d'|' -f1)
    url=$(echo "$endpoint" | cut -d'|' -f2)
    check_cdn_endpoint "$label" "$url"
    echo ""
done

Cache Purge Otomasyonu

Deployment sonrası CDN cache’ini temizlemek sıkça yapılan bir operasyondur. Her CDN için ayrı bir komut vardır ama hepsini bir scriptte toplayabilirsiniz:

#!/bin/bash
# cdn_cache_purge.sh - CDN cache temizleme otomasyonu
# CI/CD pipeline'ınıza entegre edin

CDN_PROVIDER="${CDN_PROVIDER:-cloudflare}"
DEPLOY_VERSION="${DEPLOY_VERSION:-$(date +%s)}"

purge_cloudflare() {
    local zone_id="$CF_ZONE_ID"
    local api_token="$CF_API_TOKEN"
    local urls=("$@")
    
    echo "Cloudflare cache temizleniyor..."
    
    # URL listesini JSON array'e çevir
    url_json=$(printf '"%s",' "${urls[@]}" | sed 's/,$//')
    
    response=$(curl -s -X POST 
        "https://api.cloudflare.com/client/v4/zones/$zone_id/purge_cache" 
        -H "Authorization: Bearer $api_token" 
        -H "Content-Type: application/json" 
        --data "{"files":[$url_json]}")
    
    success=$(echo "$response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('success', False))")
    
    if [ "$success" = "True" ]; then
        echo "  Cloudflare cache basariyla temizlendi"
        return 0
    else
        echo "  HATA: $(echo "$response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('errors', []))")"
        return 1
    fi
}

purge_aws_cloudfront() {
    local distribution_id="$CF_DISTRIBUTION_ID"
    local paths=("$@")
    
    echo "AWS CloudFront cache temizleniyor..."
    
    path_json=$(printf '"%s",' "${paths[@]}" | sed 's/,$//')
    
    aws cloudfront create-invalidation 
        --distribution-id "$distribution_id" 
        --paths "${paths[@]}" 
        --query 'Invalidation.Id' 
        --output text
    
    echo "  CloudFront invalidation olusturuldu"
}

# Kullanim ornegi
PURGE_URLS=(
    "https://cdn.orneksite.com/static/style.css"
    "https://cdn.orneksite.com/static/app.bundle.js"
    "https://cdn.orneksite.com/static/vendor.js"
)

case "$CDN_PROVIDER" in
    "cloudflare")
        purge_cloudflare "${PURGE_URLS[@]}"
        ;;
    "cloudfront")
        PURGE_PATHS=("/static/style.css" "/static/app.bundle.js" "/static/vendor.js")
        purge_aws_cloudfront "${PURGE_PATHS[@]}"
        ;;
    *)
        echo "Desteklenmeyen CDN provider: $CDN_PROVIDER"
        exit 1
        ;;
esac

# Purge sonrası doğrulama: cache miss bekleniyor
echo ""
echo "Purge sonrasi dogrulama (cache miss bekleniyor):"
sleep 5

for url in "${PURGE_URLS[@]}"; do
    cf_status=$(curl -sI "$url" | grep -i "cf-cache-status:" | tr -d 'rn' | awk '{print $2}')
    echo "  $url -> $cf_status"
done

Gerçek Dünya Sorunları ve Çözümleri

Yıllar içinde karşılaştığım en yaygın CDN sorunlarını ve nasıl tespit edileceğini paylaşmak istiyorum:

Sorun 1: Thundering Herd (Origin Flood) Cache süresi dolduğunda binlerce eş zamanlı istek origin’e ulaşır. Bunu log’larda tespit etmek için:

  • Origin sunucuda ani trafik spike’larını izleyin
  • Stale-while-revalidate header’ını aktif edin
  • CDN’in “Stale Content” özelliğini kullanın

Sorun 2: Vary Header Cehennemi Vary: Accept-Encoding, Accept-Language, User-Agent gibi bir header cache verimliliğini mahveder. Her farklı header kombinasyonu ayrı bir cache girişi oluşturur.

  • Sadece Vary: Accept-Encoding kullanın
  • Dil ve cihaz bazlı içerikleri farklı URL’lere taşıyın

Sorun 3: Cookie Kirliliği Authentication cookie’leri CDN’in cache’lememesine neden olur. Çözüm olarak:

  • Static asset domain’ini uygulama domain’inden ayırın (cdn.orneksite.com vs orneksite.com)
  • CDN kurallarında belirli cookie’leri strip edin

Sorun 4: SSL/TLS Performans Sorunu CDN-Origin arası bağlantı her seferinde TLS handshake yapıyorsa ciddi latency eklenir.

  • Origin Shield veya tiered caching aktif edin
  • CDN’den origin’e persistent connection kullandığınızdan emin olun
  • Origin’de TLS session resumption aktif olmalı

Haftalık CDN Sağlık Raporu

Tüm metrikleri bir araya getiren ve haftalık rapor üreten script:

#!/bin/bash
# cdn_weekly_report.sh - Haftalık CDN sağlık raporu
# Cron: 0 8 * * 1 /opt/cdn_weekly_report.sh | mail -s "CDN Haftalik Rapor" [email protected]

START_DATE=$(date -d "7 days ago" +%Y-%m-%d)
END_DATE=$(date +%Y-%m-%d)
LOG_DIR="/var/log/cloudfront"

echo "CDN Haftalik Saglik Raporu"
echo "Donem: $START_DATE / $END_DATE"
echo "Olusturulma: $(date)"
echo ""
echo "================================================"

# Toplam metrikleri hesapla
total_req=0
total_errors=0
total_hits=0
total_bytes=0

for day_offset in {1..7}; do
    day=$(date -d "$day_offset days ago" +%Y-%m-%d)
    log="$LOG_DIR/access_$day.log"
    
    [ ! -f "$log" ] && continue
    
    day_req=$(grep -v "^#" "$log" | wc -l)
    day_errors=$(grep -v "^#" "$log" | awk '$9 >= 400' | wc -l)
    day_hits=$(grep -v "^#" "$log" | awk '$14 == "Hit"' | wc -l)
    day_bytes=$(grep -v "^#" "$log" | awk '{sum += $4} END {print sum}')
    
    total_req=$((total_req + day_req))
    total_errors=$((total_errors + day_errors))
    total_hits=$((total_hits + day_hits))
    total_bytes=$((total_bytes + day_bytes))
done

# Oranları hesapla
if [ $total_req -gt 0 ]; then
    error_rate=$(echo "scale=2; $total_errors * 100 / $total_req" | bc)
    hit_ratio=$(echo "scale=2; $total_hits * 100 / $total_req" | bc)
    total_gb=$(echo "scale=2; $total_bytes / 1073741824" | bc)
    
    echo "GENEL ISTATISTIKLER"
    echo "  Toplam Istek: $total_req"
    echo "  Toplam Trafik: ${total_gb} GB"
    echo "  Hata Orani: ${error_rate}%"
    echo "  Cache Hit Ratio: ${hit_ratio}%"
    echo ""
    
    # Sağlık durumu değerlendirmesi
    echo "SAGLIK DEGERLENDIRMESI"
    
    if (( $(echo "$hit_ratio > 85" | bc -l) )); then
        echo "  Cache Performance: MUKEMMEL (${hit_ratio}%)"
    elif (( $(echo "$hit_ratio > 70" | bc -l) )); then
        echo "  Cache Performance: IYI (${hit_ratio}%)"
    else
        echo "  Cache Performance: DIKKAT GEREKIYOR (${hit_ratio}%)"
    fi
    
    if (( $(echo "$error_rate < 1" | bc -l) )); then
        echo "  Hata Orani: NORMAL (${error_rate}%)"
    elif (( $(echo "$error_rate < 5" | bc -l) )); then
        echo "  Hata Orani: DIKKAT (${error_rate}%)"
    else
        echo "  Hata Orani: KRITIK (${error_rate}%)"
    fi
fi

echo ""
echo "================================================"
echo "Rapor sonu"

Sonuç

CDN performans analizi ve izlemesi, bir kez kurulup unutulan bir sistem değil. Production ortamınız değiştikçe, trafiğiniz büyüdükçe ve içerik tipileriniz çeşitlendikçe CDN ayarlarınızı ve monitoring sisteminizi güncellemeniz gerekir.

En kritik nokta şu: metrik toplamak değil, o metriklere göre aksiyon almak önemli. Cache hit ratio %65’e düşmüş ama kimse bakmıyorsa dashboard’un hiç önemi yok. Uyarı eşiklerinizi belirleyin, uyarıları doğru kişilere yönlendirin ve her uyarı için bir runbook oluşturun.

Başlangıç için önerim şu sırayla ilerleyin: önce temel curl testlerini çalıştırın ve baseline belirleyin, ardından Prometheus metriklerini kurun, sonra uyarı sistemini aktif edin ve son olarak haftalık raporları otomatikleştirin. Bu dört adımı tamamladığınızda CDN’inizin durumunu gerçek anlamıyla anlayan bir sysadmin olursunuz; sayfalara bakmak zorunda kalmadan sorunları önceden yakalarsınız.

CDN’ler doğru yapılandırıldığında ve izlendiğinde hem kullanıcı deneyimini dramatik biçimde iyileştirir hem de altyapı maliyetlerini düşürür. Ama bunun için kör uçmayı bırakıp veriyle çalışmak şart.

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir