Akıllı Tahtalarda Otomatik Yazılım Güncelleme ve Takip Sistemi

Pardus ETAP sistem yöneticisi olarak, onlarca tahtaya (istemciye) tek tek USB takıp çıkarmak oldukça yorucu olur. Oluşturduğunuz bu .deb paketini ağ üzerinden dağıtmanın iki temel yolu vardır: "İtme" (Push) yöntemi ve "Çekme" (Pull - Depo) yöntemi.

Sizin daha önce SSH ve script yazma (Bash/Python) konusundaki tecrübelerinize dayanarak, en hızlı sonuç alacağınız SSH ile Toplu Dağıtım (Push) yöntemini ve daha profesyonel olan Basit Yerel Depo yöntemini anlatacağım.

Yöntem 1: SSH ve SCP ile Toplu Dağıtım (En Hızlı Yöntem)

Bu yöntem, paketi zorla tahtalara gönderip kurdurur. Daha önce yazdığınız yönetim scriptlerine benzer bir mantıkla çalışır.

Gereksinim:

Tahtaların IP adreslerinin olduğu bir liste (ip_listesi.txt).
Tahtalarda SSH servisinin açık olması.
sshpass aracı (Parola girmemek için). Pardus'ta yoksa: sudo apt install sshpass

Adım Adım Script:

Aşağıdaki scripti dagitim.sh olarak kaydedin ve düzenleyin:

Bash:
#!/bin/bash

# DEĞİŞKENLERİ DÜZENLEYİN
PAKET_ADI="dersplanlayici-1.0_amd64.deb"
KULLANICI="etapadmin"     # Tahtadaki yetkili kullanıcı adı
SIFRE="1"                 # Tahtaların ortak şifresi (Güvenlik uyarısı: Bunu scriptte tutmak risklidir, test içindir)
IP_LISTESI="ip_listesi.txt"

# Dosya kontrolü
if [ ! -f "$PAKET_ADI" ]; then
    echo "Hata: $PAKET_ADI dosyası bulunamadı!"
    exit 1
fi

echo "Dağıtım başlıyor: $PAKET_ADI"
echo "------------------------------------------------"

# IP Listesini oku ve döngüye sok
while IFS= read -r IP
do
    echo "[$IP] İşleniyor..."

    # 1. Adım: Dosyayı tahtaya kopyala (SCP)
    sshpass -p "$SIFRE" scp -o StrictHostKeyChecking=no "$PAKET_ADI" $KULLANICI@$IP:/tmp/
    
    if [ $? -eq 0 ]; then
        echo "   -> Dosya kopyalandı."
        
        # 2. Adım: Uzaktan kurulum komutunu çalıştır (SSH)
        # apt install ./dosya.deb komutu bağımlılıkları da çözer
        sshpass -p "$SIFRE" ssh -o StrictHostKeyChecking=no $KULLANICI@$IP "echo '$SIFRE' | sudo -S apt install /tmp/$PAKET_ADI -y"
        
        if [ $? -eq 0 ]; then
             echo "   -> KURULUM BAŞARILI!"
             # Temizlik (İsteğe bağlı)
             sshpass -p "$SIFRE" ssh $KULLANICI@$IP "rm /tmp/$PAKET_ADI"
        else
             echo "   -> HATA: Kurulum başarısız oldu."
        fi
    else
        echo "   -> HATA: Dosya kopyalanamadı (Bağlantı yok mu?)."
    fi
    echo "------------------------------------------------"

done < "$IP_LISTESI"

Kullanımı:

Scripti ve .deb dosyasını aynı klasöre koyun.
ip_listesi.txt içine tahtaların IP'lerini alt alta yazın.
chmod +x dagitim.sh ile yetki verin.
./dagitim.sh komutuyla arkanıza yaslanın.

Yöntem 2: Basit HTTP Deposu Oluşturma (Daha Profesyonel)

