Rust Web Scraping: Geliştiriciler için Adım Adım Rehber

Rust web scraping, Rust programlama dili ve crate ekosistemiyle web sayfalarını getirme ve ayrıştırma uygulamasıdır. Rust, çöp toplayıcı olmadan öngörülebilir performans ve bellek güvenliği isteyen geliştiricilere hitap eder. Bu özellik, onu kesintisiz veya yüksek hacimde çalışan tarayıcılar için güçlü bir seçenek yapar.

Bu rehber, reqwest HTTP istemcisi ve scraper ayrıştırma crate’i etrafında hazırlanmış, önce kod yaklaşımını benimseyen uygulamalı bir anlatımdır. Proje kurulumu ve en basit getirme işleminden CSS seçicilere, yapılandırılmış veri modellerine, JSON ve CSV dışa aktarmaya, sayfalamaya, yeniden deneme ve artan beklemeyle hata işlemeye, tokio ile eşzamansız eşzamanlılığa, proxy yapılandırmasına ve JavaScript yoğun siteler için headless tarayıcı alternatifine kadar ilerler. Her kod parçası derlenip çalışacak şekilde tasarlanmıştır.

DataImpulse, 195 ülkede 90 milyondan fazla residential, mobile ve datacenter IP adresi sunan etik bir proxy sağlayıcısıdır. GB başına 1 dolardan başlayan, süresi dolmayan trafik içeren kullandıkça öde modeli kullanır; web scraping, reklam doğrulama, fiyat izleme, pazar araştırması ve çoklu hesap yönetiminde kullanılır.

Web scraping için neden Rust kullanmalısınız?

Hız, düşük bellek kullanımı ve güvenilirliğin hızlı prototiplemeden daha önemli olduğu durumlarda Rust web scraping için uygundur. Derlenmiş ikili dosyaları donanıma yakın çalışır ve ödünç denetleyicisi, eşzamanlılık hatalarının tüm sınıflarını üretimde değil derleme zamanında yakalar.

Bu özellikler birkaç yaygın senaryoda fayda sağlar:

• Verim: Derlenmiş bir Rust tarayıcısı, yorumlanan bir dile göre daha düşük CPU ve bellek ek yüküyle büyük sayfa hacimlerini işler; bu da uzun işlerde altyapı maliyetini düşürür.
• Güvenli eşzamanlılık: Eşzamansız çalışma zamanı tokio, binlerce eşzamanlı isteği çalıştırmanıza olanak tanırken tür sistemi bu görevler arasındaki veri yarışlarını önler.
• Öngörülebilir kaynak kullanımı: Çöp toplayıcının olmaması daha kararlı gecikme süresi sağlar; bu da saatlerce veya günlerce ayakta kalan tarayıcılara yardımcı olur.

Bunun karşılığında öğrenme eğrisi daha dik ve derleme süreleri daha uzundur; bu nedenle Rust, tek seferlik betikler yerine ölçekli çalışan projelerde karşılığını verir. Dil ne olursa olsun aynı temel kurallar geçerlidir: robots.txt dosyasına saygı gösterin, istek hızınızı sınırlayın ve tarayıcınızın sorumlu davranması için genel web scraping en iyi uygulamalarını izleyin.

Rust scraping projesini nasıl kurarsınız?

Yeni bir Cargo paketi oluşturup ihtiyacınız olan crate’leri Cargo.toml içinde bildirerek bir Rust scraping projesi kurun. Cargo, Rust’ın derleme aracı ve paket yöneticisidir; dolayısıyla bağımlılıkları çözer ve projeyi sizin için derler.

Proje iskeletini oluşturmak için cargo new rust-scraper komutunu çalıştırın, ardından üretilen Cargo.toml dosyasını düzenleyin. Aşağıdaki bağımlılık seti bu rehberdeki her şeyi kapsar: HTTP, ayrıştırma, eşzamansız çalışma, serileştirme, CSV çıktısı, akışlar ve kullanışlı hata işleme.

[package]
name = "rust-scraper"
version = "0.1.0"
edition = "2021"

[dependencies]
reqwest = { version = "0.12", features = ["json", "socks"] }
scraper = "0.20"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
csv = "1.3"
futures = "0.3"
anyhow = "1"
thiserror = "1"

