OpenLiteSpeed ile Çoklu Sunucu Arasında Yapılandırma Senkronizasyonu

Yazar:komut.io ekibi OpenLiteSpeed Web Sunucusu Yönetimi
0 Yorum

Birden fazla sunucu yönetiyorsanız ve bunların hepsinde OpenLiteSpeed çalışıyorsa, bir noktada şu soruyla yüzleşmek zorunda kalırsınız: “Bu konfigürasyonu her sunucuya tek tek mi kopyalayacağım?” Cevap kesinlikle hayır olmalı. Bu yazıda, OpenLiteSpeed yapılandırmalarını çoklu sunucu ortamında nasıl senkronize edeceğinizi, gerçek dünya senaryolarıyla birlikte adım adım ele alacağız.

OpenLiteSpeed Yapılandırma Dosyalarını Tanımak

Senkronizasyon yapmadan önce neyi senkronize edeceğinizi bilmek gerekiyor. OpenLiteSpeed’in yapılandırma dosyaları varsayılan olarak /usr/local/lsws/conf/ dizininde bulunur. Bu dizinin altında şunlar yer alır:

  • /usr/local/lsws/conf/httpd_config.conf: Ana sunucu yapılandırması, dinleme portları, global ayarlar
  • /usr/local/lsws/conf/vhosts/: Sanal host tanımları her biri kendi alt dizininde
  • /usr/local/lsws/conf/vhosts/SITENAME/vhconf.conf: Site bazlı yapılandırma dosyası
  • /usr/local/lsws/conf/templates/: Sanal host şablonları
  • /usr/local/lsws/conf/geoip/: GeoIP veritabanları ve ilgili ayarlar

Bunların yanı sıra SSL sertifikaları genellikle /etc/letsencrypt/live/ altında tutulur ve onların da senkronizasyona dahil edilmesi gerekir.

# Yapılandırma dizininin içeriğini görmek için
find /usr/local/lsws/conf/ -type f -name "*.conf" | sort

# Hangi dosyaların son değiştirildiğini kontrol etmek için
find /usr/local/lsws/conf/ -type f -newer /tmp/last_sync -ls

Senaryo: 3 Sunuculu Yük Dengeleyici Ortamı

Diyelim ki elinizde şöyle bir yapı var: bir yük dengeleyici (load balancer) ve arkasında iki web sunucusu. Tüm trafiği load balancer üzerinden alıyorsunuz, web sunucularının yapılandırmaları her zaman birbirleriyle tutarlı olmalı. Herhangi birinde yapılan değişiklik diğerine de yansımalı. İşte burada senkronizasyon devreye giriyor.

Ortamımız şöyle olsun:

  • web01: 192.168.1.10 (birincil, master sunucu)
  • web02: 192.168.1.11 (ikincil, slave sunucu)
  • web03: 192.168.1.12 (üçüncül, slave sunucu)

rsync ile Temel Senkronizasyon

En basit ve en etkili yöntem rsync kullanmaktır. rsync, dosya değişikliklerini delta bazlı aktarır, yani sadece değişen kısımları gönderir. Bu hem bant genişliği hem de zaman açısından verimlidir.

Önce master sunucudan slave’lere SSH key tabanlı erişim ayarlamanız gerekiyor:

# web01 üzerinde SSH key oluşturun (varsa atlayın)
ssh-keygen -t ed25519 -C "ols-sync@web01" -f /root/.ssh/ols_sync_key -N ""

# Public key'i web02 ve web03'e kopyalayın
ssh-copy-id -i /root/.ssh/ols_sync_key.pub [email protected]
ssh-copy-id -i /root/.ssh/ols_sync_key.pub [email protected]

# Bağlantıyı test edin
ssh -i /root/.ssh/ols_sync_key [email protected] "hostname"

Şimdi temel senkronizasyon scriptini yazalım:

#!/bin/bash
# /usr/local/bin/ols-sync.sh

MASTER_CONF="/usr/local/lsws/conf/"
SSH_KEY="/root/.ssh/ols_sync_key"
LOG_FILE="/var/log/ols-sync.log"
SLAVES=("192.168.1.11" "192.168.1.12")

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

