تجريف الويب باستخدام Rust: دليل خطوة بخطوة للمطورين

تجريف الويب باستخدام Rust هو عملية جلب صفحات الويب وتحليلها بلغة البرمجة Rust ومنظومة الحزم الخاصة بها. تجذب Rust المطورين الذين يريدون أداءً قابلاً للتنبؤ وأماناً للذاكرة من دون جامع نفايات، ما يجعلها خياراً مناسباً للزواحف التي تعمل باستمرار أو بأحجام كبيرة.

هذا الدليل شرح عملي يضع الشيفرة أولاً، ويرتكز على عميل HTTP المسمى reqwest وحزمة التحليل scraper. يبدأ من إعداد المشروع وتنفيذ جلب بسيط، ثم ينتقل إلى محددات CSS ونماذج البيانات المنظمة والتصدير إلى JSON وCSV وتقسيم النتائج إلى صفحات ومعالجة الأخطاء بإعادة المحاولة والتأخير التصاعدي والتزامن غير المتزامن باستخدام tokio وإعداد البروكسي، ثم بديل المتصفح عديم الواجهة للمواقع المكثفة بـ JavaScript. صُممت كل مقتطفات الشيفرة لتُصرّف وتعمل.

DataImpulse مزود بروكسي أخلاقي يقدّم أكثر من 90 مليون عنوان IP سكني ومحمول ومن مراكز البيانات في 195 دولة. يعتمد نموذج الدفع حسب الاستخدام ابتداءً من 1 دولار لكل GB مع حركة مرور لا تنتهي صلاحيتها، ويُستخدم لتجريف الويب والتحقق من الإعلانات ومراقبة الأسعار وأبحاث السوق وإدارة الحسابات المتعددة.

لماذا تستخدم Rust لتجريف الويب؟

تناسب Rust تجريف الويب عندما تكون السرعة وانخفاض استهلاك الذاكرة والموثوقية أهم من إنشاء نموذج أولي سريع. تعمل ملفاتها التنفيذية المصرّفة قريباً من العتاد، ويلتقط مدقق الاقتراض فئات كاملة من أخطاء التزامن وقت التصريف بدلاً من اكتشافها في بيئة الإنتاج.

تظهر فائدة هذه الخصائص في عدة سيناريوهات شائعة:

• معدل الإنجاز: يعالج زاحف Rust المصرّف كميات كبيرة من الصفحات باستهلاك أقل لوحدة المعالجة المركزية والذاكرة من لغة مفسرة، ما يقلل تكلفة البنية التحتية في المهام الطويلة.
• تزامن آمن: تتيح لك بيئة التشغيل غير المتزامنة tokio تنفيذ آلاف الطلبات المتزامنة، بينما يمنع نظام الأنواع سباقات البيانات بين تلك المهام.
• استخدام قابل للتنبؤ للموارد: غياب جامع النفايات يعني زمناً أكثر استقراراً للاستجابة، وهو ما يفيد الزواحف التي تبقى قيد التشغيل لساعات أو أيام.

المقابل هو منحنى تعلم أكثر حدة وأوقات تصريف أطول، لذا تناسب Rust المشاريع التي تعمل على نطاق واسع أكثر من البرامج النصية لمرة واحدة. وبغض النظر عن اللغة، تنطبق القواعد الأساسية ذاتها: احترم robots.txt، واضبط معدل طلباتك، واتبع أفضل ممارسات تجريف الويب حتى يظل زاحفك ملتزماً.

كيف تُعد مشروع تجريف باستخدام Rust؟

أعِد مشروع تجريف باستخدام Rust بإنشاء حزمة Cargo جديدة وتعريف الحزم التي تحتاجها في Cargo.toml. تُعد Cargo أداة بناء Rust ومدير حزمها، لذا تحل التبعيات وتُصرّف المشروع نيابةً عنك.