Burada reqwest istekleri işler (socks özelliği SOCKS5 proxy’leri etkinleştirir, json özelliği JSON yardımcılarını ekler), scraper HTML’yi CSS seçicilerle ayrıştırır, tokio eşzamansız çalışma zamanını sağlar, serde ve serde_json verilerinizi serileştirir, csv elektronik tabloları yazar, futures eşzamanlılık için akış birleştiricileri sunar ve anyhow ile thiserror hata işlemeyi sadeleştirir. İlk isteğinizi yazmadan önce her şeyi indirmek ve derlemek için cargo build komutunu bir kez çalıştırın.

reqwest ve scraper ile bir sayfayı nasıl getirip ayrıştırırsınız?

reqwest ile bir GET isteği göndererek sayfayı getirin, ardından CSS seçicilerle sorgulamak için yanıt gövdesini scraper’a yükleyin. Aşağıdaki örnek tokio üzerinde eşzamansız çalışır, bir sayfa getirir ve her H1 öğesinin metnini yazdırır.

use scraper::{Html, Selector};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://example.com";
    let body = reqwest::get(url).await?.text().await?;

    let document = Html::parse_document(&body);
    let heading = Selector::parse("h1").unwrap();

    for element in document.select(&heading) {
        let text: String = element.text().collect();
        println!("{}", text.trim());
    }
    Ok(())
}

Akış her zaman aynıdır: reqwest::get bir yanıt döndürür, .text() gövdesini dize olarak okur ve Html::parse_document bu dizeyi sorgulanabilir bir ağaca dönüştürür. ? işleci ağ veya kod çözme hatalarını main işlevine iletir. Eşleşen bir öğede .text() çağırmak, daha sonra kırpıp kullanacağınız metin düğümlerini toplar. Bu ham HTML yaklaşımı hızlıdır ancak yalnızca sunucunun döndürdüğü işaretlemeyi gördüğünü, tarayıcının daha sonra JavaScript ile oluşturacağı içeriği görmediğini unutmayın.

CSS seçicilerle öğeleri nasıl hedeflersiniz?

Bir tarayıcı konsolunda yapacağınız gibi, standart bir CSS seçici dizesini Selector::parse işlevine geçirerek öğeleri hedefleyin. scraper crate’i etiketleri, sınıfları, id’leri, öznitelik eşleşmelerini, alt öğe yollarını ve yapısal pseudo-class’ları destekler.

use scraper::Selector;

// Match by tag
let links = Selector::parse("a").unwrap();

// Match by class
let prices = Selector::parse(".price").unwrap();

// Match by id
let main = Selector::parse("#main-content").unwrap();

// Match by attribute value
let external = Selector::parse("a[rel=\"nofollow\"]").unwrap();

// Descendant path (a title inside a product card)
let titles = Selector::parse("div.product h2.title").unwrap();

// Direct child plus pseudo-class
let first_row = Selector::parse("table > tbody > tr:first-child").unwrap();

Ayrıştırmanın küçük bir maliyeti olduğundan, her seçiciyi bir kez derleyin ve döngü içinde ayrıştırmak yerine yeniden kullanın. Bir seçici eşleşmeyebilecekse, eksik bir alanın tüm çalışmayı paniğe sürüklememesi için öğe üzerinde .unwrap() yerine yedek değeri olan .next() kullanın. Tarayıcınızın öğe seçicisinde hedef sayfayı incelemek, seçmek için kararlı sınıf adları ve öznitelikler bulmanın en hızlı yoludur.

Kazınan verileri JSON ve CSV olarak nasıl dışa aktarırsınız?

Her kaydı serde’nin Serialize özelliğini türeten bir struct olarak modelleyip bu struct’ların bir dilimini serde_json ile JSON’a veya csv crate’iyle CSV’ye yazarak kazınan verileri dışa aktarın. Türü belirlenmiş bir model tanımlamak, çıkarma ve çıktıyı eşzamanlı tutar ve kodu kendini açıklayan hâle getirir.

Önce kaydı modelleyin ve her kapsayıcı öğeden alanları çıkarın:

use scraper::{Html, Selector};
use serde::Serialize;

#[derive(Debug, Serialize)]
struct Product {
    name: String,
    price: String,
    url: String,
}