sync_to_slave() {
    local SLAVE_IP="$1"
    log "Senkronizasyon basliyor: $SLAVE_IP"

    rsync -avz --delete 
        --exclude="*.lock" 
        --exclude="*.pid" 
        -e "ssh -i $SSH_KEY -o StrictHostKeyChecking=no" 
        "$MASTER_CONF" 
        "root@$SLAVE_IP:$MASTER_CONF"

    if [ $? -eq 0 ]; then
        log "Senkronizasyon basarili: $SLAVE_IP"
        # OpenLiteSpeed'i graceful restart yap
        ssh -i "$SSH_KEY" root@"$SLAVE_IP" 
            "kill -USR1 $(cat /tmp/lshttpd.pid) 2>/dev/null || /usr/local/lsws/bin/lswsctrl restart"
        log "OLS yeniden baslatildi: $SLAVE_IP"
    else
        log "HATA: Senkronizasyon basarisiz: $SLAVE_IP"
        exit 1
    fi
}

for slave in "${SLAVES[@]}"; do
    sync_to_slave "$slave"
done

log "Tum senkronizasyonlar tamamlandi."

Bu scripti çalıştırılabilir hale getirin ve test edin:

chmod +x /usr/local/bin/ols-sync.sh
/usr/local/bin/ols-sync.sh

Otomatik Senkronizasyon: inotifywait ile Gerçek Zamanlı İzleme

Manuel veya cron tabanlı senkronizasyon çoğu zaman yeterli olsa da, kritik ortamlarda dosya değiştiği anda senkronizasyon yapmak isteyebilirsiniz. Bunun için inotify-tools paketini kullanabiliriz.

# Ubuntu/Debian
apt-get install inotify-tools -y

# CentOS/RHEL/AlmaLinux
yum install inotify-tools -y

Şimdi dosya değişikliklerini izleyen ve otomatik senkronizasyon tetikleyen bir daemon yazalım:

#!/bin/bash
# /usr/local/bin/ols-watch.sh

WATCH_DIR="/usr/local/lsws/conf/"
SYNC_SCRIPT="/usr/local/bin/ols-sync.sh"
LOG_FILE="/var/log/ols-watch.log"
COOLDOWN=5  # Saniye cinsinden bekleme suresi

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}

log "OLS yapilandirma izleyici baslatildi. Dizin: $WATCH_DIR"

LAST_SYNC=0

inotifywait -m -r -e modify,create,delete,moved_to,moved_from 
    --format '%T %w %f %e' 
    --timefmt '%Y-%m-%d %H:%M:%S' 
    "$WATCH_DIR" 2>/dev/null | while read DATE TIME DIR FILE EVENT; do

    CURRENT_TIME=$(date +%s)
    DIFF=$((CURRENT_TIME - LAST_SYNC))

    # Cooldown suresi dolmadiysa atla
    if [ "$DIFF" -lt "$COOLDOWN" ]; then
        continue
    fi

    log "Degisiklik algilandi: $DIR$FILE ($EVENT)"
    log "Senkronizasyon tetikleniyor..."

    "$SYNC_SCRIPT" >> "$LOG_FILE" 2>&1
    LAST_SYNC=$(date +%s)
done

Bu scripti systemd servisi olarak tanımlayalım:

cat > /etc/systemd/system/ols-watch.service << 'EOF'
[Unit]
Description=OpenLiteSpeed Config Watcher and Sync Service
After=network.target lsws.service

[Service]
Type=simple
ExecStart=/usr/local/bin/ols-watch.sh
Restart=always
RestartSec=10
User=root
StandardOutput=append:/var/log/ols-watch.log
StandardError=append:/var/log/ols-watch.log

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable ols-watch
systemctl start ols-watch
systemctl status ols-watch

Git ile Yapılandırma Versiyonlama

Büyük ekiplerde çalışıyorsanız, yapılandırma değişikliklerini Git ile takip etmek hem geçmişe dönük inceleme hem de rollback imkanı sağlar. Bu yaklaşım “Infrastructure as Code” felsefesinin bir parçasıdır.

# web01'de git reposu başlatın
cd /usr/local/lsws/conf/
git init
git config user.email "[email protected]"
git config user.name "OLS Sync Bot"

# .gitignore oluşturun
cat > /usr/local/lsws/conf/.gitignore << 'EOF'
*.lock
*.pid
*.bak
*.tmp
EOF