نفّذ cargo new rust-scraper لإنشاء هيكل المشروع، ثم عدّل ملف Cargo.toml الذي تم إنشاؤه. تغطي مجموعة التبعيات أدناه كل ما في هذا الدليل: HTTP والتحليل والمعالجة غير المتزامنة والتسلسل ومخرجات CSV والتدفقات ومعالجة الأخطاء الميسّرة.

[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"

هنا يتولى reqwest معالجة الطلبات، إذ إن الميزة socks تفعّل بروكسيات SOCKS5، بينما الميزة json تضيف مساعدات JSON. تحلل scraper محتوى HTML باستخدام محددات CSS، وتوفر tokio بيئة التشغيل غير المتزامنة، وتُسلسل serde وserde_json بياناتك، وتكتب csv جداول البيانات، وتوفر futures أدوات دمج التدفقات للتزامن، كما يبسّط anyhow مع thiserror معالجة الأخطاء. نفّذ cargo build مرة واحدة لتنزيل كل شيء وتصريفه قبل كتابة أول طلب.

كيف تجلب صفحة وتحللها باستخدام reqwest وscraper؟

اجلب صفحة بإرسال طلب GET باستخدام reqwest، ثم حمّل نص الاستجابة في scraper للاستعلام عنه بمحددات CSS. يعمل المثال أدناه بصورة غير متزامنة على tokio، ويسترجع صفحة ويطبع نص كل عنصر H1.

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(())
}

يبقى التسلسل نفسه دائماً: reqwest::get يعيد استجابة، .text() يقرأ نصها كسلسلة، و Html::parse_document يحوّل تلك السلسلة إلى شجرة قابلة للاستعلام. عامل ? يمرر أي خطأ في الشبكة أو فك الترميز إلى main. يؤدي استدعاء .text() على عنصر مطابق إلى جمع عقده النصية، ثم تقليمها واستخدامها. هذا الأسلوب المعتمد على HTML الخام سريع، لكن تذكر أنه لا يرى إلا الترميز الذي يعيده الخادم، وليس المحتوى الذي قد يعرضه المتصفح لاحقاً عبر JavaScript.

كيف تستهدف العناصر بمحددات CSS؟

استهدف العناصر بتمرير سلسلة محدد CSS قياسية إلى Selector::parse، تماماً كما تفعل في وحدة تحكم المتصفح. تدعم حزمة scraper الوسوم والفئات والمعرفات ومطابقات السمات ومسارات العناصر التابعة والفئات الزائفة البنيوية.

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();

صرّف كل محدد مرة واحدة وأعد استخدامه بدلاً من تحليله داخل حلقة، لأن للتحليل كلفة بسيطة. عندما قد لا يطابق المحدد أي عنصر، فالأفضل استخدام .next() مع قيمة احتياطية بدلاً من .unwrap() على العنصر كي لا يتسبب حقل مفقود في إيقاف التنفيذ كله. إن فحص الصفحة المستهدفة عبر أداة اختيار العناصر في متصفحك أسرع طريقة للعثور على أسماء الفئات والسمات الثابتة التي يمكن التحديد بها.

كيف تصدّر البيانات المجمعة إلى JSON وCSV؟

صدّر البيانات المجمعة عبر نمذجة كل سجل باعتباره struct يشتق من serde السمة Serialize، ثم اكتب شريحة من تلك البنى إلى JSON باستخدام serde_json أو إلى CSV باستخدام حزمة csv. يحافظ تعريف نموذج مضبوط الأنواع على اتساق الاستخراج والمخرجات ويجعل الشيفرة موثقة بذاتها.

ابدأ بنمذجة السجل واستخراج الحقول من كل عنصر حاوية:

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، فإن struct نفسه يغذي كلا المصدّرين من دون عمل إضافي:

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 المسماة to_string_pretty تنتج JSON مقروءاً للبشر، ودالة حزمة csv المسماة serialize تحوّل كل struct إلى صف يحمل رأساً مشتقاً من أسماء الحقول. إن إعادة استخدام نموذج واحد مضبوط الأنواع للتجريف وJSON وCSV هي ما يجعل مسار Rust سهل الصيانة مع تغير الموقع المستهدف.

