Rust 網路爬蟲高效能實作

– 8 分鐘閱讀

Rust 語言以其高效能、記憶體安全和非同步 I/O 等特性，成為構建網路爬蟲的理想選擇。相較於 Python 和 Go，Rust 在處理大量資料和複雜網頁結構時，展現出更高的穩定性和效能。本文將介紹如何利用 Rust 的非同步特性、相關型別、原子型別等，設計一個泛用的爬蟲框架，並針對不同型別的網頁，如靜態 HTML、JSON API 和動態 JavaScript 渲染的網頁，提供實作範例。同時，我們也會探討屏障同步機制在爬蟲框架中的應用，以及如何處理 CVE Details 和 GitHub API 等實際案例。

網路爬蟲技術與Rust語言優勢

網頁爬蟲與資料抓取

首先，我們需要釐清兩個常見術語之間的差異：爬蟲（Crawler）與抓取器（Scraper）。爬蟲是指遍歷大量相互連結的資料（如網頁）的過程，而抓取器則是將非結構化的網頁資料轉換為結構化資料的過程。實際上，這兩個過程通常是緊密結合的，因為大多數情況下，我們需要在多個頁面中爬行並抓取資料。因此，可以說每個爬蟲都是一個抓取器，反之亦然。

為何使用爬蟲技術？

爬蟲技術的核心優勢在於自動化。相較於手動瀏覽數千個網頁並複製貼上資料到試算表，使用專門的程式（爬蟲）可以大幅提升效率。

爬蟲設計架構

一個完整的爬蟲系統包含以下關鍵元件：

  1. 起始URL清單：提供初始的網址作為爬行起點。
  2. 蜘蛛程式（Spiders）：針對特定網站或任務客製化的爬蟲元件，包含：
    • 抓取器（Scraper）：負責擷取網址、解析資料、結構化資料，並提取新的網址以繼續爬行。
    • 處理器（Processor）：處理已結構化的資料，例如儲存到資料函式庫。
  3. 控制迴圈（Control Loop）：負責協調抓取器與處理器之間的資料傳遞，並管理待爬行的網址佇列。

將蜘蛛程式的功能拆分為抓取與處理兩個獨立階段有其優勢：可以根據工作負載調整不同的平行度。例如，可以設定較低平行度的抓取器以避免觸發網站的機器人偵測機制，同時使用較高平行度的處理器來提升效率。

為何選擇Rust開發爬蟲？

儘管Python的Scrapy和Go語言的Colly已具備成熟的爬蟲生態系統，Rust仍有其獨特優勢：

  1. 非同步I/O模型：Rust的非同步處理能力保證了最佳的網路請求效能。
  2. 記憶體相關效能：Rust無垃圾回收機制，使其在處理大量短生命週期的記憶體物件時表現更為穩定，記憶體使用更具確定性。
  3. 解析安全性：Rust的記憶體安全特性與嚴格的錯誤處理機制，使其在處理複雜且不受信任的資料格式時更為安全可靠。

相關型別（Associated Types）

在建構泛型蜘蛛程式時，使用相關型別（Associated Types）可以簡化特徵（trait）的使用方式。例如：

#[async_trait]
pub trait Spider {
    type Item;
    fn name(&self) -> String;
    fn start_urls(&self) -> Vec<String>;
    async fn scrape(&self, url: &str) -> Result<(Vec<Self::Item>, Vec<String>), Error>;
    async fn process(&self, item: Self::Item) -> Result<(), Error>;
}

這種實作方式不僅簡化了介面，也更清楚地表達了介面的運作方式。

內容解密：

  1. type Item; 定義了一個相關型別，用於表示蜘蛛程式處理的專案型別。
  2. scrape 方法負責從指定URL抓取資料並提取新的URL。
  3. process 方法處理已抓取的資料專案。

原子型別（Atomic Types）

原子型別是另一種用於多執行緒環境下的分享記憶體型別，主要用於取代Mutex在某些場景下的使用。常見的原子型別包括：

  • AtomicBool
  • AtomicI8
  • AtomicI16
  • AtomicI32
  • AtomicI64
  • AtomicIsize
  • AtomicPtr
  • AtomicU8

使用原子型別時需要注意操作順序（Ordering）的設定，通常使用Ordering::SeqCst以獲得最強的一致性保證。

程式碼範例

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;

fn main() {
    // 建立新的原子變數
    let my_atomic = AtomicUsize::new(42);
    
    // 增加1
    my_atomic.fetch_add(1, Ordering::SeqCst);
    
    // 取得目前值
    assert!(my_atomic.load(Ordering::SeqCst) == 43);
    
    // 跨執行緒分享原子變數
    let my_arc_atomic = Arc::new(AtomicUsize::new(4));
    let second_ref_atomic = my_arc_atomic.clone();
    
    thread::spawn(move || {
        second_ref_atomic.store(42, Ordering::SeqCst);
    });
}