# İlk commit
git add -A
git commit -m "Initial OLS configuration commit"

Git hook ile her commit sonrası otomatik senkronizasyon tetikleyelim:

cat > /usr/local/lsws/conf/.git/hooks/post-commit << 'EOF'
#!/bin/bash
echo "Yapılandırma değişikliği commit edildi. Senkronizasyon başlıyor..."
/usr/local/bin/ols-sync.sh
EOF

chmod +x /usr/local/lsws/conf/.git/hooks/post-commit

Artık bir değişiklik yaptığınızda şu akış işleyecek:

# Örneğin bir sanal host yapılandırmasını güncellediniz
nano /usr/local/lsws/conf/vhosts/example.com/vhconf.conf

# Değişikliği commit edin, hook otomatik senkronizasyonu tetikleyecek
cd /usr/local/lsws/conf/
git add -A
git commit -m "example.com: PHP handler guncellendi"

SSL Sertifikalarının Senkronizasyonu

OpenLiteSpeed yapılandırmasının önemli bir parçası da SSL sertifikalarıdır. Let’s Encrypt kullanıyorsanız, sertifikaların tüm sunucularda güncel kalması kritik önem taşır.

#!/bin/bash
# /usr/local/bin/ssl-sync.sh

SSH_KEY="/root/.ssh/ols_sync_key"
LOG_FILE="/var/log/ssl-sync.log"
SLAVES=("192.168.1.11" "192.168.1.12")
CERT_DIR="/etc/letsencrypt/"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

sync_ssl() {
    local SLAVE_IP="$1"
    log "SSL sertifikalari senkronize ediliyor: $SLAVE_IP"

    rsync -avz --delete 
        -e "ssh -i $SSH_KEY -o StrictHostKeyChecking=no" 
        "$CERT_DIR" 
        "root@$SLAVE_IP:$CERT_DIR"

    if [ $? -eq 0 ]; then
        log "SSL sync basarili: $SLAVE_IP"
    else
        log "HATA: SSL sync basarisiz: $SLAVE_IP"
    fi
}

for slave in "${SLAVES[@]}"; do
    sync_ssl "$slave"
done

# Ana OLS sync scriptini de calistir
/usr/local/bin/ols-sync.sh

Let’s Encrypt yenileme hook’una da ekleyin:

cat > /etc/letsencrypt/renewal-hooks/post/ols-ssl-sync.sh << 'EOF'
#!/bin/bash
/usr/local/bin/ssl-sync.sh
EOF

chmod +x /etc/letsencrypt/renewal-hooks/post/ols-ssl-sync.sh

Cron ile Zamanlanmış Yedek Senkronizasyon

inotifywait ile gerçek zamanlı izleme yapıyor olsanız bile, bir yedek mekanizma olarak cron ile periyodik senkronizasyon çalıştırmak iyi bir pratiktir. Bu, bir şekilde kaçırılan değişiklikleri yakalar.

# crontab -e ile ekleyin
# Her 15 dakikada bir yapılandırma senkronizasyonu
*/15 * * * * /usr/local/bin/ols-sync.sh >> /var/log/ols-sync-cron.log 2>&1

# Her gece 02:00'de SSL senkronizasyonu
0 2 * * * /usr/local/bin/ssl-sync.sh >> /var/log/ssl-sync-cron.log 2>&1

Senkronizasyon Öncesi ve Sonrası Doğrulama

Yapılandırma dosyaları senkronize edildi, peki doğru mu aktarıldı? Bunu kontrol etmek için bir doğrulama scripti yazalım:

#!/bin/bash
# /usr/local/bin/ols-verify.sh

SSH_KEY="/root/.ssh/ols_sync_key"
SLAVES=("192.168.1.11" "192.168.1.12")
CONF_DIR="/usr/local/lsws/conf/"
FAILED=0

echo "=== OLS Yapılandırma Doğrulama ==="
echo ""