كيف تجرّف صفحات متعددة بحلقة ترقيم الصفحات؟

اجرِ تجريفاً لصفحات متعددة بالتكرار على أرقام الصفحات أو URL للصفحة التالية، مع إعادة استخدام عميل reqwest واحد لتجميع الاتصالات بين الطلبات. أنشئ كل URL واجلبه وحلله بالدالة الواردة في القسم السابق، وتوقف عندما لا تعيد صفحة أي نتائج.

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(())
}

إنشاء العميل مرة واحدة باستخدام reqwest::Client::new() خارج الحلقة يتيح له إعادة استخدام اتصالات TCP، وهو أسرع بوضوح من إنشاء عميل جديد لكل طلب. ينهي فحص النتائج الفارغة الحلقة تلقائياً عند بلوغ الصفحة الأخيرة، وتفصل المهلة القصيرة بين الطلبات كي لا ترهق الخادم. بالنسبة إلى المواقع التي تستخدم رابطاً تالياً بدلاً من الصفحات المرقمة، استخرج href لمرساة الصفحة التالية في كل تكرار واتبعها حتى يختفي الرابط.

كيف تعالج الأخطاء وإعادات المحاولة مع التأخير التصاعدي؟

عالج الأخطاء بإرجاع خطأ مضبوط الأنواع من دوال الجلب، ثم أعد محاولة الإخفاقات العابرة بتأخير تصاعدي أسي. تنتهي مهلة الشبكات وتعيد الخوادم رموز حالة مؤقتة، لذلك يتعامل الزاحف المتين مع الإخفاق الواحد باعتباره متوقعاً لا قاتلاً.

تتيح لك حزمة thiserror تعريف تعداد أخطاء موجز يتحول تلقائياً من خطأ reqwest:

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] تعني أن إخفاق reqwest يتحول إلى ScrapeError::Request تلقائياً عبر العامل ? . وإضافة إلى الأخطاء المضبوطة الأنواع، لف الطلب في حلقة إعادة محاولة تزداد مهلة انتظارها بعد كل محاولة:

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")
}

يمنح التأخير التصاعدي الأسي، هنا 0.5s و1s و2s و4s و8s، الخادم المقيّد المعدل أو المثقل مؤقتاً فرصة للتعافي بدلاً من إرهاقه بالطلبات. والجمع بين إعادة المحاولة والبروكسيات المتناوبة أقوى: فقد ينجح طلب حُظر أو قُيّد على عنوان IP في المحاولة التالية من عنوان IP خروج مختلف.

كيف تنفذ طلبات متزامنة باستخدام tokio؟

نفّذ طلبات متزامنة بتحويل قائمة URL إلى تدفق غير متزامن وتطبيق buffer_unordered، الذي يحد عدد الطلبات قيد التنفيذ في الوقت نفسه. هذا أكبر عامل منفرد لتحسين الأداء في زاحف Rust، وتجعل tokio مع حزمة futures استخدامه آمناً.

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(())
}

هنا stream::iter تحول قائمة URL إلى تدفق، .map تبدأ طلباً غير متزامن واحداً لكل URL، و buffer_unordered(10) تُبقي عشرة طلبات كحد أقصى تعمل بالتزامن، وتنتج النتائج عند اكتمالها. استنساخ العميل لكل مهمة قليل الكلفة لأن reqwest Client هو Arc حول تجميعة اتصالات مشتركة. اضبط حد التزامن لتحقيق توازن بين السرعة والحمل الذي تضعه على الهدف: من عشرة إلى عشرين نقطة بداية معقولة، كما أن إقران التزامن الأعلى بتجميعة بروكسيات يوزع تلك الطلبات على عناوين IP كثيرة.

كيف تمرر حركة تجريف Rust عبر بروكسي؟