fn parse_products(html: &str) -> Vec<Product> {
    let document = Html::parse_document(html);
    let card = Selector::parse("div.product").unwrap();
    let name_sel = Selector::parse("h2.title").unwrap();
    let price_sel = Selector::parse("span.price").unwrap();
    let link_sel = Selector::parse("a").unwrap();

    let mut products = Vec::new();
    for card_el in document.select(&card) {
        let name = card_el
            .select(&name_sel)
            .next()
            .map(|e| e.text().collect::<String>().trim().to_string())
            .unwrap_or_default();
        let price = card_el
            .select(&price_sel)
            .next()
            .map(|e| e.text().collect::<String>().trim().to_string())
            .unwrap_or_default();
        let url = card_el
            .select(&link_sel)
            .next()
            .and_then(|e| e.value().attr("href"))
            .unwrap_or_default()
            .to_string();

        products.push(Product { name, price, url });
    }
    products
}

Product, Serialize özelliğini türettiği için aynı struct ek işlem gerektirmeden her iki dışa aktarıcıya da veri sağlar:

use std::fs::File;
use std::io::Write;

fn export_json(products: &[Product]) -> anyhow::Result<()> {
    let json = serde_json::to_string_pretty(products)?;
    let mut file = File::create("products.json")?;
    file.write_all(json.as_bytes())?;
    Ok(())
}

fn export_csv(products: &[Product]) -> anyhow::Result<()> {
    let mut writer = csv::Writer::from_path("products.csv")?;
    for product in products {
        writer.serialize(product)?;
    }
    writer.flush()?;
    Ok(())
}

serde_json’un to_string_pretty işlevi insan tarafından okunabilir JSON üretir, csv crate’inin serialize işlevi ise her struct’ı alan adlarından türetilmiş başlığı olan bir satıra eşler. Scraping, JSON ve CSV için tek bir türü belirlenmiş modeli yeniden kullanmak, hedef site değiştikçe Rust hattını bakımını kolaylaştıran şeydir.

Sayfalama döngüsüyle birden çok sayfayı nasıl kazırsınız?

Sayfa numaraları veya sonraki sayfanın URL’si üzerinde döngü kurarak birden çok sayfayı kazıyın; bağlantıların istekler arasında havuzlanması için tek bir reqwest istemcisini yeniden kullanın. Her URL’yi oluşturun, getirin, önceki bölümdeki işlevle ayrıştırın ve bir sayfa sonuç döndürmediğinde durun.

use scraper::Html;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = reqwest::Client::new();
    let mut all_products = Vec::new();

    for page in 1..=10 {
        let url = format!("https://example.com/products?page={}", page);
        let body = client.get(&url).send().await?.text().await?;
        let products = parse_products(&body);

        // Stop when a page returns no results
        if products.is_empty() {
            break;
        }
        all_products.extend(products);

        // Pause between requests to stay polite
        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
    }

    println!("Collected {} products", all_products.len());
    Ok(())
}

İstemciyi döngünün dışında reqwest::Client::new() ile bir kez oluşturmak, TCP bağlantılarını yeniden kullanmasını sağlar; bu, her istek için yeni bir istemci oluşturmaktan belirgin biçimde daha hızlıdır. Boş sonuç denetimi son sayfaya ulaştığınızda döngüyü doğal olarak bitirir, kısa bekleme ise sunucuyu aşırı yüklememeniz için istekleri aralıklı gönderir. Numaralı sayfalar yerine sonraki bağlantısını kullanan sitelerde her yinelemede sonraki sayfa bağlantısının href değerini çıkarın ve bağlantı kaybolana kadar takip edin.

Hataları ve artan beklemeli yeniden denemeleri nasıl yönetirsiniz?

Getirme işlevlerinizden türü belirlenmiş bir hata döndürerek hataları yönetin, ardından geçici başarısızlıkları üstel artan beklemeyle yeniden deneyin. Ağlarda zaman aşımı yaşanır ve sunucular geçici durum kodları döndürür; bu nedenle sağlam bir scraper, tek bir başarısızlığı ölümcül değil beklenen bir durum olarak ele alır.

thiserror crate’i, bir reqwest hatasından otomatik olarak dönüşen kompakt bir hata enum’u tanımlamanızı sağlar:

use thiserror::Error;

