Obscura: Trình duyệt headless Rust cho AI Agent — 14.000 sao — RAM 30MB, tải 85ms — Hướng dẫn cài đặt 2026 #

┌───────────────────────────────────────────────────┐
│             Obscura Architecture                    │
│                                                     │
│  ┌─────────────────────────────────────────────┐   │
│  │           CLI / Server Interface              │   │
│  │  fetch │ serve │ scrape │ eval │ dump        │   │
│  └──────────────────────┬──────────────────────┘   │
│                         │                           │
│          ┌──────────────┼──────────────┐           │
│          ▼              ▼              ▼           │
│  ┌────────────┐  ┌────────────┐  ┌──────────┐    │
│  │  fetch()   │  │  serve()   │  │ scrape() │    │
│  │ Single page │  │ CDP server │  │ Parallel │    │
│  └─────┬──────┘  └─────┬──────┘  └────┬─────┘    │
│        │               │               │           │
│        ▼               ▼               ▼           │
│  ┌─────────────────────────────────────────────┐   │
│  │           Rust Core Engine                   │   │
│  │  • V8 JavaScript engine                      │   │
│  │  • Chrome DevTools Protocol (CDP)            │   │
│  │  • Stealth mode (anti-detection)             │   │
│  │  • Tracker blocking                          │   │
│  └─────────────────────────────────────────────┘   │
│                                                     │
│  ┌─────────────────────────────────────────────┐   │
│  │     Drop-in replacement for Chrome           │   │
│  │     ✅ Puppeteer      ✅ Playwright          │   │
│  └─────────────────────────────────────────────┘   │
└───────────────────────────────────────────────────┘

Obscura là một engine trình duyệt headless viết bằng Rust, được thiết kế đặc biệt cho web scraping và tự động hóa AI agent. Chỉ với 30MB RAM và thời gian tải trang 85ms, nó vượt xa headless Chrome về hiệu năng đồng thời cung cấp tính năng chống phát hiện tích hợp sẵn.

Do h4ckf0r0day tạo ra, Obscura đã đạt 14.788 sao GitHub, được thiết kế làm giải pháp thay thế cắm-là-chạy cho headless Chrome khi dùng Puppeteer và Playwright. Điểm khác biệt chính: nó chạy JavaScript thật thông qua V8, nhưng chi phí tài nguyên chỉ bằng một phần nhỏ của Chrome.

Hướng dẫn này bao gồm cài đặt, cách dùng CLI, thiết lập máy chủ CDP, tích hợp Puppeteer/Playwright và triển khai môi trường sản xuất.

Obscura là gì? #

Obscura là một engine trình duyệt headless triển khai Chrome DevTools Protocol (CDP) bằng Rust. Khác với headless Chrome — về bản chất là trình duyệt Chrome được tinh giản — Obscura được xây dựng lại từ đầu cho tự động hóa, chứ không phải để duyệt web trên desktop.

Các chỉ số hiệu năng chính khiến Obscura nổi bật:

Metric	Obscura	Headless Chrome
Bộ nhớ	30 MB	200+ MB
Kích thước binary	70 MB	300+ MB
Chống phát hiện	Tích hợp	Không có
Tải trang	85 ms	~500 ms
Khởi động	Tức thì	~2 giây
Puppeteer	Hỗ trợ	Hỗ trợ
Playwright	Hỗ trợ	Hỗ trợ

Đây không phải đồ chơi — nó là một engine trình duyệt cấp sản xuất, hiệu quả bộ nhớ cao gấp 7 lần Chrome.

Tại sao gọi là “Obscura”? #

Cái tên lấy từ tiếng Latin nghĩa là “bóng tối” hoặc “ẩn giấu” — quá phù hợp với một trình duyệt được thiết kế để ẩn danh. Trong thời đại mà phát hiện bot, lấy dấu vân tay AI agent và các biện pháp chống scraping tràn lan, Obscura cung cấp tính năng chống phát hiện tích hợp sẵn, thứ mà headless Chrome hoàn toàn không có.

Obscura hoạt động như thế nào #

Obscura dùng engine JavaScript V8 (chính engine vận hành Chrome và Node.js) để chạy JavaScript, nhưng pipeline render trình duyệt của nó được xây dựng hoàn toàn bằng Rust. Điều này có nghĩa là nó đạt được mức tương thích JavaScript ngang Chrome đồng thời có hiệu năng ngang Rust.