內容解密：

  1. AtomicUsize::new(42) 建立了一個初始值為42的原子變數。
  2. fetch_add 方法用於原子性的增加操作。
  3. 使用Arc實作跨執行緒分享原子變數。
  4. store 方法用於設定新的值。

深入理解 Rust 中的平行程式設計：以爬蟲實作為例

在現代軟體開發中，處理平行任務已成為提升程式效能的關鍵技術之一。Rust 語言憑藉其獨特的所有權系統和強大的平行程式設計支援，為開發高效、安全的平行應用提供了堅實的基礎。本文將探討 Rust 中的平行程式設計概念，並透過實作一個泛用的爬蟲框架來展示其實際應用。

5.13 屏障（Barrier）同步機制

在平行程式設計中，Barrier 是一種重要的同步機制，它允許多個平行任務在特定點進行同步。Tokio 函式庫提供了 tokio::sync::Barrier 來實作這一功能。

use tokio::sync::Barrier;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let barrier = Arc::new(Barrier::new(3));
    let b2 = barrier.clone();
    tokio::spawn(async move {
        // 執行某些任務
        b2.wait().await;
    });

    let b3 = barrier.clone();
    tokio::spawn(async move {
        // 執行某些任務
        b3.wait().await;
    });

    barrier.wait().await;
    println!("所有三個平行任務均已完成");
}

內容解密：

  1. 我們使用 Arc 來分享 Barrier 例項，以便在多個任務之間進行同步。
  2. Barrier::new(3) 初始化一個需要等待 3 個任務到達的屏障。
  3. 每個任務在完成其工作後呼叫 wait().await，使任務在該點等待其他任務到達。
  4. 當所有任務都到達屏障時，繼續執行後續程式碼。

5.14 使用 Rust 實作爬蟲框架

本文將展示如何使用 Rust 建立一個泛用的爬蟲框架，並針對不同型別的網站（HTML、JSON API 和 JavaScript 渲染的網站）實作特定的爬蟲。

5.15 定義爬蟲特徵（Spider Trait）

定義一個通用的 Spider 特徵，以規範不同型別爬蟲的行為。

#[async_trait]
pub trait Spider: Send + Sync {
    type Item;
    fn name(&self) -> String;
    fn start_urls(&self) -> Vec<String>;
    async fn scrape(&self, url: String) -> Result<(Vec<Self::Item>, Vec<String>), Error>;
    async fn process(&self, item: Self::Item) -> Result<(), Error>;
}

內容解密：

  1. Spider 特徵定義了爬蟲的基本操作：取得名稱、起始 URL、抓取資料和處理資料。
  2. 使用 async_trait 宏允許在特徵中定義非同步方法。
  3. scrape 方法負責從給定 URL 抓取資料並提取新的 URL。
  4. process 方法處理抓取到的資料項。

5.16 實作爬蟲框架

爬蟲框架的核心是管理 URL 的抓取、資料的處理以及平行控制。

pub async fn run<T: Send + 'static>(&self, spider: Arc<dyn Spider<Item = T>>) {
    // 初始化必要的通道和同步機制
    let mut visited_urls = HashSet::<String>::new();
    let (urls_to_visit_tx, urls_to_visit_rx) = mpsc::channel(self.crawling_queue_capacity);
    // ...

    // 啟動處理器和抓取器
    self.launch_processors(processing_concurrency, spider.clone(), items_rx, barrier.clone());
    self.launch_scrapers(crawling_concurrency, spider.clone(), urls_to_visit_rx, new_urls_tx, items_tx, active_spiders, self.delay, barrier.clone());

    // 控制迴圈
    loop {
        // 處理新 URL 和檢查終止條件
        // ...
    }
}

內容解密：

  1. 使用 mpsc（多生產者，單消費者）通道來管理 URL 和資料項的傳遞。
  2. launch_processors 和 launch_scrapers 方法分別啟動資料處理和 URL 抓取的平行任務。
  3. 控制迴圈負責管理新 URL 的加入和檢查是否滿足終止條件。

5.17 爬取簡單 HTML 網站：CVE Details

本文以 CVE Details 網站為例，展示如何實作一個特定的 HTML 網站爬蟲。

5.17.1 提取結構化資料

首先定義要提取的資料結構：

#[derive(Debug, Clone)]
pub struct Cve {
    name: String,
    url: String,
    cwe_id: Option<String>,
    // 其他欄位...
}

然後，使用瀏覽器的開發者工具檢查網頁結構，以確定如何提取所需資料。

內容解密：

  1. 定義 Cve 結構體以儲存 CVE 相關資訊。

  2. 使用瀏覽器的開發者工具檢查網頁的 HTML 結構，以確定提取資料的方法。

  3. 支援更多網站型別：擴充套件框架以支援更多型別的網站，如需要登入驗證的網站等。

  4. 效能最佳化：進一步最佳化爬蟲的效能，如使用更高效的平行控制策略。

  5. 錯誤處理：增強錯誤處理機制，使爬蟲更加健壯。

