Hogyan készítsünk weboldal elérhetőség ellenőrzőt Pythonnal

A mai digitális korban egy weboldal elérhetősége alapvető fontosságú. Legyen szó személyes blogról, e-kereskedelmi platformról vagy vállalati portálról, a leállás nem csupán frusztráló, de komoly bevételkiesést és reputációs károkat is okozhat. Éppen ezért elengedhetetlen egy megbízható rendszer, amely azonnal értesít minket, ha valami nincs rendben. Ebben a cikkben bemutatjuk, hogyan hozhatunk létre egy saját, testreszabott weboldal elérhetőség ellenőrző eszközt Python programozási nyelven, lépésről lépésre.

Miért éppen a Python? Nos, a Python egyszerűsége, hatalmas könyvtár-ökoszisztémája és olvasható szintaxisa ideálissá teszi az ilyen típusú feladatokhoz. Nincsenek bonyolult beállítások, és percek alatt elindíthatjuk első ellenőrző szkriptünket.

Miért fontos a weboldal elérhetőségének ellenőrzése?

Mielőtt belemerülnénk a kódolásba, nézzük meg röviden, miért is érdemes energiát fektetni egy ilyen eszköz elkészítésébe:

Bevételkiesés megelőzése: Az e-kereskedelmi oldalak számára minden perc kiesés közvetlenül anyagi veszteséget jelent.
Ügyfél-elégedettség: A felhasználók elvárják, hogy egy weboldal mindig elérhető legyen. A gyakori leállások elriasztják őket.
SEO rangsorolás: A keresőmotorok, mint a Google, büntetik azokat az oldalakat, amelyek gyakran elérhetetlenek, rontva a keresési rangsorolást.
Problémák azonnali észlelése: Egy automatizált ellenőrző jelzi a problémát, mielőtt a felhasználók tömegei észlelnék.
Teljesítményfigyelés: Nem csak az elérhetőséget, hanem a válaszidőt is mérhetjük, ami kulcsfontosságú a felhasználói élmény szempontjából.

Most, hogy megértettük a fontosságát, vágjunk is bele a megvalósításba!

Az alapok: A ‘requests’ könyvtár és az HTTP kérések

A Python egyik legnépszerűbb és leghasznosabb könyvtára az HTTP kérések kezelésére a requests. Ez a könyvtár egyszerűvé teszi a weboldalak elérését és a válaszok feldolgozását. Ha még nincs telepítve, az alábbi paranccsal tehetjük meg:

pip install requests

Első lépés: Egyetlen URL ellenőrzése

Kezdjük egy egyszerű szkripttel, amely megpróbál elérni egy megadott URL-t, és kiírja az eredményt.

import requests

def check_single_url(url):
    """
    Ellenőrzi egyetlen URL elérhetőségét és státuszát.
    """
    try:
        # HTTP GET kérés küldése az URL-re, időtúllépéssel
        # Az időtúllépés megakadályozza, hogy a szkript örökké várjon
        response = requests.get(url, timeout=10) 
        
        # HTTP státuszkód ellenőrzése
        # A 200-as kód jelzi a sikeres választ
        if response.status_code == 200:
            print(f"[{url}] ELÉRHETŐ (Státusz: {response.status_code})")
        else:
            print(f"[{url}] NEM ELÉRHETŐ (Státusz: {response.status_code})")
        
    except requests.exceptions.ConnectionError:
        print(f"[{url}] ELÉRHETETLEN (Hálózati hiba vagy a szerver nem válaszol)")
    except requests.exceptions.Timeout:
        print(f"[{url}] IDŐTÚLLÉPÉS (A szerver túl sokáig nem válaszolt)")
    except requests.exceptions.RequestException as e:
        print(f"[{url}] Hiba történt: {e}")

if __name__ == "__main__":
    test_urls = [
        "https://www.google.com",
        "https://www.youtube.com",
        "https://nonexistent-website-12345.com", # Példa nem létező domainre
        "http://localhost:9999" # Példa csatlakozási hibára (ha nincs helyi szerver)
    ]
    
    print("Egyedi URL ellenőrzés:")
    for url in test_urls:
        check_single_url(url)

Magyarázat:

import requests: Importáljuk a requests könyvtárat.
requests.get(url, timeout=10): GET kérést küldünk a megadott URL-re. A timeout=10 paraméter azt jelenti, hogy legfeljebb 10 másodpercet várunk a válaszra. Ha ennyi idő alatt nem érkezik válasz, requests.exceptions.Timeout hiba dobódik. Az időtúllépés beállítása kritikus a hatékony ellenőrzőhöz.
response.status_code: Ez az attribútum tartalmazza a szerver által visszaadott HTTP állapotkódot. A 200 OK jelenti a sikeres lekérdezést. Egyéb gyakori kódok pl. 404 Not Found, 500 Internal Server Error.
try-except blokk: Ez elengedhetetlen a robusztusság érdekében. Kezeljük a lehetséges hibákat, mint például a hálózati problémák (ConnectionError) vagy az időtúllépés (Timeout).

Több URL ellenőrzése és fájl alapú bemenet

A legtöbb esetben nem csak egy, hanem több weboldal elérhetőségét szeretnénk ellenőrizni. Ezt a legpraktikusabb egy listából vagy egy szöveges fájlból beolvasni.

URL-ek olvasása fájlból

Hozzon létre egy urls.txt nevű fájlt, és írja bele az ellenőrizni kívánt URL-eket, minden URL-t új sorba:

https://www.google.com
https://www.microsoft.com
https://hvg.hu
https://www.not-a-real-website.org

Ezután módosíthatjuk a szkriptünket, hogy ezt a fájlt olvassa be:

import requests
import datetime
import time # A válaszidő méréséhez

def check_url_status(url):
    """
    Ellenőrzi egy URL elérhetőségét, válaszidőt mér, és státuszüzenetet ad vissza.
    """
    status_message = ""
    is_available = False
    response_time = "N/A"
    
    try:
        start_time = time.time()
        response = requests.get(url, timeout=15) # Megnövelt időtúllépés
        end_time = time.time()
        response_time = f"{(end_time - start_time):.2f} mp" # Válaszidő másodpercben

        if response.status_code == 200:
            status_message = f"ELÉRHETŐ (Státusz: {response.status_code})"
            is_available = True
        else:
            status_message = f"NEM ELÉRHETŐ (Státusz: {response.status_code})"
    except requests.exceptions.ConnectionError:
        status_message = "ELÉRHETETLEN (Hálózati hiba vagy a szerver nem válaszol)"
    except requests.exceptions.Timeout:
        status_message = "IDŐTÚLLÉPÉS (A szerver túl sokáig nem válaszolt)"
    except requests.exceptions.RequestException as e:
        status_message = f"ÁLTALÁNOS HIBA: {e}"
    
    return is_available, status_message, response_time

def check_urls_from_file(filepath):
    """
    Beolvassa az URL-eket egy fájlból és ellenőrzi azokat.
    """
    print(f"n[{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] URL-ek ellenőrzése a '{filepath}' fájlból...")
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            urls = [line.strip() for line in f if line.strip()] # Üres sorok kihagyása
        
        if not urls:
            print("Nincsenek URL-ek a fájlban az ellenőrzéshez.")
            return

        for url in urls:
            is_available, status_msg, resp_time = check_url_status(url)
            print(f"[{url}] - {status_msg} (Válaszidő: {resp_time})")

    except FileNotFoundError:
        print(f"HIBA: A '{filepath}' fájl nem található. Kérem ellenőrizze az útvonalat.")
    except Exception as e:
        print(f"HIBA történt a fájl olvasása során: {e}")

if __name__ == "__main__":
    urls_file_path = "urls.txt"
    check_urls_from_file(urls_file_path)
    print("nWeboldal ellenőrzés befejeződött.")

Újdonságok és magyarázatok:

datetime és time: Importáljuk ezeket a modulokat. A datetime a pontos időbélyegekhez, a time pedig a válaszidő méréséhez (time.time()) és a szkript szüneteltetéséhez (time.sleep()) lesz hasznos.
Válaszidő mérése: A start_time = time.time() és end_time = time.time() segítségével mérjük, mennyi ideig tartott a kérés feldolgozása, majd ezt kiírjuk. Ez kulcsfontosságú a teljesítményfigyelés szempontjából.
with open(filepath, 'r', encoding='utf-8') as f:: Biztonságos módja a fájlok megnyitásának és olvasásának. Az encoding='utf-8' segít a különböző karakterkészletek kezelésében.
[line.strip() for line in f if line.strip()]: Ez egy listakifejezés, ami beolvassa a fájl minden sorát, eltávolítja a felesleges szóközöket és új sor karaktereket (.strip()), és csak azokat a sorokat tartja meg, amelyek nem üresek.