Request (fetch / scrape / serve)
    │
    ▼
┌─────────────────────────────┐
│    Command Parser            │
│  (CLI args, CDP commands)    │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│    Navigation Manager        │
│  (URL resolution, redirects, │
│   proxy handling)            │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│    V8 JavaScript Engine      │
│  (JS execution, DOM building, │
│   CSS rendering, APIs)       │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│    Output Processor          │
│  (HTML dump, JSON, text,     │
│   eval result, assets)       │
└─────────────────────────────┘

Lệnh serve khởi động một máy chủ tương thích CDP, nhận kết nối từ Puppeteer và Playwright. Lệnh fetch thực hiện thao tác trang một lần. Lệnh scrape chạy các thao tác trang song song với mức đồng thời có thể cấu hình.

Cài đặt và thiết lập #

Cài đặt bằng binary (khuyến nghị) #

Tải binary mới nhất từ trang releases:

# Linux x86_64
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-linux.tar.gz
tar xzf obscura-x86_64-linux.tar.gz
./obscura fetch https://example.com --eval "document.title"

# Linux ARM64 (aarch64)
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-aarch64-linux.tar.gz
tar xzf obscura-aarch64-linux.tar.gz

# macOS Apple Silicon
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-aarch64-macos.tar.gz
tar xzf obscura-aarch64-macos.tar.gz

# macOS Intel
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-macos.tar.gz
tar xzf obscura-x86_64-macos.tar.gz

# Windows
# Tải .zip từ trang releases và giải nén thủ công

Không cần Chrome, Node.js hay bất kỳ phụ thuộc nào. Gói release chứa hai binary obscura và obscura-worker — hãy đặt chúng trong cùng một thư mục để hỗ trợ lệnh scrape song song.

Bản phân phối Linux nhắm tới Ubuntu 22.04 (glibc 2.35+) để tương thích với các máy chủ LTS phổ biến.

Arch Linux (AUR) #

yay -S obscura-browser

Docker #

docker run -d --name obscura -p 127.0.0.1:9222:9222 h4ckf0r0day/obscura

Image Docker được build nhiều giai đoạn với distroless/cc — không có shell, không có trình quản lý gói, khoảng 57 MB sau khi nén.

Build từ mã nguồn #

git clone https://github.com/h4ckf0r0day/obscura.git
cd obscura

# Build chuẩn (lần đầu mất khoảng 5 phút vì cần biên dịch V8)
cargo build --release

# Bật chế độ stealth (chống phát hiện + chặn tracker)
cargo build --release --features stealth

Cần Rust 1.75+ (rustup.rs). Nhờ cơ chế cache của Cargo, các lần build sau rất nhanh.

Bắt đầu nhanh #

Lấy trang #

# Lấy tiêu đề trang
obscura fetch https://example.com --eval "document.title"

# Trích xuất tất cả liên kết
obscura fetch https://example.com --dump links

# Render JavaScript rồi xuất HTML
obscura fetch https://news.ycombinator.com --dump html

# Ghi đầu ra ra tệp
obscura fetch https://example.com --dump text --output page.txt

# Stream phần thân phản hồi thô (an toàn nhị phân; phù hợp với ảnh, JSON, CSS)
obscura fetch https://picsum.photos/200/300 --dump original > photo.jpg

# Liệt kê tất cả URL tài nguyên con (định dạng NDJSON)
obscura fetch https://example.com --dump assets

# Lấy trang qua máy chủ proxy
obscura --proxy socks5://127.0.0.1:1080 fetch https://example.com --dump text

# Chờ nội dung động tải xong
obscura fetch https://example.com --wait-until networkidle0

# Đặt timeout điều hướng cho trang chậm
obscura fetch https://example.com --timeout 10

Khởi động máy chủ CDP #

Để tương thích Puppeteer/Playwright:

# Máy chủ CDP chuẩn
obscura serve --port 9222

# Bật chế độ stealth (chống phát hiện + chặn tracker)
obscura serve --port 9222 --stealth

Sau khi khởi động, bạn có thể kết nối bằng Puppeteer hoặc Playwright:

// Kết nối Puppeteer
const puppeteer = require('puppeteer-core');