#[derive(Error, Debug)]
enum ScrapeError {
    #[error("request failed: {0}")]
    Request(#[from] reqwest::Error),

    #[error("unexpected status code: {0}")]
    Status(reqwest::StatusCode),

    #[error("selector matched no elements")]
    Empty,
}

async fn fetch_page(client: &reqwest::Client, url: &str) -> Result<String, ScrapeError> {
    let response = client.get(url).send().await?;
    if !response.status().is_success() {
        return Err(ScrapeError::Status(response.status()));
    }
    Ok(response.text().await?)
}

#[from] özniteliği, bir reqwest başarısızlığının ? işleci aracılığıyla otomatik olarak ScrapeError::Request türüne dönüşmesi anlamına gelir. Türü belirlenmiş hatalara ek olarak, isteği her denemeden sonra beklemesi uzayan bir yeniden deneme döngüsüne alın:

use std::time::Duration;

async fn fetch_with_backoff(client: &reqwest::Client, url: &str) -> anyhow::Result<String> {
    let max_attempts = 5;
    for attempt in 1..=max_attempts {
        match client.get(url).send().await {
            Ok(resp) if resp.status().is_success() => {
                return Ok(resp.text().await?);
            }
            Ok(resp) => {
                eprintln!("attempt {attempt}: status {}", resp.status());
            }
            Err(err) => {
                eprintln!("attempt {attempt}: {err}");
            }
        }
        // Exponential backoff: 0.5s, 1s, 2s, 4s, 8s
        let backoff = Duration::from_millis(500 * 2u64.pow(attempt - 1));
        tokio::time::sleep(backoff).await;
    }
    anyhow::bail!("giving up on {url} after {max_attempts} attempts")
}

Üstel artan bekleme (burada 0,5 sn, 1 sn, 2 sn, 4 sn, 8 sn), hız sınırlaması uygulanmış veya kısa süreliğine aşırı yüklenmiş bir sunucuya onu sürekli zorlamak yerine toparlanması için zaman tanır. Yeniden denemeleri rotating proxy’lerle birleştirmek daha da etkilidir: bir IP’de engellenen veya kısıtlanan istek, sonraki denemede farklı bir çıkış IP’sinden başarılı olabilir.

tokio ile eşzamanlı istekleri nasıl çalıştırırsınız?

URL listenizi eşzamansız bir akışa dönüştürüp aynı anda yürütülen istek sayısını sınırlayan buffer_unordered işlevini uygulayarak eşzamanlı istekler çalıştırın. Bu, Rust scraper’daki en büyük tek performans kaldıraçlarından biridir ve tokio ile futures crate’i bunu güvenli kılar.

use futures::stream::{self, StreamExt};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = reqwest::Client::new();
    let urls: Vec<String> = (1..=50)
        .map(|n| format!("https://example.com/item/{}", n))
        .collect();

    let bodies = stream::iter(urls)
        .map(|url| {
            let client = client.clone();
            async move {
                let text = client.get(&url).send().await?.text().await?;
                Ok::<_, reqwest::Error>((url, text))
            }
        })
        .buffer_unordered(10); // at most 10 requests in flight

    bodies
        .for_each(|result| async {
            match result {
                Ok((url, body)) => println!("{}: {} bytes", url, body.len()),
                Err(err) => eprintln!("error: {}", err),
            }
        })
        .await;

    Ok(())
}

Burada stream::iter URL listesini bir akışa dönüştürür, .map her URL için bir eşzamansız istek başlatır ve buffer_unordered(10) en fazla on isteği eşzamanlı çalışır durumda tutarak sonuçları biter bitmez verir. Her görev için istemciyi klonlamak ucuzdur çünkü reqwest Client, paylaşılan bağlantı havuzunun çevresinde bir Arc‘tır. Eşzamanlılık sınırını hız ile hedefe bindirdiğiniz yük arasında denge kuracak şekilde ayarlayın: on ila yirmi makul bir başlangıç noktasıdır; daha yüksek eşzamanlılığı bir proxy havuzuyla eşleştirmek istekleri birçok IP’ye dağıtır.

Rust scraping trafiğini proxy üzerinden nasıl yönlendirirsiniz?

reqwest::Proxy ile bir reqwest istemcisi oluşturup ağ geçidinizi ve kimlik bilgilerinizi .basic_auth ile ekleyerek trafiği proxy üzerinden yönlendirin. İstekleri rotating IP’ler üzerinden göndermek yükü dağıtır, coğrafi olarak belirli içeriğe ulaşır ve hız sınırlamasına takılma olasılığını azaltır. Rotating IP’ler, engellenmeden scraping yapmak için en etkili tekniklerden biridir.