for slave in "${SLAVES[@]}"; do
    echo "Kontrol ediliyor: $slave"

    # MD5 karşılaştırması
    MASTER_MD5=$(find "$CONF_DIR" -type f -name "*.conf" | 
        sort | xargs md5sum 2>/dev/null | md5sum | awk '{print $1}')

    SLAVE_MD5=$(ssh -i "$SSH_KEY" root@"$slave" 
        "find $CONF_DIR -type f -name '*.conf' | sort | xargs md5sum 2>/dev/null | md5sum | awk '{print $1}'" 2>/dev/null)

    if [ "$MASTER_MD5" == "$SLAVE_MD5" ]; then
        echo "  [OK] $slave - Yapilandirma eslesiyor"
    else
        echo "  [HATA] $slave - Yapilandirma UYUSMAZLIGI tespit edildi!"
        FAILED=1
    fi

    # OLS servisinin çalışıp çalışmadığını kontrol et
    OLS_STATUS=$(ssh -i "$SSH_KEY" root@"$slave" 
        "systemctl is-active lsws 2>/dev/null || echo 'inactive'" 2>/dev/null)

    if [ "$OLS_STATUS" == "active" ]; then
        echo "  [OK] $slave - OLS servisi calisiyor"
    else
        echo "  [UYARI] $slave - OLS servisi durumu: $OLS_STATUS"
    fi

    echo ""
done

if [ "$FAILED" -eq 1 ]; then
    echo "SONUC: Bazi sunucularda uyusmazlik tespit edildi!"
    exit 1
else
    echo "SONUC: Tum sunucular senkronize durumda."
    exit 0
fi

Bu scripti da cron’a ekleyin, fark varsa size e-posta göndersin:

# Her saat başı doğrulama yap, hata varsa mail at
0 * * * * /usr/local/bin/ols-verify.sh || mail -s "OLS SYNC HATASI" [email protected] < /dev/null

Ansible ile Kurumsal Ölçekte Senkronizasyon

Daha büyük ortamlarda, örneğin 10+ sunucuyu yönetiyorsanız, rsync scriptleri yetersiz kalabilir. Ansible bu noktada devreye giriyor.

# Basit bir OLS sync playbook
cat > /etc/ansible/playbooks/ols-sync.yml << 'EOF'
---
- name: OpenLiteSpeed Yapılandırma Senkronizasyonu
  hosts: web_slaves
  become: yes

  tasks:
    - name: OLS yapılandırma dizinini senkronize et
      synchronize:
        src: /usr/local/lsws/conf/
        dest: /usr/local/lsws/conf/
        delete: yes
        recursive: yes
        rsync_opts:
          - "--exclude=*.lock"
          - "--exclude=*.pid"
      delegate_to: web01

    - name: SSL sertifikalarını senkronize et
      synchronize:
        src: /etc/letsencrypt/
        dest: /etc/letsencrypt/
        delete: yes
        recursive: yes
      delegate_to: web01

    - name: OLS graceful restart yap
      command: kill -USR1 "{{ lookup('file', '/tmp/lshttpd.pid') }}"
      ignore_errors: yes

    - name: OLS servisini yeniden başlat (graceful başarısız olursa)
      service:
        name: lsws
        state: restarted
      when: ansible_service_mgr == "systemd"
EOF

Ansible inventory dosyanız şöyle görünmeli:

cat > /etc/ansible/hosts << 'EOF'
[web_master]
web01 ansible_host=192.168.1.10

[web_slaves]
web02 ansible_host=192.168.1.11
web03 ansible_host=192.168.1.12

[web_all:children]
web_master
web_slaves
EOF

Playbook’u çalıştırmak için:

ansible-playbook /etc/ansible/playbooks/ols-sync.yml

Yapılandırma Kilitleme ve Çakışma Yönetimi

Birden fazla kişi aynı yapılandırma dosyalarını düzenliyorsa çakışmalar kaçınılmaz. Bunu önlemek için basit bir kilitleme mekanizması kurabilirsiniz.

#!/bin/bash
# /usr/local/bin/ols-edit.sh
# Güvenli düzenleme için wrapper script

LOCK_FILE="/tmp/ols-conf.lock"
LOCK_TIMEOUT=300  # 5 dakika
EDITOR="${EDITOR:-nano}"