Naplózás (Logging) és periodikus ellenőrzés

Egy valós idejű ellenőrző rendszernek nem elég kiírnia az eredményeket a konzolra; naplóznia is kell azokat, és rendszeres időközönként futnia kell. Ez az automatizálás lényege.

Naplózás fájlba

Minden ellenőrzés eredményét elmenthetjük egy CSV (Comma Separated Values) fájlba, ami később könnyen elemezhető például táblázatkezelő programokkal.

Periodikus futtatás

A time.sleep() függvény segítségével megadhatjuk, hogy a szkript mennyi ideig várjon két ellenőrzés között. Ezzel periodikus ellenőrzést valósíthatunk meg.

Most nézzük meg a teljes szkriptet, ami magában foglalja a fenti fejlesztéseket:

import requests
import datetime
import time
import os # Fájl létezésének ellenőrzéséhez

def check_and_log_url_status(url, log_file="website_status_log.csv"):
    """
    Ellenőrzi egy URL elérhetőségét, válaszidőt mér, 
    és naplózza az eredményt egy CSV fájlba.
    """
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    status_message = ""
    is_available = False
    response_time = "N/A"
    http_status_code = "N/A"
    error_details = ""

    try:
        start_time = time.time()
        response = requests.get(url, timeout=15)
        end_time = time.time()
        response_time = f"{(end_time - start_time):.2f} mp"
        http_status_code = response.status_code

        if response.status_code == 200:
            status_message = "ELÉRHETŐ"
            is_available = True
        else:
            status_message = "NEM ELÉRHETŐ"
            error_details = f"HTTP Státusz: {response.status_code}"
    except requests.exceptions.ConnectionError:
        status_message = "ELÉRHETETLEN"
        error_details = "Hálózati hiba vagy a szerver nem válaszol"
    except requests.exceptions.Timeout:
        status_message = "IDŐTÚLLÉPÉS"
        error_details = "A szerver túl sokáig nem válaszolt"
    except requests.exceptions.RequestException as e:
        status_message = "HIBA"
        error_details = f"Általános kérés hiba: {e}"
    
    # Kiírás a konzolra
    print(f"[{timestamp}] {url} - {status_message} (Státusz: {http_status_code}, Válaszidő: {response_time}, Hiba: {error_details if error_details else 'Nincs'})")

    # Naplózás CSV fájlba
    log_entry = f'"{timestamp}","{url}","{status_message}",{is_available},"{http_status_code}","{response_time}","{error_details}"n'
    
    # Fejléc írása, ha a fájl még nem létezik
    if not os.path.exists(log_file):
        with open(log_file, 'w', encoding='utf-8') as f:
            f.write('"Időbélyeg","URL","Státusz","Elérhető","HTTP Státusz Kód","Válaszidő","Hiba Részletek"n')

    with open(log_file, 'a', encoding='utf-8') as f:
        f.write(log_entry)
    
    return is_available, status_message, response_time

def periodic_website_checker(urls_filepath, log_filepath="website_status_log.csv", interval_seconds=300):
    """
    Periodikusan ellenőrzi az URL-eket egy fájlból és naplózza az eredményeket.
    """
    print("A weboldal elérhetőség ellenőrző elindult.")
    print(f"URL-ek a '{urls_filepath}' fájlból, eredmények a '{log_filepath}' fájlba.")
    print(f"Ellenőrzési intervallum: {interval_seconds} másodperc.")

    while True:
        current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"n--- [{current_time}] Új ellenőrzési kör indítása ---")
        try:
            with open(urls_filepath, 'r', encoding='utf-8') as f:
                urls = [line.strip() for line in f if line.strip()]
            
            if not urls:
                print("Figyelmeztetés: Nincsenek URL-ek a fájlban. Várakozás a következő körre.")
                time.sleep(interval_seconds)
                continue

            for url in urls:
                check_and_log_url_status(url, log_filepath)

        except FileNotFoundError:
            print(f"HIBA: A '{urls_filepath}' fájl nem található. Kérem ellenőrizze az útvonalat.")
        except Exception as e:
            print(f"ÁLTALÁNOS HIBA a periodikus ellenőrzés során: {e}")

        print(f"--- [{current_time}] Ellenőrzési kör befejezve. Várakozás {interval_seconds} másodpercet a következő indításig ---")
        time.sleep(interval_seconds)

if __name__ == "__main__":
    urls_source_file = "urls.txt"
    log_output_file = "website_status_log.csv"
    check_interval = 60 # Ellenőrzés minden 60 másodpercben (teszteléshez)

    # Indítsa el a periodikus ellenőrzőt
    periodic_website_checker(urls_source_file, log_output_file, check_interval)

    # Megjegyzés: A Ctrl+C-vel lehet leállítani a szkriptet a konzolban.

Kulcsfontosságú elemek ebben a verzióban:

check_and_log_url_status: Ez a függvény most már nemcsak ellenőriz, hanem automatikusan be is írja az eredményeket egy CSV fájlba.
os.path.exists(log_file): Ellenőrzi, hogy a naplófájl létezik-e. Ha nem, akkor létrehozza a fájlt, és hozzáírja a CSV fejlécet. Ez biztosítja, hogy a napló mindig olvasható legyen.
periodic_website_checker: Ez a fő függvény egy végtelen ciklusban fut (while True). A time.sleep(interval_seconds) gondoskodik a megadott időközönkénti futtatásról. Ez az automatizálás alapja.
A try-except blokkok itt is nagyon fontosak, hogy a szkript stabilan fusson hosszú távon is, még ha valamilyen hiba is történik a fájlolvasás vagy az ellenőrzés során.

További fejlesztési lehetőségek

Az általunk most elkészített Python alapú weboldal elérhetőség ellenőrző már önmagában is rendkívül hasznos, de számos módon bővíthető és fejleszthető:

Értesítések: A legfontosabb, hogy értesüljünk a problémákról. Integrálhatunk e-mail küldést (pl. smtplib könyvtárral), SMS értesítést (pl. Twilio API-val), vagy akár Slack üzeneteket is.
Részletesebb HTTP kérések: Néha nem elég egy GET kérés. Használhatunk HEAD kéréseket (csak a fejlécet kérjük le), vagy POST kéréseket (pl. bejelentkezést szimulálni).
Felhasználói ügynök (User-Agent): Beállíthatjuk a User-Agent fejlécet, hogy a kérésünk egy valós böngészőnek tűnjön, ami segíthet elkerülni egyes weboldalak tiltását.
Proxy támogatás: Ha nagy számú ellenőrzést végzünk, érdemes proxy szervereket használni, hogy elkerüljük az IP-címünk tiltását.
Adatbázis tárolás: A naplókat CSV helyett adatbázisba (pl. SQLite, PostgreSQL) menthetjük, ami hatékonyabb lekérdezést és elemzést tesz lehetővé.
Webes felület: Egy Flask vagy Django alapú webes felülettel vizuálisan is megjeleníthetjük az eredményeket, grafikonokat készíthetünk a trendekről.
Többszálú (Multithreading) ellenőrzés: Nagy mennyiségű URL esetén a párhuzamos ellenőrzés jelentősen felgyorsíthatja a folyamatot. Ezt a threading vagy concurrent.futures modulokkal lehet megvalósítani.

Gyakorlati tippek és jó tanácsok

Ne terhelje túl a szervereket: Mindig figyeljen az ellenőrzési intervallumra. Túl gyakori kérésekkel DDoS-t (Distributed Denial of Service) okozhat saját magának vagy másoknak. Legyen udvarias, és tartsa be a robots.txt fájlban lévő szabályokat, bár a saját oldalaink ellenőrzésénél ez kevésbé releváns.
Használjon megbízható időtúllépést: A timeout értékének beállítása kulcsfontosságú. Túl rövid érték fals pozitív hibákat adhat, túl hosszú pedig lassúvá teszi az ellenőrzést.
Folyamatosan fejlessze: A weboldalak és a webes technológiák folyamatosan változnak. Tartsa naprakészen a szkriptjét, és illessze hozzá az új igényekhez.

Összegzés

Láthatjuk, hogy egy Python alapú weboldal elérhetőség ellenőrző elkészítése nem ördöngösség, és a requests könyvtár segítségével könnyedén megvalósítható. Ez az eszköz egy rendkívül értékes kiegészítője lehet minden weboldal üzemeltető arsanaljának, biztosítva a folyamatos működést és a problémák gyors észlelését. Reméljük, ez a részletes útmutató inspirációt adott ahhoz, hogy belevágjon saját ellenőrző rendszere megépítésébe és testreszabásába!

Kezdje el még ma, és aludjon nyugodtabban, tudva, hogy Python ellenőrzi weboldalai elérhetőségét!