use reqwest::Proxy;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Authenticated gateway; rotates the exit IP on each request
    let proxy = Proxy::all("http://gw.dataimpulse.com:823")?
        .basic_auth("login", "password");

    let client = reqwest::Client::builder()
        .proxy(proxy)
        .timeout(std::time::Duration::from_secs(30))
        .build()?;

    let body = client
        .get("https://httpbin.org/ip")
        .send()
        .await?
        .text()
        .await?;

    println!("{}", body);
    Ok(())
}

login ve password değerlerini kendi kimlik bilgilerinizle değiştirin ve ihtiyacınız olan ağ için portu ayarlayın. Proxy isteğinizi 407 durumuyla reddederse neden neredeyse her zaman eksik veya yanlış kimlik bilgileridir; HTTP hata 407 ile proxy kimlik doğrulama rehberi sorunun nasıl giderileceğini açıklar. DataImpulse, residential proxy’leri, datacenter proxy’leri ve mobile proxy’leri HTTP, HTTPS ve SOCKS5 üzerinden rotating ve sticky session seçenekleriyle sunar. Ülke hedeflemesi dahildir; eyalet, şehir, ZIP ve ASN hedeflemesi ise ücretli eklentilerdir.

JavaScript yoğun sayfaları nasıl kazırsınız ve Rust ne zaman doğru seçimdir?

JavaScript yoğun sayfaları gerçek bir headless tarayıcıyı sürerek kazıyın; çünkü reqwest ve scraper yalnızca sunucunun ham HTML’sini görür ve betikleri asla çalıştırmaz. İçerik yalnızca istemci tarafı oluşturma sonrasında görünüyorsa WebDriver protokolünü konuşan thirtyfour gibi bir tarayıcı otomasyon crate’ine veya Chrome’u DevTools Protocol üzerinden kontrol eden chromiumoxide’a başvurun.

use thirtyfour::prelude::*;

#[tokio::main]
async fn main() -> WebDriverResult<()> {
    let caps = DesiredCapabilities::chrome();
    let driver = WebDriver::new("http://localhost:9515", caps).await?;

    driver.goto("https://example.com").await?;

    // Wait for client-side content to render, then read it
    let heading = driver.find(By::Css("h1")).await?;
    println!("{}", heading.text().await?);

    driver.quit().await?;
    Ok(())
}

thirtyfour örneği çalışan bir chromedriver’a bağlanır, bir sayfa yükler, oluşturulmuş bir öğeyi bekler ve metnini okur. Bu yaklaşım sıradan bir HTTP getirmesinden çok daha ağırdır; bu yüzden yalnızca gerçekten buna ihtiyaç duyan sayfalar için kullanın ve diğer her şey için hızlı reqwest yolunu koruyun. Bu dengeyi daha derinlemesine incelemek için dinamik web sayfalarını scraping ve JavaScript ile web scraping rehberlerine bakın. Aşağıdaki tablo, temel crate’lerin birlikte nasıl çalıştığını özetler:

Dil seçimine gelince, ölçekte sürekli performans ve düşük kaynak kullanımı gerektiğinde Rust’ı; hızlı geliştirmeye ve Scrapy ile Playwright gibi daha geniş bir scraping ekosistemine değer verdiğinizde Python’ı seçin. Yaygın bir yöntem, çıkarma kurallarını Python’da prototiplemek, ardından mantık kararlı hâle gelip hacim büyüdüğünde kritik yolu Rust’a taşımaktır. Hangisini seçerseniz seçin ağ katmanı ayrıştırıcı kadar önemlidir ve etik şekilde tedarik edilen proxy’ler büyük işleri güvenilir tutar.

Sık sorulan sorular

İlgili rehberler

• JavaScript ile Web Scraping
• Dinamik Web Sayfalarını Scraping
• Web Scraping En İyi Uygulamaları

Etik proxy’lerle güvenilir scraping

Rust scraper’ınız verileri sorunsuz biçimde getirip ayrıştırıp dışa aktardıktan sonra, onu ölçekte çalışır tutan şey güvenilir bir proxy ağıdır. DataImpulse, GB başına 1 dolardan başlayan ve süresi dolmayan trafik içeren, etik şekilde tedarik edilmiş IP’leri kullandıkça öde modeliyle sunar; böylece hesap oluşturabilir ve ilk isteklerinizi dakikalar içinde yönlendirebilirsiniz.