check_lock() {
    if [ -f "$LOCK_FILE" ]; then
        LOCK_PID=$(cat "$LOCK_FILE" | head -1)
        LOCK_USER=$(cat "$LOCK_FILE" | tail -1)
        LOCK_TIME=$(stat -c %Y "$LOCK_FILE")
        CURRENT_TIME=$(date +%s)
        DIFF=$((CURRENT_TIME - LOCK_TIME))

        if [ "$DIFF" -lt "$LOCK_TIMEOUT" ]; then
            echo "HATA: Yapılandırma dosyalari $LOCK_USER tarafindan duzenleniyor."
            echo "Kilit $((LOCK_TIMEOUT - DIFF)) saniye sonra otomatik kalkar."
            exit 1
        else
            echo "Suresi dolmus kilit temizleniyor..."
            rm -f "$LOCK_FILE"
        fi
    fi
}

create_lock() {
    echo "$$" > "$LOCK_FILE"
    echo "$(whoami)@$(hostname)" >> "$LOCK_FILE"
}

release_lock() {
    rm -f "$LOCK_FILE"
    echo "Kilit kaldirildi."
}

check_lock
create_lock
trap release_lock EXIT

echo "OLS yapilandirma duzenleme modu aktif."
echo "Ciktiginizda otomatik senkronizasyon baslayacak."
echo ""

$EDITOR "$@"

echo "Degisiklikler senkronize ediliyor..."
/usr/local/bin/ols-sync.sh

Izleme ve Alarm Kurulumu

Senkronizasyonun çalışıp çalışmadığını sürekli elle kontrol edemezsiniz. Basit bir izleme scripti kurun:

#!/bin/bash
# /usr/local/bin/ols-health-check.sh

SSH_KEY="/root/.ssh/ols_sync_key"
SLAVES=("192.168.1.11" "192.168.1.12")
ALERT_EMAIL="[email protected]"
ISSUES=()

for slave in "${SLAVES[@]}"; do
    # OLS servis durumunu kontrol et
    STATUS=$(ssh -i "$SSH_KEY" -o ConnectTimeout=5 root@"$slave" 
        "systemctl is-active lsws" 2>/dev/null)

    if [ "$STATUS" != "active" ]; then
        ISSUES+=("$slave: OLS servisi calısmiyor ($STATUS)")
    fi

    # HTTP yanıt kontrolü
    HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" 
        --connect-timeout 5 --max-time 10 
        -H "Host: health.sirket.com" 
        "http://$slave/health-check" 2>/dev/null)

    if [ "$HTTP_CODE" != "200" ]; then
        ISSUES+=("$slave: HTTP yaniti $HTTP_CODE")
    fi
done

if [ ${#ISSUES[@]} -gt 0 ]; then
    BODY="OLS Health Check Alarmi:nn"
    for issue in "${ISSUES[@]}"; do
        BODY+="- $issuen"
    done
    echo -e "$BODY" | mail -s "[ALARM] OLS Cluster Sorunu" "$ALERT_EMAIL"
fi

Sonuç

OpenLiteSpeed ile çoklu sunucu senkronizasyonu, doğru araçları ve süreçleri kurduğunuzda tahmin ettiğinizden çok daha az zahmetli hale geliyor. Küçük ortamlar için inotifywait ve rsync kombinasyonu oldukça sağlam bir çözüm sunarken, büyük ölçekli ortamlarda Ansible gibi araçlar hayatınızı ciddi ölçüde kolaylaştırıyor.

Kurduğunuz senkronizasyon altyapısında dikkat etmeniz gereken birkaç kritik nokta var. Her senkronizasyon öncesinde yapılandırmanın geçerli olduğunu doğrulayın, bir sözdizim hatası tüm cluster’ı çökertebilir. SSL sertifikalarını asla unutmayın, yapılandırma dosyaları tam uyuşsa bile eski sertifika yüzünden site erişilemez hale gelebilir. Git ile versiyonlama yapın, kötü bir değişikliği saniyeler içinde geri alabilmek paha biçilmez bir özelliktir. Son olarak, senkronizasyon scriptlerinizi de düzenli olarak test edin, acil bir durumda çalışmayan bir script işe yaramaz.

Bu yazıda anlattığım yöntemleri production ortamınıza kopyalamadan önce mutlaka test ortamında deneyin. Her yapının kendine özgü gereksinimleri olduğunu aklınızda bulundurun ve scriptleri ihtiyaçlarınıza göre uyarlayın.

Bir yanıt yazın

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