透過不斷改進和擴充套件，這一爬蟲框架將能夠滿足更多實際需求，並在資料收集和分析領域發揮重要作用。

網頁爬蟲技術深度解析：從靜態到動態網頁的抓取實戰

隨著網路技術的發展，網頁爬蟲技術也在不斷進化，以應對日益複雜的網頁結構和內容載入方式。本文將探討靜態網頁、JSON API以及動態JavaScript網頁的爬取技術，並結合具體程式碼範例進行詳細解析。

靜態網頁爬取技術實戰

靜態網頁爬取是網路爬蟲最基本的功能之一，主要涉及HTML內容的解析和資料提取。以下以CVE Details網站的爬取為例，展示靜態網頁爬蟲的實作細節。

程式碼實作解析

async fn scrape(&self, url: String) -> Result<(Vec<Self::Item>, Vec<String>), Error> {
    log::info!("visiting: {}", url);
    let http_res = self.http_client.get(url).send().await?.text().await?;
    let mut items = Vec::new();
    let document = Document::from(http_res.as_str());
    let rows = document.select(Attr("id", "vulnslisttable").descendant(Class("srrowns")));
    
    for row in rows {
        let mut columns = row.select(Name("td"));
        let _ = columns.next(); // 跳過序號欄位
        let cve_link = columns.next().unwrap().select(Name("a")).next().unwrap();
        let cve_name = cve_link.text().trim().to_string();
        let cve_url = self.normalize_url(cve_link.attr("href").unwrap());
        
        // 提取其他相關資訊
        let access = columns.next().unwrap().text().trim().to_string();
        let complexity = columns.next().unwrap().text().trim().to_string();
        // ... 其他欄位提取
        
        let cve = Cve {
            name: cve_name,
            url: cve_url,
            // ... 其他欄位指定
        };
        items.push(cve);
    }
    
    // 提取下一頁連結
    let next_pages_links = document
        .select(Attr("id", "pagingb").descendant(Name("a")))
        .filter_map(|n| n.attr("href"))
        .map(|url| self.normalize_url(url))
        .collect::<Vec<String>>();
    
    Ok((items, next_pages_links))
}

內容解密：

  1. HTTP請求處理：使用reqwest函式庫傳送HTTP GET請求並取得回應內容。
  2. HTML解析：利用Document::from將HTML字串解析為可操作的DOM結構。
  3. 資料提取：透過CSS選擇器定位特定的資料行和欄位，提取所需資訊。
  4. 資料結構化：將提取的資訊封裝為Cve結構體，方便後續處理。
  5. 分頁處理：提取下一頁的連結，為爬蟲提供繼續抓取的目標URL。

JSON API爬取技術實戰

相較於靜態網頁，JSON API提供了結構化的資料，使得資料提取更加直接。以下以GitHub API為例，展示JSON API爬蟲的實作。

程式碼實作解析

async fn scrape(&self, url: String) -> Result<(Vec<GitHubItem>, Vec<String>), Error> {
    let items: Vec<GitHubItem> = self.http_client.get(&url).send().await?.json().await?;
    
    let next_pages_links = if items.len() == self.expected_number_of_results {
        let captures = self.page_regex.captures(&url).unwrap();
        let old_page_number = captures.get(1).unwrap().as_str().to_string();
        let mut new_page_number = old_page_number.parse::<usize>()?;
        new_page_number += 1;
        
        let next_url = url.replace(
            format!("&page={}", old_page_number).as_str(),
            format!("&page={}", new_page_number).as_str(),
        );
        vec![next_url]
    } else {
        Vec::new()
    };
    
    Ok((items, next_pages_links))
}

內容解密：

  1. JSON解析：直接使用reqwest的json()方法將回應內容解析為Rust結構體。
  2. 分頁邏輯：透過正規表示式捕捉當前頁碼，並建構下一頁的URL。
  3. 終止條件：根據傳回結果的數量判斷是否到達最後一頁。

動態JavaScript網頁爬取技術

對於使用JavaScript動態載入內容的網頁，需要使用無頭瀏覽器來模擬真實瀏覽器行為。

程式碼實作解析

async fn scrape(&self, url: String) -> Result<(Vec<Self::Item>, Vec<String>), Error> {
    let mut items = Vec::new();
    let html = {
        let mut webdriver = self.webdriver_client.lock().await;
        webdriver.goto(&url).await?;
        webdriver.source().await?
    };
    
    // 對取得的HTML進行解析和資料提取
    // ...
}

內容解密：

  1. 無頭瀏覽器初始化：使用chromedriver建立可程式控制的瀏覽器環境。
  2. 頁面載入：透過webdriver介面導航到目標URL並取得渲染後的頁面原始碼。
  3. 資料處理：對取得的HTML進行解析和資料提取，處理邏輯與靜態網頁類別似。
玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。