مرر حركة المرور عبر بروكسي ببناء عميل reqwest باستخدام reqwest::Proxy وإرفاق بوابتك وبيانات اعتمادك باستخدام .basic_auth. يؤدي إرسال الطلبات عبر عناوين IP متناوبة إلى توزيع الحمل والوصول إلى محتوى مخصص جغرافياً وخفض احتمال تقييد المعدل. تدوير عناوين IP من أكثر الأساليب فعالية في التجريف من دون التعرض للحظر.

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 و password ببيانات اعتمادك واضبط المنفذ بحسب الشبكة التي تحتاجها. إذا رفض البروكسي طلبك بحالة 407، فالسبب في الغالب هو بيانات اعتماد مفقودة أو غير صحيحة؛ يشرح الدليل الخاص بـ خطأ HTTP 407 والشرح العملي عن مصادقة البروكسي كيفية إصلاح ذلك. تقدم DataImpulse بروكسيات سكنية, بروكسيات مراكز البيانات، و بروكسيات محمولة عبر HTTP وHTTPS وSOCKS5، مع جلسات متناوبة وثابتة. يتضمن العرض الاستهداف حسب الدولة، بينما الاستهداف حسب الولاية والمدينة والرمز البريدي وASN إضافات مدفوعة.

كيف تجرّف الصفحات المكثفة بـ JavaScript، ومتى تكون Rust الخيار المناسب؟

اجرِ تجريفاً للصفحات المكثفة بـ JavaScript عبر تشغيل متصفح حقيقي عديم الواجهة، لأن reqwest وscraper لا يريان إلا HTML الخام من الخادم ولا ينفذان البرامج النصية مطلقاً. عندما لا يظهر المحتوى إلا بعد العرض من جهة العميل، استخدم حزمة لأتمتة المتصفح مثل thirtyfour، التي تتحدث بروتوكول WebDriver، أو chromiumoxide، التي تتحكم في Chrome عبر DevTools Protocol.

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 بـ chromedriver يعمل بالفعل، ويحمّل صفحة وينتظر عنصراً معروضاً ويقرأ نصه. هذا النهج أثقل بكثير من جلب HTTP عادي، لذا استخدمه فقط للصفحات التي تحتاجه فعلاً واحتفظ بمسار reqwest السريع لكل ما عداه. للاطلاع بعمق أكبر على هذه المقايضة، راجع الأدلة حول تجريف صفحات الويب الديناميكية و تجريف الويب باستخدام JavaScript. يلخص الجدول أدناه كيفية تكامل الحزم الرئيسية:

في اختيار اللغة، اختر Rust عندما تحتاج إلى أداء مستدام واستهلاك منخفض للموارد على نطاق واسع، واختر Python عندما تقدر التطوير السريع ومنظومة أوسع للتجريف مثل Scrapy وPlaywright. من الأنماط الشائعة وضع نموذج أولي لقواعد الاستخراج في Python، ثم نقل المسار الأكثر كثافة إلى Rust حالما يستقر المنطق ويزداد الحجم. ومهما كان اختيارك، فإن طبقة الشبكة لا تقل أهمية عن المحلل، وتحافظ البروكسيات ذات المصادر الأخلاقية على موثوقية المهام الكبيرة.

الأسئلة الشائعة

أدلة ذات صلة

• تجريف الويب باستخدام JavaScript
• تجريف صفحات الويب الديناميكية
• أفضل ممارسات تجريف الويب

أجرِ التجريف بموثوقية عبر بروكسيات أخلاقية

بعد أن يجلب زاحف Rust الخاص بك البيانات ويحللها ويصدرها بكفاءة، فإن شبكة بروكسي موثوقة هي ما يبقيه عاملاً على نطاق واسع. تقدم DataImpulse عناوين IP من مصادر أخلاقية بنظام الدفع حسب الاستخدام ابتداءً من 1 دولار لكل GB، مع حركة مرور لا تنتهي صلاحيتها، لذا يمكنك إنشاء حساب وتمرير طلباتك الأولى خلال دقائق.