const browser = await puppeteer.connect({
  browserURL: 'http://127.0.0.1:9222',
});

const page = await browser.newPage();
await page.goto('https://example.com');
console.log(await page.title());

// Kết nối Playwright
const { chromium } = require('@playwright/test');

const browser = await chromium.connectOverCDP('http://127.0.0.1:9222');
const context = await browser.newContext();
const page = await context.newPage();
await page.goto('https://example.com');
console.log(await page.title());

Scraping song song #

# Scrape nhiều trang song song
obscura scrape url1 url2 url3 ... \
  --concurrency 25 \
  --eval "document.querySelector('h1').textContent"

# Scrape và lưu kết quả
obscura scrape site.com/page1 site.com/page2 \
  --concurrency 50 \
  --dump html \
  --output-dir ./scraped/

Lệnh scrape cần hai binary obscura và obscura-worker ở cùng một thư mục.

Tích hợp với các framework phổ biến #

Tích hợp Puppeteer #

// Dùng Obscura làm trình duyệt Puppeteer
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
puppeteer.use(StealthPlugin());

// Kết nối tới máy chủ CDP Obscura
const browser = await puppeteer.connect({
  browserURL: 'http://localhost:9222',
  defaultViewport: null,
});

// Code Puppeteer hiện có của bạn chạy được mà không cần sửa đổi
const page = await browser.newPage();
await page.goto('https://target-site.com');
const data = await page.$$eval('.item', items =>
  items.map(i => i.textContent)
);

Tích hợp Playwright #

# Kết nối Python Playwright
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(
        "http://localhost:9222"
    )
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()

Tích hợp AI agent #

# Dùng Obscura trong quy trình AI agent
import subprocess

def fetch_page_text(url):
    """Dùng Obscura lấy trang và trích xuất văn bản"""
    result = subprocess.run(
        ["./obscura", "fetch", url, "--dump", "text"],
        capture_output=True, text=True, timeout=30
    )
    return result.stdout

# AI agent có thể dùng hàm này để lấy và phân tích nội dung web
def analyze_page(agent, url):
    content = fetch_page_text(url)
    agent.prompt(f"Analyze this page content:\n{content}")

Pipeline web scraping #

#!/bin/bash
# Pipeline scraping tự động dùng Obscura

# Định nghĩa URL mục tiêu
urls=(
  "https://example.com/page1"
  "https://example.com/page2"
  "https://example.com/page3"
)

# Scrape tất cả trang song song
obscura scrape "${urls[@]}" \
  --concurrency 20 \
  --dump html \
  --output-dir ./output/ \
  --timeout 15