Eğer programınızı sık sık güncelleyecekseniz (v1.1, v1.2...), her seferinde dosya kopyalamak yerine tahtaların "güncellemeleri denetle" dediğinde otomatik almasını sağlamak daha mantıklıdır.

Bunun için kendi bilgisayarınızı geçici bir "Pardus Deposu"na dönüştürebilirsiniz.

1. Depo Klasörünü Hazırlama:

Bash:
mkdir -p ~/Masaustu/pardus-depo
cp dersplanlayici-1.0_amd64.deb ~/Masaustu/pardus-depo/
cd ~/Masaustu/pardus-depo

2. Depo İndeksini Oluşturma:

dpkg-dev paketine ihtiyacınız var (sudo apt install dpkg-dev).

Bash:
# Klasördeki paketleri tara ve Packages.gz oluştur
dpkg-scanpackages . /dev/null | gzip -9c > Packages.gz

3. Sunucuyu Başlatma (Python ile):

Anlık olarak klasörü ağa açmak için Python'un built-in sunucusunu kullanın:

Bash:
# 8000 portundan yayın yap
python3 -m http.server 8000

Artık http://SİZİN_IP_ADRESİNİZ:8000 adresinde dosyanız yayında.

4. İstemci (Tahta) Tarafında Yapılması Gereken:

Bunu bir kereliğine SSH scripti (Yöntem 1'deki gibi) ile yapabilirsiniz. Tahtanın /etc/apt/sources.list dosyasına veya /etc/apt/sources.list.d/yerel.list dosyasına şu satırı eklemeniz gerekir:

Bash:
deb [trusted=yes] http://SİZİN_IP_ADRESİNİZ:8000/ ./

Artık tahtalarda tek yapmanız gereken:

Bash:
sudo apt update && sudo apt install dersplanlayici

Siz yeni sürüm (v1.1) çıkarıp Packages.gz'yi güncellediğinizde, tahtalar apt upgrade komutuyla otomatik olarak yeni sürüme geçecektir.

Hangi Yöntem Sizin İçin Uygun?

Özellik	SSH (Push)	HTTP Depo (Pull)
Kurulum Hızı	Anında zorla kurar.	İstemcinin güncelleme yapmasını bekler.
Tekrar Kullanım	Her seferinde script çalıştırılır.	Bir kere ayarlanır, sonra otomatiktir.
Uygunluk	Tek seferlik kurulumlar için.	Sürekli geliştirilen projeler için.

Sizin durumunuzda (Sınıf Asistanı, Kilit Paneli gibi projeler geliştirdiğinizi bildiğimden), Yöntem 1 (SSH Script) şu an için en pratik çözüm olacaktır. Ancak projeleriniz olgunlaştığında kendi okul içi deponuzu (Yöntem 2) kurmak size büyük zaman kazandırır.

Harika bir karar. Okulunuzdaki Pardus sunucusu üzerinde (daha önce apt-cacher-ng kurduğunuz sunucu olabilir) kalıcı bir "Yerel Pardus Deposu" (Local Repository) kurmak, sistem yöneticiliğinde bir üst seviyeye geçmek demektir.

Bu yapıyı kurduğunuzda:

Python komutunu sürekli çalıştırmak zorunda kalmayacaksınız (Apache/Nginx bu işi yapacak).
Yeni bir .deb paketi ürettiğinizde tek bir komutla depoya atıp indeksleyeceksiniz.
Tüm tahtalar otomatik olarak bu güncellemeyi görecek.

İşte adım adım kalıcı depo kurulum rehberi:

Adım 1: Web Sunucusunu Hazırlama (Apache)

Sunucunuzda dosyaları yayınlamak için sağlam bir web sunucusuna ihtiyacımız var. apt-cacher-ng zaten 3142 portunu kullanıyor, biz standart 80 portunu kullanacağız.

Apache'yi kurun:

Bash:
sudo apt update
sudo apt install apache2 dpkg-dev

Depo klasörünü oluşturun:
Apache'nin varsayılan yayın klasörü /var/www/html altındadır.
Bash:
sudo mkdir -p /var/www/html/pardus-depo
Yazma İzni Verin:
Bu klasöre rahatça dosya atabilmek için sahipliğini kendi kullanıcınıza (örneğin etapadmin veya sizin kullanıcınız) verin.
Bash:
# $USER, o anki kullanıcınızı temsil eder sudo chown -R $USER:$USER /var/www/html/pardus-depo

Adım 2: Depo Yönetim Scripti (Otomasyon)

Her paket eklediğinizde dpkg-scanpackages komutunu elle yazmak zahmetlidir. Bunu otomatize eden bir Bash scripti yazalım. Bu script, yeni .deb paketini alacak, doğru yere koyacak ve listeyi güncelleyecektir.

depo-yonet.sh adında bir dosya oluşturun:
Bash:
nano ~/depo-yonet.sh

İçine şu kodları yapıştırın:

Bash:
#!/bin/bash

# AYARLAR
DEPO_YOLU="/var/www/html/pardus-depo"

# Parametre kontrolü
if [ -z "$1" ]; then
    echo "Kullanım: ./depo-yonet.sh [PAKET_ADI.deb]"
    echo "Örnek: ./depo-yonet.sh dersplanlayici-1.0_amd64.deb"
    exit 1
fi

# 1. Dosyayı depo klasörüne kopyala
echo "-> Paket kopyalanıyor..."
cp "$1" "$DEPO_YOLU/"

# 2. İndeks dosyasını (Packages.gz) yeniden oluştur
echo "-> İndeks güncelleniyor..."
cd "$DEPO_YOLU"
# /dev/null hatasını önlemek için multiversion desteği
dpkg-scanpackages . /dev/null | gzip -9c > Packages.gz

echo "-> TAMAMLANDI! Paket yayında."
echo "-> İstemciler 'sudo apt update' ile paketi görebilir."

Scripte çalıştırma izni verin:
Bash:
chmod +x ~/depo-yonet.sh

Adım 3: Kullanım Senaryosu (Paket Ekleme)

Artık yeni bir uygulama yazdınız veya DersPlanlayici uygulamasını güncellediniz (v1.1). Tek yapmanız gereken:

Bash:
./depo-yonet.sh dersplanlayici-1.1_amd64.deb

Bu komut dosyayı sunucuya kopyalar ve Packages.gz dosyasını yeniler.

Adım 4: İstemci (Tahta) Ayarları

Tahtaların bu sunucuyu tanıması için bir kez ayar yapmanız gerekir. Bunu daha önce hazırladığımız SSH scripti ile tüm tahtalara "Push" edebilirsiniz.

Tahtadaki /etc/apt/sources.list.d/okul-depo.list dosyasına şu satırı eklemelisiniz:

Bash:
# SUNUCU_IP yerine okul sunucunuzun sabit IP'sini yazın (örn: 192.168.1.10)
deb [trusted=yes] http://SUNUCU_IP/pardus-depo ./

Not: [trusted=yes] parametresi önemlidir. Kendi imzaladığımız (GPG key) bir yapı kurmadığımız için apt'nin "Bu depo güvensiz olabilir" uyarısını engeller. Okul içi ağda bu yöntem güvenli ve pratiktir.

Adım 5: `apt-cacher-ng` ile İlişkisi

Daha önce kurduğunuz apt-cacher-ng (Önbellek Sunucusu) ile bu yeni kurduğumuz Apache Depo Sunucusu farklı şeylerdir ama birlikte çalışabilirler.

Apache Depo: Sizin kendi ürettiğiniz özel paketlerin kaynağıdır.
apt-cacher-ng: Pardus'un resmi depolarından indirilen dosyaları saklar.

İpucu: Eğer tahtalarınızın sources.list dosyasında zaten apt-cacher-ng ayarlıysa, bu yeni yerel deponuzu apt-cacher-ng üzerinden geçirmenize gerek yoktur; doğrudan Apache'ye (Port 80) bağlanmaları en temiz yöntemdir.

Özet İş Akışı

Bilgisayarınızda uygulamanızı geliştirin (Flutter/Python).
.deb paketinizi oluşturun (dpkg-deb --build).
Sunucudaki scripte verin: ./depo-yonet.sh paketim.deb.
Tahtalar açıldığında (veya otomatik görevle) apt update && apt upgrade yaptığında uygulamanız sessizce güncellenir.

Okul ortamında tahtalar sürekli kullanımda olduğu için güncellemelerin dersi bölmemesi, ancak sistemin de güncel kalması gerekir.

Bunun için en sağlam ve yönetilebilir yöntem, güncelleme işlemini yapan bir Script hazırlamak ve bu scripti Cron (Zamanlayıcı) ile belirli saatlerde (örneğin öğle arası ve okul çıkışı) çalıştırmaktır.

İşte tahtalarınızın siz kahvenizi içerken kendi kendini güncellemesini sağlayacak sistem:

Adım 1: Güncelleme Scriptini Hazırlama

Öncelikle tahtada çalışacak, ne yaptığını kaydeden (log tutan) güvenli bir script hazırlayalım. Bu scripti bilgisayarınızda oluşturun.

Dosya adı: okul-guncelle.sh

Bash:
#!/bin/bash

# Log dosyasının yeri (Sorun olursa buraya bakarsınız)
LOG_DOSYASI="/var/log/okul-guncelleme.log"

echo "------------------------------------------------" >> $LOG_DOSYASI
echo "Başlangıç: $(date)" >> $LOG_DOSYASI

# 1. Paket listesini sessizce güncelle
# -q: Quiet (Sessiz), hatasız çıktı üretir
apt-get update -q >> $LOG_DOSYASI 2>&1

# 2. SADECE sizin programınızı güncelleyin (En Güvenli Yöntem)
# --only-upgrade: Sadece kuruluysa günceller, kurulu değilse kurmaz.
# Bu sayede tahtanın diğer sistem ayarlarını bozma riskiniz olmaz.
apt-get install --only-upgrade dersplanlayici -y >> $LOG_DOSYASI 2>&1

# EĞER tüm sistemi güncellemek isterseniz üstteki satırı silip şunu açın:
# apt-get upgrade -y >> $LOG_DOSYASI 2>&1

echo "Bitiş: $(date)" >> $LOG_DOSYASI
echo "------------------------------------------------" >> $LOG_DOSYASI

Adım 2: Zamanlayıcı Dosyasını Hazırlama (Cron)

Linux'ta /etc/cron.d/ klasörüne atılan dosyalar otomatik olarak zamanlanmış görev olarak çalışır.

Dosya adı: okul-cron

Bash:
# Yapı: Dakika Saat Gün Ay HaftanınGünü Kullanıcı Komut
# Örnek: Hafta içi (1-5) her gün 12:30'da (Öğle Arası) çalışsın
30 12 * * 1-5 root /bin/bash /usr/local/bin/okul-guncelle.sh

# Örnek: Hafta içi her gün 17:15'te (Okul Çıkışı) çalışsın
15 17 * * 1-5 root /bin/bash /usr/local/bin/okul-guncelle.sh

Adım 3: Script ve Cron Dosyasını Tahtalara Dağıtma

Şimdi elinizde iki dosya var: okul-guncelle.sh ve okul-cron. Bunları daha önce hazırladığımız SSH Dağıtım Scripti (Push Yöntemi) ile tüm tahtalara tek seferde göndereceğiz.

Dağıtım scriptinizi (dagitim.sh) şu şekilde revize edin:

Bash:
#!/bin/bash
# ... (IP okuma döngüsü başlangıcı aynı) ...

    echo "[$IP] Dosyalar gönderiliyor..."
    
    # 1. Dosyaları geçici dizine at
    sshpass -p "$SIFRE" scp okul-guncelle.sh okul-cron $KULLANICI@$IP:/tmp/
    
    # 2. Dosyaları yerlerine yerleştir ve yetki ver
    sshpass -p "$SIFRE" ssh $KULLANICI@$IP "echo '$SIFRE' | sudo -S bash -c '
        # Scripti /usr/local/bin içine taşı ve çalıştırılabilir yap
        mv /tmp/okul-guncelle.sh /usr/local/bin/okul-guncelle.sh
        chmod +x /usr/local/bin/okul-guncelle.sh
        
        # Cron dosyasını /etc/cron.d içine taşı (root sahipliğinde olmalı)
        mv /tmp/okul-cron /etc/cron.d/okul-cron
        chown root:root /etc/cron.d/okul-cron
        chmod 644 /etc/cron.d/okul-cron
        
        # Cron servisini yeniden tetikle (Genelde gerekmez ama garanti olsun)
        systemctl restart cron
    '"

# ... (Döngü bitişi) ...

Sonuç: Otomatik Pilot

Bu işlemi bir kez yaptığınızda sistem şöyle işleyecek:

Siz DersPlanlayici v1.2 versiyonunu kodladınız.
.deb paketini oluşturdunuz.
Sunucunuzdaki ./depo-yonet.sh komutuyla paketi yayınladınız.
Otomatik: Tahtalar saat 12:30 olduğunda sessizce sunucuya bakacak, yeni versiyonu görecek ve kendini güncelleyecektir.
Öğretmenler öğleden sonraki derse geldiklerinde programın yeni özelliklerini (veya yeni ikonunu) hazır bulacaklar.

Önemli İpucu: Eğer güncellemelerin yapılıp yapılmadığını kontrol etmek isterseniz, herhangi bir tahtaya bağlanıp cat /var/log/okul-guncelleme.log komutuyla o günkü işlem raporunu okuyabilirsiniz.

Bu seri ile; Manuel Kurulum > Paketleme (.deb) > Ağ Deposu Kurma > Otomatik Güncelleme süreçlerinin tamamını tamamladık. Pardus ETAP sisteminiz artık profesyonel bir DevOps döngüsüne sahip oldu!

Bu harika bir "Sistem Yöneticisi" projesine dönüşüyor! Logları dosyadan okumak yerine, her tahtanın işi bitince sunucuya "Ben güncellemeyi bitirdim, durumum bu!" diye haber vermesini sağlayacağız.

Bunun için modern ve çok hafif bir Web Dashboard hazırlayacağız.

Mimarimiz şu olacak:

Sunucu: Python (Flask) ile çalışan basit bir web sitesi. Gelen raporları kaydeder ve tablo halinde gösterir.
İstemci (Tahta): Güncelleme scripti (okul-guncelle.sh) işi bitince sunucuya gizli bir HTTP isteği (ping) atar.

Adım 1: Sunucu Tarafı (Rapor Toplayıcı)

Öncelikle sunucunuzda (depo sunucusu olarak kullandığınız makinede) Flask kütüphanesini kuralım. Bu, web sunucusu yapmamızı sağlar.

Bash:
sudo apt install python3-flask

Şimdi takip_sistemi.py adında bir dosya oluşturun ve şu kodları yapıştırın:

Python:
from flask import Flask, request, render_template_string
import json
from datetime import datetime
import os

app = Flask(__name__)
VERI_DOSYASI = 'tahta_durumlari.json'

# Verileri yükle veya boş başlat
def veri_yukle():
    if os.path.exists(VERI_DOSYASI):
        with open(VERI_DOSYASI, 'r') as f:
            return json.load(f)
    return {}

# Verileri kaydet
def veri_kaydet(data):
    with open(VERI_DOSYASI, 'w') as f:
        json.dump(data, f)

# HTML Şablonu (Basit Dashboard Tasarımı)
HTML_TEMPLATE = """
<!DOCTYPE html>
<html>
<head>
    <title>Pardus ETAP Takip Paneli</title>
    <meta http-equiv="refresh" content="30"> <style>
        body { font-family: sans-serif; padding: 20px; background: #f0f0f0; }
        h1 { color: #333; }
        table { width: 100%; border-collapse: collapse; background: white; box-shadow: 0 0 10px rgba(0,0,0,0.1); }
        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }
        th { background-color: #007bff; color: white; }
        tr:hover { background-color: #f5f5f5; }
        .basarili { color: green; font-weight: bold; }
        .hatali { color: red; font-weight: bold; }
    </style>
</head>
<body>
    <h1>🏫 ETAP Güncelleme Durum Paneli</h1>
    <table>
        <thead>
            <tr>
                <th>Tahta Adı (Hostname)</th>
                <th>IP Adresi</th>
                <th>Son İşlem Zamanı</th>
                <th>Durum</th>
            </tr>
        </thead>
        <tbody>
            {% for tahta_id, bilgi in veriler.items() %}
            <tr>
                <td>{{ tahta_id }}</td>
                <td>{{ bilgi.ip }}</td>
                <td>{{ bilgi.zaman }}</td>
                <td class="{{ 'basarili' if bilgi.durum == 'BAŞARILI' else 'hatali' }}">
                    {{ bilgi.durum }}
                </td>
            </tr>
            {% endfor %}
        </tbody>
    </table>
</body>
</html>
"""

# 1. Sayfa Görüntüleme (Dashboard)
@app.route('/')
def ana_sayfa():
    veriler = veri_yukle()
    # Verileri tarihe göre sırala (en yeni en üstte)
    return render_template_string(HTML_TEMPLATE, veriler=veriler)

# 2. Rapor Alma Endpoint'i (Tahtaların istek atacağı yer)
@app.route('/bildir')
def bildir():
    ad = request.args.get('ad', 'Bilinmeyen Tahta')
    ip = request.remote_addr
    durum = request.args.get('durum', 'BELIRSIZ')
    
    veriler = veri_yukle()
    veriler[ad] = {
        'ip': ip,
        'durum': durum,
        'zaman': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    }
    veri_kaydet(veriler)
    return "KAYDEDILDI"

if __name__ == '__main__':
    # 5000 portundan yayın yap
    app.run(host='0.0.0.0', port=5000)

Çalıştırmak için:

Bash:
python3 takip_sistemi.py

(Artık tarayıcıdan http://SUNUCU_IP:5000 adresine girerseniz boş bir tablo göreceksiniz.)

Adım 2: İstemci Tarafı (Script Güncellemesi)

Tahtalardaki okul-guncelle.sh dosyasını, işlem bitince sunucuya haber verecek şekilde güncelliyoruz. Bunun için curl komutunu kullanacağız.

Mevcut scriptinizin en altına şu satırları eklemeniz yeterli:

Bash:
# ... (Üst kısımdaki apt işlemleri bittikten sonra) ...

# $? komutu bir önceki işlemin başarı durumunu verir (0 = Başarılı, Diğerleri = Hata)
if [ $? -eq 0 ]; then
    DURUM="BAŞARILI"
else
    DURUM="HATALI"
fi

# Tahtanın adını al (Hostname genelde Tahta-01 gibidir)
TAHTA_ADI=$(hostname)
SUNUCU_IP="192.168.1.10" # BURAYA KENDİ SUNUCU IP'NİZİ YAZIN

# Sunucuya sessizce haber uçur
curl -s "http://$SUNUCU_IP:5000/bildir?ad=$TAHTA_ADI&durum=$DURUM" > /dev/null

Nasıl Çalışır?

Zamanlayıcı (Cron) tetiklenir, okul-guncelle.sh çalışır.
Script güncellemeyi yapar.
Scriptin sonundaki curl komutu sunucuya şöyle bir link açar:
http://192.168.1.10:5000/bildir?ad=Sinif-9A&durum=BAŞARILI
Python sunucusu bunu yakalar, JSON dosyasına kaydeder.
Siz odanızda http://192.168.1.10:5000 adresini açtığınızda şöyle bir ekran görürsünüz:

Tahta Adı	IP Adresi	Son İşlem Zamanı	Durum
Sinif-9A	192.168.1.45	2024-01-22 12:31:05	BAŞARILI
Lab-Bilgisayar-3	192.168.1.52	2024-01-22 12:31:10	HATALI

Bu sistem sayesinde hangi sınıfta güncellemenin başarısız olduğunu veya hangi tahtanın kapalı olduğu için güncelleme almadığını (listede tarihi eski kalacaktır) anında tespit edebilirsiniz.

Harika bir profesyonellik adımı. Bir Python scriptini terminal açık kalsın diye bekletmek yerine, onu işletim sisteminin (Systemd) yönettiği bir "Servis" haline getirmek en doğrusudur.

Böylece sunucu yeniden başlasa bile takip ekranınız otomatik olarak açılacak ve bir hata durumunda kendini yeniden başlatacaktır.

İşte takip_sistemi.py dosyasını kalıcı bir Linux servisine dönüştürme rehberi:

Adım 1: Servis Dosyasını Oluşturma

Sistem servisleri /etc/systemd/system/ altında tutulur. etap-takip adında yeni bir servis dosyası oluşturalım.

Bash:
sudo nano /etc/systemd/system/etap-takip.service

Adım 2: Servis Tanımı

Aşağıdaki kodları açılan dosyaya yapıştırın.

ÖNEMLİ: User ve WorkingDirectory kısımlarını kendi kullanıcı adınıza ve dosyanın olduğu yere göre düzenlemeyi unutmayın.

Ini, TOML
[Unit]
Description=Pardus ETAP Takip Paneli Servisi
After=network.target

[Service]
# Scripti hangi kullanıcı çalıştırsın? (Kendi kullanıcı adınızı yazın)
User=etapadmin
# Scriptin bulunduğu klasör (dosyalar buraya kaydedilecek)
WorkingDirectory=/home/etapadmin/Masaustu
# Çalıştırılacak komut (Python3 ve dosya yolu)
ExecStart=/usr/bin/python3 /home/etapadmin/Masaustu/takip_sistemi.py
# Hata verip kapanırsa otomatik yeniden başlat
Restart=always
# Çökme durumunda kaç saniye sonra başlasın
RestartSec=10

[Install]
WantedBy=multi-user.target

(Düzenledikten sonra CTRL + O ile kaydedip, CTRL + X ile çıkın.)

Adım 3: Servisi Aktif Etme

Dosyayı oluşturduk ama Systemd'in bundan haberi yok. Sırasıyla şu komutları verin:

Systemd'i Yenile (Yeni dosyayı görsün):
Bash:
sudo systemctl daemon-reload
Servisi Başlat (Hemen çalışsın):
Bash:
sudo systemctl start etap-takip
Başlangıçta Otomatik Açılmasını Sağla (Enable):
Bash:
sudo systemctl enable etap-takip

Adım 4: Durum Kontrolü

Bakalım sistemimiz sorunsuz çalışıyor mu?

Bash:
sudo systemctl status etap-takip

Eğer her şey yolundaysa, çıktıda yeşil renkli active (running) yazısını göreceksiniz. Artık terminali kapatabilirsiniz; web paneliniz (http://SUNUCU_IP:5000) arka planda sessizce ve sürekli çalışmaya devam edecek.

Tebrikler!

Bu proje serisiyle birlikte tam teşekküllü bir Pardus Sistem Yöneticisi iş akışı kurdunuz:

Paketleme: Uygulamaları .deb paketi haline getirdiniz (/opt yapısı).
Dağıtım (Repo): Okul içi ağda kendi paket deponuzu kurdunuz.
Otomasyon: Tahtaların kendi kendini güncellemesini sağladınız (cron).
İzleme: Hangi tahtanın ne durumda olduğunu gösteren canlı bir Web Paneli (systemd servisi) yazdınız.

Bu yapı, binlerce tahtayı tek bir merkezden yönetmenin temelidir.

Bu Blogda Ara

Bilişim Teknolojileri