Büyük Web Siteleri İçin Kırık Bağlantı Tarayıcı Nasıl Geliştirilir?

Büyük Web Siteleri İçin Kırık Bağlantı Tarayıcı Nasıl Geliştirilir?

Büyük web siteleri, binlerce hatta milyonlarca sayfadan oluşabilir ve bu sitelerde zamanla kırık bağlantıların (broken links) oluşması kaçınılmazdır. Bu durum, hem kullanıcı deneyimini olumsuz etkiler hem de arama motoru optimizasyonu (SEO) açısından ciddi sorunlara yol açar. Kullanıcılar aradıkları içeriğe ulaşamadığında hayal kırıklığı yaşar ve sitenizden ayrılırken, arama motorları da kırık bağlantıları sitenizin kalitesiz olduğuna dair bir işaret olarak algılayabilir. Peki, bu kaosu önlemek ve sitenizi sürekli güncel tutmak için nasıl bir çözüm üretebiliriz? Bu makalede, büyük ölçekli web siteleri için sıfırdan, adım adım bir kırık bağlantı tarayıcı (broken link scanner) geliştirmeyi derinlemesine inceleyeceğiz.

Kırık Bağlantılar Neden Büyük Bir Sorundur ve Nasıl Ortaya Çıkar?

Bir web sitesindeki kırık bağlantılar, sadece küçük bir teknik aksaklık gibi görünse de, özellikle büyük ve karmaşık platformlar için domino etkisi yaratabilen ciddi bir problem kaynağıdır. Bu bağlantılar, bir kullanıcının veya arama motoru botunun belirli bir URL’ye erişmeye çalıştığında, o kaynağın artık mevcut olmadığını belirten bir hata kodu (genellikle 404 Not Found) ile karşılaşması durumunda ortaya çıkar. Bu durum, sitenin genel sağlığı ve performansı üzerinde derinleşimli olumsuz etkilere sahiptir.

Öncelikle, kullanıcı deneyimi (user experience) açısından bakıldığında, kırık bağlantılar doğrudan bir hayal kırıklığı ve güven kaybı yaratır. Bir kullanıcı, bir ürün sayfasını, bir blog yazısını veya bir destek belgesini ararken kırık bir bağlantıya tıklarsa, beklediği içeriğe ulaşamaz. Bu durum, kullanıcının zamanını boşa harcamasına ve sitenizden olumsuz bir izlenimle ayrılmasına neden olur. Tekrarlayan kırık bağlantı deneyimleri, markanıza olan güveni zedeler ve potansiyel müşterilerin veya okuyucuların rakiplerinize yönelmesine yol açabilir. Örneğin, bir e-ticaret sitesinde, müşterinin sepetine eklemek istediği bir ürünün sayfasının kırık olduğunu düşünün. Bu durum, doğrudan bir satış kaybına ve müşteri memnuniyetsizliğine yol açacaktır.

Arama motoru optimizasyonu (SEO) açısından ise kırık bağlantılar, sitenizin sıralamasına doğrudan zarar verebilir. Arama motoru botları (örneğin Googlebot), sitenizi tararken kırık bağlantılarla karşılaştığında, bu sayfaları indeksleyemez ve sitenizin genel kalitesini düşük olarak değerlendirebilir. Yüksek sayıda kırık bağlantı, sitenizin “tarama bütçesini” (crawl budget) boşa harcar; yani botlar değerli sayfaları taramak yerine, var olmayan sayfalara zaman ayırır. Ayrıca, iç bağlantılar (internal links) aracılığıyla aktarılan “link juice” veya “otorite” de kırık bağlantılar nedeniyle boşa gider, bu da ilgili sayfaların arama motoru sonuçlarında daha düşük sıralanmasına neden olabilir. Dış bağlantılar (external links) için de durum benzerdir; eğer siteniz güvenilir olmayan veya artık var olmayan kaynaklara bağlantı veriyorsa, bu da sitenizin güvenilirliğini sorgulatabilir.

Kırık bağlantıların ortaya çıkış nedenleri oldukça çeşitlidir ve büyük web sitelerinde bu nedenlerin takibi manuel olarak neredeyse imkansızdır. En yaygın nedenlerden bazıları şunlardır:

• Silinen veya Taşınan Sayfalar: Bir web sitesindeki içerik sürekli güncellenir. Eski ürünler kaldırılabilir, blog yazıları birleştirilebilir veya kategorileri değişebilir. Eğer bu değişiklikler sırasında eski URL’ler doğru bir şekilde 301 yönlendirmesi (redirect) ile yeni URL’lere yönlendirilmezse, kırık bağlantılar oluşur.
• Yazım Hataları (Typos): Bağlantılar manuel olarak eklenirken yapılan küçük bir yazım hatası, hedef URL’nin hatalı olmasına neden olabilir. Bu durum, özellikle içerik yöneticilerinin çok sayıda bağlantı eklediği durumlarda sıkça görülür.
• Harici Bağlantılardaki Değişiklikler: Siteniz başka bir web sitesine bağlantı verdiğinde, o harici site kendi içeriğini değiştirebilir veya tamamen kapatabilir. Bu durumda, sizin sitenizdeki bağlantı da kırık hale gelir. Harici siteler üzerindeki kontrolünüz olmadığı için bu tür kırık bağlantılar özellikle zor tespit edilebilir.
• Yapısal Değişiklikler: Web sitesinin URL yapısı (URL structure) değiştiğinde, örneğin kategori isimleri veya alt dizinler yeniden düzenlendiğinde, eğer eski bağlantılar doğru şekilde güncellenmezse, binlerce kırık bağlantı bir anda ortaya çıkabilir.
• Süresi Dolan Alan Adları (Expired Domains): Özellikle harici bağlantılar söz konusu olduğunda, bağlantı verdiğiniz bir alan adının süresi dolmuş veya sahibi tarafından yenilenmemiş olabilir.
• Dosya Yükleme Hataları: PDF, resim veya diğer medya dosyalarına verilen bağlantılar, bu dosyaların sunucudan silinmesi veya yanlış yüklenmesi durumunda kırılabilir.

Büyük bir web sitesinde bu nedenlerden herhangi biri, yüzlerce veya binlerce kırık bağlantıya yol açabilir. Bu nedenle, manuel olarak her bağlantıyı kontrol etmek imkansızdır. İşte bu noktada, otomatik bir kırık bağlantı tarayıcısına olan ihtiyaç ortaya çıkar. Bu tarayıcı, sitenizi düzenli aralıklarla tarayarak, bu tür sorunları otomatik olarak tespit etmenize ve hızlıca müdahale etmenize olanak tanır.

Temel Kavramlar: Bir Bağlantı Tarayıcı Ne Yapar?

Bir kırık bağlantı tarayıcı, temel olarak bir web sitesini ziyaret eden ve tüm bağlantılarını kontrol eden otomatik bir sistemdir. Bu süreçte birkaç temel kavram ön plana çıkar:

• Web Kazıma (Web Scraping): Bir web sayfasının HTML içeriğini programatik olarak alıp, içindeki bilgileri (bu durumda bağlantıları) çıkarmak anlamına gelir. Tarayıcımız, bir sayfayı indirip içindeki <a href="..."> etiketlerini bulacaktır.
• HTTP İstekleri (HTTP Requests): Tarayıcımızın web sayfalarını indirmek ve bağlantıların durumunu kontrol etmek için kullandığı temel yöntemdir. Bir URL’ye bir HTTP GET isteği göndeririz ve sunucudan bir yanıt bekleriz.
• Durum Kodları (Status Codes): Bir HTTP isteği yapıldığında, sunucu bir durum kodu ile yanıt verir. Bu kodlar, isteğin başarılı olup olmadığını veya bir sorun olup olmadığını belirtir.
  • 200 OK: Bağlantı çalışıyor, sayfa başarıyla yüklendi.
  • 301 Moved Permanently: Sayfa kalıcı olarak başka bir yere taşındı. Bu bir kırık bağlantı değildir, ancak eski bağlantının güncellenmesi veya yönlendirmenin takip edilmesi gerekir.
  • 302 Found: Sayfa geçici olarak başka bir yere taşındı. Benzer şekilde yönlendirme takip edilmelidir.
  • 404 Not Found: En bilinen kırık bağlantı kodu. Sayfa bulunamadı.
  • 410 Gone: Sayfa kalıcı olarak kaldırıldı ve geri gelmeyecek. Bu da bir kırık bağlantıdır.
  • 500 Internal Server Error: Sunucu tarafında bir hata oluştu. Bağlantı çalışmıyor.
• URL Ayrıştırma (URL Parsing): Bir web sayfasının HTML’inden çıkarılan bağlantıların (URL’lerin) doğru formatta olup olmadığını kontrol etme, göreceli (relative) URL’leri mutlak (absolute) URL’lere dönüştürme ve aynı URL’nin farklı varyasyonlarını (örneğin, http://example.com ve http://example.com/) tek bir standart formata indirgeme işlemidir.
• Robot.txt ve Site Haritaları (Sitemaps): robots.txt dosyası, arama motorlarına hangi sayfaları tarayabileceklerini veya tarayamayacaklarını belirtir. Tarayıcımızın da bu kurallara uyması gerekir. Site haritaları (sitemap.xml), bir web sitesindeki tüm önemli URL’leri listeleyen dosyalardır ve tarayıcımızın başlangıç noktası veya keşif kaynağı olarak kullanılabilir.

Bu temel kavramları anlayarak, bir web sitesindeki her bir bağlantıyı sistematik bir şekilde kontrol edebilecek bir sistemin temellerini atmış oluruz.

Tarayıcımızın Mimarisi: Temelden İleri Seviyeye

Bir kırık bağlantı tarayıcısının geliştirilmesi, basit bir betikten (script) başlayıp, büyük ölçekli ve dayanıklı bir sisteme evrilebilen kademeli bir süreçtir. Bu bölümde, tarayıcımızın mimarisini temelden ileri seviyeye nasıl taşıyabileceğimizi inceleyeceğiz.

Basit Bir Tarayıcı İçin İlk Adımlar: Tek İş Parçacıklı Yaklaşım

Geliştirmeye başlarken, ilk adım genellikle basit bir tek iş parçacıklı (single-threaded) tarayıcı oluşturmaktır. Bu yaklaşım, temel mantığı anlamak ve hızlıca bir prototip oluşturmak için idealdir. Python, bu tür görevler için zengin kütüphane desteği sayesinde harika bir seçimdir. requests kütüphanesi HTTP istekleri yapmak için, BeautifulSoup ise HTML ayrıştırma (parsing) için oldukça kullanışlıdır.

Basit bir tarayıcının çalışma prensibi şöyledir: Belirli bir başlangıç URL’si (seed URL) ile başlar, bu URL’yi ziyaret eder, sayfanın HTML içeriğini indirir, içindeki tüm bağlantıları (<a href>) çıkarır. Çıkarılan her bağlantı için bir HTTP isteği yaparak durum kodunu kontrol eder ve kırık olanları kaydeder. Ardından, bulunan yeni bağlantıları (eğer daha önce ziyaret edilmediyse) sıraya ekleyerek bu işlemi tekrarlar. Bu döngü, belirlenen bir derinlik sınırına ulaşana veya taranacak başka bağlantı kalmayana kadar devam eder.

İşte Python ile basit bir tek iş parçacıklı tarayıcının temel yapısını gösteren bir örnek:

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse

def is_valid(url):
    """URL'nin geçerli bir HTTP veya HTTPS URL'si olup olmadığını kontrol eder."""
    try:
        result = urlparse(url)
        return all([result.scheme, result.netloc]) and result.scheme in ['http', 'https']
    except ValueError:
        return False

def get_all_links(url, base_url):
    """Bir sayfadaki tüm bağlantıları alır."""
    links = set()
    try:
        response = requests.get(url, timeout=5) # 5 saniye zaman aşımı
        soup = BeautifulSoup(response.text, 'html.parser')
        for a_tag in soup.find_all('a', href=True):
            href = a_tag.attrs.get('href')
            if href:
                # Göreceli URL'leri mutlak URL'lere dönüştür
                full_url = urljoin(base_url, href)
                if is_valid(full_url):
                    links.add(full_url)
    except requests.exceptions.RequestException as e:
        print(f"URL {url} taranırken hata oluştu: {e}")
    return links

def simple_broken_link_scanner(start_url, domain_to_scan, max_depth=2):
    """Basit bir kırık bağlantı tarayıcı."""
    visited_urls = set()
    urls_to_visit = [(start_url, 0)] # (URL, derinlik)
    broken_links = {}

    while urls_to_visit:
        current_url, depth = urls_to_visit.pop(0)

        if current_url in visited_urls or depth > max_depth:
            continue

        visited_urls.add(current_url)
        print(f"Tarama: {current_url} (Derinlik: {depth})")

        try:
            response = requests.head(current_url, timeout=5) # Sadece başlık bilgisini al
            if 400 <= response.status_code < 600:
                broken_links[current_url] = response.status_code
                print(f"KIRIK BAĞLANTI BULUNDU: {current_url} - Durum Kodu: {response.status_code}")
            else:
                # Sadece aynı alan adındaki bağlantıları keşfet
                if urlparse(current_url).netloc == urlparse(domain_to_scan).netloc:
                    new_links = get_all_links(current_url, domain_to_scan)
                    for link in new_links:
                        if urlparse(link).netloc == urlparse(domain_to_scan).netloc and link not in visited_urls:
                            urls_to_visit.append((link, depth + 1))

        except requests.exceptions.RequestException as e:
            broken_links[current_url] = str(e)
            print(f"KIRIK BAĞLANTI BULUNDU (İstek Hatası): {current_url} - Hata: {e}")

    print("\n--- Tarama Tamamlandı ---")
    if broken_links:
        print("Bulunan Kırık Bağlantılar:")
        for url, status in broken_links.items():
            print(f"- {url}: {status}")
    else:
        print("Kırık bağlantı bulunamadı.")

# Kullanım Örneği:
# if __name__ == "__main__":
#     target_url = "https://www.ornek.com" # Tarayacağınız web sitesinin ana URL'si
#     domain = urlparse(target_url).netloc
#     simple_broken_link_scanner(target_url, domain, max_depth=1)
        

Yukarıdaki örnekte, requests.head() kullanılarak sadece HTTP başlıkları (headers) alınır. Bu, sayfanın tamamını indirmekten daha hızlıdır ve genellikle bir bağlantının durum kodunu kontrol etmek için yeterlidir. Ancak, iç bağlantıları keşfetmek için sayfanın içeriği de okunmalıdır, bu nedenle get_all_links fonksiyonunda requests.get() kullanılır.

Bu tek iş parçacıklı yaklaşımın en büyük sınırlaması hızdır. Her HTTP isteği ve HTML ayrıştırma işlemi sırayla gerçekleşir. Büyük web siteleri için bu, tarama süresinin günleri hatta haftaları bulabileceği anlamına gelir. Ayrıca, bir ağ hatası veya sunucu yanıt vermediğinde tüm tarama durabilir veya yavaşlayabilir. Bu nedenle, ölçeklenebilirlik için daha gelişmiş yaklaşımlara ihtiyacımız vardır.

Ölçeklenebilirlik İçin Eşzamanlılık ve Paralellik Nasıl Uygulanır?

Büyük web sitelerini etkili bir şekilde taramak için eşzamanlılık (concurrency) ve paralellik (parallelism) vazgeçilmezdir. Tek bir isteğin tamamlanmasını beklemek yerine, aynı anda birden fazla isteği işleyebilmeliyiz. Bu, tarama hızımızı katlanarak artırır.

Eşzamanlılık (Concurrency): Aynı anda birden fazla görevin ilerlemesini sağlama yeteneğidir, ancak bu görevler mutlaka aynı anda çalışmak zorunda değildir. Örneğin, bir isteğin yanıtını beklerken başka bir isteği başlatabiliriz. Python'da asyncio modülü ve aiohttp gibi kütüphaneler asenkron programlama ile eşzamanlılık sağlar. Go dilindeki Goroutine'ler de bu yaklaşımın güçlü bir örneğidir.

import asyncio
import aiohttp
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse

async def check_link(session, url):
    """Asenkron olarak bir bağlantının durum kodunu kontrol eder."""
    try:
        async with session.head(url, timeout=aiohttp.ClientTimeout(total=5)) as response:
            if 400 <= response.status < 600:
                return url, response.status
            return None, None
    except aiohttp.ClientError as e:
        return url, str(e)
    except asyncio.TimeoutError:
        return url, "Timeout"

async def get_links_async(session, url, base_url):
    """Asenkron olarak bir sayfadaki tüm bağlantıları alır."""
    links = set()
    try:
        async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as response:
            if response.status == 200:
                text = await response.text()
                soup = BeautifulSoup(text, 'html.parser')
                for a_tag in soup.find_all('a', href=True):
                    href = a_tag.attrs.get('href')
                    if href:
                        full_url = urljoin(base_url, href)
                        if is_valid(full_url): # is_valid fonksiyonu yukarıdaki örnekten alınabilir
                            links.add(full_url)
    except aiohttp.ClientError as e:
        print(f"Asenkron tarama hatası: {url} - {e}")
    except asyncio.TimeoutError:
        print(f"Asenkron tarama zaman aşımı: {url}")
    return links

async def async_broken_link_scanner(start_url, domain_to_scan, max_depth=2, concurrency_limit=10):
    """Asenkron kırık bağlantı tarayıcı."""
    visited_urls = set()
    urls_to_visit = asyncio.Queue()
    await urls_to_visit.put((start_url, 0))
    broken_links = {}

    async with aiohttp.ClientSession() as session:
        while not urls_to_visit.empty():
            current_url, depth = await urls_to_visit.get()

            if current_url in visited_urls or depth > max_depth:
                continue

            visited_urls.add(current_url)
            print(f"Tarama: {current_url} (Derinlik: {depth})")

            url, status = await check_link(session, current_url)
            if url:
                broken_links[url] = status
                print(f"KIRIK BAĞLANTI BULUNDU: {url} - Durum Kodu/Hata: {status}")
            else:
                if urlparse(current_url).netloc == urlparse(domain_to_scan).netloc:
                    new_links = await get_links_async(session, current_url, domain_to_scan)
                    for link in new_links:
                        if urlparse(link).netloc == urlparse(domain_to_scan).netloc and link not in visited_urls:
                            await urls_to_visit.put((link, depth + 1))

    print("\n--- Asenkron Tarama Tamamlandı ---")
    if broken_links:
        print("Bulunan Kırık Bağlantılar:")
        for url, status in broken_links.items():
            print(f"- {url}: {status}")
    else:
        print("Kırık bağlantı bulunamadı.")

# Kullanım Örneği:
# if __name__ == "__main__":
#     target_url = "https://www.ornek.com"
#     domain = urlparse(target_url).netloc
#     asyncio.run(async_broken_link_scanner(target_url, domain, max_depth=1, concurrency_limit=20))
        

Paralellik (Parallelism): Birden fazla görevin aynı anda, genellikle farklı işlemci çekirdeklerinde veya makinelerde çalışmasıdır. Python'da multiprocessing modülü ile paralellik sağlanabilir. Daha büyük ölçekler için dağıtık sistemler (distributed systems) devreye girer; birden fazla makineye iş yükünü dağıtarak çok daha hızlı tarama yapabiliriz. Bu durumda, bir kuyruk sistemi (queue system) (örneğin RabbitMQ, Apache Kafka veya Redis kuyrukları) ve bir görev zamanlayıcı (task scheduler) (örneğin Celery) kullanmak faydalı olacaktır. Tarayıcımız, bulduğu bağlantıları kuyruğa atar, ve birden fazla "işçi" (worker) bu kuyruktan bağlantıları çekip paralel olarak kontrol eder.

Eşzamanlılık ve paralellik kullanırken dikkat edilmesi gereken önemli noktalar vardır:

• Hız Sınırlama (Rate Limiting): Hedef web sitesine çok fazla istek göndermek, sunucuyu aşırı yükleyebilir ve IP adresinizin engellenmesine neden olabilir. Bu nedenle, belirli bir zaman diliminde gönderilen istek sayısını sınırlamak (örneğin, saniyede X istek) kritik öneme sahiptir.
• Zaman Aşımları (Timeouts): Bir isteğin sonsuza kadar yanıt beklemesini önlemek için zaman aşımı süreleri (timeout) belirlemek önemlidir. Uzun süre yanıt vermeyen sunucular, tüm tarama sürecini yavaşlatabilir.
• Kaynak Yönetimi: Çok fazla eşzamanlı bağlantı açmak, sistem kaynaklarını (bellek, CPU) tüketebilir. Doğru eşzamanlılık sınırı bulmak önemlidir.

Veri Yönetimi ve Depolama Stratejileri

Tarayıcımız binlerce, hatta milyonlarca bağlantıyı kontrol ederken, bu verileri etkili bir şekilde yönetmek ve depolamak hayati önem taşır. Hangi bağlantıların taranacağı, hangilerinin zaten taranmış olduğu ve hangi bağlantıların kırık olduğu gibi bilgilerin saklanması gerekir.

Taranmış URL'leri İzleme: Tekrar tekrar aynı URL'yi taramayı önlemek için, taranmış URL'leri bir veri yapısında saklamamız gerekir. Python'daki set veri yapısı, hızlı "içinde mi?" (in-check) kontrolleri için idealdir. Ancak, tarama durdurulup yeniden başlatıldığında bu bilgiyi kaybetmemek için, bu setin kalıcı bir depolama alanına (örneğin bir veritabanına veya dosyaya) yazılması gerekebilir.

• Basit Depolama (CSV, JSON): Küçük ölçekli taramalar için, kırık bağlantıları bir CSV veya JSON dosyasına yazmak yeterli olabilir. Bu, hızlı ve kolay bir çözümdür.
• İlişkisel Veritabanları (SQLite, PostgreSQL, MySQL): Daha büyük ve yapılandırılmış veriler için ilişkisel veritabanları daha uygun olabilir.
  • SQLite: Tek bir dosya içinde çalışan, kurulumu kolay ve hafif bir veritabanıdır. Geliştirme ve orta ölçekli projeler için idealdir.
  • PostgreSQL veya MySQL: Büyük ölçekli, çok kullanıcılı veya dağıtık sistemler için daha güçlü ve performanslı çözümler sunar. Kırık bağlantıların yanı sıra, her URL'nin durum kodu, son tarama tarihi, bulunan bağlantı sayısı gibi detayları saklamak için tablolar oluşturabiliriz.
• NoSQL Veritabanları (MongoDB, Redis): Eğer veri yapımız esnekse veya çok yüksek okuma/yazma hızlarına ihtiyacımız varsa, NoSQL veritabanları düşünülebilir. Örneğin, Redis, taranmış URL'leri hızlı bir şekilde saklamak ve kontrol etmek için bir "set" olarak kullanılabilir.

Raporlama ve Görselleştirme: Elde ettiğimiz verilerin anlamlı hale gelmesi için iyi bir raporlama mekanizması şarttır. Kırık bağlantıların listesi, durum kodları, hangi sayfadan geldikleri gibi bilgileri içeren özet raporlar oluşturulmalıdır. Bu raporlar, geliştiricilerin veya içerik yöneticilerinin sorunları hızlıca tespit etmesine ve düzeltmesine yardımcı olur. İleri düzeyde, bu verileri bir gösterge panosu (dashboard) aracılığıyla görselleştirmek, sitenin genel sağlığını izlemek için çok değerli olabilir.

Örneğin, bir PostgreSQL veritabanı kullanarak kırık bağlantıları depolamak için basit bir tablo yapısı şöyle olabilir:

CREATE TABLE broken_links (
    id SERIAL PRIMARY KEY,
    source_url VARCHAR(2048) NOT NULL,
    broken_url VARCHAR(2048) NOT NULL,
    status_code INTEGER,
    error_message TEXT,
    scan_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
        

Bu tablo, hangi kaynaktan (source_url) hangi kırık bağlantının (broken_url) bulunduğunu, durum kodunu veya hata mesajını ve ne zaman tespit edildiğini kaydeder. Bu sayede, zaman içindeki eğilimleri izleyebilir ve düzeltmelerin etkisini görebiliriz.

Büyük Web Siteleri İçin Özel Zorluklar ve Çözümler

Büyük web siteleri, sadece bağlantı sayısı açısından değil, aynı zamanda teknolojik karmaşıklık açısından da zorluklar sunar. Bu zorlukların üstesinden gelmek için tarayıcımızın bazı özel yeteneklere sahip olması gerekir.

Dinamik İçerik ve JavaScript Destekli Siteler Nasıl Taranır?

Modern web sitelerinin çoğu, içeriklerini dinamik olarak yüklemek için JavaScript kullanır. Geleneksel HTTP istekleri (requests veya aiohttp gibi kütüphanelerle yapılanlar), sadece sunucudan gelen ham HTML'yi alır. JavaScript tarafından oluşturulan veya değiştirilen içeriği göremezler. Bu da, eğer bağlantılar JavaScript ile oluşturuluyorsa, tarayıcımızın bu bağlantıları kaçıracağı anlamına gelir.

Bu sorunu çözmek için "headless" tarayıcılar (headless browsers) kullanırız. Headless tarayıcılar, grafiksel kullanıcı arayüzü (GUI) olmadan çalışan gerçek web tarayıcılarıdır (Chrome veya Firefox gibi). Bir headless tarayıcı, bir sayfayı ziyaret ettiğinde JavaScript'i yürütür, CSS'i uygular ve tam bir DOM (Document Object Model) oluşturur. Böylece, web sitesinin son kullanıcıya göründüğü şeklini programatik olarak elde edebiliriz.

En popüler headless tarayıcı otomasyon araçları şunlardır:

• Selenium: Başlangıçta manuel test otomasyonu için geliştirilmiş olsa da, web kazıma ve dinamik içerik taraması için yaygın olarak kullanılır. Farklı tarayıcılar (Chrome, Firefox, Edge) ile entegre olabilir.
• Playwright: Microsoft tarafından geliştirilen, daha modern ve hızlı bir otomasyon kütüphanesidir. Chromium, Firefox ve WebKit gibi tarayıcı motorlarını destekler. Özellikle asenkron işlemlerde Selenium'dan daha iyi performans gösterebilir.
• Puppeteer: Google tarafından geliştirilen bir Node.js kütüphanesidir ve Chromium tabanlı tarayıcıları kontrol etmek için kullanılır. Eğer tarayıcınız Node.js ile geliştiriliyorsa, güçlü bir seçenektir.

Bu araçların kullanımı, tarayıcımızın yeteneklerini büyük ölçüde artırır ancak önemli bir performans maliyeti getirir. Her sayfa için tam bir tarayıcı başlatmak, JavaScript'i yürütmek ve DOM'u işlemek, basit bir HTTP isteğine göre çok daha fazla CPU ve bellek kaynağı tüketir. Bu nedenle, headless tarayıcıları sadece gerçekten ihtiyaç duyulduğunda kullanmak akıllıca olacaktır. Örneğin, başlangıçta sadece HTTP istekleriyle tarama yapıp, belirli bir alan adındaki bağlantılar kaçırılıyorsa veya yanlış durum kodları alınıyorsa, o alan için headless tarayıcıyı devreye sokabiliriz.

Python ile Playwright kullanarak bir sayfadaki bağlantıları nasıl alacağımıza dair kısa bir örnek:

from playwright.async_api import async_playwright

async def get_links_with_js(url):
    """Playwright kullanarak JavaScript ile yüklenen bağlantıları alır."""
    links = set()
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        try:
            await page.goto(url, wait_until="networkidle") # Ağ etkinliği bitene kadar bekle
            # Sayfadaki tüm  etiketlerinin href özelliklerini al
            hrefs = await page.evaluate('''
                Array.from(document.querySelectorAll('a[href]')).map(a => a.href);
            ''')
            for href in hrefs:
                if is_valid(href): # is_valid fonksiyonu yukarıdaki örnekten alınabilir
                    links.add(href)
        except Exception as e:
            print(f"Playwright ile tarama hatası: {url} - {e}")
        finally:
            await browser.close()
    return links

# Kullanım Örneği:
# if __name__ == "__main__":
#     target_url = "https://www.example.com/javascript-loaded-page"
#     # links = asyncio.run(get_links_with_js(target_url))
#     # print(f"Playwright ile bulunan bağlantılar: {links}")