# Hậu xử lý kết quả
for f in ./output/*.html; do
  echo "Processing: $(basename $f)"
  ./obscura fetch "$f" --dump text --output "${f%.html}.txt"
done

Benchmark hiệu năng #

Mức dùng tài nguyên #

Scenario	Obscura	Headless Chrome
Trình duyệt nhàn rỗi	30 MB RAM	200+ MB RAM
Tải một trang	thêm ~5 MB	thêm ~50 MB
100 trang song song	tổng ~300 MB	tổng ~20+ GB
Kích thước binary	70 MB	300+ MB
Image Docker	57 MB (distroless)	500+ MB

Hiệu năng tải trang #

Page Type	Obscura	Headless Chrome
HTML tĩnh	~15 ms	~80 ms
SPA render JavaScript	~85 ms	~500 ms
Dashboard nặng	~200 ms	~1500 ms
Khởi động trang	Tức thì	~2 giây

Kiểm tra mở rộng bộ nhớ (100 trang song song) #

# Kiểm tra với Obscura
obscura scrape $(seq -w 1 100 | sed 's/^/https://example.com\/page_/') \
  --concurrency 100 \
  --dump text \
  --output /dev/null
# Tổng RAM: ~280-320 MB

# Kiểm tra tương đương với headless Chrome (Puppeteer)
# Tổng RAM: ~15-25 GB

Cách dùng nâng cao #

Chế độ stealth #

Tính năng stealth cung cấp khả năng chống phát hiện tích hợp sẵn:

# Build với hỗ trợ stealth
cargo build --release --features stealth

# Hoặc dùng binary với cờ stealth
./obscura serve --port 9222 --stealth

# Chế độ stealth bao gồm:
# - Ngụy trang plugin Navigator
# - Làm rối renderer WebGL
# - Xử lý Permissions API
# - Che thuộc tính runtime Chrome
# - Chặn script tracker

Hỗ trợ máy chủ proxy #

# Proxy HTTP
obscura --proxy http://user:pass@proxy.example.com:8080 \
  fetch https://example.com

# Proxy SOCKS5
obscura --proxy socks5://127.0.0.1:1080 \
  fetch https://example.com

# Dùng proxy cùng Puppeteer
const browser = await puppeteer.connect({
  browserURL: 'http://localhost:9222',
  defaultBrowserOptions: {
    args: ['--proxy-server=http://proxy:8080']
  }
});

Tùy chọn điều hướng tùy chỉnh #

# Chờ đến khi một phần tử cụ thể xuất hiện
obscura fetch https://example.com \
  --wait-selector ".content-loaded"

# Chờ đến trạng thái mạng cụ thể
obscura fetch https://example.com \
  --wait-until networkidle0

# Kích thước viewport tùy chỉnh
obscura fetch https://example.com \
  --viewport 1920x1080

# Ghi đè User-Agent
obscura fetch https://example.com \
  --user-agent "Mozilla/5.0 (compatible; MyBot/1.0)"

# Đặt cookie trước khi tải trang
obscura --cookie "session=abc123; token=xyz789" \
  fetch https://private.example.com

# Trích xuất cookie từ phiên
obscura fetch https://example.com \
  --dump cookies --output cookies.json

So sánh với các giải pháp thay thế #

Feature	Obscura	Headless Chrome	Playwright Browser	Selenium
Mức dùng bộ nhớ	30 MB	200+ MB	150+ MB	300+ MB
Ngôn ngữ lập trình	Rust	C++	TypeScript/JS	Đa ngôn ngữ
Hỗ trợ CDP	Nguyên bản	Nguyên bản	Qua Chrome	Qua Chrome
Puppeteer	✅ Hỗ trợ	✅ Hỗ trợ	✅ Hỗ trợ	❌ Không
Playwright	✅ Hỗ trợ	✅ Hỗ trợ	✅ Hỗ trợ	❌ Không
Chống phát hiện	✅ Tích hợp	❌ Cần plugin	Cần plugin	❌ Không
Scraping song song	✅ Nguyên bản	❌ Chi phí lớn	❌ Chi phí lớn	❌ Không
Độ phức tạp cài đặt	Binary/Docker	Binary lớn	Node.js + Chrome	WebDriver
Thời gian khởi động	Tức thì	~2 giây	~3 giây	~5 giây
Giấy phép	Apache-2.0	BSD	Apache-2.0	Apache-2.0

Giới hạn / Đánh giá thành thật #

Obscura mạnh mẽ nhưng không phải giải pháp thay thế hoàn hảo cho mọi tình huống:

Dự án còn non trẻ — dù có 14.788 sao, Obscura vẫn đang được phát triển tích cực. Các trường hợp biên của framework JavaScript phức tạp có thể chưa được bao phủ đầy đủ.
Chưa tối ưu cho duyệt web desktop — nó được xây dựng cho tự động hóa, không phù hợp dùng trên desktop. Render UI, tính năng trợ năng và đầu ra in có thể khác Chrome.
Không có xoay vòng proxy tích hợp — tuy hỗ trợ kết nối máy chủ proxy nhưng không có pool proxy hay tính năng xoay vòng tích hợp. Scraping quy mô lớn cần dịch vụ proxy bên ngoài.
Giới hạn tiện ích mở rộng trình duyệt — khác Chrome, Obscura không hỗ trợ tiện ích mở rộng trình duyệt (AdBlock, uBlock, v.v.). Bạn cần tự triển khai logic chặn quảng cáo trong script.
Image Docker cực kỳ tinh giản — image Docker 57 MB không có shell hay trình quản lý gói. Việc debug bên trong container phải dựa vào cờ log tích hợp của binary obscura.
Obscura Cloud đang ở giai đoạn beta — phiên bản được lưu trữ (hạ tầng quản lý + proxy dân cư) hiện ở giai đoạn danh sách chờ/beta. Engine mã nguồn mở vẫn hoạt động đầy đủ, không bị giới hạn tính năng.

Câu hỏi thường gặp #

H: Obscura có thể thay thế headless Chrome trong script Puppeteer hiện có của tôi không?

Đ: Có, miễn là bạn kết nối qua CDP (browserURL hoặc connectOverCDP). Vì dùng cùng engine V8 và triển khai giao thức CDP, hành vi ở cấp trình duyệt rất giống Chrome.

H: Chế độ stealth so với puppeteer-extra-stealth thì sao?

Đ: Chế độ stealth của Obscura được tích hợp ngay trong engine, chứ không phải thêm vào như một lớp hậu xử lý. Nghĩa là nó xử lý vấn đề lấy dấu vân tay (thuộc tính navigator, WebGL, nội dung giọng nói) ở cấp trình duyệt thay vì vá lỗi về sau — nên kết quả nhất quán hơn.

H: Tôi có thể dùng Obscura cho kiểm thử trình duyệt không?

Đ: Có, phù hợp với hầu hết tình huống. Tính tương thích CDP của nó cho phép bạn chạy bộ kiểm thử Playwright/Puppeteer hiện có trên Obscura. Tuy nhiên, một số bài kiểm thử phụ thuộc vào render đặc thù của Chrome hoặc hành vi tiện ích mở rộng có thể cần điều chỉnh.

H: Có image Docker chính thức không?

Đ: Có, h4ckf0r0day/obscura có sẵn trên Docker Hub. Nó được build nhiều giai đoạn với distroless/cc, kích thước cực nhỏ (57 MB sau khi nén).

H: Tính tương thích JavaScript thế nào?

Đ: Obscura dùng engine V8, giống Chrome. Tính tương thích JavaScript gần như hoàn toàn giống Chrome — không thiếu API, không cần polyfill.

H: Tôi có thể chạy Obscura trên nền tảng serverless không?

Đ: Vì là binary đơn lẻ không phụ thuộc, bạn có thể chạy nó trên bất kỳ nền tảng nào hỗ trợ binary Rust biên dịch tĩnh — Lambda, Cloud Functions, Fly.io, v.v.

Kết luận #

Obscura đại diện cho một bước tiến quan trọng trong công nghệ trình duyệt headless. Với 30MB RAM, tải trang 85ms và chống phát hiện tích hợp, nó giải quyết một vấn đề căn bản đã làm khổ web scraping và tự động hóa AI agent nhiều năm: Chrome quá nặng cho các thao tác trình duyệt đồng thời ở quy mô lớn.

Với các AI agent cần duyệt web, scrape nội dung hoặc tương tác với các trang nặng JavaScript — Obscura mang lại khoảng dư hiệu năng mà headless Chrome hoàn toàn không thể sánh được. Tính tương thích Puppeteer và Playwright nghĩa là script hiện có của bạn chạy được mà không cần sửa đổi.

Dịch vụ lưu trữ Obscura Cloud sắp ra mắt (hạ tầng quản lý + proxy dân cư) sẽ giúp việc triển khai quy mô lớn dễ dàng hơn, còn engine mã nguồn mở vẫn giữ giấy phép Apache-2.0 mà không giới hạn tính năng nào.

Dùng thử Obscura: github.com/h4ckf0r0day/obscura

Bài viết liên quan:

Codegraph — Đồ thị tri thức mã nguồn được lập chỉ mục sẵn cho AI agent
MarkItDown — Chuyển đổi mọi tệp sang Markdown

Nguồn và đọc thêm:

Kho GitHub: https://github.com/h4ckf0r0day/obscura
Docker Hub: https://hub.docker.com/r/h4ckf0r0day/obscura
Trang releases: https://github.com/h4ckf0r0day/obscura/releases
Tài liệu CDP: https://chromedevtools.github.io/devtools-protocol/
Engine V8: https://v8.dev

Tham gia cộng đồng của chúng tôi để có thêm phân tích chuyên sâu về công cụ AI: t.me/DIBI8_Group

Tuyên bố miễn trừ: Bài viết này chỉ nhằm mục đích cung cấp thông tin. Hãy luôn xem xét mã nguồn trước khi chạy phần mềm bên thứ ba trong môi trường sản xuất. Tiết lộ liên kết: một số liên kết bên trên có thể chứa mã liên kết. Chúng tôi có thể nhận hoa hồng mà không phát sinh thêm chi phí